{"version":3,"sources":["webpack:///../../../src/components/VSnackbar/VSnackbar.ts","webpack:///./node_modules/snapsvg/dist/snap.svg.js","webpack:///./node_modules/save-svg-as-png/lib/saveSvgAsPng.js"],"names":["name","props","app","centered","contentClass","type","default","multiLine","text","timeout","Number","transition","Boolean","validator","v","vertical","data","activeTimeout","computed","classes","this","bottom","hasBackground","isDark","styles","$vuetify","top","paddingBottom","paddingLeft","paddingRight","paddingTop","bar","watch","isActive","mounted","setTimeout","created","$attrs","hasOwnProperty","methods","genActions","$createElement","staticClass","attrs","class","genContent","role","genWrapper","setColor","directives","value","genTransition","window","render","h","style","module","exports","glob","current_event","stop","version","has","separator","comaseparator","wildcard","numsort","a","b","events","n","firstDefined","i","ii","length","lastDefined","objtos","Object","prototype","toString","Str","String","isArray","Array","ar","call","eve","scope","l","oldstop","args","slice","arguments","listeners","z","indexed","queue","out","ce","push","zIndex","sort","apply","_events","item","items","k","j","jj","nes","names","split","e","es","concat","f","sep","replace","RegExp","on","exist","event","nt","subname","cur","join","test","nts","off","unbind","key","splice","inodes","unshift","funcs","prune","once","f2","factory","mina","requestID","animations","requestAnimFrame","requestAnimationFrame","webkitRequestAnimationFrame","mozRequestAnimationFrame","oRequestAnimationFrame","msRequestAnimationFrame","callback","Date","getTime","idgen","idprefix","ID","timer","now","sta","val","s","ds","dur","B","speed","spd","duration","stopit","id","update","pause","pdif","get","resume","frame","res","start","end","easing","set","timeStamp","len","A","anim","linear","status","time","getById","easeout","Math","pow","easein","easeinout","q","Q","sqrt","x","X","abs","y","Y","t","backin","backout","elastic","sin","PI","bounce","p","Snap","root","w","nodeType","wrap","is","Element","doc","querySelector","Paper","_","win","document","toFloat","parseFloat","toInt","parseInt","math","mmax","max","mmin","min","E","round","objectToString","colourRegExp","commaSpaces","hsrg","hs","rg","pathCommand","tCommand","pathValues","el","xlink","xmlns","hub","url","$","attr","createTextNode","createComment","substring","getAttributeNS","getAttribute","nodeValue","setAttributeNS","setAttribute","removeAttribute","createElementNS","o","toLowerCase","isFinite","clone","obj","constructor","repush","array","cacher","postprocessor","newf","arg","cache","count","shift","angle","x1","y1","x2","y2","x3","y3","atan2","rad","deg","format","tokenRegex","objNotationRegex","replacer","all","quote","quotedName","isFunc","str","tan","cos","asin","num","acos","atan","len2","closestPoint","path","distance2","dx","dy","best","bestLength","scan","scanDistance","pathNode","node","pathLength","getTotalLength","precision","pathSegList","numberOfItems","bestDistance","Infinity","scanLength","getPointAtLength","before","after","beforeLength","afterLength","beforeDistance","afterDistance","distance","snapTo","values","tolerance","rem","getRGB","colour","indexOf","r","g","hex","error","rgbtoString","charAt","toHex","red","green","blue","opacity","rgb","match","hsb2rgb","hsl2rgb","hsb","hsl","toFixed","color","getElementsByTagName","defaultView","getComputedStyle","getPropertyValue","hsbtoString","hsltoString","prepareRGB","string","clr","packageRGB","rgb2hsl","rgb2hsb","R","G","C","H","S","V","L","M","m","parsePathString","pathString","pth","arr","paramCounts","c","u","params","parseTransformString","TString","svgTransform2string","tstr","transform2matrix","bbox","tdata","Matrix","bb","tlen","command","absolute","inver","invert","translate","rotate","width","height","scale","add","rgTransform","_unit2px","unit2px","contains","compareDocumentPosition","getSomeDefs","ownerSVGElement","parentNode","select","pdefs","defs","make","getSomeSVG","svg","mgr","getW","getBBox","getH","nam","fill","appendChild","removeChild","add2group","list","forEach","children","childNodes","snap","paper","tagName","nodeName","anims","transform","mask","pattern","symbol","method","Fragment","frag","parent","desc","proto","ownerDocument","body","dom","contentDocument","jsonFiller","query","selectAll","nodelist","querySelectorAll","setInterval","attributes","json","att","parse","createDocumentFragment","full","div","createElement","innerHTML","firstChild","fragment","ch","toJSON","lastIndexOf","css","letter","cssAttr","toUpperCase","ajax","postData","req","XMLHttpRequest","pd","encodeURIComponent","open","setRequestHeader","onreadystatechange","readyState","send","load","responseText","getOffset","elem","box","getBoundingClientRect","docElem","documentElement","clientTop","clientLeft","pageYOffset","scrollTop","left","pageXOffset","scrollLeft","getElementByPoint","target","canvas","elementFromPoint","opera","so","sr","createSVGRect","hits","getIntersectionList","plugin","elproto","isWithoutTransform","getClientRects","removed","localMatrix","original","href","getElementById","pathfinder","deflt","bboxwt","realPath","matrix","map","propString","extractTransform","doReturn","fixids","it","els","ids","uses","urltest","linktest","oldid","old","fs","papa","global","getCTM","local","ms","localString","toTransformString","globalMatrix","totalMatrix","diffMatrix","total","gradientTransform","patternTransform","append","appendTo","prepend","first","insertBefore","prependTo","nextSibling","insertAfter","remove","asPX","use","cloneNode","toDefs","toPattern","patternUnits","viewBox","marker","refX","refY","cx","cy","markerWidth","markerHeight","orient","eldata","chld","removeData","outerSVG","innerSVG","toDataURL","btoa","contents","unescape","from","to","Animation","animation","inAnim","_attrs","_callback","curStatus","animate","setter","eq","fkeys","tkeys","keys","equal","d","matrixproto","norm","normalize","mag","aNew","bNew","multLeft","cNew","eNew","me","skewX","skew","skewY","fromCharCode","offset","determinant","row","scalex","shear","scaley","isSimple","isSuperSimple","noRotation","shorter","reURLValue","URL","fillStroke","grad","gradient","deurl","clipIt","clip","undefined","gradrg","setFontSize","fontSize","textExtract","chi","getFontSize","tokens","stops","seed","step","toAbsolute","txt","className","baseVal","vb","rx","ry","tp","textPath","tuner","chunk","tuned","getter","textContent","internal","rgNotSpace","addClass","pos","clazz","finalValue","curClasses","removeClass","hasClass","toggleClass","flag","operators","reUnit","reAddon","getNumber","getUnit","unit","plus","evnt","atr","aUnit","op","isNaN","bplus","rect","circle","preload","onerror","src","img","cssText","onload","image","preserveAspectRatio","offsetWidth","offsetHeight","ellipse","group","vbx","vby","vbw","vbh","ptrn","vx","vy","vw","vh","line","polyline","points","polygon","Gstops","GaddStop","inserted","stopOffset","GgetBBox","GsetStops","addStop","gradientLinear","gradientRadial","gradientUnits","setStops","fx","fy","clear","next","p2s","paths","ps","sleep","r1","r2","r0","rectPath","pathClone","pathArray","getPointAtSegmentLength","p1x","p1y","c1x","c1y","c2x","c2y","p2x","p2y","bezlen","findDotsAtSegment","getTotLen","getLengthFactory","istotal","subpath","O","onlystart","path2curve","point","sp","subpaths","getSubpathsAtLength","t1","t13","t12","t2","t3","mx","my","nx","ny","ax","ay","alpha","bezierBBox","curveDim","isPointInsideBBox","isBBoxIntersect","bbox1","bbox2","base3","p1","p2","p3","p4","x4","y4","z2","Tvalues","Cvalues","sum","ct","xbase","ybase","comb","ll","intersect","denominator","px","py","px2","py2","interHelper","bez1","bez2","justCount","l1","l2","n1","n2","dots1","dots2","xy","di","di1","dj","dj1","ci","cj","pathIntersection","path1","path2","interPathHelper","pathIntersectionNumber","x1m","y1m","x2m","y2m","pi","pj","intr","kk","segment1","segment2","isPointInsidePath","pathBBox","dim","xmin","ymin","xmax","ymax","ellipsePath","getPath","pathToRelative","lowerCase","rel","pa","pathToAbsolute","pa0","crz","dots","pop","catmullRom2bezier","l2c","q2c","_13","_23","a2c","large_arc_flag","sweep_flag","recursive","_120","f1","rx2","ry2","df","f2old","x2old","y2old","c1","s1","c2","s2","hx","hy","m1","m2","m3","m4","newres","x0","y0","b2ac","sqrtb2ac","tvalues","bounds","mt","jlen","curve","bx","by","qx","qy","attrs2","processPath","pcom","T","fixArc","pp","pcoms1","pcoms2","fixM","a1","a2","pfirst","seg","seg2","seglen","seg2len","mapPath","pathi","crp","iLen","getSubpath","closest","inside","found","intersection","intersectionNumber","isPointInside","toRelative","toCubic","Set","bindings","setproto","thisArg","each","begin","handler","cb","callbacker","bind","aname","unbound","index","insertion","tail","todel","arglen","exclude","getEmpty","equaliseTransform","tt1","tt2","maxlength","path2array","getViewBox","getColour","Function","isNumeric","arrayEqual","arr1","arr2","stroke","bUnit","supportsTouch","touchMap","mousedown","mousemove","mouseup","getScroll","preventTouch","originalEvent","preventDefault","stopTouch","stopPropagation","addEvent","fn","element","realName","scrollY","scrollX","targetTouches","olde","clientX","clientY","addEventListener","removeEventListener","drag","dragMove","dragi","touch","touches","identifier","_drag","display","move_scope","dragUp","unmousemove","unmouseup","end_scope","start_scope","eventName","hover","f_in","f_out","scope_in","scope_out","mouseover","mouseout","unhover","unmouseover","unmouseout","draggable","onmove","onstart","onend","origTransform","init","undrag","unmousedown","pproto","rgurl","filter","filstr","filterUnits","blur","def","shadow","grayscale","amount","sepia","saturate","hueRotate","amount2","brightness","contrast","firstLetter","getAlign","way","align","pink","purple","deeppurple","indigo","lightblue","cyan","teal","lightgreen","lime","yellow","amber","orange","deeporange","brown","grey","bluegrey","saveColor","colors","A100","A200","A400","A700","mui","flat","turquoise","greensea","sunflower","emerland","nephritis","carrot","pumpkin","peterriver","belizehole","alizarin","pomegranate","amethyst","wisteria","clouds","silver","wetasphalt","midnightblue","concrete","asbestos","importMUIColors","out$","xmlNs","xhtmlNs","svgNs","doctype","urlRegex","fontFormats","woff2","woff","otf","ttf","eot","sfnt","isElement","HTMLElement","SVGElement","requireDomNode","Error","requireDomNodePromise","Promise","resolve","reject","isExternal","location","host","getFontMimeTypeFromUrl","fontUrl","formats","extension","console","arrayBufferToBase64","buffer","binary","bytes","Uint8Array","byteLength","getDimension","getDimensions","_el$getBBox","_width","_height","reEncode","decodeURIComponent","uriToBlob","uri","byteString","atob","mimeString","ArrayBuffer","intArray","charCodeAt","Blob","selector","err","warn","detectCssFont","rule","fullUrl","startsWith","inlineImages","valueOf","Image","crossOrigin","getContext","drawImage","cachedFonts","inlineFonts","fonts","font","fontInBase64","response","fontUri","responseType","then","fontCss","cachedRules","styleSheetRules","styleSheets","sheet","rules","cssRules","inlineCss","options","_ref","selectorRemap","modifyStyle","modifyCss","excludeUnusedCss","generateCss","properties","sel","detectFonts","fontList","_ref2","selectorText","downloadOptions","navigator","msSaveOrOpenBlob","popup","prepareSvg","done","_ref3","_ref3$left","_ref3$top","_ref3$scale","_ref3$responsive","responsive","_ref3$excludeCss","excludeCss","backgroundColor","_getDimensions","foreignObject","outer","svgAsDataUri","_ref4","svgXml","svgAsPngUri","_ref5","_ref5$encoderType","encoderType","_ref5$encoderOptions","encoderOptions","canvg","convertToPng","_ref6","context","pixelRatio","devicePixelRatio","setTransform","png","SecurityError","download","saveLink","blob","createObjectURL","onclick","revokeObjectURL","click","title","saveSvg","downloadOpts","saveSvgAsPng"],"mappings":"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","file":"js/chunk-0fd4c608.124728f2.js","sourcesContent":["// Styles\nimport './VSnackbar.sass'\n\n// Components\nimport VSheet from '../VSheet/VSheet'\n\n// Mixins\nimport Colorable from '../../mixins/colorable'\nimport Themeable from '../../mixins/themeable'\nimport Toggleable from '../../mixins/toggleable'\nimport { factory as PositionableFactory } from '../../mixins/positionable'\n\n// Utilities\nimport mixins from '../../util/mixins'\nimport { convertToUnit, getSlot } from '../../util/helpers'\nimport { deprecate, removed } from '../../util/console'\n\n// Types\nimport { PropType, VNode } from 'vue'\n\nexport default mixins(\n  VSheet,\n  Colorable,\n  Toggleable,\n  PositionableFactory([\n    'absolute',\n    'bottom',\n    'left',\n    'right',\n    'top',\n  ])\n/* @vue/component */\n).extend({\n  name: 'v-snackbar',\n\n  props: {\n    app: Boolean,\n    centered: Boolean,\n    contentClass: {\n      type: String,\n      default: '',\n    },\n    multiLine: Boolean,\n    text: Boolean,\n    timeout: {\n      type: [Number, String],\n      default: 5000,\n    },\n    transition: {\n      type: [Boolean, String] as PropType<false | string>,\n      default: 'v-snack-transition',\n      validator: v => typeof v === 'string' || v === false,\n    },\n    vertical: Boolean,\n  },\n\n  data: () => ({\n    activeTimeout: -1,\n  }),\n\n  computed: {\n    classes (): object {\n      return {\n        'v-snack--absolute': this.absolute,\n        'v-snack--active': this.isActive,\n        'v-snack--bottom': this.bottom || !this.top,\n        'v-snack--centered': this.centered,\n        'v-snack--has-background': this.hasBackground,\n        'v-snack--left': this.left,\n        'v-snack--multi-line': this.multiLine && !this.vertical,\n        'v-snack--right': this.right,\n        'v-snack--text': this.text,\n        'v-snack--top': this.top,\n        'v-snack--vertical': this.vertical,\n      }\n    },\n    // Text and outlined styles both\n    // use transparent backgrounds\n    hasBackground (): boolean {\n      return (\n        !this.text &&\n        !this.outlined\n      )\n    },\n    // Snackbar is dark by default\n    // override themeable logic.\n    isDark (): boolean {\n      return this.hasBackground\n        ? !this.light\n        : Themeable.options.computed.isDark.call(this)\n    },\n    styles (): object {\n      // Styles are not needed when\n      // using the absolute prop.\n      if (this.absolute) return {}\n\n      const {\n        bar,\n        bottom,\n        footer,\n        insetFooter,\n        left,\n        right,\n        top,\n      } = this.$vuetify.application\n\n      // Should always move for y-axis\n      // applicationable components.\n      return {\n        paddingBottom: convertToUnit(bottom + footer + insetFooter),\n        paddingLeft: !this.app ? undefined : convertToUnit(left),\n        paddingRight: !this.app ? undefined : convertToUnit(right),\n        paddingTop: convertToUnit(bar + top),\n      }\n    },\n  },\n\n  watch: {\n    isActive: 'setTimeout',\n    timeout: 'setTimeout',\n  },\n\n  mounted () {\n    if (this.isActive) this.setTimeout()\n  },\n\n  created () {\n    /* istanbul ignore next */\n    if (this.$attrs.hasOwnProperty('auto-height')) {\n      removed('auto-height', this)\n    }\n\n    /* istanbul ignore next */\n    // eslint-disable-next-line eqeqeq\n    if (this.timeout == 0) {\n      deprecate('timeout=\"0\"', '-1', this)\n    }\n  },\n\n  methods: {\n    genActions () {\n      return this.$createElement('div', {\n        staticClass: 'v-snack__action ',\n      }, [\n        getSlot(this, 'action', {\n          attrs: { class: 'v-snack__btn' },\n        }),\n      ])\n    },\n    genContent () {\n      return this.$createElement('div', {\n        staticClass: 'v-snack__content',\n        class: {\n          [this.contentClass]: true,\n        },\n        attrs: {\n          role: 'status',\n          'aria-live': 'polite',\n        },\n      }, [getSlot(this)])\n    },\n    genWrapper () {\n      const setColor = this.hasBackground\n        ? this.setBackgroundColor\n        : this.setTextColor\n\n      const data = setColor(this.color, {\n        staticClass: 'v-snack__wrapper',\n        class: VSheet.options.computed.classes.call(this),\n        directives: [{\n          name: 'show',\n          value: this.isActive,\n        }],\n      })\n\n      return this.$createElement('div', data, [\n        this.genContent(),\n        this.genActions(),\n      ])\n    },\n    genTransition () {\n      return this.$createElement('transition', {\n        props: { name: this.transition },\n      }, [this.genWrapper()])\n    },\n    setTimeout () {\n      window.clearTimeout(this.activeTimeout)\n\n      const timeout = Number(this.timeout)\n\n      if (\n        !this.isActive ||\n        // TODO: remove 0 in v3\n        [0, -1].includes(timeout)\n      ) {\n        return\n      }\n\n      this.activeTimeout = window.setTimeout(() => {\n        this.isActive = false\n      }, timeout)\n    },\n  },\n\n  render (h): VNode {\n    return h('div', {\n      staticClass: 'v-snack',\n      class: this.classes,\n      style: this.styles,\n    }, [\n      this.transition !== false\n        ? this.genTransition()\n        : this.genWrapper(),\n    ])\n  },\n})\n","/*** IMPORTS FROM imports-loader ***/\n(function() {\nvar fix = module.exports=0;\n\n// Snap.svg 0.5.0\n//\n// 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// build: 2017-02-06\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// ┌────────────────────────────────────────────────────────────┐ \\\\\n// │ Eve 0.5.0 - JavaScript Events Library                      │ \\\\\n// ├────────────────────────────────────────────────────────────┤ \\\\\n// │ Author Dmitry Baranovskiy (http://dmitry.baranovskiy.com/) │ \\\\\n// └────────────────────────────────────────────────────────────┘ \\\\\n\n(function (glob) {\n    var version = \"0.5.0\",\n        has = \"hasOwnProperty\",\n        separator = /[\\.\\/]/,\n        comaseparator = /\\s*,\\s*/,\n        wildcard = \"*\",\n        fun = function () {},\n        numsort = function (a, b) {\n            return a - b;\n        },\n        current_event,\n        stop,\n        events = {n: {}},\n        firstDefined = function () {\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 () {\n            var i = this.length;\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     * eve\n     [ method ]\n\n     * Fires event with given `name`, given scope and other parameters.\n\n     > Arguments\n\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\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 (name, scope) {\n            var e = events,\n                oldstop = stop,\n                args = Array.prototype.slice.call(arguments, 2),\n                listeners = eve.listeners(name),\n                z = 0,\n                f = false,\n                l,\n                indexed = [],\n                queue = {},\n                out = [],\n                ce = current_event,\n                errors = [];\n            out.firstDefined = firstDefined;\n            out.lastDefined = lastDefined;\n            current_event = name;\n            stop = 0;\n            for (var i = 0, ii = listeners.length; i < ii; i++) if (\"zIndex\" in listeners[i]) {\n                indexed.push(listeners[i].zIndex);\n                if (listeners[i].zIndex < 0) {\n                    queue[listeners[i].zIndex] = listeners[i];\n                }\n            }\n            indexed.sort(numsort);\n            while (indexed[z] < 0) {\n                l = queue[indexed[z++]];\n                out.push(l.apply(scope, args));\n                if (stop) {\n                    stop = oldstop;\n                    return out;\n                }\n            }\n            for (i = 0; i < ii; i++) {\n                l = listeners[i];\n                if (\"zIndex\" in l) {\n                    if (l.zIndex == indexed[z]) {\n                        out.push(l.apply(scope, args));\n                        if (stop) {\n                            break;\n                        }\n                        do {\n                            z++;\n                            l = queue[indexed[z]];\n                            l && out.push(l.apply(scope, args));\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                    if (stop) {\n                        break;\n                    }\n                }\n            }\n            stop = oldstop;\n            current_event = ce;\n            return out;\n        };\n        // Undocumented. Debug only.\n        eve._events = events;\n    /*\\\n     * eve.listeners\n     [ method ]\n\n     * Internal method which gives you array of all event handlers that will be triggered by the given `name`.\n\n     > Arguments\n\n     - name (string) name of the event, dot (`.`) or slash (`/`) separated\n\n     = (array) array of event handlers\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        for (i = 0, ii = names.length; i < ii; i++) {\n            nes = [];\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                while (k--) {\n                    item = items[k];\n                    if (item) {\n                        nes.push(item);\n                        out = out.concat(item.f || []);\n                    }\n                }\n            }\n            es = nes;\n        }\n        return out;\n    };\n    /*\\\n     * eve.separator\n     [ method ]\n\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\n     - separator (string) new separator. Empty string resets to default: `.` or `/`.\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    eve.on = function (name, f) {\n        if (typeof f != \"function\") {\n            return function () {};\n        }\n        var names = isArray(name) ? (isArray(name[0]) ? name : [name]) : Str(name).split(comaseparator);\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                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                e.f = e.f || [];\n                for (i = 0, ii = e.f.length; i < ii; i++) if (e.f[i] == f) {\n                    exist = true;\n                    break;\n                }\n                !exist && e.f.push(f);\n            }(names[i]));\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     > Arguments\n     - event (string) event name\n     - varargs (…) and any other arguments\n     = (function) possible event handler function\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    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     > Arguments\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    eve.nt = function (subname) {\n        var cur = isArray(current_event) ? current_event.join(\".\") : current_event;\n        if (subname) {\n            return new RegExp(\"(?:\\\\.|\\\\/|^)\" + subname + \"(?:\\\\.|\\\\/|$)\").test(cur);\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    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     > Arguments\n     **\n     - name (string) name of the event, dot (`.`) or slash (`/`) separated, with optional wildcards\n     - f (function) event handler function\n    \\*/\n    /*\\\n     * eve.unbind\n     [ method ]\n     **\n     * See @eve.off\n    \\*/\n    eve.off = eve.unbind = function (name, f) {\n        if (!name) {\n            eve._events = events = {n: {}};\n            return;\n        }\n        var names = isArray(name) ? (isArray(name[0]) ? name : [name]) : Str(name).split(comaseparator);\n        if (names.length > 1) {\n            for (var i = 0, ii = names.length; i < ii; i++) {\n                eve.off(names[i], f);\n            }\n            return;\n        }\n        names = isArray(name) ? name : Str(name).split(separator);\n        var e,\n            key,\n            splice,\n            i, ii, j, jj,\n            cur = [events],\n            inodes = [];\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                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) if (e[has](key)) {\n                        splice.push(e[key]);\n                        inodes.unshift({\n                            n: e,\n                            name: key\n                        });\n                    }\n                }\n                cur.splice.apply(cur, splice);\n            }\n        }\n        for (i = 0, ii = cur.length; i < ii; i++) {\n            e = cur[i];\n            while (e.n) {\n                if (f) {\n                    if (e.f) {\n                        for (j = 0, jj = e.f.length; j < jj; j++) if (e.f[j] == f) {\n                            e.f.splice(j, 1);\n                            break;\n                        }\n                        !e.f.length && delete e.f;\n                    }\n                    for (key in e.n) if (e.n[has](key) && e.n[key].f) {\n                        var funcs = e.n[key].f;\n                        for (j = 0, jj = funcs.length; j < jj; j++) if (funcs[j] == f) {\n                            funcs.splice(j, 1);\n                            break;\n                        }\n                        !funcs.length && delete e.n[key].f;\n                    }\n                } else {\n                    delete e.f;\n                    for (key in e.n) if (e.n[has](key) && e.n[key].f) {\n                        delete e.n[key].f;\n                    }\n                }\n                e = e.n;\n            }\n        }\n        // prune inner nodes in path\n        prune: for (i = 0, ii = inodes.length; i < ii; i++) {\n            e = inodes[i];\n            for (key in e.n[e.name].f) {\n                // not empty (has listeners)\n                continue prune;\n            }\n            for (key in e.n[e.name].n) {\n                // not empty (has children)\n                continue prune;\n            }\n            // is empty\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     > Arguments\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    eve.once = function (name, f) {\n        var f2 = function () {\n            eve.off(name, f2);\n            return f.apply(this, arguments);\n        };\n        return eve.on(name, f2);\n    };\n    /*\\\n     * eve.version\n     [ property (string) ]\n     **\n     * Current version of the library.\n    \\*/\n    eve.version = version;\n    eve.toString = function () {\n        return \"You are running Eve \" + version;\n    };\n    (typeof module != \"undefined\" && module.exports) ? (module.exports = eve) : (typeof define === \"function\" && define.amd ? (define(\"eve\", [], function() { return eve; })) : (glob.eve = eve));\n})(this);\n\n(function (glob, factory) {\n    // AMD support\n    if (typeof define == \"function\" && define.amd) {\n        // Define as an anonymous module\n        define([\"eve\"], function (eve) {\n            return factory(glob, eve);\n        });\n    } else if (typeof exports != \"undefined\") {\n        // Next for Node.js or CommonJS\n        var eve = require(\"eve\");\n        module.exports = factory(glob, eve);\n    } else {\n        // Browser globals (glob is window)\n        // Snap adds itself to window\n        factory(glob, glob.eve);\n    }\n}(window || this, function (window, eve) {\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.\nvar mina = (function (eve) {\n    var animations = {},\n    requestAnimFrame = window.requestAnimationFrame       ||\n                       window.webkitRequestAnimationFrame ||\n                       window.mozRequestAnimationFrame    ||\n                       window.oRequestAnimationFrame      ||\n                       window.msRequestAnimationFrame     ||\n                       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 ||\n            Object.prototype.toString.call(a) == \"[object Array]\";\n    },\n    idgen = 0,\n    idprefix = \"M\" + (+new Date).toString(36),\n    ID = function () {\n        return idprefix + (idgen++).toString(36);\n    },\n    diff = function (a, b, A, B) {\n        if (isArray(a)) {\n            res = [];\n            for (var i = 0, ii = a.length; i < ii; i++) {\n                res[i] = diff(a[i], b, A[i], B);\n            }\n            return res;\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 (val) {\n        var a = this;\n        if (val == null) {\n            return a.s;\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 (val) {\n        var a = this;\n        if (val == null) {\n            return a.spd;\n        }\n        a.spd = val;\n    },\n    duration = function (val) {\n        var a = this;\n        if (val == null) {\n            return a.dur;\n        }\n        a.s = a.s * val / a.dur;\n        a.dur = val;\n    },\n    stopit = function () {\n        var a = this;\n        delete animations[a.id];\n        a.update();\n        eve(\"mina.stop.\" + a.id, a);\n    },\n    pause = function () {\n        var a = this;\n        if (a.pdif) {\n            return;\n        }\n        delete animations[a.id];\n        a.update();\n        a.pdif = a.get() - a.b;\n    },\n    resume = function () {\n        var a = this;\n        if (!a.pdif) {\n            return;\n        }\n        a.b = a.get() - a.pdif;\n        delete a.pdif;\n        animations[a.id] = a;\n        frame();\n    },\n    update = function () {\n        var a = this,\n            res;\n        if (isArray(a.start)) {\n            res = [];\n            for (var j = 0, jj = a.start.length; j < jj; j++) {\n                res[j] = +a.start[j] +\n                    (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        a.set(res);\n    },\n    frame = function (timeStamp) {\n        // Manual invokation?\n        if (!timeStamp) {\n            // Frame loop stopped?\n            if (!requestID) {\n                // Start frame loop...\n                requestID = requestAnimFrame(frame);\n            }\n            return;\n        }\n        var len = 0;\n        for (var i in animations) 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            if (a.s >= 1) {\n                delete animations[i];\n                a.s = 1;\n                len--;\n                (function (a) {\n                    setTimeout(function () {\n                        eve(\"mina.finish.\" + a.id, a);\n                    });\n                }(a));\n            }\n            a.update();\n        }\n        requestID = len ? requestAnimFrame(frame) : false;\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 (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, i;\n        for (i in animations) if (animations.hasOwnProperty(i)) {\n            len++;\n            if (len == 2) {\n                break;\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    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    mina.getById = function (id) {\n        return animations[id] || null;\n    };\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    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    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    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    mina.easeinout = function (n) {\n        if (n == 1) {\n            return 1;\n        }\n        if (n == 0) {\n            return 0;\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    mina.backin = function (n) {\n        if (n == 1) {\n            return 1;\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    mina.backout = function (n) {\n        if (n == 0) {\n            return 0;\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    mina.elastic = function (n) {\n        if (n == !!n) {\n            return n;\n        }\n        return Math.pow(2, -10 * n) * Math.sin((n - .075) *\n            (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    mina.bounce = function (n) {\n        var s = 7.5625,\n            p = 2.75,\n            l;\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        return l;\n    };\n    window.mina = mina;\n    return mina;\n})(typeof eve == \"undefined\" ? function () {} : eve);\n\n// 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\nvar Snap = (function(root) {\nSnap.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\\*/\nfunction Snap(w, h) {\n    if (w) {\n        if (w.nodeType) {\n            return wrap(w);\n        }\n        if (is(w, \"array\") && Snap.set) {\n            return Snap.set.apply(Snap, w);\n        }\n        if (w instanceof Element) {\n            return w;\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    w = w == null ? \"100%\" : w;\n    h = h == null ? \"100%\" : h;\n    return new Paper(w, h);\n}\nSnap.toString = function () {\n    return \"Snap v\" + this.version;\n};\nSnap._ = {};\nvar glob = {\n    win: root.window,\n    doc: root.window.document\n};\nSnap._.glob = glob;\nvar 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 = {hs: 1, rg: 1},\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 (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     * 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\nfunction $(el, attr) {\n    if (attr) {\n        if (el == \"#text\") {\n            el = glob.doc.createTextNode(attr.text || attr[\"#text\"] || \"\");\n        }\n        if (el == \"#comment\") {\n            el = glob.doc.createComment(attr.text || attr[\"#text\"] || \"\");\n        }\n        if (typeof el == \"string\") {\n            el = $(el);\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                if (attr.substring(0, 4) == \"xml:\") {\n                    return el.getAttributeNS(xmlns, attr.substring(4));\n                }\n                return el.getAttribute(attr);\n            } else if (attr == \"text\") {\n                return el.nodeValue;\n            } else {\n                return null;\n            }\n        }\n        if (el.nodeType == 1) {\n            for (var key in attr) if (attr[has](key)) {\n                var val = Str(attr[key]);\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        } else if (\"text\" in attr) {\n            el.nodeValue = attr.text;\n        }\n    } else {\n        el = glob.doc.createElementNS(xmlns, el);\n    }\n    return el;\n}\nSnap._.$ = $;\nSnap._.id = ID;\nfunction getAttrs(el) {\n    var attrs = el.attributes,\n        name,\n        out = {};\n    for (var i = 0; i < attrs.length; i++) {\n        if (attrs[i].namespaceURI == xlink) {\n            name = \"xlink:\";\n        } else {\n            name = \"\";\n        }\n        name += attrs[i].name;\n        out[name] = attrs[i].textContent;\n    }\n    return out;\n}\nfunction is(o, type) {\n    type = Str.prototype.toLowerCase.call(type);\n    if (type == \"finite\") {\n        return isFinite(o);\n    }\n    if (type == \"array\" &&\n        (o instanceof Array || Array.isArray && Array.isArray(o))) {\n        return true;\n    }\n    return  type == \"null\" && o === null ||\n            type == typeof o && o !== null ||\n            type == \"object\" && o === Object(o) ||\n            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\\*/\nSnap.format = (function () {\n    var tokenRegex = /\\{([^\\}]+)\\}/g,\n        objNotationRegex = /(?:(?:^|\\.)(.+?)(?=\\[|\\.|$|\\()|\\[('|\")(.+?)\\2\\])(\\(\\))?/g, // matches .xxxxx or [\"xxxxx\"] to run over object properties\n        replacer = function (all, key, obj) {\n            var res = obj;\n            key.replace(objNotationRegex, function (all, name, quote, quotedName, isFunc) {\n                name = name || quotedName;\n                if (res) {\n                    if (name in res) {\n                        res = res[name];\n                    }\n                    typeof res == \"function\" && isFunc && (res = res());\n                }\n            });\n            res = (res == null || res == obj ? all : res) + \"\";\n            return res;\n        };\n    return function (str, obj) {\n        return Str(str).replace(tokenRegex, function (all, key) {\n            return replacer(all, key, obj);\n        });\n    };\n})();\nfunction clone(obj) {\n    if (typeof obj == \"function\" || Object(obj) !== obj) {\n        return obj;\n    }\n    var res = new obj.constructor;\n    for (var key in obj) if (obj[has](key)) {\n        res[key] = clone(obj[key]);\n    }\n    return res;\n}\nSnap._.clone = clone;\nfunction repush(array, item) {\n    for (var i = 0, ii = array.length; i < ii; i++) if (array[i] === item) {\n        return array.push(array.splice(i, 1)[0]);\n    }\n}\nfunction 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        if (cache[has](args)) {\n            repush(count, args);\n            return postprocessor ? postprocessor(cache[args]) : cache[args];\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    return newf;\n}\nSnap._.cacher = cacher;\nfunction angle(x1, y1, x2, y2, x3, y3) {\n    if (x3 == null) {\n        var x = x1 - x2,\n            y = y1 - y2;\n        if (!x && !y) {\n            return 0;\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}\nfunction rad(deg) {\n    return deg % 360 * PI / 180;\n}\nfunction deg(rad) {\n    return rad * 180 / PI % 360;\n}\nfunction x_y() {\n    return this.x + S + this.y;\n}\nfunction x_y_w_h() {\n    return this.x + S + this.y + S + this.width + \" \\xd7 \" + this.height;\n}\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\\*/\nSnap.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\\*/\nSnap.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\\*/\nSnap.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\\*/\nSnap.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\\*/\nSnap.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\\*/\nSnap.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\\*/\nSnap.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\\*/\nSnap.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\\*/\nSnap.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\\*/\nSnap.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\\*/\nSnap.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\\*/\nSnap.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\nSnap.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    var pathNode = path.node,\n        pathLength = pathNode.getTotalLength(),\n        precision = pathLength / pathNode.pathSegList.numberOfItems * .125,\n        best,\n        bestLength,\n        bestDistance = Infinity;\n\n    // linear scan for coarse approximation\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    }\n\n    // binary search for precise estimate\n    precision *= .5;\n    while (precision > .5) {\n        var before,\n            after,\n            beforeLength,\n            afterLength,\n            beforeDistance,\n            afterDistance;\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\\*/\nSnap.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\\*/\nSnap.snapTo = function (values, value, tolerance) {\n    tolerance = is(tolerance, \"finite\") ? tolerance : 10;\n    if (is(values, \"array\")) {\n        var i = values.length;\n        while (i--) if (abs(values[i] - value) <= tolerance) {\n            return values[i];\n        }\n    } else {\n        values = +values;\n        var rem = value % values;\n        if (rem < tolerance) {\n            return value - rem;\n        }\n        if (rem > values - tolerance) {\n            return value - rem + values;\n        }\n    }\n    return value;\n};\n// Colour\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\\*/\nSnap.getRGB = cacher(function (colour) {\n    if (!colour || !!((colour = Str(colour)).indexOf(\"-\") + 1)) {\n        return {r: -1, g: -1, b: -1, hex: \"none\", error: 1, toString: rgbtoString};\n    }\n    if (colour == \"none\") {\n        return {r: -1, g: -1, b: -1, hex: \"none\", toString: rgbtoString};\n    }\n    !(hsrg[has](colour.toLowerCase().substring(0, 2)) || colour.charAt() == \"#\") && (colour = toHex(colour));\n    if (!colour) {\n        return {r: -1, g: -1, b: -1, hex: \"none\", error: 1, toString: rgbtoString};\n    }\n    var res,\n        red,\n        green,\n        blue,\n        opacity,\n        t,\n        values,\n        rgb = colour.match(colourRegExp);\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        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        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        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        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        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 = {r: red, g: green, b: blue, toString: rgbtoString};\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    return {r: -1, g: -1, b: -1, hex: \"none\", error: 1, toString: rgbtoString};\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\\*/\nSnap.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\\*/\nSnap.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\\*/\nSnap.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    return \"#\" + (16777216 | b | g << 8 | r << 16).toString(16).slice(1);\n});\nvar toHex = function (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        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},\nhsbtoString = function () {\n    return \"hsb(\" + [this.h, this.s, this.b] + \")\";\n},\nhsltoString = function () {\n    return \"hsl(\" + [this.h, this.s, this.l] + \")\";\n},\nrgbtoString = function () {\n    return this.opacity == 1 || this.opacity == null ?\n            this.hex :\n            \"rgba(\" + [this.r, this.g, this.b, this.opacity] + \")\";\n},\nprepareRGB = function (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    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    if (r > 1 || g > 1 || b > 1) {\n        r /= 255;\n        g /= 255;\n        b /= 255;\n    }\n\n    return [r, g, b];\n},\npackageRGB = function (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\\*/\nSnap.color = function (clr) {\n    var rgb;\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        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 = {hex: \"none\"};\n            clr.r = clr.g = clr.b = clr.h = clr.s = clr.v = clr.l = -1;\n            clr.error = 1;\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\\*/\nSnap.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    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\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\\*/\nSnap.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    if (h > 1 || s > 1 || l > 1) {\n        h /= 360;\n        s /= 100;\n        l /= 100;\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\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\\*/\nSnap.rgb2hsb = function (r, g, b) {\n    b = prepareRGB(r, g, b);\n    r = b[0];\n    g = b[1];\n    b = b[2];\n\n    var H, S, V, C;\n    V = mmax(r, g, b);\n    C = V - mmin(r, g, b);\n    H = C == 0 ? null :\n        V == r ? (g - b) / C :\n        V == g ? (b - r) / C + 2 :\n                 (r - g) / C + 4;\n    H = (H + 360) % 6 * 60 / 360;\n    S = C == 0 ? 0 : C / V;\n    return {h: H, s: S, b: V, toString: hsbtoString};\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\\*/\nSnap.rgb2hsl = function (r, g, b) {\n    b = prepareRGB(r, g, b);\n    r = b[0];\n    g = b[1];\n    b = b[2];\n\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 :\n        M == r ? (g - b) / C :\n        M == g ? (b - r) / C + 2 :\n                 (r - g) / C + 4;\n    H = (H + 360) % 6 * 60 / 360;\n    L = (M + m) / 2;\n    S = C == 0 ? 0 :\n         L < .5 ? C / (2 * L) :\n                  C / (2 - 2 * L);\n    return {h: H, s: S, l: L, toString: hsltoString};\n};\n\n// Transformations\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\\*/\nSnap.parsePathString = function (pathString) {\n    if (!pathString) {\n        return null;\n    }\n    var pth = Snap.path(pathString);\n    if (pth.arr) {\n        return Snap.path.clone(pth.arr);\n    }\n\n    var paramCounts = {a: 7, c: 6, o: 2, h: 1, l: 2, m: 2, r: 4, q: 4, s: 4, t: 2, v: 1, u: 3, z: 0},\n        data = [];\n    if (is(pathString, \"array\") && is(pathString[0], \"array\")) { // rough assumption\n        data = Snap.path.clone(pathString);\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            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            if (name == \"o\" && params.length == 1) {\n                data.push([b, params[0]]);\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                if (!paramCounts[name]) {\n                    break;\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\\*/\nvar parseTransformString = Snap.parseTransformString = function (TString) {\n    if (!TString) {\n        return null;\n    }\n    var paramCounts = {r: 3, s: 4, t: 2, m: 6},\n        data = [];\n    if (is(TString, \"array\") && is(TString[0], \"array\")) { // rough assumption\n        data = Snap.path.clone(TString);\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    data.toString = Snap.path.toString;\n    return data;\n};\nfunction svgTransform2string(tstr) {\n    var res = [];\n    tstr = tstr.replace(/(?:^|\\s)(\\w+)\\(([^)]+)\\)/g, function (all, name, params) {\n        params = params.split(/\\s*,\\s*|\\s+/);\n        if (name == \"rotate\" && params.length == 1) {\n            params.push(0, 0);\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            if (params.length == 1) {\n                params.push(params[0], 0, 0);\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        return all;\n    });\n    return res;\n}\nSnap._.svgTransform2string = svgTransform2string;\nSnap._.rgTransform = /^[a-z][\\s]*-?\\.?\\d/i;\nfunction transform2matrix(tstr, bbox) {\n    var tdata = parseTransformString(tstr),\n        m = new Snap.Matrix;\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            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    return m;\n}\nSnap._.transform2matrix = transform2matrix;\nSnap._unit2px = unit2px;\nvar contains = glob.doc.contains || glob.doc.compareDocumentPosition ?\n    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 && (\n                adown.contains ?\n                    adown.contains(bup) :\n                    a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16\n            ));\n    } :\n    function (a, b) {\n        if (b) {\n            while (b) {\n                b = b.parentNode;\n                if (b == a) {\n                    return true;\n                }\n            }\n        }\n        return false;\n    };\nfunction getSomeDefs(el) {\n    var p = el.node.ownerSVGElement && wrap(el.node.ownerSVGElement) ||\n            el.node.parentNode && wrap(el.node.parentNode) ||\n            Snap.select(\"svg\") ||\n            Snap(0, 0),\n        pdefs = p.select(\"defs\"),\n        defs  = pdefs == null ? false : pdefs.node;\n    if (!defs) {\n        defs = make(\"defs\", p.node).node;\n    }\n    return defs;\n}\nfunction getSomeSVG(el) {\n    return el.node.ownerSVGElement && wrap(el.node.ownerSVGElement) || Snap.select(\"svg\");\n}\nSnap._.getSomeDefs = getSomeDefs;\nSnap._.getSomeSVG = getSomeSVG;\nfunction unit2px(el, name, value) {\n    var svg = getSomeSVG(el).node,\n        out = {},\n        mgr = svg.querySelector(\".svg---mgr\");\n    if (!mgr) {\n        mgr = $(\"rect\");\n        $(mgr, {x: -9e9, y: -9e9, width: 10, height: 10, \"class\": \"svg---mgr\", fill: \"none\"});\n        svg.appendChild(mgr);\n    }\n    function getW(val) {\n        if (val == null) {\n            return E;\n        }\n        if (val == +val) {\n            return val;\n        }\n        $(mgr, {width: val});\n        try {\n            return mgr.getBBox().width;\n        } catch (e) {\n            return 0;\n        }\n    }\n    function getH(val) {\n        if (val == null) {\n            return E;\n        }\n        if (val == +val) {\n            return val;\n        }\n        $(mgr, {height: val});\n        try {\n            return mgr.getBBox().height;\n        } catch (e) {\n            return 0;\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    switch (el.type) {\n        case \"rect\":\n            set(\"rx\", getW);\n            set(\"ry\", getH);\n        case \"image\":\n            set(\"width\", getW);\n            set(\"height\", getH);\n        case \"text\":\n            set(\"x\", getW);\n            set(\"y\", getH);\n        break;\n        case \"circle\":\n            set(\"cx\", getW);\n            set(\"cy\", getH);\n            set(\"r\", getW);\n        break;\n        case \"ellipse\":\n            set(\"cx\", getW);\n            set(\"cy\", getH);\n            set(\"rx\", getW);\n            set(\"ry\", getH);\n        break;\n        case \"line\":\n            set(\"x1\", getW);\n            set(\"x2\", getW);\n            set(\"y1\", getH);\n            set(\"y2\", getH);\n        break;\n        case \"marker\":\n            set(\"refX\", getW);\n            set(\"markerWidth\", getW);\n            set(\"refY\", getH);\n            set(\"markerHeight\", getH);\n        break;\n        case \"radialGradient\":\n            set(\"fx\", getW);\n            set(\"fy\", getH);\n        break;\n        case \"tspan\":\n            set(\"dx\", getW);\n            set(\"dy\", getH);\n        break;\n        default:\n            set(name, getW);\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\\*/\nSnap.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\\*/\nSnap.selectAll = function (query) {\n    var nodelist = glob.doc.querySelectorAll(query),\n        set = (Snap.set || Array)();\n    for (var i = 0; i < nodelist.length; i++) {\n        set.push(wrap(nodelist[i]));\n    }\n    return set;\n};\n\nfunction add2group(list) {\n    if (!is(list, \"array\")) {\n        list = Array.prototype.slice.call(arguments, 0);\n    }\n    var i = 0,\n        j = 0,\n        node = this.node;\n    while (this[i]) delete this[i++];\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    var children = node.childNodes;\n    for (i = 0; i < children.length; i++) {\n        this[j++] = wrap(children[i]);\n    }\n    return this;\n}\n// Hub garbage collector every 10s\nsetInterval(function () {\n    for (var key in hub) if (hub[has](key)) {\n        var el = hub[key],\n            node = el.node;\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}, 1e4);\nfunction Element(el) {\n    if (el.snap in hub) {\n        return hub[el.snap];\n    }\n    var svg;\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    this.node = el;\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    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    if (this.type == \"g\") {\n        this.add = add2group;\n    }\n    if (this.type in {g: 1, mask: 1, pattern: 1, symbol: 1}) {\n        for (var method in Paper.prototype) if (Paper.prototype[has](method)) {\n            this[method] = Paper.prototype[method];\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    Element.prototype.attr = function (params, value) {\n        var el = this,\n            node = el.node;\n        if (!params) {\n            if (node.nodeType != 1) {\n                return {\n                    text: node.nodeValue\n                };\n            }\n            var attr = node.attributes,\n                out = {};\n            for (var i = 0, ii = attr.length; i < ii; i++) {\n                out[attr[i].nodeName] = attr[i].nodeValue;\n            }\n            return out;\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        for (var att in params) {\n            if (params[has](att)) {\n                eve(\"snap.util.attr.\" + att, el, params[att]);\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\\*/\nSnap.parse = function (svg) {\n    var f = glob.doc.createDocumentFragment(),\n        full = true,\n        div = glob.doc.createElement(\"div\");\n    svg = Str(svg);\n    if (!svg.match(/^\\s*<\\s*svg(?:\\s|>)/)) {\n        svg = \"<svg>\" + svg + \"</svg>\";\n        full = false;\n    }\n    div.innerHTML = svg;\n    svg = div.getElementsByTagName(\"svg\")[0];\n    if (svg) {\n        if (full) {\n            f = svg;\n        } else {\n            while (svg.firstChild) {\n                f.appendChild(svg.firstChild);\n            }\n        }\n    }\n    return new Fragment(f);\n};\nfunction 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\\*/\nSnap.fragment = function () {\n    var args = Array.prototype.slice.call(arguments, 0),\n        f = glob.doc.createDocumentFragment();\n    for (var i = 0, ii = args.length; i < ii; i++) {\n        var item = args[i];\n        if (item.node && item.node.nodeType) {\n            f.appendChild(item.node);\n        }\n        if (item.nodeType) {\n            f.appendChild(item);\n        }\n        if (typeof item == \"string\") {\n            f.appendChild(Snap.parse(item).node);\n        }\n    }\n    return new Fragment(f);\n};\n\nfunction make(name, parent) {\n    var res = $(name);\n    parent.appendChild(res);\n    var el = wrap(res);\n    return el;\n}\nfunction Paper(w, h) {\n    var res,\n        desc,\n        defs,\n        proto = Paper.prototype;\n    if (w && w.tagName && w.tagName.toLowerCase() == \"svg\") {\n        if (w.snap in hub) {\n            return hub[w.snap];\n        }\n        var doc = w.ownerDocument;\n        res = new Element(w);\n        desc = w.getElementsByTagName(\"desc\")[0];\n        defs = w.getElementsByTagName(\"defs\")[0];\n        if (!desc) {\n            desc = $(\"desc\");\n            desc.appendChild(doc.createTextNode(\"Created with Snap\"));\n            res.node.appendChild(desc);\n        }\n        if (!defs) {\n            defs = $(\"defs\");\n            res.node.appendChild(defs);\n        }\n        res.defs = defs;\n        for (var key in proto) if (proto[has](key)) {\n            res[key] = proto[key];\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    return res;\n}\nfunction wrap(dom) {\n    if (!dom) {\n        return dom;\n    }\n    if (dom instanceof Element || dom instanceof Fragment) {\n        return dom;\n    }\n    if (dom.tagName && dom.tagName.toLowerCase() == \"svg\") {\n        return new Paper(dom);\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    return new Element(dom);\n}\n\nSnap._.make = make;\nSnap._.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\\*/\nPaper.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\\*/\nElement.prototype.children = function () {\n    var out = [],\n        ch = this.node.childNodes;\n    for (var i = 0, ii = ch.length; i < ii; i++) {\n        out[i] = Snap(ch[i]);\n    }\n    return out;\n};\nfunction 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        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\\*/\nElement.prototype.toJSON = function () {\n    var out = [];\n    jsonFiller([this], out);\n    return out[0];\n};\n// default\neve.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    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});\nvar 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\neve.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    if (cssAttr[has](css)) {\n        this.node.style[style] = value == null ? E : value;\n    } else {\n        $(this.node, attr);\n    }\n});\n(function (proto) {}(Paper.prototype));\n\n// simple ajax\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\\*/\nSnap.ajax = function (url, postData, callback, scope){\n    var req = new XMLHttpRequest,\n        id = ID();\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            for (var key in postData) if (postData.hasOwnProperty(key)) {\n                pd.push(encodeURIComponent(key) + \"=\" + encodeURIComponent(postData[key]));\n            }\n            postData = pd.join(\"&\");\n        }\n        req.open(postData ? \"POST\" : \"GET\", url, true);\n        if (postData) {\n            req.setRequestHeader(\"X-Requested-With\", \"XMLHttpRequest\");\n            req.setRequestHeader(\"Content-type\", \"application/x-www-form-urlencoded\");\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        req.onreadystatechange = function() {\n            if (req.readyState != 4) return;\n            eve(\"snap.ajax.\" + id + \".\" + req.status, scope, req);\n        };\n        if (req.readyState == 4) {\n            return req;\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\\*/\nSnap.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};\nvar getOffset = function (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, 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\\*/\nSnap.getElementByPoint = function (x, y) {\n    var paper = this,\n        svg = paper.canvas,\n        target = glob.doc.elementFromPoint(x, y);\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        if (hits.length) {\n            target = hits[hits.length - 1];\n        }\n    }\n    if (!target) {\n        return null;\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\\*/\nSnap.plugin = function (f) {\n    f(Snap, Element, Paper, glob, Fragment);\n};\nglob.win.Snap = Snap;\nreturn Snap;\n}(window || 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.\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    elproto.getBBox = function (isWithoutTransform) {\n        if (this.type == \"tspan\") {\n            return Snap._.box(this.node.getClientRects().item(0));\n        }\n        if (!Snap.Matrix || !Snap.path) {\n            return this.node.getBBox();\n        }\n        var el = this,\n            m = new Snap.Matrix;\n        if (el.removed) {\n            return Snap._.box();\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            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        var _ = el._,\n            pathfinder = Snap.path.get[el.type] || Snap.path.get.deflt;\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    var propString = function () {\n        return this.string;\n    };\n    function extractTransform(el, tstr) {\n        if (tstr == null) {\n            var doReturn = true;\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            if (!tstr) {\n                return new Snap.Matrix;\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            if (is(tstr, \"array\")) {\n                tstr = Snap.path ? Snap.path.toString.call(tstr) : Str(tstr);\n            }\n            el._.transform = tstr;\n        }\n        var m = Snap._.transform2matrix(tstr, el.getBBox(1));\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    elproto.transform = function (tstr) {\n        var _ = this._;\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) ?\n                            Str(_.transform) : localString;\n            while (papa.type != \"svg\" && (papa = papa.parent())) {\n                ms.push(extractTransform(papa));\n            }\n            i = ms.length;\n            while (i--) {\n                m.add(ms[i]);\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        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, {gradientTransform: this.matrix});\n            } else if (this.type == \"pattern\") {\n                $(this.node, {patternTransform: this.matrix});\n            } else {\n                $(this.node, {transform: this.matrix});\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    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     * Element.add\n     [ method ]\n     **\n     * See @Element.append\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            el = wrap(el);\n            this.node.appendChild(el.node);\n            el.paper = this.paper;\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    elproto.appendTo = function (el) {\n        if (el) {\n            el = wrap(el);\n            el.append(this);\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    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                    first = el;\n                });\n                return this;\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        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    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    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        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    elproto.after = function (el) {\n        el = wrap(el);\n        var parent = el.parent();\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        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    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    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    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    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    elproto.selectAll = function (query) {\n        var nodelist = this.node.querySelectorAll(query),\n            set = (Snap.set || Array)();\n        for (var i = 0; i < nodelist.length; i++) {\n            set.push(wrap(nodelist[i]));\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    elproto.asPX = function (attr, value) {\n        if (value == null) {\n            value = this.attr(attr);\n        }\n        return +unit2px(this, attr, value);\n    };\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     * Element.use\n     [ method ]\n     **\n     * Creates a `<use>` element linked to the current element\n     **\n     = (Element) the `<use>` element\n    \\*/\n    elproto.use = function () {\n        var use,\n            id = this.node.id;\n        if (!id) {\n            id = this.id;\n            $(this.node, {\n                id: id\n            });\n        }\n        if (this.type == \"linearGradient\" || this.type == \"radialGradient\" ||\n            this.type == \"pattern\") {\n            use = make(this.type, this.node.parentNode);\n        } else {\n            use = make(\"use\", this.node.parentNode);\n        }\n        $(use.node, {\n            \"xlink:href\": \"#\" + id\n        });\n        use.original = this;\n        return use;\n    };\n    function fixids(el) {\n        var els = el.selectAll(\"*\"),\n            it,\n            url = /^\\s*url\\((\"|'|)(.*)\\1\\)\\s*$/,\n            ids = [],\n            uses = {};\n        function urltest(it, name) {\n            var val = $(it.node, name);\n            val = val && val.match(url);\n            val = val && val[2];\n            if (val && val.charAt() == \"#\") {\n                val = val.substring(1);\n            } else {\n                return;\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        function linktest(it) {\n            var val = $(it.node, \"xlink:href\");\n            if (val && val.charAt() == \"#\") {\n                val = val.substring(1);\n            } else {\n                return;\n            }\n            if (val) {\n                uses[val] = (uses[val] || []).concat(function (id) {\n                    it.attr(\"xlink:href\", \"#\" + id);\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            if (oldid) {\n                $(it.node, {id: it.id});\n                ids.push({\n                    old: oldid,\n                    id: it.id\n                });\n            }\n        }\n        for (i = 0, ii = ids.length; i < ii; i++) {\n            var fs = uses[ids[i].old];\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    elproto.clone = function () {\n        var clone = wrap(this.node.cloneNode(true));\n        if ($(clone.node, \"id\")) {\n            $(clone.node, {id: clone.id});\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    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    elproto.pattern = elproto.toPattern = function (x, y, width, height) {\n        var p = make(\"pattern\", getSomeDefs(this));\n        if (x == null) {\n            x = this.getBBox();\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        $(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    };\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     * 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    elproto.marker = function (x, y, width, height, refX, refY) {\n        var p = make(\"marker\", getSomeDefs(this));\n        if (x == null) {\n            x = this.getBBox();\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        $(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    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    elproto.data = function (key, value) {\n        var data = eldata[this.id] = eldata[this.id] || {};\n        if (arguments.length == 0){\n            eve(\"snap.data.get.\" + this.id, this, data, null);\n            return data;\n        }\n        if (arguments.length == 1) {\n            if (Snap.is(key, \"object\")) {\n                for (var i in key) if (key[has](i)) {\n                    this.data(i, key[i]);\n                }\n                return this;\n            }\n            eve(\"snap.data.get.\" + this.id, this, data[key], key);\n            return data[key];\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    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        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     * Element.toString\n     [ method ]\n     **\n     * See @Element.outerSVG\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    elproto.innerSVG = toString();\n    function toString(type) {\n        return function () {\n            var res = type ? \"<\" + this.type : \"\",\n                attr = this.node.attributes,\n                chld = this.node.childNodes;\n            if (type) {\n                for (var i = 0, ii = attr.length; i < ii; i++) {\n                    res += \" \" + attr[i].name + '=\"' +\n                            attr[i].value.replace(/\"/g, '\\\\\"') + '\"';\n                }\n            }\n            if (chld.length) {\n                type && (res += \">\");\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                type && (res += \"</\" + this.type + \">\");\n            } else {\n                type && (res += \"/>\");\n            }\n            return res;\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    Fragment.prototype.select = elproto.select;\n    /*\\\n     * Fragment.selectAll\n     [ method ]\n     **\n     * See @Element.selectAll\n    \\*/\n    Fragment.prototype.selectAll = elproto.selectAll;\n});\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.\nSnap.plugin(function (Snap, Element, Paper, glob, Fragment) {\n    var elproto = Element.prototype,\n        is = Snap.is,\n        Str = String,\n        has = \"hasOwnProperty\";\n    function slice(from, to, f) {\n        return function (arr) {\n            var res = arr.slice(from, to);\n            if (res.length == 1) {\n                res = res[0];\n            }\n            return f ? f(res) : res;\n        };\n    }\n    var Animation = function (attr, ms, easing, callback) {\n        if (typeof easing == \"function\" && !easing.length) {\n            callback = easing;\n            easing = mina.linear;\n        }\n        this.attr = attr;\n        this.dur = ms;\n        easing && (this.easing = easing);\n        callback && (this.callback = callback);\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    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    elproto.inAnim = function () {\n        var el = this,\n            res = [];\n        for (var id in el.anims) 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 (val) {\n                        return a.status(val);\n                    },\n                    stop: function () {\n                        a.stop();\n                    }\n                });\n            }(el.anims[id]));\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    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        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    elproto.stop = function () {\n        var anims = this.inAnim();\n        for (var i = 0, ii = anims.length; i < ii; i++) {\n            anims[i].stop();\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    elproto.animate = function (attrs, ms, easing, callback) {\n        if (typeof easing == \"function\" && !easing.length) {\n            callback = easing;\n            easing = mina.linear;\n        }\n        if (attrs instanceof Animation) {\n            callback = attrs.callback;\n            easing = attrs.easing;\n            ms = attrs.dur;\n            attrs = attrs.attr;\n        }\n        var fkeys = [], tkeys = [], keys = {}, from, to, f, eq,\n            el = this;\n        for (var key in attrs) 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            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        var now = mina.time(),\n            anim = mina(fkeys, tkeys, now, now + ms, mina.time, function (val) {\n                var attr = {};\n                for (var key in keys) if (keys[has](key)) {\n                    attr[key] = keys[key](val);\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});\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.\nSnap.plugin(function (Snap, Element, Paper, glob, Fragment) {\n    var objectToString = Object.prototype.toString,\n        Str = String,\n        math = Math,\n        E = \"\";\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        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    (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            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\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        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            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\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        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        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        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        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        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        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        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        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        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        matrixproto.y = function (x, y) {\n            return x * this.b + y * this.d + this.f;\n        };\n        matrixproto.get = function (i) {\n            return +this[Str.fromCharCode(97 + i)].toFixed(4);\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        matrixproto.offset = function () {\n            return [this.e.toFixed(4), this.f.toFixed(4)];\n        };\n        function norm(a) {\n            return a[0] * a[0] + a[1] * a[1];\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        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        matrixproto.split = function () {\n            var out = {};\n            // translation\n            out.dx = this.e;\n            out.dy = this.f;\n\n            // scale and shear\n            var row = [[this.a, this.b], [this.c, this.d]];\n            out.scalex = math.sqrt(norm(row[0]));\n            normalize(row[0]);\n\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\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            }\n\n            // rotation\n            var sin = row[0][1],\n                cos = row[1][1];\n            if (cos < 0) {\n                out.rotate = Snap.deg(math.acos(cos));\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        matrixproto.toTransformString = function (shorter) {\n            var s = shorter || this.split();\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) +\n                        (s.rotate ? \"r\" + [+s.rotate.toFixed(4), 0, 0] : E) +\n                        (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    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    Snap.matrix = function (a, b, c, d, e, f) {\n        return new Matrix(a, b, c, d, e, f);\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.\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    Snap.deurl = function (value) {\n        var res = String(value).match(reURLValue);\n        return res ? res[2] : value;\n    }\n    // Attributes event handlers\n    eve.on(\"snap.util.attr.mask\", function (value) {\n        if (value instanceof Element || value instanceof Fragment) {\n            eve.stop();\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            if (value.type == \"mask\") {\n                var mask = value;\n            } else {\n                mask = make(\"mask\", getSomeDefs(this));\n                mask.node.appendChild(value.node);\n            }\n            !mask.node.id && $(mask.node, {\n                id: mask.id\n            });\n            $(this.node, {\n                mask: URL(mask.id)\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            while (node) {\n                if (node.nodeName === \"clipPath\") {\n                    clip = new Element(node);\n                    break;\n                }\n                if (node.nodeName === \"svg\") {\n                    clip = undefined;\n                    break;\n                }\n                node = node.parentNode;\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            $(this.node, {\n                \"clip-path\": URL(clip.node.id || clip.id)\n            });\n        }\n    }));\n    function fillStroke(name) {\n        return function (value) {\n            eve.stop();\n            if (value instanceof Fragment && value.node.childNodes.length == 1 &&\n                (value.node.firstChild.tagName == \"radialGradient\" ||\n                value.node.firstChild.tagName == \"linearGradient\" ||\n                value.node.firstChild.tagName == \"pattern\")) {\n                value = value.node.firstChild;\n                getSomeDefs(this).appendChild(value);\n                value = wrap(value);\n            }\n            if (value instanceof Element) {\n                if (value.type == \"radialGradient\" || value.type == \"linearGradient\"\n                   || value.type == \"pattern\") {\n                    if (!value.node.id) {\n                        $(value.node, {\n                            id: value.id\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                if (fill.error) {\n                    var grad = Snap(getSomeDefs(this).ownerSVGElement).gradient(value);\n                    if (grad) {\n                        if (!grad.node.id) {\n                            $(grad.node, {\n                                id: grad.id\n                            });\n                        }\n                        fill = URL(grad.node.id);\n                    } else {\n                        fill = value;\n                    }\n                } else {\n                    fill = Str(fill);\n                }\n            }\n            var attrs = {};\n            attrs[name] = fill;\n            $(this.node, attrs);\n            this.node.style[name] = E;\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        if (!tokens) {\n            return null;\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        if (params.length == 1 && params[0] == 0) {\n            params = [];\n        }\n        stops = stops.split(\"-\");\n        stops = stops.map(function (el) {\n            el = el.split(\":\");\n            var out = {\n                color: el[0]\n            };\n            if (el[1]) {\n                out.offset = parseFloat(el[1]);\n            }\n            return out;\n        });\n        var len = stops.length,\n            start = 0,\n            j = 0;\n        function seed(i, end) {\n            var step = (end - start) / (i - j);\n            for (var k = j; k < i; k++) {\n                stops[k].offset = +(+start + step * (k - j)).toFixed(2);\n            }\n            j = i;\n            start = end;\n        }\n        len--;\n        for (var i = 0; i < len; i++) if (\"offset\" in stops[i]) {\n            seed(i, stops[i].offset);\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\n    eve.on(\"snap.util.attr.d\", function (value) {\n        eve.stop();\n        if (is(value, \"array\") && is(value[0], \"array\")) {\n            value = Snap.path.toString.call(value);\n        }\n        value = Str(value);\n        if (value.match(/[ruo]/i)) {\n            value = Snap.path.toAbsolute(value);\n        }\n        $(this.node, {d: value});\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        while (this.node.firstChild) {\n            this.node.removeChild(this.node.firstChild);\n        }\n        this.node.appendChild(txt);\n    })(-1);\n    eve.on(\"snap.util.attr.path\", function (value) {\n        eve.stop();\n        this.attr({d: value});\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        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        $(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        if (this.type == \"text\") {\n            var id, tp, node;\n            if (!value && this.textPath) {\n                tp = this.textPath;\n                while (tp.node.firstChild) {\n                    this.node.appendChild(tp.node.firstChild);\n                }\n                tp.remove();\n                delete this.textPath;\n                return;\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({id: id});\n            } else {\n                value = wrap(value);\n                if (value instanceof Element) {\n                    id = value.attr(\"id\");\n                    if (!id) {\n                        id = value.id;\n                        value.attr({id: id});\n                    }\n                }\n            }\n            if (id) {\n                tp = this.textPath;\n                node = this.node;\n                if (tp) {\n                    tp.attr({\"xlink:href\": \"#\" + id});\n                } else {\n                    tp = $(\"textPath\", {\n                        \"xlink:href\": \"#\" + id\n                    });\n                    while (node.firstChild) {\n                        tp.appendChild(node.firstChild);\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 (chunk) {\n                    var out = $(\"tspan\");\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                    out.normalize && out.normalize();\n                    return out;\n                };\n            while (node.firstChild) {\n                node.removeChild(node.firstChild);\n            }\n            var tuned = tuner(value);\n            while (tuned.firstChild) {\n                node.appendChild(tuned.firstChild);\n            }\n        }\n        eve.stop();\n    })(-1);\n    function setFontSize(value) {\n        eve.stop();\n        if (value == +value) {\n            value += \"px\";\n        }\n        this.node.style.fontSize = value;\n    }\n    eve.on(\"snap.util.attr.fontSize\", setFontSize)(-1);\n    eve.on(\"snap.util.attr.font-size\", setFontSize)(-1);\n\n\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);\n    // Markers\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                if (style == \"none\") {\n                    return style;\n                } else {\n                    return Snap(glob.doc.getElementById(style.match(reURLValue)[1]));\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                if (value == \"\" || !value) {\n                    this.node.style[name] = \"none\";\n                    return;\n                }\n                if (value.type == \"marker\") {\n                    var id = value.node.id;\n                    if (!id) {\n                        $(value.node, {id: value.id});\n                    }\n                    this.node.style[name] = URL(id);\n                    return;\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    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    function textExtract(node) {\n        var out = [];\n        var children = node.childNodes;\n        for (var i = 0, ii = children.length; i < ii; i++) {\n            var chi = children[i];\n            if (chi.nodeType == 3) {\n                out.push(chi.nodeValue);\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        return out;\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        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        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        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        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    function getFontSize() {\n        eve.stop();\n        return this.node.style.fontSize;\n    }\n    eve.on(\"snap.util.getattr.fontSize\", getFontSize)(-1);\n    eve.on(\"snap.util.getattr.font-size\", getFontSize)(-1);\n});\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.\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    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            while (clazz = classes[j++]) {\n                pos = curClasses.indexOf(clazz);\n                if (!~pos) {\n                    curClasses.push(clazz);\n                }\n            }\n\n            finalValue = curClasses.join(\" \");\n            if (className != finalValue) {\n                elem.className.baseVal = finalValue;\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    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        if (curClasses.length) {\n            j = 0;\n            while (clazz = classes[j++]) {\n                pos = curClasses.indexOf(clazz);\n                if (~pos) {\n                    curClasses.splice(pos, 1);\n                }\n            }\n\n            finalValue = curClasses.join(\" \");\n            if (className != finalValue) {\n                elem.className.baseVal = finalValue;\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    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    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        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        while (clazz = classes[j++]) {\n            pos = curClasses.indexOf(clazz);\n            if (~pos) {\n                curClasses.splice(pos, 1);\n            } else {\n                curClasses.push(clazz);\n            }\n        }\n\n        finalValue = curClasses.join(\" \");\n        if (className != finalValue) {\n            elem.className.baseVal = finalValue;\n        }\n        return this;\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.\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    function getNumber(val) {\n        return val;\n    }\n    function getUnit(unit) {\n        return function (val) {\n            return +val.toFixed(3) + unit;\n        };\n    }\n    eve.on(\"snap.util.attr\", function (val) {\n        var plus = Str(val).match(reAddon);\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            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            if (isNaN(a) || isNaN(val)) {\n                return;\n            }\n            atr[name] = val;\n            this.attr(atr);\n        }\n    })(-10);\n    eve.on(\"snap.util.equal\", function (name, b) {\n        var A, B, a = Str(this.attr(name) || \"\"),\n            el = this,\n            bplus = Str(b).match(reAddon);\n        if (bplus) {\n            eve.stop();\n            var unit = bplus[3] || \"\",\n                aUnit = a.match(reUnit),\n                op = operators[bplus[1]];\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});\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.\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    proto.rect = function (x, y, w, h, rx, ry) {\n        var attr;\n        if (ry == null) {\n            ry = rx;\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            if (rx != null) {\n                attr.rx = rx;\n                attr.ry = ry;\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    proto.circle = function (cx, cy, r) {\n        var attr;\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        return this.el(\"circle\", attr);\n    };\n\n    var preload = (function () {\n        function onerror() {\n            this.parentNode.removeChild(this);\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            img.onload = function () {\n                f.call(img);\n                img.onload = img.onerror = null;\n                body.removeChild(img);\n            };\n            img.onerror = onerror;\n            body.appendChild(img);\n            img.src = src;\n        };\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    proto.image = function (src, x, y, width, height) {\n        var el = this.el(\"image\");\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            if (x != null && y != null) {\n                set.x = x;\n                set.y = y;\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            Snap._.$(el.node, set);\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    proto.ellipse = function (cx, cy, rx, ry) {\n        var attr;\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        return this.el(\"ellipse\", attr);\n    };\n    // SIERRA Paper.path(): Unclear from the link what a Catmull-Rom curveto is, and why it would make life any easier.\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    proto.path = function (d) {\n        var attr;\n        if (is(d, \"object\") && !is(d, \"array\")) {\n            attr = d;\n        } else if (d) {\n            attr = {d: d};\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     * Paper.group\n     [ method ]\n     **\n     * See @Paper.g\n    \\*/\n    proto.group = proto.g = function (first) {\n        var attr,\n            el = this.el(\"g\");\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        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    proto.svg = function (x, y, width, height, vbx, vby, vbw, vbh) {\n        var attrs = {};\n        if (is(x, \"object\") && y == null) {\n            attrs = x;\n        } else {\n            if (x != null) {\n                attrs.x = x;\n            }\n            if (y != null) {\n                attrs.y = y;\n            }\n            if (width != null) {\n                attrs.width = width;\n            }\n            if (height != null) {\n                attrs.height = height;\n            }\n            if (vbx != null && vby != null && vbw != null && vbh != null) {\n                attrs.viewBox = [vbx, vby, vbw, vbh];\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    proto.mask = function (first) {\n        var attr,\n            el = this.el(\"mask\");\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        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    proto.ptrn = function (x, y, width, height, vx, vy, vw, vh) {\n        if (is(x, \"object\")) {\n            var attr = x;\n        } else {\n            attr = {patternUnits: \"userSpaceOnUse\"};\n            if (x) {\n                attr.x = x;\n            }\n            if (y) {\n                attr.y = y;\n            }\n            if (width != null) {\n                attr.width = width;\n            }\n            if (height != null) {\n                attr.height = height;\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        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    proto.use = function (id) {\n        if (id != null) {\n            if (id instanceof Element) {\n                if (!id.attr(\"id\")) {\n                    id.attr({id: Snap._.id(id)});\n                }\n                id = id.attr(\"id\");\n            }\n            if (String(id).charAt() == \"#\") {\n                id = id.substring(1);\n            }\n            return this.el(\"use\", {\"xlink:href\": \"#\" + id});\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    proto.symbol = function (vx, vy, vw, vh) {\n        var attr = {};\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    proto.text = function (x, y, text) {\n        var attr = {};\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        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    proto.line = function (x1, y1, x2, y2) {\n        var attr = {};\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        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    proto.polyline = function (points) {\n        if (arguments.length > 1) {\n            points = Array.prototype.slice.call(arguments, 0);\n        }\n        var attr = {};\n        if (is(points, \"object\") && !is(points, \"array\")) {\n            attr = points;\n        } else if (points != null) {\n            attr = {points: points};\n        }\n        return this.el(\"polyline\", attr);\n    };\n    /*\\\n     * Paper.polygon\n     [ method ]\n     **\n     * Draws a polygon. See @Paper.polyline\n    \\*/\n    proto.polygon = function (points) {\n        if (arguments.length > 1) {\n            points = Array.prototype.slice.call(arguments, 0);\n        }\n        var attr = {};\n        if (is(points, \"object\") && !is(points, \"array\")) {\n            attr = points;\n        } else if (points != null) {\n            attr = {points: points};\n        }\n        return this.el(\"polygon\", attr);\n    };\n    // gradients\n    (function () {\n        var $ = Snap._.$;\n        // gradients' helpers\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        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        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            if (color.opacity < 1) {\n                attr[\"stop-opacity\"] = color.opacity;\n            }\n            $(stop, attr);\n            var stops = this.stops(),\n                inserted;\n            for (var i = 0; i < stops.length; i++) {\n                var stopOffset = parseFloat(stops[i].attr(\"offset\"));\n                if (stopOffset > offset) {\n                    this.node.insertBefore(stop, stops[i].node);\n                    inserted = true;\n                    break;\n                }\n            }\n            if (!inserted) {\n                this.node.appendChild(stop);\n            }\n            return this;\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        function GsetStops(str) {\n            var grad = str,\n                stops = this.stops();\n            if (typeof str == \"string\") {\n                grad = eve(\"snap.util.grad.parse\", null, \"l(0,0,0,1)\" + str).firstDefined().stops;\n            }\n            if (!Snap.is(grad, \"array\")) {\n                return;\n            }\n            for (var i = 0; i < stops.length; i++) {\n                if (grad[i]) {\n                    var color = Snap.color(grad[i].color),\n                        attr = {\"offset\": grad[i].offset + \"%\"};\n                    attr[\"stop-color\"] = color.hex;\n                    if (color.opacity < 1) {\n                        attr[\"stop-opacity\"] = color.opacity;\n                    }\n                    stops[i].attr(attr);\n                } else {\n                    stops[i].remove();\n                }\n            }\n            for (i = stops.length; i < grad.length; i++) {\n                this.addStop(grad[i].color, grad[i].offset);\n            }\n            return this;\n        }\n        function gradient(defs, str) {\n            var grad = eve(\"snap.util.grad.parse\", null, str).firstDefined(),\n                el;\n            if (!grad) {\n                return null;\n            }\n            grad.params.unshift(defs);\n            if (grad.type.toLowerCase() == \"l\") {\n                el = gradientLinear.apply(0, grad.params);\n            } else {\n                el = gradientRadial.apply(0, grad.params);\n            }\n            if (grad.type != grad.type.toLowerCase()) {\n                $(el.node, {\n                    gradientUnits: \"userSpaceOnUse\"\n                });\n            }\n            var stops = grad.stops,\n                len = stops.length;\n            for (var i = 0; i < len; i++) {\n                var stop = stops[i];\n                el.addStop(stop.color, stop.offset);\n            }\n            return el;\n        }\n        function gradientLinear(defs, x1, y1, x2, y2) {\n            var el = Snap._.make(\"linearGradient\", defs);\n            el.stops = Gstops;\n            el.addStop = GaddStop;\n            el.getBBox = GgetBBox;\n            el.setStops = GsetStops;\n            if (x1 != null) {\n                $(el.node, {\n                    x1: x1,\n                    y1: y1,\n                    x2: x2,\n                    y2: y2\n                });\n            }\n            return el;\n        }\n        function gradientRadial(defs, cx, cy, r, fx, fy) {\n            var el = Snap._.make(\"radialGradient\", defs);\n            el.stops = Gstops;\n            el.addStop = GaddStop;\n            el.getBBox = GgetBBox;\n            if (cx != null) {\n                $(el.node, {\n                    cx: cx,\n                    cy: cy,\n                    r: r\n                });\n            }\n            if (fx != null && fy != null) {\n                $(el.node, {\n                    fx: fx,\n                    fy: fy\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        proto.gradient = function (str) {\n            return gradient(this.defs, str);\n        };\n        proto.gradientLinear = function (x1, y1, x2, y2) {\n            return gradientLinear(this.defs, x1, y1, x2, y2);\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        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            Snap._.$(svg, {xmlns: \"http://www.w3.org/2000/svg\"});\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        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        proto.clear = function () {\n            var node = this.node.firstChild,\n                next;\n            while (node) {\n                next = node.nextSibling;\n                if (node.tagName != \"defs\") {\n                    node.parentNode.removeChild(node);\n                } else {\n                    proto.clear.call({node: node});\n                }\n                node = next;\n            }\n        };\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.\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    function paths(ps) {\n        var p = paths.ps = paths.ps || {};\n        if (p[ps]) {\n            p[ps].sleep = 100;\n        } else {\n            p[ps] = {\n                sleep: 100\n            };\n        }\n        setTimeout(function () {\n            for (var key in p) if (p[has](key) && key != ps) {\n                p[key].sleep--;\n                !p[key].sleep && delete p[key];\n            }\n        });\n        return p[ps];\n    }\n    function box(x, y, width, height) {\n        if (x == null) {\n            x = y = width = height = 0;\n        }\n        if (y == null) {\n            y = x.y;\n            width = x.width;\n            height = x.height;\n            x = x.x;\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    function toString() {\n        return this.join(\",\").replace(p2s, \"$1\");\n    }\n    function pathClone(pathArray) {\n        var res = clone(pathArray);\n        res.toString = toString;\n        return res;\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,\n                getTotLen(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, length));\n        }\n    }\n    function getLengthFactory(istotal, subpath) {\n        function O(val) {\n            return +(+val).toFixed(3);\n        }\n        return Snap._.cacher(function (path, length, onlystart) {\n            if (path instanceof Element) {\n                path = path.attr(\"d\");\n            }\n            path = path2curve(path);\n            var x, y, p, l, sp = \"\", subpaths = {}, point,\n                len = 0;\n            for (var i = 0, ii = path.length; i < ii; i++) {\n                p = path[i];\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                    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 += [\n                                \"C\" + O(point.start.x),\n                                O(point.start.y),\n                                O(point.m.x),\n                                O(point.m.y),\n                                O(point.x),\n                                O(point.y)\n                            ];\n                            if (onlystart) {return sp;}\n                            subpaths.start = sp;\n                            sp = [\n                                \"M\" + O(point.x),\n                                O(point.y) + \"C\" + O(point.n.x),\n                                O(point.n.y),\n                                O(point.end.x),\n                                O(point.end.y),\n                                O(p[5]),\n                                O(p[6])\n                            ].join();\n                            len += l;\n                            x = +p[5];\n                            y = +p[6];\n                            continue;\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                    len += l;\n                    x = +p[5];\n                    y = +p[6];\n                }\n                sp += p.shift() + p;\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    var getTotalLength = getLengthFactory(1),\n        getPointAtLength = getLengthFactory(),\n        getSubpathsAtLength = getLengthFactory(0, 1);\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;\n        // (mx > nx || my < ny) && (alpha += 180);\n        return {\n            x: x,\n            y: y,\n            m: {x: mx, y: my},\n            n: {x: nx, y: ny},\n            start: {x: ax, y: ay},\n            end: {x: cx, y: cy},\n            alpha: alpha\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        var bbox = curveDim.apply(null, p1x);\n        return box(\n            bbox.min.x,\n            bbox.min.y,\n            bbox.max.x - bbox.min.x,\n            bbox.max.y - bbox.min.y\n        );\n    }\n    function isPointInsideBBox(bbox, x, y) {\n        return  x >= bbox.x &&\n                x <= bbox.x + bbox.width &&\n                y >= bbox.y &&\n                y <= bbox.y + bbox.height;\n    }\n    function isBBoxIntersect(bbox1, bbox2) {\n        bbox1 = box(bbox1);\n        bbox2 = box(bbox2);\n        return isPointInsideBBox(bbox2, bbox1.x, bbox1.y)\n            || isPointInsideBBox(bbox2, bbox1.x2, bbox1.y)\n            || isPointInsideBBox(bbox2, bbox1.x, bbox1.y2)\n            || isPointInsideBBox(bbox2, bbox1.x2, bbox1.y2)\n            || isPointInsideBBox(bbox1, bbox2.x, bbox2.y)\n            || isPointInsideBBox(bbox1, bbox2.x2, bbox2.y)\n            || isPointInsideBBox(bbox1, bbox2.x, bbox2.y2)\n            || isPointInsideBBox(bbox1, bbox2.x2, bbox2.y2)\n            || (bbox1.x < bbox2.x2 && bbox1.x > bbox2.x\n                || bbox2.x < bbox1.x2 && bbox2.x > bbox1.x)\n            && (bbox1.y < bbox2.y2 && bbox1.y > bbox2.y\n                || bbox2.y < bbox1.y2 && bbox2.y > bbox1.y);\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    function bezlen(x1, y1, x2, y2, x3, y3, x4, y4, z) {\n        if (z == null) {\n            z = 1;\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        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        return z2 * sum;\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        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        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        return t2;\n    }\n    function intersect(x1, y1, x2, y2, x3, y3, x4, y4) {\n        if (\n            mmax(x1, x2) < mmin(x3, x4) ||\n            mmin(x1, x2) > mmax(x3, x4) ||\n            mmax(y1, y2) < mmin(y3, y4) ||\n            mmin(y1, y2) > mmax(y3, y4)\n        ) {\n            return;\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        var px = nx / denominator,\n            py = ny / denominator,\n            px2 = +px.toFixed(2),\n            py2 = +py.toFixed(2);\n        if (\n            px2 < +mmin(x1, x2).toFixed(2) ||\n            px2 > +mmax(x1, x2).toFixed(2) ||\n            px2 < +mmin(x3, x4).toFixed(2) ||\n            px2 > +mmax(x3, x4).toFixed(2) ||\n            py2 < +mmin(y1, y2).toFixed(2) ||\n            py2 > +mmax(y1, y2).toFixed(2) ||\n            py2 < +mmin(y3, y4).toFixed(2) ||\n            py2 > +mmax(y3, y4).toFixed(2)\n        ) {\n            return;\n        }\n        return {x: px, y: py};\n    }\n    function inter(bez1, bez2) {\n        return interHelper(bez1, bez2);\n    }\n    function interCount(bez1, bez2) {\n        return interHelper(bez1, bez2, 1);\n    }\n    function interHelper(bez1, bez2, justCount) {\n        var bbox1 = bezierBBox(bez1),\n            bbox2 = bezierBBox(bez2);\n        if (!isBBoxIntersect(bbox1, bbox2)) {\n            return justCount ? 0 : [];\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        for (var i = 0; i < n1 + 1; i++) {\n            var p = findDotsAtSegment.apply(0, bez1.concat(i / n1));\n            dots1.push({x: p.x, y: p.y, t: i / n1});\n        }\n        for (i = 0; i < n2 + 1; i++) {\n            p = findDotsAtSegment.apply(0, bez2.concat(i / n2));\n            dots2.push({x: p.x, y: p.y, t: i / n2});\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                if (is) {\n                    if (xy[is.x.toFixed(4)] == is.y.toFixed(4)) {\n                        continue;\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                    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        return res;\n    }\n    function pathIntersection(path1, path2) {\n        return interPathHelper(path1, path2);\n    }\n    function pathIntersectionNumber(path1, path2) {\n        return interPathHelper(path1, path2, 1);\n    }\n    function interPathHelper(path1, path2, justCount) {\n        path1 = path2curve(path1);\n        path2 = path2curve(path2);\n        var x1, y1, x2, y2, x1m, y1m, x2m, y2m, bez1, bez2,\n            res = justCount ? 0 : [];\n        for (var i = 0, ii = path1.length; i < ii; i++) {\n            var pi = path1[i];\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                for (var j = 0, jj = path2.length; j < jj; j++) {\n                    var pj = path2[j];\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                        var intr = interHelper(bez1, bez2, justCount);\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                            res = res.concat(intr);\n                        }\n                    }\n                }\n            }\n        }\n        return res;\n    }\n    function isPointInsidePath(path, x, y) {\n        var bbox = pathBBox(path);\n        return isPointInsideBBox(bbox, x, y) &&\n               interPathHelper(path, [[\"M\", x, y], [\"H\", bbox.x2 + 10]], 1) % 2 == 1;\n    }\n    function pathBBox(path) {\n        var pth = paths(path);\n        if (pth.bbox) {\n            return clone(pth.bbox);\n        }\n        if (!path) {\n            return box();\n        }\n        path = path2curve(path);\n        var x = 0,\n            y = 0,\n            X = [],\n            Y = [],\n            p;\n        for (var i = 0, ii = path.length; i < ii; i++) {\n            p = path[i];\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        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    function rectPath(x, y, w, h, r) {\n        if (r) {\n            return [\n                [\"M\", +x + +r, y],\n                [\"l\", w - r * 2, 0],\n                [\"a\", r, r, 0, 0, 1, r, r],\n                [\"l\", 0, h - r * 2],\n                [\"a\", r, r, 0, 0, 1, -r, r],\n                [\"l\", r * 2 - w, 0],\n                [\"a\", r, r, 0, 0, 1, -r, -r],\n                [\"l\", 0, r * 2 - h],\n                [\"a\", r, r, 0, 0, 1, r, -r],\n                [\"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    function ellipsePath(x, y, rx, ry, a) {\n        if (a == null && ry == null) {\n            ry = rx;\n        }\n        x = +x;\n        y = +y;\n        rx = +rx;\n        ry = +ry;\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 = [\n                [\"M\", x, y],\n                [\"m\", 0, -ry],\n                [\"a\", rx, ry, 0, 1, 1, 0, 2 * ry],\n                [\"a\", rx, ry, 0, 1, 1, 0, -2 * ry],\n                [\"z\"]\n            ];\n        }\n        res.toString = toString;\n        return res;\n    }\n    var unit2px = Snap._unit2px,\n        getPath = {\n        path: function (el) {\n            return el.attr(\"path\");\n        },\n        circle: function (el) {\n            var attr = unit2px(el);\n            return ellipsePath(attr.cx, attr.cy, attr.r);\n        },\n        ellipse: function (el) {\n            var attr = unit2px(el);\n            return ellipsePath(attr.cx || 0, attr.cy || 0, attr.rx, attr.ry);\n        },\n        rect: function (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 (el) {\n            var attr = unit2px(el);\n            return rectPath(attr.x || 0, attr.y || 0, attr.width, attr.height);\n        },\n        line: function (el) {\n            return \"M\" + [el.attr(\"x1\") || 0, el.attr(\"y1\") || 0, el.attr(\"x2\"), el.attr(\"y2\")];\n        },\n        polyline: function (el) {\n            return \"M\" + el.attr(\"points\");\n        },\n        polygon: function (el) {\n            return \"M\" + el.attr(\"points\") + \"z\";\n        },\n        deflt: function (el) {\n            var bbox = el.node.getBBox();\n            return rectPath(bbox.x, bbox.y, bbox.width, bbox.height);\n        }\n    };\n    function pathToRelative(pathArray) {\n        var pth = paths(pathArray),\n            lowerCase = String.prototype.toLowerCase;\n        if (pth.rel) {\n            return pathClone(pth.rel);\n        }\n        if (!Snap.is(pathArray, \"array\") || !Snap.is(pathArray && pathArray[0], \"array\")) {\n            pathArray = Snap.parsePathString(pathArray);\n        }\n        var res = [],\n            x = 0,\n            y = 0,\n            mx = 0,\n            my = 0,\n            start = 0;\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        for (var i = start, ii = pathArray.length; i < ii; i++) {\n            var r = res[i] = [],\n                pa = pathArray[i];\n            if (pa[0] != lowerCase.call(pa[0])) {\n                r[0] = lowerCase.call(pa[0]);\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                    case \"v\":\n                        r[1] = +(pa[1] - y).toFixed(3);\n                        break;\n                    case \"m\":\n                        mx = pa[1];\n                        my = pa[2];\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            } else {\n                r = res[i] = [];\n                if (pa[0] == \"m\") {\n                    mx = pa[1] + x;\n                    my = pa[2] + y;\n                }\n                for (var k = 0, kk = pa.length; k < kk; k++) {\n                    res[i][k] = pa[k];\n                }\n            }\n            var len = res[i].length;\n            switch (res[i][0]) {\n                case \"z\":\n                    x = mx;\n                    y = my;\n                    break;\n                case \"h\":\n                    x += +res[i][len - 1];\n                    break;\n                case \"v\":\n                    y += +res[i][len - 1];\n                    break;\n                default:\n                    x += +res[i][len - 2];\n                    y += +res[i][len - 1];\n            }\n        }\n        res.toString = toString;\n        pth.rel = pathClone(res);\n        return res;\n    }\n    function pathToAbsolute(pathArray) {\n        var pth = paths(pathArray);\n        if (pth.abs) {\n            return pathClone(pth.abs);\n        }\n        if (!is(pathArray, \"array\") || !is(pathArray && pathArray[0], \"array\")) { // rough assumption\n            pathArray = Snap.parsePathString(pathArray);\n        }\n        if (!pathArray || !pathArray.length) {\n            return [[\"M\", 0, 0]];\n        }\n        var res = [],\n            x = 0,\n            y = 0,\n            mx = 0,\n            my = 0,\n            start = 0,\n            pa0;\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        var crz = pathArray.length == 3 &&\n            pathArray[0][0] == \"M\" &&\n            pathArray[1][0].toUpperCase() == \"R\" &&\n            pathArray[2][0].toUpperCase() == \"Z\";\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            if (pa0 != pa0.toUpperCase()) {\n                r[0] = pa0.toUpperCase();\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                    case \"V\":\n                        r[1] = +pa[1] + y;\n                        break;\n                    case \"H\":\n                        r[1] = +pa[1] + x;\n                        break;\n                    case \"R\":\n                        var dots = [x, y].concat(pa.slice(1));\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                        res.pop();\n                        res = res.concat(catmullRom2bezier(dots, crz));\n                        break;\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                    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                    case \"M\":\n                        mx = +pa[1] + x;\n                        my = +pa[2] + y;\n                    default:\n                        for (j = 1, jj = pa.length; j < jj; j++) {\n                            r[j] = +pa[j] + (j % 2 ? x : y);\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            pa0 = pa0.toUpperCase();\n            if (pa0 != \"O\") {\n                switch (r[0]) {\n                    case \"Z\":\n                        x = +mx;\n                        y = +my;\n                        break;\n                    case \"H\":\n                        x = r[1];\n                        break;\n                    case \"V\":\n                        y = r[1];\n                        break;\n                    case \"M\":\n                        mx = r[r.length - 2];\n                        my = r[r.length - 1];\n                    default:\n                        x = r[r.length - 2];\n                        y = r[r.length - 1];\n                }\n            }\n        }\n        res.toString = toString;\n        pth.abs = pathClone(res);\n        return res;\n    }\n    function l2c(x1, y1, x2, y2) {\n        return [x1, y1, x2, y2, x2, y2];\n    }\n    function q2c(x1, y1, ax, ay, x2, y2) {\n        var _13 = 1 / 3,\n            _23 = 2 / 3;\n        return [\n                _13 * x1 + _23 * ax,\n                _13 * y1 + _23 * ay,\n                _13 * x2 + _23 * ax,\n                _13 * y2 + _23 * ay,\n                x2,\n                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 {x: X, y: Y};\n            });\n        if (!rx || !ry) {\n            return [x1, y1, x2, y2, x2, y2];\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            if (h > 1) {\n                h = math.sqrt(h);\n                rx = h * rx;\n                ry = h * ry;\n            }\n            var rx2 = rx * rx,\n                ry2 = ry * ry,\n                k = (large_arc_flag == sweep_flag ? -1 : 1) *\n                    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\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            if (sweep_flag && f1 > f2) {\n                f1 = f1 - PI * 2;\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        var df = f2 - f1;\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        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        if (recursive) {\n            return [m2, m3, m4].concat(res);\n        } else {\n            res = [m2, m3, m4].concat(res).join().split(\",\");\n            var newres = [];\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            return newres;\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    }\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    function curveDim(x0, y0, x1, y1, x2, y2, x3, y3) {\n        var tvalues = [],\n            bounds = [[], []],\n            a, b, c, t, t1, t2, b2ac, sqrtb2ac;\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            if (abs(a) < 1e-12) {\n                if (abs(b) < 1e-12) {\n                    continue;\n                }\n                t = -c / b;\n                if (0 < t && t < 1) {\n                    tvalues.push(t);\n                }\n                continue;\n            }\n            b2ac = b * b - 4 * c * a;\n            sqrtb2ac = math.sqrt(b2ac);\n            if (b2ac < 0) {\n                continue;\n            }\n            t1 = (-b + sqrtb2ac) / (2 * a);\n            if (0 < t1 && t1 < 1) {\n                tvalues.push(t1);\n            }\n            t2 = (-b - sqrtb2ac) / (2 * a);\n            if (0 < t2 && t2 < 1) {\n                tvalues.push(t2);\n            }\n        }\n\n        var x, y, j = tvalues.length,\n            jlen = j,\n            mt;\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\n\n        return {\n          min: {x: mmin.apply(0, bounds[0]), y: mmin.apply(0, bounds[1])},\n          max: {x: mmax.apply(0, bounds[0]), y: mmax.apply(0, bounds[1])}\n        };\n    }\n\n    function path2curve(path, path2) {\n        var pth = !path2 && paths(path);\n        if (!path2 && pth.curve) {\n            return pathClone(pth.curve);\n        }\n        var p = pathToAbsolute(path),\n            p2 = path2 && pathToAbsolute(path2),\n            attrs = {x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null},\n            attrs2 = {x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null},\n            processPath = function (path, d, pcom) {\n                var nx, ny;\n                if (!path) {\n                    return [\"C\", d.x, d.y, d.x, d.y, d.x, d.y];\n                }\n                !(path[0] in {T: 1, Q: 1}) && (d.qx = d.qy = null);\n                switch (path[0]) {\n                    case \"M\":\n                        d.X = path[1];\n                        d.Y = path[2];\n                        break;\n                    case \"A\":\n                        path = [\"C\"].concat(a2c.apply(0, [d.x, d.y].concat(path.slice(1))));\n                        break;\n                    case \"S\":\n                        if (pcom == \"C\" || pcom == \"S\") { // 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                            ny = d.y * 2 - d.by;          // command's control point relative to the current point.\n                        }\n                        else {                            // or some else or nothing\n                            nx = d.x;\n                            ny = d.y;\n                        }\n                        path = [\"C\", nx, ny].concat(path.slice(1));\n                        break;\n                    case \"T\":\n                        if (pcom == \"Q\" || pcom == \"T\") { // 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                            d.qy = d.y * 2 - d.qy;        // to case \"S\".\n                        }\n                        else {                            // or something else or nothing\n                            d.qx = d.x;\n                            d.qy = d.y;\n                        }\n                        path = [\"C\"].concat(q2c(d.x, d.y, d.qx, d.qy, path[1], path[2]));\n                        break;\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                    case \"L\":\n                        path = [\"C\"].concat(l2c(d.x, d.y, path[1], path[2]));\n                        break;\n                    case \"H\":\n                        path = [\"C\"].concat(l2c(d.x, d.y, path[1], d.y));\n                        break;\n                    case \"V\":\n                        path = [\"C\"].concat(l2c(d.x, d.y, d.x, path[1]));\n                        break;\n                    case \"Z\":\n                        path = [\"C\"].concat(l2c(d.x, d.y, d.X, d.Y));\n                        break;\n                }\n                return path;\n            },\n            fixArc = function (pp, i) {\n                if (pp[i].length > 7) {\n                    pp[i].shift();\n                    var pi = pp[i];\n                    while (pi.length) {\n                        pcoms1[i] = \"A\"; // if created multiple C:s, their original seg is saved\n                        p2 && (pcoms2[i] = \"A\"); // the same as above\n                        pp.splice(i++, 0, [\"C\"].concat(pi.splice(0, 6)));\n                    }\n                    pp.splice(i, 1);\n                    ii = mmax(p.length, p2 && p2.length || 0);\n                }\n            },\n            fixM = function (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 = [], // path commands of original path p\n            pcoms2 = [], // path commands of original path p2\n            pfirst = \"\", // temporary holder for original path command\n            pcom = \"\"; // holder for previous path command of original path\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                i && ( pcom = pcoms1[i - 1]); // Get previous path command pcom\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) { // the same procedures is done to p2\n                p2[i] && (pfirst = p2[i][0]);\n                if (pfirst != \"C\") {\n                    pcoms2[i] = pfirst;\n                    i && (pcom = pcoms2[i - 1]);\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            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        if (!p2) {\n            pth.curve = pathClone(p);\n        }\n        return p2 ? [p, p2] : p;\n    }\n    function mapPath(path, matrix) {\n        if (!matrix) {\n            return path;\n        }\n        var x, y, i, j, ii, jj, pathi;\n        path = path2curve(path);\n        for (i = 0, ii = path.length; i < ii; i++) {\n            pathi = path[i];\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        return path;\n    }\n\n    // http://schepers.cc/getting-to-the-point\n    function catmullRom2bezier(crp, z) {\n        var d = [];\n        for (var i = 0, iLen = crp.length; iLen - 2 * !z > i; i += 2) {\n            var p = [\n                        {x: +crp[i - 2], y: +crp[i - 1]},\n                        {x: +crp[i],     y: +crp[i + 1]},\n                        {x: +crp[i + 2], y: +crp[i + 3]},\n                        {x: +crp[i + 4], y: +crp[i + 5]}\n                    ];\n            if (z) {\n                if (!i) {\n                    p[0] = {x: +crp[iLen - 2], y: +crp[iLen - 1]};\n                } else if (iLen - 4 == i) {\n                    p[3] = {x: +crp[0], y: +crp[1]};\n                } else if (iLen - 2 == i) {\n                    p[2] = {x: +crp[0], y: +crp[1]};\n                    p[3] = {x: +crp[2], y: +crp[3]};\n                }\n            } else {\n                if (iLen - 4 == i) {\n                    p[3] = p[2];\n                } else if (!i) {\n                    p[0] = {x: +crp[i], y: +crp[i + 1]};\n                }\n            }\n            d.push([\"C\",\n                  (-p[0].x + 6 * p[1].x + p[2].x) / 6,\n                  (-p[0].y + 6 * p[1].y + p[2].y) / 6,\n                  (p[1].x + 6 * p[2].x - p[3].x) / 6,\n                  (p[1].y + 6*p[2].y - p[3].y) / 6,\n                  p[2].x,\n                  p[2].y\n            ]);\n        }\n\n        return d;\n    }\n\n    // export\n    Snap.path = paths;\n\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    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    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    Snap.path.getSubpath = function (path, from, to) {\n        if (this.getTotalLength(path) - to < 1e-6) {\n            return getSubpathsAtLength(path, from).end;\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    elproto.getTotalLength = function () {\n        if (this.node.getTotalLength) {\n            return this.node.getTotalLength();\n        }\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     * 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    elproto.getPointAtLength = function (length) {\n        return getPointAtLength(this.attr(\"d\"), length);\n    };\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     * 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    elproto.getSubpath = function (from, to) {\n        return Snap.path.getSubpath(this.attr(\"d\"), from, to);\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    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    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    Snap.path.isPointInsideBBox = isPointInsideBBox;\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        while (r <= 1e6 && !found) {\n            for (var i = 0, ii = X.length; i < ii; i++) {\n                var xy = getter(i);\n                if (isPointInsideBBox(b, xy.x, xy.y)) {\n                    found++;\n                    inside.push(xy);\n                    break;\n                }\n            }\n            if (!found) {\n                r *= 2;\n                b = box(x - r / 2, y - r / 2, r, r)\n            }\n        }\n        if (r == 1e6) {\n            return;\n        }\n        var len = Infinity,\n            res;\n        for (i = 0, ii = inside.length; i < ii; i++) {\n            var l = Snap.len(x, y, inside[i].x, inside[i].y);\n            if (len > l) {\n                len = l;\n                inside[i].len = l;\n                res = inside[i];\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    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    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    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    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    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    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    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    Snap.path.map = mapPath;\n    Snap.path.toString = toString;\n    Snap.path.clone = pathClone;\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.\nSnap.plugin(function (Snap, Element, Paper, glob) {\n    var mmax = Math.max,\n        mmin = Math.min;\n\n    // Set\n    var Set = function (items) {\n        this.items = [];\n\tthis.bindings = {};\n        this.length = 0;\n        this.type = \"set\";\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    setproto.push = function () {\n        var item,\n            len;\n        for (var i = 0, ii = arguments.length; i < ii; i++) {\n            item = arguments[i];\n            if (item) {\n                len = this.items.length;\n                this[len] = this.items[len] = item;\n                this.length++;\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    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    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        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    setproto.animate = function (attrs, ms, easing, callback) {\n        if (typeof easing == \"function\" && !easing.length) {\n            callback = easing;\n            easing = mina.linear;\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        var args = arguments;\n        if (Snap.is(attrs, \"array\") && Snap.is(args[args.length - 1], \"array\")) {\n            var each = true;\n        }\n        var begin,\n            handler = function () {\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        return this.forEach(function (el, i) {\n            eve.once(\"snap.animcreated.\" + el.id, handler);\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    setproto.remove = function () {\n        while (this.length) {\n            this.pop().remove();\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    setproto.bind = function (attr, a, b) {\n        var data = {};\n        if (typeof a == \"function\") {\n            this.bindings[attr] = a;\n        } else {\n            var aname = b || attr;\n            this.bindings[attr] = function (v) {\n                data[aname] = v;\n                a.attr(data);\n            };\n        }\n        return this;\n    };\n    /*\\\n     * Set.attr\n     [ method ]\n     **\n     * Equivalent of @Element.attr.\n     = (object) Set object\n    \\*/\n    setproto.attr = function (value) {\n        var unbound = {};\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        for (var i = 0, ii = this.items.length; i < ii; i++) {\n            this.items[i].attr(unbound);\n        }\n        return this;\n    };\n    /*\\\n     * Set.clear\n     [ method ]\n     **\n     * Removes all elements from the set\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    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        for (i = 2; i < arguments.length; i++) {\n            args.push(arguments[i]);\n        }\n        for (i = 0; i < count; i++) {\n            todel.push(this[index + i]);\n        }\n        for (; i < this.length - index; i++) {\n            tail.push(this[index + i]);\n        }\n        var arglen = args.length;\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        i = this.items.length = this.length -= count - arglen;\n        while (this[i]) {\n            delete this[i++];\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    setproto.exclude = function (el) {\n        for (var i = 0, ii = this.length; i < ii; i++) if (this[i] == el) {\n            this.splice(i, 1);\n            return true;\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    setproto.insertAfter = function (el) {\n        var i = this.items.length;\n        while (i--) {\n            this.items[i].insertAfter(el);\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    setproto.getBBox = function () {\n        var x = [],\n            y = [],\n            x2 = [],\n            y2 = [];\n        for (var i = this.items.length; i--;) 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        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    setproto.clone = function (s) {\n        s = new Set;\n        for (var i = 0, ii = this.items.length; i < ii; i++) {\n            s.push(this.items[i].clone());\n        }\n        return s;\n    };\n    setproto.toString = function () {\n        return \"Snap\\u2018s set\";\n    };\n    setproto.type = \"set\";\n    // export\n    /*\\\n     * Snap.Set\n     [ property ]\n     **\n     * Set constructor.\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    Snap.set = function () {\n        var set = new Set;\n        if (arguments.length) {\n            set.push.apply(set, Array.prototype.slice.call(arguments, 0));\n        }\n        return set;\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.\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    function getEmpty(item) {\n        var l = item[0];\n        switch (l.toLowerCase()) {\n            case \"t\": return [l, 0, 0];\n            case \"m\": return [l, 1, 0, 0, 1, 0, 0];\n            case \"r\": if (item.length == 4) {\n                return [l, 0, item[2], item[3]];\n            } else {\n                return [l, 0];\n            }\n            case \"s\": 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    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, j, jj,\n            tt1, tt2;\n        for (; i < maxlength; i++) {\n            tt1 = t1[i] || getEmpty(t2[i]);\n            tt2 = t2[i] || getEmpty(tt1);\n            if (tt1[0] != tt2[0] ||\n                tt1[0].toLowerCase() == \"r\" && (tt1[2] != tt2[2] || tt1[3] != tt2[3]) ||\n                tt1[0].toLowerCase() == \"s\" && (tt1[3] != tt2[3] || tt1[4] != tt2[4])\n                ) {\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            from[i] = [];\n            to[i] = [];\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        return {\n            from: path2array(from),\n            to: path2array(to),\n            f: getPath(from)\n        };\n    }\n    function getNumber(val) {\n        return val;\n    }\n    function getUnit(unit) {\n        return function (val) {\n            return +val.toFixed(3) + unit;\n        };\n    }\n    function getViewBox(val) {\n        return val.join(\" \");\n    }\n    function getColour(clr) {\n        return Snap.rgb(clr[0], clr[1], clr[2], clr[3]);\n    }\n    function getPath(path) {\n        var k = 0, i, ii, j, jj, out, a, b = [];\n        for (i = 0, ii = path.length; i < ii; i++) {\n            out = \"[\";\n            a = ['\"' + path[i][0] + '\"'];\n            for (j = 1, jj = path[i].length; j < jj; j++) {\n                a[j] = \"val[\" + k++ + \"]\";\n            }\n            out += a + \"]\";\n            b[i] = out;\n        }\n        return Function(\"val\", \"return Snap.path.toString.call([\" + b + \"])\");\n    }\n    function path2array(path) {\n        var out = [];\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        return out;\n    }\n    function isNumeric(obj) {\n        return isFinite(obj);\n    }\n    function arrayEqual(arr1, arr2) {\n        if (!Snap.is(arr1, \"array\") || !Snap.is(arr2, \"array\")) {\n            return false;\n        }\n        return arr1.toString() == arr2.toString();\n    }\n    Element.prototype.equal = function (name, b) {\n        return eve(\"snap.util.equal\", this, name, b).firstDefined();\n    };\n    eve.on(\"snap.util.equal\", function (name, b) {\n        var A, B, a = Str(this.attr(name) || \"\"),\n            el = this;\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        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        if (name == \"transform\" || name == \"gradientTransform\" || name == \"patternTransform\") {\n            if (typeof b == \"string\") {\n                b = Str(b).replace(/\\.{3}|\\u2026/g, a);\n            }\n            a = this.matrix;\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            return equaliseTransform(a, b, function () {\n                return el.getBBox(1);\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        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 (val) { return val; }\n            };\n        }\n        if (isNumeric(a) && isNumeric(b)) {\n            return {\n                from: parseFloat(a),\n                to: parseFloat(b),\n                f: getNumber\n            };\n        }\n        var aUnit = a.match(reUnit),\n            bUnit = Str(b).match(reUnit);\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});\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.\nSnap.plugin(function (Snap, Element, Paper, glob) {\n    var elproto = Element.prototype,\n    has = \"hasOwnProperty\",\n    supportsTouch = \"createTouch\" in glob.doc,\n    events = [\n        \"click\", \"dblclick\", \"mousedown\", \"mousemove\", \"mouseout\",\n        \"mouseover\", \"mouseup\", \"touchstart\", \"touchmove\", \"touchend\",\n        \"touchcancel\"\n    ],\n    touchMap = {\n        mousedown: \"touchstart\",\n        mousemove: \"touchmove\",\n        mouseup: \"touchend\"\n    },\n    getScroll = function (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 () {\n        this.returnValue = false;\n    },\n    preventTouch = function () {\n        return this.originalEvent.preventDefault();\n    },\n    stopPropagation = function () {\n        this.cancelBubble = true;\n    },\n    stopTouch = function () {\n        return this.originalEvent.stopPropagation();\n    },\n    addEvent = function (obj, type, fn, element) {\n        var realName = supportsTouch && touchMap[type] ? touchMap[type] : type,\n            f = function (e) {\n                var scrollY = getScroll(\"y\", element),\n                    scrollX = getScroll(\"x\", element);\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                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\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 (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        while (j--) {\n            dragi = drag[j];\n            if (supportsTouch) {\n                var i = e.touches && e.touches.length,\n                    touch;\n                while (i--) {\n                    touch = e.touches[i];\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            var node = dragi.el.node,\n                o,\n                next = node.nextSibling,\n                parent = node.parentNode,\n                display = node.style.display;\n            // 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            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 (e) {\n        Snap.unmousemove(dragMove).unmouseup(dragUp);\n        var i = drag.length,\n            dragi;\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        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     * 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     * 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     * 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     * 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     * 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     * 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     * 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     * 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     * 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     * 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     * 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    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++) if (this.events[i].name == eventName) {\n                        try {\n                            this.events[i].f.call(this);\n                        } catch (e) {}\n                    }\n                }\n                return this;\n            };\n            Snap[\"un\" + eventName] =\n            elproto[\"un\" + eventName] = function (fn) {\n                var events = this.events || [],\n                    l = events.length;\n                while (l--) if (events[l].name == eventName &&\n                               (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                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    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    elproto.unhover = function (f_in, f_out) {\n        return this.unmouseover(f_in).unmouseout(f_out);\n    };\n    var draggable = [];\n    // 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     * 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    elproto.drag = function (onmove, onstart, onend, move_scope, start_scope, end_scope) {\n        var el = this;\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        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({el: el, move_scope: move_scope, start_scope: start_scope, end_scope: end_scope});\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        function init(e, x, y) {\n            eve(\"snap.draginit.\" + el.id, el, e, x, y);\n        }\n        eve.on(\"snap.draginit.\" + el.id, start);\n        el._drag = {};\n        draggable.push({el: el, start: start, init: init});\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     * Element.undrag\n     [ method ]\n     **\n     * Removes all drag event handlers from the given element\n    \\*/\n    elproto.undrag = function () {\n        var i = draggable.length;\n        while (i--) 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        !draggable.length && Snap.unmousemove(dragMove).unmouseup(dragUp);\n        return this;\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.\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    pproto.filter = function (filstr) {\n        var paper = this;\n        if (paper.type != \"svg\") {\n            paper = paper.paper;\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        $(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        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            if (!id) {\n                $(value.node, {id: value.id});\n                id = value.id;\n            }\n            $(this.node, {\n                filter: Snap.url(id)\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    Snap.filter.blur = function (x, y) {\n        if (x == null) {\n            x = 2;\n        }\n        var def = y == null ? x : [x, y];\n        return Snap.format('\\<feGaussianBlur stdDeviation=\"{def}\"/>', {\n            def: def\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    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        if (blur == null) {\n            blur = 4;\n        }\n        if (opacity == null) {\n            opacity = 1;\n        }\n        if (dx == null) {\n            dx = 0;\n            dy = 2;\n        }\n        if (dy == null) {\n            dy = dx;\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    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    Snap.filter.grayscale = function (amount) {\n        if (amount == null) {\n            amount = 1;\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    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    Snap.filter.sepia = function (amount) {\n        if (amount == null) {\n            amount = 1;\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    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    Snap.filter.saturate = function (amount) {\n        if (amount == null) {\n            amount = 1;\n        }\n        return Snap.format('<feColorMatrix type=\"saturate\" values=\"{amount}\"/>', {\n            amount: 1 - amount\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    Snap.filter.hueRotate = function (angle) {\n        angle = angle || 0;\n        return Snap.format('<feColorMatrix type=\"hueRotate\" values=\"{angle}\"/>', {\n            angle: angle\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    Snap.filter.invert = function (amount) {\n        if (amount == null) {\n            amount = 1;\n        }\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        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    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    Snap.filter.brightness = function (amount) {\n        if (amount == null) {\n            amount = 1;\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    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    Snap.filter.contrast = function (amount) {\n        if (amount == null) {\n            amount = 1;\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    Snap.filter.contrast.toString = function () {\n        return this();\n    };\n});\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.\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 () {\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    Element.prototype.getAlign = function (el, way) {\n        if (way == null && is(el, \"string\")) {\n            way = el;\n            el = null;\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        switch (way) {\n            case \"t\":\n                out.dx = 0;\n                out.dy = bx.y - bb.y;\n            break;\n            case \"b\":\n                out.dx = 0;\n                out.dy = bx.y2 - bb.y2;\n            break;\n            case \"m\":\n                out.dx = 0;\n                out.dy = bx.cy - bb.cy;\n            break;\n            case \"l\":\n                out.dx = bx.x - bb.x;\n                out.dy = 0;\n            break;\n            case \"r\":\n                out.dx = bx.x2 - bb.x2;\n                out.dy = 0;\n            break;\n            default:\n                out.dx = bx.cx - bb.cx;\n                out.dy = 0;\n            break;\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    Element.prototype.align = function (el, way) {\n        return this.transform(\"...\" + this.getAlign(el, way));\n    };\n});\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.\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    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    Snap.flat = {};\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        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        return color;\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    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});\n\nreturn Snap;\n}));\n}.call(window));","'use strict';\n\n(function () {\n  var out$ = typeof exports != 'undefined' && exports || typeof define != 'undefined' && {} || this || window;\n  if (typeof define !== 'undefined') define('save-svg-as-png', [], function () {\n    return out$;\n  });\n  out$.default = out$;\n\n  var xmlNs = 'http://www.w3.org/2000/xmlns/';\n  var xhtmlNs = 'http://www.w3.org/1999/xhtml';\n  var svgNs = 'http://www.w3.org/2000/svg';\n  var doctype = '<?xml version=\"1.0\" standalone=\"no\"?><!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\" [<!ENTITY nbsp \"&#160;\">]>';\n  var urlRegex = /url\\([\"']?(.+?)[\"']?\\)/;\n  var fontFormats = {\n    woff2: 'font/woff2',\n    woff: 'font/woff',\n    otf: 'application/x-font-opentype',\n    ttf: 'application/x-font-ttf',\n    eot: 'application/vnd.ms-fontobject',\n    sfnt: 'application/font-sfnt',\n    svg: 'image/svg+xml'\n  };\n\n  var isElement = function isElement(obj) {\n    return obj instanceof HTMLElement || obj instanceof SVGElement;\n  };\n  var requireDomNode = function requireDomNode(el) {\n    if (!isElement(el)) throw new Error('an HTMLElement or SVGElement is required; got ' + el);\n  };\n  var requireDomNodePromise = function requireDomNodePromise(el) {\n    return new Promise(function (resolve, reject) {\n      if (isElement(el)) resolve(el);else reject(new Error('an HTMLElement or SVGElement is required; got ' + el));\n    });\n  };\n  var isExternal = function isExternal(url) {\n    return url && url.lastIndexOf('http', 0) === 0 && url.lastIndexOf(window.location.host) === -1;\n  };\n\n  var getFontMimeTypeFromUrl = function getFontMimeTypeFromUrl(fontUrl) {\n    var formats = Object.keys(fontFormats).filter(function (extension) {\n      return fontUrl.indexOf('.' + extension) > 0;\n    }).map(function (extension) {\n      return fontFormats[extension];\n    });\n    if (formats) return formats[0];\n    console.error('Unknown font format for ' + fontUrl + '. Fonts may not be working correctly.');\n    return 'application/octet-stream';\n  };\n\n  var arrayBufferToBase64 = function arrayBufferToBase64(buffer) {\n    var binary = '';\n    var bytes = new Uint8Array(buffer);\n    for (var i = 0; i < bytes.byteLength; i++) {\n      binary += String.fromCharCode(bytes[i]);\n    }return window.btoa(binary);\n  };\n\n  var getDimension = function getDimension(el, clone, dim) {\n    var v = el.viewBox && el.viewBox.baseVal && el.viewBox.baseVal[dim] || clone.getAttribute(dim) !== null && !clone.getAttribute(dim).match(/%$/) && parseInt(clone.getAttribute(dim)) || el.getBoundingClientRect()[dim] || parseInt(clone.style[dim]) || parseInt(window.getComputedStyle(el).getPropertyValue(dim));\n    return typeof v === 'undefined' || v === null || isNaN(parseFloat(v)) ? 0 : v;\n  };\n\n  var getDimensions = function getDimensions(el, clone, width, height) {\n    if (el.tagName === 'svg') return {\n      width: width || getDimension(el, clone, 'width'),\n      height: height || getDimension(el, clone, 'height')\n    };else if (el.getBBox) {\n      var _el$getBBox = el.getBBox(),\n          x = _el$getBBox.x,\n          y = _el$getBBox.y,\n          _width = _el$getBBox.width,\n          _height = _el$getBBox.height;\n\n      return {\n        width: x + _width,\n        height: y + _height\n      };\n    }\n  };\n\n  var reEncode = function reEncode(data) {\n    return decodeURIComponent(encodeURIComponent(data).replace(/%([0-9A-F]{2})/g, function (match, p1) {\n      var c = String.fromCharCode('0x' + p1);\n      return c === '%' ? '%25' : c;\n    }));\n  };\n\n  var uriToBlob = function uriToBlob(uri) {\n    var byteString = window.atob(uri.split(',')[1]);\n    var mimeString = uri.split(',')[0].split(':')[1].split(';')[0];\n    var buffer = new ArrayBuffer(byteString.length);\n    var intArray = new Uint8Array(buffer);\n    for (var i = 0; i < byteString.length; i++) {\n      intArray[i] = byteString.charCodeAt(i);\n    }\n    return new Blob([buffer], { type: mimeString });\n  };\n\n  var query = function query(el, selector) {\n    if (!selector) return;\n    try {\n      return el.querySelector(selector) || el.parentNode && el.parentNode.querySelector(selector);\n    } catch (err) {\n      console.warn('Invalid CSS selector \"' + selector + '\"', err);\n    }\n  };\n\n  var detectCssFont = function detectCssFont(rule, href) {\n    // Match CSS font-face rules to external links.\n    // @font-face {\n    //   src: local('Abel'), url(https://fonts.gstatic.com/s/abel/v6/UzN-iejR1VoXU2Oc-7LsbvesZW2xOQ-xsNqO47m55DA.woff2);\n    // }\n    var match = rule.cssText.match(urlRegex);\n    var url = match && match[1] || '';\n    if (!url || url.match(/^data:/) || url === 'about:blank') return;\n    var fullUrl = url.startsWith('../') ? href + '/../' + url : url.startsWith('./') ? href + '/.' + url : url;\n    return {\n      text: rule.cssText,\n      format: getFontMimeTypeFromUrl(fullUrl),\n      url: fullUrl\n    };\n  };\n\n  var inlineImages = function inlineImages(el) {\n    return Promise.all(Array.from(el.querySelectorAll('image')).map(function (image) {\n      var href = image.getAttributeNS('http://www.w3.org/1999/xlink', 'href') || image.getAttribute('href');\n      if (!href) return Promise.resolve(null);\n      if (isExternal(href)) {\n        href += (href.indexOf('?') === -1 ? '?' : '&') + 't=' + new Date().valueOf();\n      }\n      return new Promise(function (resolve, reject) {\n        var canvas = document.createElement('canvas');\n        var img = new Image();\n        img.crossOrigin = 'anonymous';\n        img.src = href;\n        img.onerror = function () {\n          return reject(new Error('Could not load ' + href));\n        };\n        img.onload = function () {\n          canvas.width = img.width;\n          canvas.height = img.height;\n          canvas.getContext('2d').drawImage(img, 0, 0);\n          image.setAttributeNS('http://www.w3.org/1999/xlink', 'href', canvas.toDataURL('image/png'));\n          resolve(true);\n        };\n      });\n    }));\n  };\n\n  var cachedFonts = {};\n  var inlineFonts = function inlineFonts(fonts) {\n    return Promise.all(fonts.map(function (font) {\n      return new Promise(function (resolve, reject) {\n        if (cachedFonts[font.url]) return resolve(cachedFonts[font.url]);\n\n        var req = new XMLHttpRequest();\n        req.addEventListener('load', function () {\n          // TODO: it may also be worth it to wait until fonts are fully loaded before\n          // attempting to rasterize them. (e.g. use https://developer.mozilla.org/en-US/docs/Web/API/FontFaceSet)\n          var fontInBase64 = arrayBufferToBase64(req.response);\n          var fontUri = font.text.replace(urlRegex, 'url(\"data:' + font.format + ';base64,' + fontInBase64 + '\")') + '\\n';\n          cachedFonts[font.url] = fontUri;\n          resolve(fontUri);\n        });\n        req.addEventListener('error', function (e) {\n          console.warn('Failed to load font from: ' + font.url, e);\n          cachedFonts[font.url] = null;\n          resolve(null);\n        });\n        req.addEventListener('abort', function (e) {\n          console.warn('Aborted loading font from: ' + font.url, e);\n          resolve(null);\n        });\n        req.open('GET', font.url);\n        req.responseType = 'arraybuffer';\n        req.send();\n      });\n    })).then(function (fontCss) {\n      return fontCss.filter(function (x) {\n        return x;\n      }).join('');\n    });\n  };\n\n  var cachedRules = null;\n  var styleSheetRules = function styleSheetRules() {\n    if (cachedRules) return cachedRules;\n    return cachedRules = Array.from(document.styleSheets).map(function (sheet) {\n      try {\n        return { rules: sheet.cssRules, href: sheet.href };\n      } catch (e) {\n        console.warn('Stylesheet could not be loaded: ' + sheet.href, e);\n        return {};\n      }\n    });\n  };\n\n  var inlineCss = function inlineCss(el, options) {\n    var _ref = options || {},\n        selectorRemap = _ref.selectorRemap,\n        modifyStyle = _ref.modifyStyle,\n        modifyCss = _ref.modifyCss,\n        fonts = _ref.fonts,\n        excludeUnusedCss = _ref.excludeUnusedCss;\n\n    var generateCss = modifyCss || function (selector, properties) {\n      var sel = selectorRemap ? selectorRemap(selector) : selector;\n      var props = modifyStyle ? modifyStyle(properties) : properties;\n      return sel + '{' + props + '}\\n';\n    };\n    var css = [];\n    var detectFonts = typeof fonts === 'undefined';\n    var fontList = fonts || [];\n    styleSheetRules().forEach(function (_ref2) {\n      var rules = _ref2.rules,\n          href = _ref2.href;\n\n      if (!rules) return;\n      Array.from(rules).forEach(function (rule) {\n        if (typeof rule.style != 'undefined') {\n          if (query(el, rule.selectorText)) css.push(generateCss(rule.selectorText, rule.style.cssText));else if (detectFonts && rule.cssText.match(/^@font-face/)) {\n            var font = detectCssFont(rule, href);\n            if (font) fontList.push(font);\n          } else if (!excludeUnusedCss) {\n            css.push(rule.cssText);\n          }\n        }\n      });\n    });\n\n    return inlineFonts(fontList).then(function (fontCss) {\n      return css.join('\\n') + fontCss;\n    });\n  };\n\n  var downloadOptions = function downloadOptions() {\n    if (!navigator.msSaveOrOpenBlob && !('download' in document.createElement('a'))) {\n      return { popup: window.open() };\n    }\n  };\n\n  out$.prepareSvg = function (el, options, done) {\n    requireDomNode(el);\n\n    var _ref3 = options || {},\n        _ref3$left = _ref3.left,\n        left = _ref3$left === undefined ? 0 : _ref3$left,\n        _ref3$top = _ref3.top,\n        top = _ref3$top === undefined ? 0 : _ref3$top,\n        w = _ref3.width,\n        h = _ref3.height,\n        _ref3$scale = _ref3.scale,\n        scale = _ref3$scale === undefined ? 1 : _ref3$scale,\n        _ref3$responsive = _ref3.responsive,\n        responsive = _ref3$responsive === undefined ? false : _ref3$responsive,\n        _ref3$excludeCss = _ref3.excludeCss,\n        excludeCss = _ref3$excludeCss === undefined ? false : _ref3$excludeCss;\n\n    return inlineImages(el).then(function () {\n      var clone = el.cloneNode(true);\n      clone.style.backgroundColor = (options || {}).backgroundColor || el.style.backgroundColor;\n\n      var _getDimensions = getDimensions(el, clone, w, h),\n          width = _getDimensions.width,\n          height = _getDimensions.height;\n\n      if (el.tagName !== 'svg') {\n        if (el.getBBox) {\n          if (clone.getAttribute('transform') != null) {\n            clone.setAttribute('transform', clone.getAttribute('transform').replace(/translate\\(.*?\\)/, ''));\n          }\n          var svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');\n          svg.appendChild(clone);\n          clone = svg;\n        } else {\n          console.error('Attempted to render non-SVG element', el);\n          return;\n        }\n      }\n\n      clone.setAttribute('version', '1.1');\n      clone.setAttribute('viewBox', [left, top, width, height].join(' '));\n      if (!clone.getAttribute('xmlns')) clone.setAttributeNS(xmlNs, 'xmlns', svgNs);\n      if (!clone.getAttribute('xmlns:xlink')) clone.setAttributeNS(xmlNs, 'xmlns:xlink', 'http://www.w3.org/1999/xlink');\n\n      if (responsive) {\n        clone.removeAttribute('width');\n        clone.removeAttribute('height');\n        clone.setAttribute('preserveAspectRatio', 'xMinYMin meet');\n      } else {\n        clone.setAttribute('width', width * scale);\n        clone.setAttribute('height', height * scale);\n      }\n\n      Array.from(clone.querySelectorAll('foreignObject > *')).forEach(function (foreignObject) {\n        foreignObject.setAttributeNS(xmlNs, 'xmlns', foreignObject.tagName === 'svg' ? svgNs : xhtmlNs);\n      });\n\n      if (excludeCss) {\n        var outer = document.createElement('div');\n        outer.appendChild(clone);\n        var src = outer.innerHTML;\n        if (typeof done === 'function') done(src, width, height);else return { src: src, width: width, height: height };\n      } else {\n        return inlineCss(el, options).then(function (css) {\n          var style = document.createElement('style');\n          style.setAttribute('type', 'text/css');\n          style.innerHTML = '<![CDATA[\\n' + css + '\\n]]>';\n\n          var defs = document.createElement('defs');\n          defs.appendChild(style);\n          clone.insertBefore(defs, clone.firstChild);\n\n          var outer = document.createElement('div');\n          outer.appendChild(clone);\n          var src = outer.innerHTML.replace(/NS\\d+:href/gi, 'xmlns:xlink=\"http://www.w3.org/1999/xlink\" xlink:href');\n\n          if (typeof done === 'function') done(src, width, height);else return { src: src, width: width, height: height };\n        });\n      }\n    });\n  };\n\n  out$.svgAsDataUri = function (el, options, done) {\n    requireDomNode(el);\n    return out$.prepareSvg(el, options).then(function (_ref4) {\n      var src = _ref4.src,\n          width = _ref4.width,\n          height = _ref4.height;\n\n      var svgXml = 'data:image/svg+xml;base64,' + window.btoa(reEncode(doctype + src));\n      if (typeof done === 'function') {\n        done(svgXml, width, height);\n      }\n      return svgXml;\n    });\n  };\n\n  out$.svgAsPngUri = function (el, options, done) {\n    requireDomNode(el);\n\n    var _ref5 = options || {},\n        _ref5$encoderType = _ref5.encoderType,\n        encoderType = _ref5$encoderType === undefined ? 'image/png' : _ref5$encoderType,\n        _ref5$encoderOptions = _ref5.encoderOptions,\n        encoderOptions = _ref5$encoderOptions === undefined ? 0.8 : _ref5$encoderOptions,\n        canvg = _ref5.canvg;\n\n    var convertToPng = function convertToPng(_ref6) {\n      var src = _ref6.src,\n          width = _ref6.width,\n          height = _ref6.height;\n\n      var canvas = document.createElement('canvas');\n      var context = canvas.getContext('2d');\n      var pixelRatio = window.devicePixelRatio || 1;\n\n      canvas.width = width * pixelRatio;\n      canvas.height = height * pixelRatio;\n      canvas.style.width = canvas.width + 'px';\n      canvas.style.height = canvas.height + 'px';\n      context.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);\n\n      if (canvg) canvg(canvas, src);else context.drawImage(src, 0, 0);\n\n      var png = void 0;\n      try {\n        png = canvas.toDataURL(encoderType, encoderOptions);\n      } catch (e) {\n        if (typeof SecurityError !== 'undefined' && e instanceof SecurityError || e.name === 'SecurityError') {\n          console.error('Rendered SVG images cannot be downloaded in this browser.');\n          return;\n        } else throw e;\n      }\n      if (typeof done === 'function') done(png, canvas.width, canvas.height);\n      return Promise.resolve(png);\n    };\n\n    if (canvg) return out$.prepareSvg(el, options).then(convertToPng);else return out$.svgAsDataUri(el, options).then(function (uri) {\n      return new Promise(function (resolve, reject) {\n        var image = new Image();\n        image.onload = function () {\n          return resolve(convertToPng({\n            src: image,\n            width: image.width,\n            height: image.height\n          }));\n        };\n        image.onerror = function () {\n          reject('There was an error loading the data URI as an image on the following SVG\\n' + window.atob(uri.slice(26)) + 'Open the following link to see browser\\'s diagnosis\\n' + uri);\n        };\n        image.src = uri;\n      });\n    });\n  };\n\n  out$.download = function (name, uri, options) {\n    if (navigator.msSaveOrOpenBlob) navigator.msSaveOrOpenBlob(uriToBlob(uri), name);else {\n      var saveLink = document.createElement('a');\n      if ('download' in saveLink) {\n        saveLink.download = name;\n        saveLink.style.display = 'none';\n        document.body.appendChild(saveLink);\n        try {\n          var blob = uriToBlob(uri);\n          var url = URL.createObjectURL(blob);\n          saveLink.href = url;\n          saveLink.onclick = function () {\n            return requestAnimationFrame(function () {\n              return URL.revokeObjectURL(url);\n            });\n          };\n        } catch (e) {\n          console.error(e);\n          console.warn('Error while getting object URL. Falling back to string URL.');\n          saveLink.href = uri;\n        }\n        saveLink.click();\n        document.body.removeChild(saveLink);\n      } else if (options && options.popup) {\n        options.popup.document.title = name;\n        options.popup.location.replace(uri);\n      }\n    }\n  };\n\n  out$.saveSvg = function (el, name, options) {\n    var downloadOpts = downloadOptions(); // don't inline, can't be async\n    return requireDomNodePromise(el).then(function (el) {\n      return out$.svgAsDataUri(el, options || {});\n    }).then(function (uri) {\n      return out$.download(name, uri, downloadOpts);\n    });\n  };\n\n  out$.saveSvgAsPng = function (el, name, options) {\n    var downloadOpts = downloadOptions(); // don't inline, can't be async\n    return requireDomNodePromise(el).then(function (el) {\n      return out$.svgAsPngUri(el, options || {});\n    }).then(function (uri) {\n      return out$.download(name, uri, downloadOpts);\n    });\n  };\n})();"],"sourceRoot":""}