{"version":3,"sources":["../node_modules/react-transition-group/Transition.js","../node_modules/react-burger-menu/lib/menuFactory.js","../node_modules/lodash.omit/index.js","../node_modules/front-matter/index.js","../node_modules/react-burger-menu/lib/BurgerMenu.js","../node_modules/react-transition-group/utils/PropTypes.js","../node_modules/react-burger-menu/lib/snapsvgImporter.js","../node_modules/react-burger-menu/lib/menus/slide.js","../node_modules/react-burger-menu/lib/baseStyles.js","../node_modules/react-burger-menu/lib/BurgerIcon.js","../node_modules/react-burger-menu/lib/CrossIcon.js","../node_modules/react-burger-menu/lib/menus/stack.js","../node_modules/react-burger-menu/lib/menus/elastic.js","../node_modules/snapsvg-cjs/dist/snap.svg-cjs.js","../node_modules/eve/eve.js","../node_modules/react-burger-menu/lib/menus/bubble.js","../node_modules/react-burger-menu/lib/menus/push.js","../node_modules/react-burger-menu/lib/menus/pushRotate.js","../node_modules/react-burger-menu/lib/menus/scaleDown.js","../node_modules/react-burger-menu/lib/menus/scaleRotate.js","../node_modules/react-burger-menu/lib/menus/fallDown.js","../node_modules/react-burger-menu/lib/menus/reveal.js","../node_modules/office-ui-fabric-react/lib/components/Button/CompoundButton/CompoundButton.styles.js","../node_modules/office-ui-fabric-react/lib/components/Button/CompoundButton/CompoundButton.js"],"names":["exports","__esModule","default","EXITING","ENTERED","ENTERING","EXITED","UNMOUNTED","PropTypes","obj","newObj","key","Object","prototype","hasOwnProperty","call","desc","defineProperty","getOwnPropertyDescriptor","get","set","_interopRequireWildcard","__webpack_require__","_react","_interopRequireDefault","_reactDom","_reactLifecyclesCompat","Transition","_React$Component","subClass","superClass","props","context","_this","this","initialStatus","parentGroup","transitionGroup","appear","isMounting","enter","appearStatus","in","unmountOnExit","mountOnEnter","state","status","nextCallback","create","constructor","__proto__","_proto","getChildContext","getDerivedStateFromProps","_ref","prevState","componentDidMount","updateStatus","componentDidUpdate","prevProps","nextStatus","componentWillUnmount","cancelNextCallback","getTimeouts","exit","timeout","mounting","node","findDOMNode","performEnter","performExit","setState","_this2","appearing","timeouts","onEnter","safeSetState","onEntering","onTransitionEnd","onEntered","_this3","onExit","onExiting","onExited","cancel","nextState","callback","setNextCallback","_this4","active","event","handler","addEndListener","setTimeout","render","_this$props","children","childProps","source","excluded","i","target","sourceKeys","keys","length","indexOf","_objectWithoutPropertiesLoose","child","Children","only","cloneElement","Component","noop","contextTypes","object","childContextTypes","propTypes","defaultProps","_default","polyfill","value","_extends","assign","arguments","_createClass","defineProperties","descriptor","enumerable","configurable","writable","Constructor","protoProps","staticProps","_get","_x3","_x4","_x5","_again","property","receiver","Function","undefined","getter","parent","getPrototypeOf","_react2","_reactDom2","_propTypes2","_baseStyles2","_BurgerIcon2","_CrossIcon2","styles","Menu","_Component","instance","TypeError","_classCallCheck","isOpen","setPrototypeOf","_inherits","options","noStateChange","newState","applyWrapperStyles","onStateChange","firstItem","document","querySelector","focus","activeElement","blur","body","timeoutId","clearTimeout","applyClass","el","className","classList","htmlClassName","bodyClassName","pageWrap","pageWrapId","handleExternalWrapper","outerContainer","outerContainerId","id","wrapperStyles","wrapper","getElementById","builtStyles","getStyle","prop","style","applyOverflow","console","error","index","inline","propName","replace","charAt","toUpperCase","output","width","formattedWidth","right","e","window","keyCode","toggleMenu","disableOverlayClick","Error","customOnKeyDown","onkeydown","disableCloseOnEsc","listenForClose","bind","svg","morphShape","path","lib","select","animate","attr","pathInitial","nextProps","createElement","noOverlay","overlayClassName","trim","onClick","shouldDisableOverlayClick","getStyles","morphShapeClassName","height","viewBox","preserveAspectRatio","d","menuClassName","itemListClassName","map","item","extraProps","itemClassName","filter","join","tabIndex","customCrossIcon","customIcon","crossButtonClassName","crossClassName","customBurgerIcon","burgerButtonClassName","barClassName","burgerBarClassName","string","oneOfType","element","oneOf","func","bool","isRequired","number","module","global","LARGE_ARRAY_SIZE","HASH_UNDEFINED","INFINITY","MAX_SAFE_INTEGER","argsTag","funcTag","genTag","symbolTag","reIsHostCtor","reIsUint","freeGlobal","freeSelf","self","root","arrayIncludes","array","fromIndex","predicate","fromRight","baseFindIndex","baseIsNaN","baseIndexOf","arrayIncludesWith","comparator","arrayMap","iteratee","result","Array","arrayPush","values","offset","cacheHas","cache","has","overArg","transform","arg","arrayProto","funcProto","objectProto","coreJsData","maskSrcKey","uid","exec","IE_PROTO","funcToString","toString","objectToString","reIsNative","RegExp","Symbol","getPrototype","propertyIsEnumerable","splice","spreadableSymbol","isConcatSpreadable","nativeGetSymbols","getOwnPropertySymbols","nativeMax","Math","max","Map","getNative","nativeCreate","Hash","entries","clear","entry","ListCache","MapCache","SetCache","__data__","add","arrayLikeKeys","inherited","isArray","isArguments","n","baseTimes","String","skipIndexes","isIndex","push","assocIndexOf","other","baseIsNative","isObject","isFunction","isHostObject","test","toSource","baseKeysIn","nativeKeysIn","isProto","Ctor","proto","isPrototype","getAllKeysIn","keysFunc","symbolsFunc","baseGetAllKeys","keysIn","getSymbolsIn","getMapData","data","type","isKeyable","getValue","pop","hash","getSymbols","stubArray","isFlattenable","toKey","isObjectLike","isSymbol","isArrayLike","isArrayLikeObject","isLength","tag","start","omit","baseFlatten","depth","isStrict","basePickBy","basePick","includes","isCommon","valuesLength","outer","computed","valuesIndex","baseDifference","args","otherArgs","thisArg","apply","process","parser","pattern","platform","regex","lines","split","match","attributes","yaml","load","frontmatter","parse","slide","stack","elastic","bubble","pushRotate","scaleDown","scaleRotate","fallDown","reveal","classNamesShape","timeoutsShape","Snap","_menuFactory","_menuFactory2","overlay","position","zIndex","background","opacity","MozTransform","MsTransform","OTransform","WebkitTransform","transition","menuWrap","menu","boxSizing","overflow","itemList","display","_x","_x2","BurgerIcon","hover","left","top","bmBurgerBarsHover","icon","bmIcon","bar","getLineStyle","bmBurgerBars","bmBurgerButton","onMouseOver","onMouseOut","margin","padding","border","fontSize","cursor","CrossIcon","bmCross","getCrossStyle","bmCrossButton","nthChild","_snapsvgImporter2","pathOpen","mina","easeinout","whiteSpace","eve","requestID","animations","requestAnimFrame","requestAnimationFrame","webkitRequestAnimationFrame","mozRequestAnimationFrame","oRequestAnimationFrame","msRequestAnimationFrame","Date","getTime","a","idgen","idprefix","timer","now","sta","val","s","ds","b","dur","B","speed","spd","duration","stopit","update","pause","pdif","resume","frame","res","j","jj","end","easing","timeStamp","len","A","anim","linear","stop","time","getById","easeout","pow","easein","q","Q","sqrt","x","y","t","abs","backin","backout","sin","PI","bounce","p","w","h","nodeType","wrap","is","Element","glob","doc","Paper","version","_","win","Str","toFloat","parseFloat","toInt","parseInt","math","mmax","mmin","min","E","round","colourRegExp","commaSpaces","separator","hsrg","hs","rg","pathCommand","tCommand","pathValues","ID","xlink","xmlns","hub","url","$","createTextNode","text","createComment","substring","getAttributeNS","getAttribute","nodeValue","setAttributeNS","setAttribute","removeAttribute","createElementNS","o","toLowerCase","isFinite","slice","cacher","f","scope","postprocessor","newf","count","ii","repush","shift","rad","deg","format","tokenRegex","objNotationRegex","str","all","name","quote","quotedName","isFunc","replacer","clone","angle","tan","cos","asin","num","acos","atan","atan2","x1","y1","x2","y2","x3","y3","len2","closestPoint","distance2","dx","dy","best","bestLength","scan","scanDistance","pathNode","pathLength","getTotalLength","precision","pathSegList","numberOfItems","bestDistance","Infinity","scanLength","getPointAtLength","before","after","beforeLength","afterLength","beforeDistance","afterDistance","distance","snapTo","tolerance","rem","getRGB","colour","r","g","hex","rgbtoString","_toHex","red","green","blue","rgb","hsb2rgb","hsl2rgb","hsb","hsl","l","toFixed","color","getElementsByTagName","out","defaultView","getComputedStyle","getPropertyValue","hsbtoString","hsltoString","prepareRGB","clr","packageRGB","rgb2hsl","rgb2hsb","v","R","G","X","C","V","L","M","m","parsePathString","pathString","pth","arr","paramCounts","c","u","z","params","concat","parseTransformString","TString","svgTransform2string","tstr","rgTransform","transform2matrix","bbox","tdata","Matrix","bb","tlen","command","absolute","inver","invert","translate","rotate","scale","_unit2px","getSomeSVG","mgr","class","fill","appendChild","getW","getBBox","getH","nam","removeChild","contains","compareDocumentPosition","ownerSVGElement","add2group","list","forEach","childNodes","snap","paper","tagName","nodeName","anims","mask","symbol","method","Fragment","frag","make","defs","ownerDocument","dom","contentDocument","getSomeDefs","parentNode","pdefs","query","selectAll","nodelist","querySelectorAll","setInterval","firstDefined","json","att","createDocumentFragment","full","div","innerHTML","firstChild","fragment","ch","toJSON","jsonFiller","on","nt","css","lastIndexOf","letter","cssAttr","alignment-baseline","baseline-shift","clip","clip-path","clip-rule","color-interpolation","color-interpolation-filters","color-profile","color-rendering","direction","dominant-baseline","enable-background","fill-opacity","fill-rule","flood-color","flood-opacity","font","font-family","font-size","font-size-adjust","font-stretch","font-style","font-variant","font-weight","glyph-orientation-horizontal","glyph-orientation-vertical","image-rendering","kerning","letter-spacing","lighting-color","marker","marker-end","marker-mid","marker-start","pointer-events","shape-rendering","stop-color","stop-opacity","stroke","stroke-dasharray","stroke-dashoffset","stroke-linecap","stroke-linejoin","stroke-miterlimit","stroke-opacity","stroke-width","text-anchor","text-decoration","text-rendering","unicode-bidi","visibility","word-spacing","writing-mode","ajax","postData","req","XMLHttpRequest","pd","encodeURIComponent","open","setRequestHeader","once","onreadystatechange","readyState","send","responseText","getElementByPoint","canvas","elementFromPoint","opera","so","elem","box","getBoundingClientRect","docElem","documentElement","clientTop","clientLeft","pageYOffset","scrollTop","pageXOffset","scrollLeft","getOffset","sr","createSVGRect","hits","getIntersectionList","plugin","elproto","unit2px","isWithoutTransform","getClientRects","removed","localMatrix","original","href","pathfinder","deflt","bboxwt","realPath","matrix","propString","extractTransform","doReturn","papa","getCTM","local","ms","localString","toTransformString","globalMatrix","totalMatrix","diffMatrix","total","gradientTransform","patternTransform","append","it","appendTo","prepend","first","insertBefore","prependTo","nextSibling","insertAfter","remove","asPX","use","xlink:href","cloneNode","els","ids","uses","urltest","linktest","oldid","old","fs","fixids","toDefs","toPattern","patternUnits","refX","refY","cx","cy","markerWidth","markerHeight","orient","eldata","chld","removeData","outerSVG","innerSVG","toDataURL","btoa","contents","unescape","matrixproto","norm","normalize","mag","aNew","bNew","multLeft","cNew","eNew","me","skewX","skew","skewY","fromCharCode","determinant","row","scalex","shear","scaley","isSimple","isSuperSimple","noRotation","shorter","clipIt","reURLValue","URL","fillStroke","grad","gradient","attrs","deurl","gradrg","setFontSize","getFontSize","tokens","stops","seed","step","k","toAbsolute","txt","baseVal","vb","rx","ry","tp","textPath","tuned","tuner","chunk","setter","textExtract","chi","textContent","internal","rgNotSpace","addClass","clazz","finalValue","classes","curClasses","removeClass","pos","hasClass","toggleClass","flag","operators","+","-","/","*","reUnit","reAddon","getNumber","getUnit","unit","plus","evnt","atr","aUnit","op","isNaN","bplus","from","to","rect","circle","preload","onerror","src","img","cssText","onload","image","offsetWidth","offsetHeight","ellipse","group","vbx","vby","vbw","vbh","ptrn","vx","vy","vw","vh","line","polyline","points","polygon","Gstops","GaddStop","inserted","GgetBBox","GsetStops","addStop","gradientLinear","setStops","gradientRadial","fx","fy","unshift","gradientUnits","next","p2s","paths","ps","sleep","r1","r2","r0","rectPath","pathClone","pathArray","getPointAtSegmentLength","p1x","p1y","c1x","c1y","c2x","c2y","p2x","p2y","bezlen","findDotsAtSegment","x4","y4","ll","t2","getTotLen","getLengthFactory","istotal","subpath","O","onlystart","point","sp","subpaths","path2curve","getSubpathsAtLength","t1","t13","t12","t3","mx","my","nx","ny","alpha","bezierBBox","curveDim","isPointInsideBBox","isBBoxIntersect","bbox1","bbox2","base3","p1","p2","p3","p4","z2","Tvalues","Cvalues","sum","ct","xbase","ybase","comb","intersect","denominator","px","py","px2","py2","interHelper","bez1","bez2","justCount","n1","n2","dots1","dots2","xy","di","di1","dj","dj1","ci","cj","interPathHelper","path1","path2","x1m","y1m","x2m","y2m","pi","pj","intr","kk","segment1","segment2","pathBBox","Y","dim","xmin","ymin","ellipsePath","getPath","pathToAbsolute","pa0","pa","crz","dots","catmullRom2bezier","l2c","q2c","ax","ay","x0","y0","b2ac","sqrtb2ac","tvalues","bounds","mt","jlen","curve","bx","by","qx","qy","attrs2","processPath","pcom","T","a2c","large_arc_flag","sweep_flag","recursive","_120","f1","f2","rx2","ry2","df","f2old","x2old","y2old","c1","s1","c2","s2","hx","hy","m1","m2","m3","m4","newres","fixArc","pp","pcoms1","pcoms2","fixM","a1","a2","pfirst","seg","seg2","seglen","seg2len","crp","iLen","getSubpath","closest","inside","found","intersection","intersectionNumber","isPointInside","toRelative","lowerCase","rel","toCubic","pathi","Set","items","bindings","setproto","Animation","each","begin","cb","callbacker","aname","unbound","insertion","tail","todel","arglen","exclude","names","getEmpty","getViewBox","getColour","path2array","isNumeric","equal","Number","tt1","tt2","maxlength","equaliseTransform","arr1","arr2","bUnit","supportsTouch","events","touchMap","mousedown","mousemove","mouseup","getScroll","preventTouch","originalEvent","preventDefault","stopTouch","stopPropagation","addEvent","fn","realName","scrollY","scrollX","targetTouches","olde","clientX","clientY","addEventListener","removeEventListener","drag","dragMove","dragi","touch","touches","identifier","_drag","move_scope","dragUp","unmousemove","unmouseup","end_scope","start_scope","off","eventName","unbind","f_in","f_out","scope_in","scope_out","mouseover","mouseout","unhover","unmouseover","unmouseout","draggable","onmove","onstart","onend","origTransform","init","undrag","unmousedown","pproto","rgurl","filstr","filterUnits","def","shadow","grayscale","amount","sepia","saturate","hueRotate","amount2","brightness","contrast","firstLetter","getAlign","way","align","animation","inAnim","_attrs","_callback","curStatus","eq","fkeys","tkeys","saveColor","colors","A100","A200","A400","A700","mui","flat","pink","purple","deeppurple","indigo","lightblue","cyan","teal","lightgreen","lime","yellow","amber","orange","deeporange","brown","grey","bluegrey","turquoise","greensea","sunflower","emerland","nephritis","carrot","pumpkin","peterriver","belizehole","alizarin","pomegranate","amethyst","wisteria","clouds","silver","wetasphalt","midnightblue","concrete","asbestos","importMUIColors","__WEBPACK_AMD_DEFINE_RESULT__","current_event","comaseparator","numsort","lastDefined","objtos","ar","oldstop","listeners","indexed","queue","ce","sort","_events","nes","es","sep","exist","subname","cur","nts","inodes","funcs","prune","steps","stepsTotal","nextStep","closeButton","transformOrigin","transformStyle","perspective","perspectiveOrigin","burgerIcon","memoize","theme","customStyles","primary","_a","_b","_c","baseButtonStyles","BaseButton_styles","splitButtonStyles","SplitButton_styles","compoundButtonStyles","maxWidth","minHeight","flexContainer","flexDirection","alignItems","minWidth","textContainer","textAlign","lineHeight","flexBasis","flexShrink","label","fontWeight","semibold","description","fonts","small","standardCompoundTheme","palette","neutralSecondary","descriptionHovered","neutralDark","descriptionPressed","descriptionChecked","descriptionDisabled","primaryCompoundTheme","white","selectors","backgroundColor","MsHighContrastAdjust","ButtonThemes","__webpack_exports__","CompoundButton_CompoundButton","_super","CompoundButton","_skipComponentRefResolution","tslib_es6","react","BaseButton","variantClassName","customizable","BaseComponent"],"mappings":"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","file":"static/js/3.bd069d63.chunk.js","sourcesContent":["\"use strict\";\n\nexports.__esModule = true;\nexports.default = exports.EXITING = exports.ENTERED = exports.ENTERING = exports.EXITED = exports.UNMOUNTED = void 0;\n\nvar PropTypes = _interopRequireWildcard(require(\"prop-types\"));\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _reactDom = _interopRequireDefault(require(\"react-dom\"));\n\nvar _reactLifecyclesCompat = require(\"react-lifecycles-compat\");\n\nvar _PropTypes = require(\"./utils/PropTypes\");\n\nfunction _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    default: obj\n  };\n}\n\nfunction _interopRequireWildcard(obj) {\n  if (obj && obj.__esModule) {\n    return obj;\n  } else {\n    var newObj = {};\n\n    if (obj != null) {\n      for (var key in obj) {\n        if (Object.prototype.hasOwnProperty.call(obj, key)) {\n          var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {};\n\n          if (desc.get || desc.set) {\n            Object.defineProperty(newObj, key, desc);\n          } else {\n            newObj[key] = obj[key];\n          }\n        }\n      }\n    }\n\n    newObj.default = obj;\n    return newObj;\n  }\n}\n\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}\n\nfunction _inheritsLoose(subClass, superClass) {\n  subClass.prototype = Object.create(superClass.prototype);\n  subClass.prototype.constructor = subClass;\n  subClass.__proto__ = superClass;\n}\n\nvar UNMOUNTED = 'unmounted';\nexports.UNMOUNTED = UNMOUNTED;\nvar EXITED = 'exited';\nexports.EXITED = EXITED;\nvar ENTERING = 'entering';\nexports.ENTERING = ENTERING;\nvar ENTERED = 'entered';\nexports.ENTERED = ENTERED;\nvar EXITING = 'exiting';\n/**\n * The Transition component lets you describe a transition from one component\n * state to another _over time_ with a simple declarative API. Most commonly\n * it's used to animate the mounting and unmounting of a component, but can also\n * be used to describe in-place transition states as well.\n *\n * By default the `Transition` component does not alter the behavior of the\n * component it renders, it only tracks \"enter\" and \"exit\" states for the components.\n * It's up to you to give meaning and effect to those states. For example we can\n * add styles to a component when it enters or exits:\n *\n * ```jsx\n * import Transition from 'react-transition-group/Transition';\n *\n * const duration = 300;\n *\n * const defaultStyle = {\n *   transition: `opacity ${duration}ms ease-in-out`,\n *   opacity: 0,\n * }\n *\n * const transitionStyles = {\n *   entering: { opacity: 0 },\n *   entered:  { opacity: 1 },\n * };\n *\n * const Fade = ({ in: inProp }) => (\n *   <Transition in={inProp} timeout={duration}>\n *     {(state) => (\n *       <div style={{\n *         ...defaultStyle,\n *         ...transitionStyles[state]\n *       }}>\n *         I'm a fade Transition!\n *       </div>\n *     )}\n *   </Transition>\n * );\n * ```\n *\n * As noted the `Transition` component doesn't _do_ anything by itself to its child component.\n * What it does do is track transition states over time so you can update the\n * component (such as by adding styles or classes) when it changes states.\n *\n * There are 4 main states a Transition can be in:\n *  - `'entering'`\n *  - `'entered'`\n *  - `'exiting'`\n *  - `'exited'`\n *\n * Transition state is toggled via the `in` prop. When `true` the component begins the\n * \"Enter\" stage. During this stage, the component will shift from its current transition state,\n * to `'entering'` for the duration of the transition and then to the `'entered'` stage once\n * it's complete. Let's take the following example:\n *\n * ```jsx\n * state = { in: false };\n *\n * toggleEnterState = () => {\n *   this.setState({ in: true });\n * }\n *\n * render() {\n *   return (\n *     <div>\n *       <Transition in={this.state.in} timeout={500} />\n *       <button onClick={this.toggleEnterState}>Click to Enter</button>\n *     </div>\n *   );\n * }\n * ```\n *\n * When the button is clicked the component will shift to the `'entering'` state and\n * stay there for 500ms (the value of `timeout`) before it finally switches to `'entered'`.\n *\n * When `in` is `false` the same thing happens except the state moves from `'exiting'` to `'exited'`.\n *\n * ## Timing\n *\n * Timing is often the trickiest part of animation, mistakes can result in slight delays\n * that are hard to pin down. A common example is when you want to add an exit transition,\n * you should set the desired final styles when the state is `'exiting'`. That's when the\n * transition to those styles will start and, if you matched the `timeout` prop with the\n * CSS Transition duration, it will end exactly when the state changes to `'exited'`.\n *\n * > **Note**: For simpler transitions the `Transition` component might be enough, but\n * > take into account that it's platform-agnostic, while the `CSSTransition` component\n * > [forces reflows](https://github.com/reactjs/react-transition-group/blob/5007303e729a74be66a21c3e2205e4916821524b/src/CSSTransition.js#L208-L215)\n * > in order to make more complex transitions more predictable. For example, even though\n * > classes `example-enter` and `example-enter-active` are applied immediately one after\n * > another, you can still transition from one to the other because of the forced reflow\n * > (read [this issue](https://github.com/reactjs/react-transition-group/issues/159#issuecomment-322761171)\n * > for more info). Take this into account when choosing between `Transition` and\n * > `CSSTransition`.\n */\n\nexports.EXITING = EXITING;\n\nvar Transition =\n/*#__PURE__*/\nfunction (_React$Component) {\n  _inheritsLoose(Transition, _React$Component);\n\n  function Transition(props, context) {\n    var _this;\n\n    _this = _React$Component.call(this, props, context) || this;\n    var parentGroup = context.transitionGroup; // In the context of a TransitionGroup all enters are really appears\n\n    var appear = parentGroup && !parentGroup.isMounting ? props.enter : props.appear;\n    var initialStatus;\n    _this.appearStatus = null;\n\n    if (props.in) {\n      if (appear) {\n        initialStatus = EXITED;\n        _this.appearStatus = ENTERING;\n      } else {\n        initialStatus = ENTERED;\n      }\n    } else {\n      if (props.unmountOnExit || props.mountOnEnter) {\n        initialStatus = UNMOUNTED;\n      } else {\n        initialStatus = EXITED;\n      }\n    }\n\n    _this.state = {\n      status: initialStatus\n    };\n    _this.nextCallback = null;\n    return _this;\n  }\n\n  var _proto = Transition.prototype;\n\n  _proto.getChildContext = function getChildContext() {\n    return {\n      transitionGroup: null // allows for nested Transitions\n\n    };\n  };\n\n  Transition.getDerivedStateFromProps = function getDerivedStateFromProps(_ref, prevState) {\n    var nextIn = _ref.in;\n\n    if (nextIn && prevState.status === UNMOUNTED) {\n      return {\n        status: EXITED\n      };\n    }\n\n    return null;\n  }; // getSnapshotBeforeUpdate(prevProps) {\n  //   let nextStatus = null\n  //   if (prevProps !== this.props) {\n  //     const { status } = this.state\n  //     if (this.props.in) {\n  //       if (status !== ENTERING && status !== ENTERED) {\n  //         nextStatus = ENTERING\n  //       }\n  //     } else {\n  //       if (status === ENTERING || status === ENTERED) {\n  //         nextStatus = EXITING\n  //       }\n  //     }\n  //   }\n  //   return { nextStatus }\n  // }\n\n\n  _proto.componentDidMount = function componentDidMount() {\n    this.updateStatus(true, this.appearStatus);\n  };\n\n  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {\n    var nextStatus = null;\n\n    if (prevProps !== this.props) {\n      var status = this.state.status;\n\n      if (this.props.in) {\n        if (status !== ENTERING && status !== ENTERED) {\n          nextStatus = ENTERING;\n        }\n      } else {\n        if (status === ENTERING || status === ENTERED) {\n          nextStatus = EXITING;\n        }\n      }\n    }\n\n    this.updateStatus(false, nextStatus);\n  };\n\n  _proto.componentWillUnmount = function componentWillUnmount() {\n    this.cancelNextCallback();\n  };\n\n  _proto.getTimeouts = function getTimeouts() {\n    var timeout = this.props.timeout;\n    var exit, enter, appear;\n    exit = enter = appear = timeout;\n\n    if (timeout != null && typeof timeout !== 'number') {\n      exit = timeout.exit;\n      enter = timeout.enter;\n      appear = timeout.appear;\n    }\n\n    return {\n      exit: exit,\n      enter: enter,\n      appear: appear\n    };\n  };\n\n  _proto.updateStatus = function updateStatus(mounting, nextStatus) {\n    if (mounting === void 0) {\n      mounting = false;\n    }\n\n    if (nextStatus !== null) {\n      // nextStatus will always be ENTERING or EXITING.\n      this.cancelNextCallback();\n\n      var node = _reactDom.default.findDOMNode(this);\n\n      if (nextStatus === ENTERING) {\n        this.performEnter(node, mounting);\n      } else {\n        this.performExit(node);\n      }\n    } else if (this.props.unmountOnExit && this.state.status === EXITED) {\n      this.setState({\n        status: UNMOUNTED\n      });\n    }\n  };\n\n  _proto.performEnter = function performEnter(node, mounting) {\n    var _this2 = this;\n\n    var enter = this.props.enter;\n    var appearing = this.context.transitionGroup ? this.context.transitionGroup.isMounting : mounting;\n    var timeouts = this.getTimeouts(); // no enter animation skip right to ENTERED\n    // if we are mounting and running this it means appear _must_ be set\n\n    if (!mounting && !enter) {\n      this.safeSetState({\n        status: ENTERED\n      }, function () {\n        _this2.props.onEntered(node);\n      });\n      return;\n    }\n\n    this.props.onEnter(node, appearing);\n    this.safeSetState({\n      status: ENTERING\n    }, function () {\n      _this2.props.onEntering(node, appearing); // FIXME: appear timeout?\n\n\n      _this2.onTransitionEnd(node, timeouts.enter, function () {\n        _this2.safeSetState({\n          status: ENTERED\n        }, function () {\n          _this2.props.onEntered(node, appearing);\n        });\n      });\n    });\n  };\n\n  _proto.performExit = function performExit(node) {\n    var _this3 = this;\n\n    var exit = this.props.exit;\n    var timeouts = this.getTimeouts(); // no exit animation skip right to EXITED\n\n    if (!exit) {\n      this.safeSetState({\n        status: EXITED\n      }, function () {\n        _this3.props.onExited(node);\n      });\n      return;\n    }\n\n    this.props.onExit(node);\n    this.safeSetState({\n      status: EXITING\n    }, function () {\n      _this3.props.onExiting(node);\n\n      _this3.onTransitionEnd(node, timeouts.exit, function () {\n        _this3.safeSetState({\n          status: EXITED\n        }, function () {\n          _this3.props.onExited(node);\n        });\n      });\n    });\n  };\n\n  _proto.cancelNextCallback = function cancelNextCallback() {\n    if (this.nextCallback !== null) {\n      this.nextCallback.cancel();\n      this.nextCallback = null;\n    }\n  };\n\n  _proto.safeSetState = function safeSetState(nextState, callback) {\n    // This shouldn't be necessary, but there are weird race conditions with\n    // setState callbacks and unmounting in testing, so always make sure that\n    // we can cancel any pending setState callbacks after we unmount.\n    callback = this.setNextCallback(callback);\n    this.setState(nextState, callback);\n  };\n\n  _proto.setNextCallback = function setNextCallback(callback) {\n    var _this4 = this;\n\n    var active = true;\n\n    this.nextCallback = function (event) {\n      if (active) {\n        active = false;\n        _this4.nextCallback = null;\n        callback(event);\n      }\n    };\n\n    this.nextCallback.cancel = function () {\n      active = false;\n    };\n\n    return this.nextCallback;\n  };\n\n  _proto.onTransitionEnd = function onTransitionEnd(node, timeout, handler) {\n    this.setNextCallback(handler);\n\n    if (node) {\n      if (this.props.addEndListener) {\n        this.props.addEndListener(node, this.nextCallback);\n      }\n\n      if (timeout != null) {\n        setTimeout(this.nextCallback, timeout);\n      }\n    } else {\n      setTimeout(this.nextCallback, 0);\n    }\n  };\n\n  _proto.render = function render() {\n    var status = this.state.status;\n\n    if (status === UNMOUNTED) {\n      return null;\n    }\n\n    var _this$props = this.props,\n        children = _this$props.children,\n        childProps = _objectWithoutPropertiesLoose(_this$props, [\"children\"]); // filter props for Transtition\n\n\n    delete childProps.in;\n    delete childProps.mountOnEnter;\n    delete childProps.unmountOnExit;\n    delete childProps.appear;\n    delete childProps.enter;\n    delete childProps.exit;\n    delete childProps.timeout;\n    delete childProps.addEndListener;\n    delete childProps.onEnter;\n    delete childProps.onEntering;\n    delete childProps.onEntered;\n    delete childProps.onExit;\n    delete childProps.onExiting;\n    delete childProps.onExited;\n\n    if (typeof children === 'function') {\n      return children(status, childProps);\n    }\n\n    var child = _react.default.Children.only(children);\n\n    return _react.default.cloneElement(child, childProps);\n  };\n\n  return Transition;\n}(_react.default.Component);\n\nTransition.contextTypes = {\n  transitionGroup: PropTypes.object\n};\nTransition.childContextTypes = {\n  transitionGroup: function transitionGroup() {}\n};\nTransition.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  /**\n   * A `function` child can be used instead of a React element.\n   * This function is called with the current transition status\n   * ('entering', 'entered', 'exiting', 'exited', 'unmounted'), which can be used\n   * to apply context specific props to a component.\n   *\n   * ```jsx\n   * <Transition timeout={150}>\n   *   {(status) => (\n   *     <MyComponent className={`fade fade-${status}`} />\n   *   )}\n   * </Transition>\n   * ```\n   */\n  children: PropTypes.oneOfType([PropTypes.func.isRequired, PropTypes.element.isRequired]).isRequired,\n\n  /**\n   * Show the component; triggers the enter or exit states\n   */\n  in: PropTypes.bool,\n\n  /**\n   * By default the child component is mounted immediately along with\n   * the parent `Transition` component. If you want to \"lazy mount\" the component on the\n   * first `in={true}` you can set `mountOnEnter`. After the first enter transition the component will stay\n   * mounted, even on \"exited\", unless you also specify `unmountOnExit`.\n   */\n  mountOnEnter: PropTypes.bool,\n\n  /**\n   * By default the child component stays mounted after it reaches the `'exited'` state.\n   * Set `unmountOnExit` if you'd prefer to unmount the component after it finishes exiting.\n   */\n  unmountOnExit: PropTypes.bool,\n\n  /**\n   * Normally a component is not transitioned if it is shown when the `<Transition>` component mounts.\n   * If you want to transition on the first mount set `appear` to `true`, and the\n   * component will transition in as soon as the `<Transition>` mounts.\n   *\n   * > Note: there are no specific \"appear\" states. `appear` only adds an additional `enter` transition.\n   */\n  appear: PropTypes.bool,\n\n  /**\n   * Enable or disable enter transitions.\n   */\n  enter: PropTypes.bool,\n\n  /**\n   * Enable or disable exit transitions.\n   */\n  exit: PropTypes.bool,\n\n  /**\n   * The duration of the transition, in milliseconds.\n   * Required unless `addEndListener` is provided\n   *\n   * You may specify a single timeout for all transitions like: `timeout={500}`,\n   * or individually like:\n   *\n   * ```jsx\n   * timeout={{\n   *  enter: 300,\n   *  exit: 500,\n   * }}\n   * ```\n   *\n   * @type {number | { enter?: number, exit?: number }}\n   */\n  timeout: function timeout(props) {\n    var pt = process.env.NODE_ENV !== \"production\" ? _PropTypes.timeoutsShape : {};\n    ;\n    if (!props.addEndListener) pt = pt.isRequired;\n\n    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      args[_key - 1] = arguments[_key];\n    }\n\n    return pt.apply(void 0, [props].concat(args));\n  },\n\n  /**\n   * Add a custom transition end trigger. Called with the transitioning\n   * DOM node and a `done` callback. Allows for more fine grained transition end\n   * logic. **Note:** Timeouts are still used as a fallback if provided.\n   *\n   * ```jsx\n   * addEndListener={(node, done) => {\n   *   // use the css transitionend event to mark the finish of a transition\n   *   node.addEventListener('transitionend', done, false);\n   * }}\n   * ```\n   */\n  addEndListener: PropTypes.func,\n\n  /**\n   * Callback fired before the \"entering\" status is applied. An extra parameter\n   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool) -> void\n   */\n  onEnter: PropTypes.func,\n\n  /**\n   * Callback fired after the \"entering\" status is applied. An extra parameter\n   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool)\n   */\n  onEntering: PropTypes.func,\n\n  /**\n   * Callback fired after the \"entered\" status is applied. An extra parameter\n   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool) -> void\n   */\n  onEntered: PropTypes.func,\n\n  /**\n   * Callback fired before the \"exiting\" status is applied.\n   *\n   * @type Function(node: HtmlElement) -> void\n   */\n  onExit: PropTypes.func,\n\n  /**\n   * Callback fired after the \"exiting\" status is applied.\n   *\n   * @type Function(node: HtmlElement) -> void\n   */\n  onExiting: PropTypes.func,\n\n  /**\n   * Callback fired after the \"exited\" status is applied.\n   *\n   * @type Function(node: HtmlElement) -> void\n   */\n  onExited: PropTypes.func // Name the function so it is clearer in the documentation\n\n} : {};\n\nfunction noop() {}\n\nTransition.defaultProps = {\n  in: false,\n  mountOnEnter: false,\n  unmountOnExit: false,\n  appear: false,\n  enter: true,\n  exit: true,\n  onEnter: noop,\n  onEntering: noop,\n  onEntered: noop,\n  onExit: noop,\n  onExiting: noop,\n  onExited: noop\n};\nTransition.UNMOUNTED = 0;\nTransition.EXITED = 1;\nTransition.ENTERING = 2;\nTransition.ENTERED = 3;\nTransition.EXITING = 4;\n\nvar _default = (0, _reactLifecyclesCompat.polyfill)(Transition);\n\nexports.default = _default;","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nvar _extends = Object.assign || function (target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i];\n\n    for (var key in source) {\n      if (Object.prototype.hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n\n  return target;\n};\n\nvar _createClass = function () {\n  function defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if ('value' in descriptor) descriptor.writable = true;\n      Object.defineProperty(target, descriptor.key, descriptor);\n    }\n  }\n\n  return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n}();\n\nvar _get = function get(_x3, _x4, _x5) {\n  var _again = true;\n\n  _function: while (_again) {\n    var object = _x3,\n        property = _x4,\n        receiver = _x5;\n    _again = false;\n    if (object === null) object = Function.prototype;\n    var desc = Object.getOwnPropertyDescriptor(object, property);\n\n    if (desc === undefined) {\n      var parent = Object.getPrototypeOf(object);\n\n      if (parent === null) {\n        return undefined;\n      } else {\n        _x3 = parent;\n        _x4 = property;\n        _x5 = receiver;\n        _again = true;\n        desc = parent = undefined;\n        continue _function;\n      }\n    } else if ('value' in desc) {\n      return desc.value;\n    } else {\n      var getter = desc.get;\n\n      if (getter === undefined) {\n        return undefined;\n      }\n\n      return getter.call(receiver);\n    }\n  }\n};\n\nfunction _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    'default': obj\n  };\n}\n\nfunction _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError('Cannot call a class as a function');\n  }\n}\n\nfunction _inherits(subClass, superClass) {\n  if (typeof superClass !== 'function' && superClass !== null) {\n    throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass);\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      enumerable: false,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;\n}\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _reactDom = require('react-dom');\n\nvar _reactDom2 = _interopRequireDefault(_reactDom);\n\nvar _propTypes = require('prop-types');\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\n\nvar _baseStyles = require('./baseStyles');\n\nvar _baseStyles2 = _interopRequireDefault(_baseStyles);\n\nvar _BurgerIcon = require('./BurgerIcon');\n\nvar _BurgerIcon2 = _interopRequireDefault(_BurgerIcon);\n\nvar _CrossIcon = require('./CrossIcon');\n\nvar _CrossIcon2 = _interopRequireDefault(_CrossIcon);\n\nexports['default'] = function (styles) {\n  var Menu = function (_Component) {\n    _inherits(Menu, _Component);\n\n    function Menu(props) {\n      _classCallCheck(this, Menu);\n\n      _get(Object.getPrototypeOf(Menu.prototype), 'constructor', this).call(this, props);\n\n      this.state = {\n        isOpen: false\n      };\n    }\n\n    _createClass(Menu, [{\n      key: 'toggleMenu',\n      value: function toggleMenu() {\n        var _this = this;\n\n        var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];\n        var isOpen = options.isOpen;\n        var noStateChange = options.noStateChange;\n        var newState = {\n          isOpen: typeof isOpen !== 'undefined' ? isOpen : !this.state.isOpen\n        };\n        this.applyWrapperStyles();\n        this.setState(newState, function () {\n          !noStateChange && _this.props.onStateChange(newState); // For accessibility reasons, ensures that when we toggle open,\n          // we focus the first menu item if one exists.\n\n          if (newState.isOpen) {\n            var firstItem = document.querySelector('.bm-item');\n\n            if (firstItem) {\n              firstItem.focus();\n            }\n          } else {\n            if (document.activeElement) {\n              document.activeElement.blur();\n            } else {\n              document.body.blur(); // Needed for IE\n            }\n          } // Timeout ensures wrappers are cleared after animation finishes.\n\n\n          _this.timeoutId && clearTimeout(_this.timeoutId);\n          _this.timeoutId = setTimeout(function () {\n            _this.timeoutId = null;\n\n            if (!newState.isOpen) {\n              _this.applyWrapperStyles(false);\n            }\n          }, 500);\n        });\n      } // Applies component-specific styles to external wrapper elements.\n\n    }, {\n      key: 'applyWrapperStyles',\n      value: function applyWrapperStyles() {\n        var set = arguments.length <= 0 || arguments[0] === undefined ? true : arguments[0];\n\n        var applyClass = function applyClass(el, className) {\n          return el.classList[set ? 'add' : 'remove'](className);\n        };\n\n        if (this.props.htmlClassName) {\n          applyClass(document.querySelector('html'), this.props.htmlClassName);\n        }\n\n        if (this.props.bodyClassName) {\n          applyClass(document.querySelector('body'), this.props.bodyClassName);\n        }\n\n        if (styles.pageWrap && this.props.pageWrapId) {\n          this.handleExternalWrapper(this.props.pageWrapId, styles.pageWrap, set);\n        }\n\n        if (styles.outerContainer && this.props.outerContainerId) {\n          this.handleExternalWrapper(this.props.outerContainerId, styles.outerContainer, set);\n        }\n      } // Sets or unsets styles on DOM elements outside the menu component.\n      // This is necessary for correct page interaction with some of the menus.\n      // Throws and returns if the required external elements don't exist,\n      // which means any external page animations won't be applied.\n\n    }, {\n      key: 'handleExternalWrapper',\n      value: function handleExternalWrapper(id, wrapperStyles, set) {\n        var wrapper = document.getElementById(id);\n\n        if (!wrapper) {\n          console.error(\"Element with ID '\" + id + \"' not found\");\n          return;\n        }\n\n        var builtStyles = this.getStyle(wrapperStyles);\n\n        for (var prop in builtStyles) {\n          if (builtStyles.hasOwnProperty(prop)) {\n            wrapper.style[prop] = set ? builtStyles[prop] : '';\n          }\n        } // Prevent any horizontal scroll.\n        // Only set overflow-x as an inline style if htmlClassName or\n        // bodyClassName is not passed in. Otherwise, it is up to the caller to\n        // decide if they want to set the overflow style in CSS using the custom\n        // class names.\n\n\n        var applyOverflow = function applyOverflow(el) {\n          return el.style['overflow-x'] = set ? 'hidden' : '';\n        };\n\n        if (!this.props.htmlClassName) {\n          applyOverflow(document.querySelector('html'));\n        }\n\n        if (!this.props.bodyClassName) {\n          applyOverflow(document.querySelector('body'));\n        }\n      } // Builds styles incrementally for a given element.\n\n    }, {\n      key: 'getStyles',\n      value: function getStyles(el, index, inline) {\n        var propName = 'bm' + el.replace(el.charAt(0), el.charAt(0).toUpperCase()); // Set base styles.\n\n        var output = _baseStyles2['default'][el] ? this.getStyle(_baseStyles2['default'][el]) : {}; // Add animation-specific styles.\n\n        if (styles[el]) {\n          output = _extends({}, output, this.getStyle(styles[el], index + 1));\n        } // Add custom styles.\n\n\n        if (this.props.styles[propName]) {\n          output = _extends({}, output, this.props.styles[propName]);\n        } // Add element inline styles.\n\n\n        if (inline) {\n          output = _extends({}, output, inline);\n        }\n\n        return output;\n      }\n    }, {\n      key: 'getStyle',\n      value: function getStyle(style, index) {\n        var width = this.props.width;\n        var formattedWidth = typeof width !== 'string' ? width + 'px' : width;\n        return style(this.state.isOpen, formattedWidth, this.props.right, index);\n      }\n    }, {\n      key: 'listenForClose',\n      value: function listenForClose(e) {\n        e = e || window.event;\n\n        if (this.state.isOpen && (e.key === 'Escape' || e.keyCode === 27)) {\n          this.toggleMenu();\n        }\n      }\n    }, {\n      key: 'shouldDisableOverlayClick',\n      value: function shouldDisableOverlayClick() {\n        if (typeof this.props.disableOverlayClick === 'function') {\n          return this.props.disableOverlayClick();\n        } else {\n          return this.props.disableOverlayClick;\n        }\n      }\n    }, {\n      key: 'componentWillMount',\n      value: function componentWillMount() {\n        if (!styles) {\n          throw new Error('No styles supplied');\n        }\n      }\n    }, {\n      key: 'componentDidMount',\n      value: function componentDidMount() {\n        // Bind ESC key handler (unless disabled or custom function supplied).\n        if (this.props.customOnKeyDown) {\n          window.onkeydown = this.props.customOnKeyDown;\n        } else if (!this.props.disableCloseOnEsc) {\n          window.onkeydown = this.listenForClose.bind(this);\n        } // Allow initial open state to be set by props.\n\n\n        if (this.props.isOpen) {\n          this.toggleMenu({\n            isOpen: true,\n            noStateChange: true\n          });\n        }\n      }\n    }, {\n      key: 'componentWillUnmount',\n      value: function componentWillUnmount() {\n        window.onkeydown = null;\n        this.applyWrapperStyles(false);\n      }\n    }, {\n      key: 'componentDidUpdate',\n      value: function componentDidUpdate() {\n        var _this2 = this;\n\n        if (styles.svg) {\n          (function () {\n            var morphShape = _reactDom2['default'].findDOMNode(_this2, 'bm-morph-shape');\n\n            var path = styles.svg.lib(morphShape).select('path');\n\n            if (_this2.state.isOpen) {\n              // Animate SVG path.\n              styles.svg.animate(path);\n            } else {\n              // Reset path (timeout ensures animation happens off screen).\n              setTimeout(function () {\n                path.attr('d', styles.svg.pathInitial);\n              }, 300);\n            }\n          })();\n        }\n      }\n    }, {\n      key: 'componentWillReceiveProps',\n      value: function componentWillReceiveProps(nextProps) {\n        if (typeof nextProps.isOpen !== 'undefined' && nextProps.isOpen !== this.state.isOpen) {\n          this.toggleMenu();\n        }\n      }\n    }, {\n      key: 'render',\n      value: function render() {\n        var _this3 = this;\n\n        return _react2['default'].createElement('div', null, !this.props.noOverlay && _react2['default'].createElement('div', {\n          className: ('bm-overlay ' + this.props.overlayClassName).trim(),\n          onClick: function onClick() {\n            return !_this3.shouldDisableOverlayClick() && _this3.toggleMenu();\n          },\n          style: this.getStyles('overlay')\n        }), _react2['default'].createElement('div', {\n          id: this.props.id,\n          className: ('bm-menu-wrap ' + this.props.className).trim(),\n          style: this.getStyles('menuWrap')\n        }, styles.svg && _react2['default'].createElement('div', {\n          className: ('bm-morph-shape ' + this.props.morphShapeClassName).trim(),\n          style: this.getStyles('morphShape')\n        }, _react2['default'].createElement('svg', {\n          width: '100%',\n          height: '100%',\n          viewBox: '0 0 100 800',\n          preserveAspectRatio: 'none'\n        }, _react2['default'].createElement('path', {\n          d: styles.svg.pathInitial\n        }))), _react2['default'].createElement('div', {\n          className: ('bm-menu ' + this.props.menuClassName).trim(),\n          style: this.getStyles('menu')\n        }, _react2['default'].createElement('nav', {\n          className: ('bm-item-list ' + this.props.itemListClassName).trim(),\n          style: this.getStyles('itemList')\n        }, _react2['default'].Children.map(this.props.children, function (item, index) {\n          if (item) {\n            var classList = ['bm-item', _this3.props.itemClassName, item.props.className].filter(function (className) {\n              return !!className;\n            }).join(' ');\n            var extraProps = {\n              key: index,\n              className: classList,\n              style: _this3.getStyles('item', index, item.props.style),\n              tabIndex: _this3.state.isOpen ? 0 : -1\n            };\n            return _react2['default'].cloneElement(item, extraProps);\n          }\n        }))), this.props.customCrossIcon !== false && _react2['default'].createElement('div', {\n          style: this.getStyles('closeButton')\n        }, _react2['default'].createElement(_CrossIcon2['default'], {\n          onClick: function onClick() {\n            return _this3.toggleMenu();\n          },\n          styles: this.props.styles,\n          customIcon: this.props.customCrossIcon,\n          className: this.props.crossButtonClassName,\n          crossClassName: this.props.crossClassName,\n          tabIndex: this.state.isOpen ? 0 : -1\n        }))), this.props.customBurgerIcon !== false && _react2['default'].createElement('div', {\n          style: this.getStyles('burgerIcon')\n        }, _react2['default'].createElement(_BurgerIcon2['default'], {\n          onClick: function onClick() {\n            return _this3.toggleMenu();\n          },\n          styles: this.props.styles,\n          customIcon: this.props.customBurgerIcon,\n          className: this.props.burgerButtonClassName,\n          barClassName: this.props.burgerBarClassName\n        })));\n      }\n    }]);\n\n    return Menu;\n  }(_react.Component);\n\n  Menu.propTypes = {\n    bodyClassName: _propTypes2['default'].string,\n    burgerBarClassName: _propTypes2['default'].string,\n    burgerButtonClassName: _propTypes2['default'].string,\n    crossButtonClassName: _propTypes2['default'].string,\n    crossClassName: _propTypes2['default'].string,\n    customBurgerIcon: _propTypes2['default'].oneOfType([_propTypes2['default'].element, _propTypes2['default'].oneOf([false])]),\n    customCrossIcon: _propTypes2['default'].oneOfType([_propTypes2['default'].element, _propTypes2['default'].oneOf([false])]),\n    customOnKeyDown: _propTypes2['default'].func,\n    disableCloseOnEsc: _propTypes2['default'].bool,\n    disableOverlayClick: _propTypes2['default'].oneOfType([_propTypes2['default'].bool, _propTypes2['default'].func]),\n    htmlClassName: _propTypes2['default'].string,\n    id: _propTypes2['default'].string,\n    isOpen: _propTypes2['default'].bool,\n    itemClassName: _propTypes2['default'].string,\n    itemListClassName: _propTypes2['default'].string,\n    menuClassName: _propTypes2['default'].string,\n    morphShapeClassName: _propTypes2['default'].string,\n    noOverlay: _propTypes2['default'].bool,\n    onStateChange: _propTypes2['default'].func,\n    outerContainerId: styles && styles.outerContainer ? _propTypes2['default'].string.isRequired : _propTypes2['default'].string,\n    overlayClassName: _propTypes2['default'].string,\n    pageWrapId: styles && styles.pageWrap ? _propTypes2['default'].string.isRequired : _propTypes2['default'].string,\n    right: _propTypes2['default'].bool,\n    styles: _propTypes2['default'].object,\n    width: _propTypes2['default'].oneOfType([_propTypes2['default'].number, _propTypes2['default'].string])\n  };\n  Menu.defaultProps = {\n    bodyClassName: '',\n    burgerBarClassName: '',\n    burgerButtonClassName: '',\n    className: '',\n    crossButtonClassName: '',\n    crossClassName: '',\n    disableCloseOnEsc: false,\n    htmlClassName: '',\n    id: '',\n    itemClassName: '',\n    itemListClassName: '',\n    menuClassName: '',\n    morphShapeClassName: '',\n    noOverlay: false,\n    onStateChange: function onStateChange() {},\n    outerContainerId: '',\n    overlayClassName: '',\n    pageWrapId: '',\n    styles: {},\n    width: 300\n  };\n  return Menu;\n};\n\nmodule.exports = exports['default'];","/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n/** Used to stand-in for `undefined` hash values. */\n\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n/** Used as references for various `Number` constants. */\n\nvar INFINITY = 1 / 0,\n    MAX_SAFE_INTEGER = 9007199254740991;\n/** `Object#toString` result references. */\n\nvar argsTag = '[object Arguments]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    symbolTag = '[object Symbol]';\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\n\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n/** Used to detect host constructors (Safari). */\n\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n/** Used to detect unsigned integer values. */\n\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n/** Detect free variable `global` from Node.js. */\n\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n/** Detect free variable `self`. */\n\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n/** Used as a reference to the global object. */\n\nvar root = freeGlobal || freeSelf || Function('return this')();\n/**\n * A faster alternative to `Function#apply`, this function invokes `func`\n * with the `this` binding of `thisArg` and the arguments of `args`.\n *\n * @private\n * @param {Function} func The function to invoke.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} args The arguments to invoke `func` with.\n * @returns {*} Returns the result of `func`.\n */\n\nfunction apply(func, thisArg, args) {\n  switch (args.length) {\n    case 0:\n      return func.call(thisArg);\n\n    case 1:\n      return func.call(thisArg, args[0]);\n\n    case 2:\n      return func.call(thisArg, args[0], args[1]);\n\n    case 3:\n      return func.call(thisArg, args[0], args[1], args[2]);\n  }\n\n  return func.apply(thisArg, args);\n}\n/**\n * A specialized version of `_.includes` for arrays without support for\n * specifying an index to search from.\n *\n * @private\n * @param {Array} [array] The array to inspect.\n * @param {*} target The value to search for.\n * @returns {boolean} Returns `true` if `target` is found, else `false`.\n */\n\n\nfunction arrayIncludes(array, value) {\n  var length = array ? array.length : 0;\n  return !!length && baseIndexOf(array, value, 0) > -1;\n}\n/**\n * This function is like `arrayIncludes` except that it accepts a comparator.\n *\n * @private\n * @param {Array} [array] The array to inspect.\n * @param {*} target The value to search for.\n * @param {Function} comparator The comparator invoked per element.\n * @returns {boolean} Returns `true` if `target` is found, else `false`.\n */\n\n\nfunction arrayIncludesWith(array, value, comparator) {\n  var index = -1,\n      length = array ? array.length : 0;\n\n  while (++index < length) {\n    if (comparator(value, array[index])) {\n      return true;\n    }\n  }\n\n  return false;\n}\n/**\n * A specialized version of `_.map` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n */\n\n\nfunction arrayMap(array, iteratee) {\n  var index = -1,\n      length = array ? array.length : 0,\n      result = Array(length);\n\n  while (++index < length) {\n    result[index] = iteratee(array[index], index, array);\n  }\n\n  return result;\n}\n/**\n * Appends the elements of `values` to `array`.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n */\n\n\nfunction arrayPush(array, values) {\n  var index = -1,\n      length = values.length,\n      offset = array.length;\n\n  while (++index < length) {\n    array[offset + index] = values[index];\n  }\n\n  return array;\n}\n/**\n * The base implementation of `_.findIndex` and `_.findLastIndex` without\n * support for iteratee shorthands.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {Function} predicate The function invoked per iteration.\n * @param {number} fromIndex The index to search from.\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\n\n\nfunction baseFindIndex(array, predicate, fromIndex, fromRight) {\n  var length = array.length,\n      index = fromIndex + (fromRight ? 1 : -1);\n\n  while (fromRight ? index-- : ++index < length) {\n    if (predicate(array[index], index, array)) {\n      return index;\n    }\n  }\n\n  return -1;\n}\n/**\n * The base implementation of `_.indexOf` without `fromIndex` bounds checks.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} value The value to search for.\n * @param {number} fromIndex The index to search from.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\n\n\nfunction baseIndexOf(array, value, fromIndex) {\n  if (value !== value) {\n    return baseFindIndex(array, baseIsNaN, fromIndex);\n  }\n\n  var index = fromIndex - 1,\n      length = array.length;\n\n  while (++index < length) {\n    if (array[index] === value) {\n      return index;\n    }\n  }\n\n  return -1;\n}\n/**\n * The base implementation of `_.isNaN` without support for number objects.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.\n */\n\n\nfunction baseIsNaN(value) {\n  return value !== value;\n}\n/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\n\n\nfunction baseTimes(n, iteratee) {\n  var index = -1,\n      result = Array(n);\n\n  while (++index < n) {\n    result[index] = iteratee(index);\n  }\n\n  return result;\n}\n/**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\n\n\nfunction baseUnary(func) {\n  return function (value) {\n    return func(value);\n  };\n}\n/**\n * Checks if a cache value for `key` exists.\n *\n * @private\n * @param {Object} cache The cache to query.\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\n\n\nfunction cacheHas(cache, key) {\n  return cache.has(key);\n}\n/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\n\n\nfunction getValue(object, key) {\n  return object == null ? undefined : object[key];\n}\n/**\n * Checks if `value` is a host object in IE < 9.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a host object, else `false`.\n */\n\n\nfunction isHostObject(value) {\n  // Many host objects are `Object` objects that can coerce to strings\n  // despite having improperly defined `toString` methods.\n  var result = false;\n\n  if (value != null && typeof value.toString != 'function') {\n    try {\n      result = !!(value + '');\n    } catch (e) {}\n  }\n\n  return result;\n}\n/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\n\n\nfunction overArg(func, transform) {\n  return function (arg) {\n    return func(transform(arg));\n  };\n}\n/** Used for built-in method references. */\n\n\nvar arrayProto = Array.prototype,\n    funcProto = Function.prototype,\n    objectProto = Object.prototype;\n/** Used to detect overreaching core-js shims. */\n\nvar coreJsData = root['__core-js_shared__'];\n/** Used to detect methods masquerading as native. */\n\nvar maskSrcKey = function () {\n  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n  return uid ? 'Symbol(src)_1.' + uid : '';\n}();\n/** Used to resolve the decompiled source of functions. */\n\n\nvar funcToString = funcProto.toString;\n/** Used to check objects for own properties. */\n\nvar hasOwnProperty = objectProto.hasOwnProperty;\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\n\nvar objectToString = objectProto.toString;\n/** Used to detect if a method is native. */\n\nvar reIsNative = RegExp('^' + funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&').replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$');\n/** Built-in value references. */\n\nvar Symbol = root.Symbol,\n    getPrototype = overArg(Object.getPrototypeOf, Object),\n    propertyIsEnumerable = objectProto.propertyIsEnumerable,\n    splice = arrayProto.splice,\n    spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined;\n/* Built-in method references for those with the same name as other `lodash` methods. */\n\nvar nativeGetSymbols = Object.getOwnPropertySymbols,\n    nativeMax = Math.max;\n/* Built-in method references that are verified to be native. */\n\nvar Map = getNative(root, 'Map'),\n    nativeCreate = getNative(Object, 'create');\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\n\nfunction Hash(entries) {\n  var index = -1,\n      length = entries ? entries.length : 0;\n  this.clear();\n\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\n\n\nfunction hashClear() {\n  this.__data__ = nativeCreate ? nativeCreate(null) : {};\n}\n/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\n\n\nfunction hashDelete(key) {\n  return this.has(key) && delete this.__data__[key];\n}\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\n\n\nfunction hashGet(key) {\n  var data = this.__data__;\n\n  if (nativeCreate) {\n    var result = data[key];\n    return result === HASH_UNDEFINED ? undefined : result;\n  }\n\n  return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\n\n\nfunction hashHas(key) {\n  var data = this.__data__;\n  return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);\n}\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\n\n\nfunction hashSet(key, value) {\n  var data = this.__data__;\n  data[key] = nativeCreate && value === undefined ? HASH_UNDEFINED : value;\n  return this;\n} // Add methods to `Hash`.\n\n\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\n\nfunction ListCache(entries) {\n  var index = -1,\n      length = entries ? entries.length : 0;\n  this.clear();\n\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\n\n\nfunction listCacheClear() {\n  this.__data__ = [];\n}\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\n\n\nfunction listCacheDelete(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    return false;\n  }\n\n  var lastIndex = data.length - 1;\n\n  if (index == lastIndex) {\n    data.pop();\n  } else {\n    splice.call(data, index, 1);\n  }\n\n  return true;\n}\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\n\n\nfunction listCacheGet(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n  return index < 0 ? undefined : data[index][1];\n}\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\n\n\nfunction listCacheHas(key) {\n  return assocIndexOf(this.__data__, key) > -1;\n}\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\n\n\nfunction listCacheSet(key, value) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    data.push([key, value]);\n  } else {\n    data[index][1] = value;\n  }\n\n  return this;\n} // Add methods to `ListCache`.\n\n\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\n\nfunction MapCache(entries) {\n  var index = -1,\n      length = entries ? entries.length : 0;\n  this.clear();\n\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\n\n\nfunction mapCacheClear() {\n  this.__data__ = {\n    'hash': new Hash(),\n    'map': new (Map || ListCache)(),\n    'string': new Hash()\n  };\n}\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\n\n\nfunction mapCacheDelete(key) {\n  return getMapData(this, key)['delete'](key);\n}\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\n\n\nfunction mapCacheGet(key) {\n  return getMapData(this, key).get(key);\n}\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\n\n\nfunction mapCacheHas(key) {\n  return getMapData(this, key).has(key);\n}\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\n\n\nfunction mapCacheSet(key, value) {\n  getMapData(this, key).set(key, value);\n  return this;\n} // Add methods to `MapCache`.\n\n\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n/**\n *\n * Creates an array cache object to store unique values.\n *\n * @private\n * @constructor\n * @param {Array} [values] The values to cache.\n */\n\nfunction SetCache(values) {\n  var index = -1,\n      length = values ? values.length : 0;\n  this.__data__ = new MapCache();\n\n  while (++index < length) {\n    this.add(values[index]);\n  }\n}\n/**\n * Adds `value` to the array cache.\n *\n * @private\n * @name add\n * @memberOf SetCache\n * @alias push\n * @param {*} value The value to cache.\n * @returns {Object} Returns the cache instance.\n */\n\n\nfunction setCacheAdd(value) {\n  this.__data__.set(value, HASH_UNDEFINED);\n\n  return this;\n}\n/**\n * Checks if `value` is in the array cache.\n *\n * @private\n * @name has\n * @memberOf SetCache\n * @param {*} value The value to search for.\n * @returns {number} Returns `true` if `value` is found, else `false`.\n */\n\n\nfunction setCacheHas(value) {\n  return this.__data__.has(value);\n} // Add methods to `SetCache`.\n\n\nSetCache.prototype.add = SetCache.prototype.push = setCacheAdd;\nSetCache.prototype.has = setCacheHas;\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\n\nfunction arrayLikeKeys(value, inherited) {\n  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n  // Safari 9 makes `arguments.length` enumerable in strict mode.\n  var result = isArray(value) || isArguments(value) ? baseTimes(value.length, String) : [];\n  var length = result.length,\n      skipIndexes = !!length;\n\n  for (var key in value) {\n    if ((inherited || hasOwnProperty.call(value, key)) && !(skipIndexes && (key == 'length' || isIndex(key, length)))) {\n      result.push(key);\n    }\n  }\n\n  return result;\n}\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\n\n\nfunction assocIndexOf(array, key) {\n  var length = array.length;\n\n  while (length--) {\n    if (eq(array[length][0], key)) {\n      return length;\n    }\n  }\n\n  return -1;\n}\n/**\n * The base implementation of methods like `_.difference` without support\n * for excluding multiple arrays or iteratee shorthands.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {Array} values The values to exclude.\n * @param {Function} [iteratee] The iteratee invoked per element.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns the new array of filtered values.\n */\n\n\nfunction baseDifference(array, values, iteratee, comparator) {\n  var index = -1,\n      includes = arrayIncludes,\n      isCommon = true,\n      length = array.length,\n      result = [],\n      valuesLength = values.length;\n\n  if (!length) {\n    return result;\n  }\n\n  if (iteratee) {\n    values = arrayMap(values, baseUnary(iteratee));\n  }\n\n  if (comparator) {\n    includes = arrayIncludesWith;\n    isCommon = false;\n  } else if (values.length >= LARGE_ARRAY_SIZE) {\n    includes = cacheHas;\n    isCommon = false;\n    values = new SetCache(values);\n  }\n\n  outer: while (++index < length) {\n    var value = array[index],\n        computed = iteratee ? iteratee(value) : value;\n    value = comparator || value !== 0 ? value : 0;\n\n    if (isCommon && computed === computed) {\n      var valuesIndex = valuesLength;\n\n      while (valuesIndex--) {\n        if (values[valuesIndex] === computed) {\n          continue outer;\n        }\n      }\n\n      result.push(value);\n    } else if (!includes(values, computed, comparator)) {\n      result.push(value);\n    }\n  }\n\n  return result;\n}\n/**\n * The base implementation of `_.flatten` with support for restricting flattening.\n *\n * @private\n * @param {Array} array The array to flatten.\n * @param {number} depth The maximum recursion depth.\n * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.\n * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.\n * @param {Array} [result=[]] The initial result value.\n * @returns {Array} Returns the new flattened array.\n */\n\n\nfunction baseFlatten(array, depth, predicate, isStrict, result) {\n  var index = -1,\n      length = array.length;\n  predicate || (predicate = isFlattenable);\n  result || (result = []);\n\n  while (++index < length) {\n    var value = array[index];\n\n    if (depth > 0 && predicate(value)) {\n      if (depth > 1) {\n        // Recursively flatten arrays (susceptible to call stack limits).\n        baseFlatten(value, depth - 1, predicate, isStrict, result);\n      } else {\n        arrayPush(result, value);\n      }\n    } else if (!isStrict) {\n      result[result.length] = value;\n    }\n  }\n\n  return result;\n}\n/**\n * The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @param {Function} symbolsFunc The function to get the symbols of `object`.\n * @returns {Array} Returns the array of property names and symbols.\n */\n\n\nfunction baseGetAllKeys(object, keysFunc, symbolsFunc) {\n  var result = keysFunc(object);\n  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n}\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n *  else `false`.\n */\n\n\nfunction baseIsNative(value) {\n  if (!isObject(value) || isMasked(value)) {\n    return false;\n  }\n\n  var pattern = isFunction(value) || isHostObject(value) ? reIsNative : reIsHostCtor;\n  return pattern.test(toSource(value));\n}\n/**\n * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\n\n\nfunction baseKeysIn(object) {\n  if (!isObject(object)) {\n    return nativeKeysIn(object);\n  }\n\n  var isProto = isPrototype(object),\n      result = [];\n\n  for (var key in object) {\n    if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n      result.push(key);\n    }\n  }\n\n  return result;\n}\n/**\n * The base implementation of `_.pick` without support for individual\n * property identifiers.\n *\n * @private\n * @param {Object} object The source object.\n * @param {string[]} props The property identifiers to pick.\n * @returns {Object} Returns the new object.\n */\n\n\nfunction basePick(object, props) {\n  object = Object(object);\n  return basePickBy(object, props, function (value, key) {\n    return key in object;\n  });\n}\n/**\n * The base implementation of  `_.pickBy` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The source object.\n * @param {string[]} props The property identifiers to pick from.\n * @param {Function} predicate The function invoked per property.\n * @returns {Object} Returns the new object.\n */\n\n\nfunction basePickBy(object, props, predicate) {\n  var index = -1,\n      length = props.length,\n      result = {};\n\n  while (++index < length) {\n    var key = props[index],\n        value = object[key];\n\n    if (predicate(value, key)) {\n      result[key] = value;\n    }\n  }\n\n  return result;\n}\n/**\n * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n */\n\n\nfunction baseRest(func, start) {\n  start = nativeMax(start === undefined ? func.length - 1 : start, 0);\n  return function () {\n    var args = arguments,\n        index = -1,\n        length = nativeMax(args.length - start, 0),\n        array = Array(length);\n\n    while (++index < length) {\n      array[index] = args[start + index];\n    }\n\n    index = -1;\n    var otherArgs = Array(start + 1);\n\n    while (++index < start) {\n      otherArgs[index] = args[index];\n    }\n\n    otherArgs[start] = array;\n    return apply(func, this, otherArgs);\n  };\n}\n/**\n * Creates an array of own and inherited enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\n\n\nfunction getAllKeysIn(object) {\n  return baseGetAllKeys(object, keysIn, getSymbolsIn);\n}\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\n\n\nfunction getMapData(map, key) {\n  var data = map.__data__;\n  return isKeyable(key) ? data[typeof key == 'string' ? 'string' : 'hash'] : data.map;\n}\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\n\n\nfunction getNative(object, key) {\n  var value = getValue(object, key);\n  return baseIsNative(value) ? value : undefined;\n}\n/**\n * Creates an array of the own enumerable symbol properties of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\n\n\nvar getSymbols = nativeGetSymbols ? overArg(nativeGetSymbols, Object) : stubArray;\n/**\n * Creates an array of the own and inherited enumerable symbol properties\n * of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\n\nvar getSymbolsIn = !nativeGetSymbols ? stubArray : function (object) {\n  var result = [];\n\n  while (object) {\n    arrayPush(result, getSymbols(object));\n    object = getPrototype(object);\n  }\n\n  return result;\n};\n/**\n * Checks if `value` is a flattenable `arguments` object or array.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.\n */\n\nfunction isFlattenable(value) {\n  return isArray(value) || isArguments(value) || !!(spreadableSymbol && value && value[spreadableSymbol]);\n}\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\n\n\nfunction isIndex(value, length) {\n  length = length == null ? MAX_SAFE_INTEGER : length;\n  return !!length && (typeof value == 'number' || reIsUint.test(value)) && value > -1 && value % 1 == 0 && value < length;\n}\n/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\n\n\nfunction isKeyable(value) {\n  var type = typeof value;\n  return type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean' ? value !== '__proto__' : value === null;\n}\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\n\n\nfunction isMasked(func) {\n  return !!maskSrcKey && maskSrcKey in func;\n}\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\n\n\nfunction isPrototype(value) {\n  var Ctor = value && value.constructor,\n      proto = typeof Ctor == 'function' && Ctor.prototype || objectProto;\n  return value === proto;\n}\n/**\n * This function is like\n * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * except that it includes inherited enumerable properties.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\n\n\nfunction nativeKeysIn(object) {\n  var result = [];\n\n  if (object != null) {\n    for (var key in Object(object)) {\n      result.push(key);\n    }\n  }\n\n  return result;\n}\n/**\n * Converts `value` to a string key if it's not a string or symbol.\n *\n * @private\n * @param {*} value The value to inspect.\n * @returns {string|symbol} Returns the key.\n */\n\n\nfunction toKey(value) {\n  if (typeof value == 'string' || isSymbol(value)) {\n    return value;\n  }\n\n  var result = value + '';\n  return result == '0' && 1 / value == -INFINITY ? '-0' : result;\n}\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to process.\n * @returns {string} Returns the source code.\n */\n\n\nfunction toSource(func) {\n  if (func != null) {\n    try {\n      return funcToString.call(func);\n    } catch (e) {}\n\n    try {\n      return func + '';\n    } catch (e) {}\n  }\n\n  return '';\n}\n/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\n\n\nfunction eq(value, other) {\n  return value === other || value !== value && other !== other;\n}\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\n\n\nfunction isArguments(value) {\n  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n  return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') && (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);\n}\n/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\n\n\nvar isArray = Array.isArray;\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\n\nfunction isArrayLike(value) {\n  return value != null && isLength(value.length) && !isFunction(value);\n}\n/**\n * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array-like object,\n *  else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\n\n\nfunction isArrayLikeObject(value) {\n  return isObjectLike(value) && isArrayLike(value);\n}\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\n\n\nfunction isFunction(value) {\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 8-9 which returns 'object' for typed array and other constructors.\n  var tag = isObject(value) ? objectToString.call(value) : '';\n  return tag == funcTag || tag == genTag;\n}\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\n\n\nfunction isLength(value) {\n  return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\n\n\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\n\n\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\n\n\nfunction isSymbol(value) {\n  return typeof value == 'symbol' || isObjectLike(value) && objectToString.call(value) == symbolTag;\n}\n/**\n * Creates an array of the own and inherited enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keysIn(new Foo);\n * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n */\n\n\nfunction keysIn(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n}\n/**\n * The opposite of `_.pick`; this method creates an object composed of the\n * own and inherited enumerable string keyed properties of `object` that are\n * not omitted.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The source object.\n * @param {...(string|string[])} [props] The property identifiers to omit.\n * @returns {Object} Returns the new object.\n * @example\n *\n * var object = { 'a': 1, 'b': '2', 'c': 3 };\n *\n * _.omit(object, ['a', 'c']);\n * // => { 'b': '2' }\n */\n\n\nvar omit = baseRest(function (object, props) {\n  if (object == null) {\n    return {};\n  }\n\n  props = arrayMap(baseFlatten(props, 1), toKey);\n  return basePick(object, baseDifference(getAllKeysIn(object), props));\n});\n/**\n * This method returns a new empty array.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {Array} Returns the new empty array.\n * @example\n *\n * var arrays = _.times(2, _.stubArray);\n *\n * console.log(arrays);\n * // => [[], []]\n *\n * console.log(arrays[0] === arrays[1]);\n * // => false\n */\n\nfunction stubArray() {\n  return [];\n}\n\nmodule.exports = omit;","var parser = require('js-yaml');\n\nvar optionalByteOrderMark = \"\\\\ufeff?\";\nvar pattern = '^(' + optionalByteOrderMark + '(= yaml =|---)' + '$([\\\\s\\\\S]*?)' + '^(?:\\\\2|\\\\.\\\\.\\\\.)' + '$' + (process.platform === 'win32' ? '\\\\r?' : '') + '(?:\\\\n)?)'; // NOTE: If this pattern uses the 'g' flag the `regex` variable definition will\n// need to be moved down into the functions that use it.\n\nvar regex = new RegExp(pattern, 'm');\nmodule.exports = extractor;\nmodule.exports.test = test;\n\nfunction extractor(string) {\n  string = string || '';\n  var lines = string.split(/(\\r?\\n)/);\n\n  if (lines[0] && /= yaml =|---/.test(lines[0])) {\n    return parse(string);\n  } else {\n    return {\n      attributes: {},\n      body: string\n    };\n  }\n}\n\nfunction parse(string) {\n  var match = regex.exec(string);\n\n  if (!match) {\n    return {\n      attributes: {},\n      body: string\n    };\n  }\n\n  var yaml = match[match.length - 1].replace(/^\\s+|\\s+$/g, '');\n  var attributes = parser.load(yaml) || {};\n  var body = string.replace(match[0], '');\n  return {\n    attributes: attributes,\n    body: body,\n    frontmatter: yaml\n  };\n}\n\nfunction test(string) {\n  string = string || '';\n  return regex.test(string);\n}","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\nexports['default'] = {\n  slide: require('./menus/slide'),\n  stack: require('./menus/stack'),\n  elastic: require('./menus/elastic'),\n  bubble: require('./menus/bubble'),\n  push: require('./menus/push'),\n  pushRotate: require('./menus/pushRotate'),\n  scaleDown: require('./menus/scaleDown'),\n  scaleRotate: require('./menus/scaleRotate'),\n  fallDown: require('./menus/fallDown'),\n  reveal: require('./menus/reveal')\n};\nmodule.exports = exports['default'];","\"use strict\";\n\nexports.__esModule = true;\nexports.classNamesShape = exports.timeoutsShape = void 0;\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nfunction _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    default: obj\n  };\n}\n\nvar timeoutsShape = process.env.NODE_ENV !== 'production' ? _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.shape({\n  enter: _propTypes.default.number,\n  exit: _propTypes.default.number\n}).isRequired]) : null;\nexports.timeoutsShape = timeoutsShape;\nvar classNamesShape = process.env.NODE_ENV !== 'production' ? _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.shape({\n  enter: _propTypes.default.string,\n  exit: _propTypes.default.string,\n  active: _propTypes.default.string\n}), _propTypes.default.shape({\n  enter: _propTypes.default.string,\n  enterDone: _propTypes.default.string,\n  enterActive: _propTypes.default.string,\n  exit: _propTypes.default.string,\n  exitDone: _propTypes.default.string,\n  exitActive: _propTypes.default.string\n})]) : null;\nexports.classNamesShape = classNamesShape;","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nexports['default'] = function () {\n  var Snap = undefined;\n\n  try {\n    Snap = require('snapsvg-cjs');\n  } finally {\n    return Snap;\n  }\n};\n\nmodule.exports = exports['default'];","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nfunction _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    'default': obj\n  };\n}\n\nvar _menuFactory = require('../menuFactory');\n\nvar _menuFactory2 = _interopRequireDefault(_menuFactory);\n\nvar styles = {};\nexports['default'] = (0, _menuFactory2['default'])(styles);\nmodule.exports = exports['default'];","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\nvar styles = {\n  overlay: function overlay(isOpen) {\n    return {\n      position: 'fixed',\n      zIndex: 1000,\n      width: '100%',\n      height: '100%',\n      background: 'rgba(0, 0, 0, 0.3)',\n      opacity: isOpen ? 1 : 0,\n      MozTransform: isOpen ? '' : 'translate3d(100%, 0, 0)',\n      MsTransform: isOpen ? '' : 'translate3d(100%, 0, 0)',\n      OTransform: isOpen ? '' : 'translate3d(100%, 0, 0)',\n      WebkitTransform: isOpen ? '' : 'translate3d(100%, 0, 0)',\n      transform: isOpen ? '' : 'translate3d(100%, 0, 0)',\n      transition: isOpen ? 'opacity 0.3s' : 'opacity 0.3s, transform 0s 0.3s'\n    };\n  },\n  menuWrap: function menuWrap(isOpen, width, right) {\n    return {\n      position: 'fixed',\n      right: right ? 0 : 'inherit',\n      zIndex: 1100,\n      width: width,\n      height: '100%',\n      MozTransform: isOpen ? '' : right ? 'translate3d(100%, 0, 0)' : 'translate3d(-100%, 0, 0)',\n      MsTransform: isOpen ? '' : right ? 'translate3d(100%, 0, 0)' : 'translate3d(-100%, 0, 0)',\n      OTransform: isOpen ? '' : right ? 'translate3d(100%, 0, 0)' : 'translate3d(-100%, 0, 0)',\n      WebkitTransform: isOpen ? '' : right ? 'translate3d(100%, 0, 0)' : 'translate3d(-100%, 0, 0)',\n      transform: isOpen ? '' : right ? 'translate3d(100%, 0, 0)' : 'translate3d(-100%, 0, 0)',\n      transition: 'all 0.5s'\n    };\n  },\n  menu: function menu() {\n    return {\n      height: '100%',\n      boxSizing: 'border-box',\n      overflow: 'auto'\n    };\n  },\n  itemList: function itemList() {\n    return {\n      height: '100%'\n    };\n  },\n  item: function item() {\n    return {\n      display: 'block'\n    };\n  }\n};\nexports['default'] = styles;\nmodule.exports = exports['default'];","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nvar _extends = Object.assign || function (target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i];\n\n    for (var key in source) {\n      if (Object.prototype.hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n\n  return target;\n};\n\nvar _createClass = function () {\n  function defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if ('value' in descriptor) descriptor.writable = true;\n      Object.defineProperty(target, descriptor.key, descriptor);\n    }\n  }\n\n  return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n}();\n\nvar _get = function get(_x, _x2, _x3) {\n  var _again = true;\n\n  _function: while (_again) {\n    var object = _x,\n        property = _x2,\n        receiver = _x3;\n    _again = false;\n    if (object === null) object = Function.prototype;\n    var desc = Object.getOwnPropertyDescriptor(object, property);\n\n    if (desc === undefined) {\n      var parent = Object.getPrototypeOf(object);\n\n      if (parent === null) {\n        return undefined;\n      } else {\n        _x = parent;\n        _x2 = property;\n        _x3 = receiver;\n        _again = true;\n        desc = parent = undefined;\n        continue _function;\n      }\n    } else if ('value' in desc) {\n      return desc.value;\n    } else {\n      var getter = desc.get;\n\n      if (getter === undefined) {\n        return undefined;\n      }\n\n      return getter.call(receiver);\n    }\n  }\n};\n\nfunction _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    'default': obj\n  };\n}\n\nfunction _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError('Cannot call a class as a function');\n  }\n}\n\nfunction _inherits(subClass, superClass) {\n  if (typeof superClass !== 'function' && superClass !== null) {\n    throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass);\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      enumerable: false,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;\n}\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _propTypes = require('prop-types');\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\n\nvar BurgerIcon = function (_Component) {\n  _inherits(BurgerIcon, _Component);\n\n  function BurgerIcon(props) {\n    _classCallCheck(this, BurgerIcon);\n\n    _get(Object.getPrototypeOf(BurgerIcon.prototype), 'constructor', this).call(this, props);\n\n    this.state = {\n      hover: false\n    };\n  }\n\n  _createClass(BurgerIcon, [{\n    key: 'getLineStyle',\n    value: function getLineStyle(index) {\n      return _extends({\n        position: 'absolute',\n        height: '20%',\n        left: 0,\n        right: 0,\n        top: 20 * (index * 2) + '%',\n        opacity: this.state.hover ? 0.6 : 1\n      }, this.state.hover && this.props.styles.bmBurgerBarsHover);\n    }\n  }, {\n    key: 'render',\n    value: function render() {\n      var _this = this;\n\n      var icon = undefined;\n      var buttonStyle = {\n        position: 'absolute',\n        left: 0,\n        top: 0,\n        width: '100%',\n        height: '100%',\n        margin: 0,\n        padding: 0,\n        border: 'none',\n        fontSize: 0,\n        background: 'transparent',\n        cursor: 'pointer'\n      };\n\n      if (this.props.customIcon) {\n        var extraProps = {\n          className: 'bm-icon',\n          style: _extends({\n            width: '100%',\n            height: '100%'\n          }, this.props.styles.bmIcon)\n        };\n        icon = _react2['default'].cloneElement(this.props.customIcon, extraProps);\n      } else {\n        icon = _react2['default'].createElement('span', null, [0, 1, 2].map(function (bar) {\n          return _react2['default'].createElement('span', {\n            key: bar,\n            className: ('bm-burger-bars ' + _this.props.barClassName + ' ' + (_this.state.hover ? 'bm-burger-bars-hover' : '')).trim(),\n            style: _extends({}, _this.getLineStyle(bar), _this.props.styles.bmBurgerBars)\n          });\n        }));\n      }\n\n      return _react2['default'].createElement('div', {\n        className: ('bm-burger-button ' + this.props.className).trim(),\n        style: _extends({\n          zIndex: 1000\n        }, this.props.styles.bmBurgerButton)\n      }, icon, _react2['default'].createElement('button', {\n        onClick: this.props.onClick,\n        onMouseOver: function onMouseOver() {\n          return _this.setState({\n            hover: true\n          });\n        },\n        onMouseOut: function onMouseOut() {\n          return _this.setState({\n            hover: false\n          });\n        },\n        style: buttonStyle\n      }, 'Open Menu'));\n    }\n  }]);\n\n  return BurgerIcon;\n}(_react.Component);\n\nexports['default'] = BurgerIcon;\nBurgerIcon.propTypes = {\n  barClassName: _propTypes2['default'].string,\n  customIcon: _propTypes2['default'].element,\n  styles: _propTypes2['default'].object\n};\nBurgerIcon.defaultProps = {\n  barClassName: '',\n  className: '',\n  styles: {}\n};\nmodule.exports = exports['default'];","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nvar _extends = Object.assign || function (target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i];\n\n    for (var key in source) {\n      if (Object.prototype.hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n\n  return target;\n};\n\nvar _createClass = function () {\n  function defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if ('value' in descriptor) descriptor.writable = true;\n      Object.defineProperty(target, descriptor.key, descriptor);\n    }\n  }\n\n  return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n}();\n\nvar _get = function get(_x, _x2, _x3) {\n  var _again = true;\n\n  _function: while (_again) {\n    var object = _x,\n        property = _x2,\n        receiver = _x3;\n    _again = false;\n    if (object === null) object = Function.prototype;\n    var desc = Object.getOwnPropertyDescriptor(object, property);\n\n    if (desc === undefined) {\n      var parent = Object.getPrototypeOf(object);\n\n      if (parent === null) {\n        return undefined;\n      } else {\n        _x = parent;\n        _x2 = property;\n        _x3 = receiver;\n        _again = true;\n        desc = parent = undefined;\n        continue _function;\n      }\n    } else if ('value' in desc) {\n      return desc.value;\n    } else {\n      var getter = desc.get;\n\n      if (getter === undefined) {\n        return undefined;\n      }\n\n      return getter.call(receiver);\n    }\n  }\n};\n\nfunction _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    'default': obj\n  };\n}\n\nfunction _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError('Cannot call a class as a function');\n  }\n}\n\nfunction _inherits(subClass, superClass) {\n  if (typeof superClass !== 'function' && superClass !== null) {\n    throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass);\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      enumerable: false,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;\n}\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _propTypes = require('prop-types');\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\n\nvar CrossIcon = function (_Component) {\n  _inherits(CrossIcon, _Component);\n\n  function CrossIcon() {\n    _classCallCheck(this, CrossIcon);\n\n    _get(Object.getPrototypeOf(CrossIcon.prototype), 'constructor', this).apply(this, arguments);\n  }\n\n  _createClass(CrossIcon, [{\n    key: 'getCrossStyle',\n    value: function getCrossStyle(type) {\n      return {\n        position: 'absolute',\n        width: 3,\n        height: 14,\n        transform: type === 'before' ? 'rotate(45deg)' : 'rotate(-45deg)'\n      };\n    }\n  }, {\n    key: 'render',\n    value: function render() {\n      var _this = this;\n\n      var icon;\n      var buttonWrapperStyle = {\n        position: 'absolute',\n        width: 24,\n        height: 24,\n        right: 8,\n        top: 8\n      };\n      var buttonStyle = {\n        position: 'absolute',\n        left: 0,\n        top: 0,\n        width: '100%',\n        height: '100%',\n        margin: 0,\n        padding: 0,\n        border: 'none',\n        fontSize: 0,\n        background: 'transparent',\n        cursor: 'pointer'\n      };\n\n      if (this.props.customIcon) {\n        var extraProps = {\n          className: 'bm-cross',\n          style: _extends({\n            width: '100%',\n            height: '100%'\n          }, this.props.styles.bmCross)\n        };\n        icon = _react2['default'].cloneElement(this.props.customIcon, extraProps);\n      } else {\n        icon = _react2['default'].createElement('span', {\n          style: {\n            position: 'absolute',\n            top: '6px',\n            right: '14px'\n          }\n        }, ['before', 'after'].map(function (type, i) {\n          return _react2['default'].createElement('span', {\n            key: i,\n            className: ('bm-cross ' + _this.props.crossClassName).trim(),\n            style: _extends({}, _this.getCrossStyle(type), _this.props.styles.bmCross)\n          });\n        }));\n      }\n\n      return _react2['default'].createElement('div', {\n        className: ('bm-cross-button ' + this.props.className).trim(),\n        style: _extends({}, buttonWrapperStyle, this.props.styles.bmCrossButton)\n      }, icon, _react2['default'].createElement('button', {\n        onClick: this.props.onClick,\n        style: buttonStyle,\n        tabIndex: this.props.tabIndex\n      }, 'Close Menu'));\n    }\n  }]);\n\n  return CrossIcon;\n}(_react.Component);\n\nexports['default'] = CrossIcon;\nCrossIcon.propTypes = {\n  crossClassName: _propTypes2['default'].string,\n  customIcon: _propTypes2['default'].element,\n  styles: _propTypes2['default'].object,\n  tabIndex: _propTypes2['default'].number\n};\nCrossIcon.defaultProps = {\n  crossClassName: '',\n  className: '',\n  styles: {},\n  tabIndex: 0\n};\nmodule.exports = exports['default'];","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nfunction _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    'default': obj\n  };\n}\n\nvar _menuFactory = require('../menuFactory');\n\nvar _menuFactory2 = _interopRequireDefault(_menuFactory);\n\nvar styles = {\n  menuWrap: function menuWrap(isOpen, width, right) {\n    return {\n      MozTransform: isOpen ? '' : right ? 'translate3d(' + width + ', 0, 0)' : 'translate3d(-' + width + ', 0, 0)',\n      MsTransform: isOpen ? '' : right ? 'translate3d(' + width + ', 0, 0)' : 'translate3d(-' + width + ', 0, 0)',\n      OTransform: isOpen ? '' : right ? 'translate3d(' + width + ', 0, 0)' : 'translate3d(-' + width + ', 0, 0)',\n      WebkitTransform: isOpen ? '' : right ? 'translate3d(' + width + ', 0, 0)' : 'translate3d(-' + width + ', 0, 0)',\n      transform: isOpen ? '' : right ? 'translate3d(' + width + ', 0, 0)' : 'translate3d(-' + width + ', 0, 0)',\n      transition: isOpen ? 'transform 0.8s cubic-bezier(0.7, 0, 0.3, 1)' : 'transform 0.4s cubic-bezier(0.7, 0, 0.3, 1)'\n    };\n  },\n  item: function item(isOpen, width, right, nthChild) {\n    return {\n      MozTransform: isOpen ? '' : 'translate3d(0, ' + nthChild * 500 + 'px, 0)',\n      MsTransform: isOpen ? '' : 'translate3d(0, ' + nthChild * 500 + 'px, 0)',\n      OTransform: isOpen ? '' : 'translate3d(0, ' + nthChild * 500 + 'px, 0)',\n      WebkitTransform: isOpen ? '' : 'translate3d(0, ' + nthChild * 500 + 'px, 0)',\n      transform: isOpen ? '' : 'translate3d(0, ' + nthChild * 500 + 'px, 0)',\n      transition: isOpen ? 'transform 0.8s cubic-bezier(0.7, 0, 0.3, 1)' : 'transform 0s 0.2s cubic-bezier(0.7, 0, 0.3, 1)'\n    };\n  }\n};\nexports['default'] = (0, _menuFactory2['default'])(styles);\nmodule.exports = exports['default'];","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nfunction _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    'default': obj\n  };\n}\n\nvar _snapsvgImporter = require('../snapsvgImporter');\n\nvar _snapsvgImporter2 = _interopRequireDefault(_snapsvgImporter);\n\nvar _menuFactory = require('../menuFactory');\n\nvar _menuFactory2 = _interopRequireDefault(_menuFactory);\n\nvar styles = {\n  svg: {\n    lib: _snapsvgImporter2['default'],\n    pathInitial: 'M-1,0h101c0,0-97.833,153.603-97.833,396.167C2.167,627.579,100,800,100,800H-1V0z',\n    pathOpen: 'M-1,0h101c0,0,0-1,0,395c0,404,0,405,0,405H-1V0z',\n    animate: function animate(path) {\n      path.animate({\n        path: this.pathOpen\n      }, 400, window.mina.easeinout);\n    }\n  },\n  morphShape: function morphShape(isOpen, width, right) {\n    return {\n      position: 'absolute',\n      width: 120,\n      height: '100%',\n      right: right ? 'inherit' : 0,\n      left: right ? 0 : 'inherit',\n      MozTransform: right ? 'rotateY(180deg)' : '',\n      MsTransform: right ? 'rotateY(180deg)' : '',\n      OTransform: right ? 'rotateY(180deg)' : '',\n      WebkitTransform: right ? 'rotateY(180deg)' : '',\n      transform: right ? 'rotateY(180deg)' : ''\n    };\n  },\n  menuWrap: function menuWrap(isOpen, width, right) {\n    return {\n      MozTransform: isOpen ? 'translate3d(0, 0, 0)' : right ? 'translate3d(100%, 0, 0)' : 'translate3d(-100%, 0, 0)',\n      MsTransform: isOpen ? 'translate3d(0, 0, 0)' : right ? 'translate3d(100%, 0, 0)' : 'translate3d(-100%, 0, 0)',\n      OTransform: isOpen ? 'translate3d(0, 0, 0)' : right ? 'translate3d(100%, 0, 0)' : 'translate3d(-100%, 0, 0)',\n      WebkitTransform: isOpen ? 'translate3d(0, 0, 0)' : right ? 'translate3d(100%, 0, 0)' : 'translate3d(-100%, 0, 0)',\n      transform: isOpen ? 'translate3d(0, 0, 0)' : right ? 'translate3d(100%, 0, 0)' : 'translate3d(-100%, 0, 0)',\n      transition: 'all 0.3s'\n    };\n  },\n  menu: function menu(isOpen, width, right) {\n    return {\n      position: 'fixed',\n      right: right ? 0 : 'inherit',\n      width: 180,\n      whiteSpace: 'nowrap',\n      boxSizing: 'border-box',\n      overflow: 'visible'\n    };\n  },\n  itemList: function itemList(isOpen, width, right) {\n    if (right) {\n      return {\n        position: 'relative',\n        left: '-110px',\n        width: '170%',\n        overflow: 'auto'\n      };\n    }\n  },\n  pageWrap: function pageWrap(isOpen, width, right) {\n    return {\n      MozTransform: isOpen ? '' : right ? 'translate3d(-100px, 0, 0)' : 'translate3d(100px, 0, 0)',\n      MsTransform: isOpen ? '' : right ? 'translate3d(-100px, 0, 0)' : 'translate3d(100px, 0, 0)',\n      OTransform: isOpen ? '' : right ? 'translate3d(-100px, 0, 0)' : 'translate3d(100px, 0, 0)',\n      WebkitTransform: isOpen ? '' : right ? 'translate3d(-100px, 0, 0)' : 'translate3d(100px, 0, 0)',\n      transform: isOpen ? '' : right ? 'translate3d(-100px, 0, 0)' : 'translate3d(100px, 0, 0)',\n      transition: isOpen ? 'all 0.3s' : 'all 0.3s 0.1s'\n    };\n  },\n  outerContainer: function outerContainer(isOpen) {\n    return {\n      overflow: isOpen ? '' : 'hidden'\n    };\n  }\n};\nexports['default'] = (0, _menuFactory2['default'])(styles);\nmodule.exports = exports['default'];","window.eve = require('eve'); // Copyright (c) 2017 Adobe Systems Incorporated. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\nvar mina = function (eve) {\n  var animations = {},\n      requestAnimFrame = window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.oRequestAnimationFrame || window.msRequestAnimationFrame || function (callback) {\n    setTimeout(callback, 16, new Date().getTime());\n    return true;\n  },\n      requestID,\n      isArray = Array.isArray || function (a) {\n    return a instanceof Array || Object.prototype.toString.call(a) == \"[object Array]\";\n  },\n      idgen = 0,\n      idprefix = \"M\" + (+new Date()).toString(36),\n      ID = function ID() {\n    return idprefix + (idgen++).toString(36);\n  },\n      diff = function diff(a, b, A, B) {\n    if (isArray(a)) {\n      res = [];\n\n      for (var i = 0, ii = a.length; i < ii; i++) {\n        res[i] = diff(a[i], b, A[i], B);\n      }\n\n      return res;\n    }\n\n    var dif = (A - a) / (B - b);\n    return function (bb) {\n      return a + dif * (bb - b);\n    };\n  },\n      timer = Date.now || function () {\n    return +new Date();\n  },\n      sta = function sta(val) {\n    var a = this;\n\n    if (val == null) {\n      return a.s;\n    }\n\n    var ds = a.s - val;\n    a.b += a.dur * ds;\n    a.B += a.dur * ds;\n    a.s = val;\n  },\n      speed = function speed(val) {\n    var a = this;\n\n    if (val == null) {\n      return a.spd;\n    }\n\n    a.spd = val;\n  },\n      duration = function duration(val) {\n    var a = this;\n\n    if (val == null) {\n      return a.dur;\n    }\n\n    a.s = a.s * val / a.dur;\n    a.dur = val;\n  },\n      stopit = function stopit() {\n    var a = this;\n    delete animations[a.id];\n    a.update();\n    eve(\"mina.stop.\" + a.id, a);\n  },\n      pause = function pause() {\n    var a = this;\n\n    if (a.pdif) {\n      return;\n    }\n\n    delete animations[a.id];\n    a.update();\n    a.pdif = a.get() - a.b;\n  },\n      resume = function resume() {\n    var a = this;\n\n    if (!a.pdif) {\n      return;\n    }\n\n    a.b = a.get() - a.pdif;\n    delete a.pdif;\n    animations[a.id] = a;\n    frame();\n  },\n      update = function update() {\n    var a = this,\n        res;\n\n    if (isArray(a.start)) {\n      res = [];\n\n      for (var j = 0, jj = a.start.length; j < jj; j++) {\n        res[j] = +a.start[j] + (a.end[j] - a.start[j]) * a.easing(a.s);\n      }\n    } else {\n      res = +a.start + (a.end - a.start) * a.easing(a.s);\n    }\n\n    a.set(res);\n  },\n      frame = function frame(timeStamp) {\n    // Manual invokation?\n    if (!timeStamp) {\n      // Frame loop stopped?\n      if (!requestID) {\n        // Start frame loop...\n        requestID = requestAnimFrame(frame);\n      }\n\n      return;\n    }\n\n    var len = 0;\n\n    for (var i in animations) {\n      if (animations.hasOwnProperty(i)) {\n        var a = animations[i],\n            b = a.get(),\n            res;\n        len++;\n        a.s = (b - a.b) / (a.dur / a.spd);\n\n        if (a.s >= 1) {\n          delete animations[i];\n          a.s = 1;\n          len--;\n\n          (function (a) {\n            setTimeout(function () {\n              eve(\"mina.finish.\" + a.id, a);\n            });\n          })(a);\n        }\n\n        a.update();\n      }\n    }\n\n    requestID = len ? requestAnimFrame(frame) : false;\n  },\n\n  /*\\\n   * mina\n   [ method ]\n   **\n   * Generic animation of numbers\n   **\n   - a (number) start _slave_ number\n   - A (number) end _slave_ number\n   - b (number) start _master_ number (start time in general case)\n   - B (number) end _master_ number (end time in general case)\n   - get (function) getter of _master_ number (see @mina.time)\n   - set (function) setter of _slave_ number\n   - easing (function) #optional easing function, default is @mina.linear\n   = (object) animation descriptor\n   o {\n   o         id (string) animation id,\n   o         start (number) start _slave_ number,\n   o         end (number) end _slave_ number,\n   o         b (number) start _master_ number,\n   o         s (number) animation status (0..1),\n   o         dur (number) animation duration,\n   o         spd (number) animation speed,\n   o         get (function) getter of _master_ number (see @mina.time),\n   o         set (function) setter of _slave_ number,\n   o         easing (function) easing function, default is @mina.linear,\n   o         status (function) status getter/setter,\n   o         speed (function) speed getter/setter,\n   o         duration (function) duration getter/setter,\n   o         stop (function) animation stopper\n   o         pause (function) pauses the animation\n   o         resume (function) resumes the animation\n   o         update (function) calles setter with the right value of the animation\n   o }\n  \\*/\n  mina = function mina(a, A, b, B, get, set, easing) {\n    var anim = {\n      id: ID(),\n      start: a,\n      end: A,\n      b: b,\n      s: 0,\n      dur: B - b,\n      spd: 1,\n      get: get,\n      set: set,\n      easing: easing || mina.linear,\n      status: sta,\n      speed: speed,\n      duration: duration,\n      stop: stopit,\n      pause: pause,\n      resume: resume,\n      update: update\n    };\n    animations[anim.id] = anim;\n    var len = 0,\n        i;\n\n    for (i in animations) {\n      if (animations.hasOwnProperty(i)) {\n        len++;\n\n        if (len == 2) {\n          break;\n        }\n      }\n    }\n\n    len == 1 && frame();\n    return anim;\n  };\n  /*\\\n   * mina.time\n   [ method ]\n   **\n   * Returns the current time. Equivalent to:\n   | function () {\n   |     return (new Date).getTime();\n   | }\n  \\*/\n\n\n  mina.time = timer;\n  /*\\\n   * mina.getById\n   [ method ]\n   **\n   * Returns an animation by its id\n   - id (string) animation's id\n   = (object) See @mina\n  \\*/\n\n  mina.getById = function (id) {\n    return animations[id] || null;\n  };\n  /*\\\n   * mina.linear\n   [ method ]\n   **\n   * Default linear easing\n   - n (number) input 0..1\n   = (number) output 0..1\n  \\*/\n\n\n  mina.linear = function (n) {\n    return n;\n  };\n  /*\\\n   * mina.easeout\n   [ method ]\n   **\n   * Easeout easing\n   - n (number) input 0..1\n   = (number) output 0..1\n  \\*/\n\n\n  mina.easeout = function (n) {\n    return Math.pow(n, 1.7);\n  };\n  /*\\\n   * mina.easein\n   [ method ]\n   **\n   * Easein easing\n   - n (number) input 0..1\n   = (number) output 0..1\n  \\*/\n\n\n  mina.easein = function (n) {\n    return Math.pow(n, .48);\n  };\n  /*\\\n   * mina.easeinout\n   [ method ]\n   **\n   * Easeinout easing\n   - n (number) input 0..1\n   = (number) output 0..1\n  \\*/\n\n\n  mina.easeinout = function (n) {\n    if (n == 1) {\n      return 1;\n    }\n\n    if (n == 0) {\n      return 0;\n    }\n\n    var q = .48 - n / 1.04,\n        Q = Math.sqrt(.1734 + q * q),\n        x = Q - q,\n        X = Math.pow(Math.abs(x), 1 / 3) * (x < 0 ? -1 : 1),\n        y = -Q - q,\n        Y = Math.pow(Math.abs(y), 1 / 3) * (y < 0 ? -1 : 1),\n        t = X + Y + .5;\n    return (1 - t) * 3 * t * t + t * t * t;\n  };\n  /*\\\n   * mina.backin\n   [ method ]\n   **\n   * Backin easing\n   - n (number) input 0..1\n   = (number) output 0..1\n  \\*/\n\n\n  mina.backin = function (n) {\n    if (n == 1) {\n      return 1;\n    }\n\n    var s = 1.70158;\n    return n * n * ((s + 1) * n - s);\n  };\n  /*\\\n   * mina.backout\n   [ method ]\n   **\n   * Backout easing\n   - n (number) input 0..1\n   = (number) output 0..1\n  \\*/\n\n\n  mina.backout = function (n) {\n    if (n == 0) {\n      return 0;\n    }\n\n    n = n - 1;\n    var s = 1.70158;\n    return n * n * ((s + 1) * n + s) + 1;\n  };\n  /*\\\n   * mina.elastic\n   [ method ]\n   **\n   * Elastic easing\n   - n (number) input 0..1\n   = (number) output 0..1\n  \\*/\n\n\n  mina.elastic = function (n) {\n    if (n == !!n) {\n      return n;\n    }\n\n    return Math.pow(2, -10 * n) * Math.sin((n - .075) * (2 * Math.PI) / .3) + 1;\n  };\n  /*\\\n   * mina.bounce\n   [ method ]\n   **\n   * Bounce easing\n   - n (number) input 0..1\n   = (number) output 0..1\n  \\*/\n\n\n  mina.bounce = function (n) {\n    var s = 7.5625,\n        p = 2.75,\n        l;\n\n    if (n < 1 / p) {\n      l = s * n * n;\n    } else {\n      if (n < 2 / p) {\n        n -= 1.5 / p;\n        l = s * n * n + .75;\n      } else {\n        if (n < 2.5 / p) {\n          n -= 2.25 / p;\n          l = s * n * n + .9375;\n        } else {\n          n -= 2.625 / p;\n          l = s * n * n + .984375;\n        }\n      }\n    }\n\n    return l;\n  };\n\n  window.mina = mina;\n  return mina;\n}(typeof eve == \"undefined\" ? function () {} : eve); // Copyright (c) 2013 - 2017 Adobe Systems Incorporated. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n\nvar Snap = function (root) {\n  Snap.version = \"0.5.1\";\n  /*\\\n   * Snap\n   [ method ]\n   **\n   * Creates a drawing surface or wraps existing SVG element.\n   **\n   - width (number|string) width of surface\n   - height (number|string) height of surface\n   * or\n   - DOM (SVGElement) element to be wrapped into Snap structure\n   * or\n   - array (array) array of elements (will return set of elements)\n   * or\n   - query (string) CSS query selector\n   = (object) @Element\n  \\*/\n\n  function Snap(w, h) {\n    if (w) {\n      if (w.nodeType) {\n        return wrap(w);\n      }\n\n      if (is(w, \"array\") && Snap.set) {\n        return Snap.set.apply(Snap, w);\n      }\n\n      if (w instanceof Element) {\n        return w;\n      }\n\n      if (h == null) {\n        try {\n          w = glob.doc.querySelector(String(w));\n          return wrap(w);\n        } catch (e) {\n          return null;\n        }\n      }\n    }\n\n    w = w == null ? \"100%\" : w;\n    h = h == null ? \"100%\" : h;\n    return new Paper(w, h);\n  }\n\n  Snap.toString = function () {\n    return \"Snap v\" + this.version;\n  };\n\n  Snap._ = {};\n  var glob = {\n    win: root.window,\n    doc: root.window.document\n  };\n  Snap._.glob = glob;\n\n  var has = \"hasOwnProperty\",\n      Str = String,\n      toFloat = parseFloat,\n      toInt = parseInt,\n      math = Math,\n      mmax = math.max,\n      mmin = math.min,\n      abs = math.abs,\n      pow = math.pow,\n      PI = math.PI,\n      round = math.round,\n      E = \"\",\n      S = \" \",\n      objectToString = Object.prototype.toString,\n      ISURL = /^url\\(['\"]?([^\\)]+?)['\"]?\\)$/i,\n      colourRegExp = /^\\s*((#[a-f\\d]{6})|(#[a-f\\d]{3})|rgba?\\(\\s*([\\d\\.]+%?\\s*,\\s*[\\d\\.]+%?\\s*,\\s*[\\d\\.]+%?(?:\\s*,\\s*[\\d\\.]+%?)?)\\s*\\)|hsba?\\(\\s*([\\d\\.]+(?:deg|\\xb0|%)?\\s*,\\s*[\\d\\.]+%?\\s*,\\s*[\\d\\.]+(?:%?\\s*,\\s*[\\d\\.]+)?%?)\\s*\\)|hsla?\\(\\s*([\\d\\.]+(?:deg|\\xb0|%)?\\s*,\\s*[\\d\\.]+%?\\s*,\\s*[\\d\\.]+(?:%?\\s*,\\s*[\\d\\.]+)?%?)\\s*\\))\\s*$/i,\n      bezierrg = /^(?:cubic-)?bezier\\(([^,]+),([^,]+),([^,]+),([^\\)]+)\\)/,\n      separator = Snap._.separator = /[,\\s]+/,\n      whitespace = /[\\s]/g,\n      commaSpaces = /[\\s]*,[\\s]*/,\n      hsrg = {\n    hs: 1,\n    rg: 1\n  },\n      pathCommand = /([a-z])[\\s,]*((-?\\d*\\.?\\d*(?:e[\\-+]?\\d+)?[\\s]*,?[\\s]*)+)/ig,\n      tCommand = /([rstm])[\\s,]*((-?\\d*\\.?\\d*(?:e[\\-+]?\\d+)?[\\s]*,?[\\s]*)+)/ig,\n      pathValues = /(-?\\d*\\.?\\d*(?:e[\\-+]?\\d+)?)[\\s]*,?[\\s]*/ig,\n      idgen = 0,\n      idprefix = \"S\" + (+new Date()).toString(36),\n      ID = function ID(el) {\n    return (el && el.type ? el.type : E) + idprefix + (idgen++).toString(36);\n  },\n      xlink = \"http://www.w3.org/1999/xlink\",\n      xmlns = \"http://www.w3.org/2000/svg\",\n      hub = {},\n\n  /*\\\n   * Snap.url\n   [ method ]\n   **\n   * Wraps path into `\"url('<path>')\"`.\n   - value (string) path\n   = (string) wrapped path\n  \\*/\n  URL = Snap.url = function (url) {\n    return \"url('#\" + url + \"')\";\n  };\n\n  function $(el, attr) {\n    if (attr) {\n      if (el == \"#text\") {\n        el = glob.doc.createTextNode(attr.text || attr[\"#text\"] || \"\");\n      }\n\n      if (el == \"#comment\") {\n        el = glob.doc.createComment(attr.text || attr[\"#text\"] || \"\");\n      }\n\n      if (typeof el == \"string\") {\n        el = $(el);\n      }\n\n      if (typeof attr == \"string\") {\n        if (el.nodeType == 1) {\n          if (attr.substring(0, 6) == \"xlink:\") {\n            return el.getAttributeNS(xlink, attr.substring(6));\n          }\n\n          if (attr.substring(0, 4) == \"xml:\") {\n            return el.getAttributeNS(xmlns, attr.substring(4));\n          }\n\n          return el.getAttribute(attr);\n        } else if (attr == \"text\") {\n          return el.nodeValue;\n        } else {\n          return null;\n        }\n      }\n\n      if (el.nodeType == 1) {\n        for (var key in attr) {\n          if (attr[has](key)) {\n            var val = Str(attr[key]);\n\n            if (val) {\n              if (key.substring(0, 6) == \"xlink:\") {\n                el.setAttributeNS(xlink, key.substring(6), val);\n              } else if (key.substring(0, 4) == \"xml:\") {\n                el.setAttributeNS(xmlns, key.substring(4), val);\n              } else {\n                el.setAttribute(key, val);\n              }\n            } else {\n              el.removeAttribute(key);\n            }\n          }\n        }\n      } else if (\"text\" in attr) {\n        el.nodeValue = attr.text;\n      }\n    } else {\n      el = glob.doc.createElementNS(xmlns, el);\n    }\n\n    return el;\n  }\n\n  Snap._.$ = $;\n  Snap._.id = ID;\n\n  function getAttrs(el) {\n    var attrs = el.attributes,\n        name,\n        out = {};\n\n    for (var i = 0; i < attrs.length; i++) {\n      if (attrs[i].namespaceURI == xlink) {\n        name = \"xlink:\";\n      } else {\n        name = \"\";\n      }\n\n      name += attrs[i].name;\n      out[name] = attrs[i].textContent;\n    }\n\n    return out;\n  }\n\n  function is(o, type) {\n    type = Str.prototype.toLowerCase.call(type);\n\n    if (type == \"finite\") {\n      return isFinite(o);\n    }\n\n    if (type == \"array\" && (o instanceof Array || Array.isArray && Array.isArray(o))) {\n      return true;\n    }\n\n    return type == \"null\" && o === null || type == typeof o && o !== null || type == \"object\" && o === Object(o) || objectToString.call(o).slice(8, -1).toLowerCase() == type;\n  }\n  /*\\\n   * Snap.format\n   [ method ]\n   **\n   * Replaces construction of type `{<name>}` to the corresponding argument\n   **\n   - token (string) string to format\n   - json (object) object which properties are used as a replacement\n   = (string) formatted string\n   > Usage\n   | // this draws a rectangular shape equivalent to \"M10,20h40v50h-40z\"\n   | paper.path(Snap.format(\"M{x},{y}h{dim.width}v{dim.height}h{dim['negative width']}z\", {\n   |     x: 10,\n   |     y: 20,\n   |     dim: {\n   |         width: 40,\n   |         height: 50,\n   |         \"negative width\": -40\n   |     }\n   | }));\n  \\*/\n\n\n  Snap.format = function () {\n    var tokenRegex = /\\{([^\\}]+)\\}/g,\n        objNotationRegex = /(?:(?:^|\\.)(.+?)(?=\\[|\\.|$|\\()|\\[('|\")(.+?)\\2\\])(\\(\\))?/g,\n        // matches .xxxxx or [\"xxxxx\"] to run over object properties\n    replacer = function replacer(all, key, obj) {\n      var res = obj;\n      key.replace(objNotationRegex, function (all, name, quote, quotedName, isFunc) {\n        name = name || quotedName;\n\n        if (res) {\n          if (name in res) {\n            res = res[name];\n          }\n\n          typeof res == \"function\" && isFunc && (res = res());\n        }\n      });\n      res = (res == null || res == obj ? all : res) + \"\";\n      return res;\n    };\n\n    return function (str, obj) {\n      return Str(str).replace(tokenRegex, function (all, key) {\n        return replacer(all, key, obj);\n      });\n    };\n  }();\n\n  function clone(obj) {\n    if (typeof obj == \"function\" || Object(obj) !== obj) {\n      return obj;\n    }\n\n    var res = new obj.constructor();\n\n    for (var key in obj) {\n      if (obj[has](key)) {\n        res[key] = clone(obj[key]);\n      }\n    }\n\n    return res;\n  }\n\n  Snap._.clone = clone;\n\n  function repush(array, item) {\n    for (var i = 0, ii = array.length; i < ii; i++) {\n      if (array[i] === item) {\n        return array.push(array.splice(i, 1)[0]);\n      }\n    }\n  }\n\n  function cacher(f, scope, postprocessor) {\n    function newf() {\n      var arg = Array.prototype.slice.call(arguments, 0),\n          args = arg.join(\"\\u2400\"),\n          cache = newf.cache = newf.cache || {},\n          count = newf.count = newf.count || [];\n\n      if (cache[has](args)) {\n        repush(count, args);\n        return postprocessor ? postprocessor(cache[args]) : cache[args];\n      }\n\n      count.length >= 1e3 && delete cache[count.shift()];\n      count.push(args);\n      cache[args] = f.apply(scope, arg);\n      return postprocessor ? postprocessor(cache[args]) : cache[args];\n    }\n\n    return newf;\n  }\n\n  Snap._.cacher = cacher;\n\n  function angle(x1, y1, x2, y2, x3, y3) {\n    if (x3 == null) {\n      var x = x1 - x2,\n          y = y1 - y2;\n\n      if (!x && !y) {\n        return 0;\n      }\n\n      return (180 + math.atan2(-y, -x) * 180 / PI + 360) % 360;\n    } else {\n      return angle(x1, y1, x3, y3) - angle(x2, y2, x3, y3);\n    }\n  }\n\n  function rad(deg) {\n    return deg % 360 * PI / 180;\n  }\n\n  function deg(rad) {\n    return rad * 180 / PI % 360;\n  }\n\n  function x_y() {\n    return this.x + S + this.y;\n  }\n\n  function x_y_w_h() {\n    return this.x + S + this.y + S + this.width + \" \\xd7 \" + this.height;\n  }\n  /*\\\n   * Snap.rad\n   [ method ]\n   **\n   * Transform angle to radians\n   - deg (number) angle in degrees\n   = (number) angle in radians\n  \\*/\n\n\n  Snap.rad = rad;\n  /*\\\n   * Snap.deg\n   [ method ]\n   **\n   * Transform angle to degrees\n   - rad (number) angle in radians\n   = (number) angle in degrees\n  \\*/\n\n  Snap.deg = deg;\n  /*\\\n   * Snap.sin\n   [ method ]\n   **\n   * Equivalent to `Math.sin()` only works with degrees, not radians.\n   - angle (number) angle in degrees\n   = (number) sin\n  \\*/\n\n  Snap.sin = function (angle) {\n    return math.sin(Snap.rad(angle));\n  };\n  /*\\\n   * Snap.tan\n   [ method ]\n   **\n   * Equivalent to `Math.tan()` only works with degrees, not radians.\n   - angle (number) angle in degrees\n   = (number) tan\n  \\*/\n\n\n  Snap.tan = function (angle) {\n    return math.tan(Snap.rad(angle));\n  };\n  /*\\\n   * Snap.cos\n   [ method ]\n   **\n   * Equivalent to `Math.cos()` only works with degrees, not radians.\n   - angle (number) angle in degrees\n   = (number) cos\n  \\*/\n\n\n  Snap.cos = function (angle) {\n    return math.cos(Snap.rad(angle));\n  };\n  /*\\\n   * Snap.asin\n   [ method ]\n   **\n   * Equivalent to `Math.asin()` only works with degrees, not radians.\n   - num (number) value\n   = (number) asin in degrees\n  \\*/\n\n\n  Snap.asin = function (num) {\n    return Snap.deg(math.asin(num));\n  };\n  /*\\\n   * Snap.acos\n   [ method ]\n   **\n   * Equivalent to `Math.acos()` only works with degrees, not radians.\n   - num (number) value\n   = (number) acos in degrees\n  \\*/\n\n\n  Snap.acos = function (num) {\n    return Snap.deg(math.acos(num));\n  };\n  /*\\\n   * Snap.atan\n   [ method ]\n   **\n   * Equivalent to `Math.atan()` only works with degrees, not radians.\n   - num (number) value\n   = (number) atan in degrees\n  \\*/\n\n\n  Snap.atan = function (num) {\n    return Snap.deg(math.atan(num));\n  };\n  /*\\\n   * Snap.atan2\n   [ method ]\n   **\n   * Equivalent to `Math.atan2()` only works with degrees, not radians.\n   - num (number) value\n   = (number) atan2 in degrees\n  \\*/\n\n\n  Snap.atan2 = function (num) {\n    return Snap.deg(math.atan2(num));\n  };\n  /*\\\n   * Snap.angle\n   [ method ]\n   **\n   * Returns an angle between two or three points\n   - x1 (number) x coord of first point\n   - y1 (number) y coord of first point\n   - x2 (number) x coord of second point\n   - y2 (number) y coord of second point\n   - x3 (number) #optional x coord of third point\n   - y3 (number) #optional y coord of third point\n   = (number) angle in degrees\n  \\*/\n\n\n  Snap.angle = angle;\n  /*\\\n   * Snap.len\n   [ method ]\n   **\n   * Returns distance between two points\n   - x1 (number) x coord of first point\n   - y1 (number) y coord of first point\n   - x2 (number) x coord of second point\n   - y2 (number) y coord of second point\n   = (number) distance\n  \\*/\n\n  Snap.len = function (x1, y1, x2, y2) {\n    return Math.sqrt(Snap.len2(x1, y1, x2, y2));\n  };\n  /*\\\n   * Snap.len2\n   [ method ]\n   **\n   * Returns squared distance between two points\n   - x1 (number) x coord of first point\n   - y1 (number) y coord of first point\n   - x2 (number) x coord of second point\n   - y2 (number) y coord of second point\n   = (number) distance\n  \\*/\n\n\n  Snap.len2 = function (x1, y1, x2, y2) {\n    return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);\n  };\n  /*\\\n   * Snap.closestPoint\n   [ method ]\n   **\n   * Returns closest point to a given one on a given path.\n   - path (Element) path element\n   - x (number) x coord of a point\n   - y (number) y coord of a point\n   = (object) in format\n   {\n      x (number) x coord of the point on the path\n      y (number) y coord of the point on the path\n      length (number) length of the path to the point\n      distance (number) distance from the given point to the path\n   }\n  \\*/\n  // Copied from http://bl.ocks.org/mbostock/8027637\n\n\n  Snap.closestPoint = function (path, x, y) {\n    function distance2(p) {\n      var dx = p.x - x,\n          dy = p.y - y;\n      return dx * dx + dy * dy;\n    }\n\n    var pathNode = path.node,\n        pathLength = pathNode.getTotalLength(),\n        precision = pathLength / pathNode.pathSegList.numberOfItems * .125,\n        best,\n        bestLength,\n        bestDistance = Infinity; // linear scan for coarse approximation\n\n    for (var scan, scanLength = 0, scanDistance; scanLength <= pathLength; scanLength += precision) {\n      if ((scanDistance = distance2(scan = pathNode.getPointAtLength(scanLength))) < bestDistance) {\n        best = scan;\n        bestLength = scanLength;\n        bestDistance = scanDistance;\n      }\n    } // binary search for precise estimate\n\n\n    precision *= .5;\n\n    while (precision > .5) {\n      var before, after, beforeLength, afterLength, beforeDistance, afterDistance;\n\n      if ((beforeLength = bestLength - precision) >= 0 && (beforeDistance = distance2(before = pathNode.getPointAtLength(beforeLength))) < bestDistance) {\n        best = before;\n        bestLength = beforeLength;\n        bestDistance = beforeDistance;\n      } else if ((afterLength = bestLength + precision) <= pathLength && (afterDistance = distance2(after = pathNode.getPointAtLength(afterLength))) < bestDistance) {\n        best = after;\n        bestLength = afterLength;\n        bestDistance = afterDistance;\n      } else {\n        precision *= .5;\n      }\n    }\n\n    best = {\n      x: best.x,\n      y: best.y,\n      length: bestLength,\n      distance: Math.sqrt(bestDistance)\n    };\n    return best;\n  };\n  /*\\\n   * Snap.is\n   [ method ]\n   **\n   * Handy replacement for the `typeof` operator\n   - o (…) any object or primitive\n   - type (string) name of the type, e.g., `string`, `function`, `number`, etc.\n   = (boolean) `true` if given value is of given type\n  \\*/\n\n\n  Snap.is = is;\n  /*\\\n   * Snap.snapTo\n   [ method ]\n   **\n   * Snaps given value to given grid\n   - values (array|number) given array of values or step of the grid\n   - value (number) value to adjust\n   - tolerance (number) #optional maximum distance to the target value that would trigger the snap. Default is `10`.\n   = (number) adjusted value\n  \\*/\n\n  Snap.snapTo = function (values, value, tolerance) {\n    tolerance = is(tolerance, \"finite\") ? tolerance : 10;\n\n    if (is(values, \"array\")) {\n      var i = values.length;\n\n      while (i--) {\n        if (abs(values[i] - value) <= tolerance) {\n          return values[i];\n        }\n      }\n    } else {\n      values = +values;\n      var rem = value % values;\n\n      if (rem < tolerance) {\n        return value - rem;\n      }\n\n      if (rem > values - tolerance) {\n        return value - rem + values;\n      }\n    }\n\n    return value;\n  }; // Colour\n\n  /*\\\n   * Snap.getRGB\n   [ method ]\n   **\n   * Parses color string as RGB object\n   - color (string) color string in one of the following formats:\n   # <ul>\n   #     <li>Color name (<code>red</code>, <code>green</code>, <code>cornflowerblue</code>, etc)</li>\n   #     <li>#••• — shortened HTML color: (<code>#000</code>, <code>#fc0</code>, etc.)</li>\n   #     <li>#•••••• — full length HTML color: (<code>#000000</code>, <code>#bd2300</code>)</li>\n   #     <li>rgb(•••, •••, •••) — red, green and blue channels values: (<code>rgb(200,&nbsp;100,&nbsp;0)</code>)</li>\n   #     <li>rgba(•••, •••, •••, •••) — also with opacity</li>\n   #     <li>rgb(•••%, •••%, •••%) — same as above, but in %: (<code>rgb(100%,&nbsp;175%,&nbsp;0%)</code>)</li>\n   #     <li>rgba(•••%, •••%, •••%, •••%) — also with opacity</li>\n   #     <li>hsb(•••, •••, •••) — hue, saturation and brightness values: (<code>hsb(0.5,&nbsp;0.25,&nbsp;1)</code>)</li>\n   #     <li>hsba(•••, •••, •••, •••) — also with opacity</li>\n   #     <li>hsb(•••%, •••%, •••%) — same as above, but in %</li>\n   #     <li>hsba(•••%, •••%, •••%, •••%) — also with opacity</li>\n   #     <li>hsl(•••, •••, •••) — hue, saturation and luminosity values: (<code>hsb(0.5,&nbsp;0.25,&nbsp;0.5)</code>)</li>\n   #     <li>hsla(•••, •••, •••, •••) — also with opacity</li>\n   #     <li>hsl(•••%, •••%, •••%) — same as above, but in %</li>\n   #     <li>hsla(•••%, •••%, •••%, •••%) — also with opacity</li>\n   # </ul>\n   * Note that `%` can be used any time: `rgb(20%, 255, 50%)`.\n   = (object) RGB object in the following format:\n   o {\n   o     r (number) red,\n   o     g (number) green,\n   o     b (number) blue,\n   o     hex (string) color in HTML/CSS format: #••••••,\n   o     error (boolean) true if string can't be parsed\n   o }\n  \\*/\n\n\n  Snap.getRGB = cacher(function (colour) {\n    if (!colour || !!((colour = Str(colour)).indexOf(\"-\") + 1)) {\n      return {\n        r: -1,\n        g: -1,\n        b: -1,\n        hex: \"none\",\n        error: 1,\n        toString: rgbtoString\n      };\n    }\n\n    if (colour == \"none\") {\n      return {\n        r: -1,\n        g: -1,\n        b: -1,\n        hex: \"none\",\n        toString: rgbtoString\n      };\n    }\n\n    !(hsrg[has](colour.toLowerCase().substring(0, 2)) || colour.charAt() == \"#\") && (colour = _toHex(colour));\n\n    if (!colour) {\n      return {\n        r: -1,\n        g: -1,\n        b: -1,\n        hex: \"none\",\n        error: 1,\n        toString: rgbtoString\n      };\n    }\n\n    var res,\n        red,\n        green,\n        blue,\n        opacity,\n        t,\n        values,\n        rgb = colour.match(colourRegExp);\n\n    if (rgb) {\n      if (rgb[2]) {\n        blue = toInt(rgb[2].substring(5), 16);\n        green = toInt(rgb[2].substring(3, 5), 16);\n        red = toInt(rgb[2].substring(1, 3), 16);\n      }\n\n      if (rgb[3]) {\n        blue = toInt((t = rgb[3].charAt(3)) + t, 16);\n        green = toInt((t = rgb[3].charAt(2)) + t, 16);\n        red = toInt((t = rgb[3].charAt(1)) + t, 16);\n      }\n\n      if (rgb[4]) {\n        values = rgb[4].split(commaSpaces);\n        red = toFloat(values[0]);\n        values[0].slice(-1) == \"%\" && (red *= 2.55);\n        green = toFloat(values[1]);\n        values[1].slice(-1) == \"%\" && (green *= 2.55);\n        blue = toFloat(values[2]);\n        values[2].slice(-1) == \"%\" && (blue *= 2.55);\n        rgb[1].toLowerCase().slice(0, 4) == \"rgba\" && (opacity = toFloat(values[3]));\n        values[3] && values[3].slice(-1) == \"%\" && (opacity /= 100);\n      }\n\n      if (rgb[5]) {\n        values = rgb[5].split(commaSpaces);\n        red = toFloat(values[0]);\n        values[0].slice(-1) == \"%\" && (red /= 100);\n        green = toFloat(values[1]);\n        values[1].slice(-1) == \"%\" && (green /= 100);\n        blue = toFloat(values[2]);\n        values[2].slice(-1) == \"%\" && (blue /= 100);\n        (values[0].slice(-3) == \"deg\" || values[0].slice(-1) == \"\\xb0\") && (red /= 360);\n        rgb[1].toLowerCase().slice(0, 4) == \"hsba\" && (opacity = toFloat(values[3]));\n        values[3] && values[3].slice(-1) == \"%\" && (opacity /= 100);\n        return Snap.hsb2rgb(red, green, blue, opacity);\n      }\n\n      if (rgb[6]) {\n        values = rgb[6].split(commaSpaces);\n        red = toFloat(values[0]);\n        values[0].slice(-1) == \"%\" && (red /= 100);\n        green = toFloat(values[1]);\n        values[1].slice(-1) == \"%\" && (green /= 100);\n        blue = toFloat(values[2]);\n        values[2].slice(-1) == \"%\" && (blue /= 100);\n        (values[0].slice(-3) == \"deg\" || values[0].slice(-1) == \"\\xb0\") && (red /= 360);\n        rgb[1].toLowerCase().slice(0, 4) == \"hsla\" && (opacity = toFloat(values[3]));\n        values[3] && values[3].slice(-1) == \"%\" && (opacity /= 100);\n        return Snap.hsl2rgb(red, green, blue, opacity);\n      }\n\n      red = mmin(math.round(red), 255);\n      green = mmin(math.round(green), 255);\n      blue = mmin(math.round(blue), 255);\n      opacity = mmin(mmax(opacity, 0), 1);\n      rgb = {\n        r: red,\n        g: green,\n        b: blue,\n        toString: rgbtoString\n      };\n      rgb.hex = \"#\" + (16777216 | blue | green << 8 | red << 16).toString(16).slice(1);\n      rgb.opacity = is(opacity, \"finite\") ? opacity : 1;\n      return rgb;\n    }\n\n    return {\n      r: -1,\n      g: -1,\n      b: -1,\n      hex: \"none\",\n      error: 1,\n      toString: rgbtoString\n    };\n  }, Snap);\n  /*\\\n   * Snap.hsb\n   [ method ]\n   **\n   * Converts HSB values to a hex representation of the color\n   - h (number) hue\n   - s (number) saturation\n   - b (number) value or brightness\n   = (string) hex representation of the color\n  \\*/\n\n  Snap.hsb = cacher(function (h, s, b) {\n    return Snap.hsb2rgb(h, s, b).hex;\n  });\n  /*\\\n   * Snap.hsl\n   [ method ]\n   **\n   * Converts HSL values to a hex representation of the color\n   - h (number) hue\n   - s (number) saturation\n   - l (number) luminosity\n   = (string) hex representation of the color\n  \\*/\n\n  Snap.hsl = cacher(function (h, s, l) {\n    return Snap.hsl2rgb(h, s, l).hex;\n  });\n  /*\\\n   * Snap.rgb\n   [ method ]\n   **\n   * Converts RGB values to a hex representation of the color\n   - r (number) red\n   - g (number) green\n   - b (number) blue\n   = (string) hex representation of the color\n  \\*/\n\n  Snap.rgb = cacher(function (r, g, b, o) {\n    if (is(o, \"finite\")) {\n      var round = math.round;\n      return \"rgba(\" + [round(r), round(g), round(b), +o.toFixed(2)] + \")\";\n    }\n\n    return \"#\" + (16777216 | b | g << 8 | r << 16).toString(16).slice(1);\n  });\n\n  var _toHex = function toHex(color) {\n    var i = glob.doc.getElementsByTagName(\"head\")[0] || glob.doc.getElementsByTagName(\"svg\")[0],\n        red = \"rgb(255, 0, 0)\";\n    _toHex = cacher(function (color) {\n      if (color.toLowerCase() == \"red\") {\n        return red;\n      }\n\n      i.style.color = red;\n      i.style.color = color;\n      var out = glob.doc.defaultView.getComputedStyle(i, E).getPropertyValue(\"color\");\n      return out == red ? null : out;\n    });\n    return _toHex(color);\n  },\n      hsbtoString = function hsbtoString() {\n    return \"hsb(\" + [this.h, this.s, this.b] + \")\";\n  },\n      hsltoString = function hsltoString() {\n    return \"hsl(\" + [this.h, this.s, this.l] + \")\";\n  },\n      rgbtoString = function rgbtoString() {\n    return this.opacity == 1 || this.opacity == null ? this.hex : \"rgba(\" + [this.r, this.g, this.b, this.opacity] + \")\";\n  },\n      prepareRGB = function prepareRGB(r, g, b) {\n    if (g == null && is(r, \"object\") && \"r\" in r && \"g\" in r && \"b\" in r) {\n      b = r.b;\n      g = r.g;\n      r = r.r;\n    }\n\n    if (g == null && is(r, string)) {\n      var clr = Snap.getRGB(r);\n      r = clr.r;\n      g = clr.g;\n      b = clr.b;\n    }\n\n    if (r > 1 || g > 1 || b > 1) {\n      r /= 255;\n      g /= 255;\n      b /= 255;\n    }\n\n    return [r, g, b];\n  },\n      packageRGB = function packageRGB(r, g, b, o) {\n    r = math.round(r * 255);\n    g = math.round(g * 255);\n    b = math.round(b * 255);\n    var rgb = {\n      r: r,\n      g: g,\n      b: b,\n      opacity: is(o, \"finite\") ? o : 1,\n      hex: Snap.rgb(r, g, b),\n      toString: rgbtoString\n    };\n    is(o, \"finite\") && (rgb.opacity = o);\n    return rgb;\n  };\n  /*\\\n   * Snap.color\n   [ method ]\n   **\n   * Parses the color string and returns an object featuring the color's component values\n   - clr (string) color string in one of the supported formats (see @Snap.getRGB)\n   = (object) Combined RGB/HSB object in the following format:\n   o {\n   o     r (number) red,\n   o     g (number) green,\n   o     b (number) blue,\n   o     hex (string) color in HTML/CSS format: #••••••,\n   o     error (boolean) `true` if string can't be parsed,\n   o     h (number) hue,\n   o     s (number) saturation,\n   o     v (number) value (brightness),\n   o     l (number) lightness\n   o }\n  \\*/\n\n\n  Snap.color = function (clr) {\n    var rgb;\n\n    if (is(clr, \"object\") && \"h\" in clr && \"s\" in clr && \"b\" in clr) {\n      rgb = Snap.hsb2rgb(clr);\n      clr.r = rgb.r;\n      clr.g = rgb.g;\n      clr.b = rgb.b;\n      clr.opacity = 1;\n      clr.hex = rgb.hex;\n    } else if (is(clr, \"object\") && \"h\" in clr && \"s\" in clr && \"l\" in clr) {\n      rgb = Snap.hsl2rgb(clr);\n      clr.r = rgb.r;\n      clr.g = rgb.g;\n      clr.b = rgb.b;\n      clr.opacity = 1;\n      clr.hex = rgb.hex;\n    } else {\n      if (is(clr, \"string\")) {\n        clr = Snap.getRGB(clr);\n      }\n\n      if (is(clr, \"object\") && \"r\" in clr && \"g\" in clr && \"b\" in clr && !(\"error\" in clr)) {\n        rgb = Snap.rgb2hsl(clr);\n        clr.h = rgb.h;\n        clr.s = rgb.s;\n        clr.l = rgb.l;\n        rgb = Snap.rgb2hsb(clr);\n        clr.v = rgb.b;\n      } else {\n        clr = {\n          hex: \"none\"\n        };\n        clr.r = clr.g = clr.b = clr.h = clr.s = clr.v = clr.l = -1;\n        clr.error = 1;\n      }\n    }\n\n    clr.toString = rgbtoString;\n    return clr;\n  };\n  /*\\\n   * Snap.hsb2rgb\n   [ method ]\n   **\n   * Converts HSB values to an RGB object\n   - h (number) hue\n   - s (number) saturation\n   - v (number) value or brightness\n   = (object) RGB object in the following format:\n   o {\n   o     r (number) red,\n   o     g (number) green,\n   o     b (number) blue,\n   o     hex (string) color in HTML/CSS format: #••••••\n   o }\n  \\*/\n\n\n  Snap.hsb2rgb = function (h, s, v, o) {\n    if (is(h, \"object\") && \"h\" in h && \"s\" in h && \"b\" in h) {\n      v = h.b;\n      s = h.s;\n      o = h.o;\n      h = h.h;\n    }\n\n    h *= 360;\n    var R, G, B, X, C;\n    h = h % 360 / 60;\n    C = v * s;\n    X = C * (1 - abs(h % 2 - 1));\n    R = G = B = v - C;\n    h = ~~h;\n    R += [C, X, 0, 0, X, C][h];\n    G += [X, C, C, X, 0, 0][h];\n    B += [0, 0, X, C, C, X][h];\n    return packageRGB(R, G, B, o);\n  };\n  /*\\\n   * Snap.hsl2rgb\n   [ method ]\n   **\n   * Converts HSL values to an RGB object\n   - h (number) hue\n   - s (number) saturation\n   - l (number) luminosity\n   = (object) RGB object in the following format:\n   o {\n   o     r (number) red,\n   o     g (number) green,\n   o     b (number) blue,\n   o     hex (string) color in HTML/CSS format: #••••••\n   o }\n  \\*/\n\n\n  Snap.hsl2rgb = function (h, s, l, o) {\n    if (is(h, \"object\") && \"h\" in h && \"s\" in h && \"l\" in h) {\n      l = h.l;\n      s = h.s;\n      h = h.h;\n    }\n\n    if (h > 1 || s > 1 || l > 1) {\n      h /= 360;\n      s /= 100;\n      l /= 100;\n    }\n\n    h *= 360;\n    var R, G, B, X, C;\n    h = h % 360 / 60;\n    C = 2 * s * (l < .5 ? l : 1 - l);\n    X = C * (1 - abs(h % 2 - 1));\n    R = G = B = l - C / 2;\n    h = ~~h;\n    R += [C, X, 0, 0, X, C][h];\n    G += [X, C, C, X, 0, 0][h];\n    B += [0, 0, X, C, C, X][h];\n    return packageRGB(R, G, B, o);\n  };\n  /*\\\n   * Snap.rgb2hsb\n   [ method ]\n   **\n   * Converts RGB values to an HSB object\n   - r (number) red\n   - g (number) green\n   - b (number) blue\n   = (object) HSB object in the following format:\n   o {\n   o     h (number) hue,\n   o     s (number) saturation,\n   o     b (number) brightness\n   o }\n  \\*/\n\n\n  Snap.rgb2hsb = function (r, g, b) {\n    b = prepareRGB(r, g, b);\n    r = b[0];\n    g = b[1];\n    b = b[2];\n    var H, S, V, C;\n    V = mmax(r, g, b);\n    C = V - mmin(r, g, b);\n    H = C == 0 ? null : V == r ? (g - b) / C : V == g ? (b - r) / C + 2 : (r - g) / C + 4;\n    H = (H + 360) % 6 * 60 / 360;\n    S = C == 0 ? 0 : C / V;\n    return {\n      h: H,\n      s: S,\n      b: V,\n      toString: hsbtoString\n    };\n  };\n  /*\\\n   * Snap.rgb2hsl\n   [ method ]\n   **\n   * Converts RGB values to an HSL object\n   - r (number) red\n   - g (number) green\n   - b (number) blue\n   = (object) HSL object in the following format:\n   o {\n   o     h (number) hue,\n   o     s (number) saturation,\n   o     l (number) luminosity\n   o }\n  \\*/\n\n\n  Snap.rgb2hsl = function (r, g, b) {\n    b = prepareRGB(r, g, b);\n    r = b[0];\n    g = b[1];\n    b = b[2];\n    var H, S, L, M, m, C;\n    M = mmax(r, g, b);\n    m = mmin(r, g, b);\n    C = M - m;\n    H = C == 0 ? null : M == r ? (g - b) / C : M == g ? (b - r) / C + 2 : (r - g) / C + 4;\n    H = (H + 360) % 6 * 60 / 360;\n    L = (M + m) / 2;\n    S = C == 0 ? 0 : L < .5 ? C / (2 * L) : C / (2 - 2 * L);\n    return {\n      h: H,\n      s: S,\n      l: L,\n      toString: hsltoString\n    };\n  }; // Transformations\n\n  /*\\\n   * Snap.parsePathString\n   [ method ]\n   **\n   * Utility method\n   **\n   * Parses given path string into an array of arrays of path segments\n   - pathString (string|array) path string or array of segments (in the last case it is returned straight away)\n   = (array) array of segments\n  \\*/\n\n\n  Snap.parsePathString = function (pathString) {\n    if (!pathString) {\n      return null;\n    }\n\n    var pth = Snap.path(pathString);\n\n    if (pth.arr) {\n      return Snap.path.clone(pth.arr);\n    }\n\n    var paramCounts = {\n      a: 7,\n      c: 6,\n      o: 2,\n      h: 1,\n      l: 2,\n      m: 2,\n      r: 4,\n      q: 4,\n      s: 4,\n      t: 2,\n      v: 1,\n      u: 3,\n      z: 0\n    },\n        data = [];\n\n    if (is(pathString, \"array\") && is(pathString[0], \"array\")) {\n      // rough assumption\n      data = Snap.path.clone(pathString);\n    }\n\n    if (!data.length) {\n      Str(pathString).replace(pathCommand, function (a, b, c) {\n        var params = [],\n            name = b.toLowerCase();\n        c.replace(pathValues, function (a, b) {\n          b && params.push(+b);\n        });\n\n        if (name == \"m\" && params.length > 2) {\n          data.push([b].concat(params.splice(0, 2)));\n          name = \"l\";\n          b = b == \"m\" ? \"l\" : \"L\";\n        }\n\n        if (name == \"o\" && params.length == 1) {\n          data.push([b, params[0]]);\n        }\n\n        if (name == \"r\") {\n          data.push([b].concat(params));\n        } else while (params.length >= paramCounts[name]) {\n          data.push([b].concat(params.splice(0, paramCounts[name])));\n\n          if (!paramCounts[name]) {\n            break;\n          }\n        }\n      });\n    }\n\n    data.toString = Snap.path.toString;\n    pth.arr = Snap.path.clone(data);\n    return data;\n  };\n  /*\\\n   * Snap.parseTransformString\n   [ method ]\n   **\n   * Utility method\n   **\n   * Parses given transform string into an array of transformations\n   - TString (string|array) transform string or array of transformations (in the last case it is returned straight away)\n   = (array) array of transformations\n  \\*/\n\n\n  var parseTransformString = Snap.parseTransformString = function (TString) {\n    if (!TString) {\n      return null;\n    }\n\n    var paramCounts = {\n      r: 3,\n      s: 4,\n      t: 2,\n      m: 6\n    },\n        data = [];\n\n    if (is(TString, \"array\") && is(TString[0], \"array\")) {\n      // rough assumption\n      data = Snap.path.clone(TString);\n    }\n\n    if (!data.length) {\n      Str(TString).replace(tCommand, function (a, b, c) {\n        var params = [],\n            name = b.toLowerCase();\n        c.replace(pathValues, function (a, b) {\n          b && params.push(+b);\n        });\n        data.push([b].concat(params));\n      });\n    }\n\n    data.toString = Snap.path.toString;\n    return data;\n  };\n\n  function svgTransform2string(tstr) {\n    var res = [];\n    tstr = tstr.replace(/(?:^|\\s)(\\w+)\\(([^)]+)\\)/g, function (all, name, params) {\n      params = params.split(/\\s*,\\s*|\\s+/);\n\n      if (name == \"rotate\" && params.length == 1) {\n        params.push(0, 0);\n      }\n\n      if (name == \"scale\") {\n        if (params.length > 2) {\n          params = params.slice(0, 2);\n        } else if (params.length == 2) {\n          params.push(0, 0);\n        }\n\n        if (params.length == 1) {\n          params.push(params[0], 0, 0);\n        }\n      }\n\n      if (name == \"skewX\") {\n        res.push([\"m\", 1, 0, math.tan(rad(params[0])), 1, 0, 0]);\n      } else if (name == \"skewY\") {\n        res.push([\"m\", 1, math.tan(rad(params[0])), 0, 1, 0, 0]);\n      } else {\n        res.push([name.charAt(0)].concat(params));\n      }\n\n      return all;\n    });\n    return res;\n  }\n\n  Snap._.svgTransform2string = svgTransform2string;\n  Snap._.rgTransform = /^[a-z][\\s]*-?\\.?\\d/i;\n\n  function transform2matrix(tstr, bbox) {\n    var tdata = parseTransformString(tstr),\n        m = new Snap.Matrix();\n\n    if (tdata) {\n      for (var i = 0, ii = tdata.length; i < ii; i++) {\n        var t = tdata[i],\n            tlen = t.length,\n            command = Str(t[0]).toLowerCase(),\n            absolute = t[0] != command,\n            inver = absolute ? m.invert() : 0,\n            x1,\n            y1,\n            x2,\n            y2,\n            bb;\n\n        if (command == \"t\" && tlen == 2) {\n          m.translate(t[1], 0);\n        } else if (command == \"t\" && tlen == 3) {\n          if (absolute) {\n            x1 = inver.x(0, 0);\n            y1 = inver.y(0, 0);\n            x2 = inver.x(t[1], t[2]);\n            y2 = inver.y(t[1], t[2]);\n            m.translate(x2 - x1, y2 - y1);\n          } else {\n            m.translate(t[1], t[2]);\n          }\n        } else if (command == \"r\") {\n          if (tlen == 2) {\n            bb = bb || bbox;\n            m.rotate(t[1], bb.x + bb.width / 2, bb.y + bb.height / 2);\n          } else if (tlen == 4) {\n            if (absolute) {\n              x2 = inver.x(t[2], t[3]);\n              y2 = inver.y(t[2], t[3]);\n              m.rotate(t[1], x2, y2);\n            } else {\n              m.rotate(t[1], t[2], t[3]);\n            }\n          }\n        } else if (command == \"s\") {\n          if (tlen == 2 || tlen == 3) {\n            bb = bb || bbox;\n            m.scale(t[1], t[tlen - 1], bb.x + bb.width / 2, bb.y + bb.height / 2);\n          } else if (tlen == 4) {\n            if (absolute) {\n              x2 = inver.x(t[2], t[3]);\n              y2 = inver.y(t[2], t[3]);\n              m.scale(t[1], t[1], x2, y2);\n            } else {\n              m.scale(t[1], t[1], t[2], t[3]);\n            }\n          } else if (tlen == 5) {\n            if (absolute) {\n              x2 = inver.x(t[3], t[4]);\n              y2 = inver.y(t[3], t[4]);\n              m.scale(t[1], t[2], x2, y2);\n            } else {\n              m.scale(t[1], t[2], t[3], t[4]);\n            }\n          }\n        } else if (command == \"m\" && tlen == 7) {\n          m.add(t[1], t[2], t[3], t[4], t[5], t[6]);\n        }\n      }\n    }\n\n    return m;\n  }\n\n  Snap._.transform2matrix = transform2matrix;\n  Snap._unit2px = unit2px;\n  var contains = glob.doc.contains || glob.doc.compareDocumentPosition ? function (a, b) {\n    var adown = a.nodeType == 9 ? a.documentElement : a,\n        bup = b && b.parentNode;\n    return a == bup || !!(bup && bup.nodeType == 1 && (adown.contains ? adown.contains(bup) : a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16));\n  } : function (a, b) {\n    if (b) {\n      while (b) {\n        b = b.parentNode;\n\n        if (b == a) {\n          return true;\n        }\n      }\n    }\n\n    return false;\n  };\n\n  function getSomeDefs(el) {\n    var p = el.node.ownerSVGElement && wrap(el.node.ownerSVGElement) || el.node.parentNode && wrap(el.node.parentNode) || Snap.select(\"svg\") || Snap(0, 0),\n        pdefs = p.select(\"defs\"),\n        defs = pdefs == null ? false : pdefs.node;\n\n    if (!defs) {\n      defs = make(\"defs\", p.node).node;\n    }\n\n    return defs;\n  }\n\n  function getSomeSVG(el) {\n    return el.node.ownerSVGElement && wrap(el.node.ownerSVGElement) || Snap.select(\"svg\");\n  }\n\n  Snap._.getSomeDefs = getSomeDefs;\n  Snap._.getSomeSVG = getSomeSVG;\n\n  function unit2px(el, name, value) {\n    var svg = getSomeSVG(el).node,\n        out = {},\n        mgr = svg.querySelector(\".svg---mgr\");\n\n    if (!mgr) {\n      mgr = $(\"rect\");\n      $(mgr, {\n        x: -9e9,\n        y: -9e9,\n        width: 10,\n        height: 10,\n        \"class\": \"svg---mgr\",\n        fill: \"none\"\n      });\n      svg.appendChild(mgr);\n    }\n\n    function getW(val) {\n      if (val == null) {\n        return E;\n      }\n\n      if (val == +val) {\n        return val;\n      }\n\n      $(mgr, {\n        width: val\n      });\n\n      try {\n        return mgr.getBBox().width;\n      } catch (e) {\n        return 0;\n      }\n    }\n\n    function getH(val) {\n      if (val == null) {\n        return E;\n      }\n\n      if (val == +val) {\n        return val;\n      }\n\n      $(mgr, {\n        height: val\n      });\n\n      try {\n        return mgr.getBBox().height;\n      } catch (e) {\n        return 0;\n      }\n    }\n\n    function set(nam, f) {\n      if (name == null) {\n        out[nam] = f(el.attr(nam) || 0);\n      } else if (nam == name) {\n        out = f(value == null ? el.attr(nam) || 0 : value);\n      }\n    }\n\n    switch (el.type) {\n      case \"rect\":\n        set(\"rx\", getW);\n        set(\"ry\", getH);\n\n      case \"image\":\n        set(\"width\", getW);\n        set(\"height\", getH);\n\n      case \"text\":\n        set(\"x\", getW);\n        set(\"y\", getH);\n        break;\n\n      case \"circle\":\n        set(\"cx\", getW);\n        set(\"cy\", getH);\n        set(\"r\", getW);\n        break;\n\n      case \"ellipse\":\n        set(\"cx\", getW);\n        set(\"cy\", getH);\n        set(\"rx\", getW);\n        set(\"ry\", getH);\n        break;\n\n      case \"line\":\n        set(\"x1\", getW);\n        set(\"x2\", getW);\n        set(\"y1\", getH);\n        set(\"y2\", getH);\n        break;\n\n      case \"marker\":\n        set(\"refX\", getW);\n        set(\"markerWidth\", getW);\n        set(\"refY\", getH);\n        set(\"markerHeight\", getH);\n        break;\n\n      case \"radialGradient\":\n        set(\"fx\", getW);\n        set(\"fy\", getH);\n        break;\n\n      case \"tspan\":\n        set(\"dx\", getW);\n        set(\"dy\", getH);\n        break;\n\n      default:\n        set(name, getW);\n    }\n\n    svg.removeChild(mgr);\n    return out;\n  }\n  /*\\\n   * Snap.select\n   [ method ]\n   **\n   * Wraps a DOM element specified by CSS selector as @Element\n   - query (string) CSS selector of the element\n   = (Element) the current element\n  \\*/\n\n\n  Snap.select = function (query) {\n    query = Str(query).replace(/([^\\\\]):/g, \"$1\\\\:\");\n    return wrap(glob.doc.querySelector(query));\n  };\n  /*\\\n   * Snap.selectAll\n   [ method ]\n   **\n   * Wraps DOM elements specified by CSS selector as set or array of @Element\n   - query (string) CSS selector of the element\n   = (Element) the current element\n  \\*/\n\n\n  Snap.selectAll = function (query) {\n    var nodelist = glob.doc.querySelectorAll(query),\n        set = (Snap.set || Array)();\n\n    for (var i = 0; i < nodelist.length; i++) {\n      set.push(wrap(nodelist[i]));\n    }\n\n    return set;\n  };\n\n  function add2group(list) {\n    if (!is(list, \"array\")) {\n      list = Array.prototype.slice.call(arguments, 0);\n    }\n\n    var i = 0,\n        j = 0,\n        node = this.node;\n\n    while (this[i]) {\n      delete this[i++];\n    }\n\n    for (i = 0; i < list.length; i++) {\n      if (list[i].type == \"set\") {\n        list[i].forEach(function (el) {\n          node.appendChild(el.node);\n        });\n      } else {\n        node.appendChild(list[i].node);\n      }\n    }\n\n    var children = node.childNodes;\n\n    for (i = 0; i < children.length; i++) {\n      this[j++] = wrap(children[i]);\n    }\n\n    return this;\n  } // Hub garbage collector every 10s\n\n\n  setInterval(function () {\n    for (var key in hub) {\n      if (hub[has](key)) {\n        var el = hub[key],\n            node = el.node;\n\n        if (el.type != \"svg\" && !node.ownerSVGElement || el.type == \"svg\" && (!node.parentNode || \"ownerSVGElement\" in node.parentNode && !node.ownerSVGElement)) {\n          delete hub[key];\n        }\n      }\n    }\n  }, 1e4);\n\n  function Element(el) {\n    if (el.snap in hub) {\n      return hub[el.snap];\n    }\n\n    var svg;\n\n    try {\n      svg = el.ownerSVGElement;\n    } catch (e) {}\n    /*\\\n     * Element.node\n     [ property (object) ]\n     **\n     * Gives you a reference to the DOM object, so you can assign event handlers or just mess around.\n     > Usage\n     | // draw a circle at coordinate 10,10 with radius of 10\n     | var c = paper.circle(10, 10, 10);\n     | c.node.onclick = function () {\n     |     c.attr(\"fill\", \"red\");\n     | };\n    \\*/\n\n\n    this.node = el;\n\n    if (svg) {\n      this.paper = new Paper(svg);\n    }\n    /*\\\n     * Element.type\n     [ property (string) ]\n     **\n     * SVG tag name of the given element.\n    \\*/\n\n\n    this.type = el.tagName || el.nodeName;\n    var id = this.id = ID(this);\n    this.anims = {};\n    this._ = {\n      transform: []\n    };\n    el.snap = id;\n    hub[id] = this;\n\n    if (this.type == \"g\") {\n      this.add = add2group;\n    }\n\n    if (this.type in {\n      g: 1,\n      mask: 1,\n      pattern: 1,\n      symbol: 1\n    }) {\n      for (var method in Paper.prototype) {\n        if (Paper.prototype[has](method)) {\n          this[method] = Paper.prototype[method];\n        }\n      }\n    }\n  }\n  /*\\\n    * Element.attr\n    [ method ]\n    **\n    * Gets or sets given attributes of the element.\n    **\n    - params (object) contains key-value pairs of attributes you want to set\n    * or\n    - param (string) name of the attribute\n    = (Element) the current element\n    * or\n    = (string) value of attribute\n    > Usage\n    | el.attr({\n    |     fill: \"#fc0\",\n    |     stroke: \"#000\",\n    |     strokeWidth: 2, // CamelCase...\n    |     \"fill-opacity\": 0.5, // or dash-separated names\n    |     width: \"*=2\" // prefixed values\n    | });\n    | console.log(el.attr(\"fill\")); // #fc0\n    * Prefixed values in format `\"+=10\"` supported. All four operations\n    * (`+`, `-`, `*` and `/`) could be used. Optionally you can use units for `+`\n    * and `-`: `\"+=2em\"`.\n   \\*/\n\n\n  Element.prototype.attr = function (params, value) {\n    var el = this,\n        node = el.node;\n\n    if (!params) {\n      if (node.nodeType != 1) {\n        return {\n          text: node.nodeValue\n        };\n      }\n\n      var attr = node.attributes,\n          out = {};\n\n      for (var i = 0, ii = attr.length; i < ii; i++) {\n        out[attr[i].nodeName] = attr[i].nodeValue;\n      }\n\n      return out;\n    }\n\n    if (is(params, \"string\")) {\n      if (arguments.length > 1) {\n        var json = {};\n        json[params] = value;\n        params = json;\n      } else {\n        return eve(\"snap.util.getattr.\" + params, el).firstDefined();\n      }\n    }\n\n    for (var att in params) {\n      if (params[has](att)) {\n        eve(\"snap.util.attr.\" + att, el, params[att]);\n      }\n    }\n\n    return el;\n  };\n  /*\\\n   * Snap.parse\n   [ method ]\n   **\n   * Parses SVG fragment and converts it into a @Fragment\n   **\n   - svg (string) SVG string\n   = (Fragment) the @Fragment\n  \\*/\n\n\n  Snap.parse = function (svg) {\n    var f = glob.doc.createDocumentFragment(),\n        full = true,\n        div = glob.doc.createElement(\"div\");\n    svg = Str(svg);\n\n    if (!svg.match(/^\\s*<\\s*svg(?:\\s|>)/)) {\n      svg = \"<svg>\" + svg + \"</svg>\";\n      full = false;\n    }\n\n    div.innerHTML = svg;\n    svg = div.getElementsByTagName(\"svg\")[0];\n\n    if (svg) {\n      if (full) {\n        f = svg;\n      } else {\n        while (svg.firstChild) {\n          f.appendChild(svg.firstChild);\n        }\n      }\n    }\n\n    return new Fragment(f);\n  };\n\n  function Fragment(frag) {\n    this.node = frag;\n  }\n  /*\\\n   * Snap.fragment\n   [ method ]\n   **\n   * Creates a DOM fragment from a given list of elements or strings\n   **\n   - varargs (…) SVG string\n   = (Fragment) the @Fragment\n  \\*/\n\n\n  Snap.fragment = function () {\n    var args = Array.prototype.slice.call(arguments, 0),\n        f = glob.doc.createDocumentFragment();\n\n    for (var i = 0, ii = args.length; i < ii; i++) {\n      var item = args[i];\n\n      if (item.node && item.node.nodeType) {\n        f.appendChild(item.node);\n      }\n\n      if (item.nodeType) {\n        f.appendChild(item);\n      }\n\n      if (typeof item == \"string\") {\n        f.appendChild(Snap.parse(item).node);\n      }\n    }\n\n    return new Fragment(f);\n  };\n\n  function make(name, parent) {\n    var res = $(name);\n    parent.appendChild(res);\n    var el = wrap(res);\n    return el;\n  }\n\n  function Paper(w, h) {\n    var res,\n        desc,\n        defs,\n        proto = Paper.prototype;\n\n    if (w && w.tagName && w.tagName.toLowerCase() == \"svg\") {\n      if (w.snap in hub) {\n        return hub[w.snap];\n      }\n\n      var doc = w.ownerDocument;\n      res = new Element(w);\n      desc = w.getElementsByTagName(\"desc\")[0];\n      defs = w.getElementsByTagName(\"defs\")[0];\n\n      if (!desc) {\n        desc = $(\"desc\");\n        desc.appendChild(doc.createTextNode(\"Created with Snap\"));\n        res.node.appendChild(desc);\n      }\n\n      if (!defs) {\n        defs = $(\"defs\");\n        res.node.appendChild(defs);\n      }\n\n      res.defs = defs;\n\n      for (var key in proto) {\n        if (proto[has](key)) {\n          res[key] = proto[key];\n        }\n      }\n\n      res.paper = res.root = res;\n    } else {\n      res = make(\"svg\", glob.doc.body);\n      $(res.node, {\n        height: h,\n        version: 1.1,\n        width: w,\n        xmlns: xmlns\n      });\n    }\n\n    return res;\n  }\n\n  function wrap(dom) {\n    if (!dom) {\n      return dom;\n    }\n\n    if (dom instanceof Element || dom instanceof Fragment) {\n      return dom;\n    }\n\n    if (dom.tagName && dom.tagName.toLowerCase() == \"svg\") {\n      return new Paper(dom);\n    }\n\n    if (dom.tagName && dom.tagName.toLowerCase() == \"object\" && dom.type == \"image/svg+xml\") {\n      return new Paper(dom.contentDocument.getElementsByTagName(\"svg\")[0]);\n    }\n\n    return new Element(dom);\n  }\n\n  Snap._.make = make;\n  Snap._.wrap = wrap;\n  /*\\\n   * Paper.el\n   [ method ]\n   **\n   * Creates an element on paper with a given name and no attributes\n   **\n   - name (string) tag name\n   - attr (object) attributes\n   = (Element) the current element\n   > Usage\n   | var c = paper.circle(10, 10, 10); // is the same as...\n   | var c = paper.el(\"circle\").attr({\n   |     cx: 10,\n   |     cy: 10,\n   |     r: 10\n   | });\n   | // and the same as\n   | var c = paper.el(\"circle\", {\n   |     cx: 10,\n   |     cy: 10,\n   |     r: 10\n   | });\n  \\*/\n\n  Paper.prototype.el = function (name, attr) {\n    var el = make(name, this.node);\n    attr && el.attr(attr);\n    return el;\n  };\n  /*\\\n   * Element.children\n   [ method ]\n   **\n   * Returns array of all the children of the element.\n   = (array) array of Elements\n  \\*/\n\n\n  Element.prototype.children = function () {\n    var out = [],\n        ch = this.node.childNodes;\n\n    for (var i = 0, ii = ch.length; i < ii; i++) {\n      out[i] = Snap(ch[i]);\n    }\n\n    return out;\n  };\n\n  function jsonFiller(root, o) {\n    for (var i = 0, ii = root.length; i < ii; i++) {\n      var item = {\n        type: root[i].type,\n        attr: root[i].attr()\n      },\n          children = root[i].children();\n      o.push(item);\n\n      if (children.length) {\n        jsonFiller(children, item.childNodes = []);\n      }\n    }\n  }\n  /*\\\n   * Element.toJSON\n   [ method ]\n   **\n   * Returns object representation of the given element and all its children.\n   = (object) in format\n   o {\n   o     type (string) this.type,\n   o     attr (object) attributes map,\n   o     childNodes (array) optional array of children in the same format\n   o }\n  \\*/\n\n\n  Element.prototype.toJSON = function () {\n    var out = [];\n    jsonFiller([this], out);\n    return out[0];\n  }; // default\n\n\n  eve.on(\"snap.util.getattr\", function () {\n    var att = eve.nt();\n    att = att.substring(att.lastIndexOf(\".\") + 1);\n    var css = att.replace(/[A-Z]/g, function (letter) {\n      return \"-\" + letter.toLowerCase();\n    });\n\n    if (cssAttr[has](css)) {\n      return this.node.ownerDocument.defaultView.getComputedStyle(this.node, null).getPropertyValue(css);\n    } else {\n      return $(this.node, att);\n    }\n  });\n  var cssAttr = {\n    \"alignment-baseline\": 0,\n    \"baseline-shift\": 0,\n    \"clip\": 0,\n    \"clip-path\": 0,\n    \"clip-rule\": 0,\n    \"color\": 0,\n    \"color-interpolation\": 0,\n    \"color-interpolation-filters\": 0,\n    \"color-profile\": 0,\n    \"color-rendering\": 0,\n    \"cursor\": 0,\n    \"direction\": 0,\n    \"display\": 0,\n    \"dominant-baseline\": 0,\n    \"enable-background\": 0,\n    \"fill\": 0,\n    \"fill-opacity\": 0,\n    \"fill-rule\": 0,\n    \"filter\": 0,\n    \"flood-color\": 0,\n    \"flood-opacity\": 0,\n    \"font\": 0,\n    \"font-family\": 0,\n    \"font-size\": 0,\n    \"font-size-adjust\": 0,\n    \"font-stretch\": 0,\n    \"font-style\": 0,\n    \"font-variant\": 0,\n    \"font-weight\": 0,\n    \"glyph-orientation-horizontal\": 0,\n    \"glyph-orientation-vertical\": 0,\n    \"image-rendering\": 0,\n    \"kerning\": 0,\n    \"letter-spacing\": 0,\n    \"lighting-color\": 0,\n    \"marker\": 0,\n    \"marker-end\": 0,\n    \"marker-mid\": 0,\n    \"marker-start\": 0,\n    \"mask\": 0,\n    \"opacity\": 0,\n    \"overflow\": 0,\n    \"pointer-events\": 0,\n    \"shape-rendering\": 0,\n    \"stop-color\": 0,\n    \"stop-opacity\": 0,\n    \"stroke\": 0,\n    \"stroke-dasharray\": 0,\n    \"stroke-dashoffset\": 0,\n    \"stroke-linecap\": 0,\n    \"stroke-linejoin\": 0,\n    \"stroke-miterlimit\": 0,\n    \"stroke-opacity\": 0,\n    \"stroke-width\": 0,\n    \"text-anchor\": 0,\n    \"text-decoration\": 0,\n    \"text-rendering\": 0,\n    \"unicode-bidi\": 0,\n    \"visibility\": 0,\n    \"word-spacing\": 0,\n    \"writing-mode\": 0\n  };\n  eve.on(\"snap.util.attr\", function (value) {\n    var att = eve.nt(),\n        attr = {};\n    att = att.substring(att.lastIndexOf(\".\") + 1);\n    attr[att] = value;\n    var style = att.replace(/-(\\w)/gi, function (all, letter) {\n      return letter.toUpperCase();\n    }),\n        css = att.replace(/[A-Z]/g, function (letter) {\n      return \"-\" + letter.toLowerCase();\n    });\n\n    if (cssAttr[has](css)) {\n      this.node.style[style] = value == null ? E : value;\n    } else {\n      $(this.node, attr);\n    }\n  });\n\n  (function (proto) {})(Paper.prototype); // simple ajax\n\n  /*\\\n   * Snap.ajax\n   [ method ]\n   **\n   * Simple implementation of Ajax\n   **\n   - url (string) URL\n   - postData (object|string) data for post request\n   - callback (function) callback\n   - scope (object) #optional scope of callback\n   * or\n   - url (string) URL\n   - callback (function) callback\n   - scope (object) #optional scope of callback\n   = (XMLHttpRequest) the XMLHttpRequest object, just in case\n  \\*/\n\n\n  Snap.ajax = function (url, postData, callback, scope) {\n    var req = new XMLHttpRequest(),\n        id = ID();\n\n    if (req) {\n      if (is(postData, \"function\")) {\n        scope = callback;\n        callback = postData;\n        postData = null;\n      } else if (is(postData, \"object\")) {\n        var pd = [];\n\n        for (var key in postData) {\n          if (postData.hasOwnProperty(key)) {\n            pd.push(encodeURIComponent(key) + \"=\" + encodeURIComponent(postData[key]));\n          }\n        }\n\n        postData = pd.join(\"&\");\n      }\n\n      req.open(postData ? \"POST\" : \"GET\", url, true);\n\n      if (postData) {\n        req.setRequestHeader(\"X-Requested-With\", \"XMLHttpRequest\");\n        req.setRequestHeader(\"Content-type\", \"application/x-www-form-urlencoded\");\n      }\n\n      if (callback) {\n        eve.once(\"snap.ajax.\" + id + \".0\", callback);\n        eve.once(\"snap.ajax.\" + id + \".200\", callback);\n        eve.once(\"snap.ajax.\" + id + \".304\", callback);\n      }\n\n      req.onreadystatechange = function () {\n        if (req.readyState != 4) return;\n        eve(\"snap.ajax.\" + id + \".\" + req.status, scope, req);\n      };\n\n      if (req.readyState == 4) {\n        return req;\n      }\n\n      req.send(postData);\n      return req;\n    }\n  };\n  /*\\\n   * Snap.load\n   [ method ]\n   **\n   * Loads external SVG file as a @Fragment (see @Snap.ajax for more advanced AJAX)\n   **\n   - url (string) URL\n   - callback (function) callback\n   - scope (object) #optional scope of callback\n  \\*/\n\n\n  Snap.load = function (url, callback, scope) {\n    Snap.ajax(url, function (req) {\n      var f = Snap.parse(req.responseText);\n      scope ? callback.call(scope, f) : callback(f);\n    });\n  };\n\n  var getOffset = function getOffset(elem) {\n    var box = elem.getBoundingClientRect(),\n        doc = elem.ownerDocument,\n        body = doc.body,\n        docElem = doc.documentElement,\n        clientTop = docElem.clientTop || body.clientTop || 0,\n        clientLeft = docElem.clientLeft || body.clientLeft || 0,\n        top = box.top + (g.win.pageYOffset || docElem.scrollTop || body.scrollTop) - clientTop,\n        left = box.left + (g.win.pageXOffset || docElem.scrollLeft || body.scrollLeft) - clientLeft;\n    return {\n      y: top,\n      x: left\n    };\n  };\n  /*\\\n   * Snap.getElementByPoint\n   [ method ]\n   **\n   * Returns you topmost element under given point.\n   **\n   = (object) Snap element object\n   - x (number) x coordinate from the top left corner of the window\n   - y (number) y coordinate from the top left corner of the window\n   > Usage\n   | Snap.getElementByPoint(mouseX, mouseY).attr({stroke: \"#f00\"});\n  \\*/\n\n\n  Snap.getElementByPoint = function (x, y) {\n    var paper = this,\n        svg = paper.canvas,\n        target = glob.doc.elementFromPoint(x, y);\n\n    if (glob.win.opera && target.tagName == \"svg\") {\n      var so = getOffset(target),\n          sr = target.createSVGRect();\n      sr.x = x - so.x;\n      sr.y = y - so.y;\n      sr.width = sr.height = 1;\n      var hits = target.getIntersectionList(sr, null);\n\n      if (hits.length) {\n        target = hits[hits.length - 1];\n      }\n    }\n\n    if (!target) {\n      return null;\n    }\n\n    return wrap(target);\n  };\n  /*\\\n   * Snap.plugin\n   [ method ]\n   **\n   * Let you write plugins. You pass in a function with five arguments, like this:\n   | Snap.plugin(function (Snap, Element, Paper, global, Fragment) {\n   |     Snap.newmethod = function () {};\n   |     Element.prototype.newmethod = function () {};\n   |     Paper.prototype.newmethod = function () {};\n   | });\n   * Inside the function you have access to all main objects (and their\n   * prototypes). This allow you to extend anything you want.\n   **\n   - f (function) your plugin body\n  \\*/\n\n\n  Snap.plugin = function (f) {\n    f(Snap, Element, Paper, glob, Fragment);\n  };\n\n  glob.win.Snap = Snap;\n  return Snap;\n}(window || this); // Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n\nSnap.plugin(function (Snap, Element, Paper, glob, Fragment) {\n  var elproto = Element.prototype,\n      is = Snap.is,\n      Str = String,\n      unit2px = Snap._unit2px,\n      $ = Snap._.$,\n      make = Snap._.make,\n      getSomeDefs = Snap._.getSomeDefs,\n      has = \"hasOwnProperty\",\n      wrap = Snap._.wrap;\n  /*\\\n   * Element.getBBox\n   [ method ]\n   **\n   * Returns the bounding box descriptor for the given element\n   **\n   = (object) bounding box descriptor:\n   o {\n   o     cx: (number) x of the center,\n   o     cy: (number) x of the center,\n   o     h: (number) height,\n   o     height: (number) height,\n   o     path: (string) path command for the box,\n   o     r0: (number) radius of a circle that fully encloses the box,\n   o     r1: (number) radius of the smallest circle that can be enclosed,\n   o     r2: (number) radius of the largest circle that can be enclosed,\n   o     vb: (string) box as a viewbox command,\n   o     w: (number) width,\n   o     width: (number) width,\n   o     x2: (number) x of the right side,\n   o     x: (number) x of the left side,\n   o     y2: (number) y of the bottom edge,\n   o     y: (number) y of the top edge\n   o }\n  \\*/\n\n  elproto.getBBox = function (isWithoutTransform) {\n    if (this.type == \"tspan\") {\n      return Snap._.box(this.node.getClientRects().item(0));\n    }\n\n    if (!Snap.Matrix || !Snap.path) {\n      return this.node.getBBox();\n    }\n\n    var el = this,\n        m = new Snap.Matrix();\n\n    if (el.removed) {\n      return Snap._.box();\n    }\n\n    while (el.type == \"use\") {\n      if (!isWithoutTransform) {\n        m = m.add(el.transform().localMatrix.translate(el.attr(\"x\") || 0, el.attr(\"y\") || 0));\n      }\n\n      if (el.original) {\n        el = el.original;\n      } else {\n        var href = el.attr(\"xlink:href\");\n        el = el.original = el.node.ownerDocument.getElementById(href.substring(href.indexOf(\"#\") + 1));\n      }\n    }\n\n    var _ = el._,\n        pathfinder = Snap.path.get[el.type] || Snap.path.get.deflt;\n\n    try {\n      if (isWithoutTransform) {\n        _.bboxwt = pathfinder ? Snap.path.getBBox(el.realPath = pathfinder(el)) : Snap._.box(el.node.getBBox());\n        return Snap._.box(_.bboxwt);\n      } else {\n        el.realPath = pathfinder(el);\n        el.matrix = el.transform().localMatrix;\n        _.bbox = Snap.path.getBBox(Snap.path.map(el.realPath, m.add(el.matrix)));\n        return Snap._.box(_.bbox);\n      }\n    } catch (e) {\n      // Firefox doesn’t give you bbox of hidden element\n      return Snap._.box();\n    }\n  };\n\n  var propString = function propString() {\n    return this.string;\n  };\n\n  function extractTransform(el, tstr) {\n    if (tstr == null) {\n      var doReturn = true;\n\n      if (el.type == \"linearGradient\" || el.type == \"radialGradient\") {\n        tstr = el.node.getAttribute(\"gradientTransform\");\n      } else if (el.type == \"pattern\") {\n        tstr = el.node.getAttribute(\"patternTransform\");\n      } else {\n        tstr = el.node.getAttribute(\"transform\");\n      }\n\n      if (!tstr) {\n        return new Snap.Matrix();\n      }\n\n      tstr = Snap._.svgTransform2string(tstr);\n    } else {\n      if (!Snap._.rgTransform.test(tstr)) {\n        tstr = Snap._.svgTransform2string(tstr);\n      } else {\n        tstr = Str(tstr).replace(/\\.{3}|\\u2026/g, el._.transform || \"\");\n      }\n\n      if (is(tstr, \"array\")) {\n        tstr = Snap.path ? Snap.path.toString.call(tstr) : Str(tstr);\n      }\n\n      el._.transform = tstr;\n    }\n\n    var m = Snap._.transform2matrix(tstr, el.getBBox(1));\n\n    if (doReturn) {\n      return m;\n    } else {\n      el.matrix = m;\n    }\n  }\n  /*\\\n   * Element.transform\n   [ method ]\n   **\n   * Gets or sets transformation of the element\n   **\n   - tstr (string) transform string in Snap or SVG format\n   = (Element) the current element\n   * or\n   = (object) transformation descriptor:\n   o {\n   o     string (string) transform string,\n   o     globalMatrix (Matrix) matrix of all transformations applied to element or its parents,\n   o     localMatrix (Matrix) matrix of transformations applied only to the element,\n   o     diffMatrix (Matrix) matrix of difference between global and local transformations,\n   o     global (string) global transformation as string,\n   o     local (string) local transformation as string,\n   o     toString (function) returns `string` property\n   o }\n  \\*/\n\n\n  elproto.transform = function (tstr) {\n    var _ = this._;\n\n    if (tstr == null) {\n      var papa = this,\n          global = new Snap.Matrix(this.node.getCTM()),\n          local = extractTransform(this),\n          ms = [local],\n          m = new Snap.Matrix(),\n          i,\n          localString = local.toTransformString(),\n          string = Str(local) == Str(this.matrix) ? Str(_.transform) : localString;\n\n      while (papa.type != \"svg\" && (papa = papa.parent())) {\n        ms.push(extractTransform(papa));\n      }\n\n      i = ms.length;\n\n      while (i--) {\n        m.add(ms[i]);\n      }\n\n      return {\n        string: string,\n        globalMatrix: global,\n        totalMatrix: m,\n        localMatrix: local,\n        diffMatrix: global.clone().add(local.invert()),\n        global: global.toTransformString(),\n        total: m.toTransformString(),\n        local: localString,\n        toString: propString\n      };\n    }\n\n    if (tstr instanceof Snap.Matrix) {\n      this.matrix = tstr;\n      this._.transform = tstr.toTransformString();\n    } else {\n      extractTransform(this, tstr);\n    }\n\n    if (this.node) {\n      if (this.type == \"linearGradient\" || this.type == \"radialGradient\") {\n        $(this.node, {\n          gradientTransform: this.matrix\n        });\n      } else if (this.type == \"pattern\") {\n        $(this.node, {\n          patternTransform: this.matrix\n        });\n      } else {\n        $(this.node, {\n          transform: this.matrix\n        });\n      }\n    }\n\n    return this;\n  };\n  /*\\\n   * Element.parent\n   [ method ]\n   **\n   * Returns the element's parent\n   **\n   = (Element) the parent element\n  \\*/\n\n\n  elproto.parent = function () {\n    return wrap(this.node.parentNode);\n  };\n  /*\\\n   * Element.append\n   [ method ]\n   **\n   * Appends the given element to current one\n   **\n   - el (Element|Set) element to append\n   = (Element) the parent element\n  \\*/\n\n  /*\\\n   * Element.add\n   [ method ]\n   **\n   * See @Element.append\n  \\*/\n\n\n  elproto.append = elproto.add = function (el) {\n    if (el) {\n      if (el.type == \"set\") {\n        var it = this;\n        el.forEach(function (el) {\n          it.add(el);\n        });\n        return this;\n      }\n\n      el = wrap(el);\n      this.node.appendChild(el.node);\n      el.paper = this.paper;\n    }\n\n    return this;\n  };\n  /*\\\n   * Element.appendTo\n   [ method ]\n   **\n   * Appends the current element to the given one\n   **\n   - el (Element) parent element to append to\n   = (Element) the child element\n  \\*/\n\n\n  elproto.appendTo = function (el) {\n    if (el) {\n      el = wrap(el);\n      el.append(this);\n    }\n\n    return this;\n  };\n  /*\\\n   * Element.prepend\n   [ method ]\n   **\n   * Prepends the given element to the current one\n   **\n   - el (Element) element to prepend\n   = (Element) the parent element\n  \\*/\n\n\n  elproto.prepend = function (el) {\n    if (el) {\n      if (el.type == \"set\") {\n        var it = this,\n            first;\n        el.forEach(function (el) {\n          if (first) {\n            first.after(el);\n          } else {\n            it.prepend(el);\n          }\n\n          first = el;\n        });\n        return this;\n      }\n\n      el = wrap(el);\n      var parent = el.parent();\n      this.node.insertBefore(el.node, this.node.firstChild);\n      this.add && this.add();\n      el.paper = this.paper;\n      this.parent() && this.parent().add();\n      parent && parent.add();\n    }\n\n    return this;\n  };\n  /*\\\n   * Element.prependTo\n   [ method ]\n   **\n   * Prepends the current element to the given one\n   **\n   - el (Element) parent element to prepend to\n   = (Element) the child element\n  \\*/\n\n\n  elproto.prependTo = function (el) {\n    el = wrap(el);\n    el.prepend(this);\n    return this;\n  };\n  /*\\\n   * Element.before\n   [ method ]\n   **\n   * Inserts given element before the current one\n   **\n   - el (Element) element to insert\n   = (Element) the parent element\n  \\*/\n\n\n  elproto.before = function (el) {\n    if (el.type == \"set\") {\n      var it = this;\n      el.forEach(function (el) {\n        var parent = el.parent();\n        it.node.parentNode.insertBefore(el.node, it.node);\n        parent && parent.add();\n      });\n      this.parent().add();\n      return this;\n    }\n\n    el = wrap(el);\n    var parent = el.parent();\n    this.node.parentNode.insertBefore(el.node, this.node);\n    this.parent() && this.parent().add();\n    parent && parent.add();\n    el.paper = this.paper;\n    return this;\n  };\n  /*\\\n   * Element.after\n   [ method ]\n   **\n   * Inserts given element after the current one\n   **\n   - el (Element) element to insert\n   = (Element) the parent element\n  \\*/\n\n\n  elproto.after = function (el) {\n    el = wrap(el);\n    var parent = el.parent();\n\n    if (this.node.nextSibling) {\n      this.node.parentNode.insertBefore(el.node, this.node.nextSibling);\n    } else {\n      this.node.parentNode.appendChild(el.node);\n    }\n\n    this.parent() && this.parent().add();\n    parent && parent.add();\n    el.paper = this.paper;\n    return this;\n  };\n  /*\\\n   * Element.insertBefore\n   [ method ]\n   **\n   * Inserts the element after the given one\n   **\n   - el (Element) element next to whom insert to\n   = (Element) the parent element\n  \\*/\n\n\n  elproto.insertBefore = function (el) {\n    el = wrap(el);\n    var parent = this.parent();\n    el.node.parentNode.insertBefore(this.node, el.node);\n    this.paper = el.paper;\n    parent && parent.add();\n    el.parent() && el.parent().add();\n    return this;\n  };\n  /*\\\n   * Element.insertAfter\n   [ method ]\n   **\n   * Inserts the element after the given one\n   **\n   - el (Element) element next to whom insert to\n   = (Element) the parent element\n  \\*/\n\n\n  elproto.insertAfter = function (el) {\n    el = wrap(el);\n    var parent = this.parent();\n    el.node.parentNode.insertBefore(this.node, el.node.nextSibling);\n    this.paper = el.paper;\n    parent && parent.add();\n    el.parent() && el.parent().add();\n    return this;\n  };\n  /*\\\n   * Element.remove\n   [ method ]\n   **\n   * Removes element from the DOM\n   = (Element) the detached element\n  \\*/\n\n\n  elproto.remove = function () {\n    var parent = this.parent();\n    this.node.parentNode && this.node.parentNode.removeChild(this.node);\n    delete this.paper;\n    this.removed = true;\n    parent && parent.add();\n    return this;\n  };\n  /*\\\n   * Element.select\n   [ method ]\n   **\n   * Gathers the nested @Element matching the given set of CSS selectors\n   **\n   - query (string) CSS selector\n   = (Element) result of query selection\n  \\*/\n\n\n  elproto.select = function (query) {\n    return wrap(this.node.querySelector(query));\n  };\n  /*\\\n   * Element.selectAll\n   [ method ]\n   **\n   * Gathers nested @Element objects matching the given set of CSS selectors\n   **\n   - query (string) CSS selector\n   = (Set|array) result of query selection\n  \\*/\n\n\n  elproto.selectAll = function (query) {\n    var nodelist = this.node.querySelectorAll(query),\n        set = (Snap.set || Array)();\n\n    for (var i = 0; i < nodelist.length; i++) {\n      set.push(wrap(nodelist[i]));\n    }\n\n    return set;\n  };\n  /*\\\n   * Element.asPX\n   [ method ]\n   **\n   * Returns given attribute of the element as a `px` value (not %, em, etc.)\n   **\n   - attr (string) attribute name\n   - value (string) #optional attribute value\n   = (Element) result of query selection\n  \\*/\n\n\n  elproto.asPX = function (attr, value) {\n    if (value == null) {\n      value = this.attr(attr);\n    }\n\n    return +unit2px(this, attr, value);\n  }; // SIERRA Element.use(): I suggest adding a note about how to access the original element the returned <use> instantiates. It's a part of SVG with which ordinary web developers may be least familiar.\n\n  /*\\\n   * Element.use\n   [ method ]\n   **\n   * Creates a `<use>` element linked to the current element\n   **\n   = (Element) the `<use>` element\n  \\*/\n\n\n  elproto.use = function () {\n    var use,\n        id = this.node.id;\n\n    if (!id) {\n      id = this.id;\n      $(this.node, {\n        id: id\n      });\n    }\n\n    if (this.type == \"linearGradient\" || this.type == \"radialGradient\" || this.type == \"pattern\") {\n      use = make(this.type, this.node.parentNode);\n    } else {\n      use = make(\"use\", this.node.parentNode);\n    }\n\n    $(use.node, {\n      \"xlink:href\": \"#\" + id\n    });\n    use.original = this;\n    return use;\n  };\n\n  function fixids(el) {\n    var els = el.selectAll(\"*\"),\n        it,\n        url = /^\\s*url\\((\"|'|)(.*)\\1\\)\\s*$/,\n        ids = [],\n        uses = {};\n\n    function urltest(it, name) {\n      var val = $(it.node, name);\n      val = val && val.match(url);\n      val = val && val[2];\n\n      if (val && val.charAt() == \"#\") {\n        val = val.substring(1);\n      } else {\n        return;\n      }\n\n      if (val) {\n        uses[val] = (uses[val] || []).concat(function (id) {\n          var attr = {};\n          attr[name] = Snap.url(id);\n          $(it.node, attr);\n        });\n      }\n    }\n\n    function linktest(it) {\n      var val = $(it.node, \"xlink:href\");\n\n      if (val && val.charAt() == \"#\") {\n        val = val.substring(1);\n      } else {\n        return;\n      }\n\n      if (val) {\n        uses[val] = (uses[val] || []).concat(function (id) {\n          it.attr(\"xlink:href\", \"#\" + id);\n        });\n      }\n    }\n\n    for (var i = 0, ii = els.length; i < ii; i++) {\n      it = els[i];\n      urltest(it, \"fill\");\n      urltest(it, \"stroke\");\n      urltest(it, \"filter\");\n      urltest(it, \"mask\");\n      urltest(it, \"clip-path\");\n      linktest(it);\n      var oldid = $(it.node, \"id\");\n\n      if (oldid) {\n        $(it.node, {\n          id: it.id\n        });\n        ids.push({\n          old: oldid,\n          id: it.id\n        });\n      }\n    }\n\n    for (i = 0, ii = ids.length; i < ii; i++) {\n      var fs = uses[ids[i].old];\n\n      if (fs) {\n        for (var j = 0, jj = fs.length; j < jj; j++) {\n          fs[j](ids[i].id);\n        }\n      }\n    }\n  }\n  /*\\\n   * Element.clone\n   [ method ]\n   **\n   * Creates a clone of the element and inserts it after the element\n   **\n   = (Element) the clone\n  \\*/\n\n\n  elproto.clone = function () {\n    var clone = wrap(this.node.cloneNode(true));\n\n    if ($(clone.node, \"id\")) {\n      $(clone.node, {\n        id: clone.id\n      });\n    }\n\n    fixids(clone);\n    clone.insertAfter(this);\n    return clone;\n  };\n  /*\\\n   * Element.toDefs\n   [ method ]\n   **\n   * Moves element to the shared `<defs>` area\n   **\n   = (Element) the element\n  \\*/\n\n\n  elproto.toDefs = function () {\n    var defs = getSomeDefs(this);\n    defs.appendChild(this.node);\n    return this;\n  };\n  /*\\\n   * Element.toPattern\n   [ method ]\n   **\n   * Creates a `<pattern>` element from the current element\n   **\n   * To create a pattern you have to specify the pattern rect:\n   - x (string|number)\n   - y (string|number)\n   - width (string|number)\n   - height (string|number)\n   = (Element) the `<pattern>` element\n   * You can use pattern later on as an argument for `fill` attribute:\n   | var p = paper.path(\"M10-5-10,15M15,0,0,15M0-5-20,15\").attr({\n   |         fill: \"none\",\n   |         stroke: \"#bada55\",\n   |         strokeWidth: 5\n   |     }).pattern(0, 0, 10, 10),\n   |     c = paper.circle(200, 200, 100);\n   | c.attr({\n   |     fill: p\n   | });\n  \\*/\n\n\n  elproto.pattern = elproto.toPattern = function (x, y, width, height) {\n    var p = make(\"pattern\", getSomeDefs(this));\n\n    if (x == null) {\n      x = this.getBBox();\n    }\n\n    if (is(x, \"object\") && \"x\" in x) {\n      y = x.y;\n      width = x.width;\n      height = x.height;\n      x = x.x;\n    }\n\n    $(p.node, {\n      x: x,\n      y: y,\n      width: width,\n      height: height,\n      patternUnits: \"userSpaceOnUse\",\n      id: p.id,\n      viewBox: [x, y, width, height].join(\" \")\n    });\n    p.node.appendChild(this.node);\n    return p;\n  }; // SIERRA Element.marker(): clarify what a reference point is. E.g., helps you offset the object from its edge such as when centering it over a path.\n  // SIERRA Element.marker(): I suggest the method should accept default reference point values.  Perhaps centered with (refX = width/2) and (refY = height/2)? Also, couldn't it assume the element's current _width_ and _height_? And please specify what _x_ and _y_ mean: offsets? If so, from where?  Couldn't they also be assigned default values?\n\n  /*\\\n   * Element.marker\n   [ method ]\n   **\n   * Creates a `<marker>` element from the current element\n   **\n   * To create a marker you have to specify the bounding rect and reference point:\n   - x (number)\n   - y (number)\n   - width (number)\n   - height (number)\n   - refX (number)\n   - refY (number)\n   = (Element) the `<marker>` element\n   * You can specify the marker later as an argument for `marker-start`, `marker-end`, `marker-mid`, and `marker` attributes. The `marker` attribute places the marker at every point along the path, and `marker-mid` places them at every point except the start and end.\n  \\*/\n  // TODO add usage for markers\n\n\n  elproto.marker = function (x, y, width, height, refX, refY) {\n    var p = make(\"marker\", getSomeDefs(this));\n\n    if (x == null) {\n      x = this.getBBox();\n    }\n\n    if (is(x, \"object\") && \"x\" in x) {\n      y = x.y;\n      width = x.width;\n      height = x.height;\n      refX = x.refX || x.cx;\n      refY = x.refY || x.cy;\n      x = x.x;\n    }\n\n    $(p.node, {\n      viewBox: [x, y, width, height].join(\" \"),\n      markerWidth: width,\n      markerHeight: height,\n      orient: \"auto\",\n      refX: refX || 0,\n      refY: refY || 0,\n      id: p.id\n    });\n    p.node.appendChild(this.node);\n    return p;\n  };\n\n  var eldata = {};\n  /*\\\n   * Element.data\n   [ method ]\n   **\n   * Adds or retrieves given value associated with given key. (Don’t confuse\n   * with `data-` attributes)\n   *\n   * See also @Element.removeData\n   - key (string) key to store data\n   - value (any) #optional value to store\n   = (object) @Element\n   * or, if value is not specified:\n   = (any) value\n   > Usage\n   | for (var i = 0, i < 5, i++) {\n   |     paper.circle(10 + 15 * i, 10, 10)\n   |          .attr({fill: \"#000\"})\n   |          .data(\"i\", i)\n   |          .click(function () {\n   |             alert(this.data(\"i\"));\n   |          });\n   | }\n  \\*/\n\n  elproto.data = function (key, value) {\n    var data = eldata[this.id] = eldata[this.id] || {};\n\n    if (arguments.length == 0) {\n      eve(\"snap.data.get.\" + this.id, this, data, null);\n      return data;\n    }\n\n    if (arguments.length == 1) {\n      if (Snap.is(key, \"object\")) {\n        for (var i in key) {\n          if (key[has](i)) {\n            this.data(i, key[i]);\n          }\n        }\n\n        return this;\n      }\n\n      eve(\"snap.data.get.\" + this.id, this, data[key], key);\n      return data[key];\n    }\n\n    data[key] = value;\n    eve(\"snap.data.set.\" + this.id, this, value, key);\n    return this;\n  };\n  /*\\\n   * Element.removeData\n   [ method ]\n   **\n   * Removes value associated with an element by given key.\n   * If key is not provided, removes all the data of the element.\n   - key (string) #optional key\n   = (object) @Element\n  \\*/\n\n\n  elproto.removeData = function (key) {\n    if (key == null) {\n      eldata[this.id] = {};\n    } else {\n      eldata[this.id] && delete eldata[this.id][key];\n    }\n\n    return this;\n  };\n  /*\\\n   * Element.outerSVG\n   [ method ]\n   **\n   * Returns SVG code for the element, equivalent to HTML's `outerHTML`.\n   *\n   * See also @Element.innerSVG\n   = (string) SVG code for the element\n  \\*/\n\n  /*\\\n   * Element.toString\n   [ method ]\n   **\n   * See @Element.outerSVG\n  \\*/\n\n\n  elproto.outerSVG = elproto.toString = toString(1);\n  /*\\\n   * Element.innerSVG\n   [ method ]\n   **\n   * Returns SVG code for the element's contents, equivalent to HTML's `innerHTML`\n   = (string) SVG code for the element\n  \\*/\n\n  elproto.innerSVG = toString();\n\n  function toString(type) {\n    return function () {\n      var res = type ? \"<\" + this.type : \"\",\n          attr = this.node.attributes,\n          chld = this.node.childNodes;\n\n      if (type) {\n        for (var i = 0, ii = attr.length; i < ii; i++) {\n          res += \" \" + attr[i].name + '=\"' + attr[i].value.replace(/\"/g, '\\\\\"') + '\"';\n        }\n      }\n\n      if (chld.length) {\n        type && (res += \">\");\n\n        for (i = 0, ii = chld.length; i < ii; i++) {\n          if (chld[i].nodeType == 3) {\n            res += chld[i].nodeValue;\n          } else if (chld[i].nodeType == 1) {\n            res += wrap(chld[i]).toString();\n          }\n        }\n\n        type && (res += \"</\" + this.type + \">\");\n      } else {\n        type && (res += \"/>\");\n      }\n\n      return res;\n    };\n  }\n\n  elproto.toDataURL = function () {\n    if (window && window.btoa) {\n      var bb = this.getBBox(),\n          svg = Snap.format('<svg version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"{width}\" height=\"{height}\" viewBox=\"{x} {y} {width} {height}\">{contents}</svg>', {\n        x: +bb.x.toFixed(3),\n        y: +bb.y.toFixed(3),\n        width: +bb.width.toFixed(3),\n        height: +bb.height.toFixed(3),\n        contents: this.outerSVG()\n      });\n      return \"data:image/svg+xml;base64,\" + btoa(unescape(encodeURIComponent(svg)));\n    }\n  };\n  /*\\\n   * Fragment.select\n   [ method ]\n   **\n   * See @Element.select\n  \\*/\n\n\n  Fragment.prototype.select = elproto.select;\n  /*\\\n   * Fragment.selectAll\n   [ method ]\n   **\n   * See @Element.selectAll\n  \\*/\n\n  Fragment.prototype.selectAll = elproto.selectAll;\n}); // Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\nSnap.plugin(function (Snap, Element, Paper, glob, Fragment) {\n  var objectToString = Object.prototype.toString,\n      Str = String,\n      math = Math,\n      E = \"\";\n\n  function Matrix(a, b, c, d, e, f) {\n    if (b == null && objectToString.call(a) == \"[object SVGMatrix]\") {\n      this.a = a.a;\n      this.b = a.b;\n      this.c = a.c;\n      this.d = a.d;\n      this.e = a.e;\n      this.f = a.f;\n      return;\n    }\n\n    if (a != null) {\n      this.a = +a;\n      this.b = +b;\n      this.c = +c;\n      this.d = +d;\n      this.e = +e;\n      this.f = +f;\n    } else {\n      this.a = 1;\n      this.b = 0;\n      this.c = 0;\n      this.d = 1;\n      this.e = 0;\n      this.f = 0;\n    }\n  }\n\n  (function (matrixproto) {\n    /*\\\n     * Matrix.add\n     [ method ]\n     **\n     * Adds the given matrix to existing one\n     - a (number)\n     - b (number)\n     - c (number)\n     - d (number)\n     - e (number)\n     - f (number)\n     * or\n     - matrix (object) @Matrix\n    \\*/\n    matrixproto.add = function (a, b, c, d, e, f) {\n      if (a && a instanceof Matrix) {\n        return this.add(a.a, a.b, a.c, a.d, a.e, a.f);\n      }\n\n      var aNew = a * this.a + b * this.c,\n          bNew = a * this.b + b * this.d;\n      this.e += e * this.a + f * this.c;\n      this.f += e * this.b + f * this.d;\n      this.c = c * this.a + d * this.c;\n      this.d = c * this.b + d * this.d;\n      this.a = aNew;\n      this.b = bNew;\n      return this;\n    };\n    /*\\\n     * Matrix.multLeft\n     [ method ]\n     **\n     * Multiplies a passed affine transform to the left: M * this.\n     - a (number)\n     - b (number)\n     - c (number)\n     - d (number)\n     - e (number)\n     - f (number)\n     * or\n     - matrix (object) @Matrix\n    \\*/\n\n\n    Matrix.prototype.multLeft = function (a, b, c, d, e, f) {\n      if (a && a instanceof Matrix) {\n        return this.multLeft(a.a, a.b, a.c, a.d, a.e, a.f);\n      }\n\n      var aNew = a * this.a + c * this.b,\n          cNew = a * this.c + c * this.d,\n          eNew = a * this.e + c * this.f + e;\n      this.b = b * this.a + d * this.b;\n      this.d = b * this.c + d * this.d;\n      this.f = b * this.e + d * this.f + f;\n      this.a = aNew;\n      this.c = cNew;\n      this.e = eNew;\n      return this;\n    };\n    /*\\\n     * Matrix.invert\n     [ method ]\n     **\n     * Returns an inverted version of the matrix\n     = (object) @Matrix\n    \\*/\n\n\n    matrixproto.invert = function () {\n      var me = this,\n          x = me.a * me.d - me.b * me.c;\n      return new Matrix(me.d / x, -me.b / x, -me.c / x, me.a / x, (me.c * me.f - me.d * me.e) / x, (me.b * me.e - me.a * me.f) / x);\n    };\n    /*\\\n     * Matrix.clone\n     [ method ]\n     **\n     * Returns a copy of the matrix\n     = (object) @Matrix\n    \\*/\n\n\n    matrixproto.clone = function () {\n      return new Matrix(this.a, this.b, this.c, this.d, this.e, this.f);\n    };\n    /*\\\n     * Matrix.translate\n     [ method ]\n     **\n     * Translate the matrix\n     - x (number) horizontal offset distance\n     - y (number) vertical offset distance\n    \\*/\n\n\n    matrixproto.translate = function (x, y) {\n      this.e += x * this.a + y * this.c;\n      this.f += x * this.b + y * this.d;\n      return this;\n    };\n    /*\\\n     * Matrix.scale\n     [ method ]\n     **\n     * Scales the matrix\n     - x (number) amount to be scaled, with `1` resulting in no change\n     - y (number) #optional amount to scale along the vertical axis. (Otherwise `x` applies to both axes.)\n     - cx (number) #optional horizontal origin point from which to scale\n     - cy (number) #optional vertical origin point from which to scale\n     * Default cx, cy is the middle point of the element.\n    \\*/\n\n\n    matrixproto.scale = function (x, y, cx, cy) {\n      y == null && (y = x);\n      (cx || cy) && this.translate(cx, cy);\n      this.a *= x;\n      this.b *= x;\n      this.c *= y;\n      this.d *= y;\n      (cx || cy) && this.translate(-cx, -cy);\n      return this;\n    };\n    /*\\\n     * Matrix.rotate\n     [ method ]\n     **\n     * Rotates the matrix\n     - a (number) angle of rotation, in degrees\n     - x (number) horizontal origin point from which to rotate\n     - y (number) vertical origin point from which to rotate\n    \\*/\n\n\n    matrixproto.rotate = function (a, x, y) {\n      a = Snap.rad(a);\n      x = x || 0;\n      y = y || 0;\n      var cos = +math.cos(a).toFixed(9),\n          sin = +math.sin(a).toFixed(9);\n      this.add(cos, sin, -sin, cos, x, y);\n      return this.add(1, 0, 0, 1, -x, -y);\n    };\n    /*\\\n     * Matrix.skewX\n     [ method ]\n     **\n     * Skews the matrix along the x-axis\n     - x (number) Angle to skew along the x-axis (in degrees).\n    \\*/\n\n\n    matrixproto.skewX = function (x) {\n      return this.skew(x, 0);\n    };\n    /*\\\n     * Matrix.skewY\n     [ method ]\n     **\n     * Skews the matrix along the y-axis\n     - y (number) Angle to skew along the y-axis (in degrees).\n    \\*/\n\n\n    matrixproto.skewY = function (y) {\n      return this.skew(0, y);\n    };\n    /*\\\n     * Matrix.skew\n     [ method ]\n     **\n     * Skews the matrix\n     - y (number) Angle to skew along the y-axis (in degrees).\n     - x (number) Angle to skew along the x-axis (in degrees).\n    \\*/\n\n\n    matrixproto.skew = function (x, y) {\n      x = x || 0;\n      y = y || 0;\n      x = Snap.rad(x);\n      y = Snap.rad(y);\n      var c = math.tan(x).toFixed(9);\n      var b = math.tan(y).toFixed(9);\n      return this.add(1, b, c, 1, 0, 0);\n    };\n    /*\\\n     * Matrix.x\n     [ method ]\n     **\n     * Returns x coordinate for given point after transformation described by the matrix. See also @Matrix.y\n     - x (number)\n     - y (number)\n     = (number) x\n    \\*/\n\n\n    matrixproto.x = function (x, y) {\n      return x * this.a + y * this.c + this.e;\n    };\n    /*\\\n     * Matrix.y\n     [ method ]\n     **\n     * Returns y coordinate for given point after transformation described by the matrix. See also @Matrix.x\n     - x (number)\n     - y (number)\n     = (number) y\n    \\*/\n\n\n    matrixproto.y = function (x, y) {\n      return x * this.b + y * this.d + this.f;\n    };\n\n    matrixproto.get = function (i) {\n      return +this[Str.fromCharCode(97 + i)].toFixed(4);\n    };\n\n    matrixproto.toString = function () {\n      return \"matrix(\" + [this.get(0), this.get(1), this.get(2), this.get(3), this.get(4), this.get(5)].join() + \")\";\n    };\n\n    matrixproto.offset = function () {\n      return [this.e.toFixed(4), this.f.toFixed(4)];\n    };\n\n    function norm(a) {\n      return a[0] * a[0] + a[1] * a[1];\n    }\n\n    function normalize(a) {\n      var mag = math.sqrt(norm(a));\n      a[0] && (a[0] /= mag);\n      a[1] && (a[1] /= mag);\n    }\n    /*\\\n     * Matrix.determinant\n     [ method ]\n     **\n     * Finds determinant of the given matrix.\n     = (number) determinant\n    \\*/\n\n\n    matrixproto.determinant = function () {\n      return this.a * this.d - this.b * this.c;\n    };\n    /*\\\n     * Matrix.split\n     [ method ]\n     **\n     * Splits matrix into primitive transformations\n     = (object) in format:\n     o dx (number) translation by x\n     o dy (number) translation by y\n     o scalex (number) scale by x\n     o scaley (number) scale by y\n     o shear (number) shear\n     o rotate (number) rotation in deg\n     o isSimple (boolean) could it be represented via simple transformations\n    \\*/\n\n\n    matrixproto.split = function () {\n      var out = {}; // translation\n\n      out.dx = this.e;\n      out.dy = this.f; // scale and shear\n\n      var row = [[this.a, this.b], [this.c, this.d]];\n      out.scalex = math.sqrt(norm(row[0]));\n      normalize(row[0]);\n      out.shear = row[0][0] * row[1][0] + row[0][1] * row[1][1];\n      row[1] = [row[1][0] - row[0][0] * out.shear, row[1][1] - row[0][1] * out.shear];\n      out.scaley = math.sqrt(norm(row[1]));\n      normalize(row[1]);\n      out.shear /= out.scaley;\n\n      if (this.determinant() < 0) {\n        out.scalex = -out.scalex;\n      } // rotation\n\n\n      var sin = row[0][1],\n          cos = row[1][1];\n\n      if (cos < 0) {\n        out.rotate = Snap.deg(math.acos(cos));\n\n        if (sin < 0) {\n          out.rotate = 360 - out.rotate;\n        }\n      } else {\n        out.rotate = Snap.deg(math.asin(sin));\n      }\n\n      out.isSimple = !+out.shear.toFixed(9) && (out.scalex.toFixed(9) == out.scaley.toFixed(9) || !out.rotate);\n      out.isSuperSimple = !+out.shear.toFixed(9) && out.scalex.toFixed(9) == out.scaley.toFixed(9) && !out.rotate;\n      out.noRotation = !+out.shear.toFixed(9) && !out.rotate;\n      return out;\n    };\n    /*\\\n     * Matrix.toTransformString\n     [ method ]\n     **\n     * Returns transform string that represents given matrix\n     = (string) transform string\n    \\*/\n\n\n    matrixproto.toTransformString = function (shorter) {\n      var s = shorter || this.split();\n\n      if (!+s.shear.toFixed(9)) {\n        s.scalex = +s.scalex.toFixed(4);\n        s.scaley = +s.scaley.toFixed(4);\n        s.rotate = +s.rotate.toFixed(4);\n        return (s.dx || s.dy ? \"t\" + [+s.dx.toFixed(4), +s.dy.toFixed(4)] : E) + (s.rotate ? \"r\" + [+s.rotate.toFixed(4), 0, 0] : E) + (s.scalex != 1 || s.scaley != 1 ? \"s\" + [s.scalex, s.scaley, 0, 0] : E);\n      } else {\n        return \"m\" + [this.get(0), this.get(1), this.get(2), this.get(3), this.get(4), this.get(5)];\n      }\n    };\n  })(Matrix.prototype);\n  /*\\\n   * Snap.Matrix\n   [ method ]\n   **\n   * Matrix constructor, extend on your own risk.\n   * To create matrices use @Snap.matrix.\n  \\*/\n\n\n  Snap.Matrix = Matrix;\n  /*\\\n   * Snap.matrix\n   [ method ]\n   **\n   * Utility method\n   **\n   * Returns a matrix based on the given parameters\n   - a (number)\n   - b (number)\n   - c (number)\n   - d (number)\n   - e (number)\n   - f (number)\n   * or\n   - svgMatrix (SVGMatrix)\n   = (object) @Matrix\n  \\*/\n\n  Snap.matrix = function (a, b, c, d, e, f) {\n    return new Matrix(a, b, c, d, e, f);\n  };\n}); // Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\nSnap.plugin(function (Snap, Element, Paper, glob, Fragment) {\n  var has = \"hasOwnProperty\",\n      make = Snap._.make,\n      wrap = Snap._.wrap,\n      is = Snap.is,\n      getSomeDefs = Snap._.getSomeDefs,\n      reURLValue = /^url\\((['\"]?)([^)]+)\\1\\)$/,\n      $ = Snap._.$,\n      URL = Snap.url,\n      Str = String,\n      separator = Snap._.separator,\n      E = \"\";\n  /*\\\n   * Snap.deurl\n   [ method ]\n   **\n   * Unwraps path from `\"url(<path>)\"`.\n   - value (string) url path\n   = (string) unwrapped path\n  \\*/\n\n  Snap.deurl = function (value) {\n    var res = String(value).match(reURLValue);\n    return res ? res[2] : value;\n  }; // Attributes event handlers\n\n\n  eve.on(\"snap.util.attr.mask\", function (value) {\n    if (value instanceof Element || value instanceof Fragment) {\n      eve.stop();\n\n      if (value instanceof Fragment && value.node.childNodes.length == 1) {\n        value = value.node.firstChild;\n        getSomeDefs(this).appendChild(value);\n        value = wrap(value);\n      }\n\n      if (value.type == \"mask\") {\n        var mask = value;\n      } else {\n        mask = make(\"mask\", getSomeDefs(this));\n        mask.node.appendChild(value.node);\n      }\n\n      !mask.node.id && $(mask.node, {\n        id: mask.id\n      });\n      $(this.node, {\n        mask: URL(mask.id)\n      });\n    }\n  });\n\n  (function (clipIt) {\n    eve.on(\"snap.util.attr.clip\", clipIt);\n    eve.on(\"snap.util.attr.clip-path\", clipIt);\n    eve.on(\"snap.util.attr.clipPath\", clipIt);\n  })(function (value) {\n    if (value instanceof Element || value instanceof Fragment) {\n      eve.stop();\n      var clip,\n          node = value.node;\n\n      while (node) {\n        if (node.nodeName === \"clipPath\") {\n          clip = new Element(node);\n          break;\n        }\n\n        if (node.nodeName === \"svg\") {\n          clip = undefined;\n          break;\n        }\n\n        node = node.parentNode;\n      }\n\n      if (!clip) {\n        clip = make(\"clipPath\", getSomeDefs(this));\n        clip.node.appendChild(value.node);\n        !clip.node.id && $(clip.node, {\n          id: clip.id\n        });\n      }\n\n      $(this.node, {\n        \"clip-path\": URL(clip.node.id || clip.id)\n      });\n    }\n  });\n\n  function fillStroke(name) {\n    return function (value) {\n      eve.stop();\n\n      if (value instanceof Fragment && value.node.childNodes.length == 1 && (value.node.firstChild.tagName == \"radialGradient\" || value.node.firstChild.tagName == \"linearGradient\" || value.node.firstChild.tagName == \"pattern\")) {\n        value = value.node.firstChild;\n        getSomeDefs(this).appendChild(value);\n        value = wrap(value);\n      }\n\n      if (value instanceof Element) {\n        if (value.type == \"radialGradient\" || value.type == \"linearGradient\" || value.type == \"pattern\") {\n          if (!value.node.id) {\n            $(value.node, {\n              id: value.id\n            });\n          }\n\n          var fill = URL(value.node.id);\n        } else {\n          fill = value.attr(name);\n        }\n      } else {\n        fill = Snap.color(value);\n\n        if (fill.error) {\n          var grad = Snap(getSomeDefs(this).ownerSVGElement).gradient(value);\n\n          if (grad) {\n            if (!grad.node.id) {\n              $(grad.node, {\n                id: grad.id\n              });\n            }\n\n            fill = URL(grad.node.id);\n          } else {\n            fill = value;\n          }\n        } else {\n          fill = Str(fill);\n        }\n      }\n\n      var attrs = {};\n      attrs[name] = fill;\n      $(this.node, attrs);\n      this.node.style[name] = E;\n    };\n  }\n\n  eve.on(\"snap.util.attr.fill\", fillStroke(\"fill\"));\n  eve.on(\"snap.util.attr.stroke\", fillStroke(\"stroke\"));\n  var gradrg = /^([lr])(?:\\(([^)]*)\\))?(.*)$/i;\n  eve.on(\"snap.util.grad.parse\", function parseGrad(string) {\n    string = Str(string);\n    var tokens = string.match(gradrg);\n\n    if (!tokens) {\n      return null;\n    }\n\n    var type = tokens[1],\n        params = tokens[2],\n        stops = tokens[3];\n    params = params.split(/\\s*,\\s*/).map(function (el) {\n      return +el == el ? +el : el;\n    });\n\n    if (params.length == 1 && params[0] == 0) {\n      params = [];\n    }\n\n    stops = stops.split(\"-\");\n    stops = stops.map(function (el) {\n      el = el.split(\":\");\n      var out = {\n        color: el[0]\n      };\n\n      if (el[1]) {\n        out.offset = parseFloat(el[1]);\n      }\n\n      return out;\n    });\n    var len = stops.length,\n        start = 0,\n        j = 0;\n\n    function seed(i, end) {\n      var step = (end - start) / (i - j);\n\n      for (var k = j; k < i; k++) {\n        stops[k].offset = +(+start + step * (k - j)).toFixed(2);\n      }\n\n      j = i;\n      start = end;\n    }\n\n    len--;\n\n    for (var i = 0; i < len; i++) {\n      if (\"offset\" in stops[i]) {\n        seed(i, stops[i].offset);\n      }\n    }\n\n    stops[len].offset = stops[len].offset || 100;\n    seed(len, stops[len].offset);\n    return {\n      type: type,\n      params: params,\n      stops: stops\n    };\n  });\n  eve.on(\"snap.util.attr.d\", function (value) {\n    eve.stop();\n\n    if (is(value, \"array\") && is(value[0], \"array\")) {\n      value = Snap.path.toString.call(value);\n    }\n\n    value = Str(value);\n\n    if (value.match(/[ruo]/i)) {\n      value = Snap.path.toAbsolute(value);\n    }\n\n    $(this.node, {\n      d: value\n    });\n  })(-1);\n  eve.on(\"snap.util.attr.#text\", function (value) {\n    eve.stop();\n    value = Str(value);\n    var txt = glob.doc.createTextNode(value);\n\n    while (this.node.firstChild) {\n      this.node.removeChild(this.node.firstChild);\n    }\n\n    this.node.appendChild(txt);\n  })(-1);\n  eve.on(\"snap.util.attr.path\", function (value) {\n    eve.stop();\n    this.attr({\n      d: value\n    });\n  })(-1);\n  eve.on(\"snap.util.attr.class\", function (value) {\n    eve.stop();\n    this.node.className.baseVal = value;\n  })(-1);\n  eve.on(\"snap.util.attr.viewBox\", function (value) {\n    var vb;\n\n    if (is(value, \"object\") && \"x\" in value) {\n      vb = [value.x, value.y, value.width, value.height].join(\" \");\n    } else if (is(value, \"array\")) {\n      vb = value.join(\" \");\n    } else {\n      vb = value;\n    }\n\n    $(this.node, {\n      viewBox: vb\n    });\n    eve.stop();\n  })(-1);\n  eve.on(\"snap.util.attr.transform\", function (value) {\n    this.transform(value);\n    eve.stop();\n  })(-1);\n  eve.on(\"snap.util.attr.r\", function (value) {\n    if (this.type == \"rect\") {\n      eve.stop();\n      $(this.node, {\n        rx: value,\n        ry: value\n      });\n    }\n  })(-1);\n  eve.on(\"snap.util.attr.textpath\", function (value) {\n    eve.stop();\n\n    if (this.type == \"text\") {\n      var id, tp, node;\n\n      if (!value && this.textPath) {\n        tp = this.textPath;\n\n        while (tp.node.firstChild) {\n          this.node.appendChild(tp.node.firstChild);\n        }\n\n        tp.remove();\n        delete this.textPath;\n        return;\n      }\n\n      if (is(value, \"string\")) {\n        var defs = getSomeDefs(this),\n            path = wrap(defs.parentNode).path(value);\n        defs.appendChild(path.node);\n        id = path.id;\n        path.attr({\n          id: id\n        });\n      } else {\n        value = wrap(value);\n\n        if (value instanceof Element) {\n          id = value.attr(\"id\");\n\n          if (!id) {\n            id = value.id;\n            value.attr({\n              id: id\n            });\n          }\n        }\n      }\n\n      if (id) {\n        tp = this.textPath;\n        node = this.node;\n\n        if (tp) {\n          tp.attr({\n            \"xlink:href\": \"#\" + id\n          });\n        } else {\n          tp = $(\"textPath\", {\n            \"xlink:href\": \"#\" + id\n          });\n\n          while (node.firstChild) {\n            tp.appendChild(node.firstChild);\n          }\n\n          node.appendChild(tp);\n          this.textPath = wrap(tp);\n        }\n      }\n    }\n  })(-1);\n  eve.on(\"snap.util.attr.text\", function (value) {\n    if (this.type == \"text\") {\n      var i = 0,\n          node = this.node,\n          tuner = function tuner(chunk) {\n        var out = $(\"tspan\");\n\n        if (is(chunk, \"array\")) {\n          for (var i = 0; i < chunk.length; i++) {\n            out.appendChild(tuner(chunk[i]));\n          }\n        } else {\n          out.appendChild(glob.doc.createTextNode(chunk));\n        }\n\n        out.normalize && out.normalize();\n        return out;\n      };\n\n      while (node.firstChild) {\n        node.removeChild(node.firstChild);\n      }\n\n      var tuned = tuner(value);\n\n      while (tuned.firstChild) {\n        node.appendChild(tuned.firstChild);\n      }\n    }\n\n    eve.stop();\n  })(-1);\n\n  function setFontSize(value) {\n    eve.stop();\n\n    if (value == +value) {\n      value += \"px\";\n    }\n\n    this.node.style.fontSize = value;\n  }\n\n  eve.on(\"snap.util.attr.fontSize\", setFontSize)(-1);\n  eve.on(\"snap.util.attr.font-size\", setFontSize)(-1);\n  eve.on(\"snap.util.getattr.transform\", function () {\n    eve.stop();\n    return this.transform();\n  })(-1);\n  eve.on(\"snap.util.getattr.textpath\", function () {\n    eve.stop();\n    return this.textPath;\n  })(-1); // Markers\n\n  (function () {\n    function getter(end) {\n      return function () {\n        eve.stop();\n        var style = glob.doc.defaultView.getComputedStyle(this.node, null).getPropertyValue(\"marker-\" + end);\n\n        if (style == \"none\") {\n          return style;\n        } else {\n          return Snap(glob.doc.getElementById(style.match(reURLValue)[1]));\n        }\n      };\n    }\n\n    function setter(end) {\n      return function (value) {\n        eve.stop();\n        var name = \"marker\" + end.charAt(0).toUpperCase() + end.substring(1);\n\n        if (value == \"\" || !value) {\n          this.node.style[name] = \"none\";\n          return;\n        }\n\n        if (value.type == \"marker\") {\n          var id = value.node.id;\n\n          if (!id) {\n            $(value.node, {\n              id: value.id\n            });\n          }\n\n          this.node.style[name] = URL(id);\n          return;\n        }\n      };\n    }\n\n    eve.on(\"snap.util.getattr.marker-end\", getter(\"end\"))(-1);\n    eve.on(\"snap.util.getattr.markerEnd\", getter(\"end\"))(-1);\n    eve.on(\"snap.util.getattr.marker-start\", getter(\"start\"))(-1);\n    eve.on(\"snap.util.getattr.markerStart\", getter(\"start\"))(-1);\n    eve.on(\"snap.util.getattr.marker-mid\", getter(\"mid\"))(-1);\n    eve.on(\"snap.util.getattr.markerMid\", getter(\"mid\"))(-1);\n    eve.on(\"snap.util.attr.marker-end\", setter(\"end\"))(-1);\n    eve.on(\"snap.util.attr.markerEnd\", setter(\"end\"))(-1);\n    eve.on(\"snap.util.attr.marker-start\", setter(\"start\"))(-1);\n    eve.on(\"snap.util.attr.markerStart\", setter(\"start\"))(-1);\n    eve.on(\"snap.util.attr.marker-mid\", setter(\"mid\"))(-1);\n    eve.on(\"snap.util.attr.markerMid\", setter(\"mid\"))(-1);\n  })();\n\n  eve.on(\"snap.util.getattr.r\", function () {\n    if (this.type == \"rect\" && $(this.node, \"rx\") == $(this.node, \"ry\")) {\n      eve.stop();\n      return $(this.node, \"rx\");\n    }\n  })(-1);\n\n  function textExtract(node) {\n    var out = [];\n    var children = node.childNodes;\n\n    for (var i = 0, ii = children.length; i < ii; i++) {\n      var chi = children[i];\n\n      if (chi.nodeType == 3) {\n        out.push(chi.nodeValue);\n      }\n\n      if (chi.tagName == \"tspan\") {\n        if (chi.childNodes.length == 1 && chi.firstChild.nodeType == 3) {\n          out.push(chi.firstChild.nodeValue);\n        } else {\n          out.push(textExtract(chi));\n        }\n      }\n    }\n\n    return out;\n  }\n\n  eve.on(\"snap.util.getattr.text\", function () {\n    if (this.type == \"text\" || this.type == \"tspan\") {\n      eve.stop();\n      var out = textExtract(this.node);\n      return out.length == 1 ? out[0] : out;\n    }\n  })(-1);\n  eve.on(\"snap.util.getattr.#text\", function () {\n    return this.node.textContent;\n  })(-1);\n  eve.on(\"snap.util.getattr.fill\", function (internal) {\n    if (internal) {\n      return;\n    }\n\n    eve.stop();\n    var value = eve(\"snap.util.getattr.fill\", this, true).firstDefined();\n    return Snap(Snap.deurl(value)) || value;\n  })(-1);\n  eve.on(\"snap.util.getattr.stroke\", function (internal) {\n    if (internal) {\n      return;\n    }\n\n    eve.stop();\n    var value = eve(\"snap.util.getattr.stroke\", this, true).firstDefined();\n    return Snap(Snap.deurl(value)) || value;\n  })(-1);\n  eve.on(\"snap.util.getattr.viewBox\", function () {\n    eve.stop();\n    var vb = $(this.node, \"viewBox\");\n\n    if (vb) {\n      vb = vb.split(separator);\n      return Snap._.box(+vb[0], +vb[1], +vb[2], +vb[3]);\n    } else {\n      return;\n    }\n  })(-1);\n  eve.on(\"snap.util.getattr.points\", function () {\n    var p = $(this.node, \"points\");\n    eve.stop();\n\n    if (p) {\n      return p.split(separator);\n    } else {\n      return;\n    }\n  })(-1);\n  eve.on(\"snap.util.getattr.path\", function () {\n    var p = $(this.node, \"d\");\n    eve.stop();\n    return p;\n  })(-1);\n  eve.on(\"snap.util.getattr.class\", function () {\n    return this.node.className.baseVal;\n  })(-1);\n\n  function getFontSize() {\n    eve.stop();\n    return this.node.style.fontSize;\n  }\n\n  eve.on(\"snap.util.getattr.fontSize\", getFontSize)(-1);\n  eve.on(\"snap.util.getattr.font-size\", getFontSize)(-1);\n}); // Copyright (c) 2014 Adobe Systems Incorporated. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\nSnap.plugin(function (Snap, Element, Paper, glob, Fragment) {\n  var rgNotSpace = /\\S+/g,\n      rgBadSpace = /[\\t\\r\\n\\f]/g,\n      rgTrim = /(^\\s+|\\s+$)/g,\n      Str = String,\n      elproto = Element.prototype;\n  /*\\\n   * Element.addClass\n   [ method ]\n   **\n   * Adds given class name or list of class names to the element.\n   - value (string) class name or space separated list of class names\n   **\n   = (Element) original element.\n  \\*/\n\n  elproto.addClass = function (value) {\n    var classes = Str(value || \"\").match(rgNotSpace) || [],\n        elem = this.node,\n        className = elem.className.baseVal,\n        curClasses = className.match(rgNotSpace) || [],\n        j,\n        pos,\n        clazz,\n        finalValue;\n\n    if (classes.length) {\n      j = 0;\n\n      while (clazz = classes[j++]) {\n        pos = curClasses.indexOf(clazz);\n\n        if (!~pos) {\n          curClasses.push(clazz);\n        }\n      }\n\n      finalValue = curClasses.join(\" \");\n\n      if (className != finalValue) {\n        elem.className.baseVal = finalValue;\n      }\n    }\n\n    return this;\n  };\n  /*\\\n   * Element.removeClass\n   [ method ]\n   **\n   * Removes given class name or list of class names from the element.\n   - value (string) class name or space separated list of class names\n   **\n   = (Element) original element.\n  \\*/\n\n\n  elproto.removeClass = function (value) {\n    var classes = Str(value || \"\").match(rgNotSpace) || [],\n        elem = this.node,\n        className = elem.className.baseVal,\n        curClasses = className.match(rgNotSpace) || [],\n        j,\n        pos,\n        clazz,\n        finalValue;\n\n    if (curClasses.length) {\n      j = 0;\n\n      while (clazz = classes[j++]) {\n        pos = curClasses.indexOf(clazz);\n\n        if (~pos) {\n          curClasses.splice(pos, 1);\n        }\n      }\n\n      finalValue = curClasses.join(\" \");\n\n      if (className != finalValue) {\n        elem.className.baseVal = finalValue;\n      }\n    }\n\n    return this;\n  };\n  /*\\\n   * Element.hasClass\n   [ method ]\n   **\n   * Checks if the element has a given class name in the list of class names applied to it.\n   - value (string) class name\n   **\n   = (boolean) `true` if the element has given class\n  \\*/\n\n\n  elproto.hasClass = function (value) {\n    var elem = this.node,\n        className = elem.className.baseVal,\n        curClasses = className.match(rgNotSpace) || [];\n    return !!~curClasses.indexOf(value);\n  };\n  /*\\\n   * Element.toggleClass\n   [ method ]\n   **\n   * Add or remove one or more classes from the element, depending on either\n   * the class’s presence or the value of the `flag` argument.\n   - value (string) class name or space separated list of class names\n   - flag (boolean) value to determine whether the class should be added or removed\n   **\n   = (Element) original element.\n  \\*/\n\n\n  elproto.toggleClass = function (value, flag) {\n    if (flag != null) {\n      if (flag) {\n        return this.addClass(value);\n      } else {\n        return this.removeClass(value);\n      }\n    }\n\n    var classes = (value || \"\").match(rgNotSpace) || [],\n        elem = this.node,\n        className = elem.className.baseVal,\n        curClasses = className.match(rgNotSpace) || [],\n        j,\n        pos,\n        clazz,\n        finalValue;\n    j = 0;\n\n    while (clazz = classes[j++]) {\n      pos = curClasses.indexOf(clazz);\n\n      if (~pos) {\n        curClasses.splice(pos, 1);\n      } else {\n        curClasses.push(clazz);\n      }\n    }\n\n    finalValue = curClasses.join(\" \");\n\n    if (className != finalValue) {\n      elem.className.baseVal = finalValue;\n    }\n\n    return this;\n  };\n}); // Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\nSnap.plugin(function (Snap, Element, Paper, glob, Fragment) {\n  var operators = {\n    \"+\": function _(x, y) {\n      return x + y;\n    },\n    \"-\": function _(x, y) {\n      return x - y;\n    },\n    \"/\": function _(x, y) {\n      return x / y;\n    },\n    \"*\": function _(x, y) {\n      return x * y;\n    }\n  },\n      Str = String,\n      reUnit = /[a-z]+$/i,\n      reAddon = /^\\s*([+\\-\\/*])\\s*=\\s*([\\d.eE+\\-]+)\\s*([^\\d\\s]+)?\\s*$/;\n\n  function getNumber(val) {\n    return val;\n  }\n\n  function getUnit(unit) {\n    return function (val) {\n      return +val.toFixed(3) + unit;\n    };\n  }\n\n  eve.on(\"snap.util.attr\", function (val) {\n    var plus = Str(val).match(reAddon);\n\n    if (plus) {\n      var evnt = eve.nt(),\n          name = evnt.substring(evnt.lastIndexOf(\".\") + 1),\n          a = this.attr(name),\n          atr = {};\n      eve.stop();\n      var unit = plus[3] || \"\",\n          aUnit = a.match(reUnit),\n          op = operators[plus[1]];\n\n      if (aUnit && aUnit == unit) {\n        val = op(parseFloat(a), +plus[2]);\n      } else {\n        a = this.asPX(name);\n        val = op(this.asPX(name), this.asPX(name, plus[2] + unit));\n      }\n\n      if (isNaN(a) || isNaN(val)) {\n        return;\n      }\n\n      atr[name] = val;\n      this.attr(atr);\n    }\n  })(-10);\n  eve.on(\"snap.util.equal\", function (name, b) {\n    var A,\n        B,\n        a = Str(this.attr(name) || \"\"),\n        el = this,\n        bplus = Str(b).match(reAddon);\n\n    if (bplus) {\n      eve.stop();\n      var unit = bplus[3] || \"\",\n          aUnit = a.match(reUnit),\n          op = operators[bplus[1]];\n\n      if (aUnit && aUnit == unit) {\n        return {\n          from: parseFloat(a),\n          to: op(parseFloat(a), +bplus[2]),\n          f: getUnit(aUnit)\n        };\n      } else {\n        a = this.asPX(name);\n        return {\n          from: a,\n          to: op(a, this.asPX(name, bplus[2] + unit)),\n          f: getNumber\n        };\n      }\n    }\n  })(-10);\n}); // Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\nSnap.plugin(function (Snap, Element, Paper, glob, Fragment) {\n  var proto = Paper.prototype,\n      is = Snap.is;\n  /*\\\n   * Paper.rect\n   [ method ]\n   *\n   * Draws a rectangle\n   **\n   - x (number) x coordinate of the top left corner\n   - y (number) y coordinate of the top left corner\n   - width (number) width\n   - height (number) height\n   - rx (number) #optional horizontal radius for rounded corners, default is 0\n   - ry (number) #optional vertical radius for rounded corners, default is rx or 0\n   = (object) the `rect` element\n   **\n   > Usage\n   | // regular rectangle\n   | var c = paper.rect(10, 10, 50, 50);\n   | // rectangle with rounded corners\n   | var c = paper.rect(40, 40, 50, 50, 10);\n  \\*/\n\n  proto.rect = function (x, y, w, h, rx, ry) {\n    var attr;\n\n    if (ry == null) {\n      ry = rx;\n    }\n\n    if (is(x, \"object\") && x == \"[object Object]\") {\n      attr = x;\n    } else if (x != null) {\n      attr = {\n        x: x,\n        y: y,\n        width: w,\n        height: h\n      };\n\n      if (rx != null) {\n        attr.rx = rx;\n        attr.ry = ry;\n      }\n    }\n\n    return this.el(\"rect\", attr);\n  };\n  /*\\\n   * Paper.circle\n   [ method ]\n   **\n   * Draws a circle\n   **\n   - x (number) x coordinate of the centre\n   - y (number) y coordinate of the centre\n   - r (number) radius\n   = (object) the `circle` element\n   **\n   > Usage\n   | var c = paper.circle(50, 50, 40);\n  \\*/\n\n\n  proto.circle = function (cx, cy, r) {\n    var attr;\n\n    if (is(cx, \"object\") && cx == \"[object Object]\") {\n      attr = cx;\n    } else if (cx != null) {\n      attr = {\n        cx: cx,\n        cy: cy,\n        r: r\n      };\n    }\n\n    return this.el(\"circle\", attr);\n  };\n\n  var preload = function () {\n    function onerror() {\n      this.parentNode.removeChild(this);\n    }\n\n    return function (src, f) {\n      var img = glob.doc.createElement(\"img\"),\n          body = glob.doc.body;\n      img.style.cssText = \"position:absolute;left:-9999em;top:-9999em\";\n\n      img.onload = function () {\n        f.call(img);\n        img.onload = img.onerror = null;\n        body.removeChild(img);\n      };\n\n      img.onerror = onerror;\n      body.appendChild(img);\n      img.src = src;\n    };\n  }();\n  /*\\\n   * Paper.image\n   [ method ]\n   **\n   * Places an image on the surface\n   **\n   - src (string) URI of the source image\n   - x (number) x offset position\n   - y (number) y offset position\n   - width (number) width of the image\n   - height (number) height of the image\n   = (object) the `image` element\n   * or\n   = (object) Snap element object with type `image`\n   **\n   > Usage\n   | var c = paper.image(\"apple.png\", 10, 10, 80, 80);\n  \\*/\n\n\n  proto.image = function (src, x, y, width, height) {\n    var el = this.el(\"image\");\n\n    if (is(src, \"object\") && \"src\" in src) {\n      el.attr(src);\n    } else if (src != null) {\n      var set = {\n        \"xlink:href\": src,\n        preserveAspectRatio: \"none\"\n      };\n\n      if (x != null && y != null) {\n        set.x = x;\n        set.y = y;\n      }\n\n      if (width != null && height != null) {\n        set.width = width;\n        set.height = height;\n      } else {\n        preload(src, function () {\n          Snap._.$(el.node, {\n            width: this.offsetWidth,\n            height: this.offsetHeight\n          });\n        });\n      }\n\n      Snap._.$(el.node, set);\n    }\n\n    return el;\n  };\n  /*\\\n   * Paper.ellipse\n   [ method ]\n   **\n   * Draws an ellipse\n   **\n   - x (number) x coordinate of the centre\n   - y (number) y coordinate of the centre\n   - rx (number) horizontal radius\n   - ry (number) vertical radius\n   = (object) the `ellipse` element\n   **\n   > Usage\n   | var c = paper.ellipse(50, 50, 40, 20);\n  \\*/\n\n\n  proto.ellipse = function (cx, cy, rx, ry) {\n    var attr;\n\n    if (is(cx, \"object\") && cx == \"[object Object]\") {\n      attr = cx;\n    } else if (cx != null) {\n      attr = {\n        cx: cx,\n        cy: cy,\n        rx: rx,\n        ry: ry\n      };\n    }\n\n    return this.el(\"ellipse\", attr);\n  }; // SIERRA Paper.path(): Unclear from the link what a Catmull-Rom curveto is, and why it would make life any easier.\n\n  /*\\\n   * Paper.path\n   [ method ]\n   **\n   * Creates a `<path>` element using the given string as the path's definition\n   - pathString (string) #optional path string in SVG format\n   * Path string consists of one-letter commands, followed by comma seprarated arguments in numerical form. Example:\n   | \"M10,20L30,40\"\n   * This example features two commands: `M`, with arguments `(10, 20)` and `L` with arguments `(30, 40)`. Uppercase letter commands express coordinates in absolute terms, while lowercase commands express them in relative terms from the most recently declared coordinates.\n   *\n   # <p>Here is short list of commands available, for more details see <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" title=\"Details of a path's data attribute's format are described in the SVG specification.\">SVG path string format</a> or <a href=\"https://developer.mozilla.org/en/SVG/Tutorial/Paths\">article about path strings at MDN</a>.</p>\n   # <table><thead><tr><th>Command</th><th>Name</th><th>Parameters</th></tr></thead><tbody>\n   # <tr><td>M</td><td>moveto</td><td>(x y)+</td></tr>\n   # <tr><td>Z</td><td>closepath</td><td>(none)</td></tr>\n   # <tr><td>L</td><td>lineto</td><td>(x y)+</td></tr>\n   # <tr><td>H</td><td>horizontal lineto</td><td>x+</td></tr>\n   # <tr><td>V</td><td>vertical lineto</td><td>y+</td></tr>\n   # <tr><td>C</td><td>curveto</td><td>(x1 y1 x2 y2 x y)+</td></tr>\n   # <tr><td>S</td><td>smooth curveto</td><td>(x2 y2 x y)+</td></tr>\n   # <tr><td>Q</td><td>quadratic Bézier curveto</td><td>(x1 y1 x y)+</td></tr>\n   # <tr><td>T</td><td>smooth quadratic Bézier curveto</td><td>(x y)+</td></tr>\n   # <tr><td>A</td><td>elliptical arc</td><td>(rx ry x-axis-rotation large-arc-flag sweep-flag x y)+</td></tr>\n   # <tr><td>R</td><td><a href=\"http://en.wikipedia.org/wiki/Catmull–Rom_spline#Catmull.E2.80.93Rom_spline\">Catmull-Rom curveto</a>*</td><td>x1 y1 (x y)+</td></tr></tbody></table>\n   * * _Catmull-Rom curveto_ is a not standard SVG command and added to make life easier.\n   * Note: there is a special case when a path consists of only three commands: `M10,10R…z`. In this case the path connects back to its starting point.\n   > Usage\n   | var c = paper.path(\"M10 10L90 90\");\n   | // draw a diagonal line:\n   | // move to 10,10, line to 90,90\n  \\*/\n\n\n  proto.path = function (d) {\n    var attr;\n\n    if (is(d, \"object\") && !is(d, \"array\")) {\n      attr = d;\n    } else if (d) {\n      attr = {\n        d: d\n      };\n    }\n\n    return this.el(\"path\", attr);\n  };\n  /*\\\n   * Paper.g\n   [ method ]\n   **\n   * Creates a group element\n   **\n   - varargs (…) #optional elements to nest within the group\n   = (object) the `g` element\n   **\n   > Usage\n   | var c1 = paper.circle(),\n   |     c2 = paper.rect(),\n   |     g = paper.g(c2, c1); // note that the order of elements is different\n   * or\n   | var c1 = paper.circle(),\n   |     c2 = paper.rect(),\n   |     g = paper.g();\n   | g.add(c2, c1);\n  \\*/\n\n  /*\\\n   * Paper.group\n   [ method ]\n   **\n   * See @Paper.g\n  \\*/\n\n\n  proto.group = proto.g = function (first) {\n    var attr,\n        el = this.el(\"g\");\n\n    if (arguments.length == 1 && first && !first.type) {\n      el.attr(first);\n    } else if (arguments.length) {\n      el.add(Array.prototype.slice.call(arguments, 0));\n    }\n\n    return el;\n  };\n  /*\\\n   * Paper.svg\n   [ method ]\n   **\n   * Creates a nested SVG element.\n   - x (number) @optional X of the element\n   - y (number) @optional Y of the element\n   - width (number) @optional width of the element\n   - height (number) @optional height of the element\n   - vbx (number) @optional viewbox X\n   - vby (number) @optional viewbox Y\n   - vbw (number) @optional viewbox width\n   - vbh (number) @optional viewbox height\n   **\n   = (object) the `svg` element\n   **\n  \\*/\n\n\n  proto.svg = function (x, y, width, height, vbx, vby, vbw, vbh) {\n    var attrs = {};\n\n    if (is(x, \"object\") && y == null) {\n      attrs = x;\n    } else {\n      if (x != null) {\n        attrs.x = x;\n      }\n\n      if (y != null) {\n        attrs.y = y;\n      }\n\n      if (width != null) {\n        attrs.width = width;\n      }\n\n      if (height != null) {\n        attrs.height = height;\n      }\n\n      if (vbx != null && vby != null && vbw != null && vbh != null) {\n        attrs.viewBox = [vbx, vby, vbw, vbh];\n      }\n    }\n\n    return this.el(\"svg\", attrs);\n  };\n  /*\\\n   * Paper.mask\n   [ method ]\n   **\n   * Equivalent in behaviour to @Paper.g, except it’s a mask.\n   **\n   = (object) the `mask` element\n   **\n  \\*/\n\n\n  proto.mask = function (first) {\n    var attr,\n        el = this.el(\"mask\");\n\n    if (arguments.length == 1 && first && !first.type) {\n      el.attr(first);\n    } else if (arguments.length) {\n      el.add(Array.prototype.slice.call(arguments, 0));\n    }\n\n    return el;\n  };\n  /*\\\n   * Paper.ptrn\n   [ method ]\n   **\n   * Equivalent in behaviour to @Paper.g, except it’s a pattern.\n   - x (number) @optional X of the element\n   - y (number) @optional Y of the element\n   - width (number) @optional width of the element\n   - height (number) @optional height of the element\n   - vbx (number) @optional viewbox X\n   - vby (number) @optional viewbox Y\n   - vbw (number) @optional viewbox width\n   - vbh (number) @optional viewbox height\n   **\n   = (object) the `pattern` element\n   **\n  \\*/\n\n\n  proto.ptrn = function (x, y, width, height, vx, vy, vw, vh) {\n    if (is(x, \"object\")) {\n      var attr = x;\n    } else {\n      attr = {\n        patternUnits: \"userSpaceOnUse\"\n      };\n\n      if (x) {\n        attr.x = x;\n      }\n\n      if (y) {\n        attr.y = y;\n      }\n\n      if (width != null) {\n        attr.width = width;\n      }\n\n      if (height != null) {\n        attr.height = height;\n      }\n\n      if (vx != null && vy != null && vw != null && vh != null) {\n        attr.viewBox = [vx, vy, vw, vh];\n      } else {\n        attr.viewBox = [x || 0, y || 0, width || 0, height || 0];\n      }\n    }\n\n    return this.el(\"pattern\", attr);\n  };\n  /*\\\n   * Paper.use\n   [ method ]\n   **\n   * Creates a <use> element.\n   - id (string) @optional id of element to link\n   * or\n   - id (Element) @optional element to link\n   **\n   = (object) the `use` element\n   **\n  \\*/\n\n\n  proto.use = function (id) {\n    if (id != null) {\n      if (id instanceof Element) {\n        if (!id.attr(\"id\")) {\n          id.attr({\n            id: Snap._.id(id)\n          });\n        }\n\n        id = id.attr(\"id\");\n      }\n\n      if (String(id).charAt() == \"#\") {\n        id = id.substring(1);\n      }\n\n      return this.el(\"use\", {\n        \"xlink:href\": \"#\" + id\n      });\n    } else {\n      return Element.prototype.use.call(this);\n    }\n  };\n  /*\\\n   * Paper.symbol\n   [ method ]\n   **\n   * Creates a <symbol> element.\n   - vbx (number) @optional viewbox X\n   - vby (number) @optional viewbox Y\n   - vbw (number) @optional viewbox width\n   - vbh (number) @optional viewbox height\n   = (object) the `symbol` element\n   **\n  \\*/\n\n\n  proto.symbol = function (vx, vy, vw, vh) {\n    var attr = {};\n\n    if (vx != null && vy != null && vw != null && vh != null) {\n      attr.viewBox = [vx, vy, vw, vh];\n    }\n\n    return this.el(\"symbol\", attr);\n  };\n  /*\\\n   * Paper.text\n   [ method ]\n   **\n   * Draws a text string\n   **\n   - x (number) x coordinate position\n   - y (number) y coordinate position\n   - text (string|array) The text string to draw or array of strings to nest within separate `<tspan>` elements\n   = (object) the `text` element\n   **\n   > Usage\n   | var t1 = paper.text(50, 50, \"Snap\");\n   | var t2 = paper.text(50, 50, [\"S\",\"n\",\"a\",\"p\"]);\n   | // Text path usage\n   | t1.attr({textpath: \"M10,10L100,100\"});\n   | // or\n   | var pth = paper.path(\"M10,10L100,100\");\n   | t1.attr({textpath: pth});\n  \\*/\n\n\n  proto.text = function (x, y, text) {\n    var attr = {};\n\n    if (is(x, \"object\")) {\n      attr = x;\n    } else if (x != null) {\n      attr = {\n        x: x,\n        y: y,\n        text: text || \"\"\n      };\n    }\n\n    return this.el(\"text\", attr);\n  };\n  /*\\\n   * Paper.line\n   [ method ]\n   **\n   * Draws a line\n   **\n   - x1 (number) x coordinate position of the start\n   - y1 (number) y coordinate position of the start\n   - x2 (number) x coordinate position of the end\n   - y2 (number) y coordinate position of the end\n   = (object) the `line` element\n   **\n   > Usage\n   | var t1 = paper.line(50, 50, 100, 100);\n  \\*/\n\n\n  proto.line = function (x1, y1, x2, y2) {\n    var attr = {};\n\n    if (is(x1, \"object\")) {\n      attr = x1;\n    } else if (x1 != null) {\n      attr = {\n        x1: x1,\n        x2: x2,\n        y1: y1,\n        y2: y2\n      };\n    }\n\n    return this.el(\"line\", attr);\n  };\n  /*\\\n   * Paper.polyline\n   [ method ]\n   **\n   * Draws a polyline\n   **\n   - points (array) array of points\n   * or\n   - varargs (…) points\n   = (object) the `polyline` element\n   **\n   > Usage\n   | var p1 = paper.polyline([10, 10, 100, 100]);\n   | var p2 = paper.polyline(10, 10, 100, 100);\n  \\*/\n\n\n  proto.polyline = function (points) {\n    if (arguments.length > 1) {\n      points = Array.prototype.slice.call(arguments, 0);\n    }\n\n    var attr = {};\n\n    if (is(points, \"object\") && !is(points, \"array\")) {\n      attr = points;\n    } else if (points != null) {\n      attr = {\n        points: points\n      };\n    }\n\n    return this.el(\"polyline\", attr);\n  };\n  /*\\\n   * Paper.polygon\n   [ method ]\n   **\n   * Draws a polygon. See @Paper.polyline\n  \\*/\n\n\n  proto.polygon = function (points) {\n    if (arguments.length > 1) {\n      points = Array.prototype.slice.call(arguments, 0);\n    }\n\n    var attr = {};\n\n    if (is(points, \"object\") && !is(points, \"array\")) {\n      attr = points;\n    } else if (points != null) {\n      attr = {\n        points: points\n      };\n    }\n\n    return this.el(\"polygon\", attr);\n  }; // gradients\n\n\n  (function () {\n    var $ = Snap._.$; // gradients' helpers\n\n    /*\\\n     * Element.stops\n     [ method ]\n     **\n     * Only for gradients!\n     * Returns array of gradient stops elements.\n     = (array) the stops array.\n    \\*/\n\n    function Gstops() {\n      return this.selectAll(\"stop\");\n    }\n    /*\\\n     * Element.addStop\n     [ method ]\n     **\n     * Only for gradients!\n     * Adds another stop to the gradient.\n     - color (string) stops color\n     - offset (number) stops offset 0..100\n     = (object) gradient element\n    \\*/\n\n\n    function GaddStop(color, offset) {\n      var stop = $(\"stop\"),\n          attr = {\n        offset: +offset + \"%\"\n      };\n      color = Snap.color(color);\n      attr[\"stop-color\"] = color.hex;\n\n      if (color.opacity < 1) {\n        attr[\"stop-opacity\"] = color.opacity;\n      }\n\n      $(stop, attr);\n      var stops = this.stops(),\n          inserted;\n\n      for (var i = 0; i < stops.length; i++) {\n        var stopOffset = parseFloat(stops[i].attr(\"offset\"));\n\n        if (stopOffset > offset) {\n          this.node.insertBefore(stop, stops[i].node);\n          inserted = true;\n          break;\n        }\n      }\n\n      if (!inserted) {\n        this.node.appendChild(stop);\n      }\n\n      return this;\n    }\n\n    function GgetBBox() {\n      if (this.type == \"linearGradient\") {\n        var x1 = $(this.node, \"x1\") || 0,\n            x2 = $(this.node, \"x2\") || 1,\n            y1 = $(this.node, \"y1\") || 0,\n            y2 = $(this.node, \"y2\") || 0;\n        return Snap._.box(x1, y1, math.abs(x2 - x1), math.abs(y2 - y1));\n      } else {\n        var cx = this.node.cx || .5,\n            cy = this.node.cy || .5,\n            r = this.node.r || 0;\n        return Snap._.box(cx - r, cy - r, r * 2, r * 2);\n      }\n    }\n    /*\\\n     * Element.setStops\n     [ method ]\n     **\n     * Only for gradients!\n     * Updates stops of the gradient based on passed gradient descriptor. See @Ppaer.gradient\n     - str (string) gradient descriptor part after `()`.\n     = (object) gradient element\n     | var g = paper.gradient(\"l(0, 0, 1, 1)#000-#f00-#fff\");\n     | g.setStops(\"#fff-#000-#f00-#fc0\");\n    \\*/\n\n\n    function GsetStops(str) {\n      var grad = str,\n          stops = this.stops();\n\n      if (typeof str == \"string\") {\n        grad = eve(\"snap.util.grad.parse\", null, \"l(0,0,0,1)\" + str).firstDefined().stops;\n      }\n\n      if (!Snap.is(grad, \"array\")) {\n        return;\n      }\n\n      for (var i = 0; i < stops.length; i++) {\n        if (grad[i]) {\n          var color = Snap.color(grad[i].color),\n              attr = {\n            \"offset\": grad[i].offset + \"%\"\n          };\n          attr[\"stop-color\"] = color.hex;\n\n          if (color.opacity < 1) {\n            attr[\"stop-opacity\"] = color.opacity;\n          }\n\n          stops[i].attr(attr);\n        } else {\n          stops[i].remove();\n        }\n      }\n\n      for (i = stops.length; i < grad.length; i++) {\n        this.addStop(grad[i].color, grad[i].offset);\n      }\n\n      return this;\n    }\n\n    function gradient(defs, str) {\n      var grad = eve(\"snap.util.grad.parse\", null, str).firstDefined(),\n          el;\n\n      if (!grad) {\n        return null;\n      }\n\n      grad.params.unshift(defs);\n\n      if (grad.type.toLowerCase() == \"l\") {\n        el = gradientLinear.apply(0, grad.params);\n      } else {\n        el = gradientRadial.apply(0, grad.params);\n      }\n\n      if (grad.type != grad.type.toLowerCase()) {\n        $(el.node, {\n          gradientUnits: \"userSpaceOnUse\"\n        });\n      }\n\n      var stops = grad.stops,\n          len = stops.length;\n\n      for (var i = 0; i < len; i++) {\n        var stop = stops[i];\n        el.addStop(stop.color, stop.offset);\n      }\n\n      return el;\n    }\n\n    function gradientLinear(defs, x1, y1, x2, y2) {\n      var el = Snap._.make(\"linearGradient\", defs);\n\n      el.stops = Gstops;\n      el.addStop = GaddStop;\n      el.getBBox = GgetBBox;\n      el.setStops = GsetStops;\n\n      if (x1 != null) {\n        $(el.node, {\n          x1: x1,\n          y1: y1,\n          x2: x2,\n          y2: y2\n        });\n      }\n\n      return el;\n    }\n\n    function gradientRadial(defs, cx, cy, r, fx, fy) {\n      var el = Snap._.make(\"radialGradient\", defs);\n\n      el.stops = Gstops;\n      el.addStop = GaddStop;\n      el.getBBox = GgetBBox;\n\n      if (cx != null) {\n        $(el.node, {\n          cx: cx,\n          cy: cy,\n          r: r\n        });\n      }\n\n      if (fx != null && fy != null) {\n        $(el.node, {\n          fx: fx,\n          fy: fy\n        });\n      }\n\n      return el;\n    }\n    /*\\\n     * Paper.gradient\n     [ method ]\n     **\n     * Creates a gradient element\n     **\n     - gradient (string) gradient descriptor\n     > Gradient Descriptor\n     * The gradient descriptor is an expression formatted as\n     * follows: `<type>(<coords>)<colors>`.  The `<type>` can be\n     * either linear or radial.  The uppercase `L` or `R` letters\n     * indicate absolute coordinates offset from the SVG surface.\n     * Lowercase `l` or `r` letters indicate coordinates\n     * calculated relative to the element to which the gradient is\n     * applied.  Coordinates specify a linear gradient vector as\n     * `x1`, `y1`, `x2`, `y2`, or a radial gradient as `cx`, `cy`,\n     * `r` and optional `fx`, `fy` specifying a focal point away\n     * from the center of the circle. Specify `<colors>` as a list\n     * of dash-separated CSS color values.  Each color may be\n     * followed by a custom offset value, separated with a colon\n     * character.\n     > Examples\n     * Linear gradient, relative from top-left corner to bottom-right\n     * corner, from black through red to white:\n     | var g = paper.gradient(\"l(0, 0, 1, 1)#000-#f00-#fff\");\n     * Linear gradient, absolute from (0, 0) to (100, 100), from black\n     * through red at 25% to white:\n     | var g = paper.gradient(\"L(0, 0, 100, 100)#000-#f00:25-#fff\");\n     * Radial gradient, relative from the center of the element with radius\n     * half the width, from black to white:\n     | var g = paper.gradient(\"r(0.5, 0.5, 0.5)#000-#fff\");\n     * To apply the gradient:\n     | paper.circle(50, 50, 40).attr({\n     |     fill: g\n     | });\n     = (object) the `gradient` element\n    \\*/\n\n\n    proto.gradient = function (str) {\n      return gradient(this.defs, str);\n    };\n\n    proto.gradientLinear = function (x1, y1, x2, y2) {\n      return gradientLinear(this.defs, x1, y1, x2, y2);\n    };\n\n    proto.gradientRadial = function (cx, cy, r, fx, fy) {\n      return gradientRadial(this.defs, cx, cy, r, fx, fy);\n    };\n    /*\\\n     * Paper.toString\n     [ method ]\n     **\n     * Returns SVG code for the @Paper\n     = (string) SVG code for the @Paper\n    \\*/\n\n\n    proto.toString = function () {\n      var doc = this.node.ownerDocument,\n          f = doc.createDocumentFragment(),\n          d = doc.createElement(\"div\"),\n          svg = this.node.cloneNode(true),\n          res;\n      f.appendChild(d);\n      d.appendChild(svg);\n\n      Snap._.$(svg, {\n        xmlns: \"http://www.w3.org/2000/svg\"\n      });\n\n      res = d.innerHTML;\n      f.removeChild(f.firstChild);\n      return res;\n    };\n    /*\\\n     * Paper.toDataURL\n     [ method ]\n     **\n     * Returns SVG code for the @Paper as Data URI string.\n     = (string) Data URI string\n    \\*/\n\n\n    proto.toDataURL = function () {\n      if (window && window.btoa) {\n        return \"data:image/svg+xml;base64,\" + btoa(unescape(encodeURIComponent(this)));\n      }\n    };\n    /*\\\n     * Paper.clear\n     [ method ]\n     **\n     * Removes all child nodes of the paper, except <defs>.\n    \\*/\n\n\n    proto.clear = function () {\n      var node = this.node.firstChild,\n          next;\n\n      while (node) {\n        next = node.nextSibling;\n\n        if (node.tagName != \"defs\") {\n          node.parentNode.removeChild(node);\n        } else {\n          proto.clear.call({\n            node: node\n          });\n        }\n\n        node = next;\n      }\n    };\n  })();\n}); // Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\nSnap.plugin(function (Snap, Element, Paper, glob) {\n  var elproto = Element.prototype,\n      is = Snap.is,\n      clone = Snap._.clone,\n      has = \"hasOwnProperty\",\n      p2s = /,?([a-z]),?/gi,\n      toFloat = parseFloat,\n      math = Math,\n      PI = math.PI,\n      mmin = math.min,\n      mmax = math.max,\n      pow = math.pow,\n      abs = math.abs;\n\n  function paths(ps) {\n    var p = paths.ps = paths.ps || {};\n\n    if (p[ps]) {\n      p[ps].sleep = 100;\n    } else {\n      p[ps] = {\n        sleep: 100\n      };\n    }\n\n    setTimeout(function () {\n      for (var key in p) {\n        if (p[has](key) && key != ps) {\n          p[key].sleep--;\n          !p[key].sleep && delete p[key];\n        }\n      }\n    });\n    return p[ps];\n  }\n\n  function box(x, y, width, height) {\n    if (x == null) {\n      x = y = width = height = 0;\n    }\n\n    if (y == null) {\n      y = x.y;\n      width = x.width;\n      height = x.height;\n      x = x.x;\n    }\n\n    return {\n      x: x,\n      y: y,\n      width: width,\n      w: width,\n      height: height,\n      h: height,\n      x2: x + width,\n      y2: y + height,\n      cx: x + width / 2,\n      cy: y + height / 2,\n      r1: math.min(width, height) / 2,\n      r2: math.max(width, height) / 2,\n      r0: math.sqrt(width * width + height * height) / 2,\n      path: rectPath(x, y, width, height),\n      vb: [x, y, width, height].join(\" \")\n    };\n  }\n\n  function toString() {\n    return this.join(\",\").replace(p2s, \"$1\");\n  }\n\n  function pathClone(pathArray) {\n    var res = clone(pathArray);\n    res.toString = toString;\n    return res;\n  }\n\n  function getPointAtSegmentLength(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, length) {\n    if (length == null) {\n      return bezlen(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y);\n    } else {\n      return findDotsAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, getTotLen(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, length));\n    }\n  }\n\n  function getLengthFactory(istotal, subpath) {\n    function O(val) {\n      return +(+val).toFixed(3);\n    }\n\n    return Snap._.cacher(function (path, length, onlystart) {\n      if (path instanceof Element) {\n        path = path.attr(\"d\");\n      }\n\n      path = path2curve(path);\n      var x,\n          y,\n          p,\n          l,\n          sp = \"\",\n          subpaths = {},\n          point,\n          len = 0;\n\n      for (var i = 0, ii = path.length; i < ii; i++) {\n        p = path[i];\n\n        if (p[0] == \"M\") {\n          x = +p[1];\n          y = +p[2];\n        } else {\n          l = getPointAtSegmentLength(x, y, p[1], p[2], p[3], p[4], p[5], p[6]);\n\n          if (len + l > length) {\n            if (subpath && !subpaths.start) {\n              point = getPointAtSegmentLength(x, y, p[1], p[2], p[3], p[4], p[5], p[6], length - len);\n              sp += [\"C\" + O(point.start.x), O(point.start.y), O(point.m.x), O(point.m.y), O(point.x), O(point.y)];\n\n              if (onlystart) {\n                return sp;\n              }\n\n              subpaths.start = sp;\n              sp = [\"M\" + O(point.x), O(point.y) + \"C\" + O(point.n.x), O(point.n.y), O(point.end.x), O(point.end.y), O(p[5]), O(p[6])].join();\n              len += l;\n              x = +p[5];\n              y = +p[6];\n              continue;\n            }\n\n            if (!istotal && !subpath) {\n              point = getPointAtSegmentLength(x, y, p[1], p[2], p[3], p[4], p[5], p[6], length - len);\n              return point;\n            }\n          }\n\n          len += l;\n          x = +p[5];\n          y = +p[6];\n        }\n\n        sp += p.shift() + p;\n      }\n\n      subpaths.end = sp;\n      point = istotal ? len : subpath ? subpaths : findDotsAtSegment(x, y, p[0], p[1], p[2], p[3], p[4], p[5], 1);\n      return point;\n    }, null, Snap._.clone);\n  }\n\n  var getTotalLength = getLengthFactory(1),\n      getPointAtLength = getLengthFactory(),\n      getSubpathsAtLength = getLengthFactory(0, 1);\n\n  function findDotsAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t) {\n    var t1 = 1 - t,\n        t13 = pow(t1, 3),\n        t12 = pow(t1, 2),\n        t2 = t * t,\n        t3 = t2 * t,\n        x = t13 * p1x + t12 * 3 * t * c1x + t1 * 3 * t * t * c2x + t3 * p2x,\n        y = t13 * p1y + t12 * 3 * t * c1y + t1 * 3 * t * t * c2y + t3 * p2y,\n        mx = p1x + 2 * t * (c1x - p1x) + t2 * (c2x - 2 * c1x + p1x),\n        my = p1y + 2 * t * (c1y - p1y) + t2 * (c2y - 2 * c1y + p1y),\n        nx = c1x + 2 * t * (c2x - c1x) + t2 * (p2x - 2 * c2x + c1x),\n        ny = c1y + 2 * t * (c2y - c1y) + t2 * (p2y - 2 * c2y + c1y),\n        ax = t1 * p1x + t * c1x,\n        ay = t1 * p1y + t * c1y,\n        cx = t1 * c2x + t * p2x,\n        cy = t1 * c2y + t * p2y,\n        alpha = 90 - math.atan2(mx - nx, my - ny) * 180 / PI; // (mx > nx || my < ny) && (alpha += 180);\n\n    return {\n      x: x,\n      y: y,\n      m: {\n        x: mx,\n        y: my\n      },\n      n: {\n        x: nx,\n        y: ny\n      },\n      start: {\n        x: ax,\n        y: ay\n      },\n      end: {\n        x: cx,\n        y: cy\n      },\n      alpha: alpha\n    };\n  }\n\n  function bezierBBox(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y) {\n    if (!Snap.is(p1x, \"array\")) {\n      p1x = [p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y];\n    }\n\n    var bbox = curveDim.apply(null, p1x);\n    return box(bbox.min.x, bbox.min.y, bbox.max.x - bbox.min.x, bbox.max.y - bbox.min.y);\n  }\n\n  function isPointInsideBBox(bbox, x, y) {\n    return x >= bbox.x && x <= bbox.x + bbox.width && y >= bbox.y && y <= bbox.y + bbox.height;\n  }\n\n  function isBBoxIntersect(bbox1, bbox2) {\n    bbox1 = box(bbox1);\n    bbox2 = box(bbox2);\n    return isPointInsideBBox(bbox2, bbox1.x, bbox1.y) || isPointInsideBBox(bbox2, bbox1.x2, bbox1.y) || isPointInsideBBox(bbox2, bbox1.x, bbox1.y2) || isPointInsideBBox(bbox2, bbox1.x2, bbox1.y2) || isPointInsideBBox(bbox1, bbox2.x, bbox2.y) || isPointInsideBBox(bbox1, bbox2.x2, bbox2.y) || isPointInsideBBox(bbox1, bbox2.x, bbox2.y2) || isPointInsideBBox(bbox1, bbox2.x2, bbox2.y2) || (bbox1.x < bbox2.x2 && bbox1.x > bbox2.x || bbox2.x < bbox1.x2 && bbox2.x > bbox1.x) && (bbox1.y < bbox2.y2 && bbox1.y > bbox2.y || bbox2.y < bbox1.y2 && bbox2.y > bbox1.y);\n  }\n\n  function base3(t, p1, p2, p3, p4) {\n    var t1 = -3 * p1 + 9 * p2 - 9 * p3 + 3 * p4,\n        t2 = t * t1 + 6 * p1 - 12 * p2 + 6 * p3;\n    return t * t2 - 3 * p1 + 3 * p2;\n  }\n\n  function bezlen(x1, y1, x2, y2, x3, y3, x4, y4, z) {\n    if (z == null) {\n      z = 1;\n    }\n\n    z = z > 1 ? 1 : z < 0 ? 0 : z;\n    var z2 = z / 2,\n        n = 12,\n        Tvalues = [-.1252, .1252, -.3678, .3678, -.5873, .5873, -.7699, .7699, -.9041, .9041, -.9816, .9816],\n        Cvalues = [0.2491, 0.2491, 0.2335, 0.2335, 0.2032, 0.2032, 0.1601, 0.1601, 0.1069, 0.1069, 0.0472, 0.0472],\n        sum = 0;\n\n    for (var i = 0; i < n; i++) {\n      var ct = z2 * Tvalues[i] + z2,\n          xbase = base3(ct, x1, x2, x3, x4),\n          ybase = base3(ct, y1, y2, y3, y4),\n          comb = xbase * xbase + ybase * ybase;\n      sum += Cvalues[i] * math.sqrt(comb);\n    }\n\n    return z2 * sum;\n  }\n\n  function getTotLen(x1, y1, x2, y2, x3, y3, x4, y4, ll) {\n    if (ll < 0 || bezlen(x1, y1, x2, y2, x3, y3, x4, y4) < ll) {\n      return;\n    }\n\n    var t = 1,\n        step = t / 2,\n        t2 = t - step,\n        l,\n        e = .01;\n    l = bezlen(x1, y1, x2, y2, x3, y3, x4, y4, t2);\n\n    while (abs(l - ll) > e) {\n      step /= 2;\n      t2 += (l < ll ? 1 : -1) * step;\n      l = bezlen(x1, y1, x2, y2, x3, y3, x4, y4, t2);\n    }\n\n    return t2;\n  }\n\n  function intersect(x1, y1, x2, y2, x3, y3, x4, y4) {\n    if (mmax(x1, x2) < mmin(x3, x4) || mmin(x1, x2) > mmax(x3, x4) || mmax(y1, y2) < mmin(y3, y4) || mmin(y1, y2) > mmax(y3, y4)) {\n      return;\n    }\n\n    var nx = (x1 * y2 - y1 * x2) * (x3 - x4) - (x1 - x2) * (x3 * y4 - y3 * x4),\n        ny = (x1 * y2 - y1 * x2) * (y3 - y4) - (y1 - y2) * (x3 * y4 - y3 * x4),\n        denominator = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);\n\n    if (!denominator) {\n      return;\n    }\n\n    var px = nx / denominator,\n        py = ny / denominator,\n        px2 = +px.toFixed(2),\n        py2 = +py.toFixed(2);\n\n    if (px2 < +mmin(x1, x2).toFixed(2) || px2 > +mmax(x1, x2).toFixed(2) || px2 < +mmin(x3, x4).toFixed(2) || px2 > +mmax(x3, x4).toFixed(2) || py2 < +mmin(y1, y2).toFixed(2) || py2 > +mmax(y1, y2).toFixed(2) || py2 < +mmin(y3, y4).toFixed(2) || py2 > +mmax(y3, y4).toFixed(2)) {\n      return;\n    }\n\n    return {\n      x: px,\n      y: py\n    };\n  }\n\n  function inter(bez1, bez2) {\n    return interHelper(bez1, bez2);\n  }\n\n  function interCount(bez1, bez2) {\n    return interHelper(bez1, bez2, 1);\n  }\n\n  function interHelper(bez1, bez2, justCount) {\n    var bbox1 = bezierBBox(bez1),\n        bbox2 = bezierBBox(bez2);\n\n    if (!isBBoxIntersect(bbox1, bbox2)) {\n      return justCount ? 0 : [];\n    }\n\n    var l1 = bezlen.apply(0, bez1),\n        l2 = bezlen.apply(0, bez2),\n        n1 = ~~(l1 / 8),\n        n2 = ~~(l2 / 8),\n        dots1 = [],\n        dots2 = [],\n        xy = {},\n        res = justCount ? 0 : [];\n\n    for (var i = 0; i < n1 + 1; i++) {\n      var p = findDotsAtSegment.apply(0, bez1.concat(i / n1));\n      dots1.push({\n        x: p.x,\n        y: p.y,\n        t: i / n1\n      });\n    }\n\n    for (i = 0; i < n2 + 1; i++) {\n      p = findDotsAtSegment.apply(0, bez2.concat(i / n2));\n      dots2.push({\n        x: p.x,\n        y: p.y,\n        t: i / n2\n      });\n    }\n\n    for (i = 0; i < n1; i++) {\n      for (var j = 0; j < n2; j++) {\n        var di = dots1[i],\n            di1 = dots1[i + 1],\n            dj = dots2[j],\n            dj1 = dots2[j + 1],\n            ci = abs(di1.x - di.x) < .001 ? \"y\" : \"x\",\n            cj = abs(dj1.x - dj.x) < .001 ? \"y\" : \"x\",\n            is = intersect(di.x, di.y, di1.x, di1.y, dj.x, dj.y, dj1.x, dj1.y);\n\n        if (is) {\n          if (xy[is.x.toFixed(4)] == is.y.toFixed(4)) {\n            continue;\n          }\n\n          xy[is.x.toFixed(4)] = is.y.toFixed(4);\n          var t1 = di.t + abs((is[ci] - di[ci]) / (di1[ci] - di[ci])) * (di1.t - di.t),\n              t2 = dj.t + abs((is[cj] - dj[cj]) / (dj1[cj] - dj[cj])) * (dj1.t - dj.t);\n\n          if (t1 >= 0 && t1 <= 1 && t2 >= 0 && t2 <= 1) {\n            if (justCount) {\n              res++;\n            } else {\n              res.push({\n                x: is.x,\n                y: is.y,\n                t1: t1,\n                t2: t2\n              });\n            }\n          }\n        }\n      }\n    }\n\n    return res;\n  }\n\n  function pathIntersection(path1, path2) {\n    return interPathHelper(path1, path2);\n  }\n\n  function pathIntersectionNumber(path1, path2) {\n    return interPathHelper(path1, path2, 1);\n  }\n\n  function interPathHelper(path1, path2, justCount) {\n    path1 = path2curve(path1);\n    path2 = path2curve(path2);\n    var x1,\n        y1,\n        x2,\n        y2,\n        x1m,\n        y1m,\n        x2m,\n        y2m,\n        bez1,\n        bez2,\n        res = justCount ? 0 : [];\n\n    for (var i = 0, ii = path1.length; i < ii; i++) {\n      var pi = path1[i];\n\n      if (pi[0] == \"M\") {\n        x1 = x1m = pi[1];\n        y1 = y1m = pi[2];\n      } else {\n        if (pi[0] == \"C\") {\n          bez1 = [x1, y1].concat(pi.slice(1));\n          x1 = bez1[6];\n          y1 = bez1[7];\n        } else {\n          bez1 = [x1, y1, x1, y1, x1m, y1m, x1m, y1m];\n          x1 = x1m;\n          y1 = y1m;\n        }\n\n        for (var j = 0, jj = path2.length; j < jj; j++) {\n          var pj = path2[j];\n\n          if (pj[0] == \"M\") {\n            x2 = x2m = pj[1];\n            y2 = y2m = pj[2];\n          } else {\n            if (pj[0] == \"C\") {\n              bez2 = [x2, y2].concat(pj.slice(1));\n              x2 = bez2[6];\n              y2 = bez2[7];\n            } else {\n              bez2 = [x2, y2, x2, y2, x2m, y2m, x2m, y2m];\n              x2 = x2m;\n              y2 = y2m;\n            }\n\n            var intr = interHelper(bez1, bez2, justCount);\n\n            if (justCount) {\n              res += intr;\n            } else {\n              for (var k = 0, kk = intr.length; k < kk; k++) {\n                intr[k].segment1 = i;\n                intr[k].segment2 = j;\n                intr[k].bez1 = bez1;\n                intr[k].bez2 = bez2;\n              }\n\n              res = res.concat(intr);\n            }\n          }\n        }\n      }\n    }\n\n    return res;\n  }\n\n  function isPointInsidePath(path, x, y) {\n    var bbox = pathBBox(path);\n    return isPointInsideBBox(bbox, x, y) && interPathHelper(path, [[\"M\", x, y], [\"H\", bbox.x2 + 10]], 1) % 2 == 1;\n  }\n\n  function pathBBox(path) {\n    var pth = paths(path);\n\n    if (pth.bbox) {\n      return clone(pth.bbox);\n    }\n\n    if (!path) {\n      return box();\n    }\n\n    path = path2curve(path);\n    var x = 0,\n        y = 0,\n        X = [],\n        Y = [],\n        p;\n\n    for (var i = 0, ii = path.length; i < ii; i++) {\n      p = path[i];\n\n      if (p[0] == \"M\") {\n        x = p[1];\n        y = p[2];\n        X.push(x);\n        Y.push(y);\n      } else {\n        var dim = curveDim(x, y, p[1], p[2], p[3], p[4], p[5], p[6]);\n        X = X.concat(dim.min.x, dim.max.x);\n        Y = Y.concat(dim.min.y, dim.max.y);\n        x = p[5];\n        y = p[6];\n      }\n    }\n\n    var xmin = mmin.apply(0, X),\n        ymin = mmin.apply(0, Y),\n        xmax = mmax.apply(0, X),\n        ymax = mmax.apply(0, Y),\n        bb = box(xmin, ymin, xmax - xmin, ymax - ymin);\n    pth.bbox = clone(bb);\n    return bb;\n  }\n\n  function rectPath(x, y, w, h, r) {\n    if (r) {\n      return [[\"M\", +x + +r, y], [\"l\", w - r * 2, 0], [\"a\", r, r, 0, 0, 1, r, r], [\"l\", 0, h - r * 2], [\"a\", r, r, 0, 0, 1, -r, r], [\"l\", r * 2 - w, 0], [\"a\", r, r, 0, 0, 1, -r, -r], [\"l\", 0, r * 2 - h], [\"a\", r, r, 0, 0, 1, r, -r], [\"z\"]];\n    }\n\n    var res = [[\"M\", x, y], [\"l\", w, 0], [\"l\", 0, h], [\"l\", -w, 0], [\"z\"]];\n    res.toString = toString;\n    return res;\n  }\n\n  function ellipsePath(x, y, rx, ry, a) {\n    if (a == null && ry == null) {\n      ry = rx;\n    }\n\n    x = +x;\n    y = +y;\n    rx = +rx;\n    ry = +ry;\n\n    if (a != null) {\n      var rad = Math.PI / 180,\n          x1 = x + rx * Math.cos(-ry * rad),\n          x2 = x + rx * Math.cos(-a * rad),\n          y1 = y + rx * Math.sin(-ry * rad),\n          y2 = y + rx * Math.sin(-a * rad),\n          res = [[\"M\", x1, y1], [\"A\", rx, rx, 0, +(a - ry > 180), 0, x2, y2]];\n    } else {\n      res = [[\"M\", x, y], [\"m\", 0, -ry], [\"a\", rx, ry, 0, 1, 1, 0, 2 * ry], [\"a\", rx, ry, 0, 1, 1, 0, -2 * ry], [\"z\"]];\n    }\n\n    res.toString = toString;\n    return res;\n  }\n\n  var unit2px = Snap._unit2px,\n      getPath = {\n    path: function path(el) {\n      return el.attr(\"path\");\n    },\n    circle: function circle(el) {\n      var attr = unit2px(el);\n      return ellipsePath(attr.cx, attr.cy, attr.r);\n    },\n    ellipse: function ellipse(el) {\n      var attr = unit2px(el);\n      return ellipsePath(attr.cx || 0, attr.cy || 0, attr.rx, attr.ry);\n    },\n    rect: function rect(el) {\n      var attr = unit2px(el);\n      return rectPath(attr.x || 0, attr.y || 0, attr.width, attr.height, attr.rx, attr.ry);\n    },\n    image: function image(el) {\n      var attr = unit2px(el);\n      return rectPath(attr.x || 0, attr.y || 0, attr.width, attr.height);\n    },\n    line: function line(el) {\n      return \"M\" + [el.attr(\"x1\") || 0, el.attr(\"y1\") || 0, el.attr(\"x2\"), el.attr(\"y2\")];\n    },\n    polyline: function polyline(el) {\n      return \"M\" + el.attr(\"points\");\n    },\n    polygon: function polygon(el) {\n      return \"M\" + el.attr(\"points\") + \"z\";\n    },\n    deflt: function deflt(el) {\n      var bbox = el.node.getBBox();\n      return rectPath(bbox.x, bbox.y, bbox.width, bbox.height);\n    }\n  };\n\n  function pathToRelative(pathArray) {\n    var pth = paths(pathArray),\n        lowerCase = String.prototype.toLowerCase;\n\n    if (pth.rel) {\n      return pathClone(pth.rel);\n    }\n\n    if (!Snap.is(pathArray, \"array\") || !Snap.is(pathArray && pathArray[0], \"array\")) {\n      pathArray = Snap.parsePathString(pathArray);\n    }\n\n    var res = [],\n        x = 0,\n        y = 0,\n        mx = 0,\n        my = 0,\n        start = 0;\n\n    if (pathArray[0][0] == \"M\") {\n      x = pathArray[0][1];\n      y = pathArray[0][2];\n      mx = x;\n      my = y;\n      start++;\n      res.push([\"M\", x, y]);\n    }\n\n    for (var i = start, ii = pathArray.length; i < ii; i++) {\n      var r = res[i] = [],\n          pa = pathArray[i];\n\n      if (pa[0] != lowerCase.call(pa[0])) {\n        r[0] = lowerCase.call(pa[0]);\n\n        switch (r[0]) {\n          case \"a\":\n            r[1] = pa[1];\n            r[2] = pa[2];\n            r[3] = pa[3];\n            r[4] = pa[4];\n            r[5] = pa[5];\n            r[6] = +(pa[6] - x).toFixed(3);\n            r[7] = +(pa[7] - y).toFixed(3);\n            break;\n\n          case \"v\":\n            r[1] = +(pa[1] - y).toFixed(3);\n            break;\n\n          case \"m\":\n            mx = pa[1];\n            my = pa[2];\n\n          default:\n            for (var j = 1, jj = pa.length; j < jj; j++) {\n              r[j] = +(pa[j] - (j % 2 ? x : y)).toFixed(3);\n            }\n\n        }\n      } else {\n        r = res[i] = [];\n\n        if (pa[0] == \"m\") {\n          mx = pa[1] + x;\n          my = pa[2] + y;\n        }\n\n        for (var k = 0, kk = pa.length; k < kk; k++) {\n          res[i][k] = pa[k];\n        }\n      }\n\n      var len = res[i].length;\n\n      switch (res[i][0]) {\n        case \"z\":\n          x = mx;\n          y = my;\n          break;\n\n        case \"h\":\n          x += +res[i][len - 1];\n          break;\n\n        case \"v\":\n          y += +res[i][len - 1];\n          break;\n\n        default:\n          x += +res[i][len - 2];\n          y += +res[i][len - 1];\n      }\n    }\n\n    res.toString = toString;\n    pth.rel = pathClone(res);\n    return res;\n  }\n\n  function pathToAbsolute(pathArray) {\n    var pth = paths(pathArray);\n\n    if (pth.abs) {\n      return pathClone(pth.abs);\n    }\n\n    if (!is(pathArray, \"array\") || !is(pathArray && pathArray[0], \"array\")) {\n      // rough assumption\n      pathArray = Snap.parsePathString(pathArray);\n    }\n\n    if (!pathArray || !pathArray.length) {\n      return [[\"M\", 0, 0]];\n    }\n\n    var res = [],\n        x = 0,\n        y = 0,\n        mx = 0,\n        my = 0,\n        start = 0,\n        pa0;\n\n    if (pathArray[0][0] == \"M\") {\n      x = +pathArray[0][1];\n      y = +pathArray[0][2];\n      mx = x;\n      my = y;\n      start++;\n      res[0] = [\"M\", x, y];\n    }\n\n    var crz = pathArray.length == 3 && pathArray[0][0] == \"M\" && pathArray[1][0].toUpperCase() == \"R\" && pathArray[2][0].toUpperCase() == \"Z\";\n\n    for (var r, pa, i = start, ii = pathArray.length; i < ii; i++) {\n      res.push(r = []);\n      pa = pathArray[i];\n      pa0 = pa[0];\n\n      if (pa0 != pa0.toUpperCase()) {\n        r[0] = pa0.toUpperCase();\n\n        switch (r[0]) {\n          case \"A\":\n            r[1] = pa[1];\n            r[2] = pa[2];\n            r[3] = pa[3];\n            r[4] = pa[4];\n            r[5] = pa[5];\n            r[6] = +pa[6] + x;\n            r[7] = +pa[7] + y;\n            break;\n\n          case \"V\":\n            r[1] = +pa[1] + y;\n            break;\n\n          case \"H\":\n            r[1] = +pa[1] + x;\n            break;\n\n          case \"R\":\n            var dots = [x, y].concat(pa.slice(1));\n\n            for (var j = 2, jj = dots.length; j < jj; j++) {\n              dots[j] = +dots[j] + x;\n              dots[++j] = +dots[j] + y;\n            }\n\n            res.pop();\n            res = res.concat(catmullRom2bezier(dots, crz));\n            break;\n\n          case \"O\":\n            res.pop();\n            dots = ellipsePath(x, y, pa[1], pa[2]);\n            dots.push(dots[0]);\n            res = res.concat(dots);\n            break;\n\n          case \"U\":\n            res.pop();\n            res = res.concat(ellipsePath(x, y, pa[1], pa[2], pa[3]));\n            r = [\"U\"].concat(res[res.length - 1].slice(-2));\n            break;\n\n          case \"M\":\n            mx = +pa[1] + x;\n            my = +pa[2] + y;\n\n          default:\n            for (j = 1, jj = pa.length; j < jj; j++) {\n              r[j] = +pa[j] + (j % 2 ? x : y);\n            }\n\n        }\n      } else if (pa0 == \"R\") {\n        dots = [x, y].concat(pa.slice(1));\n        res.pop();\n        res = res.concat(catmullRom2bezier(dots, crz));\n        r = [\"R\"].concat(pa.slice(-2));\n      } else if (pa0 == \"O\") {\n        res.pop();\n        dots = ellipsePath(x, y, pa[1], pa[2]);\n        dots.push(dots[0]);\n        res = res.concat(dots);\n      } else if (pa0 == \"U\") {\n        res.pop();\n        res = res.concat(ellipsePath(x, y, pa[1], pa[2], pa[3]));\n        r = [\"U\"].concat(res[res.length - 1].slice(-2));\n      } else {\n        for (var k = 0, kk = pa.length; k < kk; k++) {\n          r[k] = pa[k];\n        }\n      }\n\n      pa0 = pa0.toUpperCase();\n\n      if (pa0 != \"O\") {\n        switch (r[0]) {\n          case \"Z\":\n            x = +mx;\n            y = +my;\n            break;\n\n          case \"H\":\n            x = r[1];\n            break;\n\n          case \"V\":\n            y = r[1];\n            break;\n\n          case \"M\":\n            mx = r[r.length - 2];\n            my = r[r.length - 1];\n\n          default:\n            x = r[r.length - 2];\n            y = r[r.length - 1];\n        }\n      }\n    }\n\n    res.toString = toString;\n    pth.abs = pathClone(res);\n    return res;\n  }\n\n  function l2c(x1, y1, x2, y2) {\n    return [x1, y1, x2, y2, x2, y2];\n  }\n\n  function q2c(x1, y1, ax, ay, x2, y2) {\n    var _13 = 1 / 3,\n        _23 = 2 / 3;\n\n    return [_13 * x1 + _23 * ax, _13 * y1 + _23 * ay, _13 * x2 + _23 * ax, _13 * y2 + _23 * ay, x2, y2];\n  }\n\n  function a2c(x1, y1, rx, ry, angle, large_arc_flag, sweep_flag, x2, y2, recursive) {\n    // for more information of where this math came from visit:\n    // http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes\n    var _120 = PI * 120 / 180,\n        rad = PI / 180 * (+angle || 0),\n        res = [],\n        xy,\n        rotate = Snap._.cacher(function (x, y, rad) {\n      var X = x * math.cos(rad) - y * math.sin(rad),\n          Y = x * math.sin(rad) + y * math.cos(rad);\n      return {\n        x: X,\n        y: Y\n      };\n    });\n\n    if (!rx || !ry) {\n      return [x1, y1, x2, y2, x2, y2];\n    }\n\n    if (!recursive) {\n      xy = rotate(x1, y1, -rad);\n      x1 = xy.x;\n      y1 = xy.y;\n      xy = rotate(x2, y2, -rad);\n      x2 = xy.x;\n      y2 = xy.y;\n      var cos = math.cos(PI / 180 * angle),\n          sin = math.sin(PI / 180 * angle),\n          x = (x1 - x2) / 2,\n          y = (y1 - y2) / 2;\n      var h = x * x / (rx * rx) + y * y / (ry * ry);\n\n      if (h > 1) {\n        h = math.sqrt(h);\n        rx = h * rx;\n        ry = h * ry;\n      }\n\n      var rx2 = rx * rx,\n          ry2 = ry * ry,\n          k = (large_arc_flag == sweep_flag ? -1 : 1) * math.sqrt(abs((rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x))),\n          cx = k * rx * y / ry + (x1 + x2) / 2,\n          cy = k * -ry * x / rx + (y1 + y2) / 2,\n          f1 = math.asin(((y1 - cy) / ry).toFixed(9)),\n          f2 = math.asin(((y2 - cy) / ry).toFixed(9));\n      f1 = x1 < cx ? PI - f1 : f1;\n      f2 = x2 < cx ? PI - f2 : f2;\n      f1 < 0 && (f1 = PI * 2 + f1);\n      f2 < 0 && (f2 = PI * 2 + f2);\n\n      if (sweep_flag && f1 > f2) {\n        f1 = f1 - PI * 2;\n      }\n\n      if (!sweep_flag && f2 > f1) {\n        f2 = f2 - PI * 2;\n      }\n    } else {\n      f1 = recursive[0];\n      f2 = recursive[1];\n      cx = recursive[2];\n      cy = recursive[3];\n    }\n\n    var df = f2 - f1;\n\n    if (abs(df) > _120) {\n      var f2old = f2,\n          x2old = x2,\n          y2old = y2;\n      f2 = f1 + _120 * (sweep_flag && f2 > f1 ? 1 : -1);\n      x2 = cx + rx * math.cos(f2);\n      y2 = cy + ry * math.sin(f2);\n      res = a2c(x2, y2, rx, ry, angle, 0, sweep_flag, x2old, y2old, [f2, f2old, cx, cy]);\n    }\n\n    df = f2 - f1;\n    var c1 = math.cos(f1),\n        s1 = math.sin(f1),\n        c2 = math.cos(f2),\n        s2 = math.sin(f2),\n        t = math.tan(df / 4),\n        hx = 4 / 3 * rx * t,\n        hy = 4 / 3 * ry * t,\n        m1 = [x1, y1],\n        m2 = [x1 + hx * s1, y1 - hy * c1],\n        m3 = [x2 + hx * s2, y2 - hy * c2],\n        m4 = [x2, y2];\n    m2[0] = 2 * m1[0] - m2[0];\n    m2[1] = 2 * m1[1] - m2[1];\n\n    if (recursive) {\n      return [m2, m3, m4].concat(res);\n    } else {\n      res = [m2, m3, m4].concat(res).join().split(\",\");\n      var newres = [];\n\n      for (var i = 0, ii = res.length; i < ii; i++) {\n        newres[i] = i % 2 ? rotate(res[i - 1], res[i], rad).y : rotate(res[i], res[i + 1], rad).x;\n      }\n\n      return newres;\n    }\n  }\n\n  function findDotAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t) {\n    var t1 = 1 - t;\n    return {\n      x: pow(t1, 3) * p1x + pow(t1, 2) * 3 * t * c1x + t1 * 3 * t * t * c2x + pow(t, 3) * p2x,\n      y: pow(t1, 3) * p1y + pow(t1, 2) * 3 * t * c1y + t1 * 3 * t * t * c2y + pow(t, 3) * p2y\n    };\n  } // Returns bounding box of cubic bezier curve.\n  // Source: http://blog.hackers-cafe.net/2009/06/how-to-calculate-bezier-curves-bounding.html\n  // Original version: NISHIO Hirokazu\n  // Modifications: https://github.com/timo22345\n\n\n  function curveDim(x0, y0, x1, y1, x2, y2, x3, y3) {\n    var tvalues = [],\n        bounds = [[], []],\n        a,\n        b,\n        c,\n        t,\n        t1,\n        t2,\n        b2ac,\n        sqrtb2ac;\n\n    for (var i = 0; i < 2; ++i) {\n      if (i == 0) {\n        b = 6 * x0 - 12 * x1 + 6 * x2;\n        a = -3 * x0 + 9 * x1 - 9 * x2 + 3 * x3;\n        c = 3 * x1 - 3 * x0;\n      } else {\n        b = 6 * y0 - 12 * y1 + 6 * y2;\n        a = -3 * y0 + 9 * y1 - 9 * y2 + 3 * y3;\n        c = 3 * y1 - 3 * y0;\n      }\n\n      if (abs(a) < 1e-12) {\n        if (abs(b) < 1e-12) {\n          continue;\n        }\n\n        t = -c / b;\n\n        if (0 < t && t < 1) {\n          tvalues.push(t);\n        }\n\n        continue;\n      }\n\n      b2ac = b * b - 4 * c * a;\n      sqrtb2ac = math.sqrt(b2ac);\n\n      if (b2ac < 0) {\n        continue;\n      }\n\n      t1 = (-b + sqrtb2ac) / (2 * a);\n\n      if (0 < t1 && t1 < 1) {\n        tvalues.push(t1);\n      }\n\n      t2 = (-b - sqrtb2ac) / (2 * a);\n\n      if (0 < t2 && t2 < 1) {\n        tvalues.push(t2);\n      }\n    }\n\n    var x,\n        y,\n        j = tvalues.length,\n        jlen = j,\n        mt;\n\n    while (j--) {\n      t = tvalues[j];\n      mt = 1 - t;\n      bounds[0][j] = mt * mt * mt * x0 + 3 * mt * mt * t * x1 + 3 * mt * t * t * x2 + t * t * t * x3;\n      bounds[1][j] = mt * mt * mt * y0 + 3 * mt * mt * t * y1 + 3 * mt * t * t * y2 + t * t * t * y3;\n    }\n\n    bounds[0][jlen] = x0;\n    bounds[1][jlen] = y0;\n    bounds[0][jlen + 1] = x3;\n    bounds[1][jlen + 1] = y3;\n    bounds[0].length = bounds[1].length = jlen + 2;\n    return {\n      min: {\n        x: mmin.apply(0, bounds[0]),\n        y: mmin.apply(0, bounds[1])\n      },\n      max: {\n        x: mmax.apply(0, bounds[0]),\n        y: mmax.apply(0, bounds[1])\n      }\n    };\n  }\n\n  function path2curve(path, path2) {\n    var pth = !path2 && paths(path);\n\n    if (!path2 && pth.curve) {\n      return pathClone(pth.curve);\n    }\n\n    var p = pathToAbsolute(path),\n        p2 = path2 && pathToAbsolute(path2),\n        attrs = {\n      x: 0,\n      y: 0,\n      bx: 0,\n      by: 0,\n      X: 0,\n      Y: 0,\n      qx: null,\n      qy: null\n    },\n        attrs2 = {\n      x: 0,\n      y: 0,\n      bx: 0,\n      by: 0,\n      X: 0,\n      Y: 0,\n      qx: null,\n      qy: null\n    },\n        processPath = function processPath(path, d, pcom) {\n      var nx, ny;\n\n      if (!path) {\n        return [\"C\", d.x, d.y, d.x, d.y, d.x, d.y];\n      }\n\n      !(path[0] in {\n        T: 1,\n        Q: 1\n      }) && (d.qx = d.qy = null);\n\n      switch (path[0]) {\n        case \"M\":\n          d.X = path[1];\n          d.Y = path[2];\n          break;\n\n        case \"A\":\n          path = [\"C\"].concat(a2c.apply(0, [d.x, d.y].concat(path.slice(1))));\n          break;\n\n        case \"S\":\n          if (pcom == \"C\" || pcom == \"S\") {\n            // In \"S\" case we have to take into account, if the previous command is C/S.\n            nx = d.x * 2 - d.bx; // And reflect the previous\n\n            ny = d.y * 2 - d.by; // command's control point relative to the current point.\n          } else {\n            // or some else or nothing\n            nx = d.x;\n            ny = d.y;\n          }\n\n          path = [\"C\", nx, ny].concat(path.slice(1));\n          break;\n\n        case \"T\":\n          if (pcom == \"Q\" || pcom == \"T\") {\n            // In \"T\" case we have to take into account, if the previous command is Q/T.\n            d.qx = d.x * 2 - d.qx; // And make a reflection similar\n\n            d.qy = d.y * 2 - d.qy; // to case \"S\".\n          } else {\n            // or something else or nothing\n            d.qx = d.x;\n            d.qy = d.y;\n          }\n\n          path = [\"C\"].concat(q2c(d.x, d.y, d.qx, d.qy, path[1], path[2]));\n          break;\n\n        case \"Q\":\n          d.qx = path[1];\n          d.qy = path[2];\n          path = [\"C\"].concat(q2c(d.x, d.y, path[1], path[2], path[3], path[4]));\n          break;\n\n        case \"L\":\n          path = [\"C\"].concat(l2c(d.x, d.y, path[1], path[2]));\n          break;\n\n        case \"H\":\n          path = [\"C\"].concat(l2c(d.x, d.y, path[1], d.y));\n          break;\n\n        case \"V\":\n          path = [\"C\"].concat(l2c(d.x, d.y, d.x, path[1]));\n          break;\n\n        case \"Z\":\n          path = [\"C\"].concat(l2c(d.x, d.y, d.X, d.Y));\n          break;\n      }\n\n      return path;\n    },\n        fixArc = function fixArc(pp, i) {\n      if (pp[i].length > 7) {\n        pp[i].shift();\n        var pi = pp[i];\n\n        while (pi.length) {\n          pcoms1[i] = \"A\"; // if created multiple C:s, their original seg is saved\n\n          p2 && (pcoms2[i] = \"A\"); // the same as above\n\n          pp.splice(i++, 0, [\"C\"].concat(pi.splice(0, 6)));\n        }\n\n        pp.splice(i, 1);\n        ii = mmax(p.length, p2 && p2.length || 0);\n      }\n    },\n        fixM = function fixM(path1, path2, a1, a2, i) {\n      if (path1 && path2 && path1[i][0] == \"M\" && path2[i][0] != \"M\") {\n        path2.splice(i, 0, [\"M\", a2.x, a2.y]);\n        a1.bx = 0;\n        a1.by = 0;\n        a1.x = path1[i][1];\n        a1.y = path1[i][2];\n        ii = mmax(p.length, p2 && p2.length || 0);\n      }\n    },\n        pcoms1 = [],\n        // path commands of original path p\n    pcoms2 = [],\n        // path commands of original path p2\n    pfirst = \"\",\n        // temporary holder for original path command\n    pcom = \"\"; // holder for previous path command of original path\n\n\n    for (var i = 0, ii = mmax(p.length, p2 && p2.length || 0); i < ii; i++) {\n      p[i] && (pfirst = p[i][0]); // save current path command\n\n      if (pfirst != \"C\") // C is not saved yet, because it may be result of conversion\n        {\n          pcoms1[i] = pfirst; // Save current path command\n\n          i && (pcom = pcoms1[i - 1]); // Get previous path command pcom\n        }\n\n      p[i] = processPath(p[i], attrs, pcom); // Previous path command is inputted to processPath\n\n      if (pcoms1[i] != \"A\" && pfirst == \"C\") pcoms1[i] = \"C\"; // A is the only command\n      // which may produce multiple C:s\n      // so we have to make sure that C is also C in original path\n\n      fixArc(p, i); // fixArc adds also the right amount of A:s to pcoms1\n\n      if (p2) {\n        // the same procedures is done to p2\n        p2[i] && (pfirst = p2[i][0]);\n\n        if (pfirst != \"C\") {\n          pcoms2[i] = pfirst;\n          i && (pcom = pcoms2[i - 1]);\n        }\n\n        p2[i] = processPath(p2[i], attrs2, pcom);\n\n        if (pcoms2[i] != \"A\" && pfirst == \"C\") {\n          pcoms2[i] = \"C\";\n        }\n\n        fixArc(p2, i);\n      }\n\n      fixM(p, p2, attrs, attrs2, i);\n      fixM(p2, p, attrs2, attrs, i);\n      var seg = p[i],\n          seg2 = p2 && p2[i],\n          seglen = seg.length,\n          seg2len = p2 && seg2.length;\n      attrs.x = seg[seglen - 2];\n      attrs.y = seg[seglen - 1];\n      attrs.bx = toFloat(seg[seglen - 4]) || attrs.x;\n      attrs.by = toFloat(seg[seglen - 3]) || attrs.y;\n      attrs2.bx = p2 && (toFloat(seg2[seg2len - 4]) || attrs2.x);\n      attrs2.by = p2 && (toFloat(seg2[seg2len - 3]) || attrs2.y);\n      attrs2.x = p2 && seg2[seg2len - 2];\n      attrs2.y = p2 && seg2[seg2len - 1];\n    }\n\n    if (!p2) {\n      pth.curve = pathClone(p);\n    }\n\n    return p2 ? [p, p2] : p;\n  }\n\n  function mapPath(path, matrix) {\n    if (!matrix) {\n      return path;\n    }\n\n    var x, y, i, j, ii, jj, pathi;\n    path = path2curve(path);\n\n    for (i = 0, ii = path.length; i < ii; i++) {\n      pathi = path[i];\n\n      for (j = 1, jj = pathi.length; j < jj; j += 2) {\n        x = matrix.x(pathi[j], pathi[j + 1]);\n        y = matrix.y(pathi[j], pathi[j + 1]);\n        pathi[j] = x;\n        pathi[j + 1] = y;\n      }\n    }\n\n    return path;\n  } // http://schepers.cc/getting-to-the-point\n\n\n  function catmullRom2bezier(crp, z) {\n    var d = [];\n\n    for (var i = 0, iLen = crp.length; iLen - 2 * !z > i; i += 2) {\n      var p = [{\n        x: +crp[i - 2],\n        y: +crp[i - 1]\n      }, {\n        x: +crp[i],\n        y: +crp[i + 1]\n      }, {\n        x: +crp[i + 2],\n        y: +crp[i + 3]\n      }, {\n        x: +crp[i + 4],\n        y: +crp[i + 5]\n      }];\n\n      if (z) {\n        if (!i) {\n          p[0] = {\n            x: +crp[iLen - 2],\n            y: +crp[iLen - 1]\n          };\n        } else if (iLen - 4 == i) {\n          p[3] = {\n            x: +crp[0],\n            y: +crp[1]\n          };\n        } else if (iLen - 2 == i) {\n          p[2] = {\n            x: +crp[0],\n            y: +crp[1]\n          };\n          p[3] = {\n            x: +crp[2],\n            y: +crp[3]\n          };\n        }\n      } else {\n        if (iLen - 4 == i) {\n          p[3] = p[2];\n        } else if (!i) {\n          p[0] = {\n            x: +crp[i],\n            y: +crp[i + 1]\n          };\n        }\n      }\n\n      d.push([\"C\", (-p[0].x + 6 * p[1].x + p[2].x) / 6, (-p[0].y + 6 * p[1].y + p[2].y) / 6, (p[1].x + 6 * p[2].x - p[3].x) / 6, (p[1].y + 6 * p[2].y - p[3].y) / 6, p[2].x, p[2].y]);\n    }\n\n    return d;\n  } // export\n\n\n  Snap.path = paths;\n  /*\\\n   * Snap.path.getTotalLength\n   [ method ]\n   **\n   * Returns the length of the given path in pixels\n   **\n   - path (string) SVG path string\n   **\n   = (number) length\n  \\*/\n\n  Snap.path.getTotalLength = getTotalLength;\n  /*\\\n   * Snap.path.getPointAtLength\n   [ method ]\n   **\n   * Returns the coordinates of the point located at the given length along the given path\n   **\n   - path (string) SVG path string\n   - length (number) length, in pixels, from the start of the path, excluding non-rendering jumps\n   **\n   = (object) representation of the point:\n   o {\n   o     x: (number) x coordinate,\n   o     y: (number) y coordinate,\n   o     alpha: (number) angle of derivative\n   o }\n  \\*/\n\n  Snap.path.getPointAtLength = getPointAtLength;\n  /*\\\n   * Snap.path.getSubpath\n   [ method ]\n   **\n   * Returns the subpath of a given path between given start and end lengths\n   **\n   - path (string) SVG path string\n   - from (number) length, in pixels, from the start of the path to the start of the segment\n   - to (number) length, in pixels, from the start of the path to the end of the segment\n   **\n   = (string) path string definition for the segment\n  \\*/\n\n  Snap.path.getSubpath = function (path, from, to) {\n    if (this.getTotalLength(path) - to < 1e-6) {\n      return getSubpathsAtLength(path, from).end;\n    }\n\n    var a = getSubpathsAtLength(path, to, 1);\n    return from ? getSubpathsAtLength(a, from).end : a;\n  };\n  /*\\\n   * Element.getTotalLength\n   [ method ]\n   **\n   * Returns the length of the path in pixels (only works for `path` elements)\n   = (number) length\n  \\*/\n\n\n  elproto.getTotalLength = function () {\n    if (this.node.getTotalLength) {\n      return this.node.getTotalLength();\n    }\n  }; // SIERRA Element.getPointAtLength()/Element.getTotalLength(): If a <path> is broken into different segments, is the jump distance to the new coordinates set by the _M_ or _m_ commands calculated as part of the path's total length?\n\n  /*\\\n   * Element.getPointAtLength\n   [ method ]\n   **\n   * Returns coordinates of the point located at the given length on the given path (only works for `path` elements)\n   **\n   - length (number) length, in pixels, from the start of the path, excluding non-rendering jumps\n   **\n   = (object) representation of the point:\n   o {\n   o     x: (number) x coordinate,\n   o     y: (number) y coordinate,\n   o     alpha: (number) angle of derivative\n   o }\n  \\*/\n\n\n  elproto.getPointAtLength = function (length) {\n    return getPointAtLength(this.attr(\"d\"), length);\n  }; // SIERRA Element.getSubpath(): Similar to the problem for Element.getPointAtLength(). Unclear how this would work for a segmented path. Overall, the concept of _subpath_ and what I'm calling a _segment_ (series of non-_M_ or _Z_ commands) is unclear.\n\n  /*\\\n   * Element.getSubpath\n   [ method ]\n   **\n   * Returns subpath of a given element from given start and end lengths (only works for `path` elements)\n   **\n   - from (number) length, in pixels, from the start of the path to the start of the segment\n   - to (number) length, in pixels, from the start of the path to the end of the segment\n   **\n   = (string) path string definition for the segment\n  \\*/\n\n\n  elproto.getSubpath = function (from, to) {\n    return Snap.path.getSubpath(this.attr(\"d\"), from, to);\n  };\n\n  Snap._.box = box;\n  /*\\\n   * Snap.path.findDotsAtSegment\n   [ method ]\n   **\n   * Utility method\n   **\n   * Finds dot coordinates on the given cubic beziér curve at the given t\n   - p1x (number) x of the first point of the curve\n   - p1y (number) y of the first point of the curve\n   - c1x (number) x of the first anchor of the curve\n   - c1y (number) y of the first anchor of the curve\n   - c2x (number) x of the second anchor of the curve\n   - c2y (number) y of the second anchor of the curve\n   - p2x (number) x of the second point of the curve\n   - p2y (number) y of the second point of the curve\n   - t (number) position on the curve (0..1)\n   = (object) point information in format:\n   o {\n   o     x: (number) x coordinate of the point,\n   o     y: (number) y coordinate of the point,\n   o     m: {\n   o         x: (number) x coordinate of the left anchor,\n   o         y: (number) y coordinate of the left anchor\n   o     },\n   o     n: {\n   o         x: (number) x coordinate of the right anchor,\n   o         y: (number) y coordinate of the right anchor\n   o     },\n   o     start: {\n   o         x: (number) x coordinate of the start of the curve,\n   o         y: (number) y coordinate of the start of the curve\n   o     },\n   o     end: {\n   o         x: (number) x coordinate of the end of the curve,\n   o         y: (number) y coordinate of the end of the curve\n   o     },\n   o     alpha: (number) angle of the curve derivative at the point\n   o }\n  \\*/\n\n  Snap.path.findDotsAtSegment = findDotsAtSegment;\n  /*\\\n   * Snap.path.bezierBBox\n   [ method ]\n   **\n   * Utility method\n   **\n   * Returns the bounding box of a given cubic beziér curve\n   - p1x (number) x of the first point of the curve\n   - p1y (number) y of the first point of the curve\n   - c1x (number) x of the first anchor of the curve\n   - c1y (number) y of the first anchor of the curve\n   - c2x (number) x of the second anchor of the curve\n   - c2y (number) y of the second anchor of the curve\n   - p2x (number) x of the second point of the curve\n   - p2y (number) y of the second point of the curve\n   * or\n   - bez (array) array of six points for beziér curve\n   = (object) bounding box\n   o {\n   o     x: (number) x coordinate of the left top point of the box,\n   o     y: (number) y coordinate of the left top point of the box,\n   o     x2: (number) x coordinate of the right bottom point of the box,\n   o     y2: (number) y coordinate of the right bottom point of the box,\n   o     width: (number) width of the box,\n   o     height: (number) height of the box\n   o }\n  \\*/\n\n  Snap.path.bezierBBox = bezierBBox;\n  /*\\\n   * Snap.path.isPointInsideBBox\n   [ method ]\n   **\n   * Utility method\n   **\n   * Returns `true` if given point is inside bounding box\n   - bbox (string) bounding box\n   - x (string) x coordinate of the point\n   - y (string) y coordinate of the point\n   = (boolean) `true` if point is inside\n  \\*/\n\n  Snap.path.isPointInsideBBox = isPointInsideBBox;\n\n  Snap.closest = function (x, y, X, Y) {\n    var r = 100,\n        b = box(x - r / 2, y - r / 2, r, r),\n        inside = [],\n        getter = X[0].hasOwnProperty(\"x\") ? function (i) {\n      return {\n        x: X[i].x,\n        y: X[i].y\n      };\n    } : function (i) {\n      return {\n        x: X[i],\n        y: Y[i]\n      };\n    },\n        found = 0;\n\n    while (r <= 1e6 && !found) {\n      for (var i = 0, ii = X.length; i < ii; i++) {\n        var xy = getter(i);\n\n        if (isPointInsideBBox(b, xy.x, xy.y)) {\n          found++;\n          inside.push(xy);\n          break;\n        }\n      }\n\n      if (!found) {\n        r *= 2;\n        b = box(x - r / 2, y - r / 2, r, r);\n      }\n    }\n\n    if (r == 1e6) {\n      return;\n    }\n\n    var len = Infinity,\n        res;\n\n    for (i = 0, ii = inside.length; i < ii; i++) {\n      var l = Snap.len(x, y, inside[i].x, inside[i].y);\n\n      if (len > l) {\n        len = l;\n        inside[i].len = l;\n        res = inside[i];\n      }\n    }\n\n    return res;\n  };\n  /*\\\n   * Snap.path.isBBoxIntersect\n   [ method ]\n   **\n   * Utility method\n   **\n   * Returns `true` if two bounding boxes intersect\n   - bbox1 (string) first bounding box\n   - bbox2 (string) second bounding box\n   = (boolean) `true` if bounding boxes intersect\n  \\*/\n\n\n  Snap.path.isBBoxIntersect = isBBoxIntersect;\n  /*\\\n   * Snap.path.intersection\n   [ method ]\n   **\n   * Utility method\n   **\n   * Finds intersections of two paths\n   - path1 (string) path string\n   - path2 (string) path string\n   = (array) dots of intersection\n   o [\n   o     {\n   o         x: (number) x coordinate of the point,\n   o         y: (number) y coordinate of the point,\n   o         t1: (number) t value for segment of path1,\n   o         t2: (number) t value for segment of path2,\n   o         segment1: (number) order number for segment of path1,\n   o         segment2: (number) order number for segment of path2,\n   o         bez1: (array) eight coordinates representing beziér curve for the segment of path1,\n   o         bez2: (array) eight coordinates representing beziér curve for the segment of path2\n   o     }\n   o ]\n  \\*/\n\n  Snap.path.intersection = pathIntersection;\n  Snap.path.intersectionNumber = pathIntersectionNumber;\n  /*\\\n   * Snap.path.isPointInside\n   [ method ]\n   **\n   * Utility method\n   **\n   * Returns `true` if given point is inside a given closed path.\n   *\n   * Note: fill mode doesn’t affect the result of this method.\n   - path (string) path string\n   - x (number) x of the point\n   - y (number) y of the point\n   = (boolean) `true` if point is inside the path\n  \\*/\n\n  Snap.path.isPointInside = isPointInsidePath;\n  /*\\\n   * Snap.path.getBBox\n   [ method ]\n   **\n   * Utility method\n   **\n   * Returns the bounding box of a given path\n   - path (string) path string\n   = (object) bounding box\n   o {\n   o     x: (number) x coordinate of the left top point of the box,\n   o     y: (number) y coordinate of the left top point of the box,\n   o     x2: (number) x coordinate of the right bottom point of the box,\n   o     y2: (number) y coordinate of the right bottom point of the box,\n   o     width: (number) width of the box,\n   o     height: (number) height of the box\n   o }\n  \\*/\n\n  Snap.path.getBBox = pathBBox;\n  Snap.path.get = getPath;\n  /*\\\n   * Snap.path.toRelative\n   [ method ]\n   **\n   * Utility method\n   **\n   * Converts path coordinates into relative values\n   - path (string) path string\n   = (array) path string\n  \\*/\n\n  Snap.path.toRelative = pathToRelative;\n  /*\\\n   * Snap.path.toAbsolute\n   [ method ]\n   **\n   * Utility method\n   **\n   * Converts path coordinates into absolute values\n   - path (string) path string\n   = (array) path string\n  \\*/\n\n  Snap.path.toAbsolute = pathToAbsolute;\n  /*\\\n   * Snap.path.toCubic\n   [ method ]\n   **\n   * Utility method\n   **\n   * Converts path to a new path where all segments are cubic beziér curves\n   - pathString (string|array) path string or array of segments\n   = (array) array of segments\n  \\*/\n\n  Snap.path.toCubic = path2curve;\n  /*\\\n   * Snap.path.map\n   [ method ]\n   **\n   * Transform the path string with the given matrix\n   - path (string) path string\n   - matrix (object) see @Matrix\n   = (string) transformed path string\n  \\*/\n\n  Snap.path.map = mapPath;\n  Snap.path.toString = toString;\n  Snap.path.clone = pathClone;\n}); // Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\nSnap.plugin(function (Snap, Element, Paper, glob) {\n  var mmax = Math.max,\n      mmin = Math.min; // Set\n\n  var Set = function Set(items) {\n    this.items = [];\n    this.bindings = {};\n    this.length = 0;\n    this.type = \"set\";\n\n    if (items) {\n      for (var i = 0, ii = items.length; i < ii; i++) {\n        if (items[i]) {\n          this[this.items.length] = this.items[this.items.length] = items[i];\n          this.length++;\n        }\n      }\n    }\n  },\n      setproto = Set.prototype;\n  /*\\\n   * Set.push\n   [ method ]\n   **\n   * Adds each argument to the current set\n   = (object) original element\n  \\*/\n\n\n  setproto.push = function () {\n    var item, len;\n\n    for (var i = 0, ii = arguments.length; i < ii; i++) {\n      item = arguments[i];\n\n      if (item) {\n        len = this.items.length;\n        this[len] = this.items[len] = item;\n        this.length++;\n      }\n    }\n\n    return this;\n  };\n  /*\\\n   * Set.pop\n   [ method ]\n   **\n   * Removes last element and returns it\n   = (object) element\n  \\*/\n\n\n  setproto.pop = function () {\n    this.length && delete this[this.length--];\n    return this.items.pop();\n  };\n  /*\\\n   * Set.forEach\n   [ method ]\n   **\n   * Executes given function for each element in the set\n   *\n   * If the function returns `false`, the loop stops running.\n   **\n   - callback (function) function to run\n   - thisArg (object) context object for the callback\n   = (object) Set object\n  \\*/\n\n\n  setproto.forEach = function (callback, thisArg) {\n    for (var i = 0, ii = this.items.length; i < ii; i++) {\n      if (callback.call(thisArg, this.items[i], i) === false) {\n        return this;\n      }\n    }\n\n    return this;\n  };\n  /*\\\n   * Set.animate\n   [ method ]\n   **\n   * Animates each element in set in sync.\n   *\n   **\n   - attrs (object) key-value pairs of destination attributes\n   - duration (number) duration of the animation in milliseconds\n   - easing (function) #optional easing function from @mina or custom\n   - callback (function) #optional callback function that executes when the animation ends\n   * or\n   - animation (array) array of animation parameter for each element in set in format `[attrs, duration, easing, callback]`\n   > Usage\n   | // animate all elements in set to radius 10\n   | set.animate({r: 10}, 500, mina.easein);\n   | // or\n   | // animate first element to radius 10, but second to radius 20 and in different time\n   | set.animate([{r: 10}, 500, mina.easein], [{r: 20}, 1500, mina.easein]);\n   = (Element) the current element\n  \\*/\n\n\n  setproto.animate = function (attrs, ms, easing, callback) {\n    if (typeof easing == \"function\" && !easing.length) {\n      callback = easing;\n      easing = mina.linear;\n    }\n\n    if (attrs instanceof Snap._.Animation) {\n      callback = attrs.callback;\n      easing = attrs.easing;\n      ms = easing.dur;\n      attrs = attrs.attr;\n    }\n\n    var args = arguments;\n\n    if (Snap.is(attrs, \"array\") && Snap.is(args[args.length - 1], \"array\")) {\n      var each = true;\n    }\n\n    var begin,\n        handler = function handler() {\n      if (begin) {\n        this.b = begin;\n      } else {\n        begin = this.b;\n      }\n    },\n        cb = 0,\n        set = this,\n        callbacker = callback && function () {\n      if (++cb == set.length) {\n        callback.call(this);\n      }\n    };\n\n    return this.forEach(function (el, i) {\n      eve.once(\"snap.animcreated.\" + el.id, handler);\n\n      if (each) {\n        args[i] && el.animate.apply(el, args[i]);\n      } else {\n        el.animate(attrs, ms, easing, callbacker);\n      }\n    });\n  };\n  /*\\\n   * Set.remove\n   [ method ]\n   **\n   * Removes all children of the set.\n   *\n   = (object) Set object\n  \\*/\n\n\n  setproto.remove = function () {\n    while (this.length) {\n      this.pop().remove();\n    }\n\n    return this;\n  };\n  /*\\\n   * Set.bind\n   [ method ]\n   **\n   * Specifies how to handle a specific attribute when applied\n   * to a set.\n   *\n   **\n   - attr (string) attribute name\n   - callback (function) function to run\n   * or\n   - attr (string) attribute name\n   - element (Element) specific element in the set to apply the attribute to\n   * or\n   - attr (string) attribute name\n   - element (Element) specific element in the set to apply the attribute to\n   - eattr (string) attribute on the element to bind the attribute to\n   = (object) Set object\n  \\*/\n\n\n  setproto.bind = function (attr, a, b) {\n    var data = {};\n\n    if (typeof a == \"function\") {\n      this.bindings[attr] = a;\n    } else {\n      var aname = b || attr;\n\n      this.bindings[attr] = function (v) {\n        data[aname] = v;\n        a.attr(data);\n      };\n    }\n\n    return this;\n  };\n  /*\\\n   * Set.attr\n   [ method ]\n   **\n   * Equivalent of @Element.attr.\n   = (object) Set object\n  \\*/\n\n\n  setproto.attr = function (value) {\n    var unbound = {};\n\n    for (var k in value) {\n      if (this.bindings[k]) {\n        this.bindings[k](value[k]);\n      } else {\n        unbound[k] = value[k];\n      }\n    }\n\n    for (var i = 0, ii = this.items.length; i < ii; i++) {\n      this.items[i].attr(unbound);\n    }\n\n    return this;\n  };\n  /*\\\n   * Set.clear\n   [ method ]\n   **\n   * Removes all elements from the set\n  \\*/\n\n\n  setproto.clear = function () {\n    while (this.length) {\n      this.pop();\n    }\n  };\n  /*\\\n   * Set.splice\n   [ method ]\n   **\n   * Removes range of elements from the set\n   **\n   - index (number) position of the deletion\n   - count (number) number of element to remove\n   - insertion… (object) #optional elements to insert\n   = (object) set elements that were deleted\n  \\*/\n\n\n  setproto.splice = function (index, count, insertion) {\n    index = index < 0 ? mmax(this.length + index, 0) : index;\n    count = mmax(0, mmin(this.length - index, count));\n    var tail = [],\n        todel = [],\n        args = [],\n        i;\n\n    for (i = 2; i < arguments.length; i++) {\n      args.push(arguments[i]);\n    }\n\n    for (i = 0; i < count; i++) {\n      todel.push(this[index + i]);\n    }\n\n    for (; i < this.length - index; i++) {\n      tail.push(this[index + i]);\n    }\n\n    var arglen = args.length;\n\n    for (i = 0; i < arglen + tail.length; i++) {\n      this.items[index + i] = this[index + i] = i < arglen ? args[i] : tail[i - arglen];\n    }\n\n    i = this.items.length = this.length -= count - arglen;\n\n    while (this[i]) {\n      delete this[i++];\n    }\n\n    return new Set(todel);\n  };\n  /*\\\n   * Set.exclude\n   [ method ]\n   **\n   * Removes given element from the set\n   **\n   - element (object) element to remove\n   = (boolean) `true` if object was found and removed from the set\n  \\*/\n\n\n  setproto.exclude = function (el) {\n    for (var i = 0, ii = this.length; i < ii; i++) {\n      if (this[i] == el) {\n        this.splice(i, 1);\n        return true;\n      }\n    }\n\n    return false;\n  };\n  /*\\\n   * Set.insertAfter\n   [ method ]\n   **\n   * Inserts set elements after given element.\n   **\n   - element (object) set will be inserted after this element\n   = (object) Set object\n  \\*/\n\n\n  setproto.insertAfter = function (el) {\n    var i = this.items.length;\n\n    while (i--) {\n      this.items[i].insertAfter(el);\n    }\n\n    return this;\n  };\n  /*\\\n   * Set.getBBox\n   [ method ]\n   **\n   * Union of all bboxes of the set. See @Element.getBBox.\n   = (object) bounding box descriptor. See @Element.getBBox.\n  \\*/\n\n\n  setproto.getBBox = function () {\n    var x = [],\n        y = [],\n        x2 = [],\n        y2 = [];\n\n    for (var i = this.items.length; i--;) {\n      if (!this.items[i].removed) {\n        var box = this.items[i].getBBox();\n        x.push(box.x);\n        y.push(box.y);\n        x2.push(box.x + box.width);\n        y2.push(box.y + box.height);\n      }\n    }\n\n    x = mmin.apply(0, x);\n    y = mmin.apply(0, y);\n    x2 = mmax.apply(0, x2);\n    y2 = mmax.apply(0, y2);\n    return {\n      x: x,\n      y: y,\n      x2: x2,\n      y2: y2,\n      width: x2 - x,\n      height: y2 - y,\n      cx: x + (x2 - x) / 2,\n      cy: y + (y2 - y) / 2\n    };\n  };\n  /*\\\n   * Set.insertAfter\n   [ method ]\n   **\n   * Creates a clone of the set.\n   **\n   = (object) New Set object\n  \\*/\n\n\n  setproto.clone = function (s) {\n    s = new Set();\n\n    for (var i = 0, ii = this.items.length; i < ii; i++) {\n      s.push(this.items[i].clone());\n    }\n\n    return s;\n  };\n\n  setproto.toString = function () {\n    return \"Snap\\u2018s set\";\n  };\n\n  setproto.type = \"set\"; // export\n\n  /*\\\n   * Snap.Set\n   [ property ]\n   **\n   * Set constructor.\n  \\*/\n\n  Snap.Set = Set;\n  /*\\\n   * Snap.set\n   [ method ]\n   **\n   * Creates a set and fills it with list of arguments.\n   **\n   = (object) New Set object\n   | var r = paper.rect(0, 0, 10, 10),\n   |     s1 = Snap.set(), // empty set\n   |     s2 = Snap.set(r, paper.circle(100, 100, 20)); // prefilled set\n  \\*/\n\n  Snap.set = function () {\n    var set = new Set();\n\n    if (arguments.length) {\n      set.push.apply(set, Array.prototype.slice.call(arguments, 0));\n    }\n\n    return set;\n  };\n}); // Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\nSnap.plugin(function (Snap, Element, Paper, glob) {\n  var names = {},\n      reUnit = /[%a-z]+$/i,\n      Str = String;\n  names.stroke = names.fill = \"colour\";\n\n  function getEmpty(item) {\n    var l = item[0];\n\n    switch (l.toLowerCase()) {\n      case \"t\":\n        return [l, 0, 0];\n\n      case \"m\":\n        return [l, 1, 0, 0, 1, 0, 0];\n\n      case \"r\":\n        if (item.length == 4) {\n          return [l, 0, item[2], item[3]];\n        } else {\n          return [l, 0];\n        }\n\n      case \"s\":\n        if (item.length == 5) {\n          return [l, 1, 1, item[3], item[4]];\n        } else if (item.length == 3) {\n          return [l, 1, 1];\n        } else {\n          return [l, 1];\n        }\n\n    }\n  }\n\n  function equaliseTransform(t1, t2, getBBox) {\n    t1 = t1 || new Snap.Matrix();\n    t2 = t2 || new Snap.Matrix();\n    t1 = Snap.parseTransformString(t1.toTransformString()) || [];\n    t2 = Snap.parseTransformString(t2.toTransformString()) || [];\n    var maxlength = Math.max(t1.length, t2.length),\n        from = [],\n        to = [],\n        i = 0,\n        j,\n        jj,\n        tt1,\n        tt2;\n\n    for (; i < maxlength; i++) {\n      tt1 = t1[i] || getEmpty(t2[i]);\n      tt2 = t2[i] || getEmpty(tt1);\n\n      if (tt1[0] != tt2[0] || tt1[0].toLowerCase() == \"r\" && (tt1[2] != tt2[2] || tt1[3] != tt2[3]) || tt1[0].toLowerCase() == \"s\" && (tt1[3] != tt2[3] || tt1[4] != tt2[4])) {\n        t1 = Snap._.transform2matrix(t1, getBBox());\n        t2 = Snap._.transform2matrix(t2, getBBox());\n        from = [[\"m\", t1.a, t1.b, t1.c, t1.d, t1.e, t1.f]];\n        to = [[\"m\", t2.a, t2.b, t2.c, t2.d, t2.e, t2.f]];\n        break;\n      }\n\n      from[i] = [];\n      to[i] = [];\n\n      for (j = 0, jj = Math.max(tt1.length, tt2.length); j < jj; j++) {\n        j in tt1 && (from[i][j] = tt1[j]);\n        j in tt2 && (to[i][j] = tt2[j]);\n      }\n    }\n\n    return {\n      from: path2array(from),\n      to: path2array(to),\n      f: getPath(from)\n    };\n  }\n\n  function getNumber(val) {\n    return val;\n  }\n\n  function getUnit(unit) {\n    return function (val) {\n      return +val.toFixed(3) + unit;\n    };\n  }\n\n  function getViewBox(val) {\n    return val.join(\" \");\n  }\n\n  function getColour(clr) {\n    return Snap.rgb(clr[0], clr[1], clr[2], clr[3]);\n  }\n\n  function getPath(path) {\n    var k = 0,\n        i,\n        ii,\n        j,\n        jj,\n        out,\n        a,\n        b = [];\n\n    for (i = 0, ii = path.length; i < ii; i++) {\n      out = \"[\";\n      a = ['\"' + path[i][0] + '\"'];\n\n      for (j = 1, jj = path[i].length; j < jj; j++) {\n        a[j] = \"val[\" + k++ + \"]\";\n      }\n\n      out += a + \"]\";\n      b[i] = out;\n    }\n\n    return Function(\"val\", \"return Snap.path.toString.call([\" + b + \"])\");\n  }\n\n  function path2array(path) {\n    var out = [];\n\n    for (var i = 0, ii = path.length; i < ii; i++) {\n      for (var j = 1, jj = path[i].length; j < jj; j++) {\n        out.push(path[i][j]);\n      }\n    }\n\n    return out;\n  }\n\n  function isNumeric(obj) {\n    return isFinite(obj);\n  }\n\n  function arrayEqual(arr1, arr2) {\n    if (!Snap.is(arr1, \"array\") || !Snap.is(arr2, \"array\")) {\n      return false;\n    }\n\n    return arr1.toString() == arr2.toString();\n  }\n\n  Element.prototype.equal = function (name, b) {\n    return eve(\"snap.util.equal\", this, name, b).firstDefined();\n  };\n\n  eve.on(\"snap.util.equal\", function (name, b) {\n    var A,\n        B,\n        a = Str(this.attr(name) || \"\"),\n        el = this;\n\n    if (names[name] == \"colour\") {\n      A = Snap.color(a);\n      B = Snap.color(b);\n      return {\n        from: [A.r, A.g, A.b, A.opacity],\n        to: [B.r, B.g, B.b, B.opacity],\n        f: getColour\n      };\n    }\n\n    if (name == \"viewBox\") {\n      A = this.attr(name).vb.split(\" \").map(Number);\n      B = b.split(\" \").map(Number);\n      return {\n        from: A,\n        to: B,\n        f: getViewBox\n      };\n    }\n\n    if (name == \"transform\" || name == \"gradientTransform\" || name == \"patternTransform\") {\n      if (typeof b == \"string\") {\n        b = Str(b).replace(/\\.{3}|\\u2026/g, a);\n      }\n\n      a = this.matrix;\n\n      if (!Snap._.rgTransform.test(b)) {\n        b = Snap._.transform2matrix(Snap._.svgTransform2string(b), this.getBBox());\n      } else {\n        b = Snap._.transform2matrix(b, this.getBBox());\n      }\n\n      return equaliseTransform(a, b, function () {\n        return el.getBBox(1);\n      });\n    }\n\n    if (name == \"d\" || name == \"path\") {\n      A = Snap.path.toCubic(a, b);\n      return {\n        from: path2array(A[0]),\n        to: path2array(A[1]),\n        f: getPath(A[0])\n      };\n    }\n\n    if (name == \"points\") {\n      A = Str(a).split(Snap._.separator);\n      B = Str(b).split(Snap._.separator);\n      return {\n        from: A,\n        to: B,\n        f: function f(val) {\n          return val;\n        }\n      };\n    }\n\n    if (isNumeric(a) && isNumeric(b)) {\n      return {\n        from: parseFloat(a),\n        to: parseFloat(b),\n        f: getNumber\n      };\n    }\n\n    var aUnit = a.match(reUnit),\n        bUnit = Str(b).match(reUnit);\n\n    if (aUnit && arrayEqual(aUnit, bUnit)) {\n      return {\n        from: parseFloat(a),\n        to: parseFloat(b),\n        f: getUnit(aUnit)\n      };\n    } else {\n      return {\n        from: this.asPX(name),\n        to: this.asPX(name, b),\n        f: getNumber\n      };\n    }\n  });\n}); // Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved.\n// \n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n// \n// http://www.apache.org/licenses/LICENSE-2.0\n// \n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\nSnap.plugin(function (Snap, Element, Paper, glob) {\n  var elproto = Element.prototype,\n      has = \"hasOwnProperty\",\n      supportsTouch = \"createTouch\" in glob.doc,\n      events = [\"click\", \"dblclick\", \"mousedown\", \"mousemove\", \"mouseout\", \"mouseover\", \"mouseup\", \"touchstart\", \"touchmove\", \"touchend\", \"touchcancel\"],\n      touchMap = {\n    mousedown: \"touchstart\",\n    mousemove: \"touchmove\",\n    mouseup: \"touchend\"\n  },\n      getScroll = function getScroll(xy, el) {\n    var name = xy == \"y\" ? \"scrollTop\" : \"scrollLeft\",\n        doc = el && el.node ? el.node.ownerDocument : glob.doc;\n    return doc[name in doc.documentElement ? \"documentElement\" : \"body\"][name];\n  },\n      preventDefault = function preventDefault() {\n    this.returnValue = false;\n  },\n      preventTouch = function preventTouch() {\n    return this.originalEvent.preventDefault();\n  },\n      stopPropagation = function stopPropagation() {\n    this.cancelBubble = true;\n  },\n      stopTouch = function stopTouch() {\n    return this.originalEvent.stopPropagation();\n  },\n      addEvent = function addEvent(obj, type, fn, element) {\n    var realName = supportsTouch && touchMap[type] ? touchMap[type] : type,\n        f = function f(e) {\n      var scrollY = getScroll(\"y\", element),\n          scrollX = getScroll(\"x\", element);\n\n      if (supportsTouch && touchMap[has](type)) {\n        for (var i = 0, ii = e.targetTouches && e.targetTouches.length; i < ii; i++) {\n          if (e.targetTouches[i].target == obj || obj.contains(e.targetTouches[i].target)) {\n            var olde = e;\n            e = e.targetTouches[i];\n            e.originalEvent = olde;\n            e.preventDefault = preventTouch;\n            e.stopPropagation = stopTouch;\n            break;\n          }\n        }\n      }\n\n      var x = e.clientX + scrollX,\n          y = e.clientY + scrollY;\n      return fn.call(element, e, x, y);\n    };\n\n    if (type !== realName) {\n      obj.addEventListener(type, f, false);\n    }\n\n    obj.addEventListener(realName, f, false);\n    return function () {\n      if (type !== realName) {\n        obj.removeEventListener(type, f, false);\n      }\n\n      obj.removeEventListener(realName, f, false);\n      return true;\n    };\n  },\n      drag = [],\n      dragMove = function dragMove(e) {\n    var x = e.clientX,\n        y = e.clientY,\n        scrollY = getScroll(\"y\"),\n        scrollX = getScroll(\"x\"),\n        dragi,\n        j = drag.length;\n\n    while (j--) {\n      dragi = drag[j];\n\n      if (supportsTouch) {\n        var i = e.touches && e.touches.length,\n            touch;\n\n        while (i--) {\n          touch = e.touches[i];\n\n          if (touch.identifier == dragi.el._drag.id || dragi.el.node.contains(touch.target)) {\n            x = touch.clientX;\n            y = touch.clientY;\n            (e.originalEvent ? e.originalEvent : e).preventDefault();\n            break;\n          }\n        }\n      } else {\n        e.preventDefault();\n      }\n\n      var node = dragi.el.node,\n          o,\n          next = node.nextSibling,\n          parent = node.parentNode,\n          display = node.style.display; // glob.win.opera && parent.removeChild(node);\n      // node.style.display = \"none\";\n      // o = dragi.el.paper.getElementByPoint(x, y);\n      // node.style.display = display;\n      // glob.win.opera && (next ? parent.insertBefore(node, next) : parent.appendChild(node));\n      // o && eve(\"snap.drag.over.\" + dragi.el.id, dragi.el, o);\n\n      x += scrollX;\n      y += scrollY;\n      eve(\"snap.drag.move.\" + dragi.el.id, dragi.move_scope || dragi.el, x - dragi.el._drag.x, y - dragi.el._drag.y, x, y, e);\n    }\n  },\n      dragUp = function dragUp(e) {\n    Snap.unmousemove(dragMove).unmouseup(dragUp);\n    var i = drag.length,\n        dragi;\n\n    while (i--) {\n      dragi = drag[i];\n      dragi.el._drag = {};\n      eve(\"snap.drag.end.\" + dragi.el.id, dragi.end_scope || dragi.start_scope || dragi.move_scope || dragi.el, e);\n      eve.off(\"snap.drag.*.\" + dragi.el.id);\n    }\n\n    drag = [];\n  };\n  /*\\\n   * Element.click\n   [ method ]\n   **\n   * Adds a click event handler to the element\n   - handler (function) handler for the event\n   = (object) @Element\n  \\*/\n\n  /*\\\n   * Element.unclick\n   [ method ]\n   **\n   * Removes a click event handler from the element\n   - handler (function) handler for the event\n   = (object) @Element\n  \\*/\n\n  /*\\\n   * Element.dblclick\n   [ method ]\n   **\n   * Adds a double click event handler to the element\n   - handler (function) handler for the event\n   = (object) @Element\n  \\*/\n\n  /*\\\n   * Element.undblclick\n   [ method ]\n   **\n   * Removes a double click event handler from the element\n   - handler (function) handler for the event\n   = (object) @Element\n  \\*/\n\n  /*\\\n   * Element.mousedown\n   [ method ]\n   **\n   * Adds a mousedown event handler to the element\n   - handler (function) handler for the event\n   = (object) @Element\n  \\*/\n\n  /*\\\n   * Element.unmousedown\n   [ method ]\n   **\n   * Removes a mousedown event handler from the element\n   - handler (function) handler for the event\n   = (object) @Element\n  \\*/\n\n  /*\\\n   * Element.mousemove\n   [ method ]\n   **\n   * Adds a mousemove event handler to the element\n   - handler (function) handler for the event\n   = (object) @Element\n  \\*/\n\n  /*\\\n   * Element.unmousemove\n   [ method ]\n   **\n   * Removes a mousemove event handler from the element\n   - handler (function) handler for the event\n   = (object) @Element\n  \\*/\n\n  /*\\\n   * Element.mouseout\n   [ method ]\n   **\n   * Adds a mouseout event handler to the element\n   - handler (function) handler for the event\n   = (object) @Element\n  \\*/\n\n  /*\\\n   * Element.unmouseout\n   [ method ]\n   **\n   * Removes a mouseout event handler from the element\n   - handler (function) handler for the event\n   = (object) @Element\n  \\*/\n\n  /*\\\n   * Element.mouseover\n   [ method ]\n   **\n   * Adds a mouseover event handler to the element\n   - handler (function) handler for the event\n   = (object) @Element\n  \\*/\n\n  /*\\\n   * Element.unmouseover\n   [ method ]\n   **\n   * Removes a mouseover event handler from the element\n   - handler (function) handler for the event\n   = (object) @Element\n  \\*/\n\n  /*\\\n   * Element.mouseup\n   [ method ]\n   **\n   * Adds a mouseup event handler to the element\n   - handler (function) handler for the event\n   = (object) @Element\n  \\*/\n\n  /*\\\n   * Element.unmouseup\n   [ method ]\n   **\n   * Removes a mouseup event handler from the element\n   - handler (function) handler for the event\n   = (object) @Element\n  \\*/\n\n  /*\\\n   * Element.touchstart\n   [ method ]\n   **\n   * Adds a touchstart event handler to the element\n   - handler (function) handler for the event\n   = (object) @Element\n  \\*/\n\n  /*\\\n   * Element.untouchstart\n   [ method ]\n   **\n   * Removes a touchstart event handler from the element\n   - handler (function) handler for the event\n   = (object) @Element\n  \\*/\n\n  /*\\\n   * Element.touchmove\n   [ method ]\n   **\n   * Adds a touchmove event handler to the element\n   - handler (function) handler for the event\n   = (object) @Element\n  \\*/\n\n  /*\\\n   * Element.untouchmove\n   [ method ]\n   **\n   * Removes a touchmove event handler from the element\n   - handler (function) handler for the event\n   = (object) @Element\n  \\*/\n\n  /*\\\n   * Element.touchend\n   [ method ]\n   **\n   * Adds a touchend event handler to the element\n   - handler (function) handler for the event\n   = (object) @Element\n  \\*/\n\n  /*\\\n   * Element.untouchend\n   [ method ]\n   **\n   * Removes a touchend event handler from the element\n   - handler (function) handler for the event\n   = (object) @Element\n  \\*/\n\n  /*\\\n   * Element.touchcancel\n   [ method ]\n   **\n   * Adds a touchcancel event handler to the element\n   - handler (function) handler for the event\n   = (object) @Element\n  \\*/\n\n  /*\\\n   * Element.untouchcancel\n   [ method ]\n   **\n   * Removes a touchcancel event handler from the element\n   - handler (function) handler for the event\n   = (object) @Element\n  \\*/\n\n\n  for (var i = events.length; i--;) {\n    (function (eventName) {\n      Snap[eventName] = elproto[eventName] = function (fn, scope) {\n        if (Snap.is(fn, \"function\")) {\n          this.events = this.events || [];\n          this.events.push({\n            name: eventName,\n            f: fn,\n            unbind: addEvent(this.node || document, eventName, fn, scope || this)\n          });\n        } else {\n          for (var i = 0, ii = this.events.length; i < ii; i++) {\n            if (this.events[i].name == eventName) {\n              try {\n                this.events[i].f.call(this);\n              } catch (e) {}\n            }\n          }\n        }\n\n        return this;\n      };\n\n      Snap[\"un\" + eventName] = elproto[\"un\" + eventName] = function (fn) {\n        var events = this.events || [],\n            l = events.length;\n\n        while (l--) {\n          if (events[l].name == eventName && (events[l].f == fn || !fn)) {\n            events[l].unbind();\n            events.splice(l, 1);\n            !events.length && delete this.events;\n            return this;\n          }\n        }\n\n        return this;\n      };\n    })(events[i]);\n  }\n  /*\\\n   * Element.hover\n   [ method ]\n   **\n   * Adds hover event handlers to the element\n   - f_in (function) handler for hover in\n   - f_out (function) handler for hover out\n   - icontext (object) #optional context for hover in handler\n   - ocontext (object) #optional context for hover out handler\n   = (object) @Element\n  \\*/\n\n\n  elproto.hover = function (f_in, f_out, scope_in, scope_out) {\n    return this.mouseover(f_in, scope_in).mouseout(f_out, scope_out || scope_in);\n  };\n  /*\\\n   * Element.unhover\n   [ method ]\n   **\n   * Removes hover event handlers from the element\n   - f_in (function) handler for hover in\n   - f_out (function) handler for hover out\n   = (object) @Element\n  \\*/\n\n\n  elproto.unhover = function (f_in, f_out) {\n    return this.unmouseover(f_in).unmouseout(f_out);\n  };\n\n  var draggable = []; // SIERRA unclear what _context_ refers to for starting, ending, moving the drag gesture.\n  // SIERRA Element.drag(): _x position of the mouse_: Where are the x/y values offset from?\n  // SIERRA Element.drag(): much of this member's doc appears to be duplicated for some reason.\n  // SIERRA Unclear about this sentence: _Additionally following drag events will be triggered: drag.start.<id> on start, drag.end.<id> on end and drag.move.<id> on every move._ Is there a global _drag_ object to which you can assign handlers keyed by an element's ID?\n\n  /*\\\n   * Element.drag\n   [ method ]\n   **\n   * Adds event handlers for an element's drag gesture\n   **\n   - onmove (function) handler for moving\n   - onstart (function) handler for drag start\n   - onend (function) handler for drag end\n   - mcontext (object) #optional context for moving handler\n   - scontext (object) #optional context for drag start handler\n   - econtext (object) #optional context for drag end handler\n   * Additionaly following `drag` events are triggered: `drag.start.<id>` on start, \n   * `drag.end.<id>` on end and `drag.move.<id>` on every move. When element is dragged over another element \n   * `drag.over.<id>` fires as well.\n   *\n   * Start event and start handler are called in specified context or in context of the element with following parameters:\n   o x (number) x position of the mouse\n   o y (number) y position of the mouse\n   o event (object) DOM event object\n   * Move event and move handler are called in specified context or in context of the element with following parameters:\n   o dx (number) shift by x from the start point\n   o dy (number) shift by y from the start point\n   o x (number) x position of the mouse\n   o y (number) y position of the mouse\n   o event (object) DOM event object\n   * End event and end handler are called in specified context or in context of the element with following parameters:\n   o event (object) DOM event object\n   = (object) @Element\n  \\*/\n\n  elproto.drag = function (onmove, onstart, onend, move_scope, start_scope, end_scope) {\n    var el = this;\n\n    if (!arguments.length) {\n      var origTransform;\n      return el.drag(function (dx, dy) {\n        this.attr({\n          transform: origTransform + (origTransform ? \"T\" : \"t\") + [dx, dy]\n        });\n      }, function () {\n        origTransform = this.transform().local;\n      });\n    }\n\n    function start(e, x, y) {\n      (e.originalEvent || e).preventDefault();\n      el._drag.x = x;\n      el._drag.y = y;\n      el._drag.id = e.identifier;\n      !drag.length && Snap.mousemove(dragMove).mouseup(dragUp);\n      drag.push({\n        el: el,\n        move_scope: move_scope,\n        start_scope: start_scope,\n        end_scope: end_scope\n      });\n      onstart && eve.on(\"snap.drag.start.\" + el.id, onstart);\n      onmove && eve.on(\"snap.drag.move.\" + el.id, onmove);\n      onend && eve.on(\"snap.drag.end.\" + el.id, onend);\n      eve(\"snap.drag.start.\" + el.id, start_scope || move_scope || el, x, y, e);\n    }\n\n    function init(e, x, y) {\n      eve(\"snap.draginit.\" + el.id, el, e, x, y);\n    }\n\n    eve.on(\"snap.draginit.\" + el.id, start);\n    el._drag = {};\n    draggable.push({\n      el: el,\n      start: start,\n      init: init\n    });\n    el.mousedown(init);\n    return el;\n  };\n  /*\n   * Element.onDragOver\n   [ method ]\n   **\n   * Shortcut to assign event handler for `drag.over.<id>` event, where `id` is the element's `id` (see @Element.id)\n   - f (function) handler for event, first argument would be the element you are dragging over\n  \\*/\n  // elproto.onDragOver = function (f) {\n  //     f ? eve.on(\"snap.drag.over.\" + this.id, f) : eve.unbind(\"snap.drag.over.\" + this.id);\n  // };\n\n  /*\\\n   * Element.undrag\n   [ method ]\n   **\n   * Removes all drag event handlers from the given element\n  \\*/\n\n\n  elproto.undrag = function () {\n    var i = draggable.length;\n\n    while (i--) {\n      if (draggable[i].el == this) {\n        this.unmousedown(draggable[i].init);\n        draggable.splice(i, 1);\n        eve.unbind(\"snap.drag.*.\" + this.id);\n        eve.unbind(\"snap.draginit.\" + this.id);\n      }\n    }\n\n    !draggable.length && Snap.unmousemove(dragMove).unmouseup(dragUp);\n    return this;\n  };\n}); // Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\nSnap.plugin(function (Snap, Element, Paper, glob) {\n  var elproto = Element.prototype,\n      pproto = Paper.prototype,\n      rgurl = /^\\s*url\\((.+)\\)/,\n      Str = String,\n      $ = Snap._.$;\n  Snap.filter = {};\n  /*\\\n   * Paper.filter\n   [ method ]\n   **\n   * Creates a `<filter>` element\n   **\n   - filstr (string) SVG fragment of filter provided as a string\n   = (object) @Element\n   * Note: It is recommended to use filters embedded into the page inside an empty SVG element.\n   > Usage\n   | var f = paper.filter('<feGaussianBlur stdDeviation=\"2\"/>'),\n   |     c = paper.circle(10, 10, 10).attr({\n   |         filter: f\n   |     });\n  \\*/\n\n  pproto.filter = function (filstr) {\n    var paper = this;\n\n    if (paper.type != \"svg\") {\n      paper = paper.paper;\n    }\n\n    var f = Snap.parse(Str(filstr)),\n        id = Snap._.id(),\n        width = paper.node.offsetWidth,\n        height = paper.node.offsetHeight,\n        filter = $(\"filter\");\n\n    $(filter, {\n      id: id,\n      filterUnits: \"userSpaceOnUse\"\n    });\n    filter.appendChild(f.node);\n    paper.defs.appendChild(filter);\n    return new Element(filter);\n  };\n\n  eve.on(\"snap.util.getattr.filter\", function () {\n    eve.stop();\n    var p = $(this.node, \"filter\");\n\n    if (p) {\n      var match = Str(p).match(rgurl);\n      return match && Snap.select(match[1]);\n    }\n  });\n  eve.on(\"snap.util.attr.filter\", function (value) {\n    if (value instanceof Element && value.type == \"filter\") {\n      eve.stop();\n      var id = value.node.id;\n\n      if (!id) {\n        $(value.node, {\n          id: value.id\n        });\n        id = value.id;\n      }\n\n      $(this.node, {\n        filter: Snap.url(id)\n      });\n    }\n\n    if (!value || value == \"none\") {\n      eve.stop();\n      this.node.removeAttribute(\"filter\");\n    }\n  });\n  /*\\\n   * Snap.filter.blur\n   [ method ]\n   **\n   * Returns an SVG markup string for the blur filter\n   **\n   - x (number) amount of horizontal blur, in pixels\n   - y (number) #optional amount of vertical blur, in pixels\n   = (string) filter representation\n   > Usage\n   | var f = paper.filter(Snap.filter.blur(5, 10)),\n   |     c = paper.circle(10, 10, 10).attr({\n   |         filter: f\n   |     });\n  \\*/\n\n  Snap.filter.blur = function (x, y) {\n    if (x == null) {\n      x = 2;\n    }\n\n    var def = y == null ? x : [x, y];\n    return Snap.format('\\<feGaussianBlur stdDeviation=\"{def}\"/>', {\n      def: def\n    });\n  };\n\n  Snap.filter.blur.toString = function () {\n    return this();\n  };\n  /*\\\n   * Snap.filter.shadow\n   [ method ]\n   **\n   * Returns an SVG markup string for the shadow filter\n   **\n   - dx (number) #optional horizontal shift of the shadow, in pixels\n   - dy (number) #optional vertical shift of the shadow, in pixels\n   - blur (number) #optional amount of blur\n   - color (string) #optional color of the shadow\n   - opacity (number) #optional `0..1` opacity of the shadow\n   * or\n   - dx (number) #optional horizontal shift of the shadow, in pixels\n   - dy (number) #optional vertical shift of the shadow, in pixels\n   - color (string) #optional color of the shadow\n   - opacity (number) #optional `0..1` opacity of the shadow\n   * which makes blur default to `4`. Or\n   - dx (number) #optional horizontal shift of the shadow, in pixels\n   - dy (number) #optional vertical shift of the shadow, in pixels\n   - opacity (number) #optional `0..1` opacity of the shadow\n   = (string) filter representation\n   > Usage\n   | var f = paper.filter(Snap.filter.shadow(0, 2, .3)),\n   |     c = paper.circle(10, 10, 10).attr({\n   |         filter: f\n   |     });\n  \\*/\n\n\n  Snap.filter.shadow = function (dx, dy, blur, color, opacity) {\n    if (opacity == null) {\n      if (color == null) {\n        opacity = blur;\n        blur = 4;\n        color = \"#000\";\n      } else {\n        opacity = color;\n        color = blur;\n        blur = 4;\n      }\n    }\n\n    if (blur == null) {\n      blur = 4;\n    }\n\n    if (opacity == null) {\n      opacity = 1;\n    }\n\n    if (dx == null) {\n      dx = 0;\n      dy = 2;\n    }\n\n    if (dy == null) {\n      dy = dx;\n    }\n\n    color = Snap.color(color);\n    return Snap.format('<feGaussianBlur in=\"SourceAlpha\" stdDeviation=\"{blur}\"/><feOffset dx=\"{dx}\" dy=\"{dy}\" result=\"offsetblur\"/><feFlood flood-color=\"{color}\"/><feComposite in2=\"offsetblur\" operator=\"in\"/><feComponentTransfer><feFuncA type=\"linear\" slope=\"{opacity}\"/></feComponentTransfer><feMerge><feMergeNode/><feMergeNode in=\"SourceGraphic\"/></feMerge>', {\n      color: color,\n      dx: dx,\n      dy: dy,\n      blur: blur,\n      opacity: opacity\n    });\n  };\n\n  Snap.filter.shadow.toString = function () {\n    return this();\n  };\n  /*\\\n   * Snap.filter.grayscale\n   [ method ]\n   **\n   * Returns an SVG markup string for the grayscale filter\n   **\n   - amount (number) amount of filter (`0..1`)\n   = (string) filter representation\n  \\*/\n\n\n  Snap.filter.grayscale = function (amount) {\n    if (amount == null) {\n      amount = 1;\n    }\n\n    return Snap.format('<feColorMatrix type=\"matrix\" values=\"{a} {b} {c} 0 0 {d} {e} {f} 0 0 {g} {b} {h} 0 0 0 0 0 1 0\"/>', {\n      a: 0.2126 + 0.7874 * (1 - amount),\n      b: 0.7152 - 0.7152 * (1 - amount),\n      c: 0.0722 - 0.0722 * (1 - amount),\n      d: 0.2126 - 0.2126 * (1 - amount),\n      e: 0.7152 + 0.2848 * (1 - amount),\n      f: 0.0722 - 0.0722 * (1 - amount),\n      g: 0.2126 - 0.2126 * (1 - amount),\n      h: 0.0722 + 0.9278 * (1 - amount)\n    });\n  };\n\n  Snap.filter.grayscale.toString = function () {\n    return this();\n  };\n  /*\\\n   * Snap.filter.sepia\n   [ method ]\n   **\n   * Returns an SVG markup string for the sepia filter\n   **\n   - amount (number) amount of filter (`0..1`)\n   = (string) filter representation\n  \\*/\n\n\n  Snap.filter.sepia = function (amount) {\n    if (amount == null) {\n      amount = 1;\n    }\n\n    return Snap.format('<feColorMatrix type=\"matrix\" values=\"{a} {b} {c} 0 0 {d} {e} {f} 0 0 {g} {h} {i} 0 0 0 0 0 1 0\"/>', {\n      a: 0.393 + 0.607 * (1 - amount),\n      b: 0.769 - 0.769 * (1 - amount),\n      c: 0.189 - 0.189 * (1 - amount),\n      d: 0.349 - 0.349 * (1 - amount),\n      e: 0.686 + 0.314 * (1 - amount),\n      f: 0.168 - 0.168 * (1 - amount),\n      g: 0.272 - 0.272 * (1 - amount),\n      h: 0.534 - 0.534 * (1 - amount),\n      i: 0.131 + 0.869 * (1 - amount)\n    });\n  };\n\n  Snap.filter.sepia.toString = function () {\n    return this();\n  };\n  /*\\\n   * Snap.filter.saturate\n   [ method ]\n   **\n   * Returns an SVG markup string for the saturate filter\n   **\n   - amount (number) amount of filter (`0..1`)\n   = (string) filter representation\n  \\*/\n\n\n  Snap.filter.saturate = function (amount) {\n    if (amount == null) {\n      amount = 1;\n    }\n\n    return Snap.format('<feColorMatrix type=\"saturate\" values=\"{amount}\"/>', {\n      amount: 1 - amount\n    });\n  };\n\n  Snap.filter.saturate.toString = function () {\n    return this();\n  };\n  /*\\\n   * Snap.filter.hueRotate\n   [ method ]\n   **\n   * Returns an SVG markup string for the hue-rotate filter\n   **\n   - angle (number) angle of rotation\n   = (string) filter representation\n  \\*/\n\n\n  Snap.filter.hueRotate = function (angle) {\n    angle = angle || 0;\n    return Snap.format('<feColorMatrix type=\"hueRotate\" values=\"{angle}\"/>', {\n      angle: angle\n    });\n  };\n\n  Snap.filter.hueRotate.toString = function () {\n    return this();\n  };\n  /*\\\n   * Snap.filter.invert\n   [ method ]\n   **\n   * Returns an SVG markup string for the invert filter\n   **\n   - amount (number) amount of filter (`0..1`)\n   = (string) filter representation\n  \\*/\n\n\n  Snap.filter.invert = function (amount) {\n    if (amount == null) {\n      amount = 1;\n    } //        <feColorMatrix type=\"matrix\" values=\"-1 0 0 0 1  0 -1 0 0 1  0 0 -1 0 1  0 0 0 1 0\" color-interpolation-filters=\"sRGB\"/>\n\n\n    return Snap.format('<feComponentTransfer><feFuncR type=\"table\" tableValues=\"{amount} {amount2}\"/><feFuncG type=\"table\" tableValues=\"{amount} {amount2}\"/><feFuncB type=\"table\" tableValues=\"{amount} {amount2}\"/></feComponentTransfer>', {\n      amount: amount,\n      amount2: 1 - amount\n    });\n  };\n\n  Snap.filter.invert.toString = function () {\n    return this();\n  };\n  /*\\\n   * Snap.filter.brightness\n   [ method ]\n   **\n   * Returns an SVG markup string for the brightness filter\n   **\n   - amount (number) amount of filter (`0..1`)\n   = (string) filter representation\n  \\*/\n\n\n  Snap.filter.brightness = function (amount) {\n    if (amount == null) {\n      amount = 1;\n    }\n\n    return Snap.format('<feComponentTransfer><feFuncR type=\"linear\" slope=\"{amount}\"/><feFuncG type=\"linear\" slope=\"{amount}\"/><feFuncB type=\"linear\" slope=\"{amount}\"/></feComponentTransfer>', {\n      amount: amount\n    });\n  };\n\n  Snap.filter.brightness.toString = function () {\n    return this();\n  };\n  /*\\\n   * Snap.filter.contrast\n   [ method ]\n   **\n   * Returns an SVG markup string for the contrast filter\n   **\n   - amount (number) amount of filter (`0..1`)\n   = (string) filter representation\n  \\*/\n\n\n  Snap.filter.contrast = function (amount) {\n    if (amount == null) {\n      amount = 1;\n    }\n\n    return Snap.format('<feComponentTransfer><feFuncR type=\"linear\" slope=\"{amount}\" intercept=\"{amount2}\"/><feFuncG type=\"linear\" slope=\"{amount}\" intercept=\"{amount2}\"/><feFuncB type=\"linear\" slope=\"{amount}\" intercept=\"{amount2}\"/></feComponentTransfer>', {\n      amount: amount,\n      amount2: .5 - amount / 2\n    });\n  };\n\n  Snap.filter.contrast.toString = function () {\n    return this();\n  };\n}); // Copyright (c) 2014 Adobe Systems Incorporated. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\nSnap.plugin(function (Snap, Element, Paper, glob, Fragment) {\n  var box = Snap._.box,\n      is = Snap.is,\n      firstLetter = /^[^a-z]*([tbmlrc])/i,\n      toString = function toString() {\n    return \"T\" + this.dx + \",\" + this.dy;\n  };\n  /*\\\n   * Element.getAlign\n   [ method ]\n   **\n   * Returns shift needed to align the element relatively to given element.\n   * If no elements specified, parent `<svg>` container will be used.\n   - el (object) @optional alignment element\n   - way (string) one of six values: `\"top\"`, `\"middle\"`, `\"bottom\"`, `\"left\"`, `\"center\"`, `\"right\"`\n   = (object|string) Object in format `{dx: , dy: }` also has a string representation as a transformation string\n   > Usage\n   | el.transform(el.getAlign(el2, \"top\"));\n   * or\n   | var dy = el.getAlign(el2, \"top\").dy;\n  \\*/\n\n\n  Element.prototype.getAlign = function (el, way) {\n    if (way == null && is(el, \"string\")) {\n      way = el;\n      el = null;\n    }\n\n    el = el || this.paper;\n    var bx = el.getBBox ? el.getBBox() : box(el),\n        bb = this.getBBox(),\n        out = {};\n    way = way && way.match(firstLetter);\n    way = way ? way[1].toLowerCase() : \"c\";\n\n    switch (way) {\n      case \"t\":\n        out.dx = 0;\n        out.dy = bx.y - bb.y;\n        break;\n\n      case \"b\":\n        out.dx = 0;\n        out.dy = bx.y2 - bb.y2;\n        break;\n\n      case \"m\":\n        out.dx = 0;\n        out.dy = bx.cy - bb.cy;\n        break;\n\n      case \"l\":\n        out.dx = bx.x - bb.x;\n        out.dy = 0;\n        break;\n\n      case \"r\":\n        out.dx = bx.x2 - bb.x2;\n        out.dy = 0;\n        break;\n\n      default:\n        out.dx = bx.cx - bb.cx;\n        out.dy = 0;\n        break;\n    }\n\n    out.toString = toString;\n    return out;\n  };\n  /*\\\n   * Element.align\n   [ method ]\n   **\n   * Aligns the element relatively to given one via transformation.\n   * If no elements specified, parent `<svg>` container will be used.\n   - el (object) @optional alignment element\n   - way (string) one of six values: `\"top\"`, `\"middle\"`, `\"bottom\"`, `\"left\"`, `\"center\"`, `\"right\"`\n   = (object) this element\n   > Usage\n   | el.align(el2, \"top\");\n   * or\n   | el.align(\"middle\");\n  \\*/\n\n\n  Element.prototype.align = function (el, way) {\n    return this.transform(\"...\" + this.getAlign(el, way));\n  };\n}); // Copyright (c) 2016 Adobe Systems Incorporated. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\nSnap.plugin(function (Snap, Element, Paper, glob, Fragment) {\n  var elproto = Element.prototype,\n      is = Snap.is,\n      Str = String,\n      has = \"hasOwnProperty\";\n\n  function slice(from, to, f) {\n    return function (arr) {\n      var res = arr.slice(from, to);\n\n      if (res.length == 1) {\n        res = res[0];\n      }\n\n      return f ? f(res) : res;\n    };\n  }\n\n  var Animation = function Animation(attr, ms, easing, callback) {\n    if (typeof easing == \"function\" && !easing.length) {\n      callback = easing;\n      easing = mina.linear;\n    }\n\n    this.attr = attr;\n    this.dur = ms;\n    easing && (this.easing = easing);\n    callback && (this.callback = callback);\n  };\n\n  Snap._.Animation = Animation;\n  /*\\\n   * Snap.animation\n   [ method ]\n   **\n   * Creates an animation object\n   **\n   - attr (object) attributes of final destination\n   - duration (number) duration of the animation, in milliseconds\n   - easing (function) #optional one of easing functions of @mina or custom one\n   - callback (function) #optional callback function that fires when animation ends\n   = (object) animation object\n  \\*/\n\n  Snap.animation = function (attr, ms, easing, callback) {\n    return new Animation(attr, ms, easing, callback);\n  };\n  /*\\\n   * Element.inAnim\n   [ method ]\n   **\n   * Returns a set of animations that may be able to manipulate the current element\n   **\n   = (object) in format:\n   o {\n   o     anim (object) animation object,\n   o     mina (object) @mina object,\n   o     curStatus (number) 0..1 — status of the animation: 0 — just started, 1 — just finished,\n   o     status (function) gets or sets the status of the animation,\n   o     stop (function) stops the animation\n   o }\n  \\*/\n\n\n  elproto.inAnim = function () {\n    var el = this,\n        res = [];\n\n    for (var id in el.anims) {\n      if (el.anims[has](id)) {\n        (function (a) {\n          res.push({\n            anim: new Animation(a._attrs, a.dur, a.easing, a._callback),\n            mina: a,\n            curStatus: a.status(),\n            status: function status(val) {\n              return a.status(val);\n            },\n            stop: function stop() {\n              a.stop();\n            }\n          });\n        })(el.anims[id]);\n      }\n    }\n\n    return res;\n  };\n  /*\\\n   * Snap.animate\n   [ method ]\n   **\n   * Runs generic animation of one number into another with a caring function\n   **\n   - from (number|array) number or array of numbers\n   - to (number|array) number or array of numbers\n   - setter (function) caring function that accepts one number argument\n   - duration (number) duration, in milliseconds\n   - easing (function) #optional easing function from @mina or custom\n   - callback (function) #optional callback function to execute when animation ends\n   = (object) animation object in @mina format\n   o {\n   o     id (string) animation id, consider it read-only,\n   o     duration (function) gets or sets the duration of the animation,\n   o     easing (function) easing,\n   o     speed (function) gets or sets the speed of the animation,\n   o     status (function) gets or sets the status of the animation,\n   o     stop (function) stops the animation\n   o }\n   | var rect = Snap().rect(0, 0, 10, 10);\n   | Snap.animate(0, 10, function (val) {\n   |     rect.attr({\n   |         x: val\n   |     });\n   | }, 1000);\n   | // in given context is equivalent to\n   | rect.animate({x: 10}, 1000);\n  \\*/\n\n\n  Snap.animate = function (from, to, setter, ms, easing, callback) {\n    if (typeof easing == \"function\" && !easing.length) {\n      callback = easing;\n      easing = mina.linear;\n    }\n\n    var now = mina.time(),\n        anim = mina(from, to, now, now + ms, mina.time, setter, easing);\n    callback && eve.once(\"mina.finish.\" + anim.id, callback);\n    return anim;\n  };\n  /*\\\n   * Element.stop\n   [ method ]\n   **\n   * Stops all the animations for the current element\n   **\n   = (Element) the current element\n  \\*/\n\n\n  elproto.stop = function () {\n    var anims = this.inAnim();\n\n    for (var i = 0, ii = anims.length; i < ii; i++) {\n      anims[i].stop();\n    }\n\n    return this;\n  };\n  /*\\\n   * Element.animate\n   [ method ]\n   **\n   * Animates the given attributes of the element\n   **\n   - attrs (object) key-value pairs of destination attributes\n   - duration (number) duration of the animation in milliseconds\n   - easing (function) #optional easing function from @mina or custom\n   - callback (function) #optional callback function that executes when the animation ends\n   = (Element) the current element\n  \\*/\n\n\n  elproto.animate = function (attrs, ms, easing, callback) {\n    if (typeof easing == \"function\" && !easing.length) {\n      callback = easing;\n      easing = mina.linear;\n    }\n\n    if (attrs instanceof Animation) {\n      callback = attrs.callback;\n      easing = attrs.easing;\n      ms = attrs.dur;\n      attrs = attrs.attr;\n    }\n\n    var fkeys = [],\n        tkeys = [],\n        keys = {},\n        from,\n        to,\n        f,\n        eq,\n        el = this;\n\n    for (var key in attrs) {\n      if (attrs[has](key)) {\n        if (el.equal) {\n          eq = el.equal(key, Str(attrs[key]));\n          from = eq.from;\n          to = eq.to;\n          f = eq.f;\n        } else {\n          from = +el.attr(key);\n          to = +attrs[key];\n        }\n\n        var len = is(from, \"array\") ? from.length : 1;\n        keys[key] = slice(fkeys.length, fkeys.length + len, f);\n        fkeys = fkeys.concat(from);\n        tkeys = tkeys.concat(to);\n      }\n    }\n\n    var now = mina.time(),\n        anim = mina(fkeys, tkeys, now, now + ms, mina.time, function (val) {\n      var attr = {};\n\n      for (var key in keys) {\n        if (keys[has](key)) {\n          attr[key] = keys[key](val);\n        }\n      }\n\n      el.attr(attr);\n    }, easing);\n    el.anims[anim.id] = anim;\n    anim._attrs = attrs;\n    anim._callback = callback;\n    eve(\"snap.animcreated.\" + el.id, anim);\n    eve.once(\"mina.finish.\" + anim.id, function () {\n      eve.off(\"mina.*.\" + anim.id);\n      delete el.anims[anim.id];\n      callback && callback.call(el);\n    });\n    eve.once(\"mina.stop.\" + anim.id, function () {\n      eve.off(\"mina.*.\" + anim.id);\n      delete el.anims[anim.id];\n    });\n    return el;\n  };\n}); // Copyright (c) 2017 Adobe Systems Incorporated. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\nSnap.plugin(function (Snap, Element, Paper, glob) {\n  // Colours are from https://www.materialui.co\n  var red = \"#ffebee#ffcdd2#ef9a9a#e57373#ef5350#f44336#e53935#d32f2f#c62828#b71c1c#ff8a80#ff5252#ff1744#d50000\",\n      pink = \"#FCE4EC#F8BBD0#F48FB1#F06292#EC407A#E91E63#D81B60#C2185B#AD1457#880E4F#FF80AB#FF4081#F50057#C51162\",\n      purple = \"#F3E5F5#E1BEE7#CE93D8#BA68C8#AB47BC#9C27B0#8E24AA#7B1FA2#6A1B9A#4A148C#EA80FC#E040FB#D500F9#AA00FF\",\n      deeppurple = \"#EDE7F6#D1C4E9#B39DDB#9575CD#7E57C2#673AB7#5E35B1#512DA8#4527A0#311B92#B388FF#7C4DFF#651FFF#6200EA\",\n      indigo = \"#E8EAF6#C5CAE9#9FA8DA#7986CB#5C6BC0#3F51B5#3949AB#303F9F#283593#1A237E#8C9EFF#536DFE#3D5AFE#304FFE\",\n      blue = \"#E3F2FD#BBDEFB#90CAF9#64B5F6#64B5F6#2196F3#1E88E5#1976D2#1565C0#0D47A1#82B1FF#448AFF#2979FF#2962FF\",\n      lightblue = \"#E1F5FE#B3E5FC#81D4FA#4FC3F7#29B6F6#03A9F4#039BE5#0288D1#0277BD#01579B#80D8FF#40C4FF#00B0FF#0091EA\",\n      cyan = \"#E0F7FA#B2EBF2#80DEEA#4DD0E1#26C6DA#00BCD4#00ACC1#0097A7#00838F#006064#84FFFF#18FFFF#00E5FF#00B8D4\",\n      teal = \"#E0F2F1#B2DFDB#80CBC4#4DB6AC#26A69A#009688#00897B#00796B#00695C#004D40#A7FFEB#64FFDA#1DE9B6#00BFA5\",\n      green = \"#E8F5E9#C8E6C9#A5D6A7#81C784#66BB6A#4CAF50#43A047#388E3C#2E7D32#1B5E20#B9F6CA#69F0AE#00E676#00C853\",\n      lightgreen = \"#F1F8E9#DCEDC8#C5E1A5#AED581#9CCC65#8BC34A#7CB342#689F38#558B2F#33691E#CCFF90#B2FF59#76FF03#64DD17\",\n      lime = \"#F9FBE7#F0F4C3#E6EE9C#DCE775#D4E157#CDDC39#C0CA33#AFB42B#9E9D24#827717#F4FF81#EEFF41#C6FF00#AEEA00\",\n      yellow = \"#FFFDE7#FFF9C4#FFF59D#FFF176#FFEE58#FFEB3B#FDD835#FBC02D#F9A825#F57F17#FFFF8D#FFFF00#FFEA00#FFD600\",\n      amber = \"#FFF8E1#FFECB3#FFE082#FFD54F#FFCA28#FFC107#FFB300#FFA000#FF8F00#FF6F00#FFE57F#FFD740#FFC400#FFAB00\",\n      orange = \"#FFF3E0#FFE0B2#FFCC80#FFB74D#FFA726#FF9800#FB8C00#F57C00#EF6C00#E65100#FFD180#FFAB40#FF9100#FF6D00\",\n      deeporange = \"#FBE9E7#FFCCBC#FFAB91#FF8A65#FF7043#FF5722#F4511E#E64A19#D84315#BF360C#FF9E80#FF6E40#FF3D00#DD2C00\",\n      brown = \"#EFEBE9#D7CCC8#BCAAA4#A1887F#8D6E63#795548#6D4C41#5D4037#4E342E#3E2723\",\n      grey = \"#FAFAFA#F5F5F5#EEEEEE#E0E0E0#BDBDBD#9E9E9E#757575#616161#424242#212121\",\n      bluegrey = \"#ECEFF1#CFD8DC#B0BEC5#90A4AE#78909C#607D8B#546E7A#455A64#37474F#263238\";\n  /*\\\n   * Snap.mui\n   [ property ]\n   **\n   * Contain Material UI colours.\n   | Snap().rect(0, 0, 10, 10).attr({fill: Snap.mui.deeppurple, stroke: Snap.mui.amber[600]});\n   # For colour reference: <a href=\"https://www.materialui.co\">https://www.materialui.co</a>.\n  \\*/\n\n  Snap.mui = {};\n  /*\\\n   * Snap.flat\n   [ property ]\n   **\n   * Contain Flat UI colours.\n   | Snap().rect(0, 0, 10, 10).attr({fill: Snap.flat.carrot, stroke: Snap.flat.wetasphalt});\n   # For colour reference: <a href=\"https://www.materialui.co\">https://www.materialui.co</a>.\n  \\*/\n\n  Snap.flat = {};\n\n  function saveColor(colors) {\n    colors = colors.split(/(?=#)/);\n    var color = new String(colors[5]);\n    color[50] = colors[0];\n    color[100] = colors[1];\n    color[200] = colors[2];\n    color[300] = colors[3];\n    color[400] = colors[4];\n    color[500] = colors[5];\n    color[600] = colors[6];\n    color[700] = colors[7];\n    color[800] = colors[8];\n    color[900] = colors[9];\n\n    if (colors[10]) {\n      color.A100 = colors[10];\n      color.A200 = colors[11];\n      color.A400 = colors[12];\n      color.A700 = colors[13];\n    }\n\n    return color;\n  }\n\n  Snap.mui.red = saveColor(red);\n  Snap.mui.pink = saveColor(pink);\n  Snap.mui.purple = saveColor(purple);\n  Snap.mui.deeppurple = saveColor(deeppurple);\n  Snap.mui.indigo = saveColor(indigo);\n  Snap.mui.blue = saveColor(blue);\n  Snap.mui.lightblue = saveColor(lightblue);\n  Snap.mui.cyan = saveColor(cyan);\n  Snap.mui.teal = saveColor(teal);\n  Snap.mui.green = saveColor(green);\n  Snap.mui.lightgreen = saveColor(lightgreen);\n  Snap.mui.lime = saveColor(lime);\n  Snap.mui.yellow = saveColor(yellow);\n  Snap.mui.amber = saveColor(amber);\n  Snap.mui.orange = saveColor(orange);\n  Snap.mui.deeporange = saveColor(deeporange);\n  Snap.mui.brown = saveColor(brown);\n  Snap.mui.grey = saveColor(grey);\n  Snap.mui.bluegrey = saveColor(bluegrey);\n  Snap.flat.turquoise = \"#1abc9c\";\n  Snap.flat.greensea = \"#16a085\";\n  Snap.flat.sunflower = \"#f1c40f\";\n  Snap.flat.orange = \"#f39c12\";\n  Snap.flat.emerland = \"#2ecc71\";\n  Snap.flat.nephritis = \"#27ae60\";\n  Snap.flat.carrot = \"#e67e22\";\n  Snap.flat.pumpkin = \"#d35400\";\n  Snap.flat.peterriver = \"#3498db\";\n  Snap.flat.belizehole = \"#2980b9\";\n  Snap.flat.alizarin = \"#e74c3c\";\n  Snap.flat.pomegranate = \"#c0392b\";\n  Snap.flat.amethyst = \"#9b59b6\";\n  Snap.flat.wisteria = \"#8e44ad\";\n  Snap.flat.clouds = \"#ecf0f1\";\n  Snap.flat.silver = \"#bdc3c7\";\n  Snap.flat.wetasphalt = \"#34495e\";\n  Snap.flat.midnightblue = \"#2c3e50\";\n  Snap.flat.concrete = \"#95a5a6\";\n  Snap.flat.asbestos = \"#7f8c8d\";\n  /*\\\n   * Snap.importMUIColors\n   [ method ]\n   **\n   * Imports Material UI colours into global object.\n   | Snap.importMUIColors();\n   | Snap().rect(0, 0, 10, 10).attr({fill: deeppurple, stroke: amber[600]});\n   # For colour reference: <a href=\"https://www.materialui.co\">https://www.materialui.co</a>.\n  \\*/\n\n  Snap.importMUIColors = function () {\n    for (var color in Snap.mui) {\n      if (Snap.mui.hasOwnProperty(color)) {\n        window[color] = Snap.mui[color];\n      }\n    }\n  };\n});\nmodule.exports = Snap;","// Copyright (c) 2017 Adobe Systems Incorporated. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n// ┌────────────────────────────────────────────────────────────┐ \\\\\n// │ Eve 0.5.4 - JavaScript Events Library                      │ \\\\\n// ├────────────────────────────────────────────────────────────┤ \\\\\n// │ Author Dmitry Baranovskiy (http://dmitry.baranovskiy.com/) │ \\\\\n// └────────────────────────────────────────────────────────────┘ \\\\\n(function (glob) {\n  var version = \"0.5.4\",\n      has = \"hasOwnProperty\",\n      separator = /[\\.\\/]/,\n      comaseparator = /\\s*,\\s*/,\n      wildcard = \"*\",\n      numsort = function numsort(a, b) {\n    return a - b;\n  },\n      current_event,\n      stop,\n      events = {\n    n: {}\n  },\n      firstDefined = function firstDefined() {\n    for (var i = 0, ii = this.length; i < ii; i++) {\n      if (typeof this[i] != \"undefined\") {\n        return this[i];\n      }\n    }\n  },\n      lastDefined = function lastDefined() {\n    var i = this.length;\n\n    while (--i) {\n      if (typeof this[i] != \"undefined\") {\n        return this[i];\n      }\n    }\n  },\n      objtos = Object.prototype.toString,\n      Str = String,\n      isArray = Array.isArray || function (ar) {\n    return ar instanceof Array || objtos.call(ar) == \"[object Array]\";\n  },\n\n  /*\\\n   * eve\n   [ method ]\n    * Fires event with given `name`, given scope and other parameters.\n    - name (string) name of the *event*, dot (`.`) or slash (`/`) separated\n   - scope (object) context for the event handlers\n   - varargs (...) the rest of arguments will be sent to event handlers\n    = (object) array of returned values from the listeners. Array has two methods `.firstDefined()` and `.lastDefined()` to get first or last not `undefined` value.\n  \\*/\n  eve = function eve(name, scope) {\n    var oldstop = stop,\n        args = Array.prototype.slice.call(arguments, 2),\n        listeners = eve.listeners(name),\n        z = 0,\n        l,\n        indexed = [],\n        queue = {},\n        out = [],\n        ce = current_event;\n    out.firstDefined = firstDefined;\n    out.lastDefined = lastDefined;\n    current_event = name;\n    stop = 0;\n\n    for (var i = 0, ii = listeners.length; i < ii; i++) {\n      if (\"zIndex\" in listeners[i]) {\n        indexed.push(listeners[i].zIndex);\n\n        if (listeners[i].zIndex < 0) {\n          queue[listeners[i].zIndex] = listeners[i];\n        }\n      }\n    }\n\n    indexed.sort(numsort);\n\n    while (indexed[z] < 0) {\n      l = queue[indexed[z++]];\n      out.push(l.apply(scope, args));\n\n      if (stop) {\n        stop = oldstop;\n        return out;\n      }\n    }\n\n    for (i = 0; i < ii; i++) {\n      l = listeners[i];\n\n      if (\"zIndex\" in l) {\n        if (l.zIndex == indexed[z]) {\n          out.push(l.apply(scope, args));\n\n          if (stop) {\n            break;\n          }\n\n          do {\n            z++;\n            l = queue[indexed[z]];\n            l && out.push(l.apply(scope, args));\n\n            if (stop) {\n              break;\n            }\n          } while (l);\n        } else {\n          queue[l.zIndex] = l;\n        }\n      } else {\n        out.push(l.apply(scope, args));\n\n        if (stop) {\n          break;\n        }\n      }\n    }\n\n    stop = oldstop;\n    current_event = ce;\n    return out;\n  }; // Undocumented. Debug only.\n\n\n  eve._events = events;\n  /*\\\n   * eve.listeners\n   [ method ]\n    * Internal method which gives you array of all event handlers that will be triggered by the given `name`.\n    - name (string) name of the event, dot (`.`) or slash (`/`) separated\n    = (array) array of event handlers\n  \\*/\n\n  eve.listeners = function (name) {\n    var names = isArray(name) ? name : name.split(separator),\n        e = events,\n        item,\n        items,\n        k,\n        i,\n        ii,\n        j,\n        jj,\n        nes,\n        es = [e],\n        out = [];\n\n    for (i = 0, ii = names.length; i < ii; i++) {\n      nes = [];\n\n      for (j = 0, jj = es.length; j < jj; j++) {\n        e = es[j].n;\n        items = [e[names[i]], e[wildcard]];\n        k = 2;\n\n        while (k--) {\n          item = items[k];\n\n          if (item) {\n            nes.push(item);\n            out = out.concat(item.f || []);\n          }\n        }\n      }\n\n      es = nes;\n    }\n\n    return out;\n  };\n  /*\\\n   * eve.separator\n   [ method ]\n    * If for some reasons you don’t like default separators (`.` or `/`) you can specify yours\n   * here. Be aware that if you pass a string longer than one character it will be treated as\n   * a list of characters.\n    - separator (string) new separator. Empty string resets to default: `.` or `/`.\n  \\*/\n\n\n  eve.separator = function (sep) {\n    if (sep) {\n      sep = Str(sep).replace(/(?=[\\.\\^\\]\\[\\-])/g, \"\\\\\");\n      sep = \"[\" + sep + \"]\";\n      separator = new RegExp(sep);\n    } else {\n      separator = /[\\.\\/]/;\n    }\n  };\n  /*\\\n   * eve.on\n   [ method ]\n   **\n   * Binds given event handler with a given name. You can use wildcards “`*`” for the names:\n   | eve.on(\"*.under.*\", f);\n   | eve(\"mouse.under.floor\"); // triggers f\n   * Use @eve to trigger the listener.\n   **\n   - name (string) name of the event, dot (`.`) or slash (`/`) separated, with optional wildcards\n   - f (function) event handler function\n   **\n   - name (array) if you don’t want to use separators, you can use array of strings\n   - f (function) event handler function\n   **\n   = (function) returned function accepts a single numeric parameter that represents z-index of the handler. It is an optional feature and only used when you need to ensure that some subset of handlers will be invoked in a given order, despite of the order of assignment.\n   > Example:\n   | eve.on(\"mouse\", eatIt)(2);\n   | eve.on(\"mouse\", scream);\n   | eve.on(\"mouse\", catchIt)(1);\n   * This will ensure that `catchIt` function will be called before `eatIt`.\n   *\n   * If you want to put your handler before non-indexed handlers, specify a negative value.\n   * Note: I assume most of the time you don’t need to worry about z-index, but it’s nice to have this feature “just in case”.\n  \\*/\n\n\n  eve.on = function (name, f) {\n    if (typeof f != \"function\") {\n      return function () {};\n    }\n\n    var names = isArray(name) ? isArray(name[0]) ? name : [name] : Str(name).split(comaseparator);\n\n    for (var i = 0, ii = names.length; i < ii; i++) {\n      (function (name) {\n        var names = isArray(name) ? name : Str(name).split(separator),\n            e = events,\n            exist;\n\n        for (var i = 0, ii = names.length; i < ii; i++) {\n          e = e.n;\n          e = e.hasOwnProperty(names[i]) && e[names[i]] || (e[names[i]] = {\n            n: {}\n          });\n        }\n\n        e.f = e.f || [];\n\n        for (i = 0, ii = e.f.length; i < ii; i++) {\n          if (e.f[i] == f) {\n            exist = true;\n            break;\n          }\n        }\n\n        !exist && e.f.push(f);\n      })(names[i]);\n    }\n\n    return function (zIndex) {\n      if (+zIndex == +zIndex) {\n        f.zIndex = +zIndex;\n      }\n    };\n  };\n  /*\\\n   * eve.f\n   [ method ]\n   **\n   * Returns function that will fire given event with optional arguments.\n   * Arguments that will be passed to the result function will be also\n   * concated to the list of final arguments.\n   | el.onclick = eve.f(\"click\", 1, 2);\n   | eve.on(\"click\", function (a, b, c) {\n   |     console.log(a, b, c); // 1, 2, [event object]\n   | });\n   - event (string) event name\n   - varargs (…) and any other arguments\n   = (function) possible event handler function\n  \\*/\n\n\n  eve.f = function (event) {\n    var attrs = [].slice.call(arguments, 1);\n    return function () {\n      eve.apply(null, [event, null].concat(attrs).concat([].slice.call(arguments, 0)));\n    };\n  };\n  /*\\\n   * eve.stop\n   [ method ]\n   **\n   * Is used inside an event handler to stop the event, preventing any subsequent listeners from firing.\n  \\*/\n\n\n  eve.stop = function () {\n    stop = 1;\n  };\n  /*\\\n   * eve.nt\n   [ method ]\n   **\n   * Could be used inside event handler to figure out actual name of the event.\n   **\n   - subname (string) #optional subname of the event\n   **\n   = (string) name of the event, if `subname` is not specified\n   * or\n   = (boolean) `true`, if current event’s name contains `subname`\n  \\*/\n\n\n  eve.nt = function (subname) {\n    var cur = isArray(current_event) ? current_event.join(\".\") : current_event;\n\n    if (subname) {\n      return new RegExp(\"(?:\\\\.|\\\\/|^)\" + subname + \"(?:\\\\.|\\\\/|$)\").test(cur);\n    }\n\n    return cur;\n  };\n  /*\\\n   * eve.nts\n   [ method ]\n   **\n   * Could be used inside event handler to figure out actual name of the event.\n   **\n   **\n   = (array) names of the event\n  \\*/\n\n\n  eve.nts = function () {\n    return isArray(current_event) ? current_event : current_event.split(separator);\n  };\n  /*\\\n   * eve.off\n   [ method ]\n   **\n   * Removes given function from the list of event listeners assigned to given name.\n   * If no arguments specified all the events will be cleared.\n   **\n   - name (string) name of the event, dot (`.`) or slash (`/`) separated, with optional wildcards\n   - f (function) event handler function\n  \\*/\n\n  /*\\\n   * eve.unbind\n   [ method ]\n   **\n   * See @eve.off\n  \\*/\n\n\n  eve.off = eve.unbind = function (name, f) {\n    if (!name) {\n      eve._events = events = {\n        n: {}\n      };\n      return;\n    }\n\n    var names = isArray(name) ? isArray(name[0]) ? name : [name] : Str(name).split(comaseparator);\n\n    if (names.length > 1) {\n      for (var i = 0, ii = names.length; i < ii; i++) {\n        eve.off(names[i], f);\n      }\n\n      return;\n    }\n\n    names = isArray(name) ? name : Str(name).split(separator);\n    var e,\n        key,\n        splice,\n        i,\n        ii,\n        j,\n        jj,\n        cur = [events],\n        inodes = [];\n\n    for (i = 0, ii = names.length; i < ii; i++) {\n      for (j = 0; j < cur.length; j += splice.length - 2) {\n        splice = [j, 1];\n        e = cur[j].n;\n\n        if (names[i] != wildcard) {\n          if (e[names[i]]) {\n            splice.push(e[names[i]]);\n            inodes.unshift({\n              n: e,\n              name: names[i]\n            });\n          }\n        } else {\n          for (key in e) {\n            if (e[has](key)) {\n              splice.push(e[key]);\n              inodes.unshift({\n                n: e,\n                name: key\n              });\n            }\n          }\n        }\n\n        cur.splice.apply(cur, splice);\n      }\n    }\n\n    for (i = 0, ii = cur.length; i < ii; i++) {\n      e = cur[i];\n\n      while (e.n) {\n        if (f) {\n          if (e.f) {\n            for (j = 0, jj = e.f.length; j < jj; j++) {\n              if (e.f[j] == f) {\n                e.f.splice(j, 1);\n                break;\n              }\n            }\n\n            !e.f.length && delete e.f;\n          }\n\n          for (key in e.n) {\n            if (e.n[has](key) && e.n[key].f) {\n              var funcs = e.n[key].f;\n\n              for (j = 0, jj = funcs.length; j < jj; j++) {\n                if (funcs[j] == f) {\n                  funcs.splice(j, 1);\n                  break;\n                }\n              }\n\n              !funcs.length && delete e.n[key].f;\n            }\n          }\n        } else {\n          delete e.f;\n\n          for (key in e.n) {\n            if (e.n[has](key) && e.n[key].f) {\n              delete e.n[key].f;\n            }\n          }\n        }\n\n        e = e.n;\n      }\n    } // prune inner nodes in path\n\n\n    prune: for (i = 0, ii = inodes.length; i < ii; i++) {\n      e = inodes[i];\n\n      for (key in e.n[e.name].f) {\n        // not empty (has listeners)\n        continue prune;\n      }\n\n      for (key in e.n[e.name].n) {\n        // not empty (has children)\n        continue prune;\n      } // is empty\n\n\n      delete e.n[e.name];\n    }\n  };\n  /*\\\n   * eve.once\n   [ method ]\n   **\n   * Binds given event handler with a given name to only run once then unbind itself.\n   | eve.once(\"login\", f);\n   | eve(\"login\"); // triggers f\n   | eve(\"login\"); // no listeners\n   * Use @eve to trigger the listener.\n   **\n   - name (string) name of the event, dot (`.`) or slash (`/`) separated, with optional wildcards\n   - f (function) event handler function\n   **\n   = (function) same return function as @eve.on\n  \\*/\n\n\n  eve.once = function (name, f) {\n    var f2 = function f2() {\n      eve.off(name, f2);\n      return f.apply(this, arguments);\n    };\n\n    return eve.on(name, f2);\n  };\n  /*\\\n   * eve.version\n   [ property (string) ]\n   **\n   * Current version of the library.\n  \\*/\n\n\n  eve.version = version;\n\n  eve.toString = function () {\n    return \"You are running Eve \" + version;\n  };\n\n  glob.eve = eve;\n  typeof module != \"undefined\" && module.exports ? module.exports = eve : typeof define === \"function\" && define.amd ? define(\"eve\", [], function () {\n    return eve;\n  }) : glob.eve = eve;\n})(typeof window != \"undefined\" ? window : this);","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nfunction _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    'default': obj\n  };\n}\n\nvar _snapsvgImporter = require('../snapsvgImporter');\n\nvar _snapsvgImporter2 = _interopRequireDefault(_snapsvgImporter);\n\nvar _menuFactory = require('../menuFactory');\n\nvar _menuFactory2 = _interopRequireDefault(_menuFactory);\n\nvar styles = {\n  svg: {\n    lib: _snapsvgImporter2['default'],\n    pathInitial: 'M-7.312,0H0c0,0,0,113.839,0,400c0,264.506,0,400,0,400h-7.312V0z',\n    pathOpen: 'M-7.312,0H15c0,0,66,113.339,66,399.5C81,664.006,15,800,15,800H-7.312V0z;M-7.312,0H100c0,0,0,113.839,0,400c0,264.506,0,400,0,400H-7.312V0z',\n    animate: function animate(path) {\n      var pos = 0;\n      var steps = this.pathOpen.split(';');\n      var stepsTotal = steps.length;\n      var mina = window.mina;\n\n      var nextStep = function nextStep() {\n        if (pos > stepsTotal - 1) return;\n        path.animate({\n          path: steps[pos]\n        }, pos === 0 ? 400 : 500, pos === 0 ? mina.easein : mina.elastic, function () {\n          nextStep();\n        });\n        pos++;\n      };\n\n      nextStep();\n    }\n  },\n  morphShape: function morphShape(isOpen, width, right) {\n    return {\n      position: 'absolute',\n      width: '100%',\n      height: '100%',\n      right: right ? 'inherit' : 0,\n      left: right ? 0 : 'inherit',\n      MozTransform: right ? 'rotateY(180deg)' : 'rotateY(0deg)',\n      MsTransform: right ? 'rotateY(180deg)' : 'rotateY(0deg)',\n      OTransform: right ? 'rotateY(180deg)' : 'rotateY(0deg)',\n      WebkitTransform: right ? 'rotateY(180deg)' : 'rotateY(0deg)',\n      transform: right ? 'rotateY(180deg)' : 'rotateY(0deg)'\n    };\n  },\n  menuWrap: function menuWrap(isOpen, width, right) {\n    return {\n      MozTransform: isOpen ? 'translate3d(0, 0, 0)' : right ? 'translate3d(100%, 0, 0)' : 'translate3d(-100%, 0, 0)',\n      MsTransform: isOpen ? 'translate3d(0, 0, 0)' : right ? 'translate3d(100%, 0, 0)' : 'translate3d(-100%, 0, 0)',\n      OTransform: isOpen ? 'translate3d(0, 0, 0)' : right ? 'translate3d(100%, 0, 0)' : 'translate3d(-100%, 0, 0)',\n      WebkitTransform: isOpen ? 'translate3d(0, 0, 0)' : right ? 'translate3d(100%, 0, 0)' : 'translate3d(-100%, 0, 0)',\n      transform: isOpen ? 'translate3d(0, 0, 0)' : right ? 'translate3d(100%, 0, 0)' : 'translate3d(-100%, 0, 0)',\n      transition: isOpen ? 'transform 0.4s 0s' : 'transform 0.4s'\n    };\n  },\n  menu: function menu(isOpen, width, right) {\n    width -= 140;\n    return {\n      position: 'fixed',\n      MozTransform: isOpen ? '' : right ? 'translate3d(' + width + ', 0, 0)' : 'translate3d(-' + width + ', 0, 0)',\n      MsTransform: isOpen ? '' : right ? 'translate3d(' + width + ', 0, 0)' : 'translate3d(-' + width + ', 0, 0)',\n      OTransform: isOpen ? '' : right ? 'translate3d(' + width + ', 0, 0)' : 'translate3d(-' + width + ', 0, 0)',\n      WebkitTransform: isOpen ? '' : right ? 'translate3d(' + width + ', 0, 0)' : 'translate3d(-' + width + ', 0, 0)',\n      transform: isOpen ? '' : right ? 'translate3d(' + width + ', 0, 0)' : 'translate3d(-' + width + ', 0, 0)',\n      transition: isOpen ? 'opacity 0.1s 0.4s cubic-bezier(.17, .67, .1, 1.27), transform 0.1s 0.4s cubic-bezier(.17, .67, .1, 1.27)' : 'opacity 0s 0.3s cubic-bezier(.17, .67, .1, 1.27), transform 0s 0.3s cubic-bezier(.17, .67, .1, 1.27)',\n      opacity: isOpen ? 1 : 0\n    };\n  },\n  item: function item(isOpen, width, right, nthChild) {\n    width -= 140;\n    return {\n      MozTransform: isOpen ? 'translate3d(0, 0, 0)' : right ? 'translate3d(' + width + ', 0, 0)' : 'translate3d(-' + width + ', 0, 0)',\n      MsTransform: isOpen ? 'translate3d(0, 0, 0)' : right ? 'translate3d(' + width + ', 0, 0)' : 'translate3d(-' + width + ', 0, 0)',\n      OTransform: isOpen ? 'translate3d(0, 0, 0)' : right ? 'translate3d(' + width + ', 0, 0)' : 'translate3d(-' + width + ', 0, 0)',\n      WebkitTransform: isOpen ? 'translate3d(0, 0, 0)' : right ? 'translate3d(' + width + ', 0, 0)' : 'translate3d(-' + width + ', 0, 0)',\n      transform: isOpen ? 'translate3d(0, 0, 0)' : right ? 'translate3d(' + width + ', 0, 0)' : 'translate3d(-' + width + ', 0, 0)',\n      transition: isOpen ? 'opacity 0.3s 0.4s, transform 0.3s 0.4s' : 'opacity 0s 0.3s cubic-bezier(.17, .67, .1, 1.27), transform 0s 0.3s cubic-bezier(.17, .67, .1, 1.27)',\n      opacity: isOpen ? 1 : 0\n    };\n  },\n  closeButton: function closeButton(isOpen, width, right) {\n    width -= 140;\n    return {\n      MozTransform: isOpen ? 'translate3d(0, 0, 0)' : right ? 'translate3d(' + width + ', 0, 0)' : 'translate3d(-' + width + ', 0, 0)',\n      MsTransform: isOpen ? 'translate3d(0, 0, 0)' : right ? 'translate3d(' + width + ', 0, 0)' : 'translate3d(-' + width + ', 0, 0)',\n      OTransform: isOpen ? 'translate3d(0, 0, 0)' : right ? 'translate3d(' + width + ', 0, 0)' : 'translate3d(-' + width + ', 0, 0)',\n      WebkitTransform: isOpen ? 'translate3d(0, 0, 0)' : right ? 'translate3d(' + width + ', 0, 0)' : 'translate3d(-' + width + ', 0, 0)',\n      transform: isOpen ? 'translate3d(0, 0, 0)' : right ? 'translate3d(' + width + ', 0, 0)' : 'translate3d(-' + width + ', 0, 0)',\n      transition: isOpen ? 'opacity 0.3s 0.4s cubic-bezier(.17, .67, .1, 1.27), transform 0.3s 0.4s cubic-bezier(.17, .67, .1, 1.27)' : 'opacity 0s 0.3s cubic-bezier(.17, .67, .1, 1.27), transform 0s 0.3s cubic-bezier(.17, .67, .1, 1.27)',\n      opacity: isOpen ? 1 : 0\n    };\n  }\n};\nexports['default'] = (0, _menuFactory2['default'])(styles);\nmodule.exports = exports['default'];","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nfunction _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    'default': obj\n  };\n}\n\nvar _menuFactory = require('../menuFactory');\n\nvar _menuFactory2 = _interopRequireDefault(_menuFactory);\n\nvar styles = {\n  pageWrap: function pageWrap(isOpen, width, right) {\n    return {\n      MozTransform: isOpen ? '' : right ? 'translate3d(-' + width + ', 0, 0)' : 'translate3d(' + width + ', 0, 0)',\n      MsTransform: isOpen ? '' : right ? 'translate3d(-' + width + ', 0, 0)' : 'translate3d(' + width + ', 0, 0)',\n      OTransform: isOpen ? '' : right ? 'translate3d(-' + width + ', 0, 0)' : 'translate3d(' + width + ', 0, 0)',\n      WebkitTransform: isOpen ? '' : right ? 'translate3d(-' + width + ', 0, 0)' : 'translate3d(' + width + ', 0, 0)',\n      transform: isOpen ? '' : right ? 'translate3d(-' + width + ', 0, 0)' : 'translate3d(' + width + ', 0, 0)',\n      transition: 'all 0.5s'\n    };\n  },\n  outerContainer: function outerContainer(isOpen) {\n    return {\n      overflow: isOpen ? '' : 'hidden'\n    };\n  }\n};\nexports['default'] = (0, _menuFactory2['default'])(styles);\nmodule.exports = exports['default'];","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nfunction _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    'default': obj\n  };\n}\n\nvar _menuFactory = require('../menuFactory');\n\nvar _menuFactory2 = _interopRequireDefault(_menuFactory);\n\nvar styles = {\n  pageWrap: function pageWrap(isOpen, width, right) {\n    return {\n      MozTransform: isOpen ? '' : right ? 'translate3d(-' + width + ', 0, 0) rotateY(15deg)' : 'translate3d(' + width + ', 0, 0) rotateY(-15deg)',\n      MsTransform: isOpen ? '' : right ? 'translate3d(-' + width + ', 0, 0) rotateY(15deg)' : 'translate3d(' + width + ', 0, 0) rotateY(-15deg)',\n      OTransform: isOpen ? '' : right ? 'translate3d(-' + width + ', 0, 0) rotateY(15deg)' : 'translate3d(' + width + ', 0, 0) rotateY(-15deg)',\n      WebkitTransform: isOpen ? '' : right ? 'translate3d(-' + width + ', 0, 0) rotateY(15deg)' : 'translate3d(' + width + ', 0, 0) rotateY(-15deg)',\n      transform: isOpen ? '' : right ? 'translate3d(-' + width + ', 0, 0) rotateY(15deg)' : 'translate3d(' + width + ', 0, 0) rotateY(-15deg)',\n      transformOrigin: right ? '100% 50%' : '0% 50%',\n      transformStyle: 'preserve-3d',\n      transition: 'all 0.5s'\n    };\n  },\n  outerContainer: function outerContainer(isOpen) {\n    return {\n      perspective: '1500px',\n      overflow: isOpen ? '' : 'hidden'\n    };\n  }\n};\nexports['default'] = (0, _menuFactory2['default'])(styles);\nmodule.exports = exports['default'];","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nfunction _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    'default': obj\n  };\n}\n\nvar _menuFactory = require('../menuFactory');\n\nvar _menuFactory2 = _interopRequireDefault(_menuFactory);\n\nvar styles = {\n  pageWrap: function pageWrap(isOpen, width) {\n    return {\n      MozTransform: isOpen ? '' : 'translate3d(0, 0, -' + width + ')',\n      MsTransform: isOpen ? '' : 'translate3d(0, 0, -' + width + ')',\n      OTransform: isOpen ? '' : 'translate3d(0, 0, -' + width + ')',\n      WebkitTransform: isOpen ? '' : 'translate3d(0, 0, -' + width + ')',\n      transform: isOpen ? '' : 'translate3d(0, 0, -' + width + ')',\n      transformOrigin: '100%',\n      transformStyle: 'preserve-3d',\n      transition: 'all 0.5s'\n    };\n  },\n  outerContainer: function outerContainer() {\n    return {\n      perspective: '1500px'\n    };\n  }\n};\nexports['default'] = (0, _menuFactory2['default'])(styles);\nmodule.exports = exports['default'];","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nfunction _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    'default': obj\n  };\n}\n\nvar _menuFactory = require('../menuFactory');\n\nvar _menuFactory2 = _interopRequireDefault(_menuFactory);\n\nvar styles = {\n  pageWrap: function pageWrap(isOpen, width, right) {\n    return {\n      MozTransform: isOpen ? '' : right ? 'translate3d(-100px, 0, -600px) rotateY(20deg)' : 'translate3d(100px, 0, -600px) rotateY(-20deg)',\n      MsTransform: isOpen ? '' : right ? 'translate3d(-100px, 0, -600px) rotateY(20deg)' : 'translate3d(100px, 0, -600px) rotateY(-20deg)',\n      OTransform: isOpen ? '' : right ? 'translate3d(-100px, 0, -600px) rotateY(20deg)' : 'translate3d(100px, 0, -600px) rotateY(-20deg)',\n      WebkitTransform: isOpen ? '' : right ? 'translate3d(-100px, 0, -600px) rotateY(20deg)' : 'translate3d(100px, 0, -600px) rotateY(-20deg)',\n      transform: isOpen ? '' : right ? 'translate3d(-100px, 0, -600px) rotateY(20deg)' : 'translate3d(100px, 0, -600px) rotateY(-20deg)',\n      transformStyle: 'preserve-3d',\n      transition: 'all 0.5s',\n      overflow: isOpen ? '' : 'hidden'\n    };\n  },\n  outerContainer: function outerContainer(isOpen) {\n    return {\n      perspective: '1500px',\n      overflow: isOpen ? '' : 'hidden'\n    };\n  }\n};\nexports['default'] = (0, _menuFactory2['default'])(styles);\nmodule.exports = exports['default'];","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nfunction _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    'default': obj\n  };\n}\n\nvar _menuFactory = require('../menuFactory');\n\nvar _menuFactory2 = _interopRequireDefault(_menuFactory);\n\nvar styles = {\n  menuWrap: function menuWrap(isOpen) {\n    return {\n      MozTransform: isOpen ? '' : 'translate3d(0, -100%, 0)',\n      MsTransform: isOpen ? '' : 'translate3d(0, -100%, 0)',\n      OTransform: isOpen ? '' : 'translate3d(0, -100%, 0)',\n      WebkitTransform: isOpen ? '' : 'translate3d(0, -100%, 0)',\n      transform: isOpen ? '' : 'translate3d(0, -100%, 0)',\n      transition: 'all 0.5s ease-in-out'\n    };\n  },\n  pageWrap: function pageWrap(isOpen, width, right) {\n    return {\n      MozTransform: isOpen ? '' : right ? 'translate3d(-' + width + ', 0, 0)' : 'translate3d(' + width + ', 0, 0)',\n      MsTransform: isOpen ? '' : right ? 'translate3d(-' + width + ', 0, 0)' : 'translate3d(' + width + ', 0, 0)',\n      OTransform: isOpen ? '' : right ? 'translate3d(-' + width + ', 0, 0)' : 'translate3d(' + width + ', 0, 0)',\n      WebkitTransform: isOpen ? '' : right ? 'translate3d(-' + width + ', 0, 0)' : 'translate3d(' + width + ', 0, 0)',\n      transform: isOpen ? '' : right ? 'translate3d(-' + width + ', 0, 0)' : 'translate3d(' + width + ', 0, 0)',\n      transition: 'all 0.5s'\n    };\n  },\n  outerContainer: function outerContainer(isOpen) {\n    return {\n      perspective: '1500px',\n      perspectiveOrigin: '0% 50%',\n      overflow: isOpen ? '' : 'hidden'\n    };\n  }\n};\nexports['default'] = (0, _menuFactory2['default'])(styles);\nmodule.exports = exports['default'];","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nfunction _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    'default': obj\n  };\n}\n\nvar _menuFactory = require('../menuFactory');\n\nvar _menuFactory2 = _interopRequireDefault(_menuFactory);\n\nvar styles = {\n  menuWrap: function menuWrap(isOpen, width, right) {\n    return {\n      visibility: isOpen ? 'visible' : 'hidden',\n      MozTransform: 'translate3d(0, 0, 0)',\n      MsTransform: 'translate3d(0, 0, 0)',\n      OTransform: 'translate3d(0, 0, 0)',\n      WebkitTransform: 'translate3d(0, 0, 0)',\n      transform: 'translate3d(0, 0, 0)',\n      zIndex: 1000\n    };\n  },\n  overlay: function overlay(isOpen, width, right) {\n    return {\n      zIndex: 1400,\n      MozTransform: isOpen ? right ? 'translate3d(-' + width + ', 0, 0)' : 'translate3d(' + width + ', 0, 0)' : 'translate3d(0, 0, 0)',\n      MsTransform: isOpen ? right ? 'translate3d(-' + width + ', 0, 0)' : 'translate3d(' + width + ', 0, 0)' : 'translate3d(0, 0, 0)',\n      OTransform: isOpen ? right ? 'translate3d(-' + width + ', 0, 0)' : 'translate3d(' + width + ', 0, 0)' : 'translate3d(0, 0, 0)',\n      WebkitTransform: isOpen ? right ? 'translate3d(-' + width + ', 0, 0)' : 'translate3d(' + width + ', 0, 0)' : 'translate3d(0, 0, 0)',\n      transform: isOpen ? right ? 'translate3d(-' + width + ', 0, 0)' : 'translate3d(' + width + ', 0, 0)' : 'translate3d(0, 0, 0)',\n      transition: 'all 0.5s',\n      visibility: isOpen ? 'visible' : 'hidden'\n    };\n  },\n  pageWrap: function pageWrap(isOpen, width, right) {\n    return {\n      MozTransform: isOpen ? '' : right ? 'translate3d(-' + width + ', 0, 0)' : 'translate3d(' + width + ', 0, 0)',\n      MsTransform: isOpen ? '' : right ? 'translate3d(-' + width + ', 0, 0)' : 'translate3d(' + width + ', 0, 0)',\n      OTransform: isOpen ? '' : right ? 'translate3d(-' + width + ', 0, 0)' : 'translate3d(' + width + ', 0, 0)',\n      WebkitTransform: isOpen ? '' : right ? 'translate3d(-' + width + ', 0, 0)' : 'translate3d(' + width + ', 0, 0)',\n      transform: isOpen ? '' : right ? 'translate3d(-' + width + ', 0, 0)' : 'translate3d(' + width + ', 0, 0)',\n      transition: 'all 0.5s',\n      zIndex: 1200,\n      position: 'relative'\n    };\n  },\n  burgerIcon: function burgerIcon(isOpen, width, right) {\n    return {\n      MozTransform: isOpen ? right ? 'translate3d(' + width + ', 0, 0)' : 'translate3d(-' + width + ', 0, 0)' : 'translate3d(0, 0, 0)',\n      MsTransform: isOpen ? right ? 'translate3d(' + width + ', 0, 0)' : 'translate3d(-' + width + ', 0, 0)' : 'translate3d(0, 0, 0)',\n      OTransform: isOpen ? right ? 'translate3d(' + width + ', 0, 0)' : 'translate3d(-' + width + ', 0, 0)' : 'translate3d(0, 0, 0)',\n      WebkitTransform: isOpen ? right ? 'translate3d(' + width + ', 0, 0)' : 'translate3d(-' + width + ', 0, 0)' : 'translate3d(0, 0, 0)',\n      transform: isOpen ? right ? 'translate3d(' + width + ', 0, 0)' : 'translate3d(-' + width + ', 0, 0)' : 'translate3d(0, 0, 0)',\n      transition: 'all 0.1s',\n      position: 'relative',\n      zIndex: 1300\n    };\n  },\n  outerContainer: function outerContainer(isOpen) {\n    return {\n      overflow: isOpen ? '' : 'hidden'\n    };\n  }\n};\nexports['default'] = (0, _menuFactory2['default'])(styles);\nmodule.exports = exports['default'];","import { concatStyleSets, FontWeights, HighContrastSelector } from '../../../Styling';\nimport { memoizeFunction } from '../../../Utilities';\nimport { getStyles as getBaseButtonStyles } from '../BaseButton.styles';\nimport { getStyles as getSplitButtonStyles } from '../SplitButton/SplitButton.styles';\nimport { primaryStyles, standardStyles } from '../ButtonThemes';\nexport var getStyles = memoizeFunction(function (theme, customStyles, primary) {\n  var baseButtonStyles = getBaseButtonStyles(theme);\n  var splitButtonStyles = getSplitButtonStyles(theme);\n  var compoundButtonStyles = {\n    root: {\n      maxWidth: '280px',\n      minHeight: '72px',\n      height: 'auto',\n      padding: '20px'\n    },\n    flexContainer: {\n      flexDirection: 'row',\n      alignItems: 'flex-start',\n      minWidth: '100%',\n      margin: ''\n    },\n    textContainer: {\n      textAlign: 'left'\n    },\n    icon: {\n      fontSize: '2em',\n      lineHeight: '1em',\n      height: '1em',\n      margin: '0px 8px 0px 0px',\n      flexBasis: '1em',\n      flexShrink: '0'\n    },\n    label: {\n      margin: '0 0 5px',\n      lineHeight: '100%',\n      fontWeight: FontWeights.semibold\n    },\n    description: [theme.fonts.small, {\n      lineHeight: '100%'\n    }]\n  };\n  var standardCompoundTheme = {\n    description: {\n      color: theme.palette.neutralSecondary\n    },\n    descriptionHovered: {\n      color: theme.palette.neutralDark\n    },\n    descriptionPressed: {\n      color: 'inherit'\n    },\n    descriptionChecked: {\n      color: 'inherit'\n    },\n    descriptionDisabled: {\n      color: 'inherit'\n    }\n  };\n  var primaryCompoundTheme = {\n    description: {\n      color: theme.palette.white,\n      selectors: (_a = {}, _a[HighContrastSelector] = {\n        color: 'Window',\n        backgroundColor: 'WindowText',\n        MsHighContrastAdjust: 'none'\n      }, _a)\n    },\n    descriptionHovered: {\n      color: theme.palette.white,\n      selectors: (_b = {}, _b[HighContrastSelector] = {\n        color: 'Window',\n        backgroundColor: 'Highlight',\n        MsHighContrastAdjust: 'none'\n      }, _b)\n    },\n    descriptionPressed: {\n      color: 'inherit'\n    },\n    descriptionChecked: {\n      color: 'inherit'\n    },\n    descriptionDisabled: {\n      color: 'inherit',\n      selectors: (_c = {}, _c[HighContrastSelector] = {\n        color: 'inherit'\n      }, _c)\n    }\n  };\n  return concatStyleSets(baseButtonStyles, compoundButtonStyles, primary ? primaryStyles(theme) : standardStyles(theme), primary ? primaryCompoundTheme : standardCompoundTheme, splitButtonStyles, customStyles);\n\n  var _a, _b, _c;\n});","import * as tslib_1 from \"tslib\";\nimport * as React from 'react';\nimport { BaseButton } from '../BaseButton';\nimport { BaseComponent, customizable } from '../../../Utilities';\nimport { getStyles } from './CompoundButton.styles';\n\nvar CompoundButton =\n/** @class */\nfunction (_super) {\n  tslib_1.__extends(CompoundButton, _super);\n\n  function CompoundButton() {\n    var _this = _super !== null && _super.apply(this, arguments) || this;\n    /**\r\n     * Tell BaseComponent to bypass resolution of componentRef.\r\n     */\n\n\n    _this._skipComponentRefResolution = true;\n    return _this;\n  }\n\n  CompoundButton.prototype.render = function () {\n    var _a = this.props,\n        _b = _a.primary,\n        primary = _b === void 0 ? false : _b,\n        styles = _a.styles,\n        theme = _a.theme;\n    return React.createElement(BaseButton, tslib_1.__assign({}, this.props, {\n      variantClassName: primary ? 'ms-Button--compoundPrimary' : 'ms-Button--compound',\n      styles: getStyles(theme, styles, primary)\n    }));\n  };\n\n  CompoundButton = tslib_1.__decorate([customizable('CompoundButton', ['theme', 'styles'], true)], CompoundButton);\n  return CompoundButton;\n}(BaseComponent);\n\nexport { CompoundButton };"],"sourceRoot":""}