{"version":3,"file":"777cf710-a6e3bd448a26e9b326b0.js","mappings":"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","sources":["webpack://bradient-js/./node_modules/snapsvg-cjs/dist/snap.svg-cjs.js"],"sourcesContent":["require(\"core-js/modules/es.array.flat.js\");\nrequire(\"core-js/modules/es.array.unscopables.flat.js\");\nwindow.eve = require('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 || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.oRequestAnimationFrame || window.msRequestAnimationFrame || function (callback) {\n      setTimeout(callback, 16, new Date().getTime());\n      return true;\n    },\n    requestID,\n    isArray = Array.isArray || function (a) {\n      return a instanceof Array || Object.prototype.toString.call(a) == \"[object Array]\";\n    },\n    idgen = 0,\n    idprefix = \"M\" + (+new Date()).toString(36),\n    ID = function ID() {\n      return idprefix + (idgen++).toString(36);\n    },\n    diff = function diff(a, b, A, B) {\n      if (isArray(a)) {\n        res = [];\n        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 sta(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 speed(val) {\n      var a = this;\n      if (val == null) {\n        return a.spd;\n      }\n      a.spd = val;\n    },\n    duration = function duration(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 stopit() {\n      var a = this;\n      delete animations[a.id];\n      a.update();\n      eve(\"mina.stop.\" + a.id, a);\n    },\n    pause = function pause() {\n      var a = this;\n      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 resume() {\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 update() {\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] + (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 frame(timeStamp) {\n      // Manual invokation?\n      if (!timeStamp) {\n        // Frame loop stopped?\n        if (!requestID) {\n          // Start frame loop...\n          requestID = requestAnimFrame(frame);\n        }\n        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 mina(a, A, b, B, get, set, easing) {\n      var anim = {\n        id: ID(),\n        start: a,\n        end: A,\n        b: b,\n        s: 0,\n        dur: B - b,\n        spd: 1,\n        get: get,\n        set: set,\n        easing: easing || mina.linear,\n        status: sta,\n        speed: speed,\n        duration: duration,\n        stop: stopit,\n        pause: pause,\n        resume: resume,\n        update: update\n      };\n      animations[anim.id] = anim;\n      var len = 0,\n        i;\n      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) * (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) {\n  Snap.version = \"0.5.1\";\n  /*\\\n   * Snap\n   [ method ]\n   **\n   * Creates a drawing surface or wraps existing SVG element.\n   **\n   - width (number|string) width of surface\n   - height (number|string) height of surface\n   * or\n   - DOM (SVGElement) element to be wrapped into Snap structure\n   * or\n   - array (array) array of elements (will return set of elements)\n   * or\n   - query (string) CSS query selector\n   = (object) @Element\n  \\*/\n  function 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  }\n  Snap.toString = function () {\n    return \"Snap v\" + this.version;\n  };\n  Snap._ = {};\n  var glob = {\n    win: root.window,\n    doc: root.window.document\n  };\n  Snap._.glob = glob;\n  var has = \"hasOwnProperty\",\n    Str = String,\n    toFloat = parseFloat,\n    toInt = parseInt,\n    math = Math,\n    mmax = math.max,\n    mmin = math.min,\n    abs = math.abs,\n    pow = math.pow,\n    PI = math.PI,\n    round = math.round,\n    E = \"\",\n    S = \" \",\n    objectToString = Object.prototype.toString,\n    ISURL = /^url\\(['\"]?([^\\)]+?)['\"]?\\)$/i,\n    colourRegExp = /^\\s*((#[a-f\\d]{6})|(#[a-f\\d]{3})|rgba?\\(\\s*([\\d\\.]+%?\\s*,\\s*[\\d\\.]+%?\\s*,\\s*[\\d\\.]+%?(?:\\s*,\\s*[\\d\\.]+%?)?)\\s*\\)|hsba?\\(\\s*([\\d\\.]+(?:deg|\\xb0|%)?\\s*,\\s*[\\d\\.]+%?\\s*,\\s*[\\d\\.]+(?:%?\\s*,\\s*[\\d\\.]+)?%?)\\s*\\)|hsla?\\(\\s*([\\d\\.]+(?:deg|\\xb0|%)?\\s*,\\s*[\\d\\.]+%?\\s*,\\s*[\\d\\.]+(?:%?\\s*,\\s*[\\d\\.]+)?%?)\\s*\\))\\s*$/i,\n    bezierrg = /^(?:cubic-)?bezier\\(([^,]+),([^,]+),([^,]+),([^\\)]+)\\)/,\n    separator = Snap._.separator = /[,\\s]+/,\n    whitespace = /[\\s]/g,\n    commaSpaces = /[\\s]*,[\\s]*/,\n    hsrg = {\n      hs: 1,\n      rg: 1\n    },\n    pathCommand = /([a-z])[\\s,]*((-?\\d*\\.?\\d*(?:e[\\-+]?\\d+)?[\\s]*,?[\\s]*)+)/ig,\n    tCommand = /([rstm])[\\s,]*((-?\\d*\\.?\\d*(?:e[\\-+]?\\d+)?[\\s]*,?[\\s]*)+)/ig,\n    pathValues = /(-?\\d*\\.?\\d*(?:e[\\-+]?\\d+)?)[\\s]*,?[\\s]*/ig,\n    idgen = 0,\n    idprefix = \"S\" + (+new Date()).toString(36),\n    ID = function ID(el) {\n      return (el && el.type ? el.type : E) + idprefix + (idgen++).toString(36);\n    },\n    xlink = \"http://www.w3.org/1999/xlink\",\n    xmlns = \"http://www.w3.org/2000/svg\",\n    hub = {},\n    /*\\\n     * 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  function $(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  }\n  Snap._.$ = $;\n  Snap._.id = ID;\n  function 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  }\n  function is(o, type) {\n    type = Str.prototype.toLowerCase.call(type);\n    if (type == \"finite\") {\n      return isFinite(o);\n    }\n    if (type == \"array\" && (o instanceof Array || Array.isArray && Array.isArray(o))) {\n      return true;\n    }\n    return type == \"null\" && o === null || type == typeof o && o !== null || type == \"object\" && o === Object(o) || objectToString.call(o).slice(8, -1).toLowerCase() == type;\n  }\n  /*\\\n   * Snap.format\n   [ method ]\n   **\n   * Replaces construction of type `{<name>}` to the corresponding argument\n   **\n   - token (string) string to format\n   - json (object) object which properties are used as a replacement\n   = (string) formatted string\n   > Usage\n   | // this draws a rectangular shape equivalent to \"M10,20h40v50h-40z\"\n   | paper.path(Snap.format(\"M{x},{y}h{dim.width}v{dim.height}h{dim['negative width']}z\", {\n   |     x: 10,\n   |     y: 20,\n   |     dim: {\n   |         width: 40,\n   |         height: 50,\n   |         \"negative width\": -40\n   |     }\n   | }));\n  \\*/\n  Snap.format = function () {\n    var tokenRegex = /\\{([^\\}]+)\\}/g,\n      objNotationRegex = /(?:(?:^|\\.)(.+?)(?=\\[|\\.|$|\\()|\\[('|\")(.+?)\\2\\])(\\(\\))?/g,\n      // matches .xxxxx or [\"xxxxx\"] to run over object properties\n      replacer = function replacer(all, key, obj) {\n        var res = obj;\n        key.replace(objNotationRegex, function (all, name, quote, quotedName, isFunc) {\n          name = name || quotedName;\n          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  }();\n  function 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  }\n  Snap._.clone = clone;\n  function 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  }\n  function cacher(f, scope, postprocessor) {\n    function newf() {\n      var arg = Array.prototype.slice.call(arguments, 0),\n        args = arg.join(\"\\u2400\"),\n        cache = newf.cache = newf.cache || {},\n        count = newf.count = newf.count || [];\n      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  }\n  Snap._.cacher = cacher;\n  function 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  }\n  function rad(deg) {\n    return deg % 360 * PI / 180;\n  }\n  function deg(rad) {\n    return rad * 180 / PI % 360;\n  }\n  function x_y() {\n    return this.x + S + this.y;\n  }\n  function 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  \\*/\n  Snap.rad = rad;\n  /*\\\n   * Snap.deg\n   [ method ]\n   **\n   * Transform angle to degrees\n   - rad (number) angle in radians\n   = (number) angle in degrees\n  \\*/\n  Snap.deg = deg;\n  /*\\\n   * Snap.sin\n   [ method ]\n   **\n   * Equivalent to `Math.sin()` only works with degrees, not radians.\n   - angle (number) angle in degrees\n   = (number) sin\n  \\*/\n  Snap.sin = function (angle) {\n    return math.sin(Snap.rad(angle));\n  };\n  /*\\\n   * Snap.tan\n   [ method ]\n   **\n   * Equivalent to `Math.tan()` only works with degrees, not radians.\n   - angle (number) angle in degrees\n   = (number) tan\n  \\*/\n  Snap.tan = function (angle) {\n    return math.tan(Snap.rad(angle));\n  };\n  /*\\\n   * Snap.cos\n   [ method ]\n   **\n   * Equivalent to `Math.cos()` only works with degrees, not radians.\n   - angle (number) angle in degrees\n   = (number) cos\n  \\*/\n  Snap.cos = function (angle) {\n    return math.cos(Snap.rad(angle));\n  };\n  /*\\\n   * Snap.asin\n   [ method ]\n   **\n   * Equivalent to `Math.asin()` only works with degrees, not radians.\n   - num (number) value\n   = (number) asin in degrees\n  \\*/\n  Snap.asin = function (num) {\n    return Snap.deg(math.asin(num));\n  };\n  /*\\\n   * Snap.acos\n   [ method ]\n   **\n   * Equivalent to `Math.acos()` only works with degrees, not radians.\n   - num (number) value\n   = (number) acos in degrees\n  \\*/\n  Snap.acos = function (num) {\n    return Snap.deg(math.acos(num));\n  };\n  /*\\\n   * Snap.atan\n   [ method ]\n   **\n   * Equivalent to `Math.atan()` only works with degrees, not radians.\n   - num (number) value\n   = (number) atan in degrees\n  \\*/\n  Snap.atan = function (num) {\n    return Snap.deg(math.atan(num));\n  };\n  /*\\\n   * Snap.atan2\n   [ method ]\n   **\n   * Equivalent to `Math.atan2()` only works with degrees, not radians.\n   - num (number) value\n   = (number) atan2 in degrees\n  \\*/\n  Snap.atan2 = function (num) {\n    return Snap.deg(math.atan2(num));\n  };\n  /*\\\n   * Snap.angle\n   [ method ]\n   **\n   * Returns an angle between two or three points\n   - x1 (number) x coord of first point\n   - y1 (number) y coord of first point\n   - x2 (number) x coord of second point\n   - y2 (number) y coord of second point\n   - x3 (number) #optional x coord of third point\n   - y3 (number) #optional y coord of third point\n   = (number) angle in degrees\n  \\*/\n  Snap.angle = angle;\n  /*\\\n   * Snap.len\n   [ method ]\n   **\n   * Returns distance between two points\n   - x1 (number) x coord of first point\n   - y1 (number) y coord of first point\n   - x2 (number) x coord of second point\n   - y2 (number) y coord of second point\n   = (number) distance\n  \\*/\n  Snap.len = function (x1, y1, x2, y2) {\n    return Math.sqrt(Snap.len2(x1, y1, x2, y2));\n  };\n  /*\\\n   * Snap.len2\n   [ method ]\n   **\n   * Returns squared distance between two points\n   - x1 (number) x coord of first point\n   - y1 (number) y coord of first point\n   - x2 (number) x coord of second point\n   - y2 (number) y coord of second point\n   = (number) distance\n  \\*/\n  Snap.len2 = function (x1, y1, x2, y2) {\n    return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);\n  };\n  /*\\\n   * Snap.closestPoint\n   [ method ]\n   **\n   * Returns closest point to a given one on a given path.\n   - path (Element) path element\n   - x (number) x coord of a point\n   - y (number) y coord of a point\n   = (object) in format\n   {\n      x (number) x coord of the point on the path\n      y (number) y coord of the point on the path\n      length (number) length of the path to the point\n      distance (number) distance from the given point to the path\n   }\n  \\*/\n  // Copied from http://bl.ocks.org/mbostock/8027637\n  Snap.closestPoint = function (path, x, y) {\n    function distance2(p) {\n      var dx = p.x - x,\n        dy = p.y - y;\n      return dx * dx + dy * dy;\n    }\n    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, after, beforeLength, afterLength, beforeDistance, 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    best = {\n      x: best.x,\n      y: best.y,\n      length: bestLength,\n      distance: Math.sqrt(bestDistance)\n    };\n    return best;\n  };\n  /*\\\n   * Snap.is\n   [ method ]\n   **\n   * Handy replacement for the `typeof` operator\n   - o (…) any object or primitive\n   - type (string) name of the type, e.g., `string`, `function`, `number`, etc.\n   = (boolean) `true` if given value is of given type\n  \\*/\n  Snap.is = is;\n  /*\\\n   * Snap.snapTo\n   [ method ]\n   **\n   * Snaps given value to given grid\n   - values (array|number) given array of values or step of the grid\n   - value (number) value to adjust\n   - tolerance (number) #optional maximum distance to the target value that would trigger the snap. Default is `10`.\n   = (number) adjusted value\n  \\*/\n  Snap.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  \\*/\n  Snap.getRGB = cacher(function (colour) {\n    if (!colour || !!((colour = Str(colour)).indexOf(\"-\") + 1)) {\n      return {\n        r: -1,\n        g: -1,\n        b: -1,\n        hex: \"none\",\n        error: 1,\n        toString: rgbtoString\n      };\n    }\n    if (colour == \"none\") {\n      return {\n        r: -1,\n        g: -1,\n        b: -1,\n        hex: \"none\",\n        toString: rgbtoString\n      };\n    }\n    !(hsrg[has](colour.toLowerCase().substring(0, 2)) || colour.charAt() == \"#\") && (colour = _toHex(colour));\n    if (!colour) {\n      return {\n        r: -1,\n        g: -1,\n        b: -1,\n        hex: \"none\",\n        error: 1,\n        toString: rgbtoString\n      };\n    }\n    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 = {\n        r: red,\n        g: green,\n        b: blue,\n        toString: rgbtoString\n      };\n      rgb.hex = \"#\" + (16777216 | blue | green << 8 | red << 16).toString(16).slice(1);\n      rgb.opacity = is(opacity, \"finite\") ? opacity : 1;\n      return rgb;\n    }\n    return {\n      r: -1,\n      g: -1,\n      b: -1,\n      hex: \"none\",\n      error: 1,\n      toString: rgbtoString\n    };\n  }, Snap);\n  /*\\\n   * Snap.hsb\n   [ method ]\n   **\n   * Converts HSB values to a hex representation of the color\n   - h (number) hue\n   - s (number) saturation\n   - b (number) value or brightness\n   = (string) hex representation of the color\n  \\*/\n  Snap.hsb = cacher(function (h, s, b) {\n    return Snap.hsb2rgb(h, s, b).hex;\n  });\n  /*\\\n   * Snap.hsl\n   [ method ]\n   **\n   * Converts HSL values to a hex representation of the color\n   - h (number) hue\n   - s (number) saturation\n   - l (number) luminosity\n   = (string) hex representation of the color\n  \\*/\n  Snap.hsl = cacher(function (h, s, l) {\n    return Snap.hsl2rgb(h, s, l).hex;\n  });\n  /*\\\n   * Snap.rgb\n   [ method ]\n   **\n   * Converts RGB values to a hex representation of the color\n   - r (number) red\n   - g (number) green\n   - b (number) blue\n   = (string) hex representation of the color\n  \\*/\n  Snap.rgb = cacher(function (r, g, b, o) {\n    if (is(o, \"finite\")) {\n      var round = math.round;\n      return \"rgba(\" + [round(r), round(g), round(b), +o.toFixed(2)] + \")\";\n    }\n    return \"#\" + (16777216 | b | g << 8 | r << 16).toString(16).slice(1);\n  });\n  var _toHex = function toHex(color) {\n      var i = glob.doc.getElementsByTagName(\"head\")[0] || glob.doc.getElementsByTagName(\"svg\")[0],\n        red = \"rgb(255, 0, 0)\";\n      _toHex = cacher(function (color) {\n        if (color.toLowerCase() == \"red\") {\n          return red;\n        }\n        i.style.color = red;\n        i.style.color = color;\n        var out = glob.doc.defaultView.getComputedStyle(i, E).getPropertyValue(\"color\");\n        return out == red ? null : out;\n      });\n      return _toHex(color);\n    },\n    hsbtoString = function hsbtoString() {\n      return \"hsb(\" + [this.h, this.s, this.b] + \")\";\n    },\n    hsltoString = function hsltoString() {\n      return \"hsl(\" + [this.h, this.s, this.l] + \")\";\n    },\n    rgbtoString = function rgbtoString() {\n      return this.opacity == 1 || this.opacity == null ? this.hex : \"rgba(\" + [this.r, this.g, this.b, this.opacity] + \")\";\n    },\n    prepareRGB = function prepareRGB(r, g, b) {\n      if (g == null && is(r, \"object\") && \"r\" in r && \"g\" in r && \"b\" in r) {\n        b = r.b;\n        g = r.g;\n        r = r.r;\n      }\n      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      return [r, g, b];\n    },\n    packageRGB = function packageRGB(r, g, b, o) {\n      r = math.round(r * 255);\n      g = math.round(g * 255);\n      b = math.round(b * 255);\n      var rgb = {\n        r: r,\n        g: g,\n        b: b,\n        opacity: is(o, \"finite\") ? o : 1,\n        hex: Snap.rgb(r, g, b),\n        toString: rgbtoString\n      };\n      is(o, \"finite\") && (rgb.opacity = o);\n      return rgb;\n    };\n  /*\\\n   * Snap.color\n   [ method ]\n   **\n   * Parses the color string and returns an object featuring the color's component values\n   - clr (string) color string in one of the supported formats (see @Snap.getRGB)\n   = (object) Combined RGB/HSB object in the following format:\n   o {\n   o     r (number) red,\n   o     g (number) green,\n   o     b (number) blue,\n   o     hex (string) color in HTML/CSS format: #••••••,\n   o     error (boolean) `true` if string can't be parsed,\n   o     h (number) hue,\n   o     s (number) saturation,\n   o     v (number) value (brightness),\n   o     l (number) lightness\n   o }\n  \\*/\n  Snap.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 = {\n          hex: \"none\"\n        };\n        clr.r = clr.g = clr.b = clr.h = clr.s = clr.v = clr.l = -1;\n        clr.error = 1;\n      }\n    }\n    clr.toString = rgbtoString;\n    return clr;\n  };\n  /*\\\n   * Snap.hsb2rgb\n   [ method ]\n   **\n   * Converts HSB values to an RGB object\n   - h (number) hue\n   - s (number) saturation\n   - v (number) value or brightness\n   = (object) RGB object in the following format:\n   o {\n   o     r (number) red,\n   o     g (number) green,\n   o     b (number) blue,\n   o     hex (string) color in HTML/CSS format: #••••••\n   o }\n  \\*/\n  Snap.hsb2rgb = function (h, s, v, o) {\n    if (is(h, \"object\") && \"h\" in h && \"s\" in h && \"b\" in h) {\n      v = h.b;\n      s = h.s;\n      o = h.o;\n      h = h.h;\n    }\n    h *= 360;\n    var R, G, B, X, C;\n    h = h % 360 / 60;\n    C = v * s;\n    X = C * (1 - abs(h % 2 - 1));\n    R = G = B = v - C;\n    h = ~~h;\n    R += [C, X, 0, 0, X, C][h];\n    G += [X, C, C, X, 0, 0][h];\n    B += [0, 0, X, C, C, X][h];\n    return packageRGB(R, G, B, o);\n  };\n  /*\\\n   * Snap.hsl2rgb\n   [ method ]\n   **\n   * Converts HSL values to an RGB object\n   - h (number) hue\n   - s (number) saturation\n   - l (number) luminosity\n   = (object) RGB object in the following format:\n   o {\n   o     r (number) red,\n   o     g (number) green,\n   o     b (number) blue,\n   o     hex (string) color in HTML/CSS format: #••••••\n   o }\n  \\*/\n  Snap.hsl2rgb = function (h, s, l, o) {\n    if (is(h, \"object\") && \"h\" in h && \"s\" in h && \"l\" in h) {\n      l = h.l;\n      s = h.s;\n      h = h.h;\n    }\n    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    h = ~~h;\n    R += [C, X, 0, 0, X, C][h];\n    G += [X, C, C, X, 0, 0][h];\n    B += [0, 0, X, C, C, X][h];\n    return packageRGB(R, G, B, o);\n  };\n  /*\\\n   * Snap.rgb2hsb\n   [ method ]\n   **\n   * Converts RGB values to an HSB object\n   - r (number) red\n   - g (number) green\n   - b (number) blue\n   = (object) HSB object in the following format:\n   o {\n   o     h (number) hue,\n   o     s (number) saturation,\n   o     b (number) brightness\n   o }\n  \\*/\n  Snap.rgb2hsb = function (r, g, b) {\n    b = prepareRGB(r, g, b);\n    r = b[0];\n    g = b[1];\n    b = b[2];\n    var H, S, V, C;\n    V = mmax(r, g, b);\n    C = V - mmin(r, g, b);\n    H = C == 0 ? null : V == r ? (g - b) / C : V == g ? (b - r) / C + 2 : (r - g) / C + 4;\n    H = (H + 360) % 6 * 60 / 360;\n    S = C == 0 ? 0 : C / V;\n    return {\n      h: H,\n      s: S,\n      b: V,\n      toString: hsbtoString\n    };\n  };\n  /*\\\n   * Snap.rgb2hsl\n   [ method ]\n   **\n   * Converts RGB values to an HSL object\n   - r (number) red\n   - g (number) green\n   - b (number) blue\n   = (object) HSL object in the following format:\n   o {\n   o     h (number) hue,\n   o     s (number) saturation,\n   o     l (number) luminosity\n   o }\n  \\*/\n  Snap.rgb2hsl = function (r, g, b) {\n    b = prepareRGB(r, g, b);\n    r = b[0];\n    g = b[1];\n    b = b[2];\n    var H, S, L, M, m, C;\n    M = mmax(r, g, b);\n    m = mmin(r, g, b);\n    C = M - m;\n    H = C == 0 ? null : M == r ? (g - b) / C : M == g ? (b - r) / C + 2 : (r - g) / C + 4;\n    H = (H + 360) % 6 * 60 / 360;\n    L = (M + m) / 2;\n    S = C == 0 ? 0 : L < .5 ? C / (2 * L) : C / (2 - 2 * L);\n    return {\n      h: H,\n      s: S,\n      l: L,\n      toString: hsltoString\n    };\n  };\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  \\*/\n  Snap.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    var paramCounts = {\n        a: 7,\n        c: 6,\n        o: 2,\n        h: 1,\n        l: 2,\n        m: 2,\n        r: 4,\n        q: 4,\n        s: 4,\n        t: 2,\n        v: 1,\n        u: 3,\n        z: 0\n      },\n      data = [];\n    if (is(pathString, \"array\") && is(pathString[0], \"array\")) {\n      // 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  \\*/\n  var parseTransformString = Snap.parseTransformString = function (TString) {\n    if (!TString) {\n      return null;\n    }\n    var paramCounts = {\n        r: 3,\n        s: 4,\n        t: 2,\n        m: 6\n      },\n      data = [];\n    if (is(TString, \"array\") && is(TString[0], \"array\")) {\n      // 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  };\n  function svgTransform2string(tstr) {\n    var res = [];\n    tstr = tstr.replace(/(?:^|\\s)(\\w+)\\(([^)]+)\\)/g, function (all, name, params) {\n      params = params.split(/\\s*,\\s*|\\s+/);\n      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  }\n  Snap._.svgTransform2string = svgTransform2string;\n  Snap._.rgTransform = /^[a-z][\\s]*-?\\.?\\d/i;\n  function 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  }\n  Snap._.transform2matrix = transform2matrix;\n  Snap._unit2px = unit2px;\n  var contains = glob.doc.contains || glob.doc.compareDocumentPosition ? function (a, b) {\n    var adown = a.nodeType == 9 ? a.documentElement : a,\n      bup = b && b.parentNode;\n    return a == bup || !!(bup && bup.nodeType == 1 && (adown.contains ? adown.contains(bup) : a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16));\n  } : function (a, b) {\n    if (b) {\n      while (b) {\n        b = b.parentNode;\n        if (b == a) {\n          return true;\n        }\n      }\n    }\n    return false;\n  };\n  function getSomeDefs(el) {\n    var p = el.node.ownerSVGElement && wrap(el.node.ownerSVGElement) || el.node.parentNode && wrap(el.node.parentNode) || Snap.select(\"svg\") || Snap(0, 0),\n      pdefs = p.select(\"defs\"),\n      defs = pdefs == null ? false : pdefs.node;\n    if (!defs) {\n      defs = make(\"defs\", p.node).node;\n    }\n    return defs;\n  }\n  function getSomeSVG(el) {\n    return el.node.ownerSVGElement && wrap(el.node.ownerSVGElement) || Snap.select(\"svg\");\n  }\n  Snap._.getSomeDefs = getSomeDefs;\n  Snap._.getSomeSVG = getSomeSVG;\n  function 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, {\n        x: -9e9,\n        y: -9e9,\n        width: 10,\n        height: 10,\n        \"class\": \"svg---mgr\",\n        fill: \"none\"\n      });\n      svg.appendChild(mgr);\n    }\n    function getW(val) {\n      if (val == null) {\n        return E;\n      }\n      if (val == +val) {\n        return val;\n      }\n      $(mgr, {\n        width: val\n      });\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, {\n        height: val\n      });\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  \\*/\n  Snap.select = function (query) {\n    query = Str(query).replace(/([^\\\\]):/g, \"$1\\\\:\");\n    return wrap(glob.doc.querySelector(query));\n  };\n  /*\\\n   * Snap.selectAll\n   [ method ]\n   **\n   * Wraps DOM elements specified by CSS selector as set or array of @Element\n   - query (string) CSS selector of the element\n   = (Element) the current element\n  \\*/\n  Snap.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  function 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\n  setInterval(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);\n  function 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 {\n      g: 1,\n      mask: 1,\n      pattern: 1,\n      symbol: 1\n    }) {\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  \\*/\n  Snap.parse = function (svg) {\n    var f = glob.doc.createDocumentFragment(),\n      full = true,\n      div = glob.doc.createElement(\"div\");\n    svg = Str(svg);\n    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  };\n  function Fragment(frag) {\n    this.node = frag;\n  }\n  /*\\\n   * Snap.fragment\n   [ method ]\n   **\n   * Creates a DOM fragment from a given list of elements or strings\n   **\n   - varargs (…) SVG string\n   = (Fragment) the @Fragment\n  \\*/\n  Snap.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  function make(name, parent) {\n    var res = $(name);\n    parent.appendChild(res);\n    var el = wrap(res);\n    return el;\n  }\n  function 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  }\n  function 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  Snap._.make = make;\n  Snap._.wrap = wrap;\n  /*\\\n   * Paper.el\n   [ method ]\n   **\n   * Creates an element on paper with a given name and no attributes\n   **\n   - name (string) tag name\n   - attr (object) attributes\n   = (Element) the current element\n   > Usage\n   | var c = paper.circle(10, 10, 10); // is the same as...\n   | var c = paper.el(\"circle\").attr({\n   |     cx: 10,\n   |     cy: 10,\n   |     r: 10\n   | });\n   | // and the same as\n   | var c = paper.el(\"circle\", {\n   |     cx: 10,\n   |     cy: 10,\n   |     r: 10\n   | });\n  \\*/\n  Paper.prototype.el = function (name, attr) {\n    var el = make(name, this.node);\n    attr && el.attr(attr);\n    return el;\n  };\n  /*\\\n   * Element.children\n   [ method ]\n   **\n   * Returns array of all the children of the element.\n   = (array) array of Elements\n  \\*/\n  Element.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  };\n  function jsonFiller(root, o) {\n    for (var i = 0, ii = root.length; i < ii; i++) {\n      var item = {\n          type: root[i].type,\n          attr: root[i].attr()\n        },\n        children = root[i].children();\n      o.push(item);\n      if (children.length) {\n        jsonFiller(children, item.childNodes = []);\n      }\n    }\n  }\n  /*\\\n   * Element.toJSON\n   [ method ]\n   **\n   * Returns object representation of the given element and all its children.\n   = (object) in format\n   o {\n   o     type (string) this.type,\n   o     attr (object) attributes map,\n   o     childNodes (array) optional array of children in the same format\n   o }\n  \\*/\n  Element.prototype.toJSON = function () {\n    var out = [];\n    jsonFiller([this], out);\n    return out[0];\n  };\n  // default\n  eve.on(\"snap.util.getattr\", function () {\n    var att = eve.nt();\n    att = att.substring(att.lastIndexOf(\".\") + 1);\n    var css = att.replace(/[A-Z]/g, function (letter) {\n      return \"-\" + letter.toLowerCase();\n    });\n    if (cssAttr[has](css)) {\n      return this.node.ownerDocument.defaultView.getComputedStyle(this.node, null).getPropertyValue(css);\n    } else {\n      return $(this.node, att);\n    }\n  });\n  var cssAttr = {\n    \"alignment-baseline\": 0,\n    \"baseline-shift\": 0,\n    \"clip\": 0,\n    \"clip-path\": 0,\n    \"clip-rule\": 0,\n    \"color\": 0,\n    \"color-interpolation\": 0,\n    \"color-interpolation-filters\": 0,\n    \"color-profile\": 0,\n    \"color-rendering\": 0,\n    \"cursor\": 0,\n    \"direction\": 0,\n    \"display\": 0,\n    \"dominant-baseline\": 0,\n    \"enable-background\": 0,\n    \"fill\": 0,\n    \"fill-opacity\": 0,\n    \"fill-rule\": 0,\n    \"filter\": 0,\n    \"flood-color\": 0,\n    \"flood-opacity\": 0,\n    \"font\": 0,\n    \"font-family\": 0,\n    \"font-size\": 0,\n    \"font-size-adjust\": 0,\n    \"font-stretch\": 0,\n    \"font-style\": 0,\n    \"font-variant\": 0,\n    \"font-weight\": 0,\n    \"glyph-orientation-horizontal\": 0,\n    \"glyph-orientation-vertical\": 0,\n    \"image-rendering\": 0,\n    \"kerning\": 0,\n    \"letter-spacing\": 0,\n    \"lighting-color\": 0,\n    \"marker\": 0,\n    \"marker-end\": 0,\n    \"marker-mid\": 0,\n    \"marker-start\": 0,\n    \"mask\": 0,\n    \"opacity\": 0,\n    \"overflow\": 0,\n    \"pointer-events\": 0,\n    \"shape-rendering\": 0,\n    \"stop-color\": 0,\n    \"stop-opacity\": 0,\n    \"stroke\": 0,\n    \"stroke-dasharray\": 0,\n    \"stroke-dashoffset\": 0,\n    \"stroke-linecap\": 0,\n    \"stroke-linejoin\": 0,\n    \"stroke-miterlimit\": 0,\n    \"stroke-opacity\": 0,\n    \"stroke-width\": 0,\n    \"text-anchor\": 0,\n    \"text-decoration\": 0,\n    \"text-rendering\": 0,\n    \"unicode-bidi\": 0,\n    \"visibility\": 0,\n    \"word-spacing\": 0,\n    \"writing-mode\": 0\n  };\n  eve.on(\"snap.util.attr\", function (value) {\n    var att = eve.nt(),\n      attr = {};\n    att = att.substring(att.lastIndexOf(\".\") + 1);\n    attr[att] = value;\n    var style = att.replace(/-(\\w)/gi, function (all, letter) {\n        return letter.toUpperCase();\n      }),\n      css = att.replace(/[A-Z]/g, function (letter) {\n        return \"-\" + letter.toLowerCase();\n      });\n    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  \\*/\n  Snap.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  \\*/\n  Snap.load = function (url, callback, scope) {\n    Snap.ajax(url, function (req) {\n      var f = Snap.parse(req.responseText);\n      scope ? callback.call(scope, f) : callback(f);\n    });\n  };\n  var getOffset = function getOffset(elem) {\n    var box = elem.getBoundingClientRect(),\n      doc = elem.ownerDocument,\n      body = doc.body,\n      docElem = doc.documentElement,\n      clientTop = docElem.clientTop || body.clientTop || 0,\n      clientLeft = docElem.clientLeft || body.clientLeft || 0,\n      top = box.top + (g.win.pageYOffset || docElem.scrollTop || body.scrollTop) - clientTop,\n      left = box.left + (g.win.pageXOffset || docElem.scrollLeft || body.scrollLeft) - clientLeft;\n    return {\n      y: top,\n      x: left\n    };\n  };\n  /*\\\n   * Snap.getElementByPoint\n   [ method ]\n   **\n   * Returns you topmost element under given point.\n   **\n   = (object) Snap element object\n   - x (number) x coordinate from the top left corner of the window\n   - y (number) y coordinate from the top left corner of the window\n   > Usage\n   | Snap.getElementByPoint(mouseX, mouseY).attr({stroke: \"#f00\"});\n  \\*/\n  Snap.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  \\*/\n  Snap.plugin = function (f) {\n    f(Snap, Element, Paper, glob, Fragment);\n  };\n  glob.win.Snap = Snap;\n  return 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 propString() {\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) ? 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    if (this.node) {\n      if (this.type == \"linearGradient\" || this.type == \"radialGradient\") {\n        $(this.node, {\n          gradientTransform: this.matrix\n        });\n      } else if (this.type == \"pattern\") {\n        $(this.node, {\n          patternTransform: this.matrix\n        });\n      } else {\n        $(this.node, {\n          transform: this.matrix\n        });\n      }\n    }\n    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\" || 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, {\n          id: it.id\n        });\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, {\n        id: clone.id\n      });\n    }\n    fixids(clone);\n    clone.insertAfter(this);\n    return clone;\n  };\n  /*\\\n   * Element.toDefs\n   [ method ]\n   **\n   * Moves element to the shared `<defs>` area\n   **\n   = (Element) the element\n  \\*/\n  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 + '=\"' + 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) 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      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      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      out.shear = row[0][0] * row[1][0] + row[0][1] * row[1][1];\n      row[1] = [row[1][0] - row[0][0] * out.shear, row[1][1] - row[0][1] * out.shear];\n      out.scaley = math.sqrt(norm(row[1]));\n      normalize(row[1]);\n      out.shear /= out.scaley;\n      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      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) + (s.rotate ? \"r\" + [+s.rotate.toFixed(4), 0, 0] : E) + (s.scalex != 1 || s.scaley != 1 ? \"s\" + [s.scalex, s.scaley, 0, 0] : E);\n      } else {\n        return \"m\" + [this.get(0), this.get(1), this.get(2), this.get(3), this.get(4), this.get(5)];\n      }\n    };\n  })(Matrix.prototype);\n  /*\\\n   * Snap.Matrix\n   [ method ]\n   **\n   * Matrix constructor, extend on your own risk.\n   * To create matrices use @Snap.matrix.\n  \\*/\n  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 && (value.node.firstChild.tagName == \"radialGradient\" || value.node.firstChild.tagName == \"linearGradient\" || value.node.firstChild.tagName == \"pattern\")) {\n        value = value.node.firstChild;\n        getSomeDefs(this).appendChild(value);\n        value = wrap(value);\n      }\n      if (value instanceof Element) {\n        if (value.type == \"radialGradient\" || value.type == \"linearGradient\" || value.type == \"pattern\") {\n          if (!value.node.id) {\n            $(value.node, {\n              id: value.id\n            });\n          }\n          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  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, {\n      d: value\n    });\n  })(-1);\n  eve.on(\"snap.util.attr.#text\", function (value) {\n    eve.stop();\n    value = Str(value);\n    var txt = glob.doc.createTextNode(value);\n    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({\n      d: value\n    });\n  })(-1);\n  eve.on(\"snap.util.attr.class\", function (value) {\n    eve.stop();\n    this.node.className.baseVal = value;\n  })(-1);\n  eve.on(\"snap.util.attr.viewBox\", function (value) {\n    var vb;\n    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({\n          id: id\n        });\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({\n              id: id\n            });\n          }\n        }\n      }\n      if (id) {\n        tp = this.textPath;\n        node = this.node;\n        if (tp) {\n          tp.attr({\n            \"xlink:href\": \"#\" + id\n          });\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 tuner(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  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, {\n              id: value.id\n            });\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    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      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      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    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,\n      B,\n      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  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 = {\n        d: d\n      };\n    }\n    return this.el(\"path\", attr);\n  };\n  /*\\\n   * Paper.g\n   [ method ]\n   **\n   * Creates a group element\n   **\n   - varargs (…) #optional elements to nest within the group\n   = (object) the `g` element\n   **\n   > Usage\n   | var c1 = paper.circle(),\n   |     c2 = paper.rect(),\n   |     g = paper.g(c2, c1); // note that the order of elements is different\n   * or\n   | var c1 = paper.circle(),\n   |     c2 = paper.rect(),\n   |     g = paper.g();\n   | g.add(c2, c1);\n  \\*/\n  /*\\\n   * 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 = {\n        patternUnits: \"userSpaceOnUse\"\n      };\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({\n            id: Snap._.id(id)\n          });\n        }\n        id = id.attr(\"id\");\n      }\n      if (String(id).charAt() == \"#\") {\n        id = id.substring(1);\n      }\n      return this.el(\"use\", {\n        \"xlink:href\": \"#\" + id\n      });\n    } else {\n      return Element.prototype.use.call(this);\n    }\n  };\n  /*\\\n   * Paper.symbol\n   [ method ]\n   **\n   * Creates a <symbol> element.\n   - vbx (number) @optional viewbox X\n   - vby (number) @optional viewbox Y\n   - vbw (number) @optional viewbox width\n   - vbh (number) @optional viewbox height\n   = (object) the `symbol` element\n   **\n  \\*/\n  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    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 = {\n        points: points\n      };\n    }\n    return this.el(\"polyline\", attr);\n  };\n  /*\\\n   * Paper.polygon\n   [ method ]\n   **\n   * Draws a polygon. See @Paper.polyline\n  \\*/\n  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 = {\n        points: points\n      };\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 = {\n              \"offset\": grad[i].offset + \"%\"\n            };\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, {\n        xmlns: \"http://www.w3.org/2000/svg\"\n      });\n      res = d.innerHTML;\n      f.removeChild(f.firstChild);\n      return res;\n    };\n    /*\\\n     * Paper.toDataURL\n     [ method ]\n     **\n     * Returns SVG code for the @Paper as Data URI string.\n     = (string) Data URI string\n    \\*/\n    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({\n            node: node\n          });\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, 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,\n        y,\n        p,\n        l,\n        sp = \"\",\n        subpaths = {},\n        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 += [\"C\" + O(point.start.x), O(point.start.y), O(point.m.x), O(point.m.y), O(point.x), O(point.y)];\n              if (onlystart) {\n                return sp;\n              }\n              subpaths.start = sp;\n              sp = [\"M\" + O(point.x), O(point.y) + \"C\" + O(point.n.x), O(point.n.y), O(point.end.x), O(point.end.y), O(p[5]), O(p[6])].join();\n              len += l;\n              x = +p[5];\n              y = +p[6];\n              continue;\n            }\n            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: {\n        x: mx,\n        y: my\n      },\n      n: {\n        x: nx,\n        y: ny\n      },\n      start: {\n        x: ax,\n        y: ay\n      },\n      end: {\n        x: cx,\n        y: cy\n      },\n      alpha: alpha\n    };\n  }\n  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(bbox.min.x, bbox.min.y, bbox.max.x - bbox.min.x, bbox.max.y - bbox.min.y);\n  }\n  function isPointInsideBBox(bbox, x, y) {\n    return x >= bbox.x && x <= bbox.x + bbox.width && y >= bbox.y && y <= bbox.y + bbox.height;\n  }\n  function isBBoxIntersect(bbox1, bbox2) {\n    bbox1 = box(bbox1);\n    bbox2 = box(bbox2);\n    return isPointInsideBBox(bbox2, bbox1.x, bbox1.y) || isPointInsideBBox(bbox2, bbox1.x2, bbox1.y) || isPointInsideBBox(bbox2, bbox1.x, bbox1.y2) || isPointInsideBBox(bbox2, bbox1.x2, bbox1.y2) || isPointInsideBBox(bbox1, bbox2.x, bbox2.y) || isPointInsideBBox(bbox1, bbox2.x2, bbox2.y) || isPointInsideBBox(bbox1, bbox2.x, bbox2.y2) || isPointInsideBBox(bbox1, bbox2.x2, bbox2.y2) || (bbox1.x < bbox2.x2 && bbox1.x > bbox2.x || bbox2.x < bbox1.x2 && bbox2.x > bbox1.x) && (bbox1.y < bbox2.y2 && bbox1.y > bbox2.y || bbox2.y < bbox1.y2 && bbox2.y > bbox1.y);\n  }\n  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 (mmax(x1, x2) < mmin(x3, x4) || mmin(x1, x2) > mmax(x3, x4) || mmax(y1, y2) < mmin(y3, y4) || mmin(y1, y2) > mmax(y3, y4)) {\n      return;\n    }\n    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    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 (px2 < +mmin(x1, x2).toFixed(2) || px2 > +mmax(x1, x2).toFixed(2) || px2 < +mmin(x3, x4).toFixed(2) || px2 > +mmax(x3, x4).toFixed(2) || py2 < +mmin(y1, y2).toFixed(2) || py2 > +mmax(y1, y2).toFixed(2) || py2 < +mmin(y3, y4).toFixed(2) || py2 > +mmax(y3, y4).toFixed(2)) {\n      return;\n    }\n    return {\n      x: px,\n      y: py\n    };\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({\n        x: p.x,\n        y: p.y,\n        t: i / n1\n      });\n    }\n    for (i = 0; i < n2 + 1; i++) {\n      p = findDotsAtSegment.apply(0, bez2.concat(i / n2));\n      dots2.push({\n        x: p.x,\n        y: p.y,\n        t: i / n2\n      });\n    }\n    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,\n      y1,\n      x2,\n      y2,\n      x1m,\n      y1m,\n      x2m,\n      y2m,\n      bez1,\n      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) && 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 [[\"M\", +x + +r, y], [\"l\", w - r * 2, 0], [\"a\", r, r, 0, 0, 1, r, r], [\"l\", 0, h - r * 2], [\"a\", r, r, 0, 0, 1, -r, r], [\"l\", r * 2 - w, 0], [\"a\", r, r, 0, 0, 1, -r, -r], [\"l\", 0, r * 2 - h], [\"a\", r, r, 0, 0, 1, r, -r], [\"z\"]];\n    }\n    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 = [[\"M\", x, y], [\"m\", 0, -ry], [\"a\", rx, ry, 0, 1, 1, 0, 2 * ry], [\"a\", rx, ry, 0, 1, 1, 0, -2 * ry], [\"z\"]];\n    }\n    res.toString = toString;\n    return res;\n  }\n  var unit2px = Snap._unit2px,\n    getPath = {\n      path: function path(el) {\n        return el.attr(\"path\");\n      },\n      circle: function circle(el) {\n        var attr = unit2px(el);\n        return ellipsePath(attr.cx, attr.cy, attr.r);\n      },\n      ellipse: function ellipse(el) {\n        var attr = unit2px(el);\n        return ellipsePath(attr.cx || 0, attr.cy || 0, attr.rx, attr.ry);\n      },\n      rect: function rect(el) {\n        var attr = unit2px(el);\n        return rectPath(attr.x || 0, attr.y || 0, attr.width, attr.height, attr.rx, attr.ry);\n      },\n      image: function image(el) {\n        var attr = unit2px(el);\n        return rectPath(attr.x || 0, attr.y || 0, attr.width, attr.height);\n      },\n      line: function line(el) {\n        return \"M\" + [el.attr(\"x1\") || 0, el.attr(\"y1\") || 0, el.attr(\"x2\"), el.attr(\"y2\")];\n      },\n      polyline: function polyline(el) {\n        return \"M\" + el.attr(\"points\");\n      },\n      polygon: function polygon(el) {\n        return \"M\" + el.attr(\"points\") + \"z\";\n      },\n      deflt: function deflt(el) {\n        var bbox = el.node.getBBox();\n        return rectPath(bbox.x, bbox.y, bbox.width, bbox.height);\n      }\n    };\n  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\")) {\n      // 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 && pathArray[0][0] == \"M\" && pathArray[1][0].toUpperCase() == \"R\" && 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 [_13 * x1 + _23 * ax, _13 * y1 + _23 * ay, _13 * x2 + _23 * ax, _13 * y2 + _23 * ay, x2, y2];\n  }\n  function a2c(x1, y1, rx, ry, angle, large_arc_flag, sweep_flag, x2, y2, recursive) {\n    // for more information of where this math came from visit:\n    // http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes\n    var _120 = PI * 120 / 180,\n      rad = PI / 180 * (+angle || 0),\n      res = [],\n      xy,\n      rotate = Snap._.cacher(function (x, y, rad) {\n        var X = x * math.cos(rad) - y * math.sin(rad),\n          Y = x * math.sin(rad) + y * math.cos(rad);\n        return {\n          x: X,\n          y: Y\n        };\n      });\n    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) * math.sqrt(abs((rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x))),\n        cx = k * rx * y / ry + (x1 + x2) / 2,\n        cy = k * -ry * x / rx + (y1 + y2) / 2,\n        f1 = math.asin(((y1 - cy) / ry).toFixed(9)),\n        f2 = math.asin(((y2 - cy) / ry).toFixed(9));\n      f1 = x1 < cx ? PI - f1 : f1;\n      f2 = x2 < cx ? PI - f2 : f2;\n      f1 < 0 && (f1 = PI * 2 + f1);\n      f2 < 0 && (f2 = PI * 2 + f2);\n      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,\n      b,\n      c,\n      t,\n      t1,\n      t2,\n      b2ac,\n      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    var x,\n      y,\n      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    bounds[0][jlen] = x0;\n    bounds[1][jlen] = y0;\n    bounds[0][jlen + 1] = x3;\n    bounds[1][jlen + 1] = y3;\n    bounds[0].length = bounds[1].length = jlen + 2;\n    return {\n      min: {\n        x: mmin.apply(0, bounds[0]),\n        y: mmin.apply(0, bounds[1])\n      },\n      max: {\n        x: mmax.apply(0, bounds[0]),\n        y: mmax.apply(0, bounds[1])\n      }\n    };\n  }\n  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 = {\n        x: 0,\n        y: 0,\n        bx: 0,\n        by: 0,\n        X: 0,\n        Y: 0,\n        qx: null,\n        qy: null\n      },\n      attrs2 = {\n        x: 0,\n        y: 0,\n        bx: 0,\n        by: 0,\n        X: 0,\n        Y: 0,\n        qx: null,\n        qy: null\n      },\n      processPath = function processPath(path, d, pcom) {\n        var nx, ny;\n        if (!path) {\n          return [\"C\", d.x, d.y, d.x, d.y, d.x, d.y];\n        }\n        !(path[0] in {\n          T: 1,\n          Q: 1\n        }) && (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\") {\n              // In \"S\" case we have to take into account, if the previous command is C/S.\n              nx = d.x * 2 - d.bx; // And reflect the previous\n              ny = d.y * 2 - d.by; // command's control point relative to the current point.\n            } else {\n              // or some else or nothing\n              nx = d.x;\n              ny = d.y;\n            }\n            path = [\"C\", nx, ny].concat(path.slice(1));\n            break;\n          case \"T\":\n            if (pcom == \"Q\" || pcom == \"T\") {\n              // In \"T\" case we have to take into account, if the previous command is Q/T.\n              d.qx = d.x * 2 - d.qx; // And make a reflection similar\n              d.qy = d.y * 2 - d.qy; // to case \"S\".\n            } else {\n              // or something else or nothing\n              d.qx = d.x;\n              d.qy = d.y;\n            }\n            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 fixArc(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 fixM(path1, path2, a1, a2, i) {\n        if (path1 && path2 && path1[i][0] == \"M\" && path2[i][0] != \"M\") {\n          path2.splice(i, 0, [\"M\", a2.x, a2.y]);\n          a1.bx = 0;\n          a1.by = 0;\n          a1.x = path1[i][1];\n          a1.y = path1[i][2];\n          ii = mmax(p.length, p2 && p2.length || 0);\n        }\n      },\n      pcoms1 = [],\n      // path commands of original path p\n      pcoms2 = [],\n      // path commands of original path p2\n      pfirst = \"\",\n      // temporary holder for original path command\n      pcom = \"\"; // holder for previous path command of original path\n    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\")\n        // 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\n      p[i] = processPath(p[i], attrs, pcom); // Previous path command is inputted to processPath\n\n      if (pcoms1[i] != \"A\" && pfirst == \"C\") pcoms1[i] = \"C\"; // A is the only command\n      // which may produce multiple C:s\n      // so we have to make sure that C is also C in original path\n\n      fixArc(p, i); // fixArc adds also the right amount of A:s to pcoms1\n\n      if (p2) {\n        // the same procedures is done to p2\n        p2[i] && (pfirst = p2[i][0]);\n        if (pfirst != \"C\") {\n          pcoms2[i] = pfirst;\n          i && (pcom = pcoms2[i - 1]);\n        }\n        p2[i] = processPath(p2[i], attrs2, pcom);\n        if (pcoms2[i] != \"A\" && pfirst == \"C\") {\n          pcoms2[i] = \"C\";\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],\n        y: +crp[i - 1]\n      }, {\n        x: +crp[i],\n        y: +crp[i + 1]\n      }, {\n        x: +crp[i + 2],\n        y: +crp[i + 3]\n      }, {\n        x: +crp[i + 4],\n        y: +crp[i + 5]\n      }];\n      if (z) {\n        if (!i) {\n          p[0] = {\n            x: +crp[iLen - 2],\n            y: +crp[iLen - 1]\n          };\n        } else if (iLen - 4 == i) {\n          p[3] = {\n            x: +crp[0],\n            y: +crp[1]\n          };\n        } else if (iLen - 2 == i) {\n          p[2] = {\n            x: +crp[0],\n            y: +crp[1]\n          };\n          p[3] = {\n            x: +crp[2],\n            y: +crp[3]\n          };\n        }\n      } else {\n        if (iLen - 4 == i) {\n          p[3] = p[2];\n        } else if (!i) {\n          p[0] = {\n            x: +crp[i],\n            y: +crp[i + 1]\n          };\n        }\n      }\n      d.push([\"C\", (-p[0].x + 6 * p[1].x + p[2].x) / 6, (-p[0].y + 6 * p[1].y + p[2].y) / 6, (p[1].x + 6 * p[2].x - p[3].x) / 6, (p[1].y + 6 * p[2].y - p[3].y) / 6, p[2].x, p[2].y]);\n    }\n    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 Set(items) {\n      this.items = [];\n      this.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, 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 handler() {\n        if (begin) {\n          this.b = begin;\n        } else {\n          begin = this.b;\n        }\n      },\n      cb = 0,\n      set = this,\n      callbacker = callback && function () {\n        if (++cb == set.length) {\n          callback.call(this);\n        }\n      };\n    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\":\n        return [l, 0, 0];\n      case \"m\":\n        return [l, 1, 0, 0, 1, 0, 0];\n      case \"r\":\n        if (item.length == 4) {\n          return [l, 0, item[2], item[3]];\n        } else {\n          return [l, 0];\n        }\n      case \"s\":\n        if (item.length == 5) {\n          return [l, 1, 1, item[3], item[4]];\n        } else if (item.length == 3) {\n          return [l, 1, 1];\n        } else {\n          return [l, 1];\n        }\n    }\n  }\n  function equaliseTransform(t1, t2, getBBox) {\n    t1 = t1 || new Snap.Matrix();\n    t2 = t2 || new Snap.Matrix();\n    t1 = Snap.parseTransformString(t1.toTransformString()) || [];\n    t2 = Snap.parseTransformString(t2.toTransformString()) || [];\n    var maxlength = Math.max(t1.length, t2.length),\n      from = [],\n      to = [],\n      i = 0,\n      j,\n      jj,\n      tt1,\n      tt2;\n    for (; i < maxlength; i++) {\n      tt1 = t1[i] || getEmpty(t2[i]);\n      tt2 = t2[i] || getEmpty(tt1);\n      if (tt1[0] != tt2[0] || tt1[0].toLowerCase() == \"r\" && (tt1[2] != tt2[2] || tt1[3] != tt2[3]) || tt1[0].toLowerCase() == \"s\" && (tt1[3] != tt2[3] || tt1[4] != tt2[4])) {\n        t1 = Snap._.transform2matrix(t1, getBBox());\n        t2 = Snap._.transform2matrix(t2, getBBox());\n        from = [[\"m\", t1.a, t1.b, t1.c, t1.d, t1.e, t1.f]];\n        to = [[\"m\", t2.a, t2.b, t2.c, t2.d, t2.e, t2.f]];\n        break;\n      }\n      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,\n      i,\n      ii,\n      j,\n      jj,\n      out,\n      a,\n      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,\n      B,\n      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 f(val) {\n          return val;\n        }\n      };\n    }\n    if (isNumeric(a) && isNumeric(b)) {\n      return {\n        from: parseFloat(a),\n        to: parseFloat(b),\n        f: getNumber\n      };\n    }\n    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 = [\"click\", \"dblclick\", \"mousedown\", \"mousemove\", \"mouseout\", \"mouseover\", \"mouseup\", \"touchstart\", \"touchmove\", \"touchend\", \"touchcancel\"],\n    touchMap = {\n      mousedown: \"touchstart\",\n      mousemove: \"touchmove\",\n      mouseup: \"touchend\"\n    },\n    getScroll = function getScroll(xy, el) {\n      var name = xy == \"y\" ? \"scrollTop\" : \"scrollLeft\",\n        doc = el && el.node ? el.node.ownerDocument : glob.doc;\n      return doc[name in doc.documentElement ? \"documentElement\" : \"body\"][name];\n    },\n    preventDefault = function preventDefault() {\n      this.returnValue = false;\n    },\n    preventTouch = function preventTouch() {\n      return this.originalEvent.preventDefault();\n    },\n    stopPropagation = function stopPropagation() {\n      this.cancelBubble = true;\n    },\n    stopTouch = function stopTouch() {\n      return this.originalEvent.stopPropagation();\n    },\n    addEvent = function addEvent(obj, type, fn, element) {\n      var realName = supportsTouch && touchMap[type] ? touchMap[type] : type,\n        f = function f(e) {\n          var scrollY = getScroll(\"y\", element),\n            scrollX = getScroll(\"x\", element);\n          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      if (type !== realName) {\n        obj.addEventListener(type, f, false);\n      }\n      obj.addEventListener(realName, f, false);\n      return function () {\n        if (type !== realName) {\n          obj.removeEventListener(type, f, false);\n        }\n        obj.removeEventListener(realName, f, false);\n        return true;\n      };\n    },\n    drag = [],\n    dragMove = function dragMove(e) {\n      var x = e.clientX,\n        y = e.clientY,\n        scrollY = getScroll(\"y\"),\n        scrollX = getScroll(\"x\"),\n        dragi,\n        j = drag.length;\n      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 dragUp(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] = elproto[\"un\" + eventName] = function (fn) {\n        var events = this.events || [],\n          l = events.length;\n        while (l--) if (events[l].name == eventName && (events[l].f == fn || !fn)) {\n          events[l].unbind();\n          events.splice(l, 1);\n          !events.length && delete this.events;\n          return this;\n        }\n        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({\n        el: el,\n        move_scope: move_scope,\n        start_scope: start_scope,\n        end_scope: end_scope\n      });\n      onstart && eve.on(\"snap.drag.start.\" + el.id, onstart);\n      onmove && eve.on(\"snap.drag.move.\" + el.id, onmove);\n      onend && eve.on(\"snap.drag.end.\" + el.id, onend);\n      eve(\"snap.drag.start.\" + el.id, start_scope || move_scope || el, x, y, e);\n    }\n    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({\n      el: el,\n      start: start,\n      init: init\n    });\n    el.mousedown(init);\n    return el;\n  };\n  /*\n   * Element.onDragOver\n   [ method ]\n   **\n   * Shortcut to assign event handler for `drag.over.<id>` event, where `id` is the element's `id` (see @Element.id)\n   - f (function) handler for event, first argument would be the element you are dragging over\n  \\*/\n  // elproto.onDragOver = function (f) {\n  //     f ? eve.on(\"snap.drag.over.\" + this.id, f) : eve.unbind(\"snap.drag.over.\" + this.id);\n  // };\n  /*\\\n   * 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  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, {\n          id: value.id\n        });\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 toString() {\n      return \"T\" + this.dx + \",\" + this.dy;\n    };\n  /*\\\n   * Element.getAlign\n   [ method ]\n   **\n   * Returns shift needed to align the element relatively to given element.\n   * If no elements specified, parent `<svg>` container will be used.\n   - el (object) @optional alignment element\n   - way (string) one of six values: `\"top\"`, `\"middle\"`, `\"bottom\"`, `\"left\"`, `\"center\"`, `\"right\"`\n   = (object|string) Object in format `{dx: , dy: }` also has a string representation as a transformation string\n   > Usage\n   | el.transform(el.getAlign(el2, \"top\"));\n   * or\n   | var dy = el.getAlign(el2, \"top\").dy;\n  \\*/\n  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) 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 Animation(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 status(val) {\n            return a.status(val);\n          },\n          stop: function stop() {\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 = [],\n      tkeys = [],\n      keys = {},\n      from,\n      to,\n      f,\n      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) 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});\nmodule.exports = Snap;"],"names":["window","eve","mina","requestID","animations","requestAnimFrame","requestAnimationFrame","webkitRequestAnimationFrame","mozRequestAnimationFrame","oRequestAnimationFrame","msRequestAnimationFrame","callback","setTimeout","Date","getTime","isArray","Array","a","Object","prototype","toString","call","idgen","idprefix","timer","now","sta","val","this","s","ds","b","dur","B","speed","spd","duration","stopit","id","update","pause","pdif","get","resume","frame","res","start","j","jj","length","end","easing","set","timeStamp","len","i","hasOwnProperty","A","anim","linear","status","stop","time","getById","n","easeout","Math","pow","easein","easeinout","q","Q","sqrt","x","y","t","abs","backin","backout","elastic","sin","PI","bounce","p","Snap","root","w","h","nodeType","wrap","is","apply","Element","glob","doc","querySelector","String","e","Paper","version","_","win","document","tokenRegex","objNotationRegex","has","Str","toFloat","parseFloat","toInt","parseInt","math","mmax","max","mmin","min","E","round","objectToString","colourRegExp","commaSpaces","separator","hsrg","hs","rg","pathCommand","tCommand","pathValues","ID","el","type","xlink","xmlns","hub","url","$","attr","createTextNode","text","createComment","substring","getAttributeNS","getAttribute","nodeValue","key","setAttributeNS","setAttribute","removeAttribute","createElementNS","o","toLowerCase","isFinite","slice","cacher","f","scope","postprocessor","newf","arg","arguments","args","join","cache","count","array","item","ii","push","splice","repush","shift","rad","deg","format","str","obj","replace","all","name","quote","quotedName","isFunc","replacer","clone","constructor","angle","tan","cos","asin","num","acos","atan","atan2","x1","y1","x2","y2","x3","y3","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","value","tolerance","rem","getRGB","colour","indexOf","r","g","hex","error","rgbtoString","charAt","_toHex","red","green","blue","opacity","rgb","match","split","hsb2rgb","hsl2rgb","hsb","hsl","l","toFixed","color","getElementsByTagName","style","out","defaultView","getComputedStyle","getPropertyValue","hsbtoString","hsltoString","prepareRGB","string","clr","packageRGB","rgb2hsl","rgb2hsb","v","R","G","X","C","V","L","M","m","parsePathString","pathString","pth","arr","paramCounts","c","u","z","data","params","concat","parseTransformString","TString","svgTransform2string","tstr","rgTransform","transform2matrix","bbox","tdata","Matrix","bb","tlen","command","absolute","inver","invert","translate","rotate","width","height","scale","add","_unit2px","svg","getSomeSVG","mgr","fill","appendChild","getW","getBBox","getH","nam","removeChild","contains","compareDocumentPosition","ownerSVGElement","select","add2group","list","forEach","children","childNodes","snap","paper","tagName","nodeName","anims","transform","mask","pattern","symbol","method","Fragment","frag","make","parent","desc","defs","proto","ownerDocument","body","dom","contentDocument","jsonFiller","getSomeDefs","parentNode","pdefs","query","selectAll","nodelist","querySelectorAll","setInterval","attributes","firstDefined","json","att","parse","createDocumentFragment","full","div","createElement","innerHTML","firstChild","fragment","ch","toJSON","on","nt","css","lastIndexOf","letter","cssAttr","toUpperCase","ajax","postData","req","XMLHttpRequest","pd","encodeURIComponent","open","setRequestHeader","once","onreadystatechange","readyState","send","load","responseText","getElementByPoint","canvas","elem","box","docElem","clientTop","clientLeft","target","elementFromPoint","opera","so","getBoundingClientRect","documentElement","top","pageYOffset","scrollTop","left","pageXOffset","scrollLeft","sr","createSVGRect","hits","getIntersectionList","plugin","elproto","unit2px","isWithoutTransform","getClientRects","removed","localMatrix","original","href","getElementById","pathfinder","deflt","bboxwt","realPath","matrix","map","propString","extractTransform","doReturn","test","papa","global","getCTM","local","ms","localString","toTransformString","globalMatrix","totalMatrix","diffMatrix","total","gradientTransform","patternTransform","append","it","appendTo","prepend","first","insertBefore","prependTo","nextSibling","insertAfter","remove","asPX","use","cloneNode","els","ids","uses","urltest","linktest","oldid","old","fs","fixids","toDefs","toPattern","patternUnits","viewBox","marker","refX","refY","cx","cy","markerWidth","markerHeight","orient","eldata","chld","removeData","outerSVG","innerSVG","toDataURL","btoa","contents","unescape","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","clipIt","reURLValue","URL","fillStroke","grad","gradient","attrs","deurl","clip","undefined","gradrg","setFontSize","fontSize","textExtract","chi","getFontSize","tokens","stops","seed","step","k","toAbsolute","txt","className","baseVal","vb","rx","ry","tp","textPath","tuned","tuner","chunk","getter","setter","textContent","internal","rgNotSpace","addClass","clazz","finalValue","classes","curClasses","removeClass","pos","hasClass","toggleClass","flag","operators","reUnit","reAddon","getNumber","getUnit","unit","plus","evnt","atr","aUnit","op","isNaN","bplus","from","to","rect","circle","preload","onerror","src","img","cssText","onload","image","preserveAspectRatio","offsetWidth","offsetHeight","ellipse","group","vbx","vby","vbw","vbh","ptrn","vx","vy","vw","vh","line","polyline","points","polygon","Gstops","GaddStop","inserted","GgetBBox","GsetStops","addStop","gradientLinear","setStops","gradientRadial","fx","fy","unshift","gradientUnits","clear","next","p2s","paths","ps","sleep","r1","r2","r0","rectPath","pathClone","pathArray","getPointAtSegmentLength","p1x","p1y","c1x","c1y","c2x","c2y","p2x","p2y","bezlen","findDotsAtSegment","x4","y4","ll","t2","getTotLen","getLengthFactory","istotal","subpath","O","onlystart","point","sp","subpaths","path2curve","getSubpathsAtLength","t1","t13","t12","t3","mx","my","nx","ny","alpha","bezierBBox","curveDim","isPointInsideBBox","isBBoxIntersect","bbox1","bbox2","base3","p1","p2","p3","p4","z2","Tvalues","Cvalues","sum","ct","xbase","ybase","comb","intersect","denominator","px","py","px2","py2","interHelper","bez1","bez2","justCount","n1","n2","dots1","dots2","xy","di","di1","dj","dj1","ci","cj","interPathHelper","path1","path2","x1m","y1m","x2m","y2m","pi","pj","intr","kk","segment1","segment2","pathBBox","Y","dim","xmin","ymin","ellipsePath","getPath","pathToAbsolute","pa0","pa","crz","dots","pop","catmullRom2bezier","l2c","q2c","ax","ay","_13","_23","a2c","large_arc_flag","sweep_flag","recursive","_120","f1","f2","rx2","ry2","df","f2old","x2old","y2old","c1","s1","c2","s2","hx","hy","m1","m2","m3","m4","newres","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","crp","iLen","getSubpath","closest","inside","found","intersection","intersectionNumber","isPointInside","toRelative","lowerCase","rel","toCubic","pathi","Set","items","bindings","setproto","thisArg","animate","Animation","each","begin","handler","cb","callbacker","bind","aname","unbound","index","insertion","tail","todel","arglen","exclude","names","getEmpty","getViewBox","getColour","Function","path2array","isNumeric","stroke","equal","Number","tt1","tt2","maxlength","equaliseTransform","arr1","arr2","bUnit","supportsTouch","events","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","off","eventName","unbind","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","animation","inAnim","_attrs","_callback","curStatus","eq","fkeys","tkeys","keys","saveColor","colors","A100","A200","A400","A700","mui","flat","pink","purple","deeppurple","indigo","lightblue","cyan","teal","lightgreen","lime","yellow","amber","orange","deeporange","brown","grey","bluegrey","turquoise","greensea","sunflower","emerland","nephritis","carrot","pumpkin","peterriver","belizehole","alizarin","pomegranate","amethyst","wisteria","clouds","silver","wetasphalt","midnightblue","concrete","asbestos","importMUIColors","module","exports"],"sourceRoot":""}