mirage2d 1.1.2 → 1.1.4

package/dist/{js/lib/_canvg@3.0.10@canvg.bd557ac8.js → assets/js/index.es-38f73a27.js}

@@ -1,13 +1,1841 @@
-import "../_core-js@3.25.0@core-js/_core-js@3.25.0@core-js.003355ed.js";
-import { _ as _asyncToGenerator, a as _defineProperty } from "../_@babel_runtime@7.18.9@@babel/_@babel_runtime@7.18.9@@babel.e0126ca2.js";
-import { r as requestAnimationFrame } from "../_raf@3.4.1@raf/_raf@3.4.1@raf.ac0d6c66.js";
-import { _ as _rgbcolor_1_0_1_rgbcolor } from "../_rgbcolor@1.0.1@rgbcolor/_rgbcolor@1.0.1@rgbcolor.dd87e013.js";
-import { _ } from "../_svg-pathdata@6.0.3@svg-pathdata/_svg-pathdata@6.0.3@svg-pathdata.7e858a5f.js";
-import { p as processCanvasRGBA } from "../_stackblur-canvas@2.5.0@stackblur-canvas/_stackblur-canvas@2.5.0@stackblur-canvas.dd883d14.js";
-import "../_@turf_bbox@6.5.0@@turf/_@turf_bbox@6.5.0@@turf.4c59feee.js";
-import "../_@turf_meta@6.5.0@@turf/_@turf_meta@6.5.0@@turf.1b9d5da5.js";
-import "../_@turf_helpers@6.5.0@@turf/_@turf_helpers@6.5.0@@turf.f1480aa1.js";
-import "../_performance-now@2.1.0@performance-now/_performance-now@2.1.0@performance-now.a51379c2.js";
+import { a as anObject$6, f as fails$7, g as global$4, b as functionCall, c as functionUncurryThis, s as shared$1, t as toString$7, o as objectCreate, i as internalState, _ as _export, w as wellKnownSymbol$5, d as defineBuiltIn$2, e as createNonEnumerableProperty$2, h as stringMultibyte, j as isCallable$2, k as classofRaw, l as isNullOrUndefined$3, m as toLength$5, r as requireObjectCoercible$6, n as getMethod$3, p as toObject$1, q as functionApply, u as toIntegerOrInfinity$1, v as isObject$1, x as objectGetOwnPropertyDescriptor, y as documentCreateElement$1, z as es_array_iterator, A as speciesConstructor$1, B as arraySliceSimple, C as commonjsGlobal, D as arrayMethodIsStrict$1, E as arrayIncludes, F as isArray$1, G as hasOwnProperty_1, H as objectIsPrototypeOf, I as functionName } from "./index-a9db46a5.js";
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg);
+    var value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+  if (info.done) {
+    resolve(value);
+  } else {
+    Promise.resolve(value).then(_next, _throw);
+  }
+}
+function _asyncToGenerator(fn) {
+  return function() {
+    var self = this, args = arguments;
+    return new Promise(function(resolve, reject) {
+      var gen = fn.apply(self, args);
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+      }
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+      _next(void 0);
+    });
+  };
+}
+var anObject$5 = anObject$6;
+var regexpFlags$1 = function() {
+  var that = anObject$5(this);
+  var result = "";
+  if (that.hasIndices)
+    result += "d";
+  if (that.global)
+    result += "g";
+  if (that.ignoreCase)
+    result += "i";
+  if (that.multiline)
+    result += "m";
+  if (that.dotAll)
+    result += "s";
+  if (that.unicode)
+    result += "u";
+  if (that.unicodeSets)
+    result += "v";
+  if (that.sticky)
+    result += "y";
+  return result;
+};
+var fails$6 = fails$7;
+var global$3 = global$4;
+var $RegExp$2 = global$3.RegExp;
+var UNSUPPORTED_Y$2 = fails$6(function() {
+  var re = $RegExp$2("a", "y");
+  re.lastIndex = 2;
+  return re.exec("abcd") != null;
+});
+var MISSED_STICKY = UNSUPPORTED_Y$2 || fails$6(function() {
+  return !$RegExp$2("a", "y").sticky;
+});
+var BROKEN_CARET = UNSUPPORTED_Y$2 || fails$6(function() {
+  var re = $RegExp$2("^r", "gy");
+  re.lastIndex = 2;
+  return re.exec("str") != null;
+});
+var regexpStickyHelpers = {
+  BROKEN_CARET,
+  MISSED_STICKY,
+  UNSUPPORTED_Y: UNSUPPORTED_Y$2
+};
+var fails$5 = fails$7;
+var global$2 = global$4;
+var $RegExp$1 = global$2.RegExp;
+var regexpUnsupportedDotAll = fails$5(function() {
+  var re = $RegExp$1(".", "s");
+  return !(re.dotAll && re.exec("\n") && re.flags === "s");
+});
+var fails$4 = fails$7;
+var global$1 = global$4;
+var $RegExp = global$1.RegExp;
+var regexpUnsupportedNcg = fails$4(function() {
+  var re = $RegExp("(?<a>b)", "g");
+  return re.exec("b").groups.a !== "b" || "b".replace(re, "$<a>c") !== "bc";
+});
+var call$5 = functionCall;
+var uncurryThis$9 = functionUncurryThis;
+var toString$6 = toString$7;
+var regexpFlags = regexpFlags$1;
+var stickyHelpers$1 = regexpStickyHelpers;
+var shared = shared$1.exports;
+var create = objectCreate;
+var getInternalState = internalState.get;
+var UNSUPPORTED_DOT_ALL = regexpUnsupportedDotAll;
+var UNSUPPORTED_NCG = regexpUnsupportedNcg;
+var nativeReplace = shared("native-string-replace", String.prototype.replace);
+var nativeExec = RegExp.prototype.exec;
+var patchedExec = nativeExec;
+var charAt$2 = uncurryThis$9("".charAt);
+var indexOf = uncurryThis$9("".indexOf);
+var replace$1 = uncurryThis$9("".replace);
+var stringSlice$4 = uncurryThis$9("".slice);
+var UPDATES_LAST_INDEX_WRONG = function() {
+  var re1 = /a/;
+  var re2 = /b*/g;
+  call$5(nativeExec, re1, "a");
+  call$5(nativeExec, re2, "a");
+  return re1.lastIndex !== 0 || re2.lastIndex !== 0;
+}();
+var UNSUPPORTED_Y$1 = stickyHelpers$1.BROKEN_CARET;
+var NPCG_INCLUDED = /()??/.exec("")[1] !== void 0;
+var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y$1 || UNSUPPORTED_DOT_ALL || UNSUPPORTED_NCG;
+if (PATCH) {
+  patchedExec = function exec2(string) {
+    var re = this;
+    var state = getInternalState(re);
+    var str = toString$6(string);
+    var raw = state.raw;
+    var result, reCopy, lastIndex, match, i2, object, group;
+    if (raw) {
+      raw.lastIndex = re.lastIndex;
+      result = call$5(patchedExec, raw, str);
+      re.lastIndex = raw.lastIndex;
+      return result;
+    }
+    var groups = state.groups;
+    var sticky = UNSUPPORTED_Y$1 && re.sticky;
+    var flags = call$5(regexpFlags, re);
+    var source = re.source;
+    var charsAdded = 0;
+    var strCopy = str;
+    if (sticky) {
+      flags = replace$1(flags, "y", "");
+      if (indexOf(flags, "g") === -1) {
+        flags += "g";
+      }
+      strCopy = stringSlice$4(str, re.lastIndex);
+      if (re.lastIndex > 0 && (!re.multiline || re.multiline && charAt$2(str, re.lastIndex - 1) !== "\n")) {
+        source = "(?: " + source + ")";
+        strCopy = " " + strCopy;
+        charsAdded++;
+      }
+      reCopy = new RegExp("^(?:" + source + ")", flags);
+    }
+    if (NPCG_INCLUDED) {
+      reCopy = new RegExp("^" + source + "$(?!\\s)", flags);
+    }
+    if (UPDATES_LAST_INDEX_WRONG)
+      lastIndex = re.lastIndex;
+    match = call$5(nativeExec, sticky ? reCopy : re, strCopy);
+    if (sticky) {
+      if (match) {
+        match.input = stringSlice$4(match.input, charsAdded);
+        match[0] = stringSlice$4(match[0], charsAdded);
+        match.index = re.lastIndex;
+        re.lastIndex += match[0].length;
+      } else
+        re.lastIndex = 0;
+    } else if (UPDATES_LAST_INDEX_WRONG && match) {
+      re.lastIndex = re.global ? match.index + match[0].length : lastIndex;
+    }
+    if (NPCG_INCLUDED && match && match.length > 1) {
+      call$5(nativeReplace, match[0], reCopy, function() {
+        for (i2 = 1; i2 < arguments.length - 2; i2++) {
+          if (arguments[i2] === void 0)
+            match[i2] = void 0;
+        }
+      });
+    }
+    if (match && groups) {
+      match.groups = object = create(null);
+      for (i2 = 0; i2 < groups.length; i2++) {
+        group = groups[i2];
+        object[group[0]] = match[group[1]];
+      }
+    }
+    return match;
+  };
+}
+var regexpExec$3 = patchedExec;
+var $$5 = _export;
+var exec$1 = regexpExec$3;
+$$5({ target: "RegExp", proto: true, forced: /./.exec !== exec$1 }, {
+  exec: exec$1
+});
+var uncurryThis$8 = functionUncurryThis;
+var defineBuiltIn$1 = defineBuiltIn$2;
+var regexpExec$2 = regexpExec$3;
+var fails$3 = fails$7;
+var wellKnownSymbol$4 = wellKnownSymbol$5;
+var createNonEnumerableProperty$1 = createNonEnumerableProperty$2;
+var SPECIES = wellKnownSymbol$4("species");
+var RegExpPrototype$2 = RegExp.prototype;
+var fixRegexpWellKnownSymbolLogic = function(KEY, exec2, FORCED, SHAM) {
+  var SYMBOL = wellKnownSymbol$4(KEY);
+  var DELEGATES_TO_SYMBOL = !fails$3(function() {
+    var O2 = {};
+    O2[SYMBOL] = function() {
+      return 7;
+    };
+    return ""[KEY](O2) != 7;
+  });
+  var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails$3(function() {
+    var execCalled = false;
+    var re = /a/;
+    if (KEY === "split") {
+      re = {};
+      re.constructor = {};
+      re.constructor[SPECIES] = function() {
+        return re;
+      };
+      re.flags = "";
+      re[SYMBOL] = /./[SYMBOL];
+    }
+    re.exec = function() {
+      execCalled = true;
+      return null;
+    };
+    re[SYMBOL]("");
+    return !execCalled;
+  });
+  if (!DELEGATES_TO_SYMBOL || !DELEGATES_TO_EXEC || FORCED) {
+    var uncurriedNativeRegExpMethod = uncurryThis$8(/./[SYMBOL]);
+    var methods = exec2(SYMBOL, ""[KEY], function(nativeMethod, regexp, str, arg2, forceStringMethod) {
+      var uncurriedNativeMethod = uncurryThis$8(nativeMethod);
+      var $exec = regexp.exec;
+      if ($exec === regexpExec$2 || $exec === RegExpPrototype$2.exec) {
+        if (DELEGATES_TO_SYMBOL && !forceStringMethod) {
+          return { done: true, value: uncurriedNativeRegExpMethod(regexp, str, arg2) };
+        }
+        return { done: true, value: uncurriedNativeMethod(str, regexp, arg2) };
+      }
+      return { done: false };
+    });
+    defineBuiltIn$1(String.prototype, KEY, methods[0]);
+    defineBuiltIn$1(RegExpPrototype$2, SYMBOL, methods[1]);
+  }
+  if (SHAM)
+    createNonEnumerableProperty$1(RegExpPrototype$2[SYMBOL], "sham", true);
+};
+var charAt$1 = stringMultibyte.charAt;
+var advanceStringIndex$3 = function(S, index2, unicode) {
+  return index2 + (unicode ? charAt$1(S, index2).length : 1);
+};
+var call$4 = functionCall;
+var anObject$4 = anObject$6;
+var isCallable$1 = isCallable$2;
+var classof$1 = classofRaw;
+var regexpExec$1 = regexpExec$3;
+var $TypeError$1 = TypeError;
+var regexpExecAbstract = function(R, S) {
+  var exec2 = R.exec;
+  if (isCallable$1(exec2)) {
+    var result = call$4(exec2, R, S);
+    if (result !== null)
+      anObject$4(result);
+    return result;
+  }
+  if (classof$1(R) === "RegExp")
+    return call$4(regexpExec$1, R, S);
+  throw $TypeError$1("RegExp#exec called on incompatible receiver");
+};
+var call$3 = functionCall;
+var fixRegExpWellKnownSymbolLogic$2 = fixRegexpWellKnownSymbolLogic;
+var anObject$3 = anObject$6;
+var isNullOrUndefined$2 = isNullOrUndefined$3;
+var toLength$4 = toLength$5;
+var toString$5 = toString$7;
+var requireObjectCoercible$5 = requireObjectCoercible$6;
+var getMethod$2 = getMethod$3;
+var advanceStringIndex$2 = advanceStringIndex$3;
+var regExpExec$1 = regexpExecAbstract;
+fixRegExpWellKnownSymbolLogic$2("match", function(MATCH2, nativeMatch, maybeCallNative) {
+  return [
+    function match(regexp) {
+      var O2 = requireObjectCoercible$5(this);
+      var matcher = isNullOrUndefined$2(regexp) ? void 0 : getMethod$2(regexp, MATCH2);
+      return matcher ? call$3(matcher, regexp, O2) : new RegExp(regexp)[MATCH2](toString$5(O2));
+    },
+    function(string) {
+      var rx = anObject$3(this);
+      var S = toString$5(string);
+      var res = maybeCallNative(nativeMatch, rx, S);
+      if (res.done)
+        return res.value;
+      if (!rx.global)
+        return regExpExec$1(rx, S);
+      var fullUnicode = rx.unicode;
+      rx.lastIndex = 0;
+      var A = [];
+      var n2 = 0;
+      var result;
+      while ((result = regExpExec$1(rx, S)) !== null) {
+        var matchStr = toString$5(result[0]);
+        A[n2] = matchStr;
+        if (matchStr === "")
+          rx.lastIndex = advanceStringIndex$2(S, toLength$4(rx.lastIndex), fullUnicode);
+        n2++;
+      }
+      return n2 === 0 ? null : A;
+    }
+  ];
+});
+var uncurryThis$7 = functionUncurryThis;
+var toObject = toObject$1;
+var floor = Math.floor;
+var charAt = uncurryThis$7("".charAt);
+var replace = uncurryThis$7("".replace);
+var stringSlice$3 = uncurryThis$7("".slice);
+var SUBSTITUTION_SYMBOLS = /\$([$&'`]|\d{1,2}|<[^>]*>)/g;
+var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&'`]|\d{1,2})/g;
+var getSubstitution$1 = function(matched, str, position, captures, namedCaptures, replacement) {
+  var tailPos = position + matched.length;
+  var m2 = captures.length;
+  var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED;
+  if (namedCaptures !== void 0) {
+    namedCaptures = toObject(namedCaptures);
+    symbols = SUBSTITUTION_SYMBOLS;
+  }
+  return replace(replacement, symbols, function(match, ch) {
+    var capture;
+    switch (charAt(ch, 0)) {
+      case "$":
+        return "$";
+      case "&":
+        return matched;
+      case "`":
+        return stringSlice$3(str, 0, position);
+      case "'":
+        return stringSlice$3(str, tailPos);
+      case "<":
+        capture = namedCaptures[stringSlice$3(ch, 1, -1)];
+        break;
+      default:
+        var n2 = +ch;
+        if (n2 === 0)
+          return match;
+        if (n2 > m2) {
+          var f2 = floor(n2 / 10);
+          if (f2 === 0)
+            return match;
+          if (f2 <= m2)
+            return captures[f2 - 1] === void 0 ? charAt(ch, 1) : captures[f2 - 1] + charAt(ch, 1);
+          return match;
+        }
+        capture = captures[n2 - 1];
+    }
+    return capture === void 0 ? "" : capture;
+  });
+};
+var apply$1 = functionApply;
+var call$2 = functionCall;
+var uncurryThis$6 = functionUncurryThis;
+var fixRegExpWellKnownSymbolLogic$1 = fixRegexpWellKnownSymbolLogic;
+var fails$2 = fails$7;
+var anObject$2 = anObject$6;
+var isCallable = isCallable$2;
+var isNullOrUndefined$1 = isNullOrUndefined$3;
+var toIntegerOrInfinity = toIntegerOrInfinity$1;
+var toLength$3 = toLength$5;
+var toString$4 = toString$7;
+var requireObjectCoercible$4 = requireObjectCoercible$6;
+var advanceStringIndex$1 = advanceStringIndex$3;
+var getMethod$1 = getMethod$3;
+var getSubstitution = getSubstitution$1;
+var regExpExec = regexpExecAbstract;
+var wellKnownSymbol$3 = wellKnownSymbol$5;
+var REPLACE = wellKnownSymbol$3("replace");
+var max = Math.max;
+var min$3 = Math.min;
+var concat = uncurryThis$6([].concat);
+var push$1 = uncurryThis$6([].push);
+var stringIndexOf$1 = uncurryThis$6("".indexOf);
+var stringSlice$2 = uncurryThis$6("".slice);
+var maybeToString = function(it) {
+  return it === void 0 ? it : String(it);
+};
+var REPLACE_KEEPS_$0 = function() {
+  return "a".replace(/./, "$0") === "$0";
+}();
+var REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = function() {
+  if (/./[REPLACE]) {
+    return /./[REPLACE]("a", "$0") === "";
+  }
+  return false;
+}();
+var REPLACE_SUPPORTS_NAMED_GROUPS = !fails$2(function() {
+  var re = /./;
+  re.exec = function() {
+    var result = [];
+    result.groups = { a: "7" };
+    return result;
+  };
+  return "".replace(re, "$<a>") !== "7";
+});
+fixRegExpWellKnownSymbolLogic$1("replace", function(_2, nativeReplace2, maybeCallNative) {
+  var UNSAFE_SUBSTITUTE = REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE ? "$" : "$0";
+  return [
+    function replace2(searchValue, replaceValue) {
+      var O2 = requireObjectCoercible$4(this);
+      var replacer = isNullOrUndefined$1(searchValue) ? void 0 : getMethod$1(searchValue, REPLACE);
+      return replacer ? call$2(replacer, searchValue, O2, replaceValue) : call$2(nativeReplace2, toString$4(O2), searchValue, replaceValue);
+    },
+    function(string, replaceValue) {
+      var rx = anObject$2(this);
+      var S = toString$4(string);
+      if (typeof replaceValue == "string" && stringIndexOf$1(replaceValue, UNSAFE_SUBSTITUTE) === -1 && stringIndexOf$1(replaceValue, "$<") === -1) {
+        var res = maybeCallNative(nativeReplace2, rx, S, replaceValue);
+        if (res.done)
+          return res.value;
+      }
+      var functionalReplace = isCallable(replaceValue);
+      if (!functionalReplace)
+        replaceValue = toString$4(replaceValue);
+      var global2 = rx.global;
+      if (global2) {
+        var fullUnicode = rx.unicode;
+        rx.lastIndex = 0;
+      }
+      var results = [];
+      while (true) {
+        var result = regExpExec(rx, S);
+        if (result === null)
+          break;
+        push$1(results, result);
+        if (!global2)
+          break;
+        var matchStr = toString$4(result[0]);
+        if (matchStr === "")
+          rx.lastIndex = advanceStringIndex$1(S, toLength$3(rx.lastIndex), fullUnicode);
+      }
+      var accumulatedResult = "";
+      var nextSourcePosition = 0;
+      for (var i2 = 0; i2 < results.length; i2++) {
+        result = results[i2];
+        var matched = toString$4(result[0]);
+        var position = max(min$3(toIntegerOrInfinity(result.index), S.length), 0);
+        var captures = [];
+        for (var j = 1; j < result.length; j++)
+          push$1(captures, maybeToString(result[j]));
+        var namedCaptures = result.groups;
+        if (functionalReplace) {
+          var replacerArgs = concat([matched], captures, position, S);
+          if (namedCaptures !== void 0)
+            push$1(replacerArgs, namedCaptures);
+          var replacement = toString$4(apply$1(replaceValue, void 0, replacerArgs));
+        } else {
+          replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue);
+        }
+        if (position >= nextSourcePosition) {
+          accumulatedResult += stringSlice$2(S, nextSourcePosition, position) + replacement;
+          nextSourcePosition = position + matched.length;
+        }
+      }
+      return accumulatedResult + stringSlice$2(S, nextSourcePosition);
+    }
+  ];
+}, !REPLACE_SUPPORTS_NAMED_GROUPS || !REPLACE_KEEPS_$0 || REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE);
+var isObject = isObject$1;
+var classof = classofRaw;
+var wellKnownSymbol$2 = wellKnownSymbol$5;
+var MATCH$1 = wellKnownSymbol$2("match");
+var isRegexp = function(it) {
+  var isRegExp2;
+  return isObject(it) && ((isRegExp2 = it[MATCH$1]) !== void 0 ? !!isRegExp2 : classof(it) == "RegExp");
+};
+var isRegExp$1 = isRegexp;
+var $TypeError = TypeError;
+var notARegexp = function(it) {
+  if (isRegExp$1(it)) {
+    throw $TypeError("The method doesn't accept regular expressions");
+  }
+  return it;
+};
+var wellKnownSymbol$1 = wellKnownSymbol$5;
+var MATCH = wellKnownSymbol$1("match");
+var correctIsRegexpLogic = function(METHOD_NAME) {
+  var regexp = /./;
+  try {
+    "/./"[METHOD_NAME](regexp);
+  } catch (error1) {
+    try {
+      regexp[MATCH] = false;
+      return "/./"[METHOD_NAME](regexp);
+    } catch (error2) {
+    }
+  }
+  return false;
+};
+var $$4 = _export;
+var uncurryThis$5 = functionUncurryThis;
+var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f;
+var toLength$2 = toLength$5;
+var toString$3 = toString$7;
+var notARegExp$2 = notARegexp;
+var requireObjectCoercible$3 = requireObjectCoercible$6;
+var correctIsRegExpLogic$2 = correctIsRegexpLogic;
+var nativeStartsWith = uncurryThis$5("".startsWith);
+var stringSlice$1 = uncurryThis$5("".slice);
+var min$2 = Math.min;
+var CORRECT_IS_REGEXP_LOGIC$1 = correctIsRegExpLogic$2("startsWith");
+var MDN_POLYFILL_BUG$1 = !CORRECT_IS_REGEXP_LOGIC$1 && !!function() {
+  var descriptor = getOwnPropertyDescriptor$1(String.prototype, "startsWith");
+  return descriptor && !descriptor.writable;
+}();
+$$4({ target: "String", proto: true, forced: !MDN_POLYFILL_BUG$1 && !CORRECT_IS_REGEXP_LOGIC$1 }, {
+  startsWith: function startsWith(searchString) {
+    var that = toString$3(requireObjectCoercible$3(this));
+    notARegExp$2(searchString);
+    var index2 = toLength$2(min$2(arguments.length > 1 ? arguments[1] : void 0, that.length));
+    var search = toString$3(searchString);
+    return nativeStartsWith ? nativeStartsWith(that, search, index2) : stringSlice$1(that, index2, index2 + search.length) === search;
+  }
+});
+var domIterables = {
+  CSSRuleList: 0,
+  CSSStyleDeclaration: 0,
+  CSSValueList: 0,
+  ClientRectList: 0,
+  DOMRectList: 0,
+  DOMStringList: 0,
+  DOMTokenList: 1,
+  DataTransferItemList: 0,
+  FileList: 0,
+  HTMLAllCollection: 0,
+  HTMLCollection: 0,
+  HTMLFormElement: 0,
+  HTMLSelectElement: 0,
+  MediaList: 0,
+  MimeTypeArray: 0,
+  NamedNodeMap: 0,
+  NodeList: 1,
+  PaintRequestList: 0,
+  Plugin: 0,
+  PluginArray: 0,
+  SVGLengthList: 0,
+  SVGNumberList: 0,
+  SVGPathSegList: 0,
+  SVGPointList: 0,
+  SVGStringList: 0,
+  SVGTransformList: 0,
+  SourceBufferList: 0,
+  StyleSheetList: 0,
+  TextTrackCueList: 0,
+  TextTrackList: 0,
+  TouchList: 0
+};
+var documentCreateElement = documentCreateElement$1;
+var classList = documentCreateElement("span").classList;
+var DOMTokenListPrototype$1 = classList && classList.constructor && classList.constructor.prototype;
+var domTokenListPrototype = DOMTokenListPrototype$1 === Object.prototype ? void 0 : DOMTokenListPrototype$1;
+var global = global$4;
+var DOMIterables = domIterables;
+var DOMTokenListPrototype = domTokenListPrototype;
+var ArrayIteratorMethods = es_array_iterator;
+var createNonEnumerableProperty = createNonEnumerableProperty$2;
+var wellKnownSymbol = wellKnownSymbol$5;
+var ITERATOR = wellKnownSymbol("iterator");
+var TO_STRING_TAG = wellKnownSymbol("toStringTag");
+var ArrayValues = ArrayIteratorMethods.values;
+var handlePrototype = function(CollectionPrototype, COLLECTION_NAME) {
+  if (CollectionPrototype) {
+    if (CollectionPrototype[ITERATOR] !== ArrayValues)
+      try {
+        createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues);
+      } catch (error) {
+        CollectionPrototype[ITERATOR] = ArrayValues;
+      }
+    if (!CollectionPrototype[TO_STRING_TAG]) {
+      createNonEnumerableProperty(CollectionPrototype, TO_STRING_TAG, COLLECTION_NAME);
+    }
+    if (DOMIterables[COLLECTION_NAME])
+      for (var METHOD_NAME in ArrayIteratorMethods) {
+        if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME])
+          try {
+            createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]);
+          } catch (error) {
+            CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME];
+          }
+      }
+  }
+};
+for (var COLLECTION_NAME in DOMIterables) {
+  handlePrototype(global[COLLECTION_NAME] && global[COLLECTION_NAME].prototype, COLLECTION_NAME);
+}
+handlePrototype(DOMTokenListPrototype, "DOMTokenList");
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var $$3 = _export;
+var uncurryThis$4 = functionUncurryThis;
+var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;
+var toLength$1 = toLength$5;
+var toString$2 = toString$7;
+var notARegExp$1 = notARegexp;
+var requireObjectCoercible$2 = requireObjectCoercible$6;
+var correctIsRegExpLogic$1 = correctIsRegexpLogic;
+var nativeEndsWith = uncurryThis$4("".endsWith);
+var slice = uncurryThis$4("".slice);
+var min$1 = Math.min;
+var CORRECT_IS_REGEXP_LOGIC = correctIsRegExpLogic$1("endsWith");
+var MDN_POLYFILL_BUG = !CORRECT_IS_REGEXP_LOGIC && !!function() {
+  var descriptor = getOwnPropertyDescriptor(String.prototype, "endsWith");
+  return descriptor && !descriptor.writable;
+}();
+$$3({ target: "String", proto: true, forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC }, {
+  endsWith: function endsWith(searchString) {
+    var that = toString$2(requireObjectCoercible$2(this));
+    notARegExp$1(searchString);
+    var endPosition = arguments.length > 1 ? arguments[1] : void 0;
+    var len = that.length;
+    var end = endPosition === void 0 ? len : min$1(toLength$1(endPosition), len);
+    var search = toString$2(searchString);
+    return nativeEndsWith ? nativeEndsWith(that, search, end) : slice(that, end - search.length, end) === search;
+  }
+});
+var apply = functionApply;
+var call$1 = functionCall;
+var uncurryThis$3 = functionUncurryThis;
+var fixRegExpWellKnownSymbolLogic = fixRegexpWellKnownSymbolLogic;
+var anObject$1 = anObject$6;
+var isNullOrUndefined = isNullOrUndefined$3;
+var isRegExp = isRegexp;
+var requireObjectCoercible$1 = requireObjectCoercible$6;
+var speciesConstructor = speciesConstructor$1;
+var advanceStringIndex = advanceStringIndex$3;
+var toLength = toLength$5;
+var toString$1 = toString$7;
+var getMethod = getMethod$3;
+var arraySlice = arraySliceSimple;
+var callRegExpExec = regexpExecAbstract;
+var regexpExec = regexpExec$3;
+var stickyHelpers = regexpStickyHelpers;
+var fails$1 = fails$7;
+var UNSUPPORTED_Y = stickyHelpers.UNSUPPORTED_Y;
+var MAX_UINT32 = 4294967295;
+var min = Math.min;
+var $push = [].push;
+var exec = uncurryThis$3(/./.exec);
+var push = uncurryThis$3($push);
+var stringSlice = uncurryThis$3("".slice);
+var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = !fails$1(function() {
+  var re = /(?:)/;
+  var originalExec = re.exec;
+  re.exec = function() {
+    return originalExec.apply(this, arguments);
+  };
+  var result = "ab".split(re);
+  return result.length !== 2 || result[0] !== "a" || result[1] !== "b";
+});
+fixRegExpWellKnownSymbolLogic("split", function(SPLIT, nativeSplit, maybeCallNative) {
+  var internalSplit;
+  if ("abbc".split(/(b)*/)[1] == "c" || "test".split(/(?:)/, -1).length != 4 || "ab".split(/(?:ab)*/).length != 2 || ".".split(/(.?)(.?)/).length != 4 || ".".split(/()()/).length > 1 || "".split(/.?/).length) {
+    internalSplit = function(separator, limit) {
+      var string = toString$1(requireObjectCoercible$1(this));
+      var lim = limit === void 0 ? MAX_UINT32 : limit >>> 0;
+      if (lim === 0)
+        return [];
+      if (separator === void 0)
+        return [string];
+      if (!isRegExp(separator)) {
+        return call$1(nativeSplit, string, separator, lim);
+      }
+      var output = [];
+      var flags = (separator.ignoreCase ? "i" : "") + (separator.multiline ? "m" : "") + (separator.unicode ? "u" : "") + (separator.sticky ? "y" : "");
+      var lastLastIndex = 0;
+      var separatorCopy = new RegExp(separator.source, flags + "g");
+      var match, lastIndex, lastLength;
+      while (match = call$1(regexpExec, separatorCopy, string)) {
+        lastIndex = separatorCopy.lastIndex;
+        if (lastIndex > lastLastIndex) {
+          push(output, stringSlice(string, lastLastIndex, match.index));
+          if (match.length > 1 && match.index < string.length)
+            apply($push, output, arraySlice(match, 1));
+          lastLength = match[0].length;
+          lastLastIndex = lastIndex;
+          if (output.length >= lim)
+            break;
+        }
+        if (separatorCopy.lastIndex === match.index)
+          separatorCopy.lastIndex++;
+      }
+      if (lastLastIndex === string.length) {
+        if (lastLength || !exec(separatorCopy, ""))
+          push(output, "");
+      } else
+        push(output, stringSlice(string, lastLastIndex));
+      return output.length > lim ? arraySlice(output, 0, lim) : output;
+    };
+  } else if ("0".split(void 0, 0).length) {
+    internalSplit = function(separator, limit) {
+      return separator === void 0 && limit === 0 ? [] : call$1(nativeSplit, this, separator, limit);
+    };
+  } else
+    internalSplit = nativeSplit;
+  return [
+    function split(separator, limit) {
+      var O2 = requireObjectCoercible$1(this);
+      var splitter = isNullOrUndefined(separator) ? void 0 : getMethod(separator, SPLIT);
+      return splitter ? call$1(splitter, separator, O2, limit) : call$1(internalSplit, toString$1(O2), separator, limit);
+    },
+    function(string, limit) {
+      var rx = anObject$1(this);
+      var S = toString$1(string);
+      var res = maybeCallNative(internalSplit, rx, S, limit, internalSplit !== nativeSplit);
+      if (res.done)
+        return res.value;
+      var C = speciesConstructor(rx, RegExp);
+      var unicodeMatching = rx.unicode;
+      var flags = (rx.ignoreCase ? "i" : "") + (rx.multiline ? "m" : "") + (rx.unicode ? "u" : "") + (UNSUPPORTED_Y ? "g" : "y");
+      var splitter = new C(UNSUPPORTED_Y ? "^(?:" + rx.source + ")" : rx, flags);
+      var lim = limit === void 0 ? MAX_UINT32 : limit >>> 0;
+      if (lim === 0)
+        return [];
+      if (S.length === 0)
+        return callRegExpExec(splitter, S) === null ? [S] : [];
+      var p2 = 0;
+      var q = 0;
+      var A = [];
+      while (q < S.length) {
+        splitter.lastIndex = UNSUPPORTED_Y ? 0 : q;
+        var z = callRegExpExec(splitter, UNSUPPORTED_Y ? stringSlice(S, q) : S);
+        var e2;
+        if (z === null || (e2 = min(toLength(splitter.lastIndex + (UNSUPPORTED_Y ? q : 0)), S.length)) === p2) {
+          q = advanceStringIndex(S, q, unicodeMatching);
+        } else {
+          push(A, stringSlice(S, p2, q));
+          if (A.length === lim)
+            return A;
+          for (var i2 = 1; i2 <= z.length - 1; i2++) {
+            push(A, z[i2]);
+            if (A.length === lim)
+              return A;
+          }
+          q = p2 = e2;
+        }
+      }
+      push(A, stringSlice(S, p2));
+      return A;
+    }
+  ];
+}, !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC, UNSUPPORTED_Y);
+var _raf_3_4_1_raf = { exports: {} };
+var performanceNow = { exports: {} };
+(function() {
+  var getNanoSeconds, hrtime, loadTime, moduleLoadTime, nodeLoadTime, upTime;
+  if (typeof performance !== "undefined" && performance !== null && performance.now) {
+    performanceNow.exports = function() {
+      return performance.now();
+    };
+  } else if (typeof process !== "undefined" && process !== null && process.hrtime) {
+    performanceNow.exports = function() {
+      return (getNanoSeconds() - nodeLoadTime) / 1e6;
+    };
+    hrtime = process.hrtime;
+    getNanoSeconds = function() {
+      var hr;
+      hr = hrtime();
+      return hr[0] * 1e9 + hr[1];
+    };
+    moduleLoadTime = getNanoSeconds();
+    upTime = process.uptime() * 1e9;
+    nodeLoadTime = moduleLoadTime - upTime;
+  } else if (Date.now) {
+    performanceNow.exports = function() {
+      return Date.now() - loadTime;
+    };
+    loadTime = Date.now();
+  } else {
+    performanceNow.exports = function() {
+      return new Date().getTime() - loadTime;
+    };
+    loadTime = new Date().getTime();
+  }
+}).call(commonjsGlobal);
+var now = performanceNow.exports, root = typeof window === "undefined" ? commonjsGlobal : window, vendors = ["moz", "webkit"], suffix = "AnimationFrame", raf = root["request" + suffix], caf = root["cancel" + suffix] || root["cancelRequest" + suffix];
+for (var i$1 = 0; !raf && i$1 < vendors.length; i$1++) {
+  raf = root[vendors[i$1] + "Request" + suffix];
+  caf = root[vendors[i$1] + "Cancel" + suffix] || root[vendors[i$1] + "CancelRequest" + suffix];
+}
+if (!raf || !caf) {
+  var last = 0, id = 0, queue = [], frameDuration = 1e3 / 60;
+  raf = function(callback) {
+    if (queue.length === 0) {
+      var _now = now(), next = Math.max(0, frameDuration - (_now - last));
+      last = next + _now;
+      setTimeout(function() {
+        var cp = queue.slice(0);
+        queue.length = 0;
+        for (var i2 = 0; i2 < cp.length; i2++) {
+          if (!cp[i2].cancelled) {
+            try {
+              cp[i2].callback(last);
+            } catch (e2) {
+              setTimeout(function() {
+                throw e2;
+              }, 0);
+            }
+          }
+        }
+      }, Math.round(next));
+    }
+    queue.push({
+      handle: ++id,
+      callback,
+      cancelled: false
+    });
+    return id;
+  };
+  caf = function(handle) {
+    for (var i2 = 0; i2 < queue.length; i2++) {
+      if (queue[i2].handle === handle) {
+        queue[i2].cancelled = true;
+      }
+    }
+  };
+}
+_raf_3_4_1_raf.exports = function(fn) {
+  return raf.call(root, fn);
+};
+_raf_3_4_1_raf.exports.cancel = function() {
+  caf.apply(root, arguments);
+};
+_raf_3_4_1_raf.exports.polyfill = function(object) {
+  if (!object) {
+    object = root;
+  }
+  object.requestAnimationFrame = raf;
+  object.cancelAnimationFrame = caf;
+};
+var requestAnimationFrame = _raf_3_4_1_raf.exports;
+var _rgbcolor_1_0_1_rgbcolor = function(color_string) {
+  this.ok = false;
+  this.alpha = 1;
+  if (color_string.charAt(0) == "#") {
+    color_string = color_string.substr(1, 6);
+  }
+  color_string = color_string.replace(/ /g, "");
+  color_string = color_string.toLowerCase();
+  var simple_colors = {
+    aliceblue: "f0f8ff",
+    antiquewhite: "faebd7",
+    aqua: "00ffff",
+    aquamarine: "7fffd4",
+    azure: "f0ffff",
+    beige: "f5f5dc",
+    bisque: "ffe4c4",
+    black: "000000",
+    blanchedalmond: "ffebcd",
+    blue: "0000ff",
+    blueviolet: "8a2be2",
+    brown: "a52a2a",
+    burlywood: "deb887",
+    cadetblue: "5f9ea0",
+    chartreuse: "7fff00",
+    chocolate: "d2691e",
+    coral: "ff7f50",
+    cornflowerblue: "6495ed",
+    cornsilk: "fff8dc",
+    crimson: "dc143c",
+    cyan: "00ffff",
+    darkblue: "00008b",
+    darkcyan: "008b8b",
+    darkgoldenrod: "b8860b",
+    darkgray: "a9a9a9",
+    darkgreen: "006400",
+    darkkhaki: "bdb76b",
+    darkmagenta: "8b008b",
+    darkolivegreen: "556b2f",
+    darkorange: "ff8c00",
+    darkorchid: "9932cc",
+    darkred: "8b0000",
+    darksalmon: "e9967a",
+    darkseagreen: "8fbc8f",
+    darkslateblue: "483d8b",
+    darkslategray: "2f4f4f",
+    darkturquoise: "00ced1",
+    darkviolet: "9400d3",
+    deeppink: "ff1493",
+    deepskyblue: "00bfff",
+    dimgray: "696969",
+    dodgerblue: "1e90ff",
+    feldspar: "d19275",
+    firebrick: "b22222",
+    floralwhite: "fffaf0",
+    forestgreen: "228b22",
+    fuchsia: "ff00ff",
+    gainsboro: "dcdcdc",
+    ghostwhite: "f8f8ff",
+    gold: "ffd700",
+    goldenrod: "daa520",
+    gray: "808080",
+    green: "008000",
+    greenyellow: "adff2f",
+    honeydew: "f0fff0",
+    hotpink: "ff69b4",
+    indianred: "cd5c5c",
+    indigo: "4b0082",
+    ivory: "fffff0",
+    khaki: "f0e68c",
+    lavender: "e6e6fa",
+    lavenderblush: "fff0f5",
+    lawngreen: "7cfc00",
+    lemonchiffon: "fffacd",
+    lightblue: "add8e6",
+    lightcoral: "f08080",
+    lightcyan: "e0ffff",
+    lightgoldenrodyellow: "fafad2",
+    lightgrey: "d3d3d3",
+    lightgreen: "90ee90",
+    lightpink: "ffb6c1",
+    lightsalmon: "ffa07a",
+    lightseagreen: "20b2aa",
+    lightskyblue: "87cefa",
+    lightslateblue: "8470ff",
+    lightslategray: "778899",
+    lightsteelblue: "b0c4de",
+    lightyellow: "ffffe0",
+    lime: "00ff00",
+    limegreen: "32cd32",
+    linen: "faf0e6",
+    magenta: "ff00ff",
+    maroon: "800000",
+    mediumaquamarine: "66cdaa",
+    mediumblue: "0000cd",
+    mediumorchid: "ba55d3",
+    mediumpurple: "9370d8",
+    mediumseagreen: "3cb371",
+    mediumslateblue: "7b68ee",
+    mediumspringgreen: "00fa9a",
+    mediumturquoise: "48d1cc",
+    mediumvioletred: "c71585",
+    midnightblue: "191970",
+    mintcream: "f5fffa",
+    mistyrose: "ffe4e1",
+    moccasin: "ffe4b5",
+    navajowhite: "ffdead",
+    navy: "000080",
+    oldlace: "fdf5e6",
+    olive: "808000",
+    olivedrab: "6b8e23",
+    orange: "ffa500",
+    orangered: "ff4500",
+    orchid: "da70d6",
+    palegoldenrod: "eee8aa",
+    palegreen: "98fb98",
+    paleturquoise: "afeeee",
+    palevioletred: "d87093",
+    papayawhip: "ffefd5",
+    peachpuff: "ffdab9",
+    peru: "cd853f",
+    pink: "ffc0cb",
+    plum: "dda0dd",
+    powderblue: "b0e0e6",
+    purple: "800080",
+    rebeccapurple: "663399",
+    red: "ff0000",
+    rosybrown: "bc8f8f",
+    royalblue: "4169e1",
+    saddlebrown: "8b4513",
+    salmon: "fa8072",
+    sandybrown: "f4a460",
+    seagreen: "2e8b57",
+    seashell: "fff5ee",
+    sienna: "a0522d",
+    silver: "c0c0c0",
+    skyblue: "87ceeb",
+    slateblue: "6a5acd",
+    slategray: "708090",
+    snow: "fffafa",
+    springgreen: "00ff7f",
+    steelblue: "4682b4",
+    tan: "d2b48c",
+    teal: "008080",
+    thistle: "d8bfd8",
+    tomato: "ff6347",
+    turquoise: "40e0d0",
+    violet: "ee82ee",
+    violetred: "d02090",
+    wheat: "f5deb3",
+    white: "ffffff",
+    whitesmoke: "f5f5f5",
+    yellow: "ffff00",
+    yellowgreen: "9acd32"
+  };
+  color_string = simple_colors[color_string] || color_string;
+  var color_defs = [
+    {
+      re: /^rgba\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3}),\s*((?:\d?\.)?\d)\)$/,
+      example: ["rgba(123, 234, 45, 0.8)", "rgba(255,234,245,1.0)"],
+      process: function(bits2) {
+        return [
+          parseInt(bits2[1]),
+          parseInt(bits2[2]),
+          parseInt(bits2[3]),
+          parseFloat(bits2[4])
+        ];
+      }
+    },
+    {
+      re: /^rgb\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3})\)$/,
+      example: ["rgb(123, 234, 45)", "rgb(255,234,245)"],
+      process: function(bits2) {
+        return [
+          parseInt(bits2[1]),
+          parseInt(bits2[2]),
+          parseInt(bits2[3])
+        ];
+      }
+    },
+    {
+      re: /^([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,
+      example: ["#00ff00", "336699"],
+      process: function(bits2) {
+        return [
+          parseInt(bits2[1], 16),
+          parseInt(bits2[2], 16),
+          parseInt(bits2[3], 16)
+        ];
+      }
+    },
+    {
+      re: /^([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
+      example: ["#fb0", "f0f"],
+      process: function(bits2) {
+        return [
+          parseInt(bits2[1] + bits2[1], 16),
+          parseInt(bits2[2] + bits2[2], 16),
+          parseInt(bits2[3] + bits2[3], 16)
+        ];
+      }
+    }
+  ];
+  for (var i2 = 0; i2 < color_defs.length; i2++) {
+    var re = color_defs[i2].re;
+    var processor = color_defs[i2].process;
+    var bits = re.exec(color_string);
+    if (bits) {
+      var channels = processor(bits);
+      this.r = channels[0];
+      this.g = channels[1];
+      this.b = channels[2];
+      if (channels.length > 3) {
+        this.alpha = channels[3];
+      }
+      this.ok = true;
+    }
+  }
+  this.r = this.r < 0 || isNaN(this.r) ? 0 : this.r > 255 ? 255 : this.r;
+  this.g = this.g < 0 || isNaN(this.g) ? 0 : this.g > 255 ? 255 : this.g;
+  this.b = this.b < 0 || isNaN(this.b) ? 0 : this.b > 255 ? 255 : this.b;
+  this.alpha = this.alpha < 0 ? 0 : this.alpha > 1 || isNaN(this.alpha) ? 1 : this.alpha;
+  this.toRGB = function() {
+    return "rgb(" + this.r + ", " + this.g + ", " + this.b + ")";
+  };
+  this.toRGBA = function() {
+    return "rgba(" + this.r + ", " + this.g + ", " + this.b + ", " + this.alpha + ")";
+  };
+  this.toHex = function() {
+    var r2 = this.r.toString(16);
+    var g = this.g.toString(16);
+    var b = this.b.toString(16);
+    if (r2.length == 1)
+      r2 = "0" + r2;
+    if (g.length == 1)
+      g = "0" + g;
+    if (b.length == 1)
+      b = "0" + b;
+    return "#" + r2 + g + b;
+  };
+  this.getHelpXML = function() {
+    var examples = new Array();
+    for (var i3 = 0; i3 < color_defs.length; i3++) {
+      var example = color_defs[i3].example;
+      for (var j = 0; j < example.length; j++) {
+        examples[examples.length] = example[j];
+      }
+    }
+    for (var sc in simple_colors) {
+      examples[examples.length] = sc;
+    }
+    var xml = document.createElement("ul");
+    xml.setAttribute("id", "rgbcolor-examples");
+    for (var i3 = 0; i3 < examples.length; i3++) {
+      try {
+        var list_item = document.createElement("li");
+        var list_color = new RGBColor(examples[i3]);
+        var example_div = document.createElement("div");
+        example_div.style.cssText = "margin: 3px; border: 1px solid black; background:" + list_color.toHex() + "; color:" + list_color.toHex();
+        example_div.appendChild(document.createTextNode("test"));
+        var list_item_value = document.createTextNode(
+          " " + examples[i3] + " -> " + list_color.toRGB() + " -> " + list_color.toHex()
+        );
+        list_item.appendChild(example_div);
+        list_item.appendChild(list_item_value);
+        xml.appendChild(list_item);
+      } catch (e2) {
+      }
+    }
+    return xml;
+  };
+};
+var $$2 = _export;
+var uncurryThis$2 = functionUncurryThis;
+var $indexOf = arrayIncludes.indexOf;
+var arrayMethodIsStrict = arrayMethodIsStrict$1;
+var nativeIndexOf = uncurryThis$2([].indexOf);
+var NEGATIVE_ZERO = !!nativeIndexOf && 1 / nativeIndexOf([1], 1, -0) < 0;
+var STRICT_METHOD = arrayMethodIsStrict("indexOf");
+$$2({ target: "Array", proto: true, forced: NEGATIVE_ZERO || !STRICT_METHOD }, {
+  indexOf: function indexOf2(searchElement) {
+    var fromIndex = arguments.length > 1 ? arguments[1] : void 0;
+    return NEGATIVE_ZERO ? nativeIndexOf(this, searchElement, fromIndex) || 0 : $indexOf(this, searchElement, fromIndex);
+  }
+});
+var $$1 = _export;
+var uncurryThis$1 = functionUncurryThis;
+var notARegExp = notARegexp;
+var requireObjectCoercible = requireObjectCoercible$6;
+var toString = toString$7;
+var correctIsRegExpLogic = correctIsRegexpLogic;
+var stringIndexOf = uncurryThis$1("".indexOf);
+$$1({ target: "String", proto: true, forced: !correctIsRegExpLogic("includes") }, {
+  includes: function includes(searchString) {
+    return !!~stringIndexOf(
+      toString(requireObjectCoercible(this)),
+      toString(notARegExp(searchString)),
+      arguments.length > 1 ? arguments[1] : void 0
+    );
+  }
+});
+var $ = _export;
+var uncurryThis = functionUncurryThis;
+var isArray = isArray$1;
+var nativeReverse = uncurryThis([].reverse);
+var test = [1, 2];
+$({ target: "Array", proto: true, forced: String(test) === String(test.reverse()) }, {
+  reverse: function reverse() {
+    if (isArray(this))
+      this.length = this.length;
+    return nativeReverse(this);
+  }
+});
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+var t = function(r2, e2) {
+  return (t = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(t2, r3) {
+    t2.__proto__ = r3;
+  } || function(t2, r3) {
+    for (var e3 in r3)
+      Object.prototype.hasOwnProperty.call(r3, e3) && (t2[e3] = r3[e3]);
+  })(r2, e2);
+};
+function r(r2, e2) {
+  if ("function" != typeof e2 && null !== e2)
+    throw new TypeError("Class extends value " + String(e2) + " is not a constructor or null");
+  function i2() {
+    this.constructor = r2;
+  }
+  t(r2, e2), r2.prototype = null === e2 ? Object.create(e2) : (i2.prototype = e2.prototype, new i2());
+}
+function e(t2) {
+  var r2 = "";
+  Array.isArray(t2) || (t2 = [t2]);
+  for (var e2 = 0; e2 < t2.length; e2++) {
+    var i2 = t2[e2];
+    if (i2.type === _.CLOSE_PATH)
+      r2 += "z";
+    else if (i2.type === _.HORIZ_LINE_TO)
+      r2 += (i2.relative ? "h" : "H") + i2.x;
+    else if (i2.type === _.VERT_LINE_TO)
+      r2 += (i2.relative ? "v" : "V") + i2.y;
+    else if (i2.type === _.MOVE_TO)
+      r2 += (i2.relative ? "m" : "M") + i2.x + " " + i2.y;
+    else if (i2.type === _.LINE_TO)
+      r2 += (i2.relative ? "l" : "L") + i2.x + " " + i2.y;
+    else if (i2.type === _.CURVE_TO)
+      r2 += (i2.relative ? "c" : "C") + i2.x1 + " " + i2.y1 + " " + i2.x2 + " " + i2.y2 + " " + i2.x + " " + i2.y;
+    else if (i2.type === _.SMOOTH_CURVE_TO)
+      r2 += (i2.relative ? "s" : "S") + i2.x2 + " " + i2.y2 + " " + i2.x + " " + i2.y;
+    else if (i2.type === _.QUAD_TO)
+      r2 += (i2.relative ? "q" : "Q") + i2.x1 + " " + i2.y1 + " " + i2.x + " " + i2.y;
+    else if (i2.type === _.SMOOTH_QUAD_TO)
+      r2 += (i2.relative ? "t" : "T") + i2.x + " " + i2.y;
+    else {
+      if (i2.type !== _.ARC)
+        throw new Error('Unexpected command type "' + i2.type + '" at index ' + e2 + ".");
+      r2 += (i2.relative ? "a" : "A") + i2.rX + " " + i2.rY + " " + i2.xRot + " " + +i2.lArcFlag + " " + +i2.sweepFlag + " " + i2.x + " " + i2.y;
+    }
+  }
+  return r2;
+}
+function i(t2, r2) {
+  var e2 = t2[0], i2 = t2[1];
+  return [e2 * Math.cos(r2) - i2 * Math.sin(r2), e2 * Math.sin(r2) + i2 * Math.cos(r2)];
+}
+function a() {
+  for (var t2 = [], r2 = 0; r2 < arguments.length; r2++)
+    t2[r2] = arguments[r2];
+  for (var e2 = 0; e2 < t2.length; e2++)
+    if ("number" != typeof t2[e2])
+      throw new Error("assertNumbers arguments[" + e2 + "] is not a number. " + typeof t2[e2] + " == typeof " + t2[e2]);
+  return true;
+}
+var n = Math.PI;
+function o(t2, r2, e2) {
+  t2.lArcFlag = 0 === t2.lArcFlag ? 0 : 1, t2.sweepFlag = 0 === t2.sweepFlag ? 0 : 1;
+  var a2 = t2.rX, o2 = t2.rY, s2 = t2.x, u2 = t2.y;
+  a2 = Math.abs(t2.rX), o2 = Math.abs(t2.rY);
+  var h2 = i([(r2 - s2) / 2, (e2 - u2) / 2], -t2.xRot / 180 * n), c2 = h2[0], y2 = h2[1], p2 = Math.pow(c2, 2) / Math.pow(a2, 2) + Math.pow(y2, 2) / Math.pow(o2, 2);
+  1 < p2 && (a2 *= Math.sqrt(p2), o2 *= Math.sqrt(p2)), t2.rX = a2, t2.rY = o2;
+  var m2 = Math.pow(a2, 2) * Math.pow(y2, 2) + Math.pow(o2, 2) * Math.pow(c2, 2), O2 = (t2.lArcFlag !== t2.sweepFlag ? 1 : -1) * Math.sqrt(Math.max(0, (Math.pow(a2, 2) * Math.pow(o2, 2) - m2) / m2)), l2 = a2 * y2 / o2 * O2, T2 = -o2 * c2 / a2 * O2, v2 = i([l2, T2], t2.xRot / 180 * n);
+  t2.cX = v2[0] + (r2 + s2) / 2, t2.cY = v2[1] + (e2 + u2) / 2, t2.phi1 = Math.atan2((y2 - T2) / o2, (c2 - l2) / a2), t2.phi2 = Math.atan2((-y2 - T2) / o2, (-c2 - l2) / a2), 0 === t2.sweepFlag && t2.phi2 > t2.phi1 && (t2.phi2 -= 2 * n), 1 === t2.sweepFlag && t2.phi2 < t2.phi1 && (t2.phi2 += 2 * n), t2.phi1 *= 180 / n, t2.phi2 *= 180 / n;
+}
+function s(t2, r2, e2) {
+  a(t2, r2, e2);
+  var i2 = t2 * t2 + r2 * r2 - e2 * e2;
+  if (0 > i2)
+    return [];
+  if (0 === i2)
+    return [[t2 * e2 / (t2 * t2 + r2 * r2), r2 * e2 / (t2 * t2 + r2 * r2)]];
+  var n2 = Math.sqrt(i2);
+  return [[(t2 * e2 + r2 * n2) / (t2 * t2 + r2 * r2), (r2 * e2 - t2 * n2) / (t2 * t2 + r2 * r2)], [(t2 * e2 - r2 * n2) / (t2 * t2 + r2 * r2), (r2 * e2 + t2 * n2) / (t2 * t2 + r2 * r2)]];
+}
+var u, h = Math.PI / 180;
+function c$1(t2, r2, e2) {
+  return (1 - e2) * t2 + e2 * r2;
+}
+function y(t2, r2, e2, i2) {
+  return t2 + Math.cos(i2 / 180 * n) * r2 + Math.sin(i2 / 180 * n) * e2;
+}
+function p(t2, r2, e2, i2) {
+  var a2 = 1e-6, n2 = r2 - t2, o2 = e2 - r2, s2 = 3 * n2 + 3 * (i2 - e2) - 6 * o2, u2 = 6 * (o2 - n2), h2 = 3 * n2;
+  return Math.abs(s2) < a2 ? [-h2 / u2] : function(t3, r3, e3) {
+    void 0 === e3 && (e3 = 1e-6);
+    var i3 = t3 * t3 / 4 - r3;
+    if (i3 < -e3)
+      return [];
+    if (i3 <= e3)
+      return [-t3 / 2];
+    var a3 = Math.sqrt(i3);
+    return [-t3 / 2 - a3, -t3 / 2 + a3];
+  }(u2 / s2, h2 / s2, a2);
+}
+function m$1(t2, r2, e2, i2, a2) {
+  var n2 = 1 - a2;
+  return t2 * (n2 * n2 * n2) + r2 * (3 * n2 * n2 * a2) + e2 * (3 * n2 * a2 * a2) + i2 * (a2 * a2 * a2);
+}
+!function(t2) {
+  function r2() {
+    return u2(function(t3, r3, e3) {
+      return t3.relative && (void 0 !== t3.x1 && (t3.x1 += r3), void 0 !== t3.y1 && (t3.y1 += e3), void 0 !== t3.x2 && (t3.x2 += r3), void 0 !== t3.y2 && (t3.y2 += e3), void 0 !== t3.x && (t3.x += r3), void 0 !== t3.y && (t3.y += e3), t3.relative = false), t3;
+    });
+  }
+  function e2() {
+    var t3 = NaN, r3 = NaN, e3 = NaN, i2 = NaN;
+    return u2(function(a2, n3, o2) {
+      return a2.type & _.SMOOTH_CURVE_TO && (a2.type = _.CURVE_TO, t3 = isNaN(t3) ? n3 : t3, r3 = isNaN(r3) ? o2 : r3, a2.x1 = a2.relative ? n3 - t3 : 2 * n3 - t3, a2.y1 = a2.relative ? o2 - r3 : 2 * o2 - r3), a2.type & _.CURVE_TO ? (t3 = a2.relative ? n3 + a2.x2 : a2.x2, r3 = a2.relative ? o2 + a2.y2 : a2.y2) : (t3 = NaN, r3 = NaN), a2.type & _.SMOOTH_QUAD_TO && (a2.type = _.QUAD_TO, e3 = isNaN(e3) ? n3 : e3, i2 = isNaN(i2) ? o2 : i2, a2.x1 = a2.relative ? n3 - e3 : 2 * n3 - e3, a2.y1 = a2.relative ? o2 - i2 : 2 * o2 - i2), a2.type & _.QUAD_TO ? (e3 = a2.relative ? n3 + a2.x1 : a2.x1, i2 = a2.relative ? o2 + a2.y1 : a2.y1) : (e3 = NaN, i2 = NaN), a2;
+    });
+  }
+  function n2() {
+    var t3 = NaN, r3 = NaN;
+    return u2(function(e3, i2, a2) {
+      if (e3.type & _.SMOOTH_QUAD_TO && (e3.type = _.QUAD_TO, t3 = isNaN(t3) ? i2 : t3, r3 = isNaN(r3) ? a2 : r3, e3.x1 = e3.relative ? i2 - t3 : 2 * i2 - t3, e3.y1 = e3.relative ? a2 - r3 : 2 * a2 - r3), e3.type & _.QUAD_TO) {
+        t3 = e3.relative ? i2 + e3.x1 : e3.x1, r3 = e3.relative ? a2 + e3.y1 : e3.y1;
+        var n3 = e3.x1, o2 = e3.y1;
+        e3.type = _.CURVE_TO, e3.x1 = ((e3.relative ? 0 : i2) + 2 * n3) / 3, e3.y1 = ((e3.relative ? 0 : a2) + 2 * o2) / 3, e3.x2 = (e3.x + 2 * n3) / 3, e3.y2 = (e3.y + 2 * o2) / 3;
+      } else
+        t3 = NaN, r3 = NaN;
+      return e3;
+    });
+  }
+  function u2(t3) {
+    var r3 = 0, e3 = 0, i2 = NaN, a2 = NaN;
+    return function(n3) {
+      if (isNaN(i2) && !(n3.type & _.MOVE_TO))
+        throw new Error("path must start with moveto");
+      var o2 = t3(n3, r3, e3, i2, a2);
+      return n3.type & _.CLOSE_PATH && (r3 = i2, e3 = a2), void 0 !== n3.x && (r3 = n3.relative ? r3 + n3.x : n3.x), void 0 !== n3.y && (e3 = n3.relative ? e3 + n3.y : n3.y), n3.type & _.MOVE_TO && (i2 = r3, a2 = e3), o2;
+    };
+  }
+  function O2(t3, r3, e3, i2, n3, o2) {
+    return a(t3, r3, e3, i2, n3, o2), u2(function(a2, s2, u3, h2) {
+      var c2 = a2.x1, y2 = a2.x2, p2 = a2.relative && !isNaN(h2), m2 = void 0 !== a2.x ? a2.x : p2 ? 0 : s2, O3 = void 0 !== a2.y ? a2.y : p2 ? 0 : u3;
+      function l3(t4) {
+        return t4 * t4;
+      }
+      a2.type & _.HORIZ_LINE_TO && 0 !== r3 && (a2.type = _.LINE_TO, a2.y = a2.relative ? 0 : u3), a2.type & _.VERT_LINE_TO && 0 !== e3 && (a2.type = _.LINE_TO, a2.x = a2.relative ? 0 : s2), void 0 !== a2.x && (a2.x = a2.x * t3 + O3 * e3 + (p2 ? 0 : n3)), void 0 !== a2.y && (a2.y = m2 * r3 + a2.y * i2 + (p2 ? 0 : o2)), void 0 !== a2.x1 && (a2.x1 = a2.x1 * t3 + a2.y1 * e3 + (p2 ? 0 : n3)), void 0 !== a2.y1 && (a2.y1 = c2 * r3 + a2.y1 * i2 + (p2 ? 0 : o2)), void 0 !== a2.x2 && (a2.x2 = a2.x2 * t3 + a2.y2 * e3 + (p2 ? 0 : n3)), void 0 !== a2.y2 && (a2.y2 = y2 * r3 + a2.y2 * i2 + (p2 ? 0 : o2));
+      var T2 = t3 * i2 - r3 * e3;
+      if (void 0 !== a2.xRot && (1 !== t3 || 0 !== r3 || 0 !== e3 || 1 !== i2))
+        if (0 === T2)
+          delete a2.rX, delete a2.rY, delete a2.xRot, delete a2.lArcFlag, delete a2.sweepFlag, a2.type = _.LINE_TO;
+        else {
+          var v2 = a2.xRot * Math.PI / 180, f2 = Math.sin(v2), N2 = Math.cos(v2), x = 1 / l3(a2.rX), d = 1 / l3(a2.rY), E = l3(N2) * x + l3(f2) * d, A = 2 * f2 * N2 * (x - d), C = l3(f2) * x + l3(N2) * d, M = E * i2 * i2 - A * r3 * i2 + C * r3 * r3, R = A * (t3 * i2 + r3 * e3) - 2 * (E * e3 * i2 + C * t3 * r3), g = E * e3 * e3 - A * t3 * e3 + C * t3 * t3, I = (Math.atan2(R, M - g) + Math.PI) % Math.PI / 2, S = Math.sin(I), L = Math.cos(I);
+          a2.rX = Math.abs(T2) / Math.sqrt(M * l3(L) + R * S * L + g * l3(S)), a2.rY = Math.abs(T2) / Math.sqrt(M * l3(S) - R * S * L + g * l3(L)), a2.xRot = 180 * I / Math.PI;
+        }
+      return void 0 !== a2.sweepFlag && 0 > T2 && (a2.sweepFlag = +!a2.sweepFlag), a2;
+    });
+  }
+  function l2() {
+    return function(t3) {
+      var r3 = {};
+      for (var e3 in t3)
+        r3[e3] = t3[e3];
+      return r3;
+    };
+  }
+  t2.ROUND = function(t3) {
+    function r3(r4) {
+      return Math.round(r4 * t3) / t3;
+    }
+    return void 0 === t3 && (t3 = 1e13), a(t3), function(t4) {
+      return void 0 !== t4.x1 && (t4.x1 = r3(t4.x1)), void 0 !== t4.y1 && (t4.y1 = r3(t4.y1)), void 0 !== t4.x2 && (t4.x2 = r3(t4.x2)), void 0 !== t4.y2 && (t4.y2 = r3(t4.y2)), void 0 !== t4.x && (t4.x = r3(t4.x)), void 0 !== t4.y && (t4.y = r3(t4.y)), void 0 !== t4.rX && (t4.rX = r3(t4.rX)), void 0 !== t4.rY && (t4.rY = r3(t4.rY)), t4;
+    };
+  }, t2.TO_ABS = r2, t2.TO_REL = function() {
+    return u2(function(t3, r3, e3) {
+      return t3.relative || (void 0 !== t3.x1 && (t3.x1 -= r3), void 0 !== t3.y1 && (t3.y1 -= e3), void 0 !== t3.x2 && (t3.x2 -= r3), void 0 !== t3.y2 && (t3.y2 -= e3), void 0 !== t3.x && (t3.x -= r3), void 0 !== t3.y && (t3.y -= e3), t3.relative = true), t3;
+    });
+  }, t2.NORMALIZE_HVZ = function(t3, r3, e3) {
+    return void 0 === t3 && (t3 = true), void 0 === r3 && (r3 = true), void 0 === e3 && (e3 = true), u2(function(i2, a2, n3, o2, s2) {
+      if (isNaN(o2) && !(i2.type & _.MOVE_TO))
+        throw new Error("path must start with moveto");
+      return r3 && i2.type & _.HORIZ_LINE_TO && (i2.type = _.LINE_TO, i2.y = i2.relative ? 0 : n3), e3 && i2.type & _.VERT_LINE_TO && (i2.type = _.LINE_TO, i2.x = i2.relative ? 0 : a2), t3 && i2.type & _.CLOSE_PATH && (i2.type = _.LINE_TO, i2.x = i2.relative ? o2 - a2 : o2, i2.y = i2.relative ? s2 - n3 : s2), i2.type & _.ARC && (0 === i2.rX || 0 === i2.rY) && (i2.type = _.LINE_TO, delete i2.rX, delete i2.rY, delete i2.xRot, delete i2.lArcFlag, delete i2.sweepFlag), i2;
+    });
+  }, t2.NORMALIZE_ST = e2, t2.QT_TO_C = n2, t2.INFO = u2, t2.SANITIZE = function(t3) {
+    void 0 === t3 && (t3 = 0), a(t3);
+    var r3 = NaN, e3 = NaN, i2 = NaN, n3 = NaN;
+    return u2(function(a2, o2, s2, u3, h2) {
+      var c2 = Math.abs, y2 = false, p2 = 0, m2 = 0;
+      if (a2.type & _.SMOOTH_CURVE_TO && (p2 = isNaN(r3) ? 0 : o2 - r3, m2 = isNaN(e3) ? 0 : s2 - e3), a2.type & (_.CURVE_TO | _.SMOOTH_CURVE_TO) ? (r3 = a2.relative ? o2 + a2.x2 : a2.x2, e3 = a2.relative ? s2 + a2.y2 : a2.y2) : (r3 = NaN, e3 = NaN), a2.type & _.SMOOTH_QUAD_TO ? (i2 = isNaN(i2) ? o2 : 2 * o2 - i2, n3 = isNaN(n3) ? s2 : 2 * s2 - n3) : a2.type & _.QUAD_TO ? (i2 = a2.relative ? o2 + a2.x1 : a2.x1, n3 = a2.relative ? s2 + a2.y1 : a2.y2) : (i2 = NaN, n3 = NaN), a2.type & _.LINE_COMMANDS || a2.type & _.ARC && (0 === a2.rX || 0 === a2.rY || !a2.lArcFlag) || a2.type & _.CURVE_TO || a2.type & _.SMOOTH_CURVE_TO || a2.type & _.QUAD_TO || a2.type & _.SMOOTH_QUAD_TO) {
+        var O3 = void 0 === a2.x ? 0 : a2.relative ? a2.x : a2.x - o2, l3 = void 0 === a2.y ? 0 : a2.relative ? a2.y : a2.y - s2;
+        p2 = isNaN(i2) ? void 0 === a2.x1 ? p2 : a2.relative ? a2.x : a2.x1 - o2 : i2 - o2, m2 = isNaN(n3) ? void 0 === a2.y1 ? m2 : a2.relative ? a2.y : a2.y1 - s2 : n3 - s2;
+        var T2 = void 0 === a2.x2 ? 0 : a2.relative ? a2.x : a2.x2 - o2, v2 = void 0 === a2.y2 ? 0 : a2.relative ? a2.y : a2.y2 - s2;
+        c2(O3) <= t3 && c2(l3) <= t3 && c2(p2) <= t3 && c2(m2) <= t3 && c2(T2) <= t3 && c2(v2) <= t3 && (y2 = true);
+      }
+      return a2.type & _.CLOSE_PATH && c2(o2 - u3) <= t3 && c2(s2 - h2) <= t3 && (y2 = true), y2 ? [] : a2;
+    });
+  }, t2.MATRIX = O2, t2.ROTATE = function(t3, r3, e3) {
+    void 0 === r3 && (r3 = 0), void 0 === e3 && (e3 = 0), a(t3, r3, e3);
+    var i2 = Math.sin(t3), n3 = Math.cos(t3);
+    return O2(n3, i2, -i2, n3, r3 - r3 * n3 + e3 * i2, e3 - r3 * i2 - e3 * n3);
+  }, t2.TRANSLATE = function(t3, r3) {
+    return void 0 === r3 && (r3 = 0), a(t3, r3), O2(1, 0, 0, 1, t3, r3);
+  }, t2.SCALE = function(t3, r3) {
+    return void 0 === r3 && (r3 = t3), a(t3, r3), O2(t3, 0, 0, r3, 0, 0);
+  }, t2.SKEW_X = function(t3) {
+    return a(t3), O2(1, 0, Math.atan(t3), 1, 0, 0);
+  }, t2.SKEW_Y = function(t3) {
+    return a(t3), O2(1, Math.atan(t3), 0, 1, 0, 0);
+  }, t2.X_AXIS_SYMMETRY = function(t3) {
+    return void 0 === t3 && (t3 = 0), a(t3), O2(-1, 0, 0, 1, t3, 0);
+  }, t2.Y_AXIS_SYMMETRY = function(t3) {
+    return void 0 === t3 && (t3 = 0), a(t3), O2(1, 0, 0, -1, 0, t3);
+  }, t2.A_TO_C = function() {
+    return u2(function(t3, r3, e3) {
+      return _.ARC === t3.type ? function(t4, r4, e4) {
+        var a2, n3, s2, u3;
+        t4.cX || o(t4, r4, e4);
+        for (var y2 = Math.min(t4.phi1, t4.phi2), p2 = Math.max(t4.phi1, t4.phi2) - y2, m2 = Math.ceil(p2 / 90), O3 = new Array(m2), l3 = r4, T2 = e4, v2 = 0; v2 < m2; v2++) {
+          var f2 = c$1(t4.phi1, t4.phi2, v2 / m2), N2 = c$1(t4.phi1, t4.phi2, (v2 + 1) / m2), x = N2 - f2, d = 4 / 3 * Math.tan(x * h / 4), E = [Math.cos(f2 * h) - d * Math.sin(f2 * h), Math.sin(f2 * h) + d * Math.cos(f2 * h)], A = E[0], C = E[1], M = [Math.cos(N2 * h), Math.sin(N2 * h)], R = M[0], g = M[1], I = [R + d * Math.sin(N2 * h), g - d * Math.cos(N2 * h)], S = I[0], L = I[1];
+          O3[v2] = { relative: t4.relative, type: _.CURVE_TO };
+          var H = function(r5, e5) {
+            var a3 = i([r5 * t4.rX, e5 * t4.rY], t4.xRot), n4 = a3[0], o2 = a3[1];
+            return [t4.cX + n4, t4.cY + o2];
+          };
+          a2 = H(A, C), O3[v2].x1 = a2[0], O3[v2].y1 = a2[1], n3 = H(S, L), O3[v2].x2 = n3[0], O3[v2].y2 = n3[1], s2 = H(R, g), O3[v2].x = s2[0], O3[v2].y = s2[1], t4.relative && (O3[v2].x1 -= l3, O3[v2].y1 -= T2, O3[v2].x2 -= l3, O3[v2].y2 -= T2, O3[v2].x -= l3, O3[v2].y -= T2), l3 = (u3 = [O3[v2].x, O3[v2].y])[0], T2 = u3[1];
+        }
+        return O3;
+      }(t3, t3.relative ? 0 : r3, t3.relative ? 0 : e3) : t3;
+    });
+  }, t2.ANNOTATE_ARCS = function() {
+    return u2(function(t3, r3, e3) {
+      return t3.relative && (r3 = 0, e3 = 0), _.ARC === t3.type && o(t3, r3, e3), t3;
+    });
+  }, t2.CLONE = l2, t2.CALCULATE_BOUNDS = function() {
+    var t3 = function(t4) {
+      var r3 = {};
+      for (var e3 in t4)
+        r3[e3] = t4[e3];
+      return r3;
+    }, i2 = r2(), a2 = n2(), h2 = e2(), c2 = u2(function(r3, e3, n3) {
+      var u3 = h2(a2(i2(t3(r3))));
+      function O3(t4) {
+        t4 > c2.maxX && (c2.maxX = t4), t4 < c2.minX && (c2.minX = t4);
+      }
+      function l3(t4) {
+        t4 > c2.maxY && (c2.maxY = t4), t4 < c2.minY && (c2.minY = t4);
+      }
+      if (u3.type & _.DRAWING_COMMANDS && (O3(e3), l3(n3)), u3.type & _.HORIZ_LINE_TO && O3(u3.x), u3.type & _.VERT_LINE_TO && l3(u3.y), u3.type & _.LINE_TO && (O3(u3.x), l3(u3.y)), u3.type & _.CURVE_TO) {
+        O3(u3.x), l3(u3.y);
+        for (var T2 = 0, v2 = p(e3, u3.x1, u3.x2, u3.x); T2 < v2.length; T2++) {
+          0 < (w = v2[T2]) && 1 > w && O3(m$1(e3, u3.x1, u3.x2, u3.x, w));
+        }
+        for (var f2 = 0, N2 = p(n3, u3.y1, u3.y2, u3.y); f2 < N2.length; f2++) {
+          0 < (w = N2[f2]) && 1 > w && l3(m$1(n3, u3.y1, u3.y2, u3.y, w));
+        }
+      }
+      if (u3.type & _.ARC) {
+        O3(u3.x), l3(u3.y), o(u3, e3, n3);
+        for (var x = u3.xRot / 180 * Math.PI, d = Math.cos(x) * u3.rX, E = Math.sin(x) * u3.rX, A = -Math.sin(x) * u3.rY, C = Math.cos(x) * u3.rY, M = u3.phi1 < u3.phi2 ? [u3.phi1, u3.phi2] : -180 > u3.phi2 ? [u3.phi2 + 360, u3.phi1 + 360] : [u3.phi2, u3.phi1], R = M[0], g = M[1], I = function(t4) {
+          var r4 = t4[0], e4 = t4[1], i3 = 180 * Math.atan2(e4, r4) / Math.PI;
+          return i3 < R ? i3 + 360 : i3;
+        }, S = 0, L = s(A, -d, 0).map(I); S < L.length; S++) {
+          (w = L[S]) > R && w < g && O3(y(u3.cX, d, A, w));
+        }
+        for (var H = 0, U = s(C, -E, 0).map(I); H < U.length; H++) {
+          var w;
+          (w = U[H]) > R && w < g && l3(y(u3.cY, E, C, w));
+        }
+      }
+      return r3;
+    });
+    return c2.minX = 1 / 0, c2.maxX = -1 / 0, c2.minY = 1 / 0, c2.maxY = -1 / 0, c2;
+  };
+}(u || (u = {}));
+var O, l = function() {
+  function t2() {
+  }
+  return t2.prototype.round = function(t3) {
+    return this.transform(u.ROUND(t3));
+  }, t2.prototype.toAbs = function() {
+    return this.transform(u.TO_ABS());
+  }, t2.prototype.toRel = function() {
+    return this.transform(u.TO_REL());
+  }, t2.prototype.normalizeHVZ = function(t3, r2, e2) {
+    return this.transform(u.NORMALIZE_HVZ(t3, r2, e2));
+  }, t2.prototype.normalizeST = function() {
+    return this.transform(u.NORMALIZE_ST());
+  }, t2.prototype.qtToC = function() {
+    return this.transform(u.QT_TO_C());
+  }, t2.prototype.aToC = function() {
+    return this.transform(u.A_TO_C());
+  }, t2.prototype.sanitize = function(t3) {
+    return this.transform(u.SANITIZE(t3));
+  }, t2.prototype.translate = function(t3, r2) {
+    return this.transform(u.TRANSLATE(t3, r2));
+  }, t2.prototype.scale = function(t3, r2) {
+    return this.transform(u.SCALE(t3, r2));
+  }, t2.prototype.rotate = function(t3, r2, e2) {
+    return this.transform(u.ROTATE(t3, r2, e2));
+  }, t2.prototype.matrix = function(t3, r2, e2, i2, a2, n2) {
+    return this.transform(u.MATRIX(t3, r2, e2, i2, a2, n2));
+  }, t2.prototype.skewX = function(t3) {
+    return this.transform(u.SKEW_X(t3));
+  }, t2.prototype.skewY = function(t3) {
+    return this.transform(u.SKEW_Y(t3));
+  }, t2.prototype.xSymmetry = function(t3) {
+    return this.transform(u.X_AXIS_SYMMETRY(t3));
+  }, t2.prototype.ySymmetry = function(t3) {
+    return this.transform(u.Y_AXIS_SYMMETRY(t3));
+  }, t2.prototype.annotateArcs = function() {
+    return this.transform(u.ANNOTATE_ARCS());
+  }, t2;
+}(), T = function(t2) {
+  return " " === t2 || "	" === t2 || "\r" === t2 || "\n" === t2;
+}, v = function(t2) {
+  return "0".charCodeAt(0) <= t2.charCodeAt(0) && t2.charCodeAt(0) <= "9".charCodeAt(0);
+}, f = function(t2) {
+  function e2() {
+    var r2 = t2.call(this) || this;
+    return r2.curNumber = "", r2.curCommandType = -1, r2.curCommandRelative = false, r2.canParseCommandOrComma = true, r2.curNumberHasExp = false, r2.curNumberHasExpDigits = false, r2.curNumberHasDecimal = false, r2.curArgs = [], r2;
+  }
+  return r(e2, t2), e2.prototype.finish = function(t3) {
+    if (void 0 === t3 && (t3 = []), this.parse(" ", t3), 0 !== this.curArgs.length || !this.canParseCommandOrComma)
+      throw new SyntaxError("Unterminated command at the path end.");
+    return t3;
+  }, e2.prototype.parse = function(t3, r2) {
+    var e3 = this;
+    void 0 === r2 && (r2 = []);
+    for (var i2 = function(t4) {
+      r2.push(t4), e3.curArgs.length = 0, e3.canParseCommandOrComma = true;
+    }, a2 = 0; a2 < t3.length; a2++) {
+      var n2 = t3[a2], o2 = !(this.curCommandType !== _.ARC || 3 !== this.curArgs.length && 4 !== this.curArgs.length || 1 !== this.curNumber.length || "0" !== this.curNumber && "1" !== this.curNumber), s2 = v(n2) && ("0" === this.curNumber && "0" === n2 || o2);
+      if (!v(n2) || s2)
+        if ("e" !== n2 && "E" !== n2)
+          if ("-" !== n2 && "+" !== n2 || !this.curNumberHasExp || this.curNumberHasExpDigits)
+            if ("." !== n2 || this.curNumberHasExp || this.curNumberHasDecimal || o2) {
+              if (this.curNumber && -1 !== this.curCommandType) {
+                var u2 = Number(this.curNumber);
+                if (isNaN(u2))
+                  throw new SyntaxError("Invalid number ending at " + a2);
+                if (this.curCommandType === _.ARC) {
+                  if (0 === this.curArgs.length || 1 === this.curArgs.length) {
+                    if (0 > u2)
+                      throw new SyntaxError('Expected positive number, got "' + u2 + '" at index "' + a2 + '"');
+                  } else if ((3 === this.curArgs.length || 4 === this.curArgs.length) && "0" !== this.curNumber && "1" !== this.curNumber)
+                    throw new SyntaxError('Expected a flag, got "' + this.curNumber + '" at index "' + a2 + '"');
+                }
+                this.curArgs.push(u2), this.curArgs.length === N[this.curCommandType] && (_.HORIZ_LINE_TO === this.curCommandType ? i2({ type: _.HORIZ_LINE_TO, relative: this.curCommandRelative, x: u2 }) : _.VERT_LINE_TO === this.curCommandType ? i2({ type: _.VERT_LINE_TO, relative: this.curCommandRelative, y: u2 }) : this.curCommandType === _.MOVE_TO || this.curCommandType === _.LINE_TO || this.curCommandType === _.SMOOTH_QUAD_TO ? (i2({ type: this.curCommandType, relative: this.curCommandRelative, x: this.curArgs[0], y: this.curArgs[1] }), _.MOVE_TO === this.curCommandType && (this.curCommandType = _.LINE_TO)) : this.curCommandType === _.CURVE_TO ? i2({ type: _.CURVE_TO, relative: this.curCommandRelative, x1: this.curArgs[0], y1: this.curArgs[1], x2: this.curArgs[2], y2: this.curArgs[3], x: this.curArgs[4], y: this.curArgs[5] }) : this.curCommandType === _.SMOOTH_CURVE_TO ? i2({ type: _.SMOOTH_CURVE_TO, relative: this.curCommandRelative, x2: this.curArgs[0], y2: this.curArgs[1], x: this.curArgs[2], y: this.curArgs[3] }) : this.curCommandType === _.QUAD_TO ? i2({ type: _.QUAD_TO, relative: this.curCommandRelative, x1: this.curArgs[0], y1: this.curArgs[1], x: this.curArgs[2], y: this.curArgs[3] }) : this.curCommandType === _.ARC && i2({ type: _.ARC, relative: this.curCommandRelative, rX: this.curArgs[0], rY: this.curArgs[1], xRot: this.curArgs[2], lArcFlag: this.curArgs[3], sweepFlag: this.curArgs[4], x: this.curArgs[5], y: this.curArgs[6] })), this.curNumber = "", this.curNumberHasExpDigits = false, this.curNumberHasExp = false, this.curNumberHasDecimal = false, this.canParseCommandOrComma = true;
+              }
+              if (!T(n2))
+                if ("," === n2 && this.canParseCommandOrComma)
+                  this.canParseCommandOrComma = false;
+                else if ("+" !== n2 && "-" !== n2 && "." !== n2)
+                  if (s2)
+                    this.curNumber = n2, this.curNumberHasDecimal = false;
+                  else {
+                    if (0 !== this.curArgs.length)
+                      throw new SyntaxError("Unterminated command at index " + a2 + ".");
+                    if (!this.canParseCommandOrComma)
+                      throw new SyntaxError('Unexpected character "' + n2 + '" at index ' + a2 + ". Command cannot follow comma");
+                    if (this.canParseCommandOrComma = false, "z" !== n2 && "Z" !== n2)
+                      if ("h" === n2 || "H" === n2)
+                        this.curCommandType = _.HORIZ_LINE_TO, this.curCommandRelative = "h" === n2;
+                      else if ("v" === n2 || "V" === n2)
+                        this.curCommandType = _.VERT_LINE_TO, this.curCommandRelative = "v" === n2;
+                      else if ("m" === n2 || "M" === n2)
+                        this.curCommandType = _.MOVE_TO, this.curCommandRelative = "m" === n2;
+                      else if ("l" === n2 || "L" === n2)
+                        this.curCommandType = _.LINE_TO, this.curCommandRelative = "l" === n2;
+                      else if ("c" === n2 || "C" === n2)
+                        this.curCommandType = _.CURVE_TO, this.curCommandRelative = "c" === n2;
+                      else if ("s" === n2 || "S" === n2)
+                        this.curCommandType = _.SMOOTH_CURVE_TO, this.curCommandRelative = "s" === n2;
+                      else if ("q" === n2 || "Q" === n2)
+                        this.curCommandType = _.QUAD_TO, this.curCommandRelative = "q" === n2;
+                      else if ("t" === n2 || "T" === n2)
+                        this.curCommandType = _.SMOOTH_QUAD_TO, this.curCommandRelative = "t" === n2;
+                      else {
+                        if ("a" !== n2 && "A" !== n2)
+                          throw new SyntaxError('Unexpected character "' + n2 + '" at index ' + a2 + ".");
+                        this.curCommandType = _.ARC, this.curCommandRelative = "a" === n2;
+                      }
+                    else
+                      r2.push({ type: _.CLOSE_PATH }), this.canParseCommandOrComma = true, this.curCommandType = -1;
+                  }
+                else
+                  this.curNumber = n2, this.curNumberHasDecimal = "." === n2;
+            } else
+              this.curNumber += n2, this.curNumberHasDecimal = true;
+          else
+            this.curNumber += n2;
+        else
+          this.curNumber += n2, this.curNumberHasExp = true;
+      else
+        this.curNumber += n2, this.curNumberHasExpDigits = this.curNumberHasExp;
+    }
+    return r2;
+  }, e2.prototype.transform = function(t3) {
+    return Object.create(this, { parse: { value: function(r2, e3) {
+      void 0 === e3 && (e3 = []);
+      for (var i2 = 0, a2 = Object.getPrototypeOf(this).parse.call(this, r2); i2 < a2.length; i2++) {
+        var n2 = a2[i2], o2 = t3(n2);
+        Array.isArray(o2) ? e3.push.apply(e3, o2) : e3.push(o2);
+      }
+      return e3;
+    } } });
+  }, e2;
+}(l), _ = function(t2) {
+  function i2(r2) {
+    var e2 = t2.call(this) || this;
+    return e2.commands = "string" == typeof r2 ? i2.parse(r2) : r2, e2;
+  }
+  return r(i2, t2), i2.prototype.encode = function() {
+    return i2.encode(this.commands);
+  }, i2.prototype.getBounds = function() {
+    var t3 = u.CALCULATE_BOUNDS();
+    return this.transform(t3), t3;
+  }, i2.prototype.transform = function(t3) {
+    for (var r2 = [], e2 = 0, i3 = this.commands; e2 < i3.length; e2++) {
+      var a2 = t3(i3[e2]);
+      Array.isArray(a2) ? r2.push.apply(r2, a2) : r2.push(a2);
+    }
+    return this.commands = r2, this;
+  }, i2.encode = function(t3) {
+    return e(t3);
+  }, i2.parse = function(t3) {
+    var r2 = new f(), e2 = [];
+    return r2.parse(t3, e2), r2.finish(e2), e2;
+  }, i2.CLOSE_PATH = 1, i2.MOVE_TO = 2, i2.HORIZ_LINE_TO = 4, i2.VERT_LINE_TO = 8, i2.LINE_TO = 16, i2.CURVE_TO = 32, i2.SMOOTH_CURVE_TO = 64, i2.QUAD_TO = 128, i2.SMOOTH_QUAD_TO = 256, i2.ARC = 512, i2.LINE_COMMANDS = i2.LINE_TO | i2.HORIZ_LINE_TO | i2.VERT_LINE_TO, i2.DRAWING_COMMANDS = i2.HORIZ_LINE_TO | i2.VERT_LINE_TO | i2.LINE_TO | i2.CURVE_TO | i2.SMOOTH_CURVE_TO | i2.QUAD_TO | i2.SMOOTH_QUAD_TO | i2.ARC, i2;
+}(l), N = ((O = {})[_.MOVE_TO] = 2, O[_.LINE_TO] = 2, O[_.HORIZ_LINE_TO] = 1, O[_.VERT_LINE_TO] = 1, O[_.CLOSE_PATH] = 0, O[_.QUAD_TO] = 4, O[_.SMOOTH_QUAD_TO] = 2, O[_.CURVE_TO] = 6, O[_.SMOOTH_CURVE_TO] = 4, O[_.ARC] = 7, O);
+var call = functionCall;
+var hasOwn = hasOwnProperty_1;
+var isPrototypeOf = objectIsPrototypeOf;
+var regExpFlags = regexpFlags$1;
+var RegExpPrototype$1 = RegExp.prototype;
+var regexpGetFlags = function(R) {
+  var flags = R.flags;
+  return flags === void 0 && !("flags" in RegExpPrototype$1) && !hasOwn(R, "flags") && isPrototypeOf(RegExpPrototype$1, R) ? call(regExpFlags, R) : flags;
+};
+var PROPER_FUNCTION_NAME = functionName.PROPER;
+var defineBuiltIn = defineBuiltIn$2;
+var anObject = anObject$6;
+var $toString = toString$7;
+var fails = fails$7;
+var getRegExpFlags = regexpGetFlags;
+var TO_STRING = "toString";
+var RegExpPrototype = RegExp.prototype;
+var nativeToString = RegExpPrototype[TO_STRING];
+var NOT_GENERIC = fails(function() {
+  return nativeToString.call({ source: "a", flags: "b" }) != "/a/b";
+});
+var INCORRECT_NAME = PROPER_FUNCTION_NAME && nativeToString.name != TO_STRING;
+if (NOT_GENERIC || INCORRECT_NAME) {
+  defineBuiltIn(RegExp.prototype, TO_STRING, function toString2() {
+    var R = anObject(this);
+    var pattern = $toString(R.source);
+    var flags = $toString(getRegExpFlags(R));
+    return "/" + pattern + "/" + flags;
+  }, { unsafe: true });
+}
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+    _typeof = function(obj2) {
+      return typeof obj2;
+    };
+  } else {
+    _typeof = function(obj2) {
+      return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+    };
+  }
+  return _typeof(obj);
+}
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+var mulTable = [512, 512, 456, 512, 328, 456, 335, 512, 405, 328, 271, 456, 388, 335, 292, 512, 454, 405, 364, 328, 298, 271, 496, 456, 420, 388, 360, 335, 312, 292, 273, 512, 482, 454, 428, 405, 383, 364, 345, 328, 312, 298, 284, 271, 259, 496, 475, 456, 437, 420, 404, 388, 374, 360, 347, 335, 323, 312, 302, 292, 282, 273, 265, 512, 497, 482, 468, 454, 441, 428, 417, 405, 394, 383, 373, 364, 354, 345, 337, 328, 320, 312, 305, 298, 291, 284, 278, 271, 265, 259, 507, 496, 485, 475, 465, 456, 446, 437, 428, 420, 412, 404, 396, 388, 381, 374, 367, 360, 354, 347, 341, 335, 329, 323, 318, 312, 307, 302, 297, 292, 287, 282, 278, 273, 269, 265, 261, 512, 505, 497, 489, 482, 475, 468, 461, 454, 447, 441, 435, 428, 422, 417, 411, 405, 399, 394, 389, 383, 378, 373, 368, 364, 359, 354, 350, 345, 341, 337, 332, 328, 324, 320, 316, 312, 309, 305, 301, 298, 294, 291, 287, 284, 281, 278, 274, 271, 268, 265, 262, 259, 257, 507, 501, 496, 491, 485, 480, 475, 470, 465, 460, 456, 451, 446, 442, 437, 433, 428, 424, 420, 416, 412, 408, 404, 400, 396, 392, 388, 385, 381, 377, 374, 370, 367, 363, 360, 357, 354, 350, 347, 344, 341, 338, 335, 332, 329, 326, 323, 320, 318, 315, 312, 310, 307, 304, 302, 299, 297, 294, 292, 289, 287, 285, 282, 280, 278, 275, 273, 271, 269, 267, 265, 263, 261, 259];
+var shgTable = [9, 11, 12, 13, 13, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24];
+function getImageDataFromCanvas(canvas, topX, topY, width, height) {
+  if (typeof canvas === "string") {
+    canvas = document.getElementById(canvas);
+  }
+  if (!canvas || _typeof(canvas) !== "object" || !("getContext" in canvas)) {
+    throw new TypeError("Expecting canvas with `getContext` method in processCanvasRGB(A) calls!");
+  }
+  var context = canvas.getContext("2d");
+  try {
+    return context.getImageData(topX, topY, width, height);
+  } catch (e2) {
+    throw new Error("unable to access image data: " + e2);
+  }
+}
+function processCanvasRGBA(canvas, topX, topY, width, height, radius) {
+  if (isNaN(radius) || radius < 1) {
+    return;
+  }
+  radius |= 0;
+  var imageData = getImageDataFromCanvas(canvas, topX, topY, width, height);
+  imageData = processImageDataRGBA(imageData, topX, topY, width, height, radius);
+  canvas.getContext("2d").putImageData(imageData, topX, topY);
+}
+function processImageDataRGBA(imageData, topX, topY, width, height, radius) {
+  var pixels = imageData.data;
+  var div = 2 * radius + 1;
+  var widthMinus1 = width - 1;
+  var heightMinus1 = height - 1;
+  var radiusPlus1 = radius + 1;
+  var sumFactor = radiusPlus1 * (radiusPlus1 + 1) / 2;
+  var stackStart = new BlurStack();
+  var stack = stackStart;
+  var stackEnd;
+  for (var i2 = 1; i2 < div; i2++) {
+    stack = stack.next = new BlurStack();
+    if (i2 === radiusPlus1) {
+      stackEnd = stack;
+    }
+  }
+  stack.next = stackStart;
+  var stackIn = null, stackOut = null, yw = 0, yi = 0;
+  var mulSum = mulTable[radius];
+  var shgSum = shgTable[radius];
+  for (var y2 = 0; y2 < height; y2++) {
+    stack = stackStart;
+    var pr = pixels[yi], pg = pixels[yi + 1], pb = pixels[yi + 2], pa = pixels[yi + 3];
+    for (var _i = 0; _i < radiusPlus1; _i++) {
+      stack.r = pr;
+      stack.g = pg;
+      stack.b = pb;
+      stack.a = pa;
+      stack = stack.next;
+    }
+    var rInSum = 0, gInSum = 0, bInSum = 0, aInSum = 0, rOutSum = radiusPlus1 * pr, gOutSum = radiusPlus1 * pg, bOutSum = radiusPlus1 * pb, aOutSum = radiusPlus1 * pa, rSum = sumFactor * pr, gSum = sumFactor * pg, bSum = sumFactor * pb, aSum = sumFactor * pa;
+    for (var _i2 = 1; _i2 < radiusPlus1; _i2++) {
+      var p2 = yi + ((widthMinus1 < _i2 ? widthMinus1 : _i2) << 2);
+      var r2 = pixels[p2], g = pixels[p2 + 1], b = pixels[p2 + 2], a2 = pixels[p2 + 3];
+      var rbs = radiusPlus1 - _i2;
+      rSum += (stack.r = r2) * rbs;
+      gSum += (stack.g = g) * rbs;
+      bSum += (stack.b = b) * rbs;
+      aSum += (stack.a = a2) * rbs;
+      rInSum += r2;
+      gInSum += g;
+      bInSum += b;
+      aInSum += a2;
+      stack = stack.next;
+    }
+    stackIn = stackStart;
+    stackOut = stackEnd;
+    for (var x = 0; x < width; x++) {
+      var paInitial = aSum * mulSum >> shgSum;
+      pixels[yi + 3] = paInitial;
+      if (paInitial !== 0) {
+        var _a2 = 255 / paInitial;
+        pixels[yi] = (rSum * mulSum >> shgSum) * _a2;
+        pixels[yi + 1] = (gSum * mulSum >> shgSum) * _a2;
+        pixels[yi + 2] = (bSum * mulSum >> shgSum) * _a2;
+      } else {
+        pixels[yi] = pixels[yi + 1] = pixels[yi + 2] = 0;
+      }
+      rSum -= rOutSum;
+      gSum -= gOutSum;
+      bSum -= bOutSum;
+      aSum -= aOutSum;
+      rOutSum -= stackIn.r;
+      gOutSum -= stackIn.g;
+      bOutSum -= stackIn.b;
+      aOutSum -= stackIn.a;
+      var _p = x + radius + 1;
+      _p = yw + (_p < widthMinus1 ? _p : widthMinus1) << 2;
+      rInSum += stackIn.r = pixels[_p];
+      gInSum += stackIn.g = pixels[_p + 1];
+      bInSum += stackIn.b = pixels[_p + 2];
+      aInSum += stackIn.a = pixels[_p + 3];
+      rSum += rInSum;
+      gSum += gInSum;
+      bSum += bInSum;
+      aSum += aInSum;
+      stackIn = stackIn.next;
+      var _stackOut = stackOut, _r = _stackOut.r, _g = _stackOut.g, _b = _stackOut.b, _a = _stackOut.a;
+      rOutSum += _r;
+      gOutSum += _g;
+      bOutSum += _b;
+      aOutSum += _a;
+      rInSum -= _r;
+      gInSum -= _g;
+      bInSum -= _b;
+      aInSum -= _a;
+      stackOut = stackOut.next;
+      yi += 4;
+    }
+    yw += width;
+  }
+  for (var _x = 0; _x < width; _x++) {
+    yi = _x << 2;
+    var _pr = pixels[yi], _pg = pixels[yi + 1], _pb = pixels[yi + 2], _pa = pixels[yi + 3], _rOutSum = radiusPlus1 * _pr, _gOutSum = radiusPlus1 * _pg, _bOutSum = radiusPlus1 * _pb, _aOutSum = radiusPlus1 * _pa, _rSum = sumFactor * _pr, _gSum = sumFactor * _pg, _bSum = sumFactor * _pb, _aSum = sumFactor * _pa;
+    stack = stackStart;
+    for (var _i3 = 0; _i3 < radiusPlus1; _i3++) {
+      stack.r = _pr;
+      stack.g = _pg;
+      stack.b = _pb;
+      stack.a = _pa;
+      stack = stack.next;
+    }
+    var yp = width;
+    var _gInSum = 0, _bInSum = 0, _aInSum = 0, _rInSum = 0;
+    for (var _i4 = 1; _i4 <= radius; _i4++) {
+      yi = yp + _x << 2;
+      var _rbs = radiusPlus1 - _i4;
+      _rSum += (stack.r = _pr = pixels[yi]) * _rbs;
+      _gSum += (stack.g = _pg = pixels[yi + 1]) * _rbs;
+      _bSum += (stack.b = _pb = pixels[yi + 2]) * _rbs;
+      _aSum += (stack.a = _pa = pixels[yi + 3]) * _rbs;
+      _rInSum += _pr;
+      _gInSum += _pg;
+      _bInSum += _pb;
+      _aInSum += _pa;
+      stack = stack.next;
+      if (_i4 < heightMinus1) {
+        yp += width;
+      }
+    }
+    yi = _x;
+    stackIn = stackStart;
+    stackOut = stackEnd;
+    for (var _y = 0; _y < height; _y++) {
+      var _p2 = yi << 2;
+      pixels[_p2 + 3] = _pa = _aSum * mulSum >> shgSum;
+      if (_pa > 0) {
+        _pa = 255 / _pa;
+        pixels[_p2] = (_rSum * mulSum >> shgSum) * _pa;
+        pixels[_p2 + 1] = (_gSum * mulSum >> shgSum) * _pa;
+        pixels[_p2 + 2] = (_bSum * mulSum >> shgSum) * _pa;
+      } else {
+        pixels[_p2] = pixels[_p2 + 1] = pixels[_p2 + 2] = 0;
+      }
+      _rSum -= _rOutSum;
+      _gSum -= _gOutSum;
+      _bSum -= _bOutSum;
+      _aSum -= _aOutSum;
+      _rOutSum -= stackIn.r;
+      _gOutSum -= stackIn.g;
+      _bOutSum -= stackIn.b;
+      _aOutSum -= stackIn.a;
+      _p2 = _x + ((_p2 = _y + radiusPlus1) < heightMinus1 ? _p2 : heightMinus1) * width << 2;
+      _rSum += _rInSum += stackIn.r = pixels[_p2];
+      _gSum += _gInSum += stackIn.g = pixels[_p2 + 1];
+      _bSum += _bInSum += stackIn.b = pixels[_p2 + 2];
+      _aSum += _aInSum += stackIn.a = pixels[_p2 + 3];
+      stackIn = stackIn.next;
+      _rOutSum += _pr = stackOut.r;
+      _gOutSum += _pg = stackOut.g;
+      _bOutSum += _pb = stackOut.b;
+      _aOutSum += _pa = stackOut.a;
+      _rInSum -= _pr;
+      _gInSum -= _pg;
+      _bInSum -= _pb;
+      _aInSum -= _pa;
+      stackOut = stackOut.next;
+      yi += width;
+    }
+  }
+  return imageData;
+}
+var BlurStack = function BlurStack2() {
+  _classCallCheck(this, BlurStack2);
+  this.r = 0;
+  this.g = 0;
+  this.b = 0;
+  this.a = 0;
+  this.next = null;
+};
 function offscreen() {
   var {
     DOMParser: DOMParserFallback
@@ -123,35 +1951,35 @@ function getSelectorSpecificity(selector) {
   return specificity.join("");
 }
 var PSEUDO_ZERO = 1e-8;
-function vectorMagnitude(v) {
-  return Math.sqrt(Math.pow(v[0], 2) + Math.pow(v[1], 2));
+function vectorMagnitude(v2) {
+  return Math.sqrt(Math.pow(v2[0], 2) + Math.pow(v2[1], 2));
 }
-function vectorsRatio(u, v) {
-  return (u[0] * v[0] + u[1] * v[1]) / (vectorMagnitude(u) * vectorMagnitude(v));
+function vectorsRatio(u2, v2) {
+  return (u2[0] * v2[0] + u2[1] * v2[1]) / (vectorMagnitude(u2) * vectorMagnitude(v2));
 }
-function vectorsAngle(u, v) {
-  return (u[0] * v[1] < u[1] * v[0] ? -1 : 1) * Math.acos(vectorsRatio(u, v));
+function vectorsAngle(u2, v2) {
+  return (u2[0] * v2[1] < u2[1] * v2[0] ? -1 : 1) * Math.acos(vectorsRatio(u2, v2));
 }
-function CB1(t) {
-  return t * t * t;
+function CB1(t2) {
+  return t2 * t2 * t2;
 }
-function CB2(t) {
-  return 3 * t * t * (1 - t);
+function CB2(t2) {
+  return 3 * t2 * t2 * (1 - t2);
 }
-function CB3(t) {
-  return 3 * t * (1 - t) * (1 - t);
+function CB3(t2) {
+  return 3 * t2 * (1 - t2) * (1 - t2);
 }
-function CB4(t) {
-  return (1 - t) * (1 - t) * (1 - t);
+function CB4(t2) {
+  return (1 - t2) * (1 - t2) * (1 - t2);
 }
-function QB1(t) {
-  return t * t;
+function QB1(t2) {
+  return t2 * t2;
 }
-function QB2(t) {
-  return 2 * t * (1 - t);
+function QB2(t2) {
+  return 2 * t2 * (1 - t2);
 }
-function QB3(t) {
-  return (1 - t) * (1 - t);
+function QB3(t2) {
+  return (1 - t2) * (1 - t2);
 }
 class Property {
   constructor(document2, name, value) {
@@ -223,11 +2051,11 @@ class Property {
     var {
       value
     } = this;
-    var n = parseFloat(value);
+    var n2 = parseFloat(value);
     if (this.isString(/%$/)) {
-      n /= 100;
+      n2 /= 100;
     }
-    return n;
+    return n2;
   }
   getString(def) {
     if (typeof def === "undefined" || this.hasValue()) {
@@ -298,11 +2126,11 @@ class Property {
       case this.isString(/%$/):
         return this.getNumber() * viewPort.computeSize(axis);
       default: {
-        var n = this.getNumber();
-        if (processPercent && n < 1) {
-          return n * viewPort.computeSize(axis);
+        var n2 = this.getNumber();
+        if (processPercent && n2 < 1) {
+          return n2 * viewPort.computeSize(axis);
         }
-        return n;
+        return n2;
       }
     }
   }
@@ -371,8 +2199,8 @@ class Property {
     var value = this.getColor();
     var len = value.length;
     var commas = 0;
-    for (var i = 0; i < len; i++) {
-      if (value[i] === ",") {
+    for (var i2 = 0; i2 < len; i2++) {
+      if (value[i2] === ",") {
         commas++;
       }
       if (commas === 3) {
@@ -444,26 +2272,26 @@ class ViewPort {
   }
 }
 class Point {
-  constructor(x, y) {
+  constructor(x, y2) {
     this.x = x;
-    this.y = y;
+    this.y = y2;
   }
   static parse(point) {
     var defaultValue = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
-    var [x = defaultValue, y = defaultValue] = toNumbers(point);
-    return new Point(x, y);
+    var [x = defaultValue, y2 = defaultValue] = toNumbers(point);
+    return new Point(x, y2);
   }
   static parseScale(scale) {
     var defaultValue = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 1;
-    var [x = defaultValue, y = x] = toNumbers(scale);
-    return new Point(x, y);
+    var [x = defaultValue, y2 = x] = toNumbers(scale);
+    return new Point(x, y2);
   }
   static parsePath(path) {
     var points = toNumbers(path);
     var len = points.length;
     var pathPoints = [];
-    for (var i = 0; i < len; i += 2) {
-      pathPoints.push(new Point(points[i], points[i + 1]));
+    for (var i2 = 0; i2 < len; i2 += 2) {
+      pathPoints.push(new Point(points[i2], points[i2 + 1]));
     }
     return pathPoints;
   }
@@ -473,10 +2301,10 @@ class Point {
   applyTransform(transform) {
     var {
       x,
-      y
+      y: y2
     } = this;
-    var xp = x * transform[0] + y * transform[2] + transform[4];
-    var yp = x * transform[1] + y * transform[3] + transform[5];
+    var xp = x * transform[0] + y2 * transform[2] + transform[4];
+    var yp = x * transform[1] + y2 * transform[3] + transform[5];
     this.x = xp;
     this.y = yp;
   }
@@ -534,11 +2362,11 @@ class Mouse {
     if (style) {
       style.cursor = "";
     }
-    events.forEach((_ref, i) => {
+    events.forEach((_ref, i2) => {
       var {
         run
       } = _ref;
-      var element = eventElements[i];
+      var element = eventElements[i2];
       while (element) {
         run(element);
         element = element.parent;
@@ -555,13 +2383,13 @@ class Mouse {
       events,
       eventElements
     } = this;
-    events.forEach((_ref2, i) => {
+    events.forEach((_ref2, i2) => {
       var {
         x,
-        y
+        y: y2
       } = _ref2;
-      if (!eventElements[i] && ctx.isPointInPath && ctx.isPointInPath(x, y)) {
-        eventElements[i] = element;
+      if (!eventElements[i2] && ctx.isPointInPath && ctx.isPointInPath(x, y2)) {
+        eventElements[i2] = element;
       }
     });
   }
@@ -573,22 +2401,22 @@ class Mouse {
       events,
       eventElements
     } = this;
-    events.forEach((_ref3, i) => {
+    events.forEach((_ref3, i2) => {
       var {
         x,
-        y
+        y: y2
       } = _ref3;
-      if (!eventElements[i] && boundingBox.isPointInBox(x, y)) {
-        eventElements[i] = element;
+      if (!eventElements[i2] && boundingBox.isPointInBox(x, y2)) {
+        eventElements[i2] = element;
       }
     });
   }
-  mapXY(x, y) {
+  mapXY(x, y2) {
     var {
       window: window2,
       ctx
     } = this.screen;
-    var point = new Point(x, y);
+    var point = new Point(x, y2);
     var element = ctx.canvas;
     while (element) {
       point.x -= element.offsetLeft;
@@ -606,12 +2434,12 @@ class Mouse {
   onClick(event) {
     var {
       x,
-      y
+      y: y2
     } = this.mapXY(event.clientX, event.clientY);
     this.events.push({
       type: "onclick",
       x,
-      y,
+      y: y2,
       run(eventTarget) {
         if (eventTarget.onClick) {
           eventTarget.onClick();
@@ -622,12 +2450,12 @@ class Mouse {
   onMouseMove(event) {
     var {
       x,
-      y
+      y: y2
     } = this.mapXY(event.clientX, event.clientY);
     this.events.push({
       type: "onmousemove",
       x,
-      y,
+      y: y2,
       run(eventTarget) {
         if (eventTarget.onMouseMove) {
           eventTarget.onMouseMove();
@@ -800,14 +2628,14 @@ class Screen {
     if (!enableRedraw) {
       return;
     }
-    var now = Date.now();
-    var then = now;
+    var now2 = Date.now();
+    var then = now2;
     var delta = 0;
     var tick = () => {
-      now = Date.now();
-      delta = now - then;
+      now2 = Date.now();
+      delta = now2 - then;
       if (delta >= frameDuration) {
-        then = now - delta % frameDuration;
+        then = now2 - delta % frameDuration;
         if (this.shouldUpdate(ignoreAnimation, forceRedraw)) {
           this.render(element, ignoreDimensions, ignoreClear, scaleWidth, scaleHeight, offsetX, offsetY);
           mouse.runEvents();
@@ -989,23 +2817,23 @@ class Translate {
   apply(ctx) {
     var {
       x,
-      y
+      y: y2
     } = this.point;
-    ctx.translate(x || 0, y || 0);
+    ctx.translate(x || 0, y2 || 0);
   }
   unapply(ctx) {
     var {
       x,
-      y
+      y: y2
     } = this.point;
-    ctx.translate(-1 * x || 0, -1 * y || 0);
+    ctx.translate(-1 * x || 0, -1 * y2 || 0);
   }
   applyToPoint(point) {
     var {
       x,
-      y
+      y: y2
     } = this.point;
-    point.applyTransform([1, 0, 0, 1, x || 0, y || 0]);
+    point.applyTransform([1, 0, 0, 1, x || 0, y2 || 0]);
   }
 }
 class Rotate {
@@ -1096,7 +2924,7 @@ class Scale {
     var {
       scale: {
         x,
-        y
+        y: y2
       },
       originX,
       originY
@@ -1104,14 +2932,14 @@ class Scale {
     var tx = originX.getPixels("x");
     var ty = originY.getPixels("y");
     ctx.translate(tx, ty);
-    ctx.scale(x, y || x);
+    ctx.scale(x, y2 || x);
     ctx.translate(-tx, -ty);
   }
   unapply(ctx) {
     var {
       scale: {
         x,
-        y
+        y: y2
       },
       originX,
       originY
@@ -1119,15 +2947,15 @@ class Scale {
     var tx = originX.getPixels("x");
     var ty = originY.getPixels("y");
     ctx.translate(tx, ty);
-    ctx.scale(1 / x, 1 / y || x);
+    ctx.scale(1 / x, 1 / y2 || x);
     ctx.translate(-tx, -ty);
   }
   applyToPoint(point) {
     var {
       x,
-      y
+      y: y2
     } = this.scale;
-    point.applyTransform([x || 0, 0, 0, y || 0, 0, 0]);
+    point.applyTransform([x || 0, 0, 0, y2 || 0, 0, 0]);
   }
 }
 class Matrix {
@@ -1158,20 +2986,20 @@ class Matrix {
       originY,
       matrix
     } = this;
-    var a = matrix[0];
+    var a2 = matrix[0];
     var b = matrix[2];
     var c2 = matrix[4];
     var d = matrix[1];
-    var e = matrix[3];
-    var f = matrix[5];
+    var e2 = matrix[3];
+    var f2 = matrix[5];
     var g = 0;
-    var h = 0;
-    var i = 1;
-    var det = 1 / (a * (e * i - f * h) - b * (d * i - f * g) + c2 * (d * h - e * g));
+    var h2 = 0;
+    var i2 = 1;
+    var det = 1 / (a2 * (e2 * i2 - f2 * h2) - b * (d * i2 - f2 * g) + c2 * (d * h2 - e2 * g));
     var tx = originX.getPixels("x");
     var ty = originY.getPixels("y");
     ctx.translate(tx, ty);
-    ctx.transform(det * (e * i - f * h), det * (f * g - d * i), det * (c2 * h - b * i), det * (a * i - c2 * g), det * (b * f - c2 * e), det * (c2 * d - a * f));
+    ctx.transform(det * (e2 * i2 - f2 * h2), det * (f2 * g - d * i2), det * (c2 * h2 - b * i2), det * (a2 * i2 - c2 * g), det * (b * f2 - c2 * e2), det * (c2 * d - a2 * f2));
     ctx.translate(-tx, -ty);
   }
   applyToPoint(point) {
@@ -1237,8 +3065,8 @@ class Transform {
       transforms
     } = this;
     var len = transforms.length;
-    for (var i = 0; i < len; i++) {
-      transforms[i].apply(ctx);
+    for (var i2 = 0; i2 < len; i2++) {
+      transforms[i2].apply(ctx);
     }
   }
   unapply(ctx) {
@@ -1246,8 +3074,8 @@ class Transform {
       transforms
     } = this;
     var len = transforms.length;
-    for (var i = len - 1; i >= 0; i--) {
-      transforms[i].unapply(ctx);
+    for (var i2 = len - 1; i2 >= 0; i2--) {
+      transforms[i2].unapply(ctx);
     }
   }
   applyToPoint(point) {
@@ -1255,8 +3083,8 @@ class Transform {
       transforms
     } = this;
     var len = transforms.length;
-    for (var i = 0; i < len; i++) {
-      transforms[i].applyToPoint(point);
+    for (var i2 = 0; i2 < len; i2++) {
+      transforms[i2].applyToPoint(point);
     }
   }
 }
@@ -1637,7 +3465,7 @@ class BoundingBox {
   get height() {
     return this.y2 - this.y1;
   }
-  addPoint(x, y) {
+  addPoint(x, y2) {
     if (typeof x !== "undefined") {
       if (isNaN(this.x1) || isNaN(this.x2)) {
         this.x1 = x;
@@ -1650,24 +3478,24 @@ class BoundingBox {
         this.x2 = x;
       }
     }
-    if (typeof y !== "undefined") {
+    if (typeof y2 !== "undefined") {
       if (isNaN(this.y1) || isNaN(this.y2)) {
-        this.y1 = y;
-        this.y2 = y;
+        this.y1 = y2;
+        this.y2 = y2;
       }
-      if (y < this.y1) {
-        this.y1 = y;
+      if (y2 < this.y1) {
+        this.y1 = y2;
       }
-      if (y > this.y2) {
-        this.y2 = y;
+      if (y2 > this.y2) {
+        this.y2 = y2;
       }
     }
   }
   addX(x) {
     this.addPoint(x, null);
   }
-  addY(y) {
-    this.addPoint(null, y);
+  addY(y2) {
+    this.addPoint(null, y2);
   }
   addBoundingBox(boundingBox) {
     if (!boundingBox) {
@@ -1682,32 +3510,32 @@ class BoundingBox {
     this.addPoint(x1, y1);
     this.addPoint(x2, y2);
   }
-  sumCubic(t, p0, p1, p2, p3) {
-    return Math.pow(1 - t, 3) * p0 + 3 * Math.pow(1 - t, 2) * t * p1 + 3 * (1 - t) * Math.pow(t, 2) * p2 + Math.pow(t, 3) * p3;
+  sumCubic(t2, p0, p1, p2, p3) {
+    return Math.pow(1 - t2, 3) * p0 + 3 * Math.pow(1 - t2, 2) * t2 * p1 + 3 * (1 - t2) * Math.pow(t2, 2) * p2 + Math.pow(t2, 3) * p3;
   }
   bezierCurveAdd(forX, p0, p1, p2, p3) {
     var b = 6 * p0 - 12 * p1 + 6 * p2;
-    var a = -3 * p0 + 9 * p1 - 9 * p2 + 3 * p3;
+    var a2 = -3 * p0 + 9 * p1 - 9 * p2 + 3 * p3;
     var c2 = 3 * p1 - 3 * p0;
-    if (a === 0) {
+    if (a2 === 0) {
       if (b === 0) {
         return;
       }
-      var t = -c2 / b;
-      if (0 < t && t < 1) {
+      var t2 = -c2 / b;
+      if (0 < t2 && t2 < 1) {
         if (forX) {
-          this.addX(this.sumCubic(t, p0, p1, p2, p3));
+          this.addX(this.sumCubic(t2, p0, p1, p2, p3));
         } else {
-          this.addY(this.sumCubic(t, p0, p1, p2, p3));
+          this.addY(this.sumCubic(t2, p0, p1, p2, p3));
         }
       }
       return;
     }
-    var b2ac = Math.pow(b, 2) - 4 * c2 * a;
+    var b2ac = Math.pow(b, 2) - 4 * c2 * a2;
     if (b2ac < 0) {
       return;
     }
-    var t1 = (-b + Math.sqrt(b2ac)) / (2 * a);
+    var t1 = (-b + Math.sqrt(b2ac)) / (2 * a2);
     if (0 < t1 && t1 < 1) {
       if (forX) {
         this.addX(this.sumCubic(t1, p0, p1, p2, p3));
@@ -1715,12 +3543,12 @@ class BoundingBox {
         this.addY(this.sumCubic(t1, p0, p1, p2, p3));
       }
     }
-    var t2 = (-b - Math.sqrt(b2ac)) / (2 * a);
-    if (0 < t2 && t2 < 1) {
+    var t22 = (-b - Math.sqrt(b2ac)) / (2 * a2);
+    if (0 < t22 && t22 < 1) {
       if (forX) {
-        this.addX(this.sumCubic(t2, p0, p1, p2, p3));
+        this.addX(this.sumCubic(t22, p0, p1, p2, p3));
       } else {
-        this.addY(this.sumCubic(t2, p0, p1, p2, p3));
+        this.addY(this.sumCubic(t22, p0, p1, p2, p3));
       }
     }
   }
@@ -1737,14 +3565,14 @@ class BoundingBox {
     var cp2y = cp1y + 1 / 3 * (p2y - p0y);
     this.addBezierCurve(p0x, p0y, cp1x, cp2x, cp1y, cp2y, p2x, p2y);
   }
-  isPointInBox(x, y) {
+  isPointInBox(x, y2) {
     var {
       x1,
       y1,
       x2,
-      y2
+      y2: y22
     } = this;
-    return x1 <= x && x <= x2 && y1 <= y && y <= y2;
+    return x1 <= x && x <= x2 && y1 <= y2 && y2 <= y22;
   }
 }
 class PathParser extends _ {
@@ -1772,10 +3600,10 @@ class PathParser extends _ {
   }
   isEnd() {
     var {
-      i,
+      i: i2,
       commands
     } = this;
-    return i >= commands.length - 1;
+    return i2 >= commands.length - 1;
   }
   next() {
     var command = this.commands[++this.i];
@@ -1821,10 +3649,10 @@ class PathParser extends _ {
     if (this.command.relative) {
       var {
         x,
-        y
+        y: y2
       } = this.current;
       point.x += x;
-      point.y += y;
+      point.y += y2;
     }
     return point;
   }
@@ -1850,11 +3678,11 @@ class PathParser extends _ {
       angles
     } = this;
     var len = angles.length;
-    for (var i = 0; i < len; i++) {
-      if (!angles[i]) {
-        for (var j = i + 1; j < len; j++) {
+    for (var i2 = 0; i2 < len; i2++) {
+      if (!angles[i2]) {
+        for (var j = i2 + 1; j < len; j++) {
           if (angles[j]) {
-            angles[i] = angles[j];
+            angles[i2] = angles[j];
             break;
           }
         }
@@ -2054,7 +3882,7 @@ class PathElement extends RenderedElement {
     } = this;
     var points = pathParser.getMarkerPoints();
     var angles = pathParser.getMarkerAngles();
-    var markers = points.map((point, i) => [point, angles[i]]);
+    var markers = points.map((point, i2) => [point, angles[i2]]);
     return markers;
   }
   renderChildren(ctx) {
@@ -2091,8 +3919,8 @@ class PathElement extends RenderedElement {
       }
       if (markerMidStyleProp.isUrlDefinition()) {
         var _marker = markerMidStyleProp.getDefinition();
-        for (var i = 1; i < markersLastIndex; i++) {
-          var [_point, _angle] = markers[i];
+        for (var i2 = 1; i2 < markersLastIndex; i2++) {
+          var [_point, _angle] = markers[i2];
           _marker.render(ctx, _point, _angle);
         }
       }
@@ -2119,12 +3947,12 @@ class PathElement extends RenderedElement {
     } = PathElement.pathM(pathParser);
     var {
       x,
-      y
+      y: y2
     } = point;
     pathParser.addMarker(point);
-    boundingBox.addPoint(x, y);
+    boundingBox.addPoint(x, y2);
     if (ctx) {
-      ctx.moveTo(x, y);
+      ctx.moveTo(x, y2);
     }
   }
   static pathL(pathParser) {
@@ -2147,12 +3975,12 @@ class PathElement extends RenderedElement {
     } = PathElement.pathL(pathParser);
     var {
       x,
-      y
+      y: y2
     } = point;
     pathParser.addMarker(point, current);
-    boundingBox.addPoint(x, y);
+    boundingBox.addPoint(x, y2);
     if (ctx) {
-      ctx.lineTo(x, y);
+      ctx.lineTo(x, y2);
     }
   }
   static pathH(pathParser) {
@@ -2177,12 +4005,12 @@ class PathElement extends RenderedElement {
     } = PathElement.pathH(pathParser);
     var {
       x,
-      y
+      y: y2
     } = point;
     pathParser.addMarker(point, current);
-    boundingBox.addPoint(x, y);
+    boundingBox.addPoint(x, y2);
     if (ctx) {
-      ctx.lineTo(x, y);
+      ctx.lineTo(x, y2);
     }
   }
   static pathV(pathParser) {
@@ -2207,12 +4035,12 @@ class PathElement extends RenderedElement {
     } = PathElement.pathV(pathParser);
     var {
       x,
-      y
+      y: y2
     } = point;
     pathParser.addMarker(point, current);
-    boundingBox.addPoint(x, y);
+    boundingBox.addPoint(x, y2);
     if (ctx) {
-      ctx.lineTo(x, y);
+      ctx.lineTo(x, y2);
     }
   }
   static pathC(pathParser) {
@@ -2345,25 +4173,25 @@ class PathElement extends RenderedElement {
     var xAxisRotation = xRot * (Math.PI / 180);
     var currentPoint = pathParser.getAsCurrentPoint();
     var currp = new Point(Math.cos(xAxisRotation) * (current.x - currentPoint.x) / 2 + Math.sin(xAxisRotation) * (current.y - currentPoint.y) / 2, -Math.sin(xAxisRotation) * (current.x - currentPoint.x) / 2 + Math.cos(xAxisRotation) * (current.y - currentPoint.y) / 2);
-    var l = Math.pow(currp.x, 2) / Math.pow(rX, 2) + Math.pow(currp.y, 2) / Math.pow(rY, 2);
-    if (l > 1) {
-      rX *= Math.sqrt(l);
-      rY *= Math.sqrt(l);
+    var l2 = Math.pow(currp.x, 2) / Math.pow(rX, 2) + Math.pow(currp.y, 2) / Math.pow(rY, 2);
+    if (l2 > 1) {
+      rX *= Math.sqrt(l2);
+      rY *= Math.sqrt(l2);
     }
-    var s = (lArcFlag === sweepFlag ? -1 : 1) * Math.sqrt((Math.pow(rX, 2) * Math.pow(rY, 2) - Math.pow(rX, 2) * Math.pow(currp.y, 2) - Math.pow(rY, 2) * Math.pow(currp.x, 2)) / (Math.pow(rX, 2) * Math.pow(currp.y, 2) + Math.pow(rY, 2) * Math.pow(currp.x, 2)));
-    if (isNaN(s)) {
-      s = 0;
+    var s2 = (lArcFlag === sweepFlag ? -1 : 1) * Math.sqrt((Math.pow(rX, 2) * Math.pow(rY, 2) - Math.pow(rX, 2) * Math.pow(currp.y, 2) - Math.pow(rY, 2) * Math.pow(currp.x, 2)) / (Math.pow(rX, 2) * Math.pow(currp.y, 2) + Math.pow(rY, 2) * Math.pow(currp.x, 2)));
+    if (isNaN(s2)) {
+      s2 = 0;
     }
-    var cpp = new Point(s * rX * currp.y / rY, s * -rY * currp.x / rX);
+    var cpp = new Point(s2 * rX * currp.y / rY, s2 * -rY * currp.x / rX);
     var centp = new Point((current.x + currentPoint.x) / 2 + Math.cos(xAxisRotation) * cpp.x - Math.sin(xAxisRotation) * cpp.y, (current.y + currentPoint.y) / 2 + Math.sin(xAxisRotation) * cpp.x + Math.cos(xAxisRotation) * cpp.y);
     var a1 = vectorsAngle([1, 0], [(currp.x - cpp.x) / rX, (currp.y - cpp.y) / rY]);
-    var u = [(currp.x - cpp.x) / rX, (currp.y - cpp.y) / rY];
-    var v = [(-currp.x - cpp.x) / rX, (-currp.y - cpp.y) / rY];
-    var ad = vectorsAngle(u, v);
-    if (vectorsRatio(u, v) <= -1) {
+    var u2 = [(currp.x - cpp.x) / rX, (currp.y - cpp.y) / rY];
+    var v2 = [(-currp.x - cpp.x) / rX, (-currp.y - cpp.y) / rY];
+    var ad = vectorsAngle(u2, v2);
+    if (vectorsRatio(u2, v2) <= -1) {
       ad = Math.PI;
     }
-    if (vectorsRatio(u, v) >= 1) {
+    if (vectorsRatio(u2, v2) >= 1) {
       ad = 0;
     }
     return {
@@ -2398,13 +4226,13 @@ class PathElement extends RenderedElement {
     pathParser.addMarkerAngle(currentPoint, ah - dir * Math.PI);
     boundingBox.addPoint(currentPoint.x, currentPoint.y);
     if (ctx && !isNaN(a1) && !isNaN(ad)) {
-      var r = rX > rY ? rX : rY;
+      var r2 = rX > rY ? rX : rY;
       var sx = rX > rY ? 1 : rX / rY;
       var sy = rX > rY ? rY / rX : 1;
       ctx.translate(centp.x, centp.y);
       ctx.rotate(xAxisRotation);
       ctx.scale(sx, sy);
-      ctx.arc(0, 0, r, a1, a1 + ad, Boolean(1 - sweepFlag));
+      ctx.arc(0, 0, r2, a1, a1 + ad, Boolean(1 - sweepFlag));
       ctx.scale(1 / sx, 1 / sy);
       ctx.rotate(-xAxisRotation);
       ctx.translate(-centp.x, -centp.y);
@@ -2462,8 +4290,8 @@ class TextElement extends RenderedElement {
     this.initializeCoordinates();
     this.adjustChildCoordinatesRecursive(ctx);
     var boundingBox = null;
-    this.children.forEach((_2, i) => {
-      var childBoundingBox = this.getChildBoundingBox(ctx, this, this, i);
+    this.children.forEach((_2, i2) => {
+      var childBoundingBox = this.getChildBoundingBox(ctx, this, this, i2);
       if (!boundingBox) {
         boundingBox = childBoundingBox;
       } else {
@@ -2485,21 +4313,21 @@ class TextElement extends RenderedElement {
     var fontSize = this.getFontSize();
     return new BoundingBox(this.x, this.y - fontSize, this.x + this.measureText(ctx), this.y);
   }
-  getGlyph(font, text, i) {
-    var char = text[i];
+  getGlyph(font, text, i2) {
+    var char = text[i2];
     var glyph = null;
     if (font.isArabic) {
       var len = text.length;
-      var prevChar = text[i - 1];
-      var nextChar = text[i + 1];
+      var prevChar = text[i2 - 1];
+      var nextChar = text[i2 + 1];
       var arabicForm = "isolated";
-      if ((i === 0 || prevChar === " ") && i < len - 1 && nextChar !== " ") {
+      if ((i2 === 0 || prevChar === " ") && i2 < len - 1 && nextChar !== " ") {
         arabicForm = "terminal";
       }
-      if (i > 0 && prevChar !== " " && i < len - 1 && nextChar !== " ") {
+      if (i2 > 0 && prevChar !== " " && i2 < len - 1 && nextChar !== " ") {
         arabicForm = "medial";
       }
-      if (i > 0 && prevChar !== " " && (i === len - 1 || nextChar === " ")) {
+      if (i2 > 0 && prevChar !== " " && (i2 === len - 1 || nextChar === " ")) {
         arabicForm = "initial";
       }
       if (typeof font.glyphs[char] !== "undefined") {
@@ -2540,8 +4368,8 @@ class TextElement extends RenderedElement {
     }
     this.initializeCoordinates();
     this.adjustChildCoordinatesRecursive(ctx);
-    this.children.forEach((_2, i) => {
-      this.renderChild(ctx, this, this, i);
+    this.children.forEach((_2, i2) => {
+      this.renderChild(ctx, this, this, i2);
     });
     var {
       mouse
@@ -2568,8 +4396,8 @@ class TextElement extends RenderedElement {
       var text = customFont.isRTL ? renderText.split("").reverse().join("") : renderText;
       var dx = toNumbers(parent.getAttribute("dx").getString());
       var len = text.length;
-      for (var i = 0; i < len; i++) {
-        var glyph = this.getGlyph(customFont, text, i);
+      for (var i2 = 0; i2 < len; i2++) {
+        var glyph = this.getGlyph(customFont, text, i2);
         ctx.translate(this.x, this.y);
         ctx.scale(scale, -scale);
         var lw = ctx.lineWidth;
@@ -2585,21 +4413,21 @@ class TextElement extends RenderedElement {
         ctx.scale(1 / scale, -1 / scale);
         ctx.translate(-this.x, -this.y);
         this.x += fontSize * (glyph.horizAdvX || customFont.horizAdvX) / unitsPerEm;
-        if (typeof dx[i] !== "undefined" && !isNaN(dx[i])) {
-          this.x += dx[i];
+        if (typeof dx[i2] !== "undefined" && !isNaN(dx[i2])) {
+          this.x += dx[i2];
         }
       }
       return;
     }
     var {
       x,
-      y
+      y: y2
     } = this;
     if (ctx.fillStyle) {
-      ctx.fillText(renderText, x, y);
+      ctx.fillText(renderText, x, y2);
     }
     if (ctx.strokeStyle) {
-      ctx.strokeText(renderText, x, y);
+      ctx.strokeText(renderText, x, y2);
     }
   }
   applyAnchoring() {
@@ -2617,31 +4445,31 @@ class TextElement extends RenderedElement {
     } else {
       shift = firstElement.x - (this.minX + this.maxX) / 2;
     }
-    for (var i = this.textChunkStart; i < this.leafTexts.length; i++) {
-      this.leafTexts[i].x += shift;
+    for (var i2 = this.textChunkStart; i2 < this.leafTexts.length; i2++) {
+      this.leafTexts[i2].x += shift;
     }
     this.minX = Number.POSITIVE_INFINITY;
     this.maxX = Number.NEGATIVE_INFINITY;
     this.textChunkStart = this.leafTexts.length;
   }
   adjustChildCoordinatesRecursive(ctx) {
-    this.children.forEach((_2, i) => {
-      this.adjustChildCoordinatesRecursiveCore(ctx, this, this, i);
+    this.children.forEach((_2, i2) => {
+      this.adjustChildCoordinatesRecursiveCore(ctx, this, this, i2);
     });
     this.applyAnchoring();
   }
-  adjustChildCoordinatesRecursiveCore(ctx, textParent, parent, i) {
-    var child = parent.children[i];
+  adjustChildCoordinatesRecursiveCore(ctx, textParent, parent, i2) {
+    var child = parent.children[i2];
     if (child.children.length > 0) {
-      child.children.forEach((_2, i2) => {
-        textParent.adjustChildCoordinatesRecursiveCore(ctx, textParent, child, i2);
+      child.children.forEach((_2, i3) => {
+        textParent.adjustChildCoordinatesRecursiveCore(ctx, textParent, child, i3);
       });
     } else {
-      this.adjustChildCoordinates(ctx, textParent, parent, i);
+      this.adjustChildCoordinates(ctx, textParent, parent, i2);
     }
   }
-  adjustChildCoordinates(ctx, textParent, parent, i) {
-    var child = parent.children[i];
+  adjustChildCoordinates(ctx, textParent, parent, i2) {
+    var child = parent.children[i2];
     if (typeof child.measureText !== "function") {
       return child;
     }
@@ -2653,7 +4481,7 @@ class TextElement extends RenderedElement {
     var dyAttr = child.getAttribute("dy");
     var customFont = child.getStyle("font-family").getDefinition();
     var isRTL = Boolean(customFont) && customFont.isRTL;
-    if (i === 0) {
+    if (i2 === 0) {
       if (!xAttr.hasValue()) {
         xAttr.setValue(child.getInheritedAttribute("x"));
       }
@@ -2706,8 +4534,8 @@ class TextElement extends RenderedElement {
     ctx.restore();
     return child;
   }
-  getChildBoundingBox(ctx, textParent, parent, i) {
-    var child = parent.children[i];
+  getChildBoundingBox(ctx, textParent, parent, i2) {
+    var child = parent.children[i2];
     if (typeof child.getBoundingBox !== "function") {
       return null;
     }
@@ -2715,17 +4543,17 @@ class TextElement extends RenderedElement {
     if (!boundingBox) {
       return null;
     }
-    child.children.forEach((_2, i2) => {
-      var childBoundingBox = textParent.getChildBoundingBox(ctx, textParent, child, i2);
+    child.children.forEach((_2, i3) => {
+      var childBoundingBox = textParent.getChildBoundingBox(ctx, textParent, child, i3);
       boundingBox.addBoundingBox(childBoundingBox);
     });
     return boundingBox;
   }
-  renderChild(ctx, textParent, parent, i) {
-    var child = parent.children[i];
+  renderChild(ctx, textParent, parent, i2) {
+    var child = parent.children[i2];
     child.render(ctx);
-    child.children.forEach((_2, i2) => {
-      textParent.renderChild(ctx, textParent, child, i2);
+    child.children.forEach((_2, i3) => {
+      textParent.renderChild(ctx, textParent, child, i3);
     });
   }
   measureText(ctx) {
@@ -2754,11 +4582,11 @@ class TextElement extends RenderedElement {
       var dx = toNumbers(parent.getAttribute("dx").getString());
       var len = text.length;
       var _measure = 0;
-      for (var i = 0; i < len; i++) {
-        var glyph = this.getGlyph(customFont, text, i);
+      for (var i2 = 0; i2 < len; i2++) {
+        var glyph = this.getGlyph(customFont, text, i2);
         _measure += (glyph.horizAdvX || customFont.horizAdvX) * fontSize / customFont.fontFace.unitsPerEm;
-        if (typeof dx[i] !== "undefined" && !isNaN(dx[i])) {
-          _measure += dx[i];
+        if (typeof dx[i2] !== "undefined" && !isNaN(dx[i2])) {
+          _measure += dx[i2];
         }
       }
       return _measure;
@@ -2947,7 +4775,7 @@ class RectElement extends PathElement {
   }
   path(ctx) {
     var x = this.getAttribute("x").getPixels("x");
-    var y = this.getAttribute("y").getPixels("y");
+    var y2 = this.getAttribute("y").getPixels("y");
     var width = this.getStyle("width", false, true).getPixels("x");
     var height = this.getStyle("height", false, true).getPixels("y");
     var rxAttr = this.getAttribute("rx");
@@ -2966,19 +4794,19 @@ class RectElement extends PathElement {
       var KAPPA = 4 * ((Math.sqrt(2) - 1) / 3);
       ctx.beginPath();
       if (height > 0 && width > 0) {
-        ctx.moveTo(x + rx, y);
-        ctx.lineTo(x + width - rx, y);
-        ctx.bezierCurveTo(x + width - rx + KAPPA * rx, y, x + width, y + ry - KAPPA * ry, x + width, y + ry);
-        ctx.lineTo(x + width, y + height - ry);
-        ctx.bezierCurveTo(x + width, y + height - ry + KAPPA * ry, x + width - rx + KAPPA * rx, y + height, x + width - rx, y + height);
-        ctx.lineTo(x + rx, y + height);
-        ctx.bezierCurveTo(x + rx - KAPPA * rx, y + height, x, y + height - ry + KAPPA * ry, x, y + height - ry);
-        ctx.lineTo(x, y + ry);
-        ctx.bezierCurveTo(x, y + ry - KAPPA * ry, x + rx - KAPPA * rx, y, x + rx, y);
+        ctx.moveTo(x + rx, y2);
+        ctx.lineTo(x + width - rx, y2);
+        ctx.bezierCurveTo(x + width - rx + KAPPA * rx, y2, x + width, y2 + ry - KAPPA * ry, x + width, y2 + ry);
+        ctx.lineTo(x + width, y2 + height - ry);
+        ctx.bezierCurveTo(x + width, y2 + height - ry + KAPPA * ry, x + width - rx + KAPPA * rx, y2 + height, x + width - rx, y2 + height);
+        ctx.lineTo(x + rx, y2 + height);
+        ctx.bezierCurveTo(x + rx - KAPPA * rx, y2 + height, x, y2 + height - ry + KAPPA * ry, x, y2 + height - ry);
+        ctx.lineTo(x, y2 + ry);
+        ctx.bezierCurveTo(x, y2 + ry - KAPPA * ry, x + rx - KAPPA * rx, y2, x + rx, y2);
         ctx.closePath();
       }
     }
-    return new BoundingBox(x, y, x + width, y + height);
+    return new BoundingBox(x, y2, x + width, y2 + height);
   }
   getMarkers() {
     return null;
@@ -2992,13 +4820,13 @@ class CircleElement extends PathElement {
   path(ctx) {
     var cx = this.getAttribute("cx").getPixels("x");
     var cy = this.getAttribute("cy").getPixels("y");
-    var r = this.getAttribute("r").getPixels();
-    if (ctx && r > 0) {
+    var r2 = this.getAttribute("r").getPixels();
+    if (ctx && r2 > 0) {
       ctx.beginPath();
-      ctx.arc(cx, cy, r, 0, Math.PI * 2, false);
+      ctx.arc(cx, cy, r2, 0, Math.PI * 2, false);
       ctx.closePath();
     }
-    return new BoundingBox(cx - r, cy - r, cx + r, cy + r);
+    return new BoundingBox(cx - r2, cy - r2, cx + r2, cy + r2);
   }
   getMarkers() {
     return null;
@@ -3055,8 +4883,8 @@ class LineElement extends PathElement {
   }
   getMarkers() {
     var [p0, p1] = this.getPoints();
-    var a = p0.angleTo(p1);
-    return [[p0, a], [p1, a]];
+    var a2 = p0.angleTo(p1);
+    return [[p0, a2], [p1, a2]];
   }
 }
 class PolylineElement extends PathElement {
@@ -3082,11 +4910,11 @@ class PolylineElement extends PathElement {
     points.forEach((_ref) => {
       var {
         x,
-        y
+        y: y2
       } = _ref;
-      boundingBox.addPoint(x, y);
+      boundingBox.addPoint(x, y2);
       if (ctx) {
-        ctx.lineTo(x, y);
+        ctx.lineTo(x, y2);
       }
     });
     return boundingBox;
@@ -3097,11 +4925,11 @@ class PolylineElement extends PathElement {
     } = this;
     var lastIndex = points.length - 1;
     var markers = [];
-    points.forEach((point, i) => {
-      if (i === lastIndex) {
+    points.forEach((point, i2) => {
+      if (i2 === lastIndex) {
         return;
       }
-      markers.push([point, point.angleTo(points[i + 1])]);
+      markers.push([point, point.angleTo(points[i2 + 1])]);
     });
     if (markers.length > 0) {
       markers.push([points[points.length - 1], markers[markers.length - 1][1]]);
@@ -3118,10 +4946,10 @@ class PolygonElement extends PolylineElement {
     var boundingBox = super.path(ctx);
     var [{
       x,
-      y
+      y: y2
     }] = this.points;
     if (ctx) {
-      ctx.lineTo(x, y);
+      ctx.lineTo(x, y2);
       ctx.closePath();
     }
     return boundingBox;
@@ -3154,10 +4982,10 @@ class PatternElement extends Element {
       Reflect.deleteProperty(this.styles, "fill-opacity");
     }
     for (var x = -1; x <= 1; x++) {
-      for (var y = -1; y <= 1; y++) {
+      for (var y2 = -1; y2 <= 1; y2++) {
         patternCtx.save();
         patternSvg.attributes.x = new Property(this.document, "x", x * patternCanvas.width);
-        patternSvg.attributes.y = new Property(this.document, "y", y * patternCanvas.height);
+        patternSvg.attributes.y = new Property(this.document, "y", y2 * patternCanvas.height);
         patternSvg.render(patternCtx);
         patternCtx.restore();
       }
@@ -3177,11 +5005,11 @@ class MarkerElement extends Element {
     }
     var {
       x,
-      y
+      y: y2
     } = point;
     var orient = this.getAttribute("orient").getString("auto");
     var markerUnits = this.getAttribute("markerUnits").getString("strokeWidth");
-    ctx.translate(x, y);
+    ctx.translate(x, y2);
     if (orient === "auto") {
       ctx.rotate(angle);
     }
@@ -3208,7 +5036,7 @@ class MarkerElement extends Element {
     if (orient === "auto") {
       ctx.rotate(-angle);
     }
-    ctx.translate(-x, -y);
+    ctx.translate(-x, -y2);
   }
 }
 class DefsElement extends Element {
@@ -3371,9 +5199,9 @@ class RadialGradientElement extends GradientElement {
     if (this.getAttribute("fy").hasValue()) {
       fy = isBoundingBoxUnits ? boundingBox.y + boundingBox.height * this.getAttribute("fy").getNumber() : this.getAttribute("fy").getPixels("y");
     }
-    var r = isBoundingBoxUnits ? (boundingBox.width + boundingBox.height) / 2 * this.getAttribute("r").getNumber() : this.getAttribute("r").getPixels();
+    var r2 = isBoundingBoxUnits ? (boundingBox.width + boundingBox.height) / 2 * this.getAttribute("r").getNumber() : this.getAttribute("r").getPixels();
     var fr = this.getAttribute("fr").getPixels();
-    return ctx.createRadialGradient(fx, fy, fr, cx, cy, r);
+    return ctx.createRadialGradient(fx, fy, fr, cx, cy, r2);
   }
 }
 class StopElement extends Element {
@@ -3483,12 +5311,12 @@ class AnimateElement extends Element {
       progress: (this.duration - this.begin) / (this.maxDuration - this.begin)
     };
     if (values.hasValue()) {
-      var p = result.progress * (values.getValue().length - 1);
-      var lb = Math.floor(p);
-      var ub = Math.ceil(p);
+      var p2 = result.progress * (values.getValue().length - 1);
+      var lb = Math.floor(p2);
+      var ub = Math.ceil(p2);
       result.from = new Property(document2, "from", parseFloat(values.getValue()[lb]));
       result.to = new Property(document2, "to", parseFloat(values.getValue()[ub]));
-      result.progress = (p - lb) / (ub - lb);
+      result.progress = (p2 - lb) / (ub - lb);
     } else {
       result.from = this.from;
       result.to = this.to;
@@ -3510,10 +5338,10 @@ class AnimateColorElement extends AnimateElement {
     var colorFrom = new _rgbcolor_1_0_1_rgbcolor(from.getColor());
     var colorTo = new _rgbcolor_1_0_1_rgbcolor(to.getColor());
     if (colorFrom.ok && colorTo.ok) {
-      var r = colorFrom.r + (colorTo.r - colorFrom.r) * progress;
+      var r2 = colorFrom.r + (colorTo.r - colorFrom.r) * progress;
       var g = colorFrom.g + (colorTo.g - colorFrom.g) * progress;
       var b = colorFrom.b + (colorTo.b - colorFrom.b) * progress;
-      return "rgb(".concat(Math.floor(r), ", ").concat(Math.floor(g), ", ").concat(Math.floor(b), ")");
+      return "rgb(".concat(Math.floor(r2), ", ").concat(Math.floor(g), ", ").concat(Math.floor(b), ")");
     }
     return this.getAttribute("from").getColor();
   }
@@ -3531,8 +5359,8 @@ class AnimateTransformElement extends AnimateElement {
     } = this.getProgress();
     var transformFrom = toNumbers(from.getString());
     var transformTo = toNumbers(to.getString());
-    var newValue = transformFrom.map((from2, i) => {
-      var to2 = transformTo[i];
+    var newValue = transformFrom.map((from2, i2) => {
+      var to2 = transformTo[i2];
       return from2 + (to2 - from2) * progress;
     }).join(" ");
     return newValue;
@@ -3636,14 +5464,14 @@ class AElement extends TextElement {
       var {
         document: document2,
         x,
-        y
+        y: y2
       } = this;
       var {
         mouse
       } = document2.screen;
       var fontSize = new Property(document2, "fontSize", Font.parse(document2.ctx.font).fontSize);
       if (mouse.isWorking()) {
-        mouse.checkBoundingBox(this, new BoundingBox(x, y - fontSize.getPixels("y"), x + this.measureText(ctx), y));
+        mouse.checkBoundingBox(this, new BoundingBox(x, y2 - fontSize.getPixels("y"), x + this.measureText(ctx), y2));
       }
     } else if (this.children.length > 0) {
       var g = new GElement(this.document, null);
@@ -3679,9 +5507,9 @@ function ownKeys$2(object, enumerableOnly) {
   return keys;
 }
 function _objectSpread$2(target) {
-  for (var i = 1; i < arguments.length; i++) {
-    var source = arguments[i] != null ? arguments[i] : {};
-    if (i % 2) {
+  for (var i2 = 1; i2 < arguments.length; i2++) {
+    var source = arguments[i2] != null ? arguments[i2] : {};
+    if (i2 % 2) {
       ownKeys$2(Object(source), true).forEach(function(key) {
         _defineProperty(target, key, source[key]);
       });
@@ -3747,14 +5575,14 @@ class TextPathElement extends TextElement {
           break;
         case PathParser.ARC: {
           var [cx, cy, rx, ry, theta, dTheta, psi, fs] = points;
-          var r = rx > ry ? rx : ry;
+          var r2 = rx > ry ? rx : ry;
           var scaleX = rx > ry ? 1 : rx / ry;
           var scaleY = rx > ry ? ry / rx : 1;
           if (ctx) {
             ctx.translate(cx, cy);
             ctx.rotate(psi);
             ctx.scale(scaleX, scaleY);
-            ctx.arc(0, 0, r, theta, theta + dTheta, Boolean(1 - fs));
+            ctx.arc(0, 0, r2, theta, theta + dTheta, Boolean(1 - fs));
             ctx.scale(1 / scaleX, 1 / scaleY);
             ctx.rotate(-psi);
             ctx.translate(-cx, -cy);
@@ -3781,7 +5609,7 @@ class TextPathElement extends TextElement {
     if (textDecoration === "underline") {
       ctx.beginPath();
     }
-    glyphInfo.forEach((glyph, i) => {
+    glyphInfo.forEach((glyph, i2) => {
       var {
         p0,
         p1,
@@ -3799,7 +5627,7 @@ class TextPathElement extends TextElement {
       }
       ctx.restore();
       if (textDecoration === "underline") {
-        if (i === 0) {
+        if (i2 === 0) {
           ctx.moveTo(p0.x, p0.y + fontSize / 8);
         }
         ctx.lineTo(p1.x, p1.y + fontSize / 5);
@@ -3888,10 +5716,10 @@ class TextPathElement extends TextElement {
     var letterSpacingCache = [];
     var textLen = renderText.length;
     this.letterSpacingCache = letterSpacingCache;
-    for (var i = 0; i < textLen; i++) {
-      letterSpacingCache.push(typeof dx[i] !== "undefined" ? dx[i] : letterSpacing);
+    for (var i2 = 0; i2 < textLen; i2++) {
+      letterSpacingCache.push(typeof dx[i2] !== "undefined" ? dx[i2] : letterSpacing);
     }
-    var dxSum = letterSpacingCache.reduce((acc, cur, i2) => i2 === 0 ? 0 : acc + cur || 0, 0);
+    var dxSum = letterSpacingCache.reduce((acc, cur, i3) => i3 === 0 ? 0 : acc + cur || 0, 0);
     var textWidth = this.measureText(ctx);
     var textFullWidth = Math.max(textWidth + dxSum, 0);
     this.textWidth = textWidth;
@@ -3907,18 +5735,18 @@ class TextPathElement extends TextElement {
       offset = -textFullWidth;
     }
     offset += startOffset;
-    chars.forEach((char, i2) => {
+    chars.forEach((char, i3) => {
       var {
         offset: nextOffset,
         segment,
         rotation
-      } = this.findSegmentToFitChar(ctx, anchor, textFullWidth, fullPathWidth, spacesNumber, offset, dy, char, i2);
+      } = this.findSegmentToFitChar(ctx, anchor, textFullWidth, fullPathWidth, spacesNumber, offset, dy, char, i3);
       offset = nextOffset;
       if (!segment.p0 || !segment.p1) {
         return;
       }
       this.glyphInfo.push({
-        text: chars[i2],
+        text: chars[i3],
         p0: segment.p0,
         p1: segment.p1,
         rotation
@@ -3999,32 +5827,32 @@ class TextPathElement extends TextElement {
   pathM(pathParser, points) {
     var {
       x,
-      y
+      y: y2
     } = PathElement.pathM(pathParser).point;
-    points.push(x, y);
+    points.push(x, y2);
   }
   pathL(pathParser, points) {
     var {
       x,
-      y
+      y: y2
     } = PathElement.pathL(pathParser).point;
-    points.push(x, y);
+    points.push(x, y2);
     return PathParser.LINE_TO;
   }
   pathH(pathParser, points) {
     var {
       x,
-      y
+      y: y2
     } = PathElement.pathH(pathParser).point;
-    points.push(x, y);
+    points.push(x, y2);
     return PathParser.LINE_TO;
   }
   pathV(pathParser, points) {
     var {
       x,
-      y
+      y: y2
     } = PathElement.pathV(pathParser).point;
-    points.push(x, y);
+    points.push(x, y2);
     return PathParser.LINE_TO;
   }
   pathC(pathParser, points) {
@@ -4077,28 +5905,28 @@ class TextPathElement extends TextElement {
     }
     return [centp.x, centp.y, rX, rY, a1, ad, xAxisRotation, sweepFlag];
   }
-  calcLength(x, y, commandType, points) {
+  calcLength(x, y2, commandType, points) {
     var len = 0;
     var p1 = null;
     var p2 = null;
-    var t = 0;
+    var t2 = 0;
     switch (commandType) {
       case PathParser.LINE_TO:
-        return this.getLineLength(x, y, points[0], points[1]);
+        return this.getLineLength(x, y2, points[0], points[1]);
       case PathParser.CURVE_TO:
         len = 0;
-        p1 = this.getPointOnCubicBezier(0, x, y, points[0], points[1], points[2], points[3], points[4], points[5]);
-        for (t = 0.01; t <= 1; t += 0.01) {
-          p2 = this.getPointOnCubicBezier(t, x, y, points[0], points[1], points[2], points[3], points[4], points[5]);
+        p1 = this.getPointOnCubicBezier(0, x, y2, points[0], points[1], points[2], points[3], points[4], points[5]);
+        for (t2 = 0.01; t2 <= 1; t2 += 0.01) {
+          p2 = this.getPointOnCubicBezier(t2, x, y2, points[0], points[1], points[2], points[3], points[4], points[5]);
           len += this.getLineLength(p1.x, p1.y, p2.x, p2.y);
           p1 = p2;
         }
         return len;
       case PathParser.QUAD_TO:
         len = 0;
-        p1 = this.getPointOnQuadraticBezier(0, x, y, points[0], points[1], points[2], points[3]);
-        for (t = 0.01; t <= 1; t += 0.01) {
-          p2 = this.getPointOnQuadraticBezier(t, x, y, points[0], points[1], points[2], points[3]);
+        p1 = this.getPointOnQuadraticBezier(0, x, y2, points[0], points[1], points[2], points[3]);
+        for (t2 = 0.01; t2 <= 1; t2 += 0.01) {
+          p2 = this.getPointOnQuadraticBezier(t2, x, y2, points[0], points[1], points[2], points[3]);
           len += this.getLineLength(p1.x, p1.y, p2.x, p2.y);
           p1 = p2;
         }
@@ -4114,14 +5942,14 @@ class TextPathElement extends TextElement {
         }
         p1 = this.getPointOnEllipticalArc(points[0], points[1], points[2], points[3], start, 0);
         if (dTheta < 0) {
-          for (t = start - inc; t > end; t -= inc) {
-            p2 = this.getPointOnEllipticalArc(points[0], points[1], points[2], points[3], t, 0);
+          for (t2 = start - inc; t2 > end; t2 -= inc) {
+            p2 = this.getPointOnEllipticalArc(points[0], points[1], points[2], points[3], t2, 0);
             len += this.getLineLength(p1.x, p1.y, p2.x, p2.y);
             p1 = p2;
           }
         } else {
-          for (t = start + inc; t < end; t += inc) {
-            p2 = this.getPointOnEllipticalArc(points[0], points[1], points[2], points[3], t, 0);
+          for (t2 = start + inc; t2 < end; t2 += inc) {
+            p2 = this.getPointOnEllipticalArc(points[0], points[1], points[2], points[3], t2, 0);
             len += this.getLineLength(p1.x, p1.y, p2.x, p2.y);
             p1 = p2;
           }
@@ -4160,10 +5988,10 @@ class TextPathElement extends TextElement {
       if (len < PSEUDO_ZERO) {
         return null;
       }
-      var u = (fromX - p1x) * (p2x - p1x) + (fromY - p1y) * (p2y - p1y);
-      u /= len * len;
-      ix = p1x + u * (p2x - p1x);
-      iy = p1y + u * (p2y - p1y);
+      var u2 = (fromX - p1x) * (p2x - p1x) + (fromY - p1y) * (p2y - p1y);
+      u2 /= len * len;
+      ix = p1x + u2 * (p2x - p1x);
+      iy = p1y + u2 * (p2y - p1y);
       var pRise = this.getLineLength(fromX, fromY, ix, iy);
       var pRun = Math.sqrt(dist * dist - pRise * pRise);
       run = Math.sqrt(pRun * pRun / (1 + m2 * m2));
@@ -4181,7 +6009,7 @@ class TextPathElement extends TextElement {
   getPointOnPath(distance) {
     var fullLen = this.getPathLength();
     var cumulativePathLength = 0;
-    var p = null;
+    var p2 = null;
     if (distance < -5e-5 || distance - 5e-5 > fullLen) {
       return null;
     }
@@ -4197,7 +6025,7 @@ class TextPathElement extends TextElement {
       var currentT = 0;
       switch (command.type) {
         case PathParser.LINE_TO:
-          p = this.getPointOnLine(delta, command.start.x, command.start.y, command.points[0], command.points[1], command.start.x, command.start.y);
+          p2 = this.getPointOnLine(delta, command.start.x, command.start.y, command.points[0], command.points[1], command.start.x, command.start.y);
           break;
         case PathParser.ARC: {
           var start = command.points[4];
@@ -4207,7 +6035,7 @@ class TextPathElement extends TextElement {
           if (dTheta < 0 && currentT < end || dTheta >= 0 && currentT > end) {
             break;
           }
-          p = this.getPointOnEllipticalArc(command.points[0], command.points[1], command.points[2], command.points[3], currentT, command.points[6]);
+          p2 = this.getPointOnEllipticalArc(command.points[0], command.points[1], command.points[2], command.points[3], currentT, command.points[6]);
           break;
         }
         case PathParser.CURVE_TO:
@@ -4215,18 +6043,18 @@ class TextPathElement extends TextElement {
           if (currentT > 1) {
             currentT = 1;
           }
-          p = this.getPointOnCubicBezier(currentT, command.start.x, command.start.y, command.points[0], command.points[1], command.points[2], command.points[3], command.points[4], command.points[5]);
+          p2 = this.getPointOnCubicBezier(currentT, command.start.x, command.start.y, command.points[0], command.points[1], command.points[2], command.points[3], command.points[4], command.points[5]);
           break;
         case PathParser.QUAD_TO:
           currentT = delta / command.pathLength;
           if (currentT > 1) {
             currentT = 1;
           }
-          p = this.getPointOnQuadraticBezier(currentT, command.start.x, command.start.y, command.points[0], command.points[1], command.points[2], command.points[3]);
+          p2 = this.getPointOnQuadraticBezier(currentT, command.start.x, command.start.y, command.points[0], command.points[1], command.points[2], command.points[3]);
           break;
       }
-      if (p) {
-        return p;
+      if (p2) {
+        return p2;
       }
       break;
     }
@@ -4243,18 +6071,18 @@ class TextPathElement extends TextElement {
   }
   getPointOnCubicBezier(pct, p1x, p1y, p2x, p2y, p3x, p3y, p4x, p4y) {
     var x = p4x * CB1(pct) + p3x * CB2(pct) + p2x * CB3(pct) + p1x * CB4(pct);
-    var y = p4y * CB1(pct) + p3y * CB2(pct) + p2y * CB3(pct) + p1y * CB4(pct);
+    var y2 = p4y * CB1(pct) + p3y * CB2(pct) + p2y * CB3(pct) + p1y * CB4(pct);
     return {
       x,
-      y
+      y: y2
     };
   }
   getPointOnQuadraticBezier(pct, p1x, p1y, p2x, p2y, p3x, p3y) {
     var x = p3x * QB1(pct) + p2x * QB2(pct) + p1x * QB3(pct);
-    var y = p3y * QB1(pct) + p2y * QB2(pct) + p1y * QB3(pct);
+    var y2 = p3y * QB1(pct) + p2y * QB2(pct) + p1y * QB3(pct);
     return {
       x,
-      y
+      y: y2
     };
   }
   getPointOnEllipticalArc(cx, cy, rx, ry, theta, psi) {
@@ -4279,21 +6107,21 @@ class TextPathElement extends TextElement {
         precision,
         points: []
       };
-      var s = 0;
-      for (var l = 0; l <= fullLen; l += precision) {
-        var p0 = this.getPointOnPath(l);
-        var p1 = this.getPointOnPath(l + precision);
+      var s2 = 0;
+      for (var l2 = 0; l2 <= fullLen; l2 += precision) {
+        var p0 = this.getPointOnPath(l2);
+        var p1 = this.getPointOnPath(l2 + precision);
         if (!p0 || !p1) {
           continue;
         }
-        s += this.getLineLength(p0.x, p0.y, p1.x, p1.y);
-        if (s >= step) {
+        s2 += this.getLineLength(p0.x, p0.y, p1.x, p1.y);
+        if (s2 >= step) {
           this.equidistantCache.points.push({
             x: p0.x,
             y: p0.y,
-            distance: l
+            distance: l2
           });
-          s -= step;
+          s2 -= step;
         }
       }
     }
@@ -4368,14 +6196,14 @@ class ImageElement extends RenderedElement {
       loaded
     } = this;
     var x = this.getAttribute("x").getPixels("x");
-    var y = this.getAttribute("y").getPixels("y");
+    var y2 = this.getAttribute("y").getPixels("y");
     var width = this.getStyle("width").getPixels("x");
     var height = this.getStyle("height").getPixels("y");
     if (!loaded || !image || !width || !height) {
       return;
     }
     ctx.save();
-    ctx.translate(x, y);
+    ctx.translate(x, y2);
     if (this.isSvg) {
       var subDocument = document2.canvg.forkString(ctx, this.image, {
         ignoreMouse: true,
@@ -4409,10 +6237,10 @@ class ImageElement extends RenderedElement {
   }
   getBoundingBox() {
     var x = this.getAttribute("x").getPixels("x");
-    var y = this.getAttribute("y").getPixels("y");
+    var y2 = this.getAttribute("y").getPixels("y");
     var width = this.getStyle("width").getPixels("x");
     var height = this.getStyle("height").getPixels("y");
-    return new BoundingBox(x, y, x + width, y + height);
+    return new BoundingBox(x, y2, x + width, y2 + height);
   }
 }
 class SymbolElement extends RenderedElement {
@@ -4576,18 +6404,18 @@ class UseElement extends RenderedElement {
     return this.cachedElement;
   }
 }
-function imGet(img, x, y, width, _height, rgba) {
-  return img[y * width * 4 + x * 4 + rgba];
+function imGet(img, x, y2, width, _height, rgba) {
+  return img[y2 * width * 4 + x * 4 + rgba];
 }
-function imSet(img, x, y, width, _height, rgba, val) {
-  img[y * width * 4 + x * 4 + rgba] = val;
+function imSet(img, x, y2, width, _height, rgba, val) {
+  img[y2 * width * 4 + x * 4 + rgba] = val;
 }
-function m(matrix, i, v) {
-  var mi = matrix[i];
-  return mi * v;
+function m(matrix, i2, v2) {
+  var mi = matrix[i2];
+  return mi * v2;
 }
-function c(a, m1, m2, m3) {
-  return m1 + Math.cos(a) * m2 + Math.sin(a) * m3;
+function c(a2, m1, m2, m3) {
+  return m1 + Math.cos(a2) * m2 + Math.sin(a2) * m3;
 }
 class FeColorMatrixElement extends Element {
   constructor(document2, node2, captureTextNodes) {
@@ -4596,13 +6424,13 @@ class FeColorMatrixElement extends Element {
     var matrix = toNumbers(this.getAttribute("values").getString());
     switch (this.getAttribute("type").getString("matrix")) {
       case "saturate": {
-        var s = matrix[0];
-        matrix = [0.213 + 0.787 * s, 0.715 - 0.715 * s, 0.072 - 0.072 * s, 0, 0, 0.213 - 0.213 * s, 0.715 + 0.285 * s, 0.072 - 0.072 * s, 0, 0, 0.213 - 0.213 * s, 0.715 - 0.715 * s, 0.072 + 0.928 * s, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1];
+        var s2 = matrix[0];
+        matrix = [0.213 + 0.787 * s2, 0.715 - 0.715 * s2, 0.072 - 0.072 * s2, 0, 0, 0.213 - 0.213 * s2, 0.715 + 0.285 * s2, 0.072 - 0.072 * s2, 0, 0, 0.213 - 0.213 * s2, 0.715 - 0.715 * s2, 0.072 + 0.928 * s2, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1];
         break;
       }
       case "hueRotate": {
-        var a = matrix[0] * Math.PI / 180;
-        matrix = [c(a, 0.213, 0.787, -0.213), c(a, 0.715, -0.715, -0.715), c(a, 0.072, -0.072, 0.928), 0, 0, c(a, 0.213, -0.213, 0.143), c(a, 0.715, 0.285, 0.14), c(a, 0.072, -0.072, -0.283), 0, 0, c(a, 0.213, -0.213, -0.787), c(a, 0.715, -0.715, 0.715), c(a, 0.072, 0.928, 0.072), 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1];
+        var a2 = matrix[0] * Math.PI / 180;
+        matrix = [c(a2, 0.213, 0.787, -0.213), c(a2, 0.715, -0.715, -0.715), c(a2, 0.072, -0.072, 0.928), 0, 0, c(a2, 0.213, -0.213, 0.143), c(a2, 0.715, 0.285, 0.14), c(a2, 0.072, -0.072, -0.283), 0, 0, c(a2, 0.213, -0.213, -0.787), c(a2, 0.715, -0.715, 0.715), c(a2, 0.072, 0.928, 0.072), 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1];
         break;
       }
       case "luminanceToAlpha":
@@ -4618,26 +6446,26 @@ class FeColorMatrixElement extends Element {
       matrix
     } = this;
     var srcData = ctx.getImageData(0, 0, width, height);
-    for (var y = 0; y < height; y++) {
+    for (var y2 = 0; y2 < height; y2++) {
       for (var x = 0; x < width; x++) {
-        var r = imGet(srcData.data, x, y, width, height, 0);
-        var g = imGet(srcData.data, x, y, width, height, 1);
-        var b = imGet(srcData.data, x, y, width, height, 2);
-        var a = imGet(srcData.data, x, y, width, height, 3);
-        var nr = m(matrix, 0, r) + m(matrix, 1, g) + m(matrix, 2, b) + m(matrix, 3, a) + m(matrix, 4, 1);
-        var ng = m(matrix, 5, r) + m(matrix, 6, g) + m(matrix, 7, b) + m(matrix, 8, a) + m(matrix, 9, 1);
-        var nb = m(matrix, 10, r) + m(matrix, 11, g) + m(matrix, 12, b) + m(matrix, 13, a) + m(matrix, 14, 1);
-        var na = m(matrix, 15, r) + m(matrix, 16, g) + m(matrix, 17, b) + m(matrix, 18, a) + m(matrix, 19, 1);
+        var r2 = imGet(srcData.data, x, y2, width, height, 0);
+        var g = imGet(srcData.data, x, y2, width, height, 1);
+        var b = imGet(srcData.data, x, y2, width, height, 2);
+        var a2 = imGet(srcData.data, x, y2, width, height, 3);
+        var nr = m(matrix, 0, r2) + m(matrix, 1, g) + m(matrix, 2, b) + m(matrix, 3, a2) + m(matrix, 4, 1);
+        var ng = m(matrix, 5, r2) + m(matrix, 6, g) + m(matrix, 7, b) + m(matrix, 8, a2) + m(matrix, 9, 1);
+        var nb = m(matrix, 10, r2) + m(matrix, 11, g) + m(matrix, 12, b) + m(matrix, 13, a2) + m(matrix, 14, 1);
+        var na = m(matrix, 15, r2) + m(matrix, 16, g) + m(matrix, 17, b) + m(matrix, 18, a2) + m(matrix, 19, 1);
         if (includeOpacity) {
           nr = 0;
           ng = 0;
           nb = 0;
-          na *= a / 255;
+          na *= a2 / 255;
         }
-        imSet(srcData.data, x, y, width, height, 0, nr);
-        imSet(srcData.data, x, y, width, height, 1, ng);
-        imSet(srcData.data, x, y, width, height, 2, nb);
-        imSet(srcData.data, x, y, width, height, 3, na);
+        imSet(srcData.data, x, y2, width, height, 0, nr);
+        imSet(srcData.data, x, y2, width, height, 1, ng);
+        imSet(srcData.data, x, y2, width, height, 2, nb);
+        imSet(srcData.data, x, y2, width, height, 3, na);
       }
     }
     ctx.clearRect(0, 0, width, height);
@@ -4654,7 +6482,7 @@ class MaskElement extends Element {
       document: document2
     } = this;
     var x = this.getAttribute("x").getPixels("x");
-    var y = this.getAttribute("y").getPixels("y");
+    var y2 = this.getAttribute("y").getPixels("y");
     var width = this.getStyle("width").getPixels("x");
     var height = this.getStyle("height").getPixels("y");
     if (!width && !height) {
@@ -4663,12 +6491,12 @@ class MaskElement extends Element {
         boundingBox.addBoundingBox(child.getBoundingBox(ctx));
       });
       x = Math.floor(boundingBox.x1);
-      y = Math.floor(boundingBox.y1);
+      y2 = Math.floor(boundingBox.y1);
       width = Math.floor(boundingBox.width);
       height = Math.floor(boundingBox.height);
     }
     var ignoredStyles = this.removeStyles(element, MaskElement.ignoreStyles);
-    var maskCanvas = document2.createCanvas(x + width, y + height);
+    var maskCanvas = document2.createCanvas(x + width, y2 + height);
     var maskCtx = maskCanvas.getContext("2d");
     document2.screen.setDefaults(maskCtx);
     this.renderChildren(maskCtx);
@@ -4682,16 +6510,16 @@ class MaskElement extends Element {
         nodeName: "includeOpacity",
         value: "true"
       }]
-    }).apply(maskCtx, 0, 0, x + width, y + height);
-    var tmpCanvas = document2.createCanvas(x + width, y + height);
+    }).apply(maskCtx, 0, 0, x + width, y2 + height);
+    var tmpCanvas = document2.createCanvas(x + width, y2 + height);
     var tmpCtx = tmpCanvas.getContext("2d");
     document2.screen.setDefaults(tmpCtx);
     element.render(tmpCtx);
     tmpCtx.globalCompositeOperation = "destination-in";
     tmpCtx.fillStyle = maskCtx.createPattern(maskCanvas, "no-repeat");
-    tmpCtx.fillRect(0, 0, x + width, y + height);
+    tmpCtx.fillRect(0, 0, x + width, y2 + height);
     ctx.fillStyle = tmpCtx.createPattern(tmpCanvas, "no-repeat");
-    ctx.fillRect(0, 0, x + width, y + height);
+    ctx.fillRect(0, 0, x + width, y2 + height);
     this.restoreStyles(element, ignoredStyles);
   }
   render(_2) {
@@ -4777,19 +6605,19 @@ class FilterElement extends Element {
       return;
     }
     var x = Math.floor(boundingBox.x);
-    var y = Math.floor(boundingBox.y);
+    var y2 = Math.floor(boundingBox.y);
     var ignoredStyles = this.removeStyles(element, FilterElement.ignoreStyles);
     var tmpCanvas = document2.createCanvas(tmpCanvasWidth, tmpCanvasHeight);
     var tmpCtx = tmpCanvas.getContext("2d");
     document2.screen.setDefaults(tmpCtx);
-    tmpCtx.translate(-x + px, -y + py);
+    tmpCtx.translate(-x + px, -y2 + py);
     element.render(tmpCtx);
     children.forEach((child) => {
       if (typeof child.apply === "function") {
         child.apply(tmpCtx, 0, 0, tmpCanvasWidth, tmpCanvasHeight);
       }
     });
-    ctx.drawImage(tmpCanvas, 0, 0, tmpCanvasWidth, tmpCanvasHeight, x - px, y - py, tmpCanvasWidth, tmpCanvasHeight);
+    ctx.drawImage(tmpCanvas, 0, 0, tmpCanvasWidth, tmpCanvasHeight, x - px, y2 - py, tmpCanvasWidth, tmpCanvasHeight);
     this.restoreStyles(element, ignoredStyles);
   }
   render(_2) {
@@ -4828,7 +6656,7 @@ class FeGaussianBlurElement extends Element {
     this.blurRadius = Math.floor(this.getAttribute("stdDeviation").getNumber());
     this.extraFilterDistance = this.blurRadius;
   }
-  apply(ctx, x, y, width, height) {
+  apply(ctx, x, y2, width, height) {
     var {
       document: document2,
       blurRadius
@@ -4840,7 +6668,7 @@ class FeGaussianBlurElement extends Element {
       canvas.style.display = "none";
       body.appendChild(canvas);
     }
-    processCanvasRGBA(canvas, x, y, width, height, blurRadius);
+    processCanvasRGBA(canvas, x, y2, width, height, blurRadius);
     if (body) {
       body.removeChild(canvas);
     }
@@ -4915,9 +6743,9 @@ function ownKeys$1(object, enumerableOnly) {
   return keys;
 }
 function _objectSpread$1(target) {
-  for (var i = 1; i < arguments.length; i++) {
-    var source = arguments[i] != null ? arguments[i] : {};
-    if (i % 2) {
+  for (var i2 = 1; i2 < arguments.length; i2++) {
+    var source = arguments[i2] != null ? arguments[i2] : {};
+    if (i2 % 2) {
       ownKeys$1(Object(source), true).forEach(function(key) {
         _defineProperty(target, key, source[key]);
       });
@@ -5067,9 +6895,9 @@ function ownKeys(object, enumerableOnly) {
   return keys;
 }
 function _objectSpread(target) {
-  for (var i = 1; i < arguments.length; i++) {
-    var source = arguments[i] != null ? arguments[i] : {};
-    if (i % 2) {
+  for (var i2 = 1; i2 < arguments.length; i2++) {
+    var source = arguments[i2] != null ? arguments[i2] : {};
+    if (i2 % 2) {
       ownKeys(Object(source), true).forEach(function(key) {
         _defineProperty(target, key, source[key]);
       });