Index: imaps-frontend/node_modules/.vite/deps/index.es-7XNKQPVZ.js
===================================================================
--- imaps-frontend/node_modules/.vite/deps/index.es-7XNKQPVZ.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/.vite/deps/index.es-7XNKQPVZ.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,10363 @@
+import {
+  _typeof
+} from "./chunk-D7ZASVPN.js";
+import {
+  __commonJS,
+  __toESM
+} from "./chunk-V4OQ3NZ2.js";
+
+// node_modules/core-js/internals/global-this.js
+var require_global_this = __commonJS({
+  "node_modules/core-js/internals/global-this.js"(exports, module) {
+    "use strict";
+    var check = function(it) {
+      return it && it.Math === Math && it;
+    };
+    module.exports = // eslint-disable-next-line es/no-global-this -- safe
+    check(typeof globalThis == "object" && globalThis) || check(typeof window == "object" && window) || // eslint-disable-next-line no-restricted-globals -- safe
+    check(typeof self == "object" && self) || check(typeof global == "object" && global) || check(typeof exports == "object" && exports) || // eslint-disable-next-line no-new-func -- fallback
+    /* @__PURE__ */ function() {
+      return this;
+    }() || Function("return this")();
+  }
+});
+
+// node_modules/core-js/internals/fails.js
+var require_fails = __commonJS({
+  "node_modules/core-js/internals/fails.js"(exports, module) {
+    "use strict";
+    module.exports = function(exec) {
+      try {
+        return !!exec();
+      } catch (error) {
+        return true;
+      }
+    };
+  }
+});
+
+// node_modules/core-js/internals/descriptors.js
+var require_descriptors = __commonJS({
+  "node_modules/core-js/internals/descriptors.js"(exports, module) {
+    "use strict";
+    var fails4 = require_fails();
+    module.exports = !fails4(function() {
+      return Object.defineProperty({}, 1, { get: function() {
+        return 7;
+      } })[1] !== 7;
+    });
+  }
+});
+
+// node_modules/core-js/internals/function-bind-native.js
+var require_function_bind_native = __commonJS({
+  "node_modules/core-js/internals/function-bind-native.js"(exports, module) {
+    "use strict";
+    var fails4 = require_fails();
+    module.exports = !fails4(function() {
+      var test2 = (function() {
+      }).bind();
+      return typeof test2 != "function" || test2.hasOwnProperty("prototype");
+    });
+  }
+});
+
+// node_modules/core-js/internals/function-call.js
+var require_function_call = __commonJS({
+  "node_modules/core-js/internals/function-call.js"(exports, module) {
+    "use strict";
+    var NATIVE_BIND = require_function_bind_native();
+    var call4 = Function.prototype.call;
+    module.exports = NATIVE_BIND ? call4.bind(call4) : function() {
+      return call4.apply(call4, arguments);
+    };
+  }
+});
+
+// node_modules/core-js/internals/object-property-is-enumerable.js
+var require_object_property_is_enumerable = __commonJS({
+  "node_modules/core-js/internals/object-property-is-enumerable.js"(exports) {
+    "use strict";
+    var $propertyIsEnumerable = {}.propertyIsEnumerable;
+    var getOwnPropertyDescriptor3 = Object.getOwnPropertyDescriptor;
+    var NASHORN_BUG = getOwnPropertyDescriptor3 && !$propertyIsEnumerable.call({ 1: 2 }, 1);
+    exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
+      var descriptor = getOwnPropertyDescriptor3(this, V);
+      return !!descriptor && descriptor.enumerable;
+    } : $propertyIsEnumerable;
+  }
+});
+
+// node_modules/core-js/internals/create-property-descriptor.js
+var require_create_property_descriptor = __commonJS({
+  "node_modules/core-js/internals/create-property-descriptor.js"(exports, module) {
+    "use strict";
+    module.exports = function(bitmap, value) {
+      return {
+        enumerable: !(bitmap & 1),
+        configurable: !(bitmap & 2),
+        writable: !(bitmap & 4),
+        value
+      };
+    };
+  }
+});
+
+// node_modules/core-js/internals/function-uncurry-this.js
+var require_function_uncurry_this = __commonJS({
+  "node_modules/core-js/internals/function-uncurry-this.js"(exports, module) {
+    "use strict";
+    var NATIVE_BIND = require_function_bind_native();
+    var FunctionPrototype = Function.prototype;
+    var call4 = FunctionPrototype.call;
+    var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call4, call4);
+    module.exports = NATIVE_BIND ? uncurryThisWithBind : function(fn) {
+      return function() {
+        return call4.apply(fn, arguments);
+      };
+    };
+  }
+});
+
+// node_modules/core-js/internals/classof-raw.js
+var require_classof_raw = __commonJS({
+  "node_modules/core-js/internals/classof-raw.js"(exports, module) {
+    "use strict";
+    var uncurryThis8 = require_function_uncurry_this();
+    var toString7 = uncurryThis8({}.toString);
+    var stringSlice4 = uncurryThis8("".slice);
+    module.exports = function(it) {
+      return stringSlice4(toString7(it), 8, -1);
+    };
+  }
+});
+
+// node_modules/core-js/internals/indexed-object.js
+var require_indexed_object = __commonJS({
+  "node_modules/core-js/internals/indexed-object.js"(exports, module) {
+    "use strict";
+    var uncurryThis8 = require_function_uncurry_this();
+    var fails4 = require_fails();
+    var classof = require_classof_raw();
+    var $Object = Object;
+    var split = uncurryThis8("".split);
+    module.exports = fails4(function() {
+      return !$Object("z").propertyIsEnumerable(0);
+    }) ? function(it) {
+      return classof(it) === "String" ? split(it, "") : $Object(it);
+    } : $Object;
+  }
+});
+
+// node_modules/core-js/internals/is-null-or-undefined.js
+var require_is_null_or_undefined = __commonJS({
+  "node_modules/core-js/internals/is-null-or-undefined.js"(exports, module) {
+    "use strict";
+    module.exports = function(it) {
+      return it === null || it === void 0;
+    };
+  }
+});
+
+// node_modules/core-js/internals/require-object-coercible.js
+var require_require_object_coercible = __commonJS({
+  "node_modules/core-js/internals/require-object-coercible.js"(exports, module) {
+    "use strict";
+    var isNullOrUndefined4 = require_is_null_or_undefined();
+    var $TypeError = TypeError;
+    module.exports = function(it) {
+      if (isNullOrUndefined4(it)) throw new $TypeError("Can't call method on " + it);
+      return it;
+    };
+  }
+});
+
+// node_modules/core-js/internals/to-indexed-object.js
+var require_to_indexed_object = __commonJS({
+  "node_modules/core-js/internals/to-indexed-object.js"(exports, module) {
+    "use strict";
+    var IndexedObject = require_indexed_object();
+    var requireObjectCoercible7 = require_require_object_coercible();
+    module.exports = function(it) {
+      return IndexedObject(requireObjectCoercible7(it));
+    };
+  }
+});
+
+// node_modules/core-js/internals/is-callable.js
+var require_is_callable = __commonJS({
+  "node_modules/core-js/internals/is-callable.js"(exports, module) {
+    "use strict";
+    var documentAll = typeof document == "object" && document.all;
+    module.exports = typeof documentAll == "undefined" && documentAll !== void 0 ? function(argument) {
+      return typeof argument == "function" || argument === documentAll;
+    } : function(argument) {
+      return typeof argument == "function";
+    };
+  }
+});
+
+// node_modules/core-js/internals/is-object.js
+var require_is_object = __commonJS({
+  "node_modules/core-js/internals/is-object.js"(exports, module) {
+    "use strict";
+    var isCallable2 = require_is_callable();
+    module.exports = function(it) {
+      return typeof it == "object" ? it !== null : isCallable2(it);
+    };
+  }
+});
+
+// node_modules/core-js/internals/get-built-in.js
+var require_get_built_in = __commonJS({
+  "node_modules/core-js/internals/get-built-in.js"(exports, module) {
+    "use strict";
+    var globalThis3 = require_global_this();
+    var isCallable2 = require_is_callable();
+    var aFunction = function(argument) {
+      return isCallable2(argument) ? argument : void 0;
+    };
+    module.exports = function(namespace, method) {
+      return arguments.length < 2 ? aFunction(globalThis3[namespace]) : globalThis3[namespace] && globalThis3[namespace][method];
+    };
+  }
+});
+
+// node_modules/core-js/internals/object-is-prototype-of.js
+var require_object_is_prototype_of = __commonJS({
+  "node_modules/core-js/internals/object-is-prototype-of.js"(exports, module) {
+    "use strict";
+    var uncurryThis8 = require_function_uncurry_this();
+    module.exports = uncurryThis8({}.isPrototypeOf);
+  }
+});
+
+// node_modules/core-js/internals/environment-user-agent.js
+var require_environment_user_agent = __commonJS({
+  "node_modules/core-js/internals/environment-user-agent.js"(exports, module) {
+    "use strict";
+    var globalThis3 = require_global_this();
+    var navigator = globalThis3.navigator;
+    var userAgent = navigator && navigator.userAgent;
+    module.exports = userAgent ? String(userAgent) : "";
+  }
+});
+
+// node_modules/core-js/internals/environment-v8-version.js
+var require_environment_v8_version = __commonJS({
+  "node_modules/core-js/internals/environment-v8-version.js"(exports, module) {
+    "use strict";
+    var globalThis3 = require_global_this();
+    var userAgent = require_environment_user_agent();
+    var process2 = globalThis3.process;
+    var Deno2 = globalThis3.Deno;
+    var versions = process2 && process2.versions || Deno2 && Deno2.version;
+    var v8 = versions && versions.v8;
+    var match;
+    var version;
+    if (v8) {
+      match = v8.split(".");
+      version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
+    }
+    if (!version && userAgent) {
+      match = userAgent.match(/Edge\/(\d+)/);
+      if (!match || match[1] >= 74) {
+        match = userAgent.match(/Chrome\/(\d+)/);
+        if (match) version = +match[1];
+      }
+    }
+    module.exports = version;
+  }
+});
+
+// node_modules/core-js/internals/symbol-constructor-detection.js
+var require_symbol_constructor_detection = __commonJS({
+  "node_modules/core-js/internals/symbol-constructor-detection.js"(exports, module) {
+    "use strict";
+    var V8_VERSION = require_environment_v8_version();
+    var fails4 = require_fails();
+    var globalThis3 = require_global_this();
+    var $String = globalThis3.String;
+    module.exports = !!Object.getOwnPropertySymbols && !fails4(function() {
+      var symbol = Symbol("symbol detection");
+      return !$String(symbol) || !(Object(symbol) instanceof Symbol) || // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
+      !Symbol.sham && V8_VERSION && V8_VERSION < 41;
+    });
+  }
+});
+
+// node_modules/core-js/internals/use-symbol-as-uid.js
+var require_use_symbol_as_uid = __commonJS({
+  "node_modules/core-js/internals/use-symbol-as-uid.js"(exports, module) {
+    "use strict";
+    var NATIVE_SYMBOL = require_symbol_constructor_detection();
+    module.exports = NATIVE_SYMBOL && !Symbol.sham && typeof Symbol.iterator == "symbol";
+  }
+});
+
+// node_modules/core-js/internals/is-symbol.js
+var require_is_symbol = __commonJS({
+  "node_modules/core-js/internals/is-symbol.js"(exports, module) {
+    "use strict";
+    var getBuiltIn = require_get_built_in();
+    var isCallable2 = require_is_callable();
+    var isPrototypeOf = require_object_is_prototype_of();
+    var USE_SYMBOL_AS_UID = require_use_symbol_as_uid();
+    var $Object = Object;
+    module.exports = USE_SYMBOL_AS_UID ? function(it) {
+      return typeof it == "symbol";
+    } : function(it) {
+      var $Symbol = getBuiltIn("Symbol");
+      return isCallable2($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));
+    };
+  }
+});
+
+// node_modules/core-js/internals/try-to-string.js
+var require_try_to_string = __commonJS({
+  "node_modules/core-js/internals/try-to-string.js"(exports, module) {
+    "use strict";
+    var $String = String;
+    module.exports = function(argument) {
+      try {
+        return $String(argument);
+      } catch (error) {
+        return "Object";
+      }
+    };
+  }
+});
+
+// node_modules/core-js/internals/a-callable.js
+var require_a_callable = __commonJS({
+  "node_modules/core-js/internals/a-callable.js"(exports, module) {
+    "use strict";
+    var isCallable2 = require_is_callable();
+    var tryToString = require_try_to_string();
+    var $TypeError = TypeError;
+    module.exports = function(argument) {
+      if (isCallable2(argument)) return argument;
+      throw new $TypeError(tryToString(argument) + " is not a function");
+    };
+  }
+});
+
+// node_modules/core-js/internals/get-method.js
+var require_get_method = __commonJS({
+  "node_modules/core-js/internals/get-method.js"(exports, module) {
+    "use strict";
+    var aCallable = require_a_callable();
+    var isNullOrUndefined4 = require_is_null_or_undefined();
+    module.exports = function(V, P) {
+      var func = V[P];
+      return isNullOrUndefined4(func) ? void 0 : aCallable(func);
+    };
+  }
+});
+
+// node_modules/core-js/internals/ordinary-to-primitive.js
+var require_ordinary_to_primitive = __commonJS({
+  "node_modules/core-js/internals/ordinary-to-primitive.js"(exports, module) {
+    "use strict";
+    var call4 = require_function_call();
+    var isCallable2 = require_is_callable();
+    var isObject = require_is_object();
+    var $TypeError = TypeError;
+    module.exports = function(input, pref) {
+      var fn, val;
+      if (pref === "string" && isCallable2(fn = input.toString) && !isObject(val = call4(fn, input))) return val;
+      if (isCallable2(fn = input.valueOf) && !isObject(val = call4(fn, input))) return val;
+      if (pref !== "string" && isCallable2(fn = input.toString) && !isObject(val = call4(fn, input))) return val;
+      throw new $TypeError("Can't convert object to primitive value");
+    };
+  }
+});
+
+// node_modules/core-js/internals/is-pure.js
+var require_is_pure = __commonJS({
+  "node_modules/core-js/internals/is-pure.js"(exports, module) {
+    "use strict";
+    module.exports = false;
+  }
+});
+
+// node_modules/core-js/internals/define-global-property.js
+var require_define_global_property = __commonJS({
+  "node_modules/core-js/internals/define-global-property.js"(exports, module) {
+    "use strict";
+    var globalThis3 = require_global_this();
+    var defineProperty = Object.defineProperty;
+    module.exports = function(key, value) {
+      try {
+        defineProperty(globalThis3, key, { value, configurable: true, writable: true });
+      } catch (error) {
+        globalThis3[key] = value;
+      }
+      return value;
+    };
+  }
+});
+
+// node_modules/core-js/internals/shared-store.js
+var require_shared_store = __commonJS({
+  "node_modules/core-js/internals/shared-store.js"(exports, module) {
+    "use strict";
+    var IS_PURE3 = require_is_pure();
+    var globalThis3 = require_global_this();
+    var defineGlobalProperty = require_define_global_property();
+    var SHARED = "__core-js_shared__";
+    var store = module.exports = globalThis3[SHARED] || defineGlobalProperty(SHARED, {});
+    (store.versions || (store.versions = [])).push({
+      version: "3.39.0",
+      mode: IS_PURE3 ? "pure" : "global",
+      copyright: "© 2014-2024 Denis Pushkarev (zloirock.ru)",
+      license: "https://github.com/zloirock/core-js/blob/v3.39.0/LICENSE",
+      source: "https://github.com/zloirock/core-js"
+    });
+  }
+});
+
+// node_modules/core-js/internals/shared.js
+var require_shared = __commonJS({
+  "node_modules/core-js/internals/shared.js"(exports, module) {
+    "use strict";
+    var store = require_shared_store();
+    module.exports = function(key, value) {
+      return store[key] || (store[key] = value || {});
+    };
+  }
+});
+
+// node_modules/core-js/internals/to-object.js
+var require_to_object = __commonJS({
+  "node_modules/core-js/internals/to-object.js"(exports, module) {
+    "use strict";
+    var requireObjectCoercible7 = require_require_object_coercible();
+    var $Object = Object;
+    module.exports = function(argument) {
+      return $Object(requireObjectCoercible7(argument));
+    };
+  }
+});
+
+// node_modules/core-js/internals/has-own-property.js
+var require_has_own_property = __commonJS({
+  "node_modules/core-js/internals/has-own-property.js"(exports, module) {
+    "use strict";
+    var uncurryThis8 = require_function_uncurry_this();
+    var toObject = require_to_object();
+    var hasOwnProperty = uncurryThis8({}.hasOwnProperty);
+    module.exports = Object.hasOwn || function hasOwn(it, key) {
+      return hasOwnProperty(toObject(it), key);
+    };
+  }
+});
+
+// node_modules/core-js/internals/uid.js
+var require_uid = __commonJS({
+  "node_modules/core-js/internals/uid.js"(exports, module) {
+    "use strict";
+    var uncurryThis8 = require_function_uncurry_this();
+    var id = 0;
+    var postfix = Math.random();
+    var toString7 = uncurryThis8(1 .toString);
+    module.exports = function(key) {
+      return "Symbol(" + (key === void 0 ? "" : key) + ")_" + toString7(++id + postfix, 36);
+    };
+  }
+});
+
+// node_modules/core-js/internals/well-known-symbol.js
+var require_well_known_symbol = __commonJS({
+  "node_modules/core-js/internals/well-known-symbol.js"(exports, module) {
+    "use strict";
+    var globalThis3 = require_global_this();
+    var shared = require_shared();
+    var hasOwn = require_has_own_property();
+    var uid = require_uid();
+    var NATIVE_SYMBOL = require_symbol_constructor_detection();
+    var USE_SYMBOL_AS_UID = require_use_symbol_as_uid();
+    var Symbol2 = globalThis3.Symbol;
+    var WellKnownSymbolsStore = shared("wks");
+    var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol2["for"] || Symbol2 : Symbol2 && Symbol2.withoutSetter || uid;
+    module.exports = function(name) {
+      if (!hasOwn(WellKnownSymbolsStore, name)) {
+        WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol2, name) ? Symbol2[name] : createWellKnownSymbol("Symbol." + name);
+      }
+      return WellKnownSymbolsStore[name];
+    };
+  }
+});
+
+// node_modules/core-js/internals/to-primitive.js
+var require_to_primitive = __commonJS({
+  "node_modules/core-js/internals/to-primitive.js"(exports, module) {
+    "use strict";
+    var call4 = require_function_call();
+    var isObject = require_is_object();
+    var isSymbol = require_is_symbol();
+    var getMethod4 = require_get_method();
+    var ordinaryToPrimitive = require_ordinary_to_primitive();
+    var wellKnownSymbol3 = require_well_known_symbol();
+    var $TypeError = TypeError;
+    var TO_PRIMITIVE = wellKnownSymbol3("toPrimitive");
+    module.exports = function(input, pref) {
+      if (!isObject(input) || isSymbol(input)) return input;
+      var exoticToPrim = getMethod4(input, TO_PRIMITIVE);
+      var result;
+      if (exoticToPrim) {
+        if (pref === void 0) pref = "default";
+        result = call4(exoticToPrim, input, pref);
+        if (!isObject(result) || isSymbol(result)) return result;
+        throw new $TypeError("Can't convert object to primitive value");
+      }
+      if (pref === void 0) pref = "number";
+      return ordinaryToPrimitive(input, pref);
+    };
+  }
+});
+
+// node_modules/core-js/internals/to-property-key.js
+var require_to_property_key = __commonJS({
+  "node_modules/core-js/internals/to-property-key.js"(exports, module) {
+    "use strict";
+    var toPrimitive2 = require_to_primitive();
+    var isSymbol = require_is_symbol();
+    module.exports = function(argument) {
+      var key = toPrimitive2(argument, "string");
+      return isSymbol(key) ? key : key + "";
+    };
+  }
+});
+
+// node_modules/core-js/internals/document-create-element.js
+var require_document_create_element = __commonJS({
+  "node_modules/core-js/internals/document-create-element.js"(exports, module) {
+    "use strict";
+    var globalThis3 = require_global_this();
+    var isObject = require_is_object();
+    var document2 = globalThis3.document;
+    var EXISTS = isObject(document2) && isObject(document2.createElement);
+    module.exports = function(it) {
+      return EXISTS ? document2.createElement(it) : {};
+    };
+  }
+});
+
+// node_modules/core-js/internals/ie8-dom-define.js
+var require_ie8_dom_define = __commonJS({
+  "node_modules/core-js/internals/ie8-dom-define.js"(exports, module) {
+    "use strict";
+    var DESCRIPTORS = require_descriptors();
+    var fails4 = require_fails();
+    var createElement = require_document_create_element();
+    module.exports = !DESCRIPTORS && !fails4(function() {
+      return Object.defineProperty(createElement("div"), "a", {
+        get: function() {
+          return 7;
+        }
+      }).a !== 7;
+    });
+  }
+});
+
+// node_modules/core-js/internals/object-get-own-property-descriptor.js
+var require_object_get_own_property_descriptor = __commonJS({
+  "node_modules/core-js/internals/object-get-own-property-descriptor.js"(exports) {
+    "use strict";
+    var DESCRIPTORS = require_descriptors();
+    var call4 = require_function_call();
+    var propertyIsEnumerableModule = require_object_property_is_enumerable();
+    var createPropertyDescriptor = require_create_property_descriptor();
+    var toIndexedObject = require_to_indexed_object();
+    var toPropertyKey2 = require_to_property_key();
+    var hasOwn = require_has_own_property();
+    var IE8_DOM_DEFINE = require_ie8_dom_define();
+    var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+    exports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor3(O2, P) {
+      O2 = toIndexedObject(O2);
+      P = toPropertyKey2(P);
+      if (IE8_DOM_DEFINE) try {
+        return $getOwnPropertyDescriptor(O2, P);
+      } catch (error) {
+      }
+      if (hasOwn(O2, P)) return createPropertyDescriptor(!call4(propertyIsEnumerableModule.f, O2, P), O2[P]);
+    };
+  }
+});
+
+// node_modules/core-js/internals/v8-prototype-define-bug.js
+var require_v8_prototype_define_bug = __commonJS({
+  "node_modules/core-js/internals/v8-prototype-define-bug.js"(exports, module) {
+    "use strict";
+    var DESCRIPTORS = require_descriptors();
+    var fails4 = require_fails();
+    module.exports = DESCRIPTORS && fails4(function() {
+      return Object.defineProperty(function() {
+      }, "prototype", {
+        value: 42,
+        writable: false
+      }).prototype !== 42;
+    });
+  }
+});
+
+// node_modules/core-js/internals/an-object.js
+var require_an_object = __commonJS({
+  "node_modules/core-js/internals/an-object.js"(exports, module) {
+    "use strict";
+    var isObject = require_is_object();
+    var $String = String;
+    var $TypeError = TypeError;
+    module.exports = function(argument) {
+      if (isObject(argument)) return argument;
+      throw new $TypeError($String(argument) + " is not an object");
+    };
+  }
+});
+
+// node_modules/core-js/internals/object-define-property.js
+var require_object_define_property = __commonJS({
+  "node_modules/core-js/internals/object-define-property.js"(exports) {
+    "use strict";
+    var DESCRIPTORS = require_descriptors();
+    var IE8_DOM_DEFINE = require_ie8_dom_define();
+    var V8_PROTOTYPE_DEFINE_BUG = require_v8_prototype_define_bug();
+    var anObject5 = require_an_object();
+    var toPropertyKey2 = require_to_property_key();
+    var $TypeError = TypeError;
+    var $defineProperty = Object.defineProperty;
+    var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+    var ENUMERABLE = "enumerable";
+    var CONFIGURABLE = "configurable";
+    var WRITABLE = "writable";
+    exports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O2, P, Attributes) {
+      anObject5(O2);
+      P = toPropertyKey2(P);
+      anObject5(Attributes);
+      if (typeof O2 === "function" && P === "prototype" && "value" in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
+        var current = $getOwnPropertyDescriptor(O2, P);
+        if (current && current[WRITABLE]) {
+          O2[P] = Attributes.value;
+          Attributes = {
+            configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],
+            enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
+            writable: false
+          };
+        }
+      }
+      return $defineProperty(O2, P, Attributes);
+    } : $defineProperty : function defineProperty(O2, P, Attributes) {
+      anObject5(O2);
+      P = toPropertyKey2(P);
+      anObject5(Attributes);
+      if (IE8_DOM_DEFINE) try {
+        return $defineProperty(O2, P, Attributes);
+      } catch (error) {
+      }
+      if ("get" in Attributes || "set" in Attributes) throw new $TypeError("Accessors not supported");
+      if ("value" in Attributes) O2[P] = Attributes.value;
+      return O2;
+    };
+  }
+});
+
+// node_modules/core-js/internals/create-non-enumerable-property.js
+var require_create_non_enumerable_property = __commonJS({
+  "node_modules/core-js/internals/create-non-enumerable-property.js"(exports, module) {
+    "use strict";
+    var DESCRIPTORS = require_descriptors();
+    var definePropertyModule = require_object_define_property();
+    var createPropertyDescriptor = require_create_property_descriptor();
+    module.exports = DESCRIPTORS ? function(object, key, value) {
+      return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
+    } : function(object, key, value) {
+      object[key] = value;
+      return object;
+    };
+  }
+});
+
+// node_modules/core-js/internals/function-name.js
+var require_function_name = __commonJS({
+  "node_modules/core-js/internals/function-name.js"(exports, module) {
+    "use strict";
+    var DESCRIPTORS = require_descriptors();
+    var hasOwn = require_has_own_property();
+    var FunctionPrototype = Function.prototype;
+    var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;
+    var EXISTS = hasOwn(FunctionPrototype, "name");
+    var PROPER = EXISTS && (function something() {
+    }).name === "something";
+    var CONFIGURABLE = EXISTS && (!DESCRIPTORS || DESCRIPTORS && getDescriptor(FunctionPrototype, "name").configurable);
+    module.exports = {
+      EXISTS,
+      PROPER,
+      CONFIGURABLE
+    };
+  }
+});
+
+// node_modules/core-js/internals/inspect-source.js
+var require_inspect_source = __commonJS({
+  "node_modules/core-js/internals/inspect-source.js"(exports, module) {
+    "use strict";
+    var uncurryThis8 = require_function_uncurry_this();
+    var isCallable2 = require_is_callable();
+    var store = require_shared_store();
+    var functionToString = uncurryThis8(Function.toString);
+    if (!isCallable2(store.inspectSource)) {
+      store.inspectSource = function(it) {
+        return functionToString(it);
+      };
+    }
+    module.exports = store.inspectSource;
+  }
+});
+
+// node_modules/core-js/internals/weak-map-basic-detection.js
+var require_weak_map_basic_detection = __commonJS({
+  "node_modules/core-js/internals/weak-map-basic-detection.js"(exports, module) {
+    "use strict";
+    var globalThis3 = require_global_this();
+    var isCallable2 = require_is_callable();
+    var WeakMap = globalThis3.WeakMap;
+    module.exports = isCallable2(WeakMap) && /native code/.test(String(WeakMap));
+  }
+});
+
+// node_modules/core-js/internals/shared-key.js
+var require_shared_key = __commonJS({
+  "node_modules/core-js/internals/shared-key.js"(exports, module) {
+    "use strict";
+    var shared = require_shared();
+    var uid = require_uid();
+    var keys = shared("keys");
+    module.exports = function(key) {
+      return keys[key] || (keys[key] = uid(key));
+    };
+  }
+});
+
+// node_modules/core-js/internals/hidden-keys.js
+var require_hidden_keys = __commonJS({
+  "node_modules/core-js/internals/hidden-keys.js"(exports, module) {
+    "use strict";
+    module.exports = {};
+  }
+});
+
+// node_modules/core-js/internals/internal-state.js
+var require_internal_state = __commonJS({
+  "node_modules/core-js/internals/internal-state.js"(exports, module) {
+    "use strict";
+    var NATIVE_WEAK_MAP = require_weak_map_basic_detection();
+    var globalThis3 = require_global_this();
+    var isObject = require_is_object();
+    var createNonEnumerableProperty2 = require_create_non_enumerable_property();
+    var hasOwn = require_has_own_property();
+    var shared = require_shared_store();
+    var sharedKey = require_shared_key();
+    var hiddenKeys = require_hidden_keys();
+    var OBJECT_ALREADY_INITIALIZED = "Object already initialized";
+    var TypeError2 = globalThis3.TypeError;
+    var WeakMap = globalThis3.WeakMap;
+    var set;
+    var get;
+    var has;
+    var enforce = function(it) {
+      return has(it) ? get(it) : set(it, {});
+    };
+    var getterFor = function(TYPE) {
+      return function(it) {
+        var state;
+        if (!isObject(it) || (state = get(it)).type !== TYPE) {
+          throw new TypeError2("Incompatible receiver, " + TYPE + " required");
+        }
+        return state;
+      };
+    };
+    if (NATIVE_WEAK_MAP || shared.state) {
+      store = shared.state || (shared.state = new WeakMap());
+      store.get = store.get;
+      store.has = store.has;
+      store.set = store.set;
+      set = function(it, metadata) {
+        if (store.has(it)) throw new TypeError2(OBJECT_ALREADY_INITIALIZED);
+        metadata.facade = it;
+        store.set(it, metadata);
+        return metadata;
+      };
+      get = function(it) {
+        return store.get(it) || {};
+      };
+      has = function(it) {
+        return store.has(it);
+      };
+    } else {
+      STATE = sharedKey("state");
+      hiddenKeys[STATE] = true;
+      set = function(it, metadata) {
+        if (hasOwn(it, STATE)) throw new TypeError2(OBJECT_ALREADY_INITIALIZED);
+        metadata.facade = it;
+        createNonEnumerableProperty2(it, STATE, metadata);
+        return metadata;
+      };
+      get = function(it) {
+        return hasOwn(it, STATE) ? it[STATE] : {};
+      };
+      has = function(it) {
+        return hasOwn(it, STATE);
+      };
+    }
+    var store;
+    var STATE;
+    module.exports = {
+      set,
+      get,
+      has,
+      enforce,
+      getterFor
+    };
+  }
+});
+
+// node_modules/core-js/internals/make-built-in.js
+var require_make_built_in = __commonJS({
+  "node_modules/core-js/internals/make-built-in.js"(exports, module) {
+    "use strict";
+    var uncurryThis8 = require_function_uncurry_this();
+    var fails4 = require_fails();
+    var isCallable2 = require_is_callable();
+    var hasOwn = require_has_own_property();
+    var DESCRIPTORS = require_descriptors();
+    var CONFIGURABLE_FUNCTION_NAME = require_function_name().CONFIGURABLE;
+    var inspectSource = require_inspect_source();
+    var InternalStateModule = require_internal_state();
+    var enforceInternalState = InternalStateModule.enforce;
+    var getInternalState = InternalStateModule.get;
+    var $String = String;
+    var defineProperty = Object.defineProperty;
+    var stringSlice4 = uncurryThis8("".slice);
+    var replace = uncurryThis8("".replace);
+    var join = uncurryThis8([].join);
+    var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails4(function() {
+      return defineProperty(function() {
+      }, "length", { value: 8 }).length !== 8;
+    });
+    var TEMPLATE = String(String).split("String");
+    var makeBuiltIn = module.exports = function(value, name, options) {
+      if (stringSlice4($String(name), 0, 7) === "Symbol(") {
+        name = "[" + replace($String(name), /^Symbol\(([^)]*)\).*$/, "$1") + "]";
+      }
+      if (options && options.getter) name = "get " + name;
+      if (options && options.setter) name = "set " + name;
+      if (!hasOwn(value, "name") || CONFIGURABLE_FUNCTION_NAME && value.name !== name) {
+        if (DESCRIPTORS) defineProperty(value, "name", { value: name, configurable: true });
+        else value.name = name;
+      }
+      if (CONFIGURABLE_LENGTH && options && hasOwn(options, "arity") && value.length !== options.arity) {
+        defineProperty(value, "length", { value: options.arity });
+      }
+      try {
+        if (options && hasOwn(options, "constructor") && options.constructor) {
+          if (DESCRIPTORS) defineProperty(value, "prototype", { writable: false });
+        } else if (value.prototype) value.prototype = void 0;
+      } catch (error) {
+      }
+      var state = enforceInternalState(value);
+      if (!hasOwn(state, "source")) {
+        state.source = join(TEMPLATE, typeof name == "string" ? name : "");
+      }
+      return value;
+    };
+    Function.prototype.toString = makeBuiltIn(function toString7() {
+      return isCallable2(this) && getInternalState(this).source || inspectSource(this);
+    }, "toString");
+  }
+});
+
+// node_modules/core-js/internals/define-built-in.js
+var require_define_built_in = __commonJS({
+  "node_modules/core-js/internals/define-built-in.js"(exports, module) {
+    "use strict";
+    var isCallable2 = require_is_callable();
+    var definePropertyModule = require_object_define_property();
+    var makeBuiltIn = require_make_built_in();
+    var defineGlobalProperty = require_define_global_property();
+    module.exports = function(O2, key, value, options) {
+      if (!options) options = {};
+      var simple = options.enumerable;
+      var name = options.name !== void 0 ? options.name : key;
+      if (isCallable2(value)) makeBuiltIn(value, name, options);
+      if (options.global) {
+        if (simple) O2[key] = value;
+        else defineGlobalProperty(key, value);
+      } else {
+        try {
+          if (!options.unsafe) delete O2[key];
+          else if (O2[key]) simple = true;
+        } catch (error) {
+        }
+        if (simple) O2[key] = value;
+        else definePropertyModule.f(O2, key, {
+          value,
+          enumerable: false,
+          configurable: !options.nonConfigurable,
+          writable: !options.nonWritable
+        });
+      }
+      return O2;
+    };
+  }
+});
+
+// node_modules/core-js/internals/math-trunc.js
+var require_math_trunc = __commonJS({
+  "node_modules/core-js/internals/math-trunc.js"(exports, module) {
+    "use strict";
+    var ceil = Math.ceil;
+    var floor = Math.floor;
+    module.exports = Math.trunc || function trunc(x) {
+      var n2 = +x;
+      return (n2 > 0 ? floor : ceil)(n2);
+    };
+  }
+});
+
+// node_modules/core-js/internals/to-integer-or-infinity.js
+var require_to_integer_or_infinity = __commonJS({
+  "node_modules/core-js/internals/to-integer-or-infinity.js"(exports, module) {
+    "use strict";
+    var trunc = require_math_trunc();
+    module.exports = function(argument) {
+      var number = +argument;
+      return number !== number || number === 0 ? 0 : trunc(number);
+    };
+  }
+});
+
+// node_modules/core-js/internals/to-absolute-index.js
+var require_to_absolute_index = __commonJS({
+  "node_modules/core-js/internals/to-absolute-index.js"(exports, module) {
+    "use strict";
+    var toIntegerOrInfinity2 = require_to_integer_or_infinity();
+    var max2 = Math.max;
+    var min5 = Math.min;
+    module.exports = function(index2, length) {
+      var integer = toIntegerOrInfinity2(index2);
+      return integer < 0 ? max2(integer + length, 0) : min5(integer, length);
+    };
+  }
+});
+
+// node_modules/core-js/internals/to-length.js
+var require_to_length = __commonJS({
+  "node_modules/core-js/internals/to-length.js"(exports, module) {
+    "use strict";
+    var toIntegerOrInfinity2 = require_to_integer_or_infinity();
+    var min5 = Math.min;
+    module.exports = function(argument) {
+      var len = toIntegerOrInfinity2(argument);
+      return len > 0 ? min5(len, 9007199254740991) : 0;
+    };
+  }
+});
+
+// node_modules/core-js/internals/length-of-array-like.js
+var require_length_of_array_like = __commonJS({
+  "node_modules/core-js/internals/length-of-array-like.js"(exports, module) {
+    "use strict";
+    var toLength6 = require_to_length();
+    module.exports = function(obj) {
+      return toLength6(obj.length);
+    };
+  }
+});
+
+// node_modules/core-js/internals/array-includes.js
+var require_array_includes = __commonJS({
+  "node_modules/core-js/internals/array-includes.js"(exports, module) {
+    "use strict";
+    var toIndexedObject = require_to_indexed_object();
+    var toAbsoluteIndex = require_to_absolute_index();
+    var lengthOfArrayLike = require_length_of_array_like();
+    var createMethod = function(IS_INCLUDES) {
+      return function($this, el, fromIndex) {
+        var O2 = toIndexedObject($this);
+        var length = lengthOfArrayLike(O2);
+        if (length === 0) return !IS_INCLUDES && -1;
+        var index2 = toAbsoluteIndex(fromIndex, length);
+        var value;
+        if (IS_INCLUDES && el !== el) while (length > index2) {
+          value = O2[index2++];
+          if (value !== value) return true;
+        }
+        else for (; length > index2; index2++) {
+          if ((IS_INCLUDES || index2 in O2) && O2[index2] === el) return IS_INCLUDES || index2 || 0;
+        }
+        return !IS_INCLUDES && -1;
+      };
+    };
+    module.exports = {
+      // `Array.prototype.includes` method
+      // https://tc39.es/ecma262/#sec-array.prototype.includes
+      includes: createMethod(true),
+      // `Array.prototype.indexOf` method
+      // https://tc39.es/ecma262/#sec-array.prototype.indexof
+      indexOf: createMethod(false)
+    };
+  }
+});
+
+// node_modules/core-js/internals/object-keys-internal.js
+var require_object_keys_internal = __commonJS({
+  "node_modules/core-js/internals/object-keys-internal.js"(exports, module) {
+    "use strict";
+    var uncurryThis8 = require_function_uncurry_this();
+    var hasOwn = require_has_own_property();
+    var toIndexedObject = require_to_indexed_object();
+    var indexOf2 = require_array_includes().indexOf;
+    var hiddenKeys = require_hidden_keys();
+    var push3 = uncurryThis8([].push);
+    module.exports = function(object, names) {
+      var O2 = toIndexedObject(object);
+      var i2 = 0;
+      var result = [];
+      var key;
+      for (key in O2) !hasOwn(hiddenKeys, key) && hasOwn(O2, key) && push3(result, key);
+      while (names.length > i2) if (hasOwn(O2, key = names[i2++])) {
+        ~indexOf2(result, key) || push3(result, key);
+      }
+      return result;
+    };
+  }
+});
+
+// node_modules/core-js/internals/enum-bug-keys.js
+var require_enum_bug_keys = __commonJS({
+  "node_modules/core-js/internals/enum-bug-keys.js"(exports, module) {
+    "use strict";
+    module.exports = [
+      "constructor",
+      "hasOwnProperty",
+      "isPrototypeOf",
+      "propertyIsEnumerable",
+      "toLocaleString",
+      "toString",
+      "valueOf"
+    ];
+  }
+});
+
+// node_modules/core-js/internals/object-get-own-property-names.js
+var require_object_get_own_property_names = __commonJS({
+  "node_modules/core-js/internals/object-get-own-property-names.js"(exports) {
+    "use strict";
+    var internalObjectKeys = require_object_keys_internal();
+    var enumBugKeys = require_enum_bug_keys();
+    var hiddenKeys = enumBugKeys.concat("length", "prototype");
+    exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O2) {
+      return internalObjectKeys(O2, hiddenKeys);
+    };
+  }
+});
+
+// node_modules/core-js/internals/object-get-own-property-symbols.js
+var require_object_get_own_property_symbols = __commonJS({
+  "node_modules/core-js/internals/object-get-own-property-symbols.js"(exports) {
+    "use strict";
+    exports.f = Object.getOwnPropertySymbols;
+  }
+});
+
+// node_modules/core-js/internals/own-keys.js
+var require_own_keys = __commonJS({
+  "node_modules/core-js/internals/own-keys.js"(exports, module) {
+    "use strict";
+    var getBuiltIn = require_get_built_in();
+    var uncurryThis8 = require_function_uncurry_this();
+    var getOwnPropertyNamesModule = require_object_get_own_property_names();
+    var getOwnPropertySymbolsModule = require_object_get_own_property_symbols();
+    var anObject5 = require_an_object();
+    var concat2 = uncurryThis8([].concat);
+    module.exports = getBuiltIn("Reflect", "ownKeys") || function ownKeys2(it) {
+      var keys = getOwnPropertyNamesModule.f(anObject5(it));
+      var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
+      return getOwnPropertySymbols ? concat2(keys, getOwnPropertySymbols(it)) : keys;
+    };
+  }
+});
+
+// node_modules/core-js/internals/copy-constructor-properties.js
+var require_copy_constructor_properties = __commonJS({
+  "node_modules/core-js/internals/copy-constructor-properties.js"(exports, module) {
+    "use strict";
+    var hasOwn = require_has_own_property();
+    var ownKeys2 = require_own_keys();
+    var getOwnPropertyDescriptorModule = require_object_get_own_property_descriptor();
+    var definePropertyModule = require_object_define_property();
+    module.exports = function(target, source, exceptions) {
+      var keys = ownKeys2(source);
+      var defineProperty = definePropertyModule.f;
+      var getOwnPropertyDescriptor3 = getOwnPropertyDescriptorModule.f;
+      for (var i2 = 0; i2 < keys.length; i2++) {
+        var key = keys[i2];
+        if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {
+          defineProperty(target, key, getOwnPropertyDescriptor3(source, key));
+        }
+      }
+    };
+  }
+});
+
+// node_modules/core-js/internals/is-forced.js
+var require_is_forced = __commonJS({
+  "node_modules/core-js/internals/is-forced.js"(exports, module) {
+    "use strict";
+    var fails4 = require_fails();
+    var isCallable2 = require_is_callable();
+    var replacement = /#|\.prototype\./;
+    var isForced = function(feature, detection) {
+      var value = data[normalize(feature)];
+      return value === POLYFILL ? true : value === NATIVE ? false : isCallable2(detection) ? fails4(detection) : !!detection;
+    };
+    var normalize = isForced.normalize = function(string) {
+      return String(string).replace(replacement, ".").toLowerCase();
+    };
+    var data = isForced.data = {};
+    var NATIVE = isForced.NATIVE = "N";
+    var POLYFILL = isForced.POLYFILL = "P";
+    module.exports = isForced;
+  }
+});
+
+// node_modules/core-js/internals/export.js
+var require_export = __commonJS({
+  "node_modules/core-js/internals/export.js"(exports, module) {
+    "use strict";
+    var globalThis3 = require_global_this();
+    var getOwnPropertyDescriptor3 = require_object_get_own_property_descriptor().f;
+    var createNonEnumerableProperty2 = require_create_non_enumerable_property();
+    var defineBuiltIn2 = require_define_built_in();
+    var defineGlobalProperty = require_define_global_property();
+    var copyConstructorProperties = require_copy_constructor_properties();
+    var isForced = require_is_forced();
+    module.exports = function(options, source) {
+      var TARGET = options.target;
+      var GLOBAL = options.global;
+      var STATIC = options.stat;
+      var FORCED3, target, key, targetProperty, sourceProperty, descriptor;
+      if (GLOBAL) {
+        target = globalThis3;
+      } else if (STATIC) {
+        target = globalThis3[TARGET] || defineGlobalProperty(TARGET, {});
+      } else {
+        target = globalThis3[TARGET] && globalThis3[TARGET].prototype;
+      }
+      if (target) for (key in source) {
+        sourceProperty = source[key];
+        if (options.dontCallGetSet) {
+          descriptor = getOwnPropertyDescriptor3(target, key);
+          targetProperty = descriptor && descriptor.value;
+        } else targetProperty = target[key];
+        FORCED3 = isForced(GLOBAL ? key : TARGET + (STATIC ? "." : "#") + key, options.forced);
+        if (!FORCED3 && targetProperty !== void 0) {
+          if (typeof sourceProperty == typeof targetProperty) continue;
+          copyConstructorProperties(sourceProperty, targetProperty);
+        }
+        if (options.sham || targetProperty && targetProperty.sham) {
+          createNonEnumerableProperty2(sourceProperty, "sham", true);
+        }
+        defineBuiltIn2(target, key, sourceProperty, options);
+      }
+    };
+  }
+});
+
+// node_modules/core-js/internals/environment.js
+var require_environment = __commonJS({
+  "node_modules/core-js/internals/environment.js"(exports, module) {
+    "use strict";
+    var globalThis3 = require_global_this();
+    var userAgent = require_environment_user_agent();
+    var classof = require_classof_raw();
+    var userAgentStartsWith = function(string) {
+      return userAgent.slice(0, string.length) === string;
+    };
+    module.exports = function() {
+      if (userAgentStartsWith("Bun/")) return "BUN";
+      if (userAgentStartsWith("Cloudflare-Workers")) return "CLOUDFLARE";
+      if (userAgentStartsWith("Deno/")) return "DENO";
+      if (userAgentStartsWith("Node.js/")) return "NODE";
+      if (globalThis3.Bun && typeof Bun.version == "string") return "BUN";
+      if (globalThis3.Deno && typeof Deno.version == "object") return "DENO";
+      if (classof(globalThis3.process) === "process") return "NODE";
+      if (globalThis3.window && globalThis3.document) return "BROWSER";
+      return "REST";
+    }();
+  }
+});
+
+// node_modules/core-js/internals/environment-is-node.js
+var require_environment_is_node = __commonJS({
+  "node_modules/core-js/internals/environment-is-node.js"(exports, module) {
+    "use strict";
+    var ENVIRONMENT = require_environment();
+    module.exports = ENVIRONMENT === "NODE";
+  }
+});
+
+// node_modules/core-js/internals/function-uncurry-this-accessor.js
+var require_function_uncurry_this_accessor = __commonJS({
+  "node_modules/core-js/internals/function-uncurry-this-accessor.js"(exports, module) {
+    "use strict";
+    var uncurryThis8 = require_function_uncurry_this();
+    var aCallable = require_a_callable();
+    module.exports = function(object, key, method) {
+      try {
+        return uncurryThis8(aCallable(Object.getOwnPropertyDescriptor(object, key)[method]));
+      } catch (error) {
+      }
+    };
+  }
+});
+
+// node_modules/core-js/internals/is-possible-prototype.js
+var require_is_possible_prototype = __commonJS({
+  "node_modules/core-js/internals/is-possible-prototype.js"(exports, module) {
+    "use strict";
+    var isObject = require_is_object();
+    module.exports = function(argument) {
+      return isObject(argument) || argument === null;
+    };
+  }
+});
+
+// node_modules/core-js/internals/a-possible-prototype.js
+var require_a_possible_prototype = __commonJS({
+  "node_modules/core-js/internals/a-possible-prototype.js"(exports, module) {
+    "use strict";
+    var isPossiblePrototype = require_is_possible_prototype();
+    var $String = String;
+    var $TypeError = TypeError;
+    module.exports = function(argument) {
+      if (isPossiblePrototype(argument)) return argument;
+      throw new $TypeError("Can't set " + $String(argument) + " as a prototype");
+    };
+  }
+});
+
+// node_modules/core-js/internals/object-set-prototype-of.js
+var require_object_set_prototype_of = __commonJS({
+  "node_modules/core-js/internals/object-set-prototype-of.js"(exports, module) {
+    "use strict";
+    var uncurryThisAccessor = require_function_uncurry_this_accessor();
+    var isObject = require_is_object();
+    var requireObjectCoercible7 = require_require_object_coercible();
+    var aPossiblePrototype = require_a_possible_prototype();
+    module.exports = Object.setPrototypeOf || ("__proto__" in {} ? function() {
+      var CORRECT_SETTER = false;
+      var test2 = {};
+      var setter;
+      try {
+        setter = uncurryThisAccessor(Object.prototype, "__proto__", "set");
+        setter(test2, []);
+        CORRECT_SETTER = test2 instanceof Array;
+      } catch (error) {
+      }
+      return function setPrototypeOf(O2, proto) {
+        requireObjectCoercible7(O2);
+        aPossiblePrototype(proto);
+        if (!isObject(O2)) return O2;
+        if (CORRECT_SETTER) setter(O2, proto);
+        else O2.__proto__ = proto;
+        return O2;
+      };
+    }() : void 0);
+  }
+});
+
+// node_modules/core-js/internals/set-to-string-tag.js
+var require_set_to_string_tag = __commonJS({
+  "node_modules/core-js/internals/set-to-string-tag.js"(exports, module) {
+    "use strict";
+    var defineProperty = require_object_define_property().f;
+    var hasOwn = require_has_own_property();
+    var wellKnownSymbol3 = require_well_known_symbol();
+    var TO_STRING_TAG = wellKnownSymbol3("toStringTag");
+    module.exports = function(target, TAG, STATIC) {
+      if (target && !STATIC) target = target.prototype;
+      if (target && !hasOwn(target, TO_STRING_TAG)) {
+        defineProperty(target, TO_STRING_TAG, { configurable: true, value: TAG });
+      }
+    };
+  }
+});
+
+// node_modules/core-js/internals/define-built-in-accessor.js
+var require_define_built_in_accessor = __commonJS({
+  "node_modules/core-js/internals/define-built-in-accessor.js"(exports, module) {
+    "use strict";
+    var makeBuiltIn = require_make_built_in();
+    var defineProperty = require_object_define_property();
+    module.exports = function(target, name, descriptor) {
+      if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true });
+      if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true });
+      return defineProperty.f(target, name, descriptor);
+    };
+  }
+});
+
+// node_modules/core-js/internals/set-species.js
+var require_set_species = __commonJS({
+  "node_modules/core-js/internals/set-species.js"(exports, module) {
+    "use strict";
+    var getBuiltIn = require_get_built_in();
+    var defineBuiltInAccessor = require_define_built_in_accessor();
+    var wellKnownSymbol3 = require_well_known_symbol();
+    var DESCRIPTORS = require_descriptors();
+    var SPECIES = wellKnownSymbol3("species");
+    module.exports = function(CONSTRUCTOR_NAME) {
+      var Constructor = getBuiltIn(CONSTRUCTOR_NAME);
+      if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) {
+        defineBuiltInAccessor(Constructor, SPECIES, {
+          configurable: true,
+          get: function() {
+            return this;
+          }
+        });
+      }
+    };
+  }
+});
+
+// node_modules/core-js/internals/an-instance.js
+var require_an_instance = __commonJS({
+  "node_modules/core-js/internals/an-instance.js"(exports, module) {
+    "use strict";
+    var isPrototypeOf = require_object_is_prototype_of();
+    var $TypeError = TypeError;
+    module.exports = function(it, Prototype) {
+      if (isPrototypeOf(Prototype, it)) return it;
+      throw new $TypeError("Incorrect invocation");
+    };
+  }
+});
+
+// node_modules/core-js/internals/to-string-tag-support.js
+var require_to_string_tag_support = __commonJS({
+  "node_modules/core-js/internals/to-string-tag-support.js"(exports, module) {
+    "use strict";
+    var wellKnownSymbol3 = require_well_known_symbol();
+    var TO_STRING_TAG = wellKnownSymbol3("toStringTag");
+    var test2 = {};
+    test2[TO_STRING_TAG] = "z";
+    module.exports = String(test2) === "[object z]";
+  }
+});
+
+// node_modules/core-js/internals/classof.js
+var require_classof = __commonJS({
+  "node_modules/core-js/internals/classof.js"(exports, module) {
+    "use strict";
+    var TO_STRING_TAG_SUPPORT = require_to_string_tag_support();
+    var isCallable2 = require_is_callable();
+    var classofRaw = require_classof_raw();
+    var wellKnownSymbol3 = require_well_known_symbol();
+    var TO_STRING_TAG = wellKnownSymbol3("toStringTag");
+    var $Object = Object;
+    var CORRECT_ARGUMENTS = classofRaw(/* @__PURE__ */ function() {
+      return arguments;
+    }()) === "Arguments";
+    var tryGet = function(it, key) {
+      try {
+        return it[key];
+      } catch (error) {
+      }
+    };
+    module.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function(it) {
+      var O2, tag, result;
+      return it === void 0 ? "Undefined" : it === null ? "Null" : typeof (tag = tryGet(O2 = $Object(it), TO_STRING_TAG)) == "string" ? tag : CORRECT_ARGUMENTS ? classofRaw(O2) : (result = classofRaw(O2)) === "Object" && isCallable2(O2.callee) ? "Arguments" : result;
+    };
+  }
+});
+
+// node_modules/core-js/internals/is-constructor.js
+var require_is_constructor = __commonJS({
+  "node_modules/core-js/internals/is-constructor.js"(exports, module) {
+    "use strict";
+    var uncurryThis8 = require_function_uncurry_this();
+    var fails4 = require_fails();
+    var isCallable2 = require_is_callable();
+    var classof = require_classof();
+    var getBuiltIn = require_get_built_in();
+    var inspectSource = require_inspect_source();
+    var noop2 = function() {
+    };
+    var construct = getBuiltIn("Reflect", "construct");
+    var constructorRegExp = /^\s*(?:class|function)\b/;
+    var exec = uncurryThis8(constructorRegExp.exec);
+    var INCORRECT_TO_STRING = !constructorRegExp.test(noop2);
+    var isConstructorModern = function isConstructor(argument) {
+      if (!isCallable2(argument)) return false;
+      try {
+        construct(noop2, [], argument);
+        return true;
+      } catch (error) {
+        return false;
+      }
+    };
+    var isConstructorLegacy = function isConstructor(argument) {
+      if (!isCallable2(argument)) return false;
+      switch (classof(argument)) {
+        case "AsyncFunction":
+        case "GeneratorFunction":
+        case "AsyncGeneratorFunction":
+          return false;
+      }
+      try {
+        return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));
+      } catch (error) {
+        return true;
+      }
+    };
+    isConstructorLegacy.sham = true;
+    module.exports = !construct || fails4(function() {
+      var called;
+      return isConstructorModern(isConstructorModern.call) || !isConstructorModern(Object) || !isConstructorModern(function() {
+        called = true;
+      }) || called;
+    }) ? isConstructorLegacy : isConstructorModern;
+  }
+});
+
+// node_modules/core-js/internals/a-constructor.js
+var require_a_constructor = __commonJS({
+  "node_modules/core-js/internals/a-constructor.js"(exports, module) {
+    "use strict";
+    var isConstructor = require_is_constructor();
+    var tryToString = require_try_to_string();
+    var $TypeError = TypeError;
+    module.exports = function(argument) {
+      if (isConstructor(argument)) return argument;
+      throw new $TypeError(tryToString(argument) + " is not a constructor");
+    };
+  }
+});
+
+// node_modules/core-js/internals/species-constructor.js
+var require_species_constructor = __commonJS({
+  "node_modules/core-js/internals/species-constructor.js"(exports, module) {
+    "use strict";
+    var anObject5 = require_an_object();
+    var aConstructor = require_a_constructor();
+    var isNullOrUndefined4 = require_is_null_or_undefined();
+    var wellKnownSymbol3 = require_well_known_symbol();
+    var SPECIES = wellKnownSymbol3("species");
+    module.exports = function(O2, defaultConstructor) {
+      var C = anObject5(O2).constructor;
+      var S;
+      return C === void 0 || isNullOrUndefined4(S = anObject5(C)[SPECIES]) ? defaultConstructor : aConstructor(S);
+    };
+  }
+});
+
+// node_modules/core-js/internals/function-apply.js
+var require_function_apply = __commonJS({
+  "node_modules/core-js/internals/function-apply.js"(exports, module) {
+    "use strict";
+    var NATIVE_BIND = require_function_bind_native();
+    var FunctionPrototype = Function.prototype;
+    var apply2 = FunctionPrototype.apply;
+    var call4 = FunctionPrototype.call;
+    module.exports = typeof Reflect == "object" && Reflect.apply || (NATIVE_BIND ? call4.bind(apply2) : function() {
+      return call4.apply(apply2, arguments);
+    });
+  }
+});
+
+// node_modules/core-js/internals/function-uncurry-this-clause.js
+var require_function_uncurry_this_clause = __commonJS({
+  "node_modules/core-js/internals/function-uncurry-this-clause.js"(exports, module) {
+    "use strict";
+    var classofRaw = require_classof_raw();
+    var uncurryThis8 = require_function_uncurry_this();
+    module.exports = function(fn) {
+      if (classofRaw(fn) === "Function") return uncurryThis8(fn);
+    };
+  }
+});
+
+// node_modules/core-js/internals/function-bind-context.js
+var require_function_bind_context = __commonJS({
+  "node_modules/core-js/internals/function-bind-context.js"(exports, module) {
+    "use strict";
+    var uncurryThis8 = require_function_uncurry_this_clause();
+    var aCallable = require_a_callable();
+    var NATIVE_BIND = require_function_bind_native();
+    var bind = uncurryThis8(uncurryThis8.bind);
+    module.exports = function(fn, that) {
+      aCallable(fn);
+      return that === void 0 ? fn : NATIVE_BIND ? bind(fn, that) : function() {
+        return fn.apply(that, arguments);
+      };
+    };
+  }
+});
+
+// node_modules/core-js/internals/html.js
+var require_html = __commonJS({
+  "node_modules/core-js/internals/html.js"(exports, module) {
+    "use strict";
+    var getBuiltIn = require_get_built_in();
+    module.exports = getBuiltIn("document", "documentElement");
+  }
+});
+
+// node_modules/core-js/internals/array-slice.js
+var require_array_slice = __commonJS({
+  "node_modules/core-js/internals/array-slice.js"(exports, module) {
+    "use strict";
+    var uncurryThis8 = require_function_uncurry_this();
+    module.exports = uncurryThis8([].slice);
+  }
+});
+
+// node_modules/core-js/internals/validate-arguments-length.js
+var require_validate_arguments_length = __commonJS({
+  "node_modules/core-js/internals/validate-arguments-length.js"(exports, module) {
+    "use strict";
+    var $TypeError = TypeError;
+    module.exports = function(passed, required) {
+      if (passed < required) throw new $TypeError("Not enough arguments");
+      return passed;
+    };
+  }
+});
+
+// node_modules/core-js/internals/environment-is-ios.js
+var require_environment_is_ios = __commonJS({
+  "node_modules/core-js/internals/environment-is-ios.js"(exports, module) {
+    "use strict";
+    var userAgent = require_environment_user_agent();
+    module.exports = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent);
+  }
+});
+
+// node_modules/core-js/internals/task.js
+var require_task = __commonJS({
+  "node_modules/core-js/internals/task.js"(exports, module) {
+    "use strict";
+    var globalThis3 = require_global_this();
+    var apply2 = require_function_apply();
+    var bind = require_function_bind_context();
+    var isCallable2 = require_is_callable();
+    var hasOwn = require_has_own_property();
+    var fails4 = require_fails();
+    var html = require_html();
+    var arraySlice = require_array_slice();
+    var createElement = require_document_create_element();
+    var validateArgumentsLength = require_validate_arguments_length();
+    var IS_IOS = require_environment_is_ios();
+    var IS_NODE2 = require_environment_is_node();
+    var set = globalThis3.setImmediate;
+    var clear = globalThis3.clearImmediate;
+    var process2 = globalThis3.process;
+    var Dispatch = globalThis3.Dispatch;
+    var Function2 = globalThis3.Function;
+    var MessageChannel = globalThis3.MessageChannel;
+    var String2 = globalThis3.String;
+    var counter = 0;
+    var queue = {};
+    var ONREADYSTATECHANGE = "onreadystatechange";
+    var $location;
+    var defer;
+    var channel;
+    var port;
+    fails4(function() {
+      $location = globalThis3.location;
+    });
+    var run = function(id) {
+      if (hasOwn(queue, id)) {
+        var fn = queue[id];
+        delete queue[id];
+        fn();
+      }
+    };
+    var runner = function(id) {
+      return function() {
+        run(id);
+      };
+    };
+    var eventListener = function(event) {
+      run(event.data);
+    };
+    var globalPostMessageDefer = function(id) {
+      globalThis3.postMessage(String2(id), $location.protocol + "//" + $location.host);
+    };
+    if (!set || !clear) {
+      set = function setImmediate(handler) {
+        validateArgumentsLength(arguments.length, 1);
+        var fn = isCallable2(handler) ? handler : Function2(handler);
+        var args = arraySlice(arguments, 1);
+        queue[++counter] = function() {
+          apply2(fn, void 0, args);
+        };
+        defer(counter);
+        return counter;
+      };
+      clear = function clearImmediate(id) {
+        delete queue[id];
+      };
+      if (IS_NODE2) {
+        defer = function(id) {
+          process2.nextTick(runner(id));
+        };
+      } else if (Dispatch && Dispatch.now) {
+        defer = function(id) {
+          Dispatch.now(runner(id));
+        };
+      } else if (MessageChannel && !IS_IOS) {
+        channel = new MessageChannel();
+        port = channel.port2;
+        channel.port1.onmessage = eventListener;
+        defer = bind(port.postMessage, port);
+      } else if (globalThis3.addEventListener && isCallable2(globalThis3.postMessage) && !globalThis3.importScripts && $location && $location.protocol !== "file:" && !fails4(globalPostMessageDefer)) {
+        defer = globalPostMessageDefer;
+        globalThis3.addEventListener("message", eventListener, false);
+      } else if (ONREADYSTATECHANGE in createElement("script")) {
+        defer = function(id) {
+          html.appendChild(createElement("script"))[ONREADYSTATECHANGE] = function() {
+            html.removeChild(this);
+            run(id);
+          };
+        };
+      } else {
+        defer = function(id) {
+          setTimeout(runner(id), 0);
+        };
+      }
+    }
+    module.exports = {
+      set,
+      clear
+    };
+  }
+});
+
+// node_modules/core-js/internals/safe-get-built-in.js
+var require_safe_get_built_in = __commonJS({
+  "node_modules/core-js/internals/safe-get-built-in.js"(exports, module) {
+    "use strict";
+    var globalThis3 = require_global_this();
+    var DESCRIPTORS = require_descriptors();
+    var getOwnPropertyDescriptor3 = Object.getOwnPropertyDescriptor;
+    module.exports = function(name) {
+      if (!DESCRIPTORS) return globalThis3[name];
+      var descriptor = getOwnPropertyDescriptor3(globalThis3, name);
+      return descriptor && descriptor.value;
+    };
+  }
+});
+
+// node_modules/core-js/internals/queue.js
+var require_queue = __commonJS({
+  "node_modules/core-js/internals/queue.js"(exports, module) {
+    "use strict";
+    var Queue = function() {
+      this.head = null;
+      this.tail = null;
+    };
+    Queue.prototype = {
+      add: function(item) {
+        var entry = { item, next: null };
+        var tail = this.tail;
+        if (tail) tail.next = entry;
+        else this.head = entry;
+        this.tail = entry;
+      },
+      get: function() {
+        var entry = this.head;
+        if (entry) {
+          var next = this.head = entry.next;
+          if (next === null) this.tail = null;
+          return entry.item;
+        }
+      }
+    };
+    module.exports = Queue;
+  }
+});
+
+// node_modules/core-js/internals/environment-is-ios-pebble.js
+var require_environment_is_ios_pebble = __commonJS({
+  "node_modules/core-js/internals/environment-is-ios-pebble.js"(exports, module) {
+    "use strict";
+    var userAgent = require_environment_user_agent();
+    module.exports = /ipad|iphone|ipod/i.test(userAgent) && typeof Pebble != "undefined";
+  }
+});
+
+// node_modules/core-js/internals/environment-is-webos-webkit.js
+var require_environment_is_webos_webkit = __commonJS({
+  "node_modules/core-js/internals/environment-is-webos-webkit.js"(exports, module) {
+    "use strict";
+    var userAgent = require_environment_user_agent();
+    module.exports = /web0s(?!.*chrome)/i.test(userAgent);
+  }
+});
+
+// node_modules/core-js/internals/microtask.js
+var require_microtask = __commonJS({
+  "node_modules/core-js/internals/microtask.js"(exports, module) {
+    "use strict";
+    var globalThis3 = require_global_this();
+    var safeGetBuiltIn = require_safe_get_built_in();
+    var bind = require_function_bind_context();
+    var macrotask = require_task().set;
+    var Queue = require_queue();
+    var IS_IOS = require_environment_is_ios();
+    var IS_IOS_PEBBLE = require_environment_is_ios_pebble();
+    var IS_WEBOS_WEBKIT = require_environment_is_webos_webkit();
+    var IS_NODE2 = require_environment_is_node();
+    var MutationObserver = globalThis3.MutationObserver || globalThis3.WebKitMutationObserver;
+    var document2 = globalThis3.document;
+    var process2 = globalThis3.process;
+    var Promise2 = globalThis3.Promise;
+    var microtask = safeGetBuiltIn("queueMicrotask");
+    var notify;
+    var toggle;
+    var node2;
+    var promise;
+    var then;
+    if (!microtask) {
+      queue = new Queue();
+      flush = function() {
+        var parent, fn;
+        if (IS_NODE2 && (parent = process2.domain)) parent.exit();
+        while (fn = queue.get()) try {
+          fn();
+        } catch (error) {
+          if (queue.head) notify();
+          throw error;
+        }
+        if (parent) parent.enter();
+      };
+      if (!IS_IOS && !IS_NODE2 && !IS_WEBOS_WEBKIT && MutationObserver && document2) {
+        toggle = true;
+        node2 = document2.createTextNode("");
+        new MutationObserver(flush).observe(node2, { characterData: true });
+        notify = function() {
+          node2.data = toggle = !toggle;
+        };
+      } else if (!IS_IOS_PEBBLE && Promise2 && Promise2.resolve) {
+        promise = Promise2.resolve(void 0);
+        promise.constructor = Promise2;
+        then = bind(promise.then, promise);
+        notify = function() {
+          then(flush);
+        };
+      } else if (IS_NODE2) {
+        notify = function() {
+          process2.nextTick(flush);
+        };
+      } else {
+        macrotask = bind(macrotask, globalThis3);
+        notify = function() {
+          macrotask(flush);
+        };
+      }
+      microtask = function(fn) {
+        if (!queue.head) notify();
+        queue.add(fn);
+      };
+    }
+    var queue;
+    var flush;
+    module.exports = microtask;
+  }
+});
+
+// node_modules/core-js/internals/host-report-errors.js
+var require_host_report_errors = __commonJS({
+  "node_modules/core-js/internals/host-report-errors.js"(exports, module) {
+    "use strict";
+    module.exports = function(a2, b) {
+      try {
+        arguments.length === 1 ? console.error(a2) : console.error(a2, b);
+      } catch (error) {
+      }
+    };
+  }
+});
+
+// node_modules/core-js/internals/perform.js
+var require_perform = __commonJS({
+  "node_modules/core-js/internals/perform.js"(exports, module) {
+    "use strict";
+    module.exports = function(exec) {
+      try {
+        return { error: false, value: exec() };
+      } catch (error) {
+        return { error: true, value: error };
+      }
+    };
+  }
+});
+
+// node_modules/core-js/internals/promise-native-constructor.js
+var require_promise_native_constructor = __commonJS({
+  "node_modules/core-js/internals/promise-native-constructor.js"(exports, module) {
+    "use strict";
+    var globalThis3 = require_global_this();
+    module.exports = globalThis3.Promise;
+  }
+});
+
+// node_modules/core-js/internals/promise-constructor-detection.js
+var require_promise_constructor_detection = __commonJS({
+  "node_modules/core-js/internals/promise-constructor-detection.js"(exports, module) {
+    "use strict";
+    var globalThis3 = require_global_this();
+    var NativePromiseConstructor = require_promise_native_constructor();
+    var isCallable2 = require_is_callable();
+    var isForced = require_is_forced();
+    var inspectSource = require_inspect_source();
+    var wellKnownSymbol3 = require_well_known_symbol();
+    var ENVIRONMENT = require_environment();
+    var IS_PURE3 = require_is_pure();
+    var V8_VERSION = require_environment_v8_version();
+    var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;
+    var SPECIES = wellKnownSymbol3("species");
+    var SUBCLASSING = false;
+    var NATIVE_PROMISE_REJECTION_EVENT = isCallable2(globalThis3.PromiseRejectionEvent);
+    var FORCED_PROMISE_CONSTRUCTOR = isForced("Promise", function() {
+      var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor);
+      var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor);
+      if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;
+      if (IS_PURE3 && !(NativePromisePrototype["catch"] && NativePromisePrototype["finally"])) return true;
+      if (!V8_VERSION || V8_VERSION < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) {
+        var promise = new NativePromiseConstructor(function(resolve) {
+          resolve(1);
+        });
+        var FakePromise = function(exec) {
+          exec(function() {
+          }, function() {
+          });
+        };
+        var constructor = promise.constructor = {};
+        constructor[SPECIES] = FakePromise;
+        SUBCLASSING = promise.then(function() {
+        }) instanceof FakePromise;
+        if (!SUBCLASSING) return true;
+      }
+      return !GLOBAL_CORE_JS_PROMISE && (ENVIRONMENT === "BROWSER" || ENVIRONMENT === "DENO") && !NATIVE_PROMISE_REJECTION_EVENT;
+    });
+    module.exports = {
+      CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR,
+      REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT,
+      SUBCLASSING
+    };
+  }
+});
+
+// node_modules/core-js/internals/new-promise-capability.js
+var require_new_promise_capability = __commonJS({
+  "node_modules/core-js/internals/new-promise-capability.js"(exports, module) {
+    "use strict";
+    var aCallable = require_a_callable();
+    var $TypeError = TypeError;
+    var PromiseCapability = function(C) {
+      var resolve, reject;
+      this.promise = new C(function($$resolve, $$reject) {
+        if (resolve !== void 0 || reject !== void 0) throw new $TypeError("Bad Promise constructor");
+        resolve = $$resolve;
+        reject = $$reject;
+      });
+      this.resolve = aCallable(resolve);
+      this.reject = aCallable(reject);
+    };
+    module.exports.f = function(C) {
+      return new PromiseCapability(C);
+    };
+  }
+});
+
+// node_modules/core-js/modules/es.promise.constructor.js
+var require_es_promise_constructor = __commonJS({
+  "node_modules/core-js/modules/es.promise.constructor.js"() {
+    "use strict";
+    var $8 = require_export();
+    var IS_PURE3 = require_is_pure();
+    var IS_NODE2 = require_environment_is_node();
+    var globalThis3 = require_global_this();
+    var call4 = require_function_call();
+    var defineBuiltIn2 = require_define_built_in();
+    var setPrototypeOf = require_object_set_prototype_of();
+    var setToStringTag2 = require_set_to_string_tag();
+    var setSpecies = require_set_species();
+    var aCallable = require_a_callable();
+    var isCallable2 = require_is_callable();
+    var isObject = require_is_object();
+    var anInstance = require_an_instance();
+    var speciesConstructor2 = require_species_constructor();
+    var task = require_task().set;
+    var microtask = require_microtask();
+    var hostReportErrors = require_host_report_errors();
+    var perform = require_perform();
+    var Queue = require_queue();
+    var InternalStateModule = require_internal_state();
+    var NativePromiseConstructor = require_promise_native_constructor();
+    var PromiseConstructorDetection = require_promise_constructor_detection();
+    var newPromiseCapabilityModule = require_new_promise_capability();
+    var PROMISE = "Promise";
+    var FORCED_PROMISE_CONSTRUCTOR = PromiseConstructorDetection.CONSTRUCTOR;
+    var NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT;
+    var NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING;
+    var getInternalPromiseState = InternalStateModule.getterFor(PROMISE);
+    var setInternalState = InternalStateModule.set;
+    var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;
+    var PromiseConstructor = NativePromiseConstructor;
+    var PromisePrototype = NativePromisePrototype;
+    var TypeError2 = globalThis3.TypeError;
+    var document2 = globalThis3.document;
+    var process2 = globalThis3.process;
+    var newPromiseCapability = newPromiseCapabilityModule.f;
+    var newGenericPromiseCapability = newPromiseCapability;
+    var DISPATCH_EVENT = !!(document2 && document2.createEvent && globalThis3.dispatchEvent);
+    var UNHANDLED_REJECTION = "unhandledrejection";
+    var REJECTION_HANDLED = "rejectionhandled";
+    var PENDING = 0;
+    var FULFILLED = 1;
+    var REJECTED = 2;
+    var HANDLED = 1;
+    var UNHANDLED = 2;
+    var Internal;
+    var OwnPromiseCapability;
+    var PromiseWrapper;
+    var nativeThen;
+    var isThenable = function(it) {
+      var then;
+      return isObject(it) && isCallable2(then = it.then) ? then : false;
+    };
+    var callReaction = function(reaction, state) {
+      var value = state.value;
+      var ok = state.state === FULFILLED;
+      var handler = ok ? reaction.ok : reaction.fail;
+      var resolve = reaction.resolve;
+      var reject = reaction.reject;
+      var domain = reaction.domain;
+      var result, then, exited;
+      try {
+        if (handler) {
+          if (!ok) {
+            if (state.rejection === UNHANDLED) onHandleUnhandled(state);
+            state.rejection = HANDLED;
+          }
+          if (handler === true) result = value;
+          else {
+            if (domain) domain.enter();
+            result = handler(value);
+            if (domain) {
+              domain.exit();
+              exited = true;
+            }
+          }
+          if (result === reaction.promise) {
+            reject(new TypeError2("Promise-chain cycle"));
+          } else if (then = isThenable(result)) {
+            call4(then, result, resolve, reject);
+          } else resolve(result);
+        } else reject(value);
+      } catch (error) {
+        if (domain && !exited) domain.exit();
+        reject(error);
+      }
+    };
+    var notify = function(state, isReject) {
+      if (state.notified) return;
+      state.notified = true;
+      microtask(function() {
+        var reactions = state.reactions;
+        var reaction;
+        while (reaction = reactions.get()) {
+          callReaction(reaction, state);
+        }
+        state.notified = false;
+        if (isReject && !state.rejection) onUnhandled(state);
+      });
+    };
+    var dispatchEvent = function(name, promise, reason) {
+      var event, handler;
+      if (DISPATCH_EVENT) {
+        event = document2.createEvent("Event");
+        event.promise = promise;
+        event.reason = reason;
+        event.initEvent(name, false, true);
+        globalThis3.dispatchEvent(event);
+      } else event = { promise, reason };
+      if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = globalThis3["on" + name])) handler(event);
+      else if (name === UNHANDLED_REJECTION) hostReportErrors("Unhandled promise rejection", reason);
+    };
+    var onUnhandled = function(state) {
+      call4(task, globalThis3, function() {
+        var promise = state.facade;
+        var value = state.value;
+        var IS_UNHANDLED = isUnhandled(state);
+        var result;
+        if (IS_UNHANDLED) {
+          result = perform(function() {
+            if (IS_NODE2) {
+              process2.emit("unhandledRejection", value, promise);
+            } else dispatchEvent(UNHANDLED_REJECTION, promise, value);
+          });
+          state.rejection = IS_NODE2 || isUnhandled(state) ? UNHANDLED : HANDLED;
+          if (result.error) throw result.value;
+        }
+      });
+    };
+    var isUnhandled = function(state) {
+      return state.rejection !== HANDLED && !state.parent;
+    };
+    var onHandleUnhandled = function(state) {
+      call4(task, globalThis3, function() {
+        var promise = state.facade;
+        if (IS_NODE2) {
+          process2.emit("rejectionHandled", promise);
+        } else dispatchEvent(REJECTION_HANDLED, promise, state.value);
+      });
+    };
+    var bind = function(fn, state, unwrap) {
+      return function(value) {
+        fn(state, value, unwrap);
+      };
+    };
+    var internalReject = function(state, value, unwrap) {
+      if (state.done) return;
+      state.done = true;
+      if (unwrap) state = unwrap;
+      state.value = value;
+      state.state = REJECTED;
+      notify(state, true);
+    };
+    var internalResolve = function(state, value, unwrap) {
+      if (state.done) return;
+      state.done = true;
+      if (unwrap) state = unwrap;
+      try {
+        if (state.facade === value) throw new TypeError2("Promise can't be resolved itself");
+        var then = isThenable(value);
+        if (then) {
+          microtask(function() {
+            var wrapper = { done: false };
+            try {
+              call4(
+                then,
+                value,
+                bind(internalResolve, wrapper, state),
+                bind(internalReject, wrapper, state)
+              );
+            } catch (error) {
+              internalReject(wrapper, error, state);
+            }
+          });
+        } else {
+          state.value = value;
+          state.state = FULFILLED;
+          notify(state, false);
+        }
+      } catch (error) {
+        internalReject({ done: false }, error, state);
+      }
+    };
+    if (FORCED_PROMISE_CONSTRUCTOR) {
+      PromiseConstructor = function Promise2(executor) {
+        anInstance(this, PromisePrototype);
+        aCallable(executor);
+        call4(Internal, this);
+        var state = getInternalPromiseState(this);
+        try {
+          executor(bind(internalResolve, state), bind(internalReject, state));
+        } catch (error) {
+          internalReject(state, error);
+        }
+      };
+      PromisePrototype = PromiseConstructor.prototype;
+      Internal = function Promise2(executor) {
+        setInternalState(this, {
+          type: PROMISE,
+          done: false,
+          notified: false,
+          parent: false,
+          reactions: new Queue(),
+          rejection: false,
+          state: PENDING,
+          value: null
+        });
+      };
+      Internal.prototype = defineBuiltIn2(PromisePrototype, "then", function then(onFulfilled, onRejected) {
+        var state = getInternalPromiseState(this);
+        var reaction = newPromiseCapability(speciesConstructor2(this, PromiseConstructor));
+        state.parent = true;
+        reaction.ok = isCallable2(onFulfilled) ? onFulfilled : true;
+        reaction.fail = isCallable2(onRejected) && onRejected;
+        reaction.domain = IS_NODE2 ? process2.domain : void 0;
+        if (state.state === PENDING) state.reactions.add(reaction);
+        else microtask(function() {
+          callReaction(reaction, state);
+        });
+        return reaction.promise;
+      });
+      OwnPromiseCapability = function() {
+        var promise = new Internal();
+        var state = getInternalPromiseState(promise);
+        this.promise = promise;
+        this.resolve = bind(internalResolve, state);
+        this.reject = bind(internalReject, state);
+      };
+      newPromiseCapabilityModule.f = newPromiseCapability = function(C) {
+        return C === PromiseConstructor || C === PromiseWrapper ? new OwnPromiseCapability(C) : newGenericPromiseCapability(C);
+      };
+      if (!IS_PURE3 && isCallable2(NativePromiseConstructor) && NativePromisePrototype !== Object.prototype) {
+        nativeThen = NativePromisePrototype.then;
+        if (!NATIVE_PROMISE_SUBCLASSING) {
+          defineBuiltIn2(NativePromisePrototype, "then", function then(onFulfilled, onRejected) {
+            var that = this;
+            return new PromiseConstructor(function(resolve, reject) {
+              call4(nativeThen, that, resolve, reject);
+            }).then(onFulfilled, onRejected);
+          }, { unsafe: true });
+        }
+        try {
+          delete NativePromisePrototype.constructor;
+        } catch (error) {
+        }
+        if (setPrototypeOf) {
+          setPrototypeOf(NativePromisePrototype, PromisePrototype);
+        }
+      }
+    }
+    $8({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {
+      Promise: PromiseConstructor
+    });
+    setToStringTag2(PromiseConstructor, PROMISE, false, true);
+    setSpecies(PROMISE);
+  }
+});
+
+// node_modules/core-js/internals/iterators.js
+var require_iterators = __commonJS({
+  "node_modules/core-js/internals/iterators.js"(exports, module) {
+    "use strict";
+    module.exports = {};
+  }
+});
+
+// node_modules/core-js/internals/is-array-iterator-method.js
+var require_is_array_iterator_method = __commonJS({
+  "node_modules/core-js/internals/is-array-iterator-method.js"(exports, module) {
+    "use strict";
+    var wellKnownSymbol3 = require_well_known_symbol();
+    var Iterators = require_iterators();
+    var ITERATOR2 = wellKnownSymbol3("iterator");
+    var ArrayPrototype = Array.prototype;
+    module.exports = function(it) {
+      return it !== void 0 && (Iterators.Array === it || ArrayPrototype[ITERATOR2] === it);
+    };
+  }
+});
+
+// node_modules/core-js/internals/get-iterator-method.js
+var require_get_iterator_method = __commonJS({
+  "node_modules/core-js/internals/get-iterator-method.js"(exports, module) {
+    "use strict";
+    var classof = require_classof();
+    var getMethod4 = require_get_method();
+    var isNullOrUndefined4 = require_is_null_or_undefined();
+    var Iterators = require_iterators();
+    var wellKnownSymbol3 = require_well_known_symbol();
+    var ITERATOR2 = wellKnownSymbol3("iterator");
+    module.exports = function(it) {
+      if (!isNullOrUndefined4(it)) return getMethod4(it, ITERATOR2) || getMethod4(it, "@@iterator") || Iterators[classof(it)];
+    };
+  }
+});
+
+// node_modules/core-js/internals/get-iterator.js
+var require_get_iterator = __commonJS({
+  "node_modules/core-js/internals/get-iterator.js"(exports, module) {
+    "use strict";
+    var call4 = require_function_call();
+    var aCallable = require_a_callable();
+    var anObject5 = require_an_object();
+    var tryToString = require_try_to_string();
+    var getIteratorMethod = require_get_iterator_method();
+    var $TypeError = TypeError;
+    module.exports = function(argument, usingIterator) {
+      var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;
+      if (aCallable(iteratorMethod)) return anObject5(call4(iteratorMethod, argument));
+      throw new $TypeError(tryToString(argument) + " is not iterable");
+    };
+  }
+});
+
+// node_modules/core-js/internals/iterator-close.js
+var require_iterator_close = __commonJS({
+  "node_modules/core-js/internals/iterator-close.js"(exports, module) {
+    "use strict";
+    var call4 = require_function_call();
+    var anObject5 = require_an_object();
+    var getMethod4 = require_get_method();
+    module.exports = function(iterator, kind, value) {
+      var innerResult, innerError;
+      anObject5(iterator);
+      try {
+        innerResult = getMethod4(iterator, "return");
+        if (!innerResult) {
+          if (kind === "throw") throw value;
+          return value;
+        }
+        innerResult = call4(innerResult, iterator);
+      } catch (error) {
+        innerError = true;
+        innerResult = error;
+      }
+      if (kind === "throw") throw value;
+      if (innerError) throw innerResult;
+      anObject5(innerResult);
+      return value;
+    };
+  }
+});
+
+// node_modules/core-js/internals/iterate.js
+var require_iterate = __commonJS({
+  "node_modules/core-js/internals/iterate.js"(exports, module) {
+    "use strict";
+    var bind = require_function_bind_context();
+    var call4 = require_function_call();
+    var anObject5 = require_an_object();
+    var tryToString = require_try_to_string();
+    var isArrayIteratorMethod = require_is_array_iterator_method();
+    var lengthOfArrayLike = require_length_of_array_like();
+    var isPrototypeOf = require_object_is_prototype_of();
+    var getIterator = require_get_iterator();
+    var getIteratorMethod = require_get_iterator_method();
+    var iteratorClose = require_iterator_close();
+    var $TypeError = TypeError;
+    var Result = function(stopped, result) {
+      this.stopped = stopped;
+      this.result = result;
+    };
+    var ResultPrototype = Result.prototype;
+    module.exports = function(iterable, unboundFunction, options) {
+      var that = options && options.that;
+      var AS_ENTRIES = !!(options && options.AS_ENTRIES);
+      var IS_RECORD = !!(options && options.IS_RECORD);
+      var IS_ITERATOR = !!(options && options.IS_ITERATOR);
+      var INTERRUPTED = !!(options && options.INTERRUPTED);
+      var fn = bind(unboundFunction, that);
+      var iterator, iterFn, index2, length, result, next, step;
+      var stop = function(condition) {
+        if (iterator) iteratorClose(iterator, "normal", condition);
+        return new Result(true, condition);
+      };
+      var callFn = function(value) {
+        if (AS_ENTRIES) {
+          anObject5(value);
+          return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
+        }
+        return INTERRUPTED ? fn(value, stop) : fn(value);
+      };
+      if (IS_RECORD) {
+        iterator = iterable.iterator;
+      } else if (IS_ITERATOR) {
+        iterator = iterable;
+      } else {
+        iterFn = getIteratorMethod(iterable);
+        if (!iterFn) throw new $TypeError(tryToString(iterable) + " is not iterable");
+        if (isArrayIteratorMethod(iterFn)) {
+          for (index2 = 0, length = lengthOfArrayLike(iterable); length > index2; index2++) {
+            result = callFn(iterable[index2]);
+            if (result && isPrototypeOf(ResultPrototype, result)) return result;
+          }
+          return new Result(false);
+        }
+        iterator = getIterator(iterable, iterFn);
+      }
+      next = IS_RECORD ? iterable.next : iterator.next;
+      while (!(step = call4(next, iterator)).done) {
+        try {
+          result = callFn(step.value);
+        } catch (error) {
+          iteratorClose(iterator, "throw", error);
+        }
+        if (typeof result == "object" && result && isPrototypeOf(ResultPrototype, result)) return result;
+      }
+      return new Result(false);
+    };
+  }
+});
+
+// node_modules/core-js/internals/check-correctness-of-iteration.js
+var require_check_correctness_of_iteration = __commonJS({
+  "node_modules/core-js/internals/check-correctness-of-iteration.js"(exports, module) {
+    "use strict";
+    var wellKnownSymbol3 = require_well_known_symbol();
+    var ITERATOR2 = wellKnownSymbol3("iterator");
+    var SAFE_CLOSING = false;
+    try {
+      called = 0;
+      iteratorWithReturn = {
+        next: function() {
+          return { done: !!called++ };
+        },
+        "return": function() {
+          SAFE_CLOSING = true;
+        }
+      };
+      iteratorWithReturn[ITERATOR2] = function() {
+        return this;
+      };
+      Array.from(iteratorWithReturn, function() {
+        throw 2;
+      });
+    } catch (error) {
+    }
+    var called;
+    var iteratorWithReturn;
+    module.exports = function(exec, SKIP_CLOSING) {
+      try {
+        if (!SKIP_CLOSING && !SAFE_CLOSING) return false;
+      } catch (error) {
+        return false;
+      }
+      var ITERATION_SUPPORT = false;
+      try {
+        var object = {};
+        object[ITERATOR2] = function() {
+          return {
+            next: function() {
+              return { done: ITERATION_SUPPORT = true };
+            }
+          };
+        };
+        exec(object);
+      } catch (error) {
+      }
+      return ITERATION_SUPPORT;
+    };
+  }
+});
+
+// node_modules/core-js/internals/promise-statics-incorrect-iteration.js
+var require_promise_statics_incorrect_iteration = __commonJS({
+  "node_modules/core-js/internals/promise-statics-incorrect-iteration.js"(exports, module) {
+    "use strict";
+    var NativePromiseConstructor = require_promise_native_constructor();
+    var checkCorrectnessOfIteration = require_check_correctness_of_iteration();
+    var FORCED_PROMISE_CONSTRUCTOR = require_promise_constructor_detection().CONSTRUCTOR;
+    module.exports = FORCED_PROMISE_CONSTRUCTOR || !checkCorrectnessOfIteration(function(iterable) {
+      NativePromiseConstructor.all(iterable).then(void 0, function() {
+      });
+    });
+  }
+});
+
+// node_modules/core-js/modules/es.promise.all.js
+var require_es_promise_all = __commonJS({
+  "node_modules/core-js/modules/es.promise.all.js"() {
+    "use strict";
+    var $8 = require_export();
+    var call4 = require_function_call();
+    var aCallable = require_a_callable();
+    var newPromiseCapabilityModule = require_new_promise_capability();
+    var perform = require_perform();
+    var iterate = require_iterate();
+    var PROMISE_STATICS_INCORRECT_ITERATION = require_promise_statics_incorrect_iteration();
+    $8({ target: "Promise", stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {
+      all: function all(iterable) {
+        var C = this;
+        var capability = newPromiseCapabilityModule.f(C);
+        var resolve = capability.resolve;
+        var reject = capability.reject;
+        var result = perform(function() {
+          var $promiseResolve = aCallable(C.resolve);
+          var values = [];
+          var counter = 0;
+          var remaining = 1;
+          iterate(iterable, function(promise) {
+            var index2 = counter++;
+            var alreadyCalled = false;
+            remaining++;
+            call4($promiseResolve, C, promise).then(function(value) {
+              if (alreadyCalled) return;
+              alreadyCalled = true;
+              values[index2] = value;
+              --remaining || resolve(values);
+            }, reject);
+          });
+          --remaining || resolve(values);
+        });
+        if (result.error) reject(result.value);
+        return capability.promise;
+      }
+    });
+  }
+});
+
+// node_modules/core-js/modules/es.promise.catch.js
+var require_es_promise_catch = __commonJS({
+  "node_modules/core-js/modules/es.promise.catch.js"() {
+    "use strict";
+    var $8 = require_export();
+    var IS_PURE3 = require_is_pure();
+    var FORCED_PROMISE_CONSTRUCTOR = require_promise_constructor_detection().CONSTRUCTOR;
+    var NativePromiseConstructor = require_promise_native_constructor();
+    var getBuiltIn = require_get_built_in();
+    var isCallable2 = require_is_callable();
+    var defineBuiltIn2 = require_define_built_in();
+    var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;
+    $8({ target: "Promise", proto: true, forced: FORCED_PROMISE_CONSTRUCTOR, real: true }, {
+      "catch": function(onRejected) {
+        return this.then(void 0, onRejected);
+      }
+    });
+    if (!IS_PURE3 && isCallable2(NativePromiseConstructor)) {
+      method = getBuiltIn("Promise").prototype["catch"];
+      if (NativePromisePrototype["catch"] !== method) {
+        defineBuiltIn2(NativePromisePrototype, "catch", method, { unsafe: true });
+      }
+    }
+    var method;
+  }
+});
+
+// node_modules/core-js/modules/es.promise.race.js
+var require_es_promise_race = __commonJS({
+  "node_modules/core-js/modules/es.promise.race.js"() {
+    "use strict";
+    var $8 = require_export();
+    var call4 = require_function_call();
+    var aCallable = require_a_callable();
+    var newPromiseCapabilityModule = require_new_promise_capability();
+    var perform = require_perform();
+    var iterate = require_iterate();
+    var PROMISE_STATICS_INCORRECT_ITERATION = require_promise_statics_incorrect_iteration();
+    $8({ target: "Promise", stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {
+      race: function race(iterable) {
+        var C = this;
+        var capability = newPromiseCapabilityModule.f(C);
+        var reject = capability.reject;
+        var result = perform(function() {
+          var $promiseResolve = aCallable(C.resolve);
+          iterate(iterable, function(promise) {
+            call4($promiseResolve, C, promise).then(capability.resolve, reject);
+          });
+        });
+        if (result.error) reject(result.value);
+        return capability.promise;
+      }
+    });
+  }
+});
+
+// node_modules/core-js/modules/es.promise.reject.js
+var require_es_promise_reject = __commonJS({
+  "node_modules/core-js/modules/es.promise.reject.js"() {
+    "use strict";
+    var $8 = require_export();
+    var newPromiseCapabilityModule = require_new_promise_capability();
+    var FORCED_PROMISE_CONSTRUCTOR = require_promise_constructor_detection().CONSTRUCTOR;
+    $8({ target: "Promise", stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {
+      reject: function reject(r2) {
+        var capability = newPromiseCapabilityModule.f(this);
+        var capabilityReject = capability.reject;
+        capabilityReject(r2);
+        return capability.promise;
+      }
+    });
+  }
+});
+
+// node_modules/core-js/internals/promise-resolve.js
+var require_promise_resolve = __commonJS({
+  "node_modules/core-js/internals/promise-resolve.js"(exports, module) {
+    "use strict";
+    var anObject5 = require_an_object();
+    var isObject = require_is_object();
+    var newPromiseCapability = require_new_promise_capability();
+    module.exports = function(C, x) {
+      anObject5(C);
+      if (isObject(x) && x.constructor === C) return x;
+      var promiseCapability = newPromiseCapability.f(C);
+      var resolve = promiseCapability.resolve;
+      resolve(x);
+      return promiseCapability.promise;
+    };
+  }
+});
+
+// node_modules/core-js/modules/es.promise.resolve.js
+var require_es_promise_resolve = __commonJS({
+  "node_modules/core-js/modules/es.promise.resolve.js"() {
+    "use strict";
+    var $8 = require_export();
+    var getBuiltIn = require_get_built_in();
+    var IS_PURE3 = require_is_pure();
+    var NativePromiseConstructor = require_promise_native_constructor();
+    var FORCED_PROMISE_CONSTRUCTOR = require_promise_constructor_detection().CONSTRUCTOR;
+    var promiseResolve = require_promise_resolve();
+    var PromiseConstructorWrapper = getBuiltIn("Promise");
+    var CHECK_WRAPPER = IS_PURE3 && !FORCED_PROMISE_CONSTRUCTOR;
+    $8({ target: "Promise", stat: true, forced: IS_PURE3 || FORCED_PROMISE_CONSTRUCTOR }, {
+      resolve: function resolve(x) {
+        return promiseResolve(CHECK_WRAPPER && this === PromiseConstructorWrapper ? NativePromiseConstructor : this, x);
+      }
+    });
+  }
+});
+
+// node_modules/core-js/internals/to-string.js
+var require_to_string = __commonJS({
+  "node_modules/core-js/internals/to-string.js"(exports, module) {
+    "use strict";
+    var classof = require_classof();
+    var $String = String;
+    module.exports = function(argument) {
+      if (classof(argument) === "Symbol") throw new TypeError("Cannot convert a Symbol value to a string");
+      return $String(argument);
+    };
+  }
+});
+
+// node_modules/core-js/internals/regexp-flags.js
+var require_regexp_flags = __commonJS({
+  "node_modules/core-js/internals/regexp-flags.js"(exports, module) {
+    "use strict";
+    var anObject5 = require_an_object();
+    module.exports = function() {
+      var that = anObject5(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;
+    };
+  }
+});
+
+// node_modules/core-js/internals/regexp-sticky-helpers.js
+var require_regexp_sticky_helpers = __commonJS({
+  "node_modules/core-js/internals/regexp-sticky-helpers.js"(exports, module) {
+    "use strict";
+    var fails4 = require_fails();
+    var globalThis3 = require_global_this();
+    var $RegExp = globalThis3.RegExp;
+    var UNSUPPORTED_Y2 = fails4(function() {
+      var re = $RegExp("a", "y");
+      re.lastIndex = 2;
+      return re.exec("abcd") !== null;
+    });
+    var MISSED_STICKY = UNSUPPORTED_Y2 || fails4(function() {
+      return !$RegExp("a", "y").sticky;
+    });
+    var BROKEN_CARET = UNSUPPORTED_Y2 || fails4(function() {
+      var re = $RegExp("^r", "gy");
+      re.lastIndex = 2;
+      return re.exec("str") !== null;
+    });
+    module.exports = {
+      BROKEN_CARET,
+      MISSED_STICKY,
+      UNSUPPORTED_Y: UNSUPPORTED_Y2
+    };
+  }
+});
+
+// node_modules/core-js/internals/object-keys.js
+var require_object_keys = __commonJS({
+  "node_modules/core-js/internals/object-keys.js"(exports, module) {
+    "use strict";
+    var internalObjectKeys = require_object_keys_internal();
+    var enumBugKeys = require_enum_bug_keys();
+    module.exports = Object.keys || function keys(O2) {
+      return internalObjectKeys(O2, enumBugKeys);
+    };
+  }
+});
+
+// node_modules/core-js/internals/object-define-properties.js
+var require_object_define_properties = __commonJS({
+  "node_modules/core-js/internals/object-define-properties.js"(exports) {
+    "use strict";
+    var DESCRIPTORS = require_descriptors();
+    var V8_PROTOTYPE_DEFINE_BUG = require_v8_prototype_define_bug();
+    var definePropertyModule = require_object_define_property();
+    var anObject5 = require_an_object();
+    var toIndexedObject = require_to_indexed_object();
+    var objectKeys = require_object_keys();
+    exports.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O2, Properties) {
+      anObject5(O2);
+      var props = toIndexedObject(Properties);
+      var keys = objectKeys(Properties);
+      var length = keys.length;
+      var index2 = 0;
+      var key;
+      while (length > index2) definePropertyModule.f(O2, key = keys[index2++], props[key]);
+      return O2;
+    };
+  }
+});
+
+// node_modules/core-js/internals/object-create.js
+var require_object_create = __commonJS({
+  "node_modules/core-js/internals/object-create.js"(exports, module) {
+    "use strict";
+    var anObject5 = require_an_object();
+    var definePropertiesModule = require_object_define_properties();
+    var enumBugKeys = require_enum_bug_keys();
+    var hiddenKeys = require_hidden_keys();
+    var html = require_html();
+    var documentCreateElement = require_document_create_element();
+    var sharedKey = require_shared_key();
+    var GT = ">";
+    var LT = "<";
+    var PROTOTYPE = "prototype";
+    var SCRIPT = "script";
+    var IE_PROTO = sharedKey("IE_PROTO");
+    var EmptyConstructor = function() {
+    };
+    var scriptTag = function(content) {
+      return LT + SCRIPT + GT + content + LT + "/" + SCRIPT + GT;
+    };
+    var NullProtoObjectViaActiveX = function(activeXDocument2) {
+      activeXDocument2.write(scriptTag(""));
+      activeXDocument2.close();
+      var temp = activeXDocument2.parentWindow.Object;
+      activeXDocument2 = null;
+      return temp;
+    };
+    var NullProtoObjectViaIFrame = function() {
+      var iframe = documentCreateElement("iframe");
+      var JS = "java" + SCRIPT + ":";
+      var iframeDocument;
+      iframe.style.display = "none";
+      html.appendChild(iframe);
+      iframe.src = String(JS);
+      iframeDocument = iframe.contentWindow.document;
+      iframeDocument.open();
+      iframeDocument.write(scriptTag("document.F=Object"));
+      iframeDocument.close();
+      return iframeDocument.F;
+    };
+    var activeXDocument;
+    var NullProtoObject = function() {
+      try {
+        activeXDocument = new ActiveXObject("htmlfile");
+      } catch (error) {
+      }
+      NullProtoObject = typeof document != "undefined" ? document.domain && activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame() : NullProtoObjectViaActiveX(activeXDocument);
+      var length = enumBugKeys.length;
+      while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
+      return NullProtoObject();
+    };
+    hiddenKeys[IE_PROTO] = true;
+    module.exports = Object.create || function create(O2, Properties) {
+      var result;
+      if (O2 !== null) {
+        EmptyConstructor[PROTOTYPE] = anObject5(O2);
+        result = new EmptyConstructor();
+        EmptyConstructor[PROTOTYPE] = null;
+        result[IE_PROTO] = O2;
+      } else result = NullProtoObject();
+      return Properties === void 0 ? result : definePropertiesModule.f(result, Properties);
+    };
+  }
+});
+
+// node_modules/core-js/internals/regexp-unsupported-dot-all.js
+var require_regexp_unsupported_dot_all = __commonJS({
+  "node_modules/core-js/internals/regexp-unsupported-dot-all.js"(exports, module) {
+    "use strict";
+    var fails4 = require_fails();
+    var globalThis3 = require_global_this();
+    var $RegExp = globalThis3.RegExp;
+    module.exports = fails4(function() {
+      var re = $RegExp(".", "s");
+      return !(re.dotAll && re.test("\n") && re.flags === "s");
+    });
+  }
+});
+
+// node_modules/core-js/internals/regexp-unsupported-ncg.js
+var require_regexp_unsupported_ncg = __commonJS({
+  "node_modules/core-js/internals/regexp-unsupported-ncg.js"(exports, module) {
+    "use strict";
+    var fails4 = require_fails();
+    var globalThis3 = require_global_this();
+    var $RegExp = globalThis3.RegExp;
+    module.exports = fails4(function() {
+      var re = $RegExp("(?<a>b)", "g");
+      return re.exec("b").groups.a !== "b" || "b".replace(re, "$<a>c") !== "bc";
+    });
+  }
+});
+
+// node_modules/core-js/internals/regexp-exec.js
+var require_regexp_exec = __commonJS({
+  "node_modules/core-js/internals/regexp-exec.js"(exports, module) {
+    "use strict";
+    var call4 = require_function_call();
+    var uncurryThis8 = require_function_uncurry_this();
+    var toString7 = require_to_string();
+    var regexpFlags = require_regexp_flags();
+    var stickyHelpers2 = require_regexp_sticky_helpers();
+    var shared = require_shared();
+    var create = require_object_create();
+    var getInternalState = require_internal_state().get;
+    var UNSUPPORTED_DOT_ALL = require_regexp_unsupported_dot_all();
+    var UNSUPPORTED_NCG = require_regexp_unsupported_ncg();
+    var nativeReplace = shared("native-string-replace", String.prototype.replace);
+    var nativeExec = RegExp.prototype.exec;
+    var patchedExec = nativeExec;
+    var charAt = uncurryThis8("".charAt);
+    var indexOf2 = uncurryThis8("".indexOf);
+    var replace = uncurryThis8("".replace);
+    var stringSlice4 = uncurryThis8("".slice);
+    var UPDATES_LAST_INDEX_WRONG = function() {
+      var re1 = /a/;
+      var re2 = /b*/g;
+      call4(nativeExec, re1, "a");
+      call4(nativeExec, re2, "a");
+      return re1.lastIndex !== 0 || re2.lastIndex !== 0;
+    }();
+    var UNSUPPORTED_Y2 = stickyHelpers2.BROKEN_CARET;
+    var NPCG_INCLUDED = /()??/.exec("")[1] !== void 0;
+    var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y2 || UNSUPPORTED_DOT_ALL || UNSUPPORTED_NCG;
+    if (PATCH) {
+      patchedExec = function exec(string) {
+        var re = this;
+        var state = getInternalState(re);
+        var str = toString7(string);
+        var raw = state.raw;
+        var result, reCopy, lastIndex, match, i2, object, group;
+        if (raw) {
+          raw.lastIndex = re.lastIndex;
+          result = call4(patchedExec, raw, str);
+          re.lastIndex = raw.lastIndex;
+          return result;
+        }
+        var groups = state.groups;
+        var sticky = UNSUPPORTED_Y2 && re.sticky;
+        var flags = call4(regexpFlags, re);
+        var source = re.source;
+        var charsAdded = 0;
+        var strCopy = str;
+        if (sticky) {
+          flags = replace(flags, "y", "");
+          if (indexOf2(flags, "g") === -1) {
+            flags += "g";
+          }
+          strCopy = stringSlice4(str, re.lastIndex);
+          if (re.lastIndex > 0 && (!re.multiline || re.multiline && charAt(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 = call4(nativeExec, sticky ? reCopy : re, strCopy);
+        if (sticky) {
+          if (match) {
+            match.input = stringSlice4(match.input, charsAdded);
+            match[0] = stringSlice4(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) {
+          call4(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;
+      };
+    }
+    module.exports = patchedExec;
+  }
+});
+
+// node_modules/core-js/modules/es.regexp.exec.js
+var require_es_regexp_exec = __commonJS({
+  "node_modules/core-js/modules/es.regexp.exec.js"() {
+    "use strict";
+    var $8 = require_export();
+    var exec = require_regexp_exec();
+    $8({ target: "RegExp", proto: true, forced: /./.exec !== exec }, {
+      exec
+    });
+  }
+});
+
+// node_modules/core-js/internals/fix-regexp-well-known-symbol-logic.js
+var require_fix_regexp_well_known_symbol_logic = __commonJS({
+  "node_modules/core-js/internals/fix-regexp-well-known-symbol-logic.js"(exports, module) {
+    "use strict";
+    require_es_regexp_exec();
+    var call4 = require_function_call();
+    var defineBuiltIn2 = require_define_built_in();
+    var regexpExec = require_regexp_exec();
+    var fails4 = require_fails();
+    var wellKnownSymbol3 = require_well_known_symbol();
+    var createNonEnumerableProperty2 = require_create_non_enumerable_property();
+    var SPECIES = wellKnownSymbol3("species");
+    var RegExpPrototype2 = RegExp.prototype;
+    module.exports = function(KEY, exec, FORCED3, SHAM) {
+      var SYMBOL = wellKnownSymbol3(KEY);
+      var DELEGATES_TO_SYMBOL = !fails4(function() {
+        var O2 = {};
+        O2[SYMBOL] = function() {
+          return 7;
+        };
+        return ""[KEY](O2) !== 7;
+      });
+      var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails4(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 || FORCED3) {
+        var nativeRegExpMethod = /./[SYMBOL];
+        var methods = exec(SYMBOL, ""[KEY], function(nativeMethod, regexp, str, arg2, forceStringMethod) {
+          var $exec = regexp.exec;
+          if ($exec === regexpExec || $exec === RegExpPrototype2.exec) {
+            if (DELEGATES_TO_SYMBOL && !forceStringMethod) {
+              return { done: true, value: call4(nativeRegExpMethod, regexp, str, arg2) };
+            }
+            return { done: true, value: call4(nativeMethod, str, regexp, arg2) };
+          }
+          return { done: false };
+        });
+        defineBuiltIn2(String.prototype, KEY, methods[0]);
+        defineBuiltIn2(RegExpPrototype2, SYMBOL, methods[1]);
+      }
+      if (SHAM) createNonEnumerableProperty2(RegExpPrototype2[SYMBOL], "sham", true);
+    };
+  }
+});
+
+// node_modules/core-js/internals/string-multibyte.js
+var require_string_multibyte = __commonJS({
+  "node_modules/core-js/internals/string-multibyte.js"(exports, module) {
+    "use strict";
+    var uncurryThis8 = require_function_uncurry_this();
+    var toIntegerOrInfinity2 = require_to_integer_or_infinity();
+    var toString7 = require_to_string();
+    var requireObjectCoercible7 = require_require_object_coercible();
+    var charAt = uncurryThis8("".charAt);
+    var charCodeAt = uncurryThis8("".charCodeAt);
+    var stringSlice4 = uncurryThis8("".slice);
+    var createMethod = function(CONVERT_TO_STRING) {
+      return function($this, pos) {
+        var S = toString7(requireObjectCoercible7($this));
+        var position = toIntegerOrInfinity2(pos);
+        var size = S.length;
+        var first, second;
+        if (position < 0 || position >= size) return CONVERT_TO_STRING ? "" : void 0;
+        first = charCodeAt(S, position);
+        return first < 55296 || first > 56319 || position + 1 === size || (second = charCodeAt(S, position + 1)) < 56320 || second > 57343 ? CONVERT_TO_STRING ? charAt(S, position) : first : CONVERT_TO_STRING ? stringSlice4(S, position, position + 2) : (first - 55296 << 10) + (second - 56320) + 65536;
+      };
+    };
+    module.exports = {
+      // `String.prototype.codePointAt` method
+      // https://tc39.es/ecma262/#sec-string.prototype.codepointat
+      codeAt: createMethod(false),
+      // `String.prototype.at` method
+      // https://github.com/mathiasbynens/String.prototype.at
+      charAt: createMethod(true)
+    };
+  }
+});
+
+// node_modules/core-js/internals/advance-string-index.js
+var require_advance_string_index = __commonJS({
+  "node_modules/core-js/internals/advance-string-index.js"(exports, module) {
+    "use strict";
+    var charAt = require_string_multibyte().charAt;
+    module.exports = function(S, index2, unicode) {
+      return index2 + (unicode ? charAt(S, index2).length : 1);
+    };
+  }
+});
+
+// node_modules/core-js/internals/regexp-exec-abstract.js
+var require_regexp_exec_abstract = __commonJS({
+  "node_modules/core-js/internals/regexp-exec-abstract.js"(exports, module) {
+    "use strict";
+    var call4 = require_function_call();
+    var anObject5 = require_an_object();
+    var isCallable2 = require_is_callable();
+    var classof = require_classof_raw();
+    var regexpExec = require_regexp_exec();
+    var $TypeError = TypeError;
+    module.exports = function(R, S) {
+      var exec = R.exec;
+      if (isCallable2(exec)) {
+        var result = call4(exec, R, S);
+        if (result !== null) anObject5(result);
+        return result;
+      }
+      if (classof(R) === "RegExp") return call4(regexpExec, R, S);
+      throw new $TypeError("RegExp#exec called on incompatible receiver");
+    };
+  }
+});
+
+// node_modules/core-js/internals/get-substitution.js
+var require_get_substitution = __commonJS({
+  "node_modules/core-js/internals/get-substitution.js"(exports, module) {
+    "use strict";
+    var uncurryThis8 = require_function_uncurry_this();
+    var toObject = require_to_object();
+    var floor = Math.floor;
+    var charAt = uncurryThis8("".charAt);
+    var replace = uncurryThis8("".replace);
+    var stringSlice4 = uncurryThis8("".slice);
+    var SUBSTITUTION_SYMBOLS = /\$([$&'`]|\d{1,2}|<[^>]*>)/g;
+    var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&'`]|\d{1,2})/g;
+    module.exports = function(matched, str, position, captures, namedCaptures, replacement) {
+      var tailPos = position + matched.length;
+      var m3 = 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 stringSlice4(str, 0, position);
+          case "'":
+            return stringSlice4(str, tailPos);
+          case "<":
+            capture = namedCaptures[stringSlice4(ch, 1, -1)];
+            break;
+          default:
+            var n2 = +ch;
+            if (n2 === 0) return match;
+            if (n2 > m3) {
+              var f2 = floor(n2 / 10);
+              if (f2 === 0) return match;
+              if (f2 <= m3) 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;
+      });
+    };
+  }
+});
+
+// node_modules/core-js/internals/is-regexp.js
+var require_is_regexp = __commonJS({
+  "node_modules/core-js/internals/is-regexp.js"(exports, module) {
+    "use strict";
+    var isObject = require_is_object();
+    var classof = require_classof_raw();
+    var wellKnownSymbol3 = require_well_known_symbol();
+    var MATCH = wellKnownSymbol3("match");
+    module.exports = function(it) {
+      var isRegExp;
+      return isObject(it) && ((isRegExp = it[MATCH]) !== void 0 ? !!isRegExp : classof(it) === "RegExp");
+    };
+  }
+});
+
+// node_modules/core-js/internals/not-a-regexp.js
+var require_not_a_regexp = __commonJS({
+  "node_modules/core-js/internals/not-a-regexp.js"(exports, module) {
+    "use strict";
+    var isRegExp = require_is_regexp();
+    var $TypeError = TypeError;
+    module.exports = function(it) {
+      if (isRegExp(it)) {
+        throw new $TypeError("The method doesn't accept regular expressions");
+      }
+      return it;
+    };
+  }
+});
+
+// node_modules/core-js/internals/correct-is-regexp-logic.js
+var require_correct_is_regexp_logic = __commonJS({
+  "node_modules/core-js/internals/correct-is-regexp-logic.js"(exports, module) {
+    "use strict";
+    var wellKnownSymbol3 = require_well_known_symbol();
+    var MATCH = wellKnownSymbol3("match");
+    module.exports = function(METHOD_NAME) {
+      var regexp = /./;
+      try {
+        "/./"[METHOD_NAME](regexp);
+      } catch (error1) {
+        try {
+          regexp[MATCH] = false;
+          return "/./"[METHOD_NAME](regexp);
+        } catch (error2) {
+        }
+      }
+      return false;
+    };
+  }
+});
+
+// node_modules/core-js/internals/add-to-unscopables.js
+var require_add_to_unscopables = __commonJS({
+  "node_modules/core-js/internals/add-to-unscopables.js"(exports, module) {
+    "use strict";
+    var wellKnownSymbol3 = require_well_known_symbol();
+    var create = require_object_create();
+    var defineProperty = require_object_define_property().f;
+    var UNSCOPABLES = wellKnownSymbol3("unscopables");
+    var ArrayPrototype = Array.prototype;
+    if (ArrayPrototype[UNSCOPABLES] === void 0) {
+      defineProperty(ArrayPrototype, UNSCOPABLES, {
+        configurable: true,
+        value: create(null)
+      });
+    }
+    module.exports = function(key) {
+      ArrayPrototype[UNSCOPABLES][key] = true;
+    };
+  }
+});
+
+// node_modules/core-js/internals/correct-prototype-getter.js
+var require_correct_prototype_getter = __commonJS({
+  "node_modules/core-js/internals/correct-prototype-getter.js"(exports, module) {
+    "use strict";
+    var fails4 = require_fails();
+    module.exports = !fails4(function() {
+      function F() {
+      }
+      F.prototype.constructor = null;
+      return Object.getPrototypeOf(new F()) !== F.prototype;
+    });
+  }
+});
+
+// node_modules/core-js/internals/object-get-prototype-of.js
+var require_object_get_prototype_of = __commonJS({
+  "node_modules/core-js/internals/object-get-prototype-of.js"(exports, module) {
+    "use strict";
+    var hasOwn = require_has_own_property();
+    var isCallable2 = require_is_callable();
+    var toObject = require_to_object();
+    var sharedKey = require_shared_key();
+    var CORRECT_PROTOTYPE_GETTER = require_correct_prototype_getter();
+    var IE_PROTO = sharedKey("IE_PROTO");
+    var $Object = Object;
+    var ObjectPrototype = $Object.prototype;
+    module.exports = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function(O2) {
+      var object = toObject(O2);
+      if (hasOwn(object, IE_PROTO)) return object[IE_PROTO];
+      var constructor = object.constructor;
+      if (isCallable2(constructor) && object instanceof constructor) {
+        return constructor.prototype;
+      }
+      return object instanceof $Object ? ObjectPrototype : null;
+    };
+  }
+});
+
+// node_modules/core-js/internals/iterators-core.js
+var require_iterators_core = __commonJS({
+  "node_modules/core-js/internals/iterators-core.js"(exports, module) {
+    "use strict";
+    var fails4 = require_fails();
+    var isCallable2 = require_is_callable();
+    var isObject = require_is_object();
+    var create = require_object_create();
+    var getPrototypeOf = require_object_get_prototype_of();
+    var defineBuiltIn2 = require_define_built_in();
+    var wellKnownSymbol3 = require_well_known_symbol();
+    var IS_PURE3 = require_is_pure();
+    var ITERATOR2 = wellKnownSymbol3("iterator");
+    var BUGGY_SAFARI_ITERATORS = false;
+    var IteratorPrototype;
+    var PrototypeOfArrayIteratorPrototype;
+    var arrayIterator;
+    if ([].keys) {
+      arrayIterator = [].keys();
+      if (!("next" in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;
+      else {
+        PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));
+        if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;
+      }
+    }
+    var NEW_ITERATOR_PROTOTYPE = !isObject(IteratorPrototype) || fails4(function() {
+      var test2 = {};
+      return IteratorPrototype[ITERATOR2].call(test2) !== test2;
+    });
+    if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype = {};
+    else if (IS_PURE3) IteratorPrototype = create(IteratorPrototype);
+    if (!isCallable2(IteratorPrototype[ITERATOR2])) {
+      defineBuiltIn2(IteratorPrototype, ITERATOR2, function() {
+        return this;
+      });
+    }
+    module.exports = {
+      IteratorPrototype,
+      BUGGY_SAFARI_ITERATORS
+    };
+  }
+});
+
+// node_modules/core-js/internals/iterator-create-constructor.js
+var require_iterator_create_constructor = __commonJS({
+  "node_modules/core-js/internals/iterator-create-constructor.js"(exports, module) {
+    "use strict";
+    var IteratorPrototype = require_iterators_core().IteratorPrototype;
+    var create = require_object_create();
+    var createPropertyDescriptor = require_create_property_descriptor();
+    var setToStringTag2 = require_set_to_string_tag();
+    var Iterators = require_iterators();
+    var returnThis = function() {
+      return this;
+    };
+    module.exports = function(IteratorConstructor, NAME, next, ENUMERABLE_NEXT) {
+      var TO_STRING_TAG = NAME + " Iterator";
+      IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next) });
+      setToStringTag2(IteratorConstructor, TO_STRING_TAG, false, true);
+      Iterators[TO_STRING_TAG] = returnThis;
+      return IteratorConstructor;
+    };
+  }
+});
+
+// node_modules/core-js/internals/iterator-define.js
+var require_iterator_define = __commonJS({
+  "node_modules/core-js/internals/iterator-define.js"(exports, module) {
+    "use strict";
+    var $8 = require_export();
+    var call4 = require_function_call();
+    var IS_PURE3 = require_is_pure();
+    var FunctionName = require_function_name();
+    var isCallable2 = require_is_callable();
+    var createIteratorConstructor = require_iterator_create_constructor();
+    var getPrototypeOf = require_object_get_prototype_of();
+    var setPrototypeOf = require_object_set_prototype_of();
+    var setToStringTag2 = require_set_to_string_tag();
+    var createNonEnumerableProperty2 = require_create_non_enumerable_property();
+    var defineBuiltIn2 = require_define_built_in();
+    var wellKnownSymbol3 = require_well_known_symbol();
+    var Iterators = require_iterators();
+    var IteratorsCore = require_iterators_core();
+    var PROPER_FUNCTION_NAME2 = FunctionName.PROPER;
+    var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;
+    var IteratorPrototype = IteratorsCore.IteratorPrototype;
+    var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;
+    var ITERATOR2 = wellKnownSymbol3("iterator");
+    var KEYS = "keys";
+    var VALUES = "values";
+    var ENTRIES = "entries";
+    var returnThis = function() {
+      return this;
+    };
+    module.exports = function(Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED3) {
+      createIteratorConstructor(IteratorConstructor, NAME, next);
+      var getIterationMethod = function(KIND) {
+        if (KIND === DEFAULT && defaultIterator) return defaultIterator;
+        if (!BUGGY_SAFARI_ITERATORS && KIND && KIND in IterablePrototype) return IterablePrototype[KIND];
+        switch (KIND) {
+          case KEYS:
+            return function keys() {
+              return new IteratorConstructor(this, KIND);
+            };
+          case VALUES:
+            return function values() {
+              return new IteratorConstructor(this, KIND);
+            };
+          case ENTRIES:
+            return function entries() {
+              return new IteratorConstructor(this, KIND);
+            };
+        }
+        return function() {
+          return new IteratorConstructor(this);
+        };
+      };
+      var TO_STRING_TAG = NAME + " Iterator";
+      var INCORRECT_VALUES_NAME = false;
+      var IterablePrototype = Iterable.prototype;
+      var nativeIterator = IterablePrototype[ITERATOR2] || IterablePrototype["@@iterator"] || DEFAULT && IterablePrototype[DEFAULT];
+      var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);
+      var anyNativeIterator = NAME === "Array" ? IterablePrototype.entries || nativeIterator : nativeIterator;
+      var CurrentIteratorPrototype, methods, KEY;
+      if (anyNativeIterator) {
+        CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));
+        if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {
+          if (!IS_PURE3 && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {
+            if (setPrototypeOf) {
+              setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);
+            } else if (!isCallable2(CurrentIteratorPrototype[ITERATOR2])) {
+              defineBuiltIn2(CurrentIteratorPrototype, ITERATOR2, returnThis);
+            }
+          }
+          setToStringTag2(CurrentIteratorPrototype, TO_STRING_TAG, true, true);
+          if (IS_PURE3) Iterators[TO_STRING_TAG] = returnThis;
+        }
+      }
+      if (PROPER_FUNCTION_NAME2 && DEFAULT === VALUES && nativeIterator && nativeIterator.name !== VALUES) {
+        if (!IS_PURE3 && CONFIGURABLE_FUNCTION_NAME) {
+          createNonEnumerableProperty2(IterablePrototype, "name", VALUES);
+        } else {
+          INCORRECT_VALUES_NAME = true;
+          defaultIterator = function values() {
+            return call4(nativeIterator, this);
+          };
+        }
+      }
+      if (DEFAULT) {
+        methods = {
+          values: getIterationMethod(VALUES),
+          keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),
+          entries: getIterationMethod(ENTRIES)
+        };
+        if (FORCED3) for (KEY in methods) {
+          if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {
+            defineBuiltIn2(IterablePrototype, KEY, methods[KEY]);
+          }
+        }
+        else $8({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);
+      }
+      if ((!IS_PURE3 || FORCED3) && IterablePrototype[ITERATOR2] !== defaultIterator) {
+        defineBuiltIn2(IterablePrototype, ITERATOR2, defaultIterator, { name: DEFAULT });
+      }
+      Iterators[NAME] = defaultIterator;
+      return methods;
+    };
+  }
+});
+
+// node_modules/core-js/internals/create-iter-result-object.js
+var require_create_iter_result_object = __commonJS({
+  "node_modules/core-js/internals/create-iter-result-object.js"(exports, module) {
+    "use strict";
+    module.exports = function(value, done) {
+      return { value, done };
+    };
+  }
+});
+
+// node_modules/core-js/modules/es.array.iterator.js
+var require_es_array_iterator = __commonJS({
+  "node_modules/core-js/modules/es.array.iterator.js"(exports, module) {
+    "use strict";
+    var toIndexedObject = require_to_indexed_object();
+    var addToUnscopables = require_add_to_unscopables();
+    var Iterators = require_iterators();
+    var InternalStateModule = require_internal_state();
+    var defineProperty = require_object_define_property().f;
+    var defineIterator = require_iterator_define();
+    var createIterResultObject = require_create_iter_result_object();
+    var IS_PURE3 = require_is_pure();
+    var DESCRIPTORS = require_descriptors();
+    var ARRAY_ITERATOR = "Array Iterator";
+    var setInternalState = InternalStateModule.set;
+    var getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);
+    module.exports = defineIterator(Array, "Array", function(iterated, kind) {
+      setInternalState(this, {
+        type: ARRAY_ITERATOR,
+        target: toIndexedObject(iterated),
+        // target
+        index: 0,
+        // next index
+        kind
+        // kind
+      });
+    }, function() {
+      var state = getInternalState(this);
+      var target = state.target;
+      var index2 = state.index++;
+      if (!target || index2 >= target.length) {
+        state.target = null;
+        return createIterResultObject(void 0, true);
+      }
+      switch (state.kind) {
+        case "keys":
+          return createIterResultObject(index2, false);
+        case "values":
+          return createIterResultObject(target[index2], false);
+      }
+      return createIterResultObject([index2, target[index2]], false);
+    }, "values");
+    var values = Iterators.Arguments = Iterators.Array;
+    addToUnscopables("keys");
+    addToUnscopables("values");
+    addToUnscopables("entries");
+    if (!IS_PURE3 && DESCRIPTORS && values.name !== "values") try {
+      defineProperty(values, "name", { value: "values" });
+    } catch (error) {
+    }
+  }
+});
+
+// node_modules/core-js/internals/dom-iterables.js
+var require_dom_iterables = __commonJS({
+  "node_modules/core-js/internals/dom-iterables.js"(exports, module) {
+    "use strict";
+    module.exports = {
+      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
+    };
+  }
+});
+
+// node_modules/core-js/internals/dom-token-list-prototype.js
+var require_dom_token_list_prototype = __commonJS({
+  "node_modules/core-js/internals/dom-token-list-prototype.js"(exports, module) {
+    "use strict";
+    var documentCreateElement = require_document_create_element();
+    var classList = documentCreateElement("span").classList;
+    var DOMTokenListPrototype2 = classList && classList.constructor && classList.constructor.prototype;
+    module.exports = DOMTokenListPrototype2 === Object.prototype ? void 0 : DOMTokenListPrototype2;
+  }
+});
+
+// node_modules/core-js/internals/array-reduce.js
+var require_array_reduce = __commonJS({
+  "node_modules/core-js/internals/array-reduce.js"(exports, module) {
+    "use strict";
+    var aCallable = require_a_callable();
+    var toObject = require_to_object();
+    var IndexedObject = require_indexed_object();
+    var lengthOfArrayLike = require_length_of_array_like();
+    var $TypeError = TypeError;
+    var REDUCE_EMPTY = "Reduce of empty array with no initial value";
+    var createMethod = function(IS_RIGHT) {
+      return function(that, callbackfn, argumentsLength, memo) {
+        var O2 = toObject(that);
+        var self2 = IndexedObject(O2);
+        var length = lengthOfArrayLike(O2);
+        aCallable(callbackfn);
+        if (length === 0 && argumentsLength < 2) throw new $TypeError(REDUCE_EMPTY);
+        var index2 = IS_RIGHT ? length - 1 : 0;
+        var i2 = IS_RIGHT ? -1 : 1;
+        if (argumentsLength < 2) while (true) {
+          if (index2 in self2) {
+            memo = self2[index2];
+            index2 += i2;
+            break;
+          }
+          index2 += i2;
+          if (IS_RIGHT ? index2 < 0 : length <= index2) {
+            throw new $TypeError(REDUCE_EMPTY);
+          }
+        }
+        for (; IS_RIGHT ? index2 >= 0 : length > index2; index2 += i2) if (index2 in self2) {
+          memo = callbackfn(memo, self2[index2], index2, O2);
+        }
+        return memo;
+      };
+    };
+    module.exports = {
+      // `Array.prototype.reduce` method
+      // https://tc39.es/ecma262/#sec-array.prototype.reduce
+      left: createMethod(false),
+      // `Array.prototype.reduceRight` method
+      // https://tc39.es/ecma262/#sec-array.prototype.reduceright
+      right: createMethod(true)
+    };
+  }
+});
+
+// node_modules/core-js/internals/array-method-is-strict.js
+var require_array_method_is_strict = __commonJS({
+  "node_modules/core-js/internals/array-method-is-strict.js"(exports, module) {
+    "use strict";
+    var fails4 = require_fails();
+    module.exports = function(METHOD_NAME, argument) {
+      var method = [][METHOD_NAME];
+      return !!method && fails4(function() {
+        method.call(null, argument || function() {
+          return 1;
+        }, 1);
+      });
+    };
+  }
+});
+
+// node_modules/performance-now/lib/performance-now.js
+var require_performance_now = __commonJS({
+  "node_modules/performance-now/lib/performance-now.js"(exports, module) {
+    (function() {
+      var getNanoSeconds, hrtime, loadTime, moduleLoadTime, nodeLoadTime, upTime;
+      if (typeof performance !== "undefined" && performance !== null && performance.now) {
+        module.exports = function() {
+          return performance.now();
+        };
+      } else if (typeof process !== "undefined" && process !== null && process.hrtime) {
+        module.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) {
+        module.exports = function() {
+          return Date.now() - loadTime;
+        };
+        loadTime = Date.now();
+      } else {
+        module.exports = function() {
+          return (/* @__PURE__ */ new Date()).getTime() - loadTime;
+        };
+        loadTime = (/* @__PURE__ */ new Date()).getTime();
+      }
+    }).call(exports);
+  }
+});
+
+// node_modules/raf/index.js
+var require_raf = __commonJS({
+  "node_modules/raf/index.js"(exports, module) {
+    var now = require_performance_now();
+    var root = typeof window === "undefined" ? global : window;
+    var vendors = ["moz", "webkit"];
+    var suffix = "AnimationFrame";
+    var raf = root["request" + suffix];
+    var caf = root["cancel" + suffix] || root["cancelRequest" + suffix];
+    for (i2 = 0; !raf && i2 < vendors.length; i2++) {
+      raf = root[vendors[i2] + "Request" + suffix];
+      caf = root[vendors[i2] + "Cancel" + suffix] || root[vendors[i2] + "CancelRequest" + suffix];
+    }
+    var i2;
+    if (!raf || !caf) {
+      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 i3 = 0; i3 < cp.length; i3++) {
+              if (!cp[i3].cancelled) {
+                try {
+                  cp[i3].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 i3 = 0; i3 < queue.length; i3++) {
+          if (queue[i3].handle === handle) {
+            queue[i3].cancelled = true;
+          }
+        }
+      };
+    }
+    var last;
+    var id;
+    var queue;
+    var frameDuration;
+    module.exports = function(fn) {
+      return raf.call(root, fn);
+    };
+    module.exports.cancel = function() {
+      caf.apply(root, arguments);
+    };
+    module.exports.polyfill = function(object) {
+      if (!object) {
+        object = root;
+      }
+      object.requestAnimationFrame = raf;
+      object.cancelAnimationFrame = caf;
+    };
+  }
+});
+
+// node_modules/core-js/internals/whitespaces.js
+var require_whitespaces = __commonJS({
+  "node_modules/core-js/internals/whitespaces.js"(exports, module) {
+    "use strict";
+    module.exports = "	\n\v\f\r                　\u2028\u2029\uFEFF";
+  }
+});
+
+// node_modules/core-js/internals/string-trim.js
+var require_string_trim = __commonJS({
+  "node_modules/core-js/internals/string-trim.js"(exports, module) {
+    "use strict";
+    var uncurryThis8 = require_function_uncurry_this();
+    var requireObjectCoercible7 = require_require_object_coercible();
+    var toString7 = require_to_string();
+    var whitespaces = require_whitespaces();
+    var replace = uncurryThis8("".replace);
+    var ltrim = RegExp("^[" + whitespaces + "]+");
+    var rtrim = RegExp("(^|[^" + whitespaces + "])[" + whitespaces + "]+$");
+    var createMethod = function(TYPE) {
+      return function($this) {
+        var string = toString7(requireObjectCoercible7($this));
+        if (TYPE & 1) string = replace(string, ltrim, "");
+        if (TYPE & 2) string = replace(string, rtrim, "$1");
+        return string;
+      };
+    };
+    module.exports = {
+      // `String.prototype.{ trimLeft, trimStart }` methods
+      // https://tc39.es/ecma262/#sec-string.prototype.trimstart
+      start: createMethod(1),
+      // `String.prototype.{ trimRight, trimEnd }` methods
+      // https://tc39.es/ecma262/#sec-string.prototype.trimend
+      end: createMethod(2),
+      // `String.prototype.trim` method
+      // https://tc39.es/ecma262/#sec-string.prototype.trim
+      trim: createMethod(3)
+    };
+  }
+});
+
+// node_modules/core-js/internals/string-trim-forced.js
+var require_string_trim_forced = __commonJS({
+  "node_modules/core-js/internals/string-trim-forced.js"(exports, module) {
+    "use strict";
+    var PROPER_FUNCTION_NAME2 = require_function_name().PROPER;
+    var fails4 = require_fails();
+    var whitespaces = require_whitespaces();
+    var non = "​
+᠎";
+    module.exports = function(METHOD_NAME) {
+      return fails4(function() {
+        return !!whitespaces[METHOD_NAME]() || non[METHOD_NAME]() !== non || PROPER_FUNCTION_NAME2 && whitespaces[METHOD_NAME].name !== METHOD_NAME;
+      });
+    };
+  }
+});
+
+// node_modules/rgbcolor/index.js
+var require_rgbcolor = __commonJS({
+  "node_modules/rgbcolor/index.js"(exports, module) {
+    module.exports = 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;
+      };
+    };
+  }
+});
+
+// node_modules/core-js/internals/is-array.js
+var require_is_array = __commonJS({
+  "node_modules/core-js/internals/is-array.js"(exports, module) {
+    "use strict";
+    var classof = require_classof_raw();
+    module.exports = Array.isArray || function isArray2(argument) {
+      return classof(argument) === "Array";
+    };
+  }
+});
+
+// node_modules/core-js/internals/regexp-get-flags.js
+var require_regexp_get_flags = __commonJS({
+  "node_modules/core-js/internals/regexp-get-flags.js"(exports, module) {
+    "use strict";
+    var call4 = require_function_call();
+    var hasOwn = require_has_own_property();
+    var isPrototypeOf = require_object_is_prototype_of();
+    var regExpFlags = require_regexp_flags();
+    var RegExpPrototype2 = RegExp.prototype;
+    module.exports = function(R) {
+      var flags = R.flags;
+      return flags === void 0 && !("flags" in RegExpPrototype2) && !hasOwn(R, "flags") && isPrototypeOf(RegExpPrototype2, R) ? call4(regExpFlags, R) : flags;
+    };
+  }
+});
+
+// node_modules/core-js/modules/es.promise.js
+require_es_promise_constructor();
+require_es_promise_all();
+require_es_promise_catch();
+require_es_promise_race();
+require_es_promise_reject();
+require_es_promise_resolve();
+
+// node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js
+function asyncGeneratorStep(n2, t2, e2, r2, o2, a2, c3) {
+  try {
+    var i2 = n2[a2](c3), u2 = i2.value;
+  } catch (n3) {
+    return void e2(n3);
+  }
+  i2.done ? t2(u2) : Promise.resolve(u2).then(r2, o2);
+}
+function _asyncToGenerator(n2) {
+  return function() {
+    var t2 = this, e2 = arguments;
+    return new Promise(function(r2, o2) {
+      var a2 = n2.apply(t2, e2);
+      function _next(n3) {
+        asyncGeneratorStep(a2, r2, o2, _next, _throw, "next", n3);
+      }
+      function _throw(n3) {
+        asyncGeneratorStep(a2, r2, o2, _next, _throw, "throw", n3);
+      }
+      _next(void 0);
+    });
+  };
+}
+
+// node_modules/core-js/modules/es.string.match.js
+var call = require_function_call();
+var fixRegExpWellKnownSymbolLogic = require_fix_regexp_well_known_symbol_logic();
+var anObject = require_an_object();
+var isNullOrUndefined = require_is_null_or_undefined();
+var toLength = require_to_length();
+var toString = require_to_string();
+var requireObjectCoercible = require_require_object_coercible();
+var getMethod = require_get_method();
+var advanceStringIndex = require_advance_string_index();
+var regExpExec = require_regexp_exec_abstract();
+fixRegExpWellKnownSymbolLogic("match", function(MATCH, nativeMatch, maybeCallNative) {
+  return [
+    // `String.prototype.match` method
+    // https://tc39.es/ecma262/#sec-string.prototype.match
+    function match(regexp) {
+      var O2 = requireObjectCoercible(this);
+      var matcher = isNullOrUndefined(regexp) ? void 0 : getMethod(regexp, MATCH);
+      return matcher ? call(matcher, regexp, O2) : new RegExp(regexp)[MATCH](toString(O2));
+    },
+    // `RegExp.prototype[@@match]` method
+    // https://tc39.es/ecma262/#sec-regexp.prototype-@@match
+    function(string) {
+      var rx = anObject(this);
+      var S = toString(string);
+      var res = maybeCallNative(nativeMatch, rx, S);
+      if (res.done) return res.value;
+      if (!rx.global) return regExpExec(rx, S);
+      var fullUnicode = rx.unicode;
+      rx.lastIndex = 0;
+      var A = [];
+      var n2 = 0;
+      var result;
+      while ((result = regExpExec(rx, S)) !== null) {
+        var matchStr = toString(result[0]);
+        A[n2] = matchStr;
+        if (matchStr === "") rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);
+        n2++;
+      }
+      return n2 === 0 ? null : A;
+    }
+  ];
+});
+
+// node_modules/core-js/modules/es.string.replace.js
+var apply = require_function_apply();
+var call2 = require_function_call();
+var uncurryThis = require_function_uncurry_this();
+var fixRegExpWellKnownSymbolLogic2 = require_fix_regexp_well_known_symbol_logic();
+var fails = require_fails();
+var anObject2 = require_an_object();
+var isCallable = require_is_callable();
+var isNullOrUndefined2 = require_is_null_or_undefined();
+var toIntegerOrInfinity = require_to_integer_or_infinity();
+var toLength2 = require_to_length();
+var toString2 = require_to_string();
+var requireObjectCoercible2 = require_require_object_coercible();
+var advanceStringIndex2 = require_advance_string_index();
+var getMethod2 = require_get_method();
+var getSubstitution = require_get_substitution();
+var regExpExec2 = require_regexp_exec_abstract();
+var wellKnownSymbol = require_well_known_symbol();
+var REPLACE = wellKnownSymbol("replace");
+var max = Math.max;
+var min = Math.min;
+var concat = uncurryThis([].concat);
+var push = uncurryThis([].push);
+var stringIndexOf = uncurryThis("".indexOf);
+var stringSlice = uncurryThis("".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(function() {
+  var re = /./;
+  re.exec = function() {
+    var result = [];
+    result.groups = { a: "7" };
+    return result;
+  };
+  return "".replace(re, "$<a>") !== "7";
+});
+fixRegExpWellKnownSymbolLogic2("replace", function(_2, nativeReplace, maybeCallNative) {
+  var UNSAFE_SUBSTITUTE = REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE ? "$" : "$0";
+  return [
+    // `String.prototype.replace` method
+    // https://tc39.es/ecma262/#sec-string.prototype.replace
+    function replace(searchValue, replaceValue) {
+      var O2 = requireObjectCoercible2(this);
+      var replacer = isNullOrUndefined2(searchValue) ? void 0 : getMethod2(searchValue, REPLACE);
+      return replacer ? call2(replacer, searchValue, O2, replaceValue) : call2(nativeReplace, toString2(O2), searchValue, replaceValue);
+    },
+    // `RegExp.prototype[@@replace]` method
+    // https://tc39.es/ecma262/#sec-regexp.prototype-@@replace
+    function(string, replaceValue) {
+      var rx = anObject2(this);
+      var S = toString2(string);
+      if (typeof replaceValue == "string" && stringIndexOf(replaceValue, UNSAFE_SUBSTITUTE) === -1 && stringIndexOf(replaceValue, "$<") === -1) {
+        var res = maybeCallNative(nativeReplace, rx, S, replaceValue);
+        if (res.done) return res.value;
+      }
+      var functionalReplace = isCallable(replaceValue);
+      if (!functionalReplace) replaceValue = toString2(replaceValue);
+      var global2 = rx.global;
+      var fullUnicode;
+      if (global2) {
+        fullUnicode = rx.unicode;
+        rx.lastIndex = 0;
+      }
+      var results = [];
+      var result;
+      while (true) {
+        result = regExpExec2(rx, S);
+        if (result === null) break;
+        push(results, result);
+        if (!global2) break;
+        var matchStr = toString2(result[0]);
+        if (matchStr === "") rx.lastIndex = advanceStringIndex2(S, toLength2(rx.lastIndex), fullUnicode);
+      }
+      var accumulatedResult = "";
+      var nextSourcePosition = 0;
+      for (var i2 = 0; i2 < results.length; i2++) {
+        result = results[i2];
+        var matched = toString2(result[0]);
+        var position = max(min(toIntegerOrInfinity(result.index), S.length), 0);
+        var captures = [];
+        var replacement;
+        for (var j = 1; j < result.length; j++) push(captures, maybeToString(result[j]));
+        var namedCaptures = result.groups;
+        if (functionalReplace) {
+          var replacerArgs = concat([matched], captures, position, S);
+          if (namedCaptures !== void 0) push(replacerArgs, namedCaptures);
+          replacement = toString2(apply(replaceValue, void 0, replacerArgs));
+        } else {
+          replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue);
+        }
+        if (position >= nextSourcePosition) {
+          accumulatedResult += stringSlice(S, nextSourcePosition, position) + replacement;
+          nextSourcePosition = position + matched.length;
+        }
+      }
+      return accumulatedResult + stringSlice(S, nextSourcePosition);
+    }
+  ];
+}, !REPLACE_SUPPORTS_NAMED_GROUPS || !REPLACE_KEEPS_$0 || REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE);
+
+// node_modules/core-js/modules/es.string.starts-with.js
+var $ = require_export();
+var uncurryThis2 = require_function_uncurry_this_clause();
+var getOwnPropertyDescriptor = require_object_get_own_property_descriptor().f;
+var toLength3 = require_to_length();
+var toString3 = require_to_string();
+var notARegExp = require_not_a_regexp();
+var requireObjectCoercible3 = require_require_object_coercible();
+var correctIsRegExpLogic = require_correct_is_regexp_logic();
+var IS_PURE = require_is_pure();
+var stringSlice2 = uncurryThis2("".slice);
+var min2 = Math.min;
+var CORRECT_IS_REGEXP_LOGIC = correctIsRegExpLogic("startsWith");
+var MDN_POLYFILL_BUG = !IS_PURE && !CORRECT_IS_REGEXP_LOGIC && !!function() {
+  var descriptor = getOwnPropertyDescriptor(String.prototype, "startsWith");
+  return descriptor && !descriptor.writable;
+}();
+$({ target: "String", proto: true, forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC }, {
+  startsWith: function startsWith(searchString) {
+    var that = toString3(requireObjectCoercible3(this));
+    notARegExp(searchString);
+    var index2 = toLength3(min2(arguments.length > 1 ? arguments[1] : void 0, that.length));
+    var search = toString3(searchString);
+    return stringSlice2(that, index2, index2 + search.length) === search;
+  }
+});
+
+// node_modules/canvg/lib/index.es.js
+var import_es_array_iterator = __toESM(require_es_array_iterator());
+
+// node_modules/core-js/modules/web.dom-collections.iterator.js
+var globalThis2 = require_global_this();
+var DOMIterables = require_dom_iterables();
+var DOMTokenListPrototype = require_dom_token_list_prototype();
+var ArrayIteratorMethods = require_es_array_iterator();
+var createNonEnumerableProperty = require_create_non_enumerable_property();
+var setToStringTag = require_set_to_string_tag();
+var wellKnownSymbol2 = require_well_known_symbol();
+var ITERATOR = wellKnownSymbol2("iterator");
+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;
+    }
+    setToStringTag(CollectionPrototype, COLLECTION_NAME, true);
+    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 (COLLECTION_NAME in DOMIterables) {
+  handlePrototype(globalThis2[COLLECTION_NAME] && globalThis2[COLLECTION_NAME].prototype, COLLECTION_NAME);
+}
+var COLLECTION_NAME;
+handlePrototype(DOMTokenListPrototype, "DOMTokenList");
+
+// node_modules/@babel/runtime/helpers/esm/toPrimitive.js
+function toPrimitive(t2, r2) {
+  if ("object" != _typeof(t2) || !t2) return t2;
+  var e2 = t2[Symbol.toPrimitive];
+  if (void 0 !== e2) {
+    var i2 = e2.call(t2, r2 || "default");
+    if ("object" != _typeof(i2)) return i2;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r2 ? String : Number)(t2);
+}
+
+// node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
+function toPropertyKey(t2) {
+  var i2 = toPrimitive(t2, "string");
+  return "symbol" == _typeof(i2) ? i2 : i2 + "";
+}
+
+// node_modules/@babel/runtime/helpers/esm/defineProperty.js
+function _defineProperty(e2, r2, t2) {
+  return (r2 = toPropertyKey(r2)) in e2 ? Object.defineProperty(e2, r2, {
+    value: t2,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  }) : e2[r2] = t2, e2;
+}
+
+// node_modules/core-js/modules/es.array.reduce.js
+var $2 = require_export();
+var $reduce = require_array_reduce().left;
+var arrayMethodIsStrict = require_array_method_is_strict();
+var CHROME_VERSION = require_environment_v8_version();
+var IS_NODE = require_environment_is_node();
+var CHROME_BUG = !IS_NODE && CHROME_VERSION > 79 && CHROME_VERSION < 83;
+var FORCED = CHROME_BUG || !arrayMethodIsStrict("reduce");
+$2({ target: "Array", proto: true, forced: FORCED }, {
+  reduce: function reduce(callbackfn) {
+    var length = arguments.length;
+    return $reduce(this, callbackfn, length, length > 1 ? arguments[1] : void 0);
+  }
+});
+
+// node_modules/core-js/modules/es.string.ends-with.js
+var $3 = require_export();
+var uncurryThis3 = require_function_uncurry_this_clause();
+var getOwnPropertyDescriptor2 = require_object_get_own_property_descriptor().f;
+var toLength4 = require_to_length();
+var toString4 = require_to_string();
+var notARegExp2 = require_not_a_regexp();
+var requireObjectCoercible4 = require_require_object_coercible();
+var correctIsRegExpLogic2 = require_correct_is_regexp_logic();
+var IS_PURE2 = require_is_pure();
+var slice = uncurryThis3("".slice);
+var min3 = Math.min;
+var CORRECT_IS_REGEXP_LOGIC2 = correctIsRegExpLogic2("endsWith");
+var MDN_POLYFILL_BUG2 = !IS_PURE2 && !CORRECT_IS_REGEXP_LOGIC2 && !!function() {
+  var descriptor = getOwnPropertyDescriptor2(String.prototype, "endsWith");
+  return descriptor && !descriptor.writable;
+}();
+$3({ target: "String", proto: true, forced: !MDN_POLYFILL_BUG2 && !CORRECT_IS_REGEXP_LOGIC2 }, {
+  endsWith: function endsWith(searchString) {
+    var that = toString4(requireObjectCoercible4(this));
+    notARegExp2(searchString);
+    var endPosition = arguments.length > 1 ? arguments[1] : void 0;
+    var len = that.length;
+    var end = endPosition === void 0 ? len : min3(toLength4(endPosition), len);
+    var search = toString4(searchString);
+    return slice(that, end - search.length, end) === search;
+  }
+});
+
+// node_modules/core-js/modules/es.string.split.js
+var call3 = require_function_call();
+var uncurryThis4 = require_function_uncurry_this();
+var fixRegExpWellKnownSymbolLogic3 = require_fix_regexp_well_known_symbol_logic();
+var anObject3 = require_an_object();
+var isNullOrUndefined3 = require_is_null_or_undefined();
+var requireObjectCoercible5 = require_require_object_coercible();
+var speciesConstructor = require_species_constructor();
+var advanceStringIndex3 = require_advance_string_index();
+var toLength5 = require_to_length();
+var toString5 = require_to_string();
+var getMethod3 = require_get_method();
+var regExpExec3 = require_regexp_exec_abstract();
+var stickyHelpers = require_regexp_sticky_helpers();
+var fails2 = require_fails();
+var UNSUPPORTED_Y = stickyHelpers.UNSUPPORTED_Y;
+var MAX_UINT32 = 4294967295;
+var min4 = Math.min;
+var push2 = uncurryThis4([].push);
+var stringSlice3 = uncurryThis4("".slice);
+var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = !fails2(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";
+});
+var BUGGY = "abbc".split(/(b)*/)[1] === "c" || // eslint-disable-next-line regexp/no-empty-group -- required for testing
+"test".split(/(?:)/, -1).length !== 4 || "ab".split(/(?:ab)*/).length !== 2 || ".".split(/(.?)(.?)/).length !== 4 || // eslint-disable-next-line regexp/no-empty-capturing-group, regexp/no-empty-group -- required for testing
+".".split(/()()/).length > 1 || "".split(/.?/).length;
+fixRegExpWellKnownSymbolLogic3("split", function(SPLIT, nativeSplit, maybeCallNative) {
+  var internalSplit = "0".split(void 0, 0).length ? function(separator, limit) {
+    return separator === void 0 && limit === 0 ? [] : call3(nativeSplit, this, separator, limit);
+  } : nativeSplit;
+  return [
+    // `String.prototype.split` method
+    // https://tc39.es/ecma262/#sec-string.prototype.split
+    function split(separator, limit) {
+      var O2 = requireObjectCoercible5(this);
+      var splitter = isNullOrUndefined3(separator) ? void 0 : getMethod3(separator, SPLIT);
+      return splitter ? call3(splitter, separator, O2, limit) : call3(internalSplit, toString5(O2), separator, limit);
+    },
+    // `RegExp.prototype[@@split]` method
+    // https://tc39.es/ecma262/#sec-regexp.prototype-@@split
+    //
+    // NOTE: This cannot be properly polyfilled in engines that don't support
+    // the 'y' flag.
+    function(string, limit) {
+      var rx = anObject3(this);
+      var S = toString5(string);
+      if (!BUGGY) {
+        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 regExpExec3(splitter, S) === null ? [S] : [];
+      var p2 = 0;
+      var q = 0;
+      var A = [];
+      while (q < S.length) {
+        splitter.lastIndex = UNSUPPORTED_Y ? 0 : q;
+        var z = regExpExec3(splitter, UNSUPPORTED_Y ? stringSlice3(S, q) : S);
+        var e2;
+        if (z === null || (e2 = min4(toLength5(splitter.lastIndex + (UNSUPPORTED_Y ? q : 0)), S.length)) === p2) {
+          q = advanceStringIndex3(S, q, unicodeMatching);
+        } else {
+          push2(A, stringSlice3(S, p2, q));
+          if (A.length === lim) return A;
+          for (var i2 = 1; i2 <= z.length - 1; i2++) {
+            push2(A, z[i2]);
+            if (A.length === lim) return A;
+          }
+          q = p2 = e2;
+        }
+      }
+      push2(A, stringSlice3(S, p2));
+      return A;
+    }
+  ];
+}, BUGGY || !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC, UNSUPPORTED_Y);
+
+// node_modules/canvg/lib/index.es.js
+var import_raf = __toESM(require_raf());
+
+// node_modules/core-js/modules/es.string.trim.js
+var $4 = require_export();
+var $trim = require_string_trim().trim;
+var forcedStringTrimMethod = require_string_trim_forced();
+$4({ target: "String", proto: true, forced: forcedStringTrimMethod("trim") }, {
+  trim: function trim() {
+    return $trim(this);
+  }
+});
+
+// node_modules/canvg/lib/index.es.js
+var import_rgbcolor = __toESM(require_rgbcolor());
+
+// node_modules/core-js/modules/es.array.index-of.js
+var $5 = require_export();
+var uncurryThis5 = require_function_uncurry_this_clause();
+var $indexOf = require_array_includes().indexOf;
+var arrayMethodIsStrict2 = require_array_method_is_strict();
+var nativeIndexOf = uncurryThis5([].indexOf);
+var NEGATIVE_ZERO = !!nativeIndexOf && 1 / nativeIndexOf([1], 1, -0) < 0;
+var FORCED2 = NEGATIVE_ZERO || !arrayMethodIsStrict2("indexOf");
+$5({ target: "Array", proto: true, forced: FORCED2 }, {
+  indexOf: function indexOf(searchElement) {
+    var fromIndex = arguments.length > 1 ? arguments[1] : void 0;
+    return NEGATIVE_ZERO ? nativeIndexOf(this, searchElement, fromIndex) || 0 : $indexOf(this, searchElement, fromIndex);
+  }
+});
+
+// node_modules/core-js/modules/es.string.includes.js
+var $6 = require_export();
+var uncurryThis6 = require_function_uncurry_this();
+var notARegExp3 = require_not_a_regexp();
+var requireObjectCoercible6 = require_require_object_coercible();
+var toString6 = require_to_string();
+var correctIsRegExpLogic3 = require_correct_is_regexp_logic();
+var stringIndexOf2 = uncurryThis6("".indexOf);
+$6({ target: "String", proto: true, forced: !correctIsRegExpLogic3("includes") }, {
+  includes: function includes(searchString) {
+    return !!~stringIndexOf2(
+      toString6(requireObjectCoercible6(this)),
+      toString6(notARegExp3(searchString)),
+      arguments.length > 1 ? arguments[1] : void 0
+    );
+  }
+});
+
+// node_modules/core-js/modules/es.array.reverse.js
+var $7 = require_export();
+var uncurryThis7 = require_function_uncurry_this();
+var isArray = require_is_array();
+var nativeReverse = uncurryThis7([].reverse);
+var test = [1, 2];
+$7({ target: "Array", proto: true, forced: String(test) === String(test.reverse()) }, {
+  reverse: function reverse() {
+    if (isArray(this)) this.length = this.length;
+    return nativeReverse(this);
+  }
+});
+
+// node_modules/svg-pathdata/lib/SVGPathData.module.js
+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), c3 = h2[0], y2 = h2[1], p2 = Math.pow(c3, 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 m3 = Math.pow(a2, 2) * Math.pow(y2, 2) + Math.pow(o2, 2) * Math.pow(c3, 2), O2 = (t2.lArcFlag !== t2.sweepFlag ? 1 : -1) * Math.sqrt(Math.max(0, (Math.pow(a2, 2) * Math.pow(o2, 2) - m3) / m3)), l2 = a2 * y2 / o2 * O2, T2 = -o2 * c3 / 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, (c3 - l2) / a2), t2.phi2 = Math.atan2((-y2 - T2) / o2, (-c3 - 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;
+var h = Math.PI / 180;
+function c(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(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 c3 = a2.x1, y2 = a2.x2, p2 = a2.relative && !isNaN(h2), m3 = 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 = m3 * 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 = c3 * 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 c3 = Math.abs, y2 = false, p2 = 0, m3 = 0;
+      if (a2.type & _.SMOOTH_CURVE_TO && (p2 = isNaN(r3) ? 0 : o2 - r3, m3 = 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, m3 = isNaN(n3) ? void 0 === a2.y1 ? m3 : 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;
+        c3(O3) <= t3 && c3(l3) <= t3 && c3(p2) <= t3 && c3(m3) <= t3 && c3(T2) <= t3 && c3(v2) <= t3 && (y2 = true);
+      }
+      return a2.type & _.CLOSE_PATH && c3(o2 - u3) <= t3 && c3(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, m3 = Math.ceil(p2 / 90), O3 = new Array(m3), l3 = r4, T2 = e4, v2 = 0; v2 < m3; v2++) {
+          var f2 = c(t4.phi1, t4.phi2, v2 / m3), N2 = c(t4.phi1, t4.phi2, (v2 + 1) / m3), 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(), c3 = u2(function(r3, e3, n3) {
+      var u3 = h2(a2(i2(t3(r3))));
+      function O3(t4) {
+        t4 > c3.maxX && (c3.maxX = t4), t4 < c3.minX && (c3.minX = t4);
+      }
+      function l3(t4) {
+        t4 > c3.maxY && (c3.maxY = t4), t4 < c3.minY && (c3.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(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(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 c3.minX = 1 / 0, c3.maxX = -1 / 0, c3.minY = 1 / 0, c3.maxY = -1 / 0, c3;
+  };
+}(u || (u = {}));
+var O;
+var 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;
+}();
+var T = function(t2) {
+  return " " === t2 || "	" === t2 || "\r" === t2 || "\n" === t2;
+};
+var v = function(t2) {
+  return "0".charCodeAt(0) <= t2.charCodeAt(0) && t2.charCodeAt(0) <= "9".charCodeAt(0);
+};
+var 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);
+var _ = 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);
+var 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);
+
+// node_modules/core-js/modules/es.regexp.to-string.js
+var PROPER_FUNCTION_NAME = require_function_name().PROPER;
+var defineBuiltIn = require_define_built_in();
+var anObject4 = require_an_object();
+var $toString = require_to_string();
+var fails3 = require_fails();
+var getRegExpFlags = require_regexp_get_flags();
+var TO_STRING = "toString";
+var RegExpPrototype = RegExp.prototype;
+var nativeToString = RegExpPrototype[TO_STRING];
+var NOT_GENERIC = fails3(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(RegExpPrototype, TO_STRING, function toString7() {
+    var R = anObject4(this);
+    var pattern = $toString(R.source);
+    var flags = $toString(getRegExpFlags(R));
+    return "/" + pattern + "/" + flags;
+  }, { unsafe: true });
+}
+
+// node_modules/stackblur-canvas/dist/stackblur-es.js
+function _typeof2(obj) {
+  "@babel/helpers - typeof";
+  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+    _typeof2 = function(obj2) {
+      return typeof obj2;
+    };
+  } else {
+    _typeof2 = function(obj2) {
+      return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+    };
+  }
+  return _typeof2(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 || _typeof2(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 = (
+  /**
+   * Set properties.
+   */
+  function BlurStack2() {
+    _classCallCheck(this, BlurStack2);
+    this.r = 0;
+    this.g = 0;
+    this.b = 0;
+    this.a = 0;
+    this.next = null;
+  }
+);
+
+// node_modules/canvg/lib/index.es.js
+function offscreen() {
+  var {
+    DOMParser: DOMParserFallback
+  } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+  var preset = {
+    window: null,
+    ignoreAnimation: true,
+    ignoreMouse: true,
+    DOMParser: DOMParserFallback,
+    createCanvas(width, height) {
+      return new OffscreenCanvas(width, height);
+    },
+    createImage(url) {
+      return _asyncToGenerator(function* () {
+        var response = yield fetch(url);
+        var blob = yield response.blob();
+        var img = yield createImageBitmap(blob);
+        return img;
+      })();
+    }
+  };
+  if (typeof DOMParser !== "undefined" || typeof DOMParserFallback === "undefined") {
+    Reflect.deleteProperty(preset, "DOMParser");
+  }
+  return preset;
+}
+function node(_ref) {
+  var {
+    DOMParser: DOMParser2,
+    canvas,
+    fetch: fetch2
+  } = _ref;
+  return {
+    window: null,
+    ignoreAnimation: true,
+    ignoreMouse: true,
+    DOMParser: DOMParser2,
+    fetch: fetch2,
+    createCanvas: canvas.createCanvas,
+    createImage: canvas.loadImage
+  };
+}
+var index = Object.freeze({
+  __proto__: null,
+  offscreen,
+  node
+});
+function compressSpaces(str) {
+  return str.replace(/(?!\u3000)\s+/gm, " ");
+}
+function trimLeft(str) {
+  return str.replace(/^[\n \t]+/, "");
+}
+function trimRight(str) {
+  return str.replace(/[\n \t]+$/, "");
+}
+function toNumbers(str) {
+  var matches = (str || "").match(/-?(\d+(?:\.\d*(?:[eE][+-]?\d+)?)?|\.\d+)(?=\D|$)/gm) || [];
+  return matches.map(parseFloat);
+}
+var allUppercase = /^[A-Z-]+$/;
+function normalizeAttributeName(name) {
+  if (allUppercase.test(name)) {
+    return name.toLowerCase();
+  }
+  return name;
+}
+function parseExternalUrl(url) {
+  var urlMatch = /url\(('([^']+)'|"([^"]+)"|([^'")]+))\)/.exec(url) || [];
+  return urlMatch[2] || urlMatch[3] || urlMatch[4];
+}
+function normalizeColor(color) {
+  if (!color.startsWith("rgb")) {
+    return color;
+  }
+  var rgbParts = 3;
+  var normalizedColor = color.replace(/\d+(\.\d+)?/g, (num, isFloat) => rgbParts-- && isFloat ? String(Math.round(parseFloat(num))) : num);
+  return normalizedColor;
+}
+var attributeRegex = /(\[[^\]]+\])/g;
+var idRegex = /(#[^\s+>~.[:]+)/g;
+var classRegex = /(\.[^\s+>~.[:]+)/g;
+var pseudoElementRegex = /(::[^\s+>~.[:]+|:first-line|:first-letter|:before|:after)/gi;
+var pseudoClassWithBracketsRegex = /(:[\w-]+\([^)]*\))/gi;
+var pseudoClassRegex = /(:[^\s+>~.[:]+)/g;
+var elementRegex = /([^\s+>~.[:]+)/g;
+function findSelectorMatch(selector, regex) {
+  var matches = regex.exec(selector);
+  if (!matches) {
+    return [selector, 0];
+  }
+  return [selector.replace(regex, " "), matches.length];
+}
+function getSelectorSpecificity(selector) {
+  var specificity = [0, 0, 0];
+  var currentSelector = selector.replace(/:not\(([^)]*)\)/g, "     $1 ").replace(/{[\s\S]*/gm, " ");
+  var delta = 0;
+  [currentSelector, delta] = findSelectorMatch(currentSelector, attributeRegex);
+  specificity[1] += delta;
+  [currentSelector, delta] = findSelectorMatch(currentSelector, idRegex);
+  specificity[0] += delta;
+  [currentSelector, delta] = findSelectorMatch(currentSelector, classRegex);
+  specificity[1] += delta;
+  [currentSelector, delta] = findSelectorMatch(currentSelector, pseudoElementRegex);
+  specificity[2] += delta;
+  [currentSelector, delta] = findSelectorMatch(currentSelector, pseudoClassWithBracketsRegex);
+  specificity[1] += delta;
+  [currentSelector, delta] = findSelectorMatch(currentSelector, pseudoClassRegex);
+  specificity[1] += delta;
+  currentSelector = currentSelector.replace(/[*\s+>~]/g, " ").replace(/[#.]/g, " ");
+  [currentSelector, delta] = findSelectorMatch(currentSelector, elementRegex);
+  specificity[2] += delta;
+  return specificity.join("");
+}
+var PSEUDO_ZERO = 1e-8;
+function vectorMagnitude(v2) {
+  return Math.sqrt(Math.pow(v2[0], 2) + Math.pow(v2[1], 2));
+}
+function vectorsRatio(u2, v2) {
+  return (u2[0] * v2[0] + u2[1] * v2[1]) / (vectorMagnitude(u2) * vectorMagnitude(v2));
+}
+function vectorsAngle(u2, v2) {
+  return (u2[0] * v2[1] < u2[1] * v2[0] ? -1 : 1) * Math.acos(vectorsRatio(u2, v2));
+}
+function CB1(t2) {
+  return t2 * t2 * t2;
+}
+function CB2(t2) {
+  return 3 * t2 * t2 * (1 - t2);
+}
+function CB3(t2) {
+  return 3 * t2 * (1 - t2) * (1 - t2);
+}
+function CB4(t2) {
+  return (1 - t2) * (1 - t2) * (1 - t2);
+}
+function QB1(t2) {
+  return t2 * t2;
+}
+function QB2(t2) {
+  return 2 * t2 * (1 - t2);
+}
+function QB3(t2) {
+  return (1 - t2) * (1 - t2);
+}
+var Property = class _Property {
+  constructor(document2, name, value) {
+    this.document = document2;
+    this.name = name;
+    this.value = value;
+    this.isNormalizedColor = false;
+  }
+  static empty(document2) {
+    return new _Property(document2, "EMPTY", "");
+  }
+  split() {
+    var separator = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : " ";
+    var {
+      document: document2,
+      name
+    } = this;
+    return compressSpaces(this.getString()).trim().split(separator).map((value) => new _Property(document2, name, value));
+  }
+  hasValue(zeroIsValue) {
+    var {
+      value
+    } = this;
+    return value !== null && value !== "" && (zeroIsValue || value !== 0) && typeof value !== "undefined";
+  }
+  isString(regexp) {
+    var {
+      value
+    } = this;
+    var result = typeof value === "string";
+    if (!result || !regexp) {
+      return result;
+    }
+    return regexp.test(value);
+  }
+  isUrlDefinition() {
+    return this.isString(/^url\(/);
+  }
+  isPixels() {
+    if (!this.hasValue()) {
+      return false;
+    }
+    var asString = this.getString();
+    switch (true) {
+      case asString.endsWith("px"):
+      case /^[0-9]+$/.test(asString):
+        return true;
+      default:
+        return false;
+    }
+  }
+  setValue(value) {
+    this.value = value;
+    return this;
+  }
+  getValue(def) {
+    if (typeof def === "undefined" || this.hasValue()) {
+      return this.value;
+    }
+    return def;
+  }
+  getNumber(def) {
+    if (!this.hasValue()) {
+      if (typeof def === "undefined") {
+        return 0;
+      }
+      return parseFloat(def);
+    }
+    var {
+      value
+    } = this;
+    var n2 = parseFloat(value);
+    if (this.isString(/%$/)) {
+      n2 /= 100;
+    }
+    return n2;
+  }
+  getString(def) {
+    if (typeof def === "undefined" || this.hasValue()) {
+      return typeof this.value === "undefined" ? "" : String(this.value);
+    }
+    return String(def);
+  }
+  getColor(def) {
+    var color = this.getString(def);
+    if (this.isNormalizedColor) {
+      return color;
+    }
+    this.isNormalizedColor = true;
+    color = normalizeColor(color);
+    this.value = color;
+    return color;
+  }
+  getDpi() {
+    return 96;
+  }
+  getRem() {
+    return this.document.rootEmSize;
+  }
+  getEm() {
+    return this.document.emSize;
+  }
+  getUnits() {
+    return this.getString().replace(/[0-9.-]/g, "");
+  }
+  getPixels(axisOrIsFontSize) {
+    var processPercent = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+    if (!this.hasValue()) {
+      return 0;
+    }
+    var [axis, isFontSize] = typeof axisOrIsFontSize === "boolean" ? [void 0, axisOrIsFontSize] : [axisOrIsFontSize];
+    var {
+      viewPort
+    } = this.document.screen;
+    switch (true) {
+      case this.isString(/vmin$/):
+        return this.getNumber() / 100 * Math.min(viewPort.computeSize("x"), viewPort.computeSize("y"));
+      case this.isString(/vmax$/):
+        return this.getNumber() / 100 * Math.max(viewPort.computeSize("x"), viewPort.computeSize("y"));
+      case this.isString(/vw$/):
+        return this.getNumber() / 100 * viewPort.computeSize("x");
+      case this.isString(/vh$/):
+        return this.getNumber() / 100 * viewPort.computeSize("y");
+      case this.isString(/rem$/):
+        return this.getNumber() * this.getRem();
+      case this.isString(/em$/):
+        return this.getNumber() * this.getEm();
+      case this.isString(/ex$/):
+        return this.getNumber() * this.getEm() / 2;
+      case this.isString(/px$/):
+        return this.getNumber();
+      case this.isString(/pt$/):
+        return this.getNumber() * this.getDpi() * (1 / 72);
+      case this.isString(/pc$/):
+        return this.getNumber() * 15;
+      case this.isString(/cm$/):
+        return this.getNumber() * this.getDpi() / 2.54;
+      case this.isString(/mm$/):
+        return this.getNumber() * this.getDpi() / 25.4;
+      case this.isString(/in$/):
+        return this.getNumber() * this.getDpi();
+      case (this.isString(/%$/) && isFontSize):
+        return this.getNumber() * this.getEm();
+      case this.isString(/%$/):
+        return this.getNumber() * viewPort.computeSize(axis);
+      default: {
+        var n2 = this.getNumber();
+        if (processPercent && n2 < 1) {
+          return n2 * viewPort.computeSize(axis);
+        }
+        return n2;
+      }
+    }
+  }
+  getMilliseconds() {
+    if (!this.hasValue()) {
+      return 0;
+    }
+    if (this.isString(/ms$/)) {
+      return this.getNumber();
+    }
+    return this.getNumber() * 1e3;
+  }
+  getRadians() {
+    if (!this.hasValue()) {
+      return 0;
+    }
+    switch (true) {
+      case this.isString(/deg$/):
+        return this.getNumber() * (Math.PI / 180);
+      case this.isString(/grad$/):
+        return this.getNumber() * (Math.PI / 200);
+      case this.isString(/rad$/):
+        return this.getNumber();
+      default:
+        return this.getNumber() * (Math.PI / 180);
+    }
+  }
+  getDefinition() {
+    var asString = this.getString();
+    var name = /#([^)'"]+)/.exec(asString);
+    if (name) {
+      name = name[1];
+    }
+    if (!name) {
+      name = asString;
+    }
+    return this.document.definitions[name];
+  }
+  getFillStyleDefinition(element, opacity) {
+    var def = this.getDefinition();
+    if (!def) {
+      return null;
+    }
+    if (typeof def.createGradient === "function") {
+      return def.createGradient(this.document.ctx, element, opacity);
+    }
+    if (typeof def.createPattern === "function") {
+      if (def.getHrefAttribute().hasValue()) {
+        var patternTransform = def.getAttribute("patternTransform");
+        def = def.getHrefAttribute().getDefinition();
+        if (patternTransform.hasValue()) {
+          def.getAttribute("patternTransform", true).setValue(patternTransform.value);
+        }
+      }
+      return def.createPattern(this.document.ctx, element, opacity);
+    }
+    return null;
+  }
+  getTextBaseline() {
+    if (!this.hasValue()) {
+      return null;
+    }
+    return _Property.textBaselineMapping[this.getString()];
+  }
+  addOpacity(opacity) {
+    var value = this.getColor();
+    var len = value.length;
+    var commas = 0;
+    for (var i2 = 0; i2 < len; i2++) {
+      if (value[i2] === ",") {
+        commas++;
+      }
+      if (commas === 3) {
+        break;
+      }
+    }
+    if (opacity.hasValue() && this.isString() && commas !== 3) {
+      var color = new import_rgbcolor.default(value);
+      if (color.ok) {
+        color.alpha = opacity.getNumber();
+        value = color.toRGBA();
+      }
+    }
+    return new _Property(this.document, this.name, value);
+  }
+};
+Property.textBaselineMapping = {
+  "baseline": "alphabetic",
+  "before-edge": "top",
+  "text-before-edge": "top",
+  "middle": "middle",
+  "central": "middle",
+  "after-edge": "bottom",
+  "text-after-edge": "bottom",
+  "ideographic": "ideographic",
+  "alphabetic": "alphabetic",
+  "hanging": "hanging",
+  "mathematical": "alphabetic"
+};
+var ViewPort = class {
+  constructor() {
+    this.viewPorts = [];
+  }
+  clear() {
+    this.viewPorts = [];
+  }
+  setCurrent(width, height) {
+    this.viewPorts.push({
+      width,
+      height
+    });
+  }
+  removeCurrent() {
+    this.viewPorts.pop();
+  }
+  getCurrent() {
+    var {
+      viewPorts
+    } = this;
+    return viewPorts[viewPorts.length - 1];
+  }
+  get width() {
+    return this.getCurrent().width;
+  }
+  get height() {
+    return this.getCurrent().height;
+  }
+  computeSize(d) {
+    if (typeof d === "number") {
+      return d;
+    }
+    if (d === "x") {
+      return this.width;
+    }
+    if (d === "y") {
+      return this.height;
+    }
+    return Math.sqrt(Math.pow(this.width, 2) + Math.pow(this.height, 2)) / Math.sqrt(2);
+  }
+};
+var Point = class _Point {
+  constructor(x, y2) {
+    this.x = x;
+    this.y = y2;
+  }
+  static parse(point) {
+    var defaultValue = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
+    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, y2 = x] = toNumbers(scale);
+    return new _Point(x, y2);
+  }
+  static parsePath(path) {
+    var points = toNumbers(path);
+    var len = points.length;
+    var pathPoints = [];
+    for (var i2 = 0; i2 < len; i2 += 2) {
+      pathPoints.push(new _Point(points[i2], points[i2 + 1]));
+    }
+    return pathPoints;
+  }
+  angleTo(point) {
+    return Math.atan2(point.y - this.y, point.x - this.x);
+  }
+  applyTransform(transform) {
+    var {
+      x,
+      y: y2
+    } = this;
+    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;
+  }
+};
+var Mouse = class {
+  constructor(screen) {
+    this.screen = screen;
+    this.working = false;
+    this.events = [];
+    this.eventElements = [];
+    this.onClick = this.onClick.bind(this);
+    this.onMouseMove = this.onMouseMove.bind(this);
+  }
+  isWorking() {
+    return this.working;
+  }
+  start() {
+    if (this.working) {
+      return;
+    }
+    var {
+      screen,
+      onClick,
+      onMouseMove
+    } = this;
+    var canvas = screen.ctx.canvas;
+    canvas.onclick = onClick;
+    canvas.onmousemove = onMouseMove;
+    this.working = true;
+  }
+  stop() {
+    if (!this.working) {
+      return;
+    }
+    var canvas = this.screen.ctx.canvas;
+    this.working = false;
+    canvas.onclick = null;
+    canvas.onmousemove = null;
+  }
+  hasEvents() {
+    return this.working && this.events.length > 0;
+  }
+  runEvents() {
+    if (!this.working) {
+      return;
+    }
+    var {
+      screen: document2,
+      events,
+      eventElements
+    } = this;
+    var {
+      style
+    } = document2.ctx.canvas;
+    if (style) {
+      style.cursor = "";
+    }
+    events.forEach((_ref, i2) => {
+      var {
+        run
+      } = _ref;
+      var element = eventElements[i2];
+      while (element) {
+        run(element);
+        element = element.parent;
+      }
+    });
+    this.events = [];
+    this.eventElements = [];
+  }
+  checkPath(element, ctx) {
+    if (!this.working || !ctx) {
+      return;
+    }
+    var {
+      events,
+      eventElements
+    } = this;
+    events.forEach((_ref2, i2) => {
+      var {
+        x,
+        y: y2
+      } = _ref2;
+      if (!eventElements[i2] && ctx.isPointInPath && ctx.isPointInPath(x, y2)) {
+        eventElements[i2] = element;
+      }
+    });
+  }
+  checkBoundingBox(element, boundingBox) {
+    if (!this.working || !boundingBox) {
+      return;
+    }
+    var {
+      events,
+      eventElements
+    } = this;
+    events.forEach((_ref3, i2) => {
+      var {
+        x,
+        y: y2
+      } = _ref3;
+      if (!eventElements[i2] && boundingBox.isPointInBox(x, y2)) {
+        eventElements[i2] = element;
+      }
+    });
+  }
+  mapXY(x, y2) {
+    var {
+      window: window2,
+      ctx
+    } = this.screen;
+    var point = new Point(x, y2);
+    var element = ctx.canvas;
+    while (element) {
+      point.x -= element.offsetLeft;
+      point.y -= element.offsetTop;
+      element = element.offsetParent;
+    }
+    if (window2.scrollX) {
+      point.x += window2.scrollX;
+    }
+    if (window2.scrollY) {
+      point.y += window2.scrollY;
+    }
+    return point;
+  }
+  onClick(event) {
+    var {
+      x,
+      y: y2
+    } = this.mapXY(event.clientX, event.clientY);
+    this.events.push({
+      type: "onclick",
+      x,
+      y: y2,
+      run(eventTarget) {
+        if (eventTarget.onClick) {
+          eventTarget.onClick();
+        }
+      }
+    });
+  }
+  onMouseMove(event) {
+    var {
+      x,
+      y: y2
+    } = this.mapXY(event.clientX, event.clientY);
+    this.events.push({
+      type: "onmousemove",
+      x,
+      y: y2,
+      run(eventTarget) {
+        if (eventTarget.onMouseMove) {
+          eventTarget.onMouseMove();
+        }
+      }
+    });
+  }
+};
+var defaultWindow = typeof window !== "undefined" ? window : null;
+var defaultFetch$1 = typeof fetch !== "undefined" ? fetch.bind(void 0) : null;
+var Screen = class {
+  constructor(ctx) {
+    var {
+      fetch: fetch2 = defaultFetch$1,
+      window: window2 = defaultWindow
+    } = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    this.ctx = ctx;
+    this.FRAMERATE = 30;
+    this.MAX_VIRTUAL_PIXELS = 3e4;
+    this.CLIENT_WIDTH = 800;
+    this.CLIENT_HEIGHT = 600;
+    this.viewPort = new ViewPort();
+    this.mouse = new Mouse(this);
+    this.animations = [];
+    this.waits = [];
+    this.frameDuration = 0;
+    this.isReadyLock = false;
+    this.isFirstRender = true;
+    this.intervalId = null;
+    this.window = window2;
+    this.fetch = fetch2;
+  }
+  wait(checker) {
+    this.waits.push(checker);
+  }
+  ready() {
+    if (!this.readyPromise) {
+      return Promise.resolve();
+    }
+    return this.readyPromise;
+  }
+  isReady() {
+    if (this.isReadyLock) {
+      return true;
+    }
+    var isReadyLock = this.waits.every((_2) => _2());
+    if (isReadyLock) {
+      this.waits = [];
+      if (this.resolveReady) {
+        this.resolveReady();
+      }
+    }
+    this.isReadyLock = isReadyLock;
+    return isReadyLock;
+  }
+  setDefaults(ctx) {
+    ctx.strokeStyle = "rgba(0,0,0,0)";
+    ctx.lineCap = "butt";
+    ctx.lineJoin = "miter";
+    ctx.miterLimit = 4;
+  }
+  setViewBox(_ref) {
+    var {
+      document: document2,
+      ctx,
+      aspectRatio,
+      width,
+      desiredWidth,
+      height,
+      desiredHeight,
+      minX = 0,
+      minY = 0,
+      refX,
+      refY,
+      clip = false,
+      clipX = 0,
+      clipY = 0
+    } = _ref;
+    var cleanAspectRatio = compressSpaces(aspectRatio).replace(/^defer\s/, "");
+    var [aspectRatioAlign, aspectRatioMeetOrSlice] = cleanAspectRatio.split(" ");
+    var align = aspectRatioAlign || "xMidYMid";
+    var meetOrSlice = aspectRatioMeetOrSlice || "meet";
+    var scaleX = width / desiredWidth;
+    var scaleY = height / desiredHeight;
+    var scaleMin = Math.min(scaleX, scaleY);
+    var scaleMax = Math.max(scaleX, scaleY);
+    var finalDesiredWidth = desiredWidth;
+    var finalDesiredHeight = desiredHeight;
+    if (meetOrSlice === "meet") {
+      finalDesiredWidth *= scaleMin;
+      finalDesiredHeight *= scaleMin;
+    }
+    if (meetOrSlice === "slice") {
+      finalDesiredWidth *= scaleMax;
+      finalDesiredHeight *= scaleMax;
+    }
+    var refXProp = new Property(document2, "refX", refX);
+    var refYProp = new Property(document2, "refY", refY);
+    var hasRefs = refXProp.hasValue() && refYProp.hasValue();
+    if (hasRefs) {
+      ctx.translate(-scaleMin * refXProp.getPixels("x"), -scaleMin * refYProp.getPixels("y"));
+    }
+    if (clip) {
+      var scaledClipX = scaleMin * clipX;
+      var scaledClipY = scaleMin * clipY;
+      ctx.beginPath();
+      ctx.moveTo(scaledClipX, scaledClipY);
+      ctx.lineTo(width, scaledClipY);
+      ctx.lineTo(width, height);
+      ctx.lineTo(scaledClipX, height);
+      ctx.closePath();
+      ctx.clip();
+    }
+    if (!hasRefs) {
+      var isMeetMinY = meetOrSlice === "meet" && scaleMin === scaleY;
+      var isSliceMaxY = meetOrSlice === "slice" && scaleMax === scaleY;
+      var isMeetMinX = meetOrSlice === "meet" && scaleMin === scaleX;
+      var isSliceMaxX = meetOrSlice === "slice" && scaleMax === scaleX;
+      if (align.startsWith("xMid") && (isMeetMinY || isSliceMaxY)) {
+        ctx.translate(width / 2 - finalDesiredWidth / 2, 0);
+      }
+      if (align.endsWith("YMid") && (isMeetMinX || isSliceMaxX)) {
+        ctx.translate(0, height / 2 - finalDesiredHeight / 2);
+      }
+      if (align.startsWith("xMax") && (isMeetMinY || isSliceMaxY)) {
+        ctx.translate(width - finalDesiredWidth, 0);
+      }
+      if (align.endsWith("YMax") && (isMeetMinX || isSliceMaxX)) {
+        ctx.translate(0, height - finalDesiredHeight);
+      }
+    }
+    switch (true) {
+      case align === "none":
+        ctx.scale(scaleX, scaleY);
+        break;
+      case meetOrSlice === "meet":
+        ctx.scale(scaleMin, scaleMin);
+        break;
+      case meetOrSlice === "slice":
+        ctx.scale(scaleMax, scaleMax);
+        break;
+    }
+    ctx.translate(-minX, -minY);
+  }
+  start(element) {
+    var {
+      enableRedraw = false,
+      ignoreMouse = false,
+      ignoreAnimation = false,
+      ignoreDimensions = false,
+      ignoreClear = false,
+      forceRedraw,
+      scaleWidth,
+      scaleHeight,
+      offsetX,
+      offsetY
+    } = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    var {
+      FRAMERATE,
+      mouse
+    } = this;
+    var frameDuration = 1e3 / FRAMERATE;
+    this.frameDuration = frameDuration;
+    this.readyPromise = new Promise((resolve) => {
+      this.resolveReady = resolve;
+    });
+    if (this.isReady()) {
+      this.render(element, ignoreDimensions, ignoreClear, scaleWidth, scaleHeight, offsetX, offsetY);
+    }
+    if (!enableRedraw) {
+      return;
+    }
+    var now = Date.now();
+    var then = now;
+    var delta = 0;
+    var tick = () => {
+      now = Date.now();
+      delta = now - then;
+      if (delta >= frameDuration) {
+        then = now - delta % frameDuration;
+        if (this.shouldUpdate(ignoreAnimation, forceRedraw)) {
+          this.render(element, ignoreDimensions, ignoreClear, scaleWidth, scaleHeight, offsetX, offsetY);
+          mouse.runEvents();
+        }
+      }
+      this.intervalId = (0, import_raf.default)(tick);
+    };
+    if (!ignoreMouse) {
+      mouse.start();
+    }
+    this.intervalId = (0, import_raf.default)(tick);
+  }
+  stop() {
+    if (this.intervalId) {
+      import_raf.default.cancel(this.intervalId);
+      this.intervalId = null;
+    }
+    this.mouse.stop();
+  }
+  shouldUpdate(ignoreAnimation, forceRedraw) {
+    if (!ignoreAnimation) {
+      var {
+        frameDuration
+      } = this;
+      var shouldUpdate = this.animations.reduce((shouldUpdate2, animation) => animation.update(frameDuration) || shouldUpdate2, false);
+      if (shouldUpdate) {
+        return true;
+      }
+    }
+    if (typeof forceRedraw === "function" && forceRedraw()) {
+      return true;
+    }
+    if (!this.isReadyLock && this.isReady()) {
+      return true;
+    }
+    if (this.mouse.hasEvents()) {
+      return true;
+    }
+    return false;
+  }
+  render(element, ignoreDimensions, ignoreClear, scaleWidth, scaleHeight, offsetX, offsetY) {
+    var {
+      CLIENT_WIDTH,
+      CLIENT_HEIGHT,
+      viewPort,
+      ctx,
+      isFirstRender
+    } = this;
+    var canvas = ctx.canvas;
+    viewPort.clear();
+    if (canvas.width && canvas.height) {
+      viewPort.setCurrent(canvas.width, canvas.height);
+    } else {
+      viewPort.setCurrent(CLIENT_WIDTH, CLIENT_HEIGHT);
+    }
+    var widthStyle = element.getStyle("width");
+    var heightStyle = element.getStyle("height");
+    if (!ignoreDimensions && (isFirstRender || typeof scaleWidth !== "number" && typeof scaleHeight !== "number")) {
+      if (widthStyle.hasValue()) {
+        canvas.width = widthStyle.getPixels("x");
+        if (canvas.style) {
+          canvas.style.width = "".concat(canvas.width, "px");
+        }
+      }
+      if (heightStyle.hasValue()) {
+        canvas.height = heightStyle.getPixels("y");
+        if (canvas.style) {
+          canvas.style.height = "".concat(canvas.height, "px");
+        }
+      }
+    }
+    var cWidth = canvas.clientWidth || canvas.width;
+    var cHeight = canvas.clientHeight || canvas.height;
+    if (ignoreDimensions && widthStyle.hasValue() && heightStyle.hasValue()) {
+      cWidth = widthStyle.getPixels("x");
+      cHeight = heightStyle.getPixels("y");
+    }
+    viewPort.setCurrent(cWidth, cHeight);
+    if (typeof offsetX === "number") {
+      element.getAttribute("x", true).setValue(offsetX);
+    }
+    if (typeof offsetY === "number") {
+      element.getAttribute("y", true).setValue(offsetY);
+    }
+    if (typeof scaleWidth === "number" || typeof scaleHeight === "number") {
+      var viewBox = toNumbers(element.getAttribute("viewBox").getString());
+      var xRatio = 0;
+      var yRatio = 0;
+      if (typeof scaleWidth === "number") {
+        var _widthStyle = element.getStyle("width");
+        if (_widthStyle.hasValue()) {
+          xRatio = _widthStyle.getPixels("x") / scaleWidth;
+        } else if (!isNaN(viewBox[2])) {
+          xRatio = viewBox[2] / scaleWidth;
+        }
+      }
+      if (typeof scaleHeight === "number") {
+        var _heightStyle = element.getStyle("height");
+        if (_heightStyle.hasValue()) {
+          yRatio = _heightStyle.getPixels("y") / scaleHeight;
+        } else if (!isNaN(viewBox[3])) {
+          yRatio = viewBox[3] / scaleHeight;
+        }
+      }
+      if (!xRatio) {
+        xRatio = yRatio;
+      }
+      if (!yRatio) {
+        yRatio = xRatio;
+      }
+      element.getAttribute("width", true).setValue(scaleWidth);
+      element.getAttribute("height", true).setValue(scaleHeight);
+      var transformStyle = element.getStyle("transform", true, true);
+      transformStyle.setValue("".concat(transformStyle.getString(), " scale(").concat(1 / xRatio, ", ").concat(1 / yRatio, ")"));
+    }
+    if (!ignoreClear) {
+      ctx.clearRect(0, 0, cWidth, cHeight);
+    }
+    element.render(ctx);
+    if (isFirstRender) {
+      this.isFirstRender = false;
+    }
+  }
+};
+Screen.defaultWindow = defaultWindow;
+Screen.defaultFetch = defaultFetch$1;
+var {
+  defaultFetch
+} = Screen;
+var DefaultDOMParser = typeof DOMParser !== "undefined" ? DOMParser : null;
+var Parser = class {
+  constructor() {
+    var {
+      fetch: fetch2 = defaultFetch,
+      DOMParser: DOMParser2 = DefaultDOMParser
+    } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    this.fetch = fetch2;
+    this.DOMParser = DOMParser2;
+  }
+  parse(resource) {
+    var _this = this;
+    return _asyncToGenerator(function* () {
+      if (resource.startsWith("<")) {
+        return _this.parseFromString(resource);
+      }
+      return _this.load(resource);
+    })();
+  }
+  parseFromString(xml) {
+    var parser = new this.DOMParser();
+    try {
+      return this.checkDocument(parser.parseFromString(xml, "image/svg+xml"));
+    } catch (err) {
+      return this.checkDocument(parser.parseFromString(xml, "text/xml"));
+    }
+  }
+  checkDocument(document2) {
+    var parserError = document2.getElementsByTagName("parsererror")[0];
+    if (parserError) {
+      throw new Error(parserError.textContent);
+    }
+    return document2;
+  }
+  load(url) {
+    var _this2 = this;
+    return _asyncToGenerator(function* () {
+      var response = yield _this2.fetch(url);
+      var xml = yield response.text();
+      return _this2.parseFromString(xml);
+    })();
+  }
+};
+var Translate = class {
+  constructor(_2, point) {
+    this.type = "translate";
+    this.point = null;
+    this.point = Point.parse(point);
+  }
+  apply(ctx) {
+    var {
+      x,
+      y: y2
+    } = this.point;
+    ctx.translate(x || 0, y2 || 0);
+  }
+  unapply(ctx) {
+    var {
+      x,
+      y: y2
+    } = this.point;
+    ctx.translate(-1 * x || 0, -1 * y2 || 0);
+  }
+  applyToPoint(point) {
+    var {
+      x,
+      y: y2
+    } = this.point;
+    point.applyTransform([1, 0, 0, 1, x || 0, y2 || 0]);
+  }
+};
+var Rotate = class {
+  constructor(document2, rotate, transformOrigin) {
+    this.type = "rotate";
+    this.angle = null;
+    this.originX = null;
+    this.originY = null;
+    this.cx = 0;
+    this.cy = 0;
+    var numbers = toNumbers(rotate);
+    this.angle = new Property(document2, "angle", numbers[0]);
+    this.originX = transformOrigin[0];
+    this.originY = transformOrigin[1];
+    this.cx = numbers[1] || 0;
+    this.cy = numbers[2] || 0;
+  }
+  apply(ctx) {
+    var {
+      cx,
+      cy,
+      originX,
+      originY,
+      angle
+    } = this;
+    var tx = cx + originX.getPixels("x");
+    var ty = cy + originY.getPixels("y");
+    ctx.translate(tx, ty);
+    ctx.rotate(angle.getRadians());
+    ctx.translate(-tx, -ty);
+  }
+  unapply(ctx) {
+    var {
+      cx,
+      cy,
+      originX,
+      originY,
+      angle
+    } = this;
+    var tx = cx + originX.getPixels("x");
+    var ty = cy + originY.getPixels("y");
+    ctx.translate(tx, ty);
+    ctx.rotate(-1 * angle.getRadians());
+    ctx.translate(-tx, -ty);
+  }
+  applyToPoint(point) {
+    var {
+      cx,
+      cy,
+      angle
+    } = this;
+    var rad = angle.getRadians();
+    point.applyTransform([
+      1,
+      0,
+      0,
+      1,
+      cx || 0,
+      cy || 0
+      // this.p.y
+    ]);
+    point.applyTransform([Math.cos(rad), Math.sin(rad), -Math.sin(rad), Math.cos(rad), 0, 0]);
+    point.applyTransform([
+      1,
+      0,
+      0,
+      1,
+      -cx || 0,
+      -cy || 0
+      // -this.p.y
+    ]);
+  }
+};
+var Scale = class {
+  constructor(_2, scale, transformOrigin) {
+    this.type = "scale";
+    this.scale = null;
+    this.originX = null;
+    this.originY = null;
+    var scaleSize = Point.parseScale(scale);
+    if (scaleSize.x === 0 || scaleSize.y === 0) {
+      scaleSize.x = PSEUDO_ZERO;
+      scaleSize.y = PSEUDO_ZERO;
+    }
+    this.scale = scaleSize;
+    this.originX = transformOrigin[0];
+    this.originY = transformOrigin[1];
+  }
+  apply(ctx) {
+    var {
+      scale: {
+        x,
+        y: y2
+      },
+      originX,
+      originY
+    } = this;
+    var tx = originX.getPixels("x");
+    var ty = originY.getPixels("y");
+    ctx.translate(tx, ty);
+    ctx.scale(x, y2 || x);
+    ctx.translate(-tx, -ty);
+  }
+  unapply(ctx) {
+    var {
+      scale: {
+        x,
+        y: y2
+      },
+      originX,
+      originY
+    } = this;
+    var tx = originX.getPixels("x");
+    var ty = originY.getPixels("y");
+    ctx.translate(tx, ty);
+    ctx.scale(1 / x, 1 / y2 || x);
+    ctx.translate(-tx, -ty);
+  }
+  applyToPoint(point) {
+    var {
+      x,
+      y: y2
+    } = this.scale;
+    point.applyTransform([x || 0, 0, 0, y2 || 0, 0, 0]);
+  }
+};
+var Matrix = class {
+  constructor(_2, matrix, transformOrigin) {
+    this.type = "matrix";
+    this.matrix = [];
+    this.originX = null;
+    this.originY = null;
+    this.matrix = toNumbers(matrix);
+    this.originX = transformOrigin[0];
+    this.originY = transformOrigin[1];
+  }
+  apply(ctx) {
+    var {
+      originX,
+      originY,
+      matrix
+    } = this;
+    var tx = originX.getPixels("x");
+    var ty = originY.getPixels("y");
+    ctx.translate(tx, ty);
+    ctx.transform(matrix[0], matrix[1], matrix[2], matrix[3], matrix[4], matrix[5]);
+    ctx.translate(-tx, -ty);
+  }
+  unapply(ctx) {
+    var {
+      originX,
+      originY,
+      matrix
+    } = this;
+    var a2 = matrix[0];
+    var b = matrix[2];
+    var c3 = matrix[4];
+    var d = matrix[1];
+    var e2 = matrix[3];
+    var f2 = matrix[5];
+    var g = 0;
+    var h2 = 0;
+    var i2 = 1;
+    var det = 1 / (a2 * (e2 * i2 - f2 * h2) - b * (d * i2 - f2 * g) + c3 * (d * h2 - e2 * g));
+    var tx = originX.getPixels("x");
+    var ty = originY.getPixels("y");
+    ctx.translate(tx, ty);
+    ctx.transform(det * (e2 * i2 - f2 * h2), det * (f2 * g - d * i2), det * (c3 * h2 - b * i2), det * (a2 * i2 - c3 * g), det * (b * f2 - c3 * e2), det * (c3 * d - a2 * f2));
+    ctx.translate(-tx, -ty);
+  }
+  applyToPoint(point) {
+    point.applyTransform(this.matrix);
+  }
+};
+var Skew = class extends Matrix {
+  constructor(document2, skew, transformOrigin) {
+    super(document2, skew, transformOrigin);
+    this.type = "skew";
+    this.angle = null;
+    this.angle = new Property(document2, "angle", skew);
+  }
+};
+var SkewX = class extends Skew {
+  constructor(document2, skew, transformOrigin) {
+    super(document2, skew, transformOrigin);
+    this.type = "skewX";
+    this.matrix = [1, 0, Math.tan(this.angle.getRadians()), 1, 0, 0];
+  }
+};
+var SkewY = class extends Skew {
+  constructor(document2, skew, transformOrigin) {
+    super(document2, skew, transformOrigin);
+    this.type = "skewY";
+    this.matrix = [1, Math.tan(this.angle.getRadians()), 0, 1, 0, 0];
+  }
+};
+function parseTransforms(transform) {
+  return compressSpaces(transform).trim().replace(/\)([a-zA-Z])/g, ") $1").replace(/\)(\s?,\s?)/g, ") ").split(/\s(?=[a-z])/);
+}
+function parseTransform(transform) {
+  var [type, value] = transform.split("(");
+  return [type.trim(), value.trim().replace(")", "")];
+}
+var Transform = class _Transform {
+  constructor(document2, transform, transformOrigin) {
+    this.document = document2;
+    this.transforms = [];
+    var data = parseTransforms(transform);
+    data.forEach((transform2) => {
+      if (transform2 === "none") {
+        return;
+      }
+      var [type, value] = parseTransform(transform2);
+      var TransformType = _Transform.transformTypes[type];
+      if (typeof TransformType !== "undefined") {
+        this.transforms.push(new TransformType(this.document, value, transformOrigin));
+      }
+    });
+  }
+  static fromElement(document2, element) {
+    var transformStyle = element.getStyle("transform", false, true);
+    var [transformOriginXProperty, transformOriginYProperty = transformOriginXProperty] = element.getStyle("transform-origin", false, true).split();
+    var transformOrigin = [transformOriginXProperty, transformOriginYProperty];
+    if (transformStyle.hasValue()) {
+      return new _Transform(document2, transformStyle.getString(), transformOrigin);
+    }
+    return null;
+  }
+  apply(ctx) {
+    var {
+      transforms
+    } = this;
+    var len = transforms.length;
+    for (var i2 = 0; i2 < len; i2++) {
+      transforms[i2].apply(ctx);
+    }
+  }
+  unapply(ctx) {
+    var {
+      transforms
+    } = this;
+    var len = transforms.length;
+    for (var i2 = len - 1; i2 >= 0; i2--) {
+      transforms[i2].unapply(ctx);
+    }
+  }
+  // TODO: applyToPoint unused ... remove?
+  applyToPoint(point) {
+    var {
+      transforms
+    } = this;
+    var len = transforms.length;
+    for (var i2 = 0; i2 < len; i2++) {
+      transforms[i2].applyToPoint(point);
+    }
+  }
+};
+Transform.transformTypes = {
+  translate: Translate,
+  rotate: Rotate,
+  scale: Scale,
+  matrix: Matrix,
+  skewX: SkewX,
+  skewY: SkewY
+};
+var Element = class _Element {
+  constructor(document2, node2) {
+    var captureTextNodes = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+    this.document = document2;
+    this.node = node2;
+    this.captureTextNodes = captureTextNodes;
+    this.attributes = {};
+    this.styles = {};
+    this.stylesSpecificity = {};
+    this.animationFrozen = false;
+    this.animationFrozenValue = "";
+    this.parent = null;
+    this.children = [];
+    if (!node2 || node2.nodeType !== 1) {
+      return;
+    }
+    Array.from(node2.attributes).forEach((attribute) => {
+      var nodeName = normalizeAttributeName(attribute.nodeName);
+      this.attributes[nodeName] = new Property(document2, nodeName, attribute.value);
+    });
+    this.addStylesFromStyleDefinition();
+    if (this.getAttribute("style").hasValue()) {
+      var styles = this.getAttribute("style").getString().split(";").map((_2) => _2.trim());
+      styles.forEach((style) => {
+        if (!style) {
+          return;
+        }
+        var [name, value] = style.split(":").map((_2) => _2.trim());
+        this.styles[name] = new Property(document2, name, value);
+      });
+    }
+    var {
+      definitions
+    } = document2;
+    var id = this.getAttribute("id");
+    if (id.hasValue()) {
+      if (!definitions[id.getString()]) {
+        definitions[id.getString()] = this;
+      }
+    }
+    Array.from(node2.childNodes).forEach((childNode) => {
+      if (childNode.nodeType === 1) {
+        this.addChild(childNode);
+      } else if (captureTextNodes && (childNode.nodeType === 3 || childNode.nodeType === 4)) {
+        var textNode = document2.createTextNode(childNode);
+        if (textNode.getText().length > 0) {
+          this.addChild(textNode);
+        }
+      }
+    });
+  }
+  getAttribute(name) {
+    var createIfNotExists = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+    var attr = this.attributes[name];
+    if (!attr && createIfNotExists) {
+      var _attr = new Property(this.document, name, "");
+      this.attributes[name] = _attr;
+      return _attr;
+    }
+    return attr || Property.empty(this.document);
+  }
+  getHrefAttribute() {
+    for (var key in this.attributes) {
+      if (key === "href" || key.endsWith(":href")) {
+        return this.attributes[key];
+      }
+    }
+    return Property.empty(this.document);
+  }
+  getStyle(name) {
+    var createIfNotExists = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+    var skipAncestors = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+    var style = this.styles[name];
+    if (style) {
+      return style;
+    }
+    var attr = this.getAttribute(name);
+    if (attr !== null && attr !== void 0 && attr.hasValue()) {
+      this.styles[name] = attr;
+      return attr;
+    }
+    if (!skipAncestors) {
+      var {
+        parent
+      } = this;
+      if (parent) {
+        var parentStyle = parent.getStyle(name);
+        if (parentStyle !== null && parentStyle !== void 0 && parentStyle.hasValue()) {
+          return parentStyle;
+        }
+      }
+    }
+    if (createIfNotExists) {
+      var _style = new Property(this.document, name, "");
+      this.styles[name] = _style;
+      return _style;
+    }
+    return style || Property.empty(this.document);
+  }
+  render(ctx) {
+    if (this.getStyle("display").getString() === "none" || this.getStyle("visibility").getString() === "hidden") {
+      return;
+    }
+    ctx.save();
+    if (this.getStyle("mask").hasValue()) {
+      var mask = this.getStyle("mask").getDefinition();
+      if (mask) {
+        this.applyEffects(ctx);
+        mask.apply(ctx, this);
+      }
+    } else if (this.getStyle("filter").getValue("none") !== "none") {
+      var filter = this.getStyle("filter").getDefinition();
+      if (filter) {
+        this.applyEffects(ctx);
+        filter.apply(ctx, this);
+      }
+    } else {
+      this.setContext(ctx);
+      this.renderChildren(ctx);
+      this.clearContext(ctx);
+    }
+    ctx.restore();
+  }
+  setContext(_2) {
+  }
+  applyEffects(ctx) {
+    var transform = Transform.fromElement(this.document, this);
+    if (transform) {
+      transform.apply(ctx);
+    }
+    var clipPathStyleProp = this.getStyle("clip-path", false, true);
+    if (clipPathStyleProp.hasValue()) {
+      var clip = clipPathStyleProp.getDefinition();
+      if (clip) {
+        clip.apply(ctx);
+      }
+    }
+  }
+  clearContext(_2) {
+  }
+  renderChildren(ctx) {
+    this.children.forEach((child) => {
+      child.render(ctx);
+    });
+  }
+  addChild(childNode) {
+    var child = childNode instanceof _Element ? childNode : this.document.createElement(childNode);
+    child.parent = this;
+    if (!_Element.ignoreChildTypes.includes(child.type)) {
+      this.children.push(child);
+    }
+  }
+  matchesSelector(selector) {
+    var _node$getAttribute;
+    var {
+      node: node2
+    } = this;
+    if (typeof node2.matches === "function") {
+      return node2.matches(selector);
+    }
+    var styleClasses = (_node$getAttribute = node2.getAttribute) === null || _node$getAttribute === void 0 ? void 0 : _node$getAttribute.call(node2, "class");
+    if (!styleClasses || styleClasses === "") {
+      return false;
+    }
+    return styleClasses.split(" ").some((styleClass) => ".".concat(styleClass) === selector);
+  }
+  addStylesFromStyleDefinition() {
+    var {
+      styles,
+      stylesSpecificity
+    } = this.document;
+    for (var selector in styles) {
+      if (!selector.startsWith("@") && this.matchesSelector(selector)) {
+        var style = styles[selector];
+        var specificity = stylesSpecificity[selector];
+        if (style) {
+          for (var name in style) {
+            var existingSpecificity = this.stylesSpecificity[name];
+            if (typeof existingSpecificity === "undefined") {
+              existingSpecificity = "000";
+            }
+            if (specificity >= existingSpecificity) {
+              this.styles[name] = style[name];
+              this.stylesSpecificity[name] = specificity;
+            }
+          }
+        }
+      }
+    }
+  }
+  removeStyles(element, ignoreStyles) {
+    var toRestore = ignoreStyles.reduce((toRestore2, name) => {
+      var styleProp = element.getStyle(name);
+      if (!styleProp.hasValue()) {
+        return toRestore2;
+      }
+      var value = styleProp.getString();
+      styleProp.setValue("");
+      return [...toRestore2, [name, value]];
+    }, []);
+    return toRestore;
+  }
+  restoreStyles(element, styles) {
+    styles.forEach((_ref) => {
+      var [name, value] = _ref;
+      element.getStyle(name, true).setValue(value);
+    });
+  }
+  isFirstChild() {
+    var _this$parent;
+    return ((_this$parent = this.parent) === null || _this$parent === void 0 ? void 0 : _this$parent.children.indexOf(this)) === 0;
+  }
+};
+Element.ignoreChildTypes = ["title"];
+var UnknownElement = class extends Element {
+  constructor(document2, node2, captureTextNodes) {
+    super(document2, node2, captureTextNodes);
+  }
+};
+function wrapFontFamily(fontFamily) {
+  var trimmed = fontFamily.trim();
+  return /^('|")/.test(trimmed) ? trimmed : '"'.concat(trimmed, '"');
+}
+function prepareFontFamily(fontFamily) {
+  return typeof process === "undefined" ? fontFamily : fontFamily.trim().split(",").map(wrapFontFamily).join(",");
+}
+function prepareFontStyle(fontStyle) {
+  if (!fontStyle) {
+    return "";
+  }
+  var targetFontStyle = fontStyle.trim().toLowerCase();
+  switch (targetFontStyle) {
+    case "normal":
+    case "italic":
+    case "oblique":
+    case "inherit":
+    case "initial":
+    case "unset":
+      return targetFontStyle;
+    default:
+      if (/^oblique\s+(-|)\d+deg$/.test(targetFontStyle)) {
+        return targetFontStyle;
+      }
+      return "";
+  }
+}
+function prepareFontWeight(fontWeight) {
+  if (!fontWeight) {
+    return "";
+  }
+  var targetFontWeight = fontWeight.trim().toLowerCase();
+  switch (targetFontWeight) {
+    case "normal":
+    case "bold":
+    case "lighter":
+    case "bolder":
+    case "inherit":
+    case "initial":
+    case "unset":
+      return targetFontWeight;
+    default:
+      if (/^[\d.]+$/.test(targetFontWeight)) {
+        return targetFontWeight;
+      }
+      return "";
+  }
+}
+var Font = class _Font {
+  constructor(fontStyle, fontVariant, fontWeight, fontSize, fontFamily, inherit) {
+    var inheritFont = inherit ? typeof inherit === "string" ? _Font.parse(inherit) : inherit : {};
+    this.fontFamily = fontFamily || inheritFont.fontFamily;
+    this.fontSize = fontSize || inheritFont.fontSize;
+    this.fontStyle = fontStyle || inheritFont.fontStyle;
+    this.fontWeight = fontWeight || inheritFont.fontWeight;
+    this.fontVariant = fontVariant || inheritFont.fontVariant;
+  }
+  static parse() {
+    var font = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "";
+    var inherit = arguments.length > 1 ? arguments[1] : void 0;
+    var fontStyle = "";
+    var fontVariant = "";
+    var fontWeight = "";
+    var fontSize = "";
+    var fontFamily = "";
+    var parts = compressSpaces(font).trim().split(" ");
+    var set = {
+      fontSize: false,
+      fontStyle: false,
+      fontWeight: false,
+      fontVariant: false
+    };
+    parts.forEach((part) => {
+      switch (true) {
+        case (!set.fontStyle && _Font.styles.includes(part)):
+          if (part !== "inherit") {
+            fontStyle = part;
+          }
+          set.fontStyle = true;
+          break;
+        case (!set.fontVariant && _Font.variants.includes(part)):
+          if (part !== "inherit") {
+            fontVariant = part;
+          }
+          set.fontStyle = true;
+          set.fontVariant = true;
+          break;
+        case (!set.fontWeight && _Font.weights.includes(part)):
+          if (part !== "inherit") {
+            fontWeight = part;
+          }
+          set.fontStyle = true;
+          set.fontVariant = true;
+          set.fontWeight = true;
+          break;
+        case !set.fontSize:
+          if (part !== "inherit") {
+            [fontSize] = part.split("/");
+          }
+          set.fontStyle = true;
+          set.fontVariant = true;
+          set.fontWeight = true;
+          set.fontSize = true;
+          break;
+        default:
+          if (part !== "inherit") {
+            fontFamily += part;
+          }
+      }
+    });
+    return new _Font(fontStyle, fontVariant, fontWeight, fontSize, fontFamily, inherit);
+  }
+  toString() {
+    return [
+      prepareFontStyle(this.fontStyle),
+      this.fontVariant,
+      prepareFontWeight(this.fontWeight),
+      this.fontSize,
+      // Wrap fontFamily only on nodejs and only for canvas.ctx
+      prepareFontFamily(this.fontFamily)
+    ].join(" ").trim();
+  }
+};
+Font.styles = "normal|italic|oblique|inherit";
+Font.variants = "normal|small-caps|inherit";
+Font.weights = "normal|bold|bolder|lighter|100|200|300|400|500|600|700|800|900|inherit";
+var BoundingBox = class {
+  constructor() {
+    var x1 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : Number.NaN;
+    var y1 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : Number.NaN;
+    var x2 = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : Number.NaN;
+    var y2 = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : Number.NaN;
+    this.x1 = x1;
+    this.y1 = y1;
+    this.x2 = x2;
+    this.y2 = y2;
+    this.addPoint(x1, y1);
+    this.addPoint(x2, y2);
+  }
+  get x() {
+    return this.x1;
+  }
+  get y() {
+    return this.y1;
+  }
+  get width() {
+    return this.x2 - this.x1;
+  }
+  get height() {
+    return this.y2 - this.y1;
+  }
+  addPoint(x, y2) {
+    if (typeof x !== "undefined") {
+      if (isNaN(this.x1) || isNaN(this.x2)) {
+        this.x1 = x;
+        this.x2 = x;
+      }
+      if (x < this.x1) {
+        this.x1 = x;
+      }
+      if (x > this.x2) {
+        this.x2 = x;
+      }
+    }
+    if (typeof y2 !== "undefined") {
+      if (isNaN(this.y1) || isNaN(this.y2)) {
+        this.y1 = y2;
+        this.y2 = y2;
+      }
+      if (y2 < this.y1) {
+        this.y1 = y2;
+      }
+      if (y2 > this.y2) {
+        this.y2 = y2;
+      }
+    }
+  }
+  addX(x) {
+    this.addPoint(x, null);
+  }
+  addY(y2) {
+    this.addPoint(null, y2);
+  }
+  addBoundingBox(boundingBox) {
+    if (!boundingBox) {
+      return;
+    }
+    var {
+      x1,
+      y1,
+      x2,
+      y2
+    } = boundingBox;
+    this.addPoint(x1, y1);
+    this.addPoint(x2, y2);
+  }
+  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 a2 = -3 * p0 + 9 * p1 - 9 * p2 + 3 * p3;
+    var c3 = 3 * p1 - 3 * p0;
+    if (a2 === 0) {
+      if (b === 0) {
+        return;
+      }
+      var t2 = -c3 / b;
+      if (0 < t2 && t2 < 1) {
+        if (forX) {
+          this.addX(this.sumCubic(t2, p0, p1, p2, p3));
+        } else {
+          this.addY(this.sumCubic(t2, p0, p1, p2, p3));
+        }
+      }
+      return;
+    }
+    var b2ac = Math.pow(b, 2) - 4 * c3 * a2;
+    if (b2ac < 0) {
+      return;
+    }
+    var t1 = (-b + Math.sqrt(b2ac)) / (2 * a2);
+    if (0 < t1 && t1 < 1) {
+      if (forX) {
+        this.addX(this.sumCubic(t1, p0, p1, p2, p3));
+      } else {
+        this.addY(this.sumCubic(t1, p0, p1, p2, p3));
+      }
+    }
+    var t22 = (-b - Math.sqrt(b2ac)) / (2 * a2);
+    if (0 < t22 && t22 < 1) {
+      if (forX) {
+        this.addX(this.sumCubic(t22, p0, p1, p2, p3));
+      } else {
+        this.addY(this.sumCubic(t22, p0, p1, p2, p3));
+      }
+    }
+  }
+  // from http://blog.hackers-cafe.net/2009/06/how-to-calculate-bezier-curves-bounding.html
+  addBezierCurve(p0x, p0y, p1x, p1y, p2x, p2y, p3x, p3y) {
+    this.addPoint(p0x, p0y);
+    this.addPoint(p3x, p3y);
+    this.bezierCurveAdd(true, p0x, p1x, p2x, p3x);
+    this.bezierCurveAdd(false, p0y, p1y, p2y, p3y);
+  }
+  addQuadraticCurve(p0x, p0y, p1x, p1y, p2x, p2y) {
+    var cp1x = p0x + 2 / 3 * (p1x - p0x);
+    var cp1y = p0y + 2 / 3 * (p1y - p0y);
+    var cp2x = cp1x + 1 / 3 * (p2x - p0x);
+    var cp2y = cp1y + 1 / 3 * (p2y - p0y);
+    this.addBezierCurve(p0x, p0y, cp1x, cp2x, cp1y, cp2y, p2x, p2y);
+  }
+  isPointInBox(x, y2) {
+    var {
+      x1,
+      y1,
+      x2,
+      y2: y22
+    } = this;
+    return x1 <= x && x <= x2 && y1 <= y2 && y2 <= y22;
+  }
+};
+var PathParser = class extends _ {
+  constructor(path) {
+    super(path.replace(/([+\-.])\s+/gm, "$1").replace(/[^MmZzLlHhVvCcSsQqTtAae\d\s.,+-].*/g, ""));
+    this.control = null;
+    this.start = null;
+    this.current = null;
+    this.command = null;
+    this.commands = this.commands;
+    this.i = -1;
+    this.previousCommand = null;
+    this.points = [];
+    this.angles = [];
+  }
+  reset() {
+    this.i = -1;
+    this.command = null;
+    this.previousCommand = null;
+    this.start = new Point(0, 0);
+    this.control = new Point(0, 0);
+    this.current = new Point(0, 0);
+    this.points = [];
+    this.angles = [];
+  }
+  isEnd() {
+    var {
+      i: i2,
+      commands
+    } = this;
+    return i2 >= commands.length - 1;
+  }
+  next() {
+    var command = this.commands[++this.i];
+    this.previousCommand = this.command;
+    this.command = command;
+    return command;
+  }
+  getPoint() {
+    var xProp = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "x";
+    var yProp = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "y";
+    var point = new Point(this.command[xProp], this.command[yProp]);
+    return this.makeAbsolute(point);
+  }
+  getAsControlPoint(xProp, yProp) {
+    var point = this.getPoint(xProp, yProp);
+    this.control = point;
+    return point;
+  }
+  getAsCurrentPoint(xProp, yProp) {
+    var point = this.getPoint(xProp, yProp);
+    this.current = point;
+    return point;
+  }
+  getReflectedControlPoint() {
+    var previousCommand = this.previousCommand.type;
+    if (previousCommand !== _.CURVE_TO && previousCommand !== _.SMOOTH_CURVE_TO && previousCommand !== _.QUAD_TO && previousCommand !== _.SMOOTH_QUAD_TO) {
+      return this.current;
+    }
+    var {
+      current: {
+        x: cx,
+        y: cy
+      },
+      control: {
+        x: ox,
+        y: oy
+      }
+    } = this;
+    var point = new Point(2 * cx - ox, 2 * cy - oy);
+    return point;
+  }
+  makeAbsolute(point) {
+    if (this.command.relative) {
+      var {
+        x,
+        y: y2
+      } = this.current;
+      point.x += x;
+      point.y += y2;
+    }
+    return point;
+  }
+  addMarker(point, from, priorTo) {
+    var {
+      points,
+      angles
+    } = this;
+    if (priorTo && angles.length > 0 && !angles[angles.length - 1]) {
+      angles[angles.length - 1] = points[points.length - 1].angleTo(priorTo);
+    }
+    this.addMarkerAngle(point, from ? from.angleTo(point) : null);
+  }
+  addMarkerAngle(point, angle) {
+    this.points.push(point);
+    this.angles.push(angle);
+  }
+  getMarkerPoints() {
+    return this.points;
+  }
+  getMarkerAngles() {
+    var {
+      angles
+    } = this;
+    var len = angles.length;
+    for (var i2 = 0; i2 < len; i2++) {
+      if (!angles[i2]) {
+        for (var j = i2 + 1; j < len; j++) {
+          if (angles[j]) {
+            angles[i2] = angles[j];
+            break;
+          }
+        }
+      }
+    }
+    return angles;
+  }
+};
+var RenderedElement = class extends Element {
+  constructor() {
+    super(...arguments);
+    this.modifiedEmSizeStack = false;
+  }
+  calculateOpacity() {
+    var opacity = 1;
+    var element = this;
+    while (element) {
+      var opacityStyle = element.getStyle("opacity", false, true);
+      if (opacityStyle.hasValue(true)) {
+        opacity *= opacityStyle.getNumber();
+      }
+      element = element.parent;
+    }
+    return opacity;
+  }
+  setContext(ctx) {
+    var fromMeasure = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+    if (!fromMeasure) {
+      var fillStyleProp = this.getStyle("fill");
+      var fillOpacityStyleProp = this.getStyle("fill-opacity");
+      var strokeStyleProp = this.getStyle("stroke");
+      var strokeOpacityProp = this.getStyle("stroke-opacity");
+      if (fillStyleProp.isUrlDefinition()) {
+        var fillStyle = fillStyleProp.getFillStyleDefinition(this, fillOpacityStyleProp);
+        if (fillStyle) {
+          ctx.fillStyle = fillStyle;
+        }
+      } else if (fillStyleProp.hasValue()) {
+        if (fillStyleProp.getString() === "currentColor") {
+          fillStyleProp.setValue(this.getStyle("color").getColor());
+        }
+        var _fillStyle = fillStyleProp.getColor();
+        if (_fillStyle !== "inherit") {
+          ctx.fillStyle = _fillStyle === "none" ? "rgba(0,0,0,0)" : _fillStyle;
+        }
+      }
+      if (fillOpacityStyleProp.hasValue()) {
+        var _fillStyle2 = new Property(this.document, "fill", ctx.fillStyle).addOpacity(fillOpacityStyleProp).getColor();
+        ctx.fillStyle = _fillStyle2;
+      }
+      if (strokeStyleProp.isUrlDefinition()) {
+        var strokeStyle = strokeStyleProp.getFillStyleDefinition(this, strokeOpacityProp);
+        if (strokeStyle) {
+          ctx.strokeStyle = strokeStyle;
+        }
+      } else if (strokeStyleProp.hasValue()) {
+        if (strokeStyleProp.getString() === "currentColor") {
+          strokeStyleProp.setValue(this.getStyle("color").getColor());
+        }
+        var _strokeStyle = strokeStyleProp.getString();
+        if (_strokeStyle !== "inherit") {
+          ctx.strokeStyle = _strokeStyle === "none" ? "rgba(0,0,0,0)" : _strokeStyle;
+        }
+      }
+      if (strokeOpacityProp.hasValue()) {
+        var _strokeStyle2 = new Property(this.document, "stroke", ctx.strokeStyle).addOpacity(strokeOpacityProp).getString();
+        ctx.strokeStyle = _strokeStyle2;
+      }
+      var strokeWidthStyleProp = this.getStyle("stroke-width");
+      if (strokeWidthStyleProp.hasValue()) {
+        var newLineWidth = strokeWidthStyleProp.getPixels();
+        ctx.lineWidth = !newLineWidth ? PSEUDO_ZERO : newLineWidth;
+      }
+      var strokeLinecapStyleProp = this.getStyle("stroke-linecap");
+      var strokeLinejoinStyleProp = this.getStyle("stroke-linejoin");
+      var strokeMiterlimitProp = this.getStyle("stroke-miterlimit");
+      var strokeDasharrayStyleProp = this.getStyle("stroke-dasharray");
+      var strokeDashoffsetProp = this.getStyle("stroke-dashoffset");
+      if (strokeLinecapStyleProp.hasValue()) {
+        ctx.lineCap = strokeLinecapStyleProp.getString();
+      }
+      if (strokeLinejoinStyleProp.hasValue()) {
+        ctx.lineJoin = strokeLinejoinStyleProp.getString();
+      }
+      if (strokeMiterlimitProp.hasValue()) {
+        ctx.miterLimit = strokeMiterlimitProp.getNumber();
+      }
+      if (strokeDasharrayStyleProp.hasValue() && strokeDasharrayStyleProp.getString() !== "none") {
+        var gaps = toNumbers(strokeDasharrayStyleProp.getString());
+        if (typeof ctx.setLineDash !== "undefined") {
+          ctx.setLineDash(gaps);
+        } else if (typeof ctx.webkitLineDash !== "undefined") {
+          ctx.webkitLineDash = gaps;
+        } else if (typeof ctx.mozDash !== "undefined" && !(gaps.length === 1 && gaps[0] === 0)) {
+          ctx.mozDash = gaps;
+        }
+        var offset = strokeDashoffsetProp.getPixels();
+        if (typeof ctx.lineDashOffset !== "undefined") {
+          ctx.lineDashOffset = offset;
+        } else if (typeof ctx.webkitLineDashOffset !== "undefined") {
+          ctx.webkitLineDashOffset = offset;
+        } else if (typeof ctx.mozDashOffset !== "undefined") {
+          ctx.mozDashOffset = offset;
+        }
+      }
+    }
+    this.modifiedEmSizeStack = false;
+    if (typeof ctx.font !== "undefined") {
+      var fontStyleProp = this.getStyle("font");
+      var fontStyleStyleProp = this.getStyle("font-style");
+      var fontVariantStyleProp = this.getStyle("font-variant");
+      var fontWeightStyleProp = this.getStyle("font-weight");
+      var fontSizeStyleProp = this.getStyle("font-size");
+      var fontFamilyStyleProp = this.getStyle("font-family");
+      var font = new Font(fontStyleStyleProp.getString(), fontVariantStyleProp.getString(), fontWeightStyleProp.getString(), fontSizeStyleProp.hasValue() ? "".concat(fontSizeStyleProp.getPixels(true), "px") : "", fontFamilyStyleProp.getString(), Font.parse(fontStyleProp.getString(), ctx.font));
+      fontStyleStyleProp.setValue(font.fontStyle);
+      fontVariantStyleProp.setValue(font.fontVariant);
+      fontWeightStyleProp.setValue(font.fontWeight);
+      fontSizeStyleProp.setValue(font.fontSize);
+      fontFamilyStyleProp.setValue(font.fontFamily);
+      ctx.font = font.toString();
+      if (fontSizeStyleProp.isPixels()) {
+        this.document.emSize = fontSizeStyleProp.getPixels();
+        this.modifiedEmSizeStack = true;
+      }
+    }
+    if (!fromMeasure) {
+      this.applyEffects(ctx);
+      ctx.globalAlpha = this.calculateOpacity();
+    }
+  }
+  clearContext(ctx) {
+    super.clearContext(ctx);
+    if (this.modifiedEmSizeStack) {
+      this.document.popEmSize();
+    }
+  }
+};
+var PathElement = class _PathElement extends RenderedElement {
+  constructor(document2, node2, captureTextNodes) {
+    super(document2, node2, captureTextNodes);
+    this.type = "path";
+    this.pathParser = null;
+    this.pathParser = new PathParser(this.getAttribute("d").getString());
+  }
+  path(ctx) {
+    var {
+      pathParser
+    } = this;
+    var boundingBox = new BoundingBox();
+    pathParser.reset();
+    if (ctx) {
+      ctx.beginPath();
+    }
+    while (!pathParser.isEnd()) {
+      switch (pathParser.next().type) {
+        case PathParser.MOVE_TO:
+          this.pathM(ctx, boundingBox);
+          break;
+        case PathParser.LINE_TO:
+          this.pathL(ctx, boundingBox);
+          break;
+        case PathParser.HORIZ_LINE_TO:
+          this.pathH(ctx, boundingBox);
+          break;
+        case PathParser.VERT_LINE_TO:
+          this.pathV(ctx, boundingBox);
+          break;
+        case PathParser.CURVE_TO:
+          this.pathC(ctx, boundingBox);
+          break;
+        case PathParser.SMOOTH_CURVE_TO:
+          this.pathS(ctx, boundingBox);
+          break;
+        case PathParser.QUAD_TO:
+          this.pathQ(ctx, boundingBox);
+          break;
+        case PathParser.SMOOTH_QUAD_TO:
+          this.pathT(ctx, boundingBox);
+          break;
+        case PathParser.ARC:
+          this.pathA(ctx, boundingBox);
+          break;
+        case PathParser.CLOSE_PATH:
+          this.pathZ(ctx, boundingBox);
+          break;
+      }
+    }
+    return boundingBox;
+  }
+  getBoundingBox(_2) {
+    return this.path();
+  }
+  getMarkers() {
+    var {
+      pathParser
+    } = this;
+    var points = pathParser.getMarkerPoints();
+    var angles = pathParser.getMarkerAngles();
+    var markers = points.map((point, i2) => [point, angles[i2]]);
+    return markers;
+  }
+  renderChildren(ctx) {
+    this.path(ctx);
+    this.document.screen.mouse.checkPath(this, ctx);
+    var fillRuleStyleProp = this.getStyle("fill-rule");
+    if (ctx.fillStyle !== "") {
+      if (fillRuleStyleProp.getString("inherit") !== "inherit") {
+        ctx.fill(fillRuleStyleProp.getString());
+      } else {
+        ctx.fill();
+      }
+    }
+    if (ctx.strokeStyle !== "") {
+      if (this.getAttribute("vector-effect").getString() === "non-scaling-stroke") {
+        ctx.save();
+        ctx.setTransform(1, 0, 0, 1, 0, 0);
+        ctx.stroke();
+        ctx.restore();
+      } else {
+        ctx.stroke();
+      }
+    }
+    var markers = this.getMarkers();
+    if (markers) {
+      var markersLastIndex = markers.length - 1;
+      var markerStartStyleProp = this.getStyle("marker-start");
+      var markerMidStyleProp = this.getStyle("marker-mid");
+      var markerEndStyleProp = this.getStyle("marker-end");
+      if (markerStartStyleProp.isUrlDefinition()) {
+        var marker = markerStartStyleProp.getDefinition();
+        var [point, angle] = markers[0];
+        marker.render(ctx, point, angle);
+      }
+      if (markerMidStyleProp.isUrlDefinition()) {
+        var _marker = markerMidStyleProp.getDefinition();
+        for (var i2 = 1; i2 < markersLastIndex; i2++) {
+          var [_point, _angle] = markers[i2];
+          _marker.render(ctx, _point, _angle);
+        }
+      }
+      if (markerEndStyleProp.isUrlDefinition()) {
+        var _marker2 = markerEndStyleProp.getDefinition();
+        var [_point2, _angle2] = markers[markersLastIndex];
+        _marker2.render(ctx, _point2, _angle2);
+      }
+    }
+  }
+  static pathM(pathParser) {
+    var point = pathParser.getAsCurrentPoint();
+    pathParser.start = pathParser.current;
+    return {
+      point
+    };
+  }
+  pathM(ctx, boundingBox) {
+    var {
+      pathParser
+    } = this;
+    var {
+      point
+    } = _PathElement.pathM(pathParser);
+    var {
+      x,
+      y: y2
+    } = point;
+    pathParser.addMarker(point);
+    boundingBox.addPoint(x, y2);
+    if (ctx) {
+      ctx.moveTo(x, y2);
+    }
+  }
+  static pathL(pathParser) {
+    var {
+      current
+    } = pathParser;
+    var point = pathParser.getAsCurrentPoint();
+    return {
+      current,
+      point
+    };
+  }
+  pathL(ctx, boundingBox) {
+    var {
+      pathParser
+    } = this;
+    var {
+      current,
+      point
+    } = _PathElement.pathL(pathParser);
+    var {
+      x,
+      y: y2
+    } = point;
+    pathParser.addMarker(point, current);
+    boundingBox.addPoint(x, y2);
+    if (ctx) {
+      ctx.lineTo(x, y2);
+    }
+  }
+  static pathH(pathParser) {
+    var {
+      current,
+      command
+    } = pathParser;
+    var point = new Point((command.relative ? current.x : 0) + command.x, current.y);
+    pathParser.current = point;
+    return {
+      current,
+      point
+    };
+  }
+  pathH(ctx, boundingBox) {
+    var {
+      pathParser
+    } = this;
+    var {
+      current,
+      point
+    } = _PathElement.pathH(pathParser);
+    var {
+      x,
+      y: y2
+    } = point;
+    pathParser.addMarker(point, current);
+    boundingBox.addPoint(x, y2);
+    if (ctx) {
+      ctx.lineTo(x, y2);
+    }
+  }
+  static pathV(pathParser) {
+    var {
+      current,
+      command
+    } = pathParser;
+    var point = new Point(current.x, (command.relative ? current.y : 0) + command.y);
+    pathParser.current = point;
+    return {
+      current,
+      point
+    };
+  }
+  pathV(ctx, boundingBox) {
+    var {
+      pathParser
+    } = this;
+    var {
+      current,
+      point
+    } = _PathElement.pathV(pathParser);
+    var {
+      x,
+      y: y2
+    } = point;
+    pathParser.addMarker(point, current);
+    boundingBox.addPoint(x, y2);
+    if (ctx) {
+      ctx.lineTo(x, y2);
+    }
+  }
+  static pathC(pathParser) {
+    var {
+      current
+    } = pathParser;
+    var point = pathParser.getPoint("x1", "y1");
+    var controlPoint = pathParser.getAsControlPoint("x2", "y2");
+    var currentPoint = pathParser.getAsCurrentPoint();
+    return {
+      current,
+      point,
+      controlPoint,
+      currentPoint
+    };
+  }
+  pathC(ctx, boundingBox) {
+    var {
+      pathParser
+    } = this;
+    var {
+      current,
+      point,
+      controlPoint,
+      currentPoint
+    } = _PathElement.pathC(pathParser);
+    pathParser.addMarker(currentPoint, controlPoint, point);
+    boundingBox.addBezierCurve(current.x, current.y, point.x, point.y, controlPoint.x, controlPoint.y, currentPoint.x, currentPoint.y);
+    if (ctx) {
+      ctx.bezierCurveTo(point.x, point.y, controlPoint.x, controlPoint.y, currentPoint.x, currentPoint.y);
+    }
+  }
+  static pathS(pathParser) {
+    var {
+      current
+    } = pathParser;
+    var point = pathParser.getReflectedControlPoint();
+    var controlPoint = pathParser.getAsControlPoint("x2", "y2");
+    var currentPoint = pathParser.getAsCurrentPoint();
+    return {
+      current,
+      point,
+      controlPoint,
+      currentPoint
+    };
+  }
+  pathS(ctx, boundingBox) {
+    var {
+      pathParser
+    } = this;
+    var {
+      current,
+      point,
+      controlPoint,
+      currentPoint
+    } = _PathElement.pathS(pathParser);
+    pathParser.addMarker(currentPoint, controlPoint, point);
+    boundingBox.addBezierCurve(current.x, current.y, point.x, point.y, controlPoint.x, controlPoint.y, currentPoint.x, currentPoint.y);
+    if (ctx) {
+      ctx.bezierCurveTo(point.x, point.y, controlPoint.x, controlPoint.y, currentPoint.x, currentPoint.y);
+    }
+  }
+  static pathQ(pathParser) {
+    var {
+      current
+    } = pathParser;
+    var controlPoint = pathParser.getAsControlPoint("x1", "y1");
+    var currentPoint = pathParser.getAsCurrentPoint();
+    return {
+      current,
+      controlPoint,
+      currentPoint
+    };
+  }
+  pathQ(ctx, boundingBox) {
+    var {
+      pathParser
+    } = this;
+    var {
+      current,
+      controlPoint,
+      currentPoint
+    } = _PathElement.pathQ(pathParser);
+    pathParser.addMarker(currentPoint, controlPoint, controlPoint);
+    boundingBox.addQuadraticCurve(current.x, current.y, controlPoint.x, controlPoint.y, currentPoint.x, currentPoint.y);
+    if (ctx) {
+      ctx.quadraticCurveTo(controlPoint.x, controlPoint.y, currentPoint.x, currentPoint.y);
+    }
+  }
+  static pathT(pathParser) {
+    var {
+      current
+    } = pathParser;
+    var controlPoint = pathParser.getReflectedControlPoint();
+    pathParser.control = controlPoint;
+    var currentPoint = pathParser.getAsCurrentPoint();
+    return {
+      current,
+      controlPoint,
+      currentPoint
+    };
+  }
+  pathT(ctx, boundingBox) {
+    var {
+      pathParser
+    } = this;
+    var {
+      current,
+      controlPoint,
+      currentPoint
+    } = _PathElement.pathT(pathParser);
+    pathParser.addMarker(currentPoint, controlPoint, controlPoint);
+    boundingBox.addQuadraticCurve(current.x, current.y, controlPoint.x, controlPoint.y, currentPoint.x, currentPoint.y);
+    if (ctx) {
+      ctx.quadraticCurveTo(controlPoint.x, controlPoint.y, currentPoint.x, currentPoint.y);
+    }
+  }
+  static pathA(pathParser) {
+    var {
+      current,
+      command
+    } = pathParser;
+    var {
+      rX,
+      rY,
+      xRot,
+      lArcFlag,
+      sweepFlag
+    } = command;
+    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 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 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(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 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(u2, v2) >= 1) {
+      ad = 0;
+    }
+    return {
+      currentPoint,
+      rX,
+      rY,
+      sweepFlag,
+      xAxisRotation,
+      centp,
+      a1,
+      ad
+    };
+  }
+  pathA(ctx, boundingBox) {
+    var {
+      pathParser
+    } = this;
+    var {
+      currentPoint,
+      rX,
+      rY,
+      sweepFlag,
+      xAxisRotation,
+      centp,
+      a1,
+      ad
+    } = _PathElement.pathA(pathParser);
+    var dir = 1 - sweepFlag ? 1 : -1;
+    var ah = a1 + dir * (ad / 2);
+    var halfWay = new Point(centp.x + rX * Math.cos(ah), centp.y + rY * Math.sin(ah));
+    pathParser.addMarkerAngle(halfWay, ah - dir * Math.PI / 2);
+    pathParser.addMarkerAngle(currentPoint, ah - dir * Math.PI);
+    boundingBox.addPoint(currentPoint.x, currentPoint.y);
+    if (ctx && !isNaN(a1) && !isNaN(ad)) {
+      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, r2, a1, a1 + ad, Boolean(1 - sweepFlag));
+      ctx.scale(1 / sx, 1 / sy);
+      ctx.rotate(-xAxisRotation);
+      ctx.translate(-centp.x, -centp.y);
+    }
+  }
+  static pathZ(pathParser) {
+    pathParser.current = pathParser.start;
+  }
+  pathZ(ctx, boundingBox) {
+    _PathElement.pathZ(this.pathParser);
+    if (ctx) {
+      if (boundingBox.x1 !== boundingBox.x2 && boundingBox.y1 !== boundingBox.y2) {
+        ctx.closePath();
+      }
+    }
+  }
+};
+var GlyphElement = class extends PathElement {
+  constructor(document2, node2, captureTextNodes) {
+    super(document2, node2, captureTextNodes);
+    this.type = "glyph";
+    this.horizAdvX = this.getAttribute("horiz-adv-x").getNumber();
+    this.unicode = this.getAttribute("unicode").getString();
+    this.arabicForm = this.getAttribute("arabic-form").getString();
+  }
+};
+var TextElement = class _TextElement extends RenderedElement {
+  constructor(document2, node2, captureTextNodes) {
+    super(document2, node2, new.target === _TextElement ? true : captureTextNodes);
+    this.type = "text";
+    this.x = 0;
+    this.y = 0;
+    this.measureCache = -1;
+  }
+  setContext(ctx) {
+    var fromMeasure = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+    super.setContext(ctx, fromMeasure);
+    var textBaseline = this.getStyle("dominant-baseline").getTextBaseline() || this.getStyle("alignment-baseline").getTextBaseline();
+    if (textBaseline) {
+      ctx.textBaseline = textBaseline;
+    }
+  }
+  initializeCoordinates() {
+    this.x = 0;
+    this.y = 0;
+    this.leafTexts = [];
+    this.textChunkStart = 0;
+    this.minX = Number.POSITIVE_INFINITY;
+    this.maxX = Number.NEGATIVE_INFINITY;
+  }
+  getBoundingBox(ctx) {
+    if (this.type !== "text") {
+      return this.getTElementBoundingBox(ctx);
+    }
+    this.initializeCoordinates();
+    this.adjustChildCoordinatesRecursive(ctx);
+    var boundingBox = null;
+    this.children.forEach((_2, i2) => {
+      var childBoundingBox = this.getChildBoundingBox(ctx, this, this, i2);
+      if (!boundingBox) {
+        boundingBox = childBoundingBox;
+      } else {
+        boundingBox.addBoundingBox(childBoundingBox);
+      }
+    });
+    return boundingBox;
+  }
+  getFontSize() {
+    var {
+      document: document2,
+      parent
+    } = this;
+    var inheritFontSize = Font.parse(document2.ctx.font).fontSize;
+    var fontSize = parent.getStyle("font-size").getNumber(inheritFontSize);
+    return fontSize;
+  }
+  getTElementBoundingBox(ctx) {
+    var fontSize = this.getFontSize();
+    return new BoundingBox(this.x, this.y - fontSize, this.x + this.measureText(ctx), this.y);
+  }
+  getGlyph(font, text, i2) {
+    var char = text[i2];
+    var glyph = null;
+    if (font.isArabic) {
+      var len = text.length;
+      var prevChar = text[i2 - 1];
+      var nextChar = text[i2 + 1];
+      var arabicForm = "isolated";
+      if ((i2 === 0 || prevChar === " ") && i2 < len - 1 && nextChar !== " ") {
+        arabicForm = "terminal";
+      }
+      if (i2 > 0 && prevChar !== " " && i2 < len - 1 && nextChar !== " ") {
+        arabicForm = "medial";
+      }
+      if (i2 > 0 && prevChar !== " " && (i2 === len - 1 || nextChar === " ")) {
+        arabicForm = "initial";
+      }
+      if (typeof font.glyphs[char] !== "undefined") {
+        var maybeGlyph = font.glyphs[char];
+        glyph = maybeGlyph instanceof GlyphElement ? maybeGlyph : maybeGlyph[arabicForm];
+      }
+    } else {
+      glyph = font.glyphs[char];
+    }
+    if (!glyph) {
+      glyph = font.missingGlyph;
+    }
+    return glyph;
+  }
+  getText() {
+    return "";
+  }
+  getTextFromNode(node2) {
+    var textNode = node2 || this.node;
+    var childNodes = Array.from(textNode.parentNode.childNodes);
+    var index2 = childNodes.indexOf(textNode);
+    var lastIndex = childNodes.length - 1;
+    var text = compressSpaces(
+      // textNode.value
+      // || textNode.text
+      textNode.textContent || ""
+    );
+    if (index2 === 0) {
+      text = trimLeft(text);
+    }
+    if (index2 === lastIndex) {
+      text = trimRight(text);
+    }
+    return text;
+  }
+  renderChildren(ctx) {
+    if (this.type !== "text") {
+      this.renderTElementChildren(ctx);
+      return;
+    }
+    this.initializeCoordinates();
+    this.adjustChildCoordinatesRecursive(ctx);
+    this.children.forEach((_2, i2) => {
+      this.renderChild(ctx, this, this, i2);
+    });
+    var {
+      mouse
+    } = this.document.screen;
+    if (mouse.isWorking()) {
+      mouse.checkBoundingBox(this, this.getBoundingBox(ctx));
+    }
+  }
+  renderTElementChildren(ctx) {
+    var {
+      document: document2,
+      parent
+    } = this;
+    var renderText = this.getText();
+    var customFont = parent.getStyle("font-family").getDefinition();
+    if (customFont) {
+      var {
+        unitsPerEm
+      } = customFont.fontFace;
+      var ctxFont = Font.parse(document2.ctx.font);
+      var fontSize = parent.getStyle("font-size").getNumber(ctxFont.fontSize);
+      var fontStyle = parent.getStyle("font-style").getString(ctxFont.fontStyle);
+      var scale = fontSize / unitsPerEm;
+      var text = customFont.isRTL ? renderText.split("").reverse().join("") : renderText;
+      var dx = toNumbers(parent.getAttribute("dx").getString());
+      var len = text.length;
+      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;
+        ctx.lineWidth = ctx.lineWidth * unitsPerEm / fontSize;
+        if (fontStyle === "italic") {
+          ctx.transform(1, 0, 0.4, 1, 0, 0);
+        }
+        glyph.render(ctx);
+        if (fontStyle === "italic") {
+          ctx.transform(1, 0, -0.4, 1, 0, 0);
+        }
+        ctx.lineWidth = lw;
+        ctx.scale(1 / scale, -1 / scale);
+        ctx.translate(-this.x, -this.y);
+        this.x += fontSize * (glyph.horizAdvX || customFont.horizAdvX) / unitsPerEm;
+        if (typeof dx[i2] !== "undefined" && !isNaN(dx[i2])) {
+          this.x += dx[i2];
+        }
+      }
+      return;
+    }
+    var {
+      x,
+      y: y2
+    } = this;
+    if (ctx.fillStyle) {
+      ctx.fillText(renderText, x, y2);
+    }
+    if (ctx.strokeStyle) {
+      ctx.strokeText(renderText, x, y2);
+    }
+  }
+  applyAnchoring() {
+    if (this.textChunkStart >= this.leafTexts.length) {
+      return;
+    }
+    var firstElement = this.leafTexts[this.textChunkStart];
+    var textAnchor = firstElement.getStyle("text-anchor").getString("start");
+    var isRTL = false;
+    var shift = 0;
+    if (textAnchor === "start" && !isRTL || textAnchor === "end" && isRTL) {
+      shift = firstElement.x - this.minX;
+    } else if (textAnchor === "end" && !isRTL || textAnchor === "start" && isRTL) {
+      shift = firstElement.x - this.maxX;
+    } else {
+      shift = firstElement.x - (this.minX + this.maxX) / 2;
+    }
+    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, i2) => {
+      this.adjustChildCoordinatesRecursiveCore(ctx, this, this, i2);
+    });
+    this.applyAnchoring();
+  }
+  adjustChildCoordinatesRecursiveCore(ctx, textParent, parent, i2) {
+    var child = parent.children[i2];
+    if (child.children.length > 0) {
+      child.children.forEach((_2, i3) => {
+        textParent.adjustChildCoordinatesRecursiveCore(ctx, textParent, child, i3);
+      });
+    } else {
+      this.adjustChildCoordinates(ctx, textParent, parent, i2);
+    }
+  }
+  adjustChildCoordinates(ctx, textParent, parent, i2) {
+    var child = parent.children[i2];
+    if (typeof child.measureText !== "function") {
+      return child;
+    }
+    ctx.save();
+    child.setContext(ctx, true);
+    var xAttr = child.getAttribute("x");
+    var yAttr = child.getAttribute("y");
+    var dxAttr = child.getAttribute("dx");
+    var dyAttr = child.getAttribute("dy");
+    var customFont = child.getStyle("font-family").getDefinition();
+    var isRTL = Boolean(customFont) && customFont.isRTL;
+    if (i2 === 0) {
+      if (!xAttr.hasValue()) {
+        xAttr.setValue(child.getInheritedAttribute("x"));
+      }
+      if (!yAttr.hasValue()) {
+        yAttr.setValue(child.getInheritedAttribute("y"));
+      }
+      if (!dxAttr.hasValue()) {
+        dxAttr.setValue(child.getInheritedAttribute("dx"));
+      }
+      if (!dyAttr.hasValue()) {
+        dyAttr.setValue(child.getInheritedAttribute("dy"));
+      }
+    }
+    var width = child.measureText(ctx);
+    if (isRTL) {
+      textParent.x -= width;
+    }
+    if (xAttr.hasValue()) {
+      textParent.applyAnchoring();
+      child.x = xAttr.getPixels("x");
+      if (dxAttr.hasValue()) {
+        child.x += dxAttr.getPixels("x");
+      }
+    } else {
+      if (dxAttr.hasValue()) {
+        textParent.x += dxAttr.getPixels("x");
+      }
+      child.x = textParent.x;
+    }
+    textParent.x = child.x;
+    if (!isRTL) {
+      textParent.x += width;
+    }
+    if (yAttr.hasValue()) {
+      child.y = yAttr.getPixels("y");
+      if (dyAttr.hasValue()) {
+        child.y += dyAttr.getPixels("y");
+      }
+    } else {
+      if (dyAttr.hasValue()) {
+        textParent.y += dyAttr.getPixels("y");
+      }
+      child.y = textParent.y;
+    }
+    textParent.y = child.y;
+    textParent.leafTexts.push(child);
+    textParent.minX = Math.min(textParent.minX, child.x, child.x + width);
+    textParent.maxX = Math.max(textParent.maxX, child.x, child.x + width);
+    child.clearContext(ctx);
+    ctx.restore();
+    return child;
+  }
+  getChildBoundingBox(ctx, textParent, parent, i2) {
+    var child = parent.children[i2];
+    if (typeof child.getBoundingBox !== "function") {
+      return null;
+    }
+    var boundingBox = child.getBoundingBox(ctx);
+    if (!boundingBox) {
+      return null;
+    }
+    child.children.forEach((_2, i3) => {
+      var childBoundingBox = textParent.getChildBoundingBox(ctx, textParent, child, i3);
+      boundingBox.addBoundingBox(childBoundingBox);
+    });
+    return boundingBox;
+  }
+  renderChild(ctx, textParent, parent, i2) {
+    var child = parent.children[i2];
+    child.render(ctx);
+    child.children.forEach((_2, i3) => {
+      textParent.renderChild(ctx, textParent, child, i3);
+    });
+  }
+  measureText(ctx) {
+    var {
+      measureCache
+    } = this;
+    if (~measureCache) {
+      return measureCache;
+    }
+    var renderText = this.getText();
+    var measure = this.measureTargetText(ctx, renderText);
+    this.measureCache = measure;
+    return measure;
+  }
+  measureTargetText(ctx, targetText) {
+    if (!targetText.length) {
+      return 0;
+    }
+    var {
+      parent
+    } = this;
+    var customFont = parent.getStyle("font-family").getDefinition();
+    if (customFont) {
+      var fontSize = this.getFontSize();
+      var text = customFont.isRTL ? targetText.split("").reverse().join("") : targetText;
+      var dx = toNumbers(parent.getAttribute("dx").getString());
+      var len = text.length;
+      var _measure = 0;
+      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[i2] !== "undefined" && !isNaN(dx[i2])) {
+          _measure += dx[i2];
+        }
+      }
+      return _measure;
+    }
+    if (!ctx.measureText) {
+      return targetText.length * 10;
+    }
+    ctx.save();
+    this.setContext(ctx, true);
+    var {
+      width: measure
+    } = ctx.measureText(targetText);
+    this.clearContext(ctx);
+    ctx.restore();
+    return measure;
+  }
+  /**
+   * Inherits positional attributes from {@link TextElement} parent(s). Attributes
+   * are only inherited from a parent to its first child.
+   * @param name - The attribute name.
+   * @returns The attribute value or null.
+   */
+  getInheritedAttribute(name) {
+    var current = this;
+    while (current instanceof _TextElement && current.isFirstChild()) {
+      var parentAttr = current.parent.getAttribute(name);
+      if (parentAttr.hasValue(true)) {
+        return parentAttr.getValue("0");
+      }
+      current = current.parent;
+    }
+    return null;
+  }
+};
+var TSpanElement = class _TSpanElement extends TextElement {
+  constructor(document2, node2, captureTextNodes) {
+    super(document2, node2, new.target === _TSpanElement ? true : captureTextNodes);
+    this.type = "tspan";
+    this.text = this.children.length > 0 ? "" : this.getTextFromNode();
+  }
+  getText() {
+    return this.text;
+  }
+};
+var TextNode = class extends TSpanElement {
+  constructor() {
+    super(...arguments);
+    this.type = "textNode";
+  }
+};
+var SVGElement = class extends RenderedElement {
+  constructor() {
+    super(...arguments);
+    this.type = "svg";
+    this.root = false;
+  }
+  setContext(ctx) {
+    var _this$node$parentNode;
+    var {
+      document: document2
+    } = this;
+    var {
+      screen,
+      window: window2
+    } = document2;
+    var canvas = ctx.canvas;
+    screen.setDefaults(ctx);
+    if (canvas.style && typeof ctx.font !== "undefined" && window2 && typeof window2.getComputedStyle !== "undefined") {
+      ctx.font = window2.getComputedStyle(canvas).getPropertyValue("font");
+      var fontSizeProp = new Property(document2, "fontSize", Font.parse(ctx.font).fontSize);
+      if (fontSizeProp.hasValue()) {
+        document2.rootEmSize = fontSizeProp.getPixels("y");
+        document2.emSize = document2.rootEmSize;
+      }
+    }
+    if (!this.getAttribute("x").hasValue()) {
+      this.getAttribute("x", true).setValue(0);
+    }
+    if (!this.getAttribute("y").hasValue()) {
+      this.getAttribute("y", true).setValue(0);
+    }
+    var {
+      width,
+      height
+    } = screen.viewPort;
+    if (!this.getStyle("width").hasValue()) {
+      this.getStyle("width", true).setValue("100%");
+    }
+    if (!this.getStyle("height").hasValue()) {
+      this.getStyle("height", true).setValue("100%");
+    }
+    if (!this.getStyle("color").hasValue()) {
+      this.getStyle("color", true).setValue("black");
+    }
+    var refXAttr = this.getAttribute("refX");
+    var refYAttr = this.getAttribute("refY");
+    var viewBoxAttr = this.getAttribute("viewBox");
+    var viewBox = viewBoxAttr.hasValue() ? toNumbers(viewBoxAttr.getString()) : null;
+    var clip = !this.root && this.getStyle("overflow").getValue("hidden") !== "visible";
+    var minX = 0;
+    var minY = 0;
+    var clipX = 0;
+    var clipY = 0;
+    if (viewBox) {
+      minX = viewBox[0];
+      minY = viewBox[1];
+    }
+    if (!this.root) {
+      width = this.getStyle("width").getPixels("x");
+      height = this.getStyle("height").getPixels("y");
+      if (this.type === "marker") {
+        clipX = minX;
+        clipY = minY;
+        minX = 0;
+        minY = 0;
+      }
+    }
+    screen.viewPort.setCurrent(width, height);
+    if (this.node && (!this.parent || ((_this$node$parentNode = this.node.parentNode) === null || _this$node$parentNode === void 0 ? void 0 : _this$node$parentNode.nodeName) === "foreignObject") && this.getStyle("transform", false, true).hasValue() && !this.getStyle("transform-origin", false, true).hasValue()) {
+      this.getStyle("transform-origin", true, true).setValue("50% 50%");
+    }
+    super.setContext(ctx);
+    ctx.translate(this.getAttribute("x").getPixels("x"), this.getAttribute("y").getPixels("y"));
+    if (viewBox) {
+      width = viewBox[2];
+      height = viewBox[3];
+    }
+    document2.setViewBox({
+      ctx,
+      aspectRatio: this.getAttribute("preserveAspectRatio").getString(),
+      width: screen.viewPort.width,
+      desiredWidth: width,
+      height: screen.viewPort.height,
+      desiredHeight: height,
+      minX,
+      minY,
+      refX: refXAttr.getValue(),
+      refY: refYAttr.getValue(),
+      clip,
+      clipX,
+      clipY
+    });
+    if (viewBox) {
+      screen.viewPort.removeCurrent();
+      screen.viewPort.setCurrent(width, height);
+    }
+  }
+  clearContext(ctx) {
+    super.clearContext(ctx);
+    this.document.screen.viewPort.removeCurrent();
+  }
+  /**
+   * Resize SVG to fit in given size.
+   * @param width
+   * @param height
+   * @param preserveAspectRatio
+   */
+  resize(width) {
+    var height = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : width;
+    var preserveAspectRatio = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+    var widthAttr = this.getAttribute("width", true);
+    var heightAttr = this.getAttribute("height", true);
+    var viewBoxAttr = this.getAttribute("viewBox");
+    var styleAttr = this.getAttribute("style");
+    var originWidth = widthAttr.getNumber(0);
+    var originHeight = heightAttr.getNumber(0);
+    if (preserveAspectRatio) {
+      if (typeof preserveAspectRatio === "string") {
+        this.getAttribute("preserveAspectRatio", true).setValue(preserveAspectRatio);
+      } else {
+        var preserveAspectRatioAttr = this.getAttribute("preserveAspectRatio");
+        if (preserveAspectRatioAttr.hasValue()) {
+          preserveAspectRatioAttr.setValue(preserveAspectRatioAttr.getString().replace(/^\s*(\S.*\S)\s*$/, "$1"));
+        }
+      }
+    }
+    widthAttr.setValue(width);
+    heightAttr.setValue(height);
+    if (!viewBoxAttr.hasValue()) {
+      viewBoxAttr.setValue("0 0 ".concat(originWidth || width, " ").concat(originHeight || height));
+    }
+    if (styleAttr.hasValue()) {
+      var widthStyle = this.getStyle("width");
+      var heightStyle = this.getStyle("height");
+      if (widthStyle.hasValue()) {
+        widthStyle.setValue("".concat(width, "px"));
+      }
+      if (heightStyle.hasValue()) {
+        heightStyle.setValue("".concat(height, "px"));
+      }
+    }
+  }
+};
+var RectElement = class extends PathElement {
+  constructor() {
+    super(...arguments);
+    this.type = "rect";
+  }
+  path(ctx) {
+    var x = this.getAttribute("x").getPixels("x");
+    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");
+    var ryAttr = this.getAttribute("ry");
+    var rx = rxAttr.getPixels("x");
+    var ry = ryAttr.getPixels("y");
+    if (rxAttr.hasValue() && !ryAttr.hasValue()) {
+      ry = rx;
+    }
+    if (ryAttr.hasValue() && !rxAttr.hasValue()) {
+      rx = ry;
+    }
+    rx = Math.min(rx, width / 2);
+    ry = Math.min(ry, height / 2);
+    if (ctx) {
+      var KAPPA = 4 * ((Math.sqrt(2) - 1) / 3);
+      ctx.beginPath();
+      if (height > 0 && width > 0) {
+        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, y2, x + width, y2 + height);
+  }
+  getMarkers() {
+    return null;
+  }
+};
+var CircleElement = class extends PathElement {
+  constructor() {
+    super(...arguments);
+    this.type = "circle";
+  }
+  path(ctx) {
+    var cx = this.getAttribute("cx").getPixels("x");
+    var cy = this.getAttribute("cy").getPixels("y");
+    var r2 = this.getAttribute("r").getPixels();
+    if (ctx && r2 > 0) {
+      ctx.beginPath();
+      ctx.arc(cx, cy, r2, 0, Math.PI * 2, false);
+      ctx.closePath();
+    }
+    return new BoundingBox(cx - r2, cy - r2, cx + r2, cy + r2);
+  }
+  getMarkers() {
+    return null;
+  }
+};
+var EllipseElement = class extends PathElement {
+  constructor() {
+    super(...arguments);
+    this.type = "ellipse";
+  }
+  path(ctx) {
+    var KAPPA = 4 * ((Math.sqrt(2) - 1) / 3);
+    var rx = this.getAttribute("rx").getPixels("x");
+    var ry = this.getAttribute("ry").getPixels("y");
+    var cx = this.getAttribute("cx").getPixels("x");
+    var cy = this.getAttribute("cy").getPixels("y");
+    if (ctx && rx > 0 && ry > 0) {
+      ctx.beginPath();
+      ctx.moveTo(cx + rx, cy);
+      ctx.bezierCurveTo(cx + rx, cy + KAPPA * ry, cx + KAPPA * rx, cy + ry, cx, cy + ry);
+      ctx.bezierCurveTo(cx - KAPPA * rx, cy + ry, cx - rx, cy + KAPPA * ry, cx - rx, cy);
+      ctx.bezierCurveTo(cx - rx, cy - KAPPA * ry, cx - KAPPA * rx, cy - ry, cx, cy - ry);
+      ctx.bezierCurveTo(cx + KAPPA * rx, cy - ry, cx + rx, cy - KAPPA * ry, cx + rx, cy);
+      ctx.closePath();
+    }
+    return new BoundingBox(cx - rx, cy - ry, cx + rx, cy + ry);
+  }
+  getMarkers() {
+    return null;
+  }
+};
+var LineElement = class extends PathElement {
+  constructor() {
+    super(...arguments);
+    this.type = "line";
+  }
+  getPoints() {
+    return [new Point(this.getAttribute("x1").getPixels("x"), this.getAttribute("y1").getPixels("y")), new Point(this.getAttribute("x2").getPixels("x"), this.getAttribute("y2").getPixels("y"))];
+  }
+  path(ctx) {
+    var [{
+      x: x0,
+      y: y0
+    }, {
+      x: x1,
+      y: y1
+    }] = this.getPoints();
+    if (ctx) {
+      ctx.beginPath();
+      ctx.moveTo(x0, y0);
+      ctx.lineTo(x1, y1);
+    }
+    return new BoundingBox(x0, y0, x1, y1);
+  }
+  getMarkers() {
+    var [p0, p1] = this.getPoints();
+    var a2 = p0.angleTo(p1);
+    return [[p0, a2], [p1, a2]];
+  }
+};
+var PolylineElement = class extends PathElement {
+  constructor(document2, node2, captureTextNodes) {
+    super(document2, node2, captureTextNodes);
+    this.type = "polyline";
+    this.points = [];
+    this.points = Point.parsePath(this.getAttribute("points").getString());
+  }
+  path(ctx) {
+    var {
+      points
+    } = this;
+    var [{
+      x: x0,
+      y: y0
+    }] = points;
+    var boundingBox = new BoundingBox(x0, y0);
+    if (ctx) {
+      ctx.beginPath();
+      ctx.moveTo(x0, y0);
+    }
+    points.forEach((_ref) => {
+      var {
+        x,
+        y: y2
+      } = _ref;
+      boundingBox.addPoint(x, y2);
+      if (ctx) {
+        ctx.lineTo(x, y2);
+      }
+    });
+    return boundingBox;
+  }
+  getMarkers() {
+    var {
+      points
+    } = this;
+    var lastIndex = points.length - 1;
+    var markers = [];
+    points.forEach((point, i2) => {
+      if (i2 === lastIndex) {
+        return;
+      }
+      markers.push([point, point.angleTo(points[i2 + 1])]);
+    });
+    if (markers.length > 0) {
+      markers.push([points[points.length - 1], markers[markers.length - 1][1]]);
+    }
+    return markers;
+  }
+};
+var PolygonElement = class extends PolylineElement {
+  constructor() {
+    super(...arguments);
+    this.type = "polygon";
+  }
+  path(ctx) {
+    var boundingBox = super.path(ctx);
+    var [{
+      x,
+      y: y2
+    }] = this.points;
+    if (ctx) {
+      ctx.lineTo(x, y2);
+      ctx.closePath();
+    }
+    return boundingBox;
+  }
+};
+var PatternElement = class extends Element {
+  constructor() {
+    super(...arguments);
+    this.type = "pattern";
+  }
+  createPattern(ctx, _2, parentOpacityProp) {
+    var width = this.getStyle("width").getPixels("x", true);
+    var height = this.getStyle("height").getPixels("y", true);
+    var patternSvg = new SVGElement(this.document, null);
+    patternSvg.attributes.viewBox = new Property(this.document, "viewBox", this.getAttribute("viewBox").getValue());
+    patternSvg.attributes.width = new Property(this.document, "width", "".concat(width, "px"));
+    patternSvg.attributes.height = new Property(this.document, "height", "".concat(height, "px"));
+    patternSvg.attributes.transform = new Property(this.document, "transform", this.getAttribute("patternTransform").getValue());
+    patternSvg.children = this.children;
+    var patternCanvas = this.document.createCanvas(width, height);
+    var patternCtx = patternCanvas.getContext("2d");
+    var xAttr = this.getAttribute("x");
+    var yAttr = this.getAttribute("y");
+    if (xAttr.hasValue() && yAttr.hasValue()) {
+      patternCtx.translate(xAttr.getPixels("x", true), yAttr.getPixels("y", true));
+    }
+    if (parentOpacityProp.hasValue()) {
+      this.styles["fill-opacity"] = parentOpacityProp;
+    } else {
+      Reflect.deleteProperty(this.styles, "fill-opacity");
+    }
+    for (var x = -1; x <= 1; x++) {
+      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", y2 * patternCanvas.height);
+        patternSvg.render(patternCtx);
+        patternCtx.restore();
+      }
+    }
+    var pattern = ctx.createPattern(patternCanvas, "repeat");
+    return pattern;
+  }
+};
+var MarkerElement = class extends Element {
+  constructor() {
+    super(...arguments);
+    this.type = "marker";
+  }
+  render(ctx, point, angle) {
+    if (!point) {
+      return;
+    }
+    var {
+      x,
+      y: y2
+    } = point;
+    var orient = this.getAttribute("orient").getString("auto");
+    var markerUnits = this.getAttribute("markerUnits").getString("strokeWidth");
+    ctx.translate(x, y2);
+    if (orient === "auto") {
+      ctx.rotate(angle);
+    }
+    if (markerUnits === "strokeWidth") {
+      ctx.scale(ctx.lineWidth, ctx.lineWidth);
+    }
+    ctx.save();
+    var markerSvg = new SVGElement(this.document, null);
+    markerSvg.type = this.type;
+    markerSvg.attributes.viewBox = new Property(this.document, "viewBox", this.getAttribute("viewBox").getValue());
+    markerSvg.attributes.refX = new Property(this.document, "refX", this.getAttribute("refX").getValue());
+    markerSvg.attributes.refY = new Property(this.document, "refY", this.getAttribute("refY").getValue());
+    markerSvg.attributes.width = new Property(this.document, "width", this.getAttribute("markerWidth").getValue());
+    markerSvg.attributes.height = new Property(this.document, "height", this.getAttribute("markerHeight").getValue());
+    markerSvg.attributes.overflow = new Property(this.document, "overflow", this.getAttribute("overflow").getValue());
+    markerSvg.attributes.fill = new Property(this.document, "fill", this.getAttribute("fill").getColor("black"));
+    markerSvg.attributes.stroke = new Property(this.document, "stroke", this.getAttribute("stroke").getValue("none"));
+    markerSvg.children = this.children;
+    markerSvg.render(ctx);
+    ctx.restore();
+    if (markerUnits === "strokeWidth") {
+      ctx.scale(1 / ctx.lineWidth, 1 / ctx.lineWidth);
+    }
+    if (orient === "auto") {
+      ctx.rotate(-angle);
+    }
+    ctx.translate(-x, -y2);
+  }
+};
+var DefsElement = class extends Element {
+  constructor() {
+    super(...arguments);
+    this.type = "defs";
+  }
+  render() {
+  }
+};
+var GElement = class extends RenderedElement {
+  constructor() {
+    super(...arguments);
+    this.type = "g";
+  }
+  getBoundingBox(ctx) {
+    var boundingBox = new BoundingBox();
+    this.children.forEach((child) => {
+      boundingBox.addBoundingBox(child.getBoundingBox(ctx));
+    });
+    return boundingBox;
+  }
+};
+var GradientElement = class extends Element {
+  constructor(document2, node2, captureTextNodes) {
+    super(document2, node2, captureTextNodes);
+    this.attributesToInherit = ["gradientUnits"];
+    this.stops = [];
+    var {
+      stops,
+      children
+    } = this;
+    children.forEach((child) => {
+      if (child.type === "stop") {
+        stops.push(child);
+      }
+    });
+  }
+  getGradientUnits() {
+    return this.getAttribute("gradientUnits").getString("objectBoundingBox");
+  }
+  createGradient(ctx, element, parentOpacityProp) {
+    var stopsContainer = this;
+    if (this.getHrefAttribute().hasValue()) {
+      stopsContainer = this.getHrefAttribute().getDefinition();
+      this.inheritStopContainer(stopsContainer);
+    }
+    var {
+      stops
+    } = stopsContainer;
+    var gradient = this.getGradient(ctx, element);
+    if (!gradient) {
+      return this.addParentOpacity(parentOpacityProp, stops[stops.length - 1].color);
+    }
+    stops.forEach((stop) => {
+      gradient.addColorStop(stop.offset, this.addParentOpacity(parentOpacityProp, stop.color));
+    });
+    if (this.getAttribute("gradientTransform").hasValue()) {
+      var {
+        document: document2
+      } = this;
+      var {
+        MAX_VIRTUAL_PIXELS,
+        viewPort
+      } = document2.screen;
+      var [rootView] = viewPort.viewPorts;
+      var rect = new RectElement(document2, null);
+      rect.attributes.x = new Property(document2, "x", -MAX_VIRTUAL_PIXELS / 3);
+      rect.attributes.y = new Property(document2, "y", -MAX_VIRTUAL_PIXELS / 3);
+      rect.attributes.width = new Property(document2, "width", MAX_VIRTUAL_PIXELS);
+      rect.attributes.height = new Property(document2, "height", MAX_VIRTUAL_PIXELS);
+      var group = new GElement(document2, null);
+      group.attributes.transform = new Property(document2, "transform", this.getAttribute("gradientTransform").getValue());
+      group.children = [rect];
+      var patternSvg = new SVGElement(document2, null);
+      patternSvg.attributes.x = new Property(document2, "x", 0);
+      patternSvg.attributes.y = new Property(document2, "y", 0);
+      patternSvg.attributes.width = new Property(document2, "width", rootView.width);
+      patternSvg.attributes.height = new Property(document2, "height", rootView.height);
+      patternSvg.children = [group];
+      var patternCanvas = document2.createCanvas(rootView.width, rootView.height);
+      var patternCtx = patternCanvas.getContext("2d");
+      patternCtx.fillStyle = gradient;
+      patternSvg.render(patternCtx);
+      return patternCtx.createPattern(patternCanvas, "no-repeat");
+    }
+    return gradient;
+  }
+  inheritStopContainer(stopsContainer) {
+    this.attributesToInherit.forEach((attributeToInherit) => {
+      if (!this.getAttribute(attributeToInherit).hasValue() && stopsContainer.getAttribute(attributeToInherit).hasValue()) {
+        this.getAttribute(attributeToInherit, true).setValue(stopsContainer.getAttribute(attributeToInherit).getValue());
+      }
+    });
+  }
+  addParentOpacity(parentOpacityProp, color) {
+    if (parentOpacityProp.hasValue()) {
+      var colorProp = new Property(this.document, "color", color);
+      return colorProp.addOpacity(parentOpacityProp).getColor();
+    }
+    return color;
+  }
+};
+var LinearGradientElement = class extends GradientElement {
+  constructor(document2, node2, captureTextNodes) {
+    super(document2, node2, captureTextNodes);
+    this.type = "linearGradient";
+    this.attributesToInherit.push("x1", "y1", "x2", "y2");
+  }
+  getGradient(ctx, element) {
+    var isBoundingBoxUnits = this.getGradientUnits() === "objectBoundingBox";
+    var boundingBox = isBoundingBoxUnits ? element.getBoundingBox(ctx) : null;
+    if (isBoundingBoxUnits && !boundingBox) {
+      return null;
+    }
+    if (!this.getAttribute("x1").hasValue() && !this.getAttribute("y1").hasValue() && !this.getAttribute("x2").hasValue() && !this.getAttribute("y2").hasValue()) {
+      this.getAttribute("x1", true).setValue(0);
+      this.getAttribute("y1", true).setValue(0);
+      this.getAttribute("x2", true).setValue(1);
+      this.getAttribute("y2", true).setValue(0);
+    }
+    var x1 = isBoundingBoxUnits ? boundingBox.x + boundingBox.width * this.getAttribute("x1").getNumber() : this.getAttribute("x1").getPixels("x");
+    var y1 = isBoundingBoxUnits ? boundingBox.y + boundingBox.height * this.getAttribute("y1").getNumber() : this.getAttribute("y1").getPixels("y");
+    var x2 = isBoundingBoxUnits ? boundingBox.x + boundingBox.width * this.getAttribute("x2").getNumber() : this.getAttribute("x2").getPixels("x");
+    var y2 = isBoundingBoxUnits ? boundingBox.y + boundingBox.height * this.getAttribute("y2").getNumber() : this.getAttribute("y2").getPixels("y");
+    if (x1 === x2 && y1 === y2) {
+      return null;
+    }
+    return ctx.createLinearGradient(x1, y1, x2, y2);
+  }
+};
+var RadialGradientElement = class extends GradientElement {
+  constructor(document2, node2, captureTextNodes) {
+    super(document2, node2, captureTextNodes);
+    this.type = "radialGradient";
+    this.attributesToInherit.push("cx", "cy", "r", "fx", "fy", "fr");
+  }
+  getGradient(ctx, element) {
+    var isBoundingBoxUnits = this.getGradientUnits() === "objectBoundingBox";
+    var boundingBox = element.getBoundingBox(ctx);
+    if (isBoundingBoxUnits && !boundingBox) {
+      return null;
+    }
+    if (!this.getAttribute("cx").hasValue()) {
+      this.getAttribute("cx", true).setValue("50%");
+    }
+    if (!this.getAttribute("cy").hasValue()) {
+      this.getAttribute("cy", true).setValue("50%");
+    }
+    if (!this.getAttribute("r").hasValue()) {
+      this.getAttribute("r", true).setValue("50%");
+    }
+    var cx = isBoundingBoxUnits ? boundingBox.x + boundingBox.width * this.getAttribute("cx").getNumber() : this.getAttribute("cx").getPixels("x");
+    var cy = isBoundingBoxUnits ? boundingBox.y + boundingBox.height * this.getAttribute("cy").getNumber() : this.getAttribute("cy").getPixels("y");
+    var fx = cx;
+    var fy = cy;
+    if (this.getAttribute("fx").hasValue()) {
+      fx = isBoundingBoxUnits ? boundingBox.x + boundingBox.width * this.getAttribute("fx").getNumber() : this.getAttribute("fx").getPixels("x");
+    }
+    if (this.getAttribute("fy").hasValue()) {
+      fy = isBoundingBoxUnits ? boundingBox.y + boundingBox.height * this.getAttribute("fy").getNumber() : this.getAttribute("fy").getPixels("y");
+    }
+    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, r2);
+  }
+};
+var StopElement = class extends Element {
+  constructor(document2, node2, captureTextNodes) {
+    super(document2, node2, captureTextNodes);
+    this.type = "stop";
+    var offset = Math.max(0, Math.min(1, this.getAttribute("offset").getNumber()));
+    var stopOpacity = this.getStyle("stop-opacity");
+    var stopColor = this.getStyle("stop-color", true);
+    if (stopColor.getString() === "") {
+      stopColor.setValue("#000");
+    }
+    if (stopOpacity.hasValue()) {
+      stopColor = stopColor.addOpacity(stopOpacity);
+    }
+    this.offset = offset;
+    this.color = stopColor.getColor();
+  }
+};
+var AnimateElement = class extends Element {
+  constructor(document2, node2, captureTextNodes) {
+    super(document2, node2, captureTextNodes);
+    this.type = "animate";
+    this.duration = 0;
+    this.initialValue = null;
+    this.initialUnits = "";
+    this.removed = false;
+    this.frozen = false;
+    document2.screen.animations.push(this);
+    this.begin = this.getAttribute("begin").getMilliseconds();
+    this.maxDuration = this.begin + this.getAttribute("dur").getMilliseconds();
+    this.from = this.getAttribute("from");
+    this.to = this.getAttribute("to");
+    this.values = new Property(document2, "values", null);
+    var valuesAttr = this.getAttribute("values");
+    if (valuesAttr.hasValue()) {
+      this.values.setValue(valuesAttr.getString().split(";"));
+    }
+  }
+  getProperty() {
+    var attributeType = this.getAttribute("attributeType").getString();
+    var attributeName = this.getAttribute("attributeName").getString();
+    if (attributeType === "CSS") {
+      return this.parent.getStyle(attributeName, true);
+    }
+    return this.parent.getAttribute(attributeName, true);
+  }
+  calcValue() {
+    var {
+      initialUnits
+    } = this;
+    var {
+      progress,
+      from,
+      to
+    } = this.getProgress();
+    var newValue = from.getNumber() + (to.getNumber() - from.getNumber()) * progress;
+    if (initialUnits === "%") {
+      newValue *= 100;
+    }
+    return "".concat(newValue).concat(initialUnits);
+  }
+  update(delta) {
+    var {
+      parent
+    } = this;
+    var prop = this.getProperty();
+    if (!this.initialValue) {
+      this.initialValue = prop.getString();
+      this.initialUnits = prop.getUnits();
+    }
+    if (this.duration > this.maxDuration) {
+      var fill = this.getAttribute("fill").getString("remove");
+      if (this.getAttribute("repeatCount").getString() === "indefinite" || this.getAttribute("repeatDur").getString() === "indefinite") {
+        this.duration = 0;
+      } else if (fill === "freeze" && !this.frozen) {
+        this.frozen = true;
+        parent.animationFrozen = true;
+        parent.animationFrozenValue = prop.getString();
+      } else if (fill === "remove" && !this.removed) {
+        this.removed = true;
+        prop.setValue(parent.animationFrozen ? parent.animationFrozenValue : this.initialValue);
+        return true;
+      }
+      return false;
+    }
+    this.duration += delta;
+    var updated = false;
+    if (this.begin < this.duration) {
+      var newValue = this.calcValue();
+      var typeAttr = this.getAttribute("type");
+      if (typeAttr.hasValue()) {
+        var type = typeAttr.getString();
+        newValue = "".concat(type, "(").concat(newValue, ")");
+      }
+      prop.setValue(newValue);
+      updated = true;
+    }
+    return updated;
+  }
+  getProgress() {
+    var {
+      document: document2,
+      values
+    } = this;
+    var result = {
+      progress: (this.duration - this.begin) / (this.maxDuration - this.begin)
+    };
+    if (values.hasValue()) {
+      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 = (p2 - lb) / (ub - lb);
+    } else {
+      result.from = this.from;
+      result.to = this.to;
+    }
+    return result;
+  }
+};
+var AnimateColorElement = class extends AnimateElement {
+  constructor() {
+    super(...arguments);
+    this.type = "animateColor";
+  }
+  calcValue() {
+    var {
+      progress,
+      from,
+      to
+    } = this.getProgress();
+    var colorFrom = new import_rgbcolor.default(from.getColor());
+    var colorTo = new import_rgbcolor.default(to.getColor());
+    if (colorFrom.ok && colorTo.ok) {
+      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(r2), ", ").concat(Math.floor(g), ", ").concat(Math.floor(b), ")");
+    }
+    return this.getAttribute("from").getColor();
+  }
+};
+var AnimateTransformElement = class extends AnimateElement {
+  constructor() {
+    super(...arguments);
+    this.type = "animateTransform";
+  }
+  calcValue() {
+    var {
+      progress,
+      from,
+      to
+    } = this.getProgress();
+    var transformFrom = toNumbers(from.getString());
+    var transformTo = toNumbers(to.getString());
+    var newValue = transformFrom.map((from2, i2) => {
+      var to2 = transformTo[i2];
+      return from2 + (to2 - from2) * progress;
+    }).join(" ");
+    return newValue;
+  }
+};
+var FontElement = class extends Element {
+  constructor(document2, node2, captureTextNodes) {
+    super(document2, node2, captureTextNodes);
+    this.type = "font";
+    this.glyphs = {};
+    this.horizAdvX = this.getAttribute("horiz-adv-x").getNumber();
+    var {
+      definitions
+    } = document2;
+    var {
+      children
+    } = this;
+    for (var child of children) {
+      switch (child.type) {
+        case "font-face": {
+          this.fontFace = child;
+          var fontFamilyStyle = child.getStyle("font-family");
+          if (fontFamilyStyle.hasValue()) {
+            definitions[fontFamilyStyle.getString()] = this;
+          }
+          break;
+        }
+        case "missing-glyph":
+          this.missingGlyph = child;
+          break;
+        case "glyph": {
+          var glyph = child;
+          if (glyph.arabicForm) {
+            this.isRTL = true;
+            this.isArabic = true;
+            if (typeof this.glyphs[glyph.unicode] === "undefined") {
+              this.glyphs[glyph.unicode] = {};
+            }
+            this.glyphs[glyph.unicode][glyph.arabicForm] = glyph;
+          } else {
+            this.glyphs[glyph.unicode] = glyph;
+          }
+          break;
+        }
+      }
+    }
+  }
+  render() {
+  }
+};
+var FontFaceElement = class extends Element {
+  constructor(document2, node2, captureTextNodes) {
+    super(document2, node2, captureTextNodes);
+    this.type = "font-face";
+    this.ascent = this.getAttribute("ascent").getNumber();
+    this.descent = this.getAttribute("descent").getNumber();
+    this.unitsPerEm = this.getAttribute("units-per-em").getNumber();
+  }
+};
+var MissingGlyphElement = class extends PathElement {
+  constructor() {
+    super(...arguments);
+    this.type = "missing-glyph";
+    this.horizAdvX = 0;
+  }
+};
+var TRefElement = class extends TextElement {
+  constructor() {
+    super(...arguments);
+    this.type = "tref";
+  }
+  getText() {
+    var element = this.getHrefAttribute().getDefinition();
+    if (element) {
+      var firstChild = element.children[0];
+      if (firstChild) {
+        return firstChild.getText();
+      }
+    }
+    return "";
+  }
+};
+var AElement = class extends TextElement {
+  constructor(document2, node2, captureTextNodes) {
+    super(document2, node2, captureTextNodes);
+    this.type = "a";
+    var {
+      childNodes
+    } = node2;
+    var firstChild = childNodes[0];
+    var hasText = childNodes.length > 0 && Array.from(childNodes).every((node3) => node3.nodeType === 3);
+    this.hasText = hasText;
+    this.text = hasText ? this.getTextFromNode(firstChild) : "";
+  }
+  getText() {
+    return this.text;
+  }
+  renderChildren(ctx) {
+    if (this.hasText) {
+      super.renderChildren(ctx);
+      var {
+        document: document2,
+        x,
+        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, y2 - fontSize.getPixels("y"), x + this.measureText(ctx), y2));
+      }
+    } else if (this.children.length > 0) {
+      var g = new GElement(this.document, null);
+      g.children = this.children;
+      g.parent = this;
+      g.render(ctx);
+    }
+  }
+  onClick() {
+    var {
+      window: window2
+    } = this.document;
+    if (window2) {
+      window2.open(this.getHrefAttribute().getString());
+    }
+  }
+  onMouseMove() {
+    var ctx = this.document.ctx;
+    ctx.canvas.style.cursor = "pointer";
+  }
+};
+function ownKeys$2(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    if (enumerableOnly) {
+      symbols = symbols.filter(function(sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+      });
+    }
+    keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread$2(target) {
+  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]);
+      });
+    } else if (Object.getOwnPropertyDescriptors) {
+      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+      ownKeys$2(Object(source)).forEach(function(key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+  }
+  return target;
+}
+var TextPathElement = class extends TextElement {
+  constructor(document2, node2, captureTextNodes) {
+    super(document2, node2, captureTextNodes);
+    this.type = "textPath";
+    this.textWidth = 0;
+    this.textHeight = 0;
+    this.pathLength = -1;
+    this.glyphInfo = null;
+    this.letterSpacingCache = [];
+    this.measuresCache = /* @__PURE__ */ new Map([["", 0]]);
+    var pathElement = this.getHrefAttribute().getDefinition();
+    this.text = this.getTextFromNode();
+    this.dataArray = this.parsePathData(pathElement);
+  }
+  getText() {
+    return this.text;
+  }
+  path(ctx) {
+    var {
+      dataArray
+    } = this;
+    if (ctx) {
+      ctx.beginPath();
+    }
+    dataArray.forEach((_ref) => {
+      var {
+        type,
+        points
+      } = _ref;
+      switch (type) {
+        case PathParser.LINE_TO:
+          if (ctx) {
+            ctx.lineTo(points[0], points[1]);
+          }
+          break;
+        case PathParser.MOVE_TO:
+          if (ctx) {
+            ctx.moveTo(points[0], points[1]);
+          }
+          break;
+        case PathParser.CURVE_TO:
+          if (ctx) {
+            ctx.bezierCurveTo(points[0], points[1], points[2], points[3], points[4], points[5]);
+          }
+          break;
+        case PathParser.QUAD_TO:
+          if (ctx) {
+            ctx.quadraticCurveTo(points[0], points[1], points[2], points[3]);
+          }
+          break;
+        case PathParser.ARC: {
+          var [cx, cy, rx, ry, theta, dTheta, psi, fs] = points;
+          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, r2, theta, theta + dTheta, Boolean(1 - fs));
+            ctx.scale(1 / scaleX, 1 / scaleY);
+            ctx.rotate(-psi);
+            ctx.translate(-cx, -cy);
+          }
+          break;
+        }
+        case PathParser.CLOSE_PATH:
+          if (ctx) {
+            ctx.closePath();
+          }
+          break;
+      }
+    });
+  }
+  renderChildren(ctx) {
+    this.setTextData(ctx);
+    ctx.save();
+    var textDecoration = this.parent.getStyle("text-decoration").getString();
+    var fontSize = this.getFontSize();
+    var {
+      glyphInfo
+    } = this;
+    var fill = ctx.fillStyle;
+    if (textDecoration === "underline") {
+      ctx.beginPath();
+    }
+    glyphInfo.forEach((glyph, i2) => {
+      var {
+        p0,
+        p1,
+        rotation,
+        text: partialText
+      } = glyph;
+      ctx.save();
+      ctx.translate(p0.x, p0.y);
+      ctx.rotate(rotation);
+      if (ctx.fillStyle) {
+        ctx.fillText(partialText, 0, 0);
+      }
+      if (ctx.strokeStyle) {
+        ctx.strokeText(partialText, 0, 0);
+      }
+      ctx.restore();
+      if (textDecoration === "underline") {
+        if (i2 === 0) {
+          ctx.moveTo(p0.x, p0.y + fontSize / 8);
+        }
+        ctx.lineTo(p1.x, p1.y + fontSize / 5);
+      }
+    });
+    if (textDecoration === "underline") {
+      ctx.lineWidth = fontSize / 20;
+      ctx.strokeStyle = fill;
+      ctx.stroke();
+      ctx.closePath();
+    }
+    ctx.restore();
+  }
+  getLetterSpacingAt() {
+    var idx = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0;
+    return this.letterSpacingCache[idx] || 0;
+  }
+  findSegmentToFitChar(ctx, anchor, textFullWidth, fullPathWidth, spacesNumber, inputOffset, dy, c3, charI) {
+    var offset = inputOffset;
+    var glyphWidth = this.measureText(ctx, c3);
+    if (c3 === " " && anchor === "justify" && textFullWidth < fullPathWidth) {
+      glyphWidth += (fullPathWidth - textFullWidth) / spacesNumber;
+    }
+    if (charI > -1) {
+      offset += this.getLetterSpacingAt(charI);
+    }
+    var splineStep = this.textHeight / 20;
+    var p0 = this.getEquidistantPointOnPath(offset, splineStep, 0);
+    var p1 = this.getEquidistantPointOnPath(offset + glyphWidth, splineStep, 0);
+    var segment = {
+      p0,
+      p1
+    };
+    var rotation = p0 && p1 ? Math.atan2(p1.y - p0.y, p1.x - p0.x) : 0;
+    if (dy) {
+      var dyX = Math.cos(Math.PI / 2 + rotation) * dy;
+      var dyY = Math.cos(-rotation) * dy;
+      segment.p0 = _objectSpread$2(_objectSpread$2({}, p0), {}, {
+        x: p0.x + dyX,
+        y: p0.y + dyY
+      });
+      segment.p1 = _objectSpread$2(_objectSpread$2({}, p1), {}, {
+        x: p1.x + dyX,
+        y: p1.y + dyY
+      });
+    }
+    offset += glyphWidth;
+    return {
+      offset,
+      segment,
+      rotation
+    };
+  }
+  measureText(ctx, text) {
+    var {
+      measuresCache
+    } = this;
+    var targetText = text || this.getText();
+    if (measuresCache.has(targetText)) {
+      return measuresCache.get(targetText);
+    }
+    var measure = this.measureTargetText(ctx, targetText);
+    measuresCache.set(targetText, measure);
+    return measure;
+  }
+  // This method supposes what all custom fonts already loaded.
+  // If some font will be loaded after this method call, <textPath> will not be rendered correctly.
+  // You need to call this method manually to update glyphs cache.
+  setTextData(ctx) {
+    if (this.glyphInfo) {
+      return;
+    }
+    var renderText = this.getText();
+    var chars = renderText.split("");
+    var spacesNumber = renderText.split(" ").length - 1;
+    var dx = this.parent.getAttribute("dx").split().map((_2) => _2.getPixels("x"));
+    var dy = this.parent.getAttribute("dy").getPixels("y");
+    var anchor = this.parent.getStyle("text-anchor").getString("start");
+    var thisSpacing = this.getStyle("letter-spacing");
+    var parentSpacing = this.parent.getStyle("letter-spacing");
+    var letterSpacing = 0;
+    if (!thisSpacing.hasValue() || thisSpacing.getValue() === "inherit") {
+      letterSpacing = parentSpacing.getPixels();
+    } else if (thisSpacing.hasValue()) {
+      if (thisSpacing.getValue() !== "initial" && thisSpacing.getValue() !== "unset") {
+        letterSpacing = thisSpacing.getPixels();
+      }
+    }
+    var letterSpacingCache = [];
+    var textLen = renderText.length;
+    this.letterSpacingCache = letterSpacingCache;
+    for (var i2 = 0; i2 < textLen; i2++) {
+      letterSpacingCache.push(typeof dx[i2] !== "undefined" ? dx[i2] : letterSpacing);
+    }
+    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;
+    this.textHeight = this.getFontSize();
+    this.glyphInfo = [];
+    var fullPathWidth = this.getPathLength();
+    var startOffset = this.getStyle("startOffset").getNumber(0) * fullPathWidth;
+    var offset = 0;
+    if (anchor === "middle" || anchor === "center") {
+      offset = -textFullWidth / 2;
+    }
+    if (anchor === "end" || anchor === "right") {
+      offset = -textFullWidth;
+    }
+    offset += startOffset;
+    chars.forEach((char, i3) => {
+      var {
+        offset: nextOffset,
+        segment,
+        rotation
+      } = this.findSegmentToFitChar(ctx, anchor, textFullWidth, fullPathWidth, spacesNumber, offset, dy, char, i3);
+      offset = nextOffset;
+      if (!segment.p0 || !segment.p1) {
+        return;
+      }
+      this.glyphInfo.push({
+        // transposeX: midpoint.x,
+        // transposeY: midpoint.y,
+        text: chars[i3],
+        p0: segment.p0,
+        p1: segment.p1,
+        rotation
+      });
+    });
+  }
+  parsePathData(path) {
+    this.pathLength = -1;
+    if (!path) {
+      return [];
+    }
+    var pathCommands = [];
+    var {
+      pathParser
+    } = path;
+    pathParser.reset();
+    while (!pathParser.isEnd()) {
+      var {
+        current
+      } = pathParser;
+      var startX = current ? current.x : 0;
+      var startY = current ? current.y : 0;
+      var command = pathParser.next();
+      var nextCommandType = command.type;
+      var points = [];
+      switch (command.type) {
+        case PathParser.MOVE_TO:
+          this.pathM(pathParser, points);
+          break;
+        case PathParser.LINE_TO:
+          nextCommandType = this.pathL(pathParser, points);
+          break;
+        case PathParser.HORIZ_LINE_TO:
+          nextCommandType = this.pathH(pathParser, points);
+          break;
+        case PathParser.VERT_LINE_TO:
+          nextCommandType = this.pathV(pathParser, points);
+          break;
+        case PathParser.CURVE_TO:
+          this.pathC(pathParser, points);
+          break;
+        case PathParser.SMOOTH_CURVE_TO:
+          nextCommandType = this.pathS(pathParser, points);
+          break;
+        case PathParser.QUAD_TO:
+          this.pathQ(pathParser, points);
+          break;
+        case PathParser.SMOOTH_QUAD_TO:
+          nextCommandType = this.pathT(pathParser, points);
+          break;
+        case PathParser.ARC:
+          points = this.pathA(pathParser);
+          break;
+        case PathParser.CLOSE_PATH:
+          PathElement.pathZ(pathParser);
+          break;
+      }
+      if (command.type !== PathParser.CLOSE_PATH) {
+        pathCommands.push({
+          type: nextCommandType,
+          points,
+          start: {
+            x: startX,
+            y: startY
+          },
+          pathLength: this.calcLength(startX, startY, nextCommandType, points)
+        });
+      } else {
+        pathCommands.push({
+          type: PathParser.CLOSE_PATH,
+          points: [],
+          pathLength: 0
+        });
+      }
+    }
+    return pathCommands;
+  }
+  pathM(pathParser, points) {
+    var {
+      x,
+      y: y2
+    } = PathElement.pathM(pathParser).point;
+    points.push(x, y2);
+  }
+  pathL(pathParser, points) {
+    var {
+      x,
+      y: y2
+    } = PathElement.pathL(pathParser).point;
+    points.push(x, y2);
+    return PathParser.LINE_TO;
+  }
+  pathH(pathParser, points) {
+    var {
+      x,
+      y: y2
+    } = PathElement.pathH(pathParser).point;
+    points.push(x, y2);
+    return PathParser.LINE_TO;
+  }
+  pathV(pathParser, points) {
+    var {
+      x,
+      y: y2
+    } = PathElement.pathV(pathParser).point;
+    points.push(x, y2);
+    return PathParser.LINE_TO;
+  }
+  pathC(pathParser, points) {
+    var {
+      point,
+      controlPoint,
+      currentPoint
+    } = PathElement.pathC(pathParser);
+    points.push(point.x, point.y, controlPoint.x, controlPoint.y, currentPoint.x, currentPoint.y);
+  }
+  pathS(pathParser, points) {
+    var {
+      point,
+      controlPoint,
+      currentPoint
+    } = PathElement.pathS(pathParser);
+    points.push(point.x, point.y, controlPoint.x, controlPoint.y, currentPoint.x, currentPoint.y);
+    return PathParser.CURVE_TO;
+  }
+  pathQ(pathParser, points) {
+    var {
+      controlPoint,
+      currentPoint
+    } = PathElement.pathQ(pathParser);
+    points.push(controlPoint.x, controlPoint.y, currentPoint.x, currentPoint.y);
+  }
+  pathT(pathParser, points) {
+    var {
+      controlPoint,
+      currentPoint
+    } = PathElement.pathT(pathParser);
+    points.push(controlPoint.x, controlPoint.y, currentPoint.x, currentPoint.y);
+    return PathParser.QUAD_TO;
+  }
+  pathA(pathParser) {
+    var {
+      rX,
+      rY,
+      sweepFlag,
+      xAxisRotation,
+      centp,
+      a1,
+      ad
+    } = PathElement.pathA(pathParser);
+    if (sweepFlag === 0 && ad > 0) {
+      ad -= 2 * Math.PI;
+    }
+    if (sweepFlag === 1 && ad < 0) {
+      ad += 2 * Math.PI;
+    }
+    return [centp.x, centp.y, rX, rY, a1, ad, xAxisRotation, sweepFlag];
+  }
+  calcLength(x, y2, commandType, points) {
+    var len = 0;
+    var p1 = null;
+    var p2 = null;
+    var t2 = 0;
+    switch (commandType) {
+      case PathParser.LINE_TO:
+        return this.getLineLength(x, y2, points[0], points[1]);
+      case PathParser.CURVE_TO:
+        len = 0;
+        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, 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;
+        }
+        return len;
+      case PathParser.ARC: {
+        len = 0;
+        var start = points[4];
+        var dTheta = points[5];
+        var end = points[4] + dTheta;
+        var inc = Math.PI / 180;
+        if (Math.abs(start - end) < inc) {
+          inc = Math.abs(start - end);
+        }
+        p1 = this.getPointOnEllipticalArc(points[0], points[1], points[2], points[3], start, 0);
+        if (dTheta < 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 (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;
+          }
+        }
+        p2 = this.getPointOnEllipticalArc(points[0], points[1], points[2], points[3], end, 0);
+        len += this.getLineLength(p1.x, p1.y, p2.x, p2.y);
+        return len;
+      }
+    }
+    return 0;
+  }
+  getPointOnLine(dist, p1x, p1y, p2x, p2y) {
+    var fromX = arguments.length > 5 && arguments[5] !== void 0 ? arguments[5] : p1x;
+    var fromY = arguments.length > 6 && arguments[6] !== void 0 ? arguments[6] : p1y;
+    var m3 = (p2y - p1y) / (p2x - p1x + PSEUDO_ZERO);
+    var run = Math.sqrt(dist * dist / (1 + m3 * m3));
+    if (p2x < p1x) {
+      run *= -1;
+    }
+    var rise = m3 * run;
+    var pt = null;
+    if (p2x === p1x) {
+      pt = {
+        x: fromX,
+        y: fromY + rise
+      };
+    } else if ((fromY - p1y) / (fromX - p1x + PSEUDO_ZERO) === m3) {
+      pt = {
+        x: fromX + run,
+        y: fromY + rise
+      };
+    } else {
+      var ix = 0;
+      var iy = 0;
+      var len = this.getLineLength(p1x, p1y, p2x, p2y);
+      if (len < PSEUDO_ZERO) {
+        return null;
+      }
+      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 + m3 * m3));
+      if (p2x < p1x) {
+        run *= -1;
+      }
+      rise = m3 * run;
+      pt = {
+        x: ix + run,
+        y: iy + rise
+      };
+    }
+    return pt;
+  }
+  getPointOnPath(distance) {
+    var fullLen = this.getPathLength();
+    var cumulativePathLength = 0;
+    var p2 = null;
+    if (distance < -5e-5 || distance - 5e-5 > fullLen) {
+      return null;
+    }
+    var {
+      dataArray
+    } = this;
+    for (var command of dataArray) {
+      if (command && (command.pathLength < 5e-5 || cumulativePathLength + command.pathLength + 5e-5 < distance)) {
+        cumulativePathLength += command.pathLength;
+        continue;
+      }
+      var delta = distance - cumulativePathLength;
+      var currentT = 0;
+      switch (command.type) {
+        case PathParser.LINE_TO:
+          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];
+          var dTheta = command.points[5];
+          var end = command.points[4] + dTheta;
+          currentT = start + delta / command.pathLength * dTheta;
+          if (dTheta < 0 && currentT < end || dTheta >= 0 && currentT > end) {
+            break;
+          }
+          p2 = this.getPointOnEllipticalArc(command.points[0], command.points[1], command.points[2], command.points[3], currentT, command.points[6]);
+          break;
+        }
+        case PathParser.CURVE_TO:
+          currentT = delta / command.pathLength;
+          if (currentT > 1) {
+            currentT = 1;
+          }
+          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;
+          }
+          p2 = this.getPointOnQuadraticBezier(currentT, command.start.x, command.start.y, command.points[0], command.points[1], command.points[2], command.points[3]);
+          break;
+      }
+      if (p2) {
+        return p2;
+      }
+      break;
+    }
+    return null;
+  }
+  getLineLength(x1, y1, x2, y2) {
+    return Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
+  }
+  getPathLength() {
+    if (this.pathLength === -1) {
+      this.pathLength = this.dataArray.reduce((length, command) => command.pathLength > 0 ? length + command.pathLength : length, 0);
+    }
+    return this.pathLength;
+  }
+  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 y2 = p4y * CB1(pct) + p3y * CB2(pct) + p2y * CB3(pct) + p1y * CB4(pct);
+    return {
+      x,
+      y: y2
+    };
+  }
+  getPointOnQuadraticBezier(pct, p1x, p1y, p2x, p2y, p3x, p3y) {
+    var x = p3x * QB1(pct) + p2x * QB2(pct) + p1x * QB3(pct);
+    var y2 = p3y * QB1(pct) + p2y * QB2(pct) + p1y * QB3(pct);
+    return {
+      x,
+      y: y2
+    };
+  }
+  getPointOnEllipticalArc(cx, cy, rx, ry, theta, psi) {
+    var cosPsi = Math.cos(psi);
+    var sinPsi = Math.sin(psi);
+    var pt = {
+      x: rx * Math.cos(theta),
+      y: ry * Math.sin(theta)
+    };
+    return {
+      x: cx + (pt.x * cosPsi - pt.y * sinPsi),
+      y: cy + (pt.x * sinPsi + pt.y * cosPsi)
+    };
+  }
+  // TODO need some optimisations. possibly build cache only for curved segments?
+  buildEquidistantCache(inputStep, inputPrecision) {
+    var fullLen = this.getPathLength();
+    var precision = inputPrecision || 0.25;
+    var step = inputStep || fullLen / 100;
+    if (!this.equidistantCache || this.equidistantCache.step !== step || this.equidistantCache.precision !== precision) {
+      this.equidistantCache = {
+        step,
+        precision,
+        points: []
+      };
+      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;
+        }
+        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: l2
+          });
+          s2 -= step;
+        }
+      }
+    }
+  }
+  getEquidistantPointOnPath(targetDistance, step, precision) {
+    this.buildEquidistantCache(step, precision);
+    if (targetDistance < 0 || targetDistance - this.getPathLength() > 5e-5) {
+      return null;
+    }
+    var idx = Math.round(targetDistance / this.getPathLength() * (this.equidistantCache.points.length - 1));
+    return this.equidistantCache.points[idx] || null;
+  }
+};
+var dataUriRegex = /^\s*data:(([^/,;]+\/[^/,;]+)(?:;([^,;=]+=[^,;=]+))?)?(?:;(base64))?,(.*)$/i;
+var ImageElement = class extends RenderedElement {
+  constructor(document2, node2, captureTextNodes) {
+    super(document2, node2, captureTextNodes);
+    this.type = "image";
+    this.loaded = false;
+    var href = this.getHrefAttribute().getString();
+    if (!href) {
+      return;
+    }
+    var isSvg = href.endsWith(".svg") || /^\s*data:image\/svg\+xml/i.test(href);
+    document2.images.push(this);
+    if (!isSvg) {
+      void this.loadImage(href);
+    } else {
+      void this.loadSvg(href);
+    }
+    this.isSvg = isSvg;
+  }
+  loadImage(href) {
+    var _this = this;
+    return _asyncToGenerator(function* () {
+      try {
+        var image = yield _this.document.createImage(href);
+        _this.image = image;
+      } catch (err) {
+        console.error('Error while loading image "'.concat(href, '":'), err);
+      }
+      _this.loaded = true;
+    })();
+  }
+  loadSvg(href) {
+    var _this2 = this;
+    return _asyncToGenerator(function* () {
+      var match = dataUriRegex.exec(href);
+      if (match) {
+        var data = match[5];
+        if (match[4] === "base64") {
+          _this2.image = atob(data);
+        } else {
+          _this2.image = decodeURIComponent(data);
+        }
+      } else {
+        try {
+          var response = yield _this2.document.fetch(href);
+          var svg = yield response.text();
+          _this2.image = svg;
+        } catch (err) {
+          console.error('Error while loading image "'.concat(href, '":'), err);
+        }
+      }
+      _this2.loaded = true;
+    })();
+  }
+  renderChildren(ctx) {
+    var {
+      document: document2,
+      image,
+      loaded
+    } = this;
+    var x = this.getAttribute("x").getPixels("x");
+    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, y2);
+    if (this.isSvg) {
+      var subDocument = document2.canvg.forkString(ctx, this.image, {
+        ignoreMouse: true,
+        ignoreAnimation: true,
+        ignoreDimensions: true,
+        ignoreClear: true,
+        offsetX: 0,
+        offsetY: 0,
+        scaleWidth: width,
+        scaleHeight: height
+      });
+      subDocument.document.documentElement.parent = this;
+      void subDocument.render();
+    } else {
+      var _image = this.image;
+      document2.setViewBox({
+        ctx,
+        aspectRatio: this.getAttribute("preserveAspectRatio").getString(),
+        width,
+        desiredWidth: _image.width,
+        height,
+        desiredHeight: _image.height
+      });
+      if (this.loaded) {
+        if (typeof _image.complete === "undefined" || _image.complete) {
+          ctx.drawImage(_image, 0, 0);
+        }
+      }
+    }
+    ctx.restore();
+  }
+  getBoundingBox() {
+    var x = this.getAttribute("x").getPixels("x");
+    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, y2, x + width, y2 + height);
+  }
+};
+var SymbolElement = class extends RenderedElement {
+  constructor() {
+    super(...arguments);
+    this.type = "symbol";
+  }
+  render(_2) {
+  }
+};
+var SVGFontLoader = class {
+  constructor(document2) {
+    this.document = document2;
+    this.loaded = false;
+    document2.fonts.push(this);
+  }
+  load(fontFamily, url) {
+    var _this = this;
+    return _asyncToGenerator(function* () {
+      try {
+        var {
+          document: document2
+        } = _this;
+        var svgDocument = yield document2.canvg.parser.load(url);
+        var fonts = svgDocument.getElementsByTagName("font");
+        Array.from(fonts).forEach((fontNode) => {
+          var font = document2.createElement(fontNode);
+          document2.definitions[fontFamily] = font;
+        });
+      } catch (err) {
+        console.error('Error while loading font "'.concat(url, '":'), err);
+      }
+      _this.loaded = true;
+    })();
+  }
+};
+var StyleElement = class extends Element {
+  constructor(document2, node2, captureTextNodes) {
+    super(document2, node2, captureTextNodes);
+    this.type = "style";
+    var css = compressSpaces(
+      Array.from(node2.childNodes).map((_2) => _2.textContent).join("").replace(/(\/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*+\/)|(^[\s]*\/\/.*)/gm, "").replace(/@import.*;/g, "")
+      // remove imports
+    );
+    var cssDefs = css.split("}");
+    cssDefs.forEach((_2) => {
+      var def = _2.trim();
+      if (!def) {
+        return;
+      }
+      var cssParts = def.split("{");
+      var cssClasses = cssParts[0].split(",");
+      var cssProps = cssParts[1].split(";");
+      cssClasses.forEach((_3) => {
+        var cssClass = _3.trim();
+        if (!cssClass) {
+          return;
+        }
+        var props = document2.styles[cssClass] || {};
+        cssProps.forEach((cssProp) => {
+          var prop = cssProp.indexOf(":");
+          var name = cssProp.substr(0, prop).trim();
+          var value = cssProp.substr(prop + 1, cssProp.length - prop).trim();
+          if (name && value) {
+            props[name] = new Property(document2, name, value);
+          }
+        });
+        document2.styles[cssClass] = props;
+        document2.stylesSpecificity[cssClass] = getSelectorSpecificity(cssClass);
+        if (cssClass === "@font-face") {
+          var fontFamily = props["font-family"].getString().replace(/"|'/g, "");
+          var srcs = props.src.getString().split(",");
+          srcs.forEach((src) => {
+            if (src.indexOf('format("svg")') > 0) {
+              var url = parseExternalUrl(src);
+              if (url) {
+                void new SVGFontLoader(document2).load(fontFamily, url);
+              }
+            }
+          });
+        }
+      });
+    });
+  }
+};
+StyleElement.parseExternalUrl = parseExternalUrl;
+var UseElement = class extends RenderedElement {
+  constructor() {
+    super(...arguments);
+    this.type = "use";
+  }
+  setContext(ctx) {
+    super.setContext(ctx);
+    var xAttr = this.getAttribute("x");
+    var yAttr = this.getAttribute("y");
+    if (xAttr.hasValue()) {
+      ctx.translate(xAttr.getPixels("x"), 0);
+    }
+    if (yAttr.hasValue()) {
+      ctx.translate(0, yAttr.getPixels("y"));
+    }
+  }
+  path(ctx) {
+    var {
+      element
+    } = this;
+    if (element) {
+      element.path(ctx);
+    }
+  }
+  renderChildren(ctx) {
+    var {
+      document: document2,
+      element
+    } = this;
+    if (element) {
+      var tempSvg = element;
+      if (element.type === "symbol") {
+        tempSvg = new SVGElement(document2, null);
+        tempSvg.attributes.viewBox = new Property(document2, "viewBox", element.getAttribute("viewBox").getString());
+        tempSvg.attributes.preserveAspectRatio = new Property(document2, "preserveAspectRatio", element.getAttribute("preserveAspectRatio").getString());
+        tempSvg.attributes.overflow = new Property(document2, "overflow", element.getAttribute("overflow").getString());
+        tempSvg.children = element.children;
+        element.styles.opacity = new Property(document2, "opacity", this.calculateOpacity());
+      }
+      if (tempSvg.type === "svg") {
+        var widthStyle = this.getStyle("width", false, true);
+        var heightStyle = this.getStyle("height", false, true);
+        if (widthStyle.hasValue()) {
+          tempSvg.attributes.width = new Property(document2, "width", widthStyle.getString());
+        }
+        if (heightStyle.hasValue()) {
+          tempSvg.attributes.height = new Property(document2, "height", heightStyle.getString());
+        }
+      }
+      var oldParent = tempSvg.parent;
+      tempSvg.parent = this;
+      tempSvg.render(ctx);
+      tempSvg.parent = oldParent;
+    }
+  }
+  getBoundingBox(ctx) {
+    var {
+      element
+    } = this;
+    if (element) {
+      return element.getBoundingBox(ctx);
+    }
+    return null;
+  }
+  elementTransform() {
+    var {
+      document: document2,
+      element
+    } = this;
+    return Transform.fromElement(document2, element);
+  }
+  get element() {
+    if (!this.cachedElement) {
+      this.cachedElement = this.getHrefAttribute().getDefinition();
+    }
+    return this.cachedElement;
+  }
+};
+function imGet(img, x, y2, width, _height, rgba) {
+  return img[y2 * width * 4 + x * 4 + rgba];
+}
+function imSet(img, x, y2, width, _height, rgba, val) {
+  img[y2 * width * 4 + x * 4 + rgba] = val;
+}
+function m2(matrix, i2, v2) {
+  var mi = matrix[i2];
+  return mi * v2;
+}
+function c2(a2, m1, m22, m3) {
+  return m1 + Math.cos(a2) * m22 + Math.sin(a2) * m3;
+}
+var FeColorMatrixElement = class extends Element {
+  constructor(document2, node2, captureTextNodes) {
+    super(document2, node2, captureTextNodes);
+    this.type = "feColorMatrix";
+    var matrix = toNumbers(this.getAttribute("values").getString());
+    switch (this.getAttribute("type").getString("matrix")) {
+      case "saturate": {
+        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 a2 = matrix[0] * Math.PI / 180;
+        matrix = [c2(a2, 0.213, 0.787, -0.213), c2(a2, 0.715, -0.715, -0.715), c2(a2, 0.072, -0.072, 0.928), 0, 0, c2(a2, 0.213, -0.213, 0.143), c2(a2, 0.715, 0.285, 0.14), c2(a2, 0.072, -0.072, -0.283), 0, 0, c2(a2, 0.213, -0.213, -0.787), c2(a2, 0.715, -0.715, 0.715), c2(a2, 0.072, 0.928, 0.072), 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1];
+        break;
+      }
+      case "luminanceToAlpha":
+        matrix = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.2125, 0.7154, 0.0721, 0, 0, 0, 0, 0, 0, 1];
+        break;
+    }
+    this.matrix = matrix;
+    this.includeOpacity = this.getAttribute("includeOpacity").hasValue();
+  }
+  apply(ctx, _x, _y, width, height) {
+    var {
+      includeOpacity,
+      matrix
+    } = this;
+    var srcData = ctx.getImageData(0, 0, width, height);
+    for (var y2 = 0; y2 < height; y2++) {
+      for (var x = 0; x < width; x++) {
+        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 = m2(matrix, 0, r2) + m2(matrix, 1, g) + m2(matrix, 2, b) + m2(matrix, 3, a2) + m2(matrix, 4, 1);
+        var ng = m2(matrix, 5, r2) + m2(matrix, 6, g) + m2(matrix, 7, b) + m2(matrix, 8, a2) + m2(matrix, 9, 1);
+        var nb = m2(matrix, 10, r2) + m2(matrix, 11, g) + m2(matrix, 12, b) + m2(matrix, 13, a2) + m2(matrix, 14, 1);
+        var na = m2(matrix, 15, r2) + m2(matrix, 16, g) + m2(matrix, 17, b) + m2(matrix, 18, a2) + m2(matrix, 19, 1);
+        if (includeOpacity) {
+          nr = 0;
+          ng = 0;
+          nb = 0;
+          na *= a2 / 255;
+        }
+        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);
+    ctx.putImageData(srcData, 0, 0);
+  }
+};
+var MaskElement = class _MaskElement extends Element {
+  constructor() {
+    super(...arguments);
+    this.type = "mask";
+  }
+  apply(ctx, element) {
+    var {
+      document: document2
+    } = this;
+    var x = this.getAttribute("x").getPixels("x");
+    var y2 = this.getAttribute("y").getPixels("y");
+    var width = this.getStyle("width").getPixels("x");
+    var height = this.getStyle("height").getPixels("y");
+    if (!width && !height) {
+      var boundingBox = new BoundingBox();
+      this.children.forEach((child) => {
+        boundingBox.addBoundingBox(child.getBoundingBox(ctx));
+      });
+      x = Math.floor(boundingBox.x1);
+      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, y2 + height);
+    var maskCtx = maskCanvas.getContext("2d");
+    document2.screen.setDefaults(maskCtx);
+    this.renderChildren(maskCtx);
+    new FeColorMatrixElement(document2, {
+      nodeType: 1,
+      childNodes: [],
+      attributes: [{
+        nodeName: "type",
+        value: "luminanceToAlpha"
+      }, {
+        nodeName: "includeOpacity",
+        value: "true"
+      }]
+    }).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, y2 + height);
+    ctx.fillStyle = tmpCtx.createPattern(tmpCanvas, "no-repeat");
+    ctx.fillRect(0, 0, x + width, y2 + height);
+    this.restoreStyles(element, ignoredStyles);
+  }
+  render(_2) {
+  }
+};
+MaskElement.ignoreStyles = ["mask", "transform", "clip-path"];
+var noop = () => {
+};
+var ClipPathElement = class extends Element {
+  constructor() {
+    super(...arguments);
+    this.type = "clipPath";
+  }
+  apply(ctx) {
+    var {
+      document: document2
+    } = this;
+    var contextProto = Reflect.getPrototypeOf(ctx);
+    var {
+      beginPath,
+      closePath
+    } = ctx;
+    if (contextProto) {
+      contextProto.beginPath = noop;
+      contextProto.closePath = noop;
+    }
+    Reflect.apply(beginPath, ctx, []);
+    this.children.forEach((child) => {
+      if (typeof child.path === "undefined") {
+        return;
+      }
+      var transform = typeof child.elementTransform !== "undefined" ? child.elementTransform() : null;
+      if (!transform) {
+        transform = Transform.fromElement(document2, child);
+      }
+      if (transform) {
+        transform.apply(ctx);
+      }
+      child.path(ctx);
+      if (contextProto) {
+        contextProto.closePath = closePath;
+      }
+      if (transform) {
+        transform.unapply(ctx);
+      }
+    });
+    Reflect.apply(closePath, ctx, []);
+    ctx.clip();
+    if (contextProto) {
+      contextProto.beginPath = beginPath;
+      contextProto.closePath = closePath;
+    }
+  }
+  render(_2) {
+  }
+};
+var FilterElement = class _FilterElement extends Element {
+  constructor() {
+    super(...arguments);
+    this.type = "filter";
+  }
+  apply(ctx, element) {
+    var {
+      document: document2,
+      children
+    } = this;
+    var boundingBox = element.getBoundingBox(ctx);
+    if (!boundingBox) {
+      return;
+    }
+    var px = 0;
+    var py = 0;
+    children.forEach((child) => {
+      var efd = child.extraFilterDistance || 0;
+      px = Math.max(px, efd);
+      py = Math.max(py, efd);
+    });
+    var width = Math.floor(boundingBox.width);
+    var height = Math.floor(boundingBox.height);
+    var tmpCanvasWidth = width + 2 * px;
+    var tmpCanvasHeight = height + 2 * py;
+    if (tmpCanvasWidth < 1 || tmpCanvasHeight < 1) {
+      return;
+    }
+    var x = Math.floor(boundingBox.x);
+    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, -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, y2 - py, tmpCanvasWidth, tmpCanvasHeight);
+    this.restoreStyles(element, ignoredStyles);
+  }
+  render(_2) {
+  }
+};
+FilterElement.ignoreStyles = ["filter", "transform", "clip-path"];
+var FeDropShadowElement = class extends Element {
+  constructor(document2, node2, captureTextNodes) {
+    super(document2, node2, captureTextNodes);
+    this.type = "feDropShadow";
+    this.addStylesFromStyleDefinition();
+  }
+  apply(_2, _x, _y, _width, _height) {
+  }
+};
+var FeMorphologyElement = class extends Element {
+  constructor() {
+    super(...arguments);
+    this.type = "feMorphology";
+  }
+  apply(_2, _x, _y, _width, _height) {
+  }
+};
+var FeCompositeElement = class extends Element {
+  constructor() {
+    super(...arguments);
+    this.type = "feComposite";
+  }
+  apply(_2, _x, _y, _width, _height) {
+  }
+};
+var FeGaussianBlurElement = class extends Element {
+  constructor(document2, node2, captureTextNodes) {
+    super(document2, node2, captureTextNodes);
+    this.type = "feGaussianBlur";
+    this.blurRadius = Math.floor(this.getAttribute("stdDeviation").getNumber());
+    this.extraFilterDistance = this.blurRadius;
+  }
+  apply(ctx, x, y2, width, height) {
+    var {
+      document: document2,
+      blurRadius
+    } = this;
+    var body = document2.window ? document2.window.document.body : null;
+    var canvas = ctx.canvas;
+    canvas.id = document2.getUniqueId();
+    if (body) {
+      canvas.style.display = "none";
+      body.appendChild(canvas);
+    }
+    processCanvasRGBA(canvas, x, y2, width, height, blurRadius);
+    if (body) {
+      body.removeChild(canvas);
+    }
+  }
+};
+var TitleElement = class extends Element {
+  constructor() {
+    super(...arguments);
+    this.type = "title";
+  }
+};
+var DescElement = class extends Element {
+  constructor() {
+    super(...arguments);
+    this.type = "desc";
+  }
+};
+var elements = {
+  "svg": SVGElement,
+  "rect": RectElement,
+  "circle": CircleElement,
+  "ellipse": EllipseElement,
+  "line": LineElement,
+  "polyline": PolylineElement,
+  "polygon": PolygonElement,
+  "path": PathElement,
+  "pattern": PatternElement,
+  "marker": MarkerElement,
+  "defs": DefsElement,
+  "linearGradient": LinearGradientElement,
+  "radialGradient": RadialGradientElement,
+  "stop": StopElement,
+  "animate": AnimateElement,
+  "animateColor": AnimateColorElement,
+  "animateTransform": AnimateTransformElement,
+  "font": FontElement,
+  "font-face": FontFaceElement,
+  "missing-glyph": MissingGlyphElement,
+  "glyph": GlyphElement,
+  "text": TextElement,
+  "tspan": TSpanElement,
+  "tref": TRefElement,
+  "a": AElement,
+  "textPath": TextPathElement,
+  "image": ImageElement,
+  "g": GElement,
+  "symbol": SymbolElement,
+  "style": StyleElement,
+  "use": UseElement,
+  "mask": MaskElement,
+  "clipPath": ClipPathElement,
+  "filter": FilterElement,
+  "feDropShadow": FeDropShadowElement,
+  "feMorphology": FeMorphologyElement,
+  "feComposite": FeCompositeElement,
+  "feColorMatrix": FeColorMatrixElement,
+  "feGaussianBlur": FeGaussianBlurElement,
+  "title": TitleElement,
+  "desc": DescElement
+};
+function ownKeys$1(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    if (enumerableOnly) {
+      symbols = symbols.filter(function(sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+      });
+    }
+    keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread$1(target) {
+  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]);
+      });
+    } else if (Object.getOwnPropertyDescriptors) {
+      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+      ownKeys$1(Object(source)).forEach(function(key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+  }
+  return target;
+}
+function createCanvas(width, height) {
+  var canvas = document.createElement("canvas");
+  canvas.width = width;
+  canvas.height = height;
+  return canvas;
+}
+function createImage(_x) {
+  return _createImage.apply(this, arguments);
+}
+function _createImage() {
+  _createImage = _asyncToGenerator(function* (src) {
+    var anonymousCrossOrigin = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+    var image = document.createElement("img");
+    if (anonymousCrossOrigin) {
+      image.crossOrigin = "Anonymous";
+    }
+    return new Promise((resolve, reject) => {
+      image.onload = () => {
+        resolve(image);
+      };
+      image.onerror = (_event, _source, _lineno, _colno, error) => {
+        reject(error);
+      };
+      image.src = src;
+    });
+  });
+  return _createImage.apply(this, arguments);
+}
+var Document = class _Document {
+  constructor(canvg) {
+    var {
+      rootEmSize = 12,
+      emSize = 12,
+      createCanvas: createCanvas2 = _Document.createCanvas,
+      createImage: createImage2 = _Document.createImage,
+      anonymousCrossOrigin
+    } = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    this.canvg = canvg;
+    this.definitions = {};
+    this.styles = {};
+    this.stylesSpecificity = {};
+    this.images = [];
+    this.fonts = [];
+    this.emSizeStack = [];
+    this.uniqueId = 0;
+    this.screen = canvg.screen;
+    this.rootEmSize = rootEmSize;
+    this.emSize = emSize;
+    this.createCanvas = createCanvas2;
+    this.createImage = this.bindCreateImage(createImage2, anonymousCrossOrigin);
+    this.screen.wait(this.isImagesLoaded.bind(this));
+    this.screen.wait(this.isFontsLoaded.bind(this));
+  }
+  bindCreateImage(createImage2, anonymousCrossOrigin) {
+    if (typeof anonymousCrossOrigin === "boolean") {
+      return (source, forceAnonymousCrossOrigin) => createImage2(source, typeof forceAnonymousCrossOrigin === "boolean" ? forceAnonymousCrossOrigin : anonymousCrossOrigin);
+    }
+    return createImage2;
+  }
+  get window() {
+    return this.screen.window;
+  }
+  get fetch() {
+    return this.screen.fetch;
+  }
+  get ctx() {
+    return this.screen.ctx;
+  }
+  get emSize() {
+    var {
+      emSizeStack
+    } = this;
+    return emSizeStack[emSizeStack.length - 1];
+  }
+  set emSize(value) {
+    var {
+      emSizeStack
+    } = this;
+    emSizeStack.push(value);
+  }
+  popEmSize() {
+    var {
+      emSizeStack
+    } = this;
+    emSizeStack.pop();
+  }
+  getUniqueId() {
+    return "canvg".concat(++this.uniqueId);
+  }
+  isImagesLoaded() {
+    return this.images.every((_2) => _2.loaded);
+  }
+  isFontsLoaded() {
+    return this.fonts.every((_2) => _2.loaded);
+  }
+  createDocumentElement(document2) {
+    var documentElement = this.createElement(document2.documentElement);
+    documentElement.root = true;
+    documentElement.addStylesFromStyleDefinition();
+    this.documentElement = documentElement;
+    return documentElement;
+  }
+  createElement(node2) {
+    var elementType = node2.nodeName.replace(/^[^:]+:/, "");
+    var ElementType = _Document.elementTypes[elementType];
+    if (typeof ElementType !== "undefined") {
+      return new ElementType(this, node2);
+    }
+    return new UnknownElement(this, node2);
+  }
+  createTextNode(node2) {
+    return new TextNode(this, node2);
+  }
+  setViewBox(config) {
+    this.screen.setViewBox(_objectSpread$1({
+      document: this
+    }, config));
+  }
+};
+Document.createCanvas = createCanvas;
+Document.createImage = createImage;
+Document.elementTypes = elements;
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    if (enumerableOnly) {
+      symbols = symbols.filter(function(sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+      });
+    }
+    keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread(target) {
+  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]);
+      });
+    } else if (Object.getOwnPropertyDescriptors) {
+      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+      ownKeys(Object(source)).forEach(function(key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+  }
+  return target;
+}
+var Canvg = class _Canvg {
+  /**
+   * Main constructor.
+   * @param ctx - Rendering context.
+   * @param svg - SVG Document.
+   * @param options - Rendering options.
+   */
+  constructor(ctx, svg) {
+    var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+    this.parser = new Parser(options);
+    this.screen = new Screen(ctx, options);
+    this.options = options;
+    var document2 = new Document(this, options);
+    var documentElement = document2.createDocumentElement(svg);
+    this.document = document2;
+    this.documentElement = documentElement;
+  }
+  /**
+   * Create Canvg instance from SVG source string or URL.
+   * @param ctx - Rendering context.
+   * @param svg - SVG source string or URL.
+   * @param options - Rendering options.
+   * @returns Canvg instance.
+   */
+  static from(ctx, svg) {
+    var _arguments = arguments;
+    return _asyncToGenerator(function* () {
+      var options = _arguments.length > 2 && _arguments[2] !== void 0 ? _arguments[2] : {};
+      var parser = new Parser(options);
+      var svgDocument = yield parser.parse(svg);
+      return new _Canvg(ctx, svgDocument, options);
+    })();
+  }
+  /**
+   * Create Canvg instance from SVG source string.
+   * @param ctx - Rendering context.
+   * @param svg - SVG source string.
+   * @param options - Rendering options.
+   * @returns Canvg instance.
+   */
+  static fromString(ctx, svg) {
+    var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+    var parser = new Parser(options);
+    var svgDocument = parser.parseFromString(svg);
+    return new _Canvg(ctx, svgDocument, options);
+  }
+  /**
+   * Create new Canvg instance with inherited options.
+   * @param ctx - Rendering context.
+   * @param svg - SVG source string or URL.
+   * @param options - Rendering options.
+   * @returns Canvg instance.
+   */
+  fork(ctx, svg) {
+    var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+    return _Canvg.from(ctx, svg, _objectSpread(_objectSpread({}, this.options), options));
+  }
+  /**
+   * Create new Canvg instance with inherited options.
+   * @param ctx - Rendering context.
+   * @param svg - SVG source string.
+   * @param options - Rendering options.
+   * @returns Canvg instance.
+   */
+  forkString(ctx, svg) {
+    var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+    return _Canvg.fromString(ctx, svg, _objectSpread(_objectSpread({}, this.options), options));
+  }
+  /**
+   * Document is ready promise.
+   * @returns Ready promise.
+   */
+  ready() {
+    return this.screen.ready();
+  }
+  /**
+   * Document is ready value.
+   * @returns Is ready or not.
+   */
+  isReady() {
+    return this.screen.isReady();
+  }
+  /**
+   * Render only first frame, ignoring animations and mouse.
+   * @param options - Rendering options.
+   */
+  render() {
+    var _arguments2 = arguments, _this = this;
+    return _asyncToGenerator(function* () {
+      var options = _arguments2.length > 0 && _arguments2[0] !== void 0 ? _arguments2[0] : {};
+      _this.start(_objectSpread({
+        enableRedraw: true,
+        ignoreAnimation: true,
+        ignoreMouse: true
+      }, options));
+      yield _this.ready();
+      _this.stop();
+    })();
+  }
+  /**
+   * Start rendering.
+   * @param options - Render options.
+   */
+  start() {
+    var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    var {
+      documentElement,
+      screen,
+      options: baseOptions
+    } = this;
+    screen.start(documentElement, _objectSpread(_objectSpread({
+      enableRedraw: true
+    }, baseOptions), options));
+  }
+  /**
+   * Stop rendering.
+   */
+  stop() {
+    this.screen.stop();
+  }
+  /**
+   * Resize SVG to fit in given size.
+   * @param width
+   * @param height
+   * @param preserveAspectRatio
+   */
+  resize(width) {
+    var height = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : width;
+    var preserveAspectRatio = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+    this.documentElement.resize(width, height, preserveAspectRatio);
+  }
+};
+export {
+  AElement,
+  AnimateColorElement,
+  AnimateElement,
+  AnimateTransformElement,
+  BoundingBox,
+  CB1,
+  CB2,
+  CB3,
+  CB4,
+  Canvg,
+  CircleElement,
+  ClipPathElement,
+  DefsElement,
+  DescElement,
+  Document,
+  Element,
+  EllipseElement,
+  FeColorMatrixElement,
+  FeCompositeElement,
+  FeDropShadowElement,
+  FeGaussianBlurElement,
+  FeMorphologyElement,
+  FilterElement,
+  Font,
+  FontElement,
+  FontFaceElement,
+  GElement,
+  GlyphElement,
+  GradientElement,
+  ImageElement,
+  LineElement,
+  LinearGradientElement,
+  MarkerElement,
+  MaskElement,
+  Matrix,
+  MissingGlyphElement,
+  Mouse,
+  PSEUDO_ZERO,
+  Parser,
+  PathElement,
+  PathParser,
+  PatternElement,
+  Point,
+  PolygonElement,
+  PolylineElement,
+  Property,
+  QB1,
+  QB2,
+  QB3,
+  RadialGradientElement,
+  RectElement,
+  RenderedElement,
+  Rotate,
+  SVGElement,
+  SVGFontLoader,
+  Scale,
+  Screen,
+  Skew,
+  SkewX,
+  SkewY,
+  StopElement,
+  StyleElement,
+  SymbolElement,
+  TRefElement,
+  TSpanElement,
+  TextElement,
+  TextPathElement,
+  TitleElement,
+  Transform,
+  Translate,
+  UnknownElement,
+  UseElement,
+  ViewPort,
+  compressSpaces,
+  Canvg as default,
+  getSelectorSpecificity,
+  normalizeAttributeName,
+  normalizeColor,
+  parseExternalUrl,
+  index as presets,
+  toNumbers,
+  trimLeft,
+  trimRight,
+  vectorMagnitude,
+  vectorsAngle,
+  vectorsRatio
+};
+/*! Bundled license information:
+
+svg-pathdata/lib/SVGPathData.module.js:
+  (*! *****************************************************************************
+  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.
+  ***************************************************************************** *)
+*/
+//# sourceMappingURL=index.es-7XNKQPVZ.js.map
