@quick-threejs/reactive 0.1.38 → 0.1.39

package/dist/FontLoader-Cp39O036.mjs

@@ -0,0 +1,3057 @@
+var or = Object.defineProperty;
+var sr = (e, t, r) => t in e ? or(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var h = (e, t, r) => sr(e, typeof t != "symbol" ? t + "" : t, r);
+import { EventDispatcher as ar, ObjectLoader as ur, Loader as cr, FileLoader as fr, ShapePath as lr } from "three";
+const $n = [
+  "ArrowUp",
+  "ArrowDown",
+  "ArrowLeft",
+  "ArrowRight"
+], jn = [
+  "contextmenu",
+  "resize",
+  "mousedown",
+  "mousemove",
+  "mouseup",
+  "pointerdown",
+  "pointermove",
+  "pointercancel",
+  "pointerup",
+  "touchstart",
+  "touchmove",
+  "touchend",
+  "wheel",
+  "keydown"
+];
+var dr = /* @__PURE__ */ ((e) => (e[e.PERSPECTIVE = 0] = "PERSPECTIVE", e[e.ORTHOGRAPHIC = 1] = "ORTHOGRAPHIC", e))(dr || {});
+class hr {
+  constructor() {
+    h(this, "contextmenu$$");
+    h(this, "resize$$");
+    h(this, "mousedown$$");
+    h(this, "mousemove$$");
+    h(this, "mouseup$$");
+    h(this, "pointerdown$$");
+    h(this, "pointermove$$");
+    h(this, "pointercancel$$");
+    h(this, "pointerup$$");
+    h(this, "touchstart$$");
+    h(this, "touchmove$$");
+    h(this, "touchend$$");
+    h(this, "wheel$$");
+    h(this, "keydown$$");
+  }
+}
+class pr extends hr {
+  constructor() {
+    super(...arguments);
+    h(this, "contextmenu$");
+    h(this, "resize$");
+    h(this, "mousedown$");
+    h(this, "mousemove$");
+    h(this, "mouseup$");
+    h(this, "pointerdown$");
+    h(this, "pointermove$");
+    h(this, "pointercancel$");
+    h(this, "pointerup$");
+    h(this, "touchstart$");
+    h(this, "touchmove$");
+    h(this, "touchend$");
+    h(this, "wheel$");
+    h(this, "keydown$");
+  }
+}
+class An extends pr {
+  constructor() {
+    super(...arguments);
+    h(this, "contextmenu");
+    h(this, "resize");
+    h(this, "mousedown");
+    h(this, "mousemove");
+    h(this, "mouseup");
+    h(this, "pointerdown");
+    h(this, "pointermove");
+    h(this, "pointercancel");
+    h(this, "pointerup");
+    h(this, "touchstart");
+    h(this, "touchmove");
+    h(this, "touchend");
+    h(this, "wheel");
+    h(this, "keydown");
+  }
+}
+class Cn {
+  constructor() {
+    h(this, "contextmenu$");
+    h(this, "resize$");
+    h(this, "mousedown$");
+    h(this, "mousemove$");
+    h(this, "mouseup$");
+    h(this, "pointerdown$");
+    h(this, "pointermove$");
+    h(this, "pointercancel$");
+    h(this, "pointerup$");
+    h(this, "touchstart$");
+    h(this, "touchmove$");
+    h(this, "touchend$");
+    h(this, "wheel$");
+    h(this, "keydown$");
+    h(this, "contextmenu");
+    h(this, "resize");
+    h(this, "mousedown");
+    h(this, "mousemove");
+    h(this, "mouseup");
+    h(this, "pointerdown");
+    h(this, "pointermove");
+    h(this, "pointercancel");
+    h(this, "pointerup");
+    h(this, "touchstart");
+    h(this, "touchmove");
+    h(this, "touchend");
+    h(this, "wheel");
+    h(this, "keydown");
+  }
+}
+class zn {
+  constructor() {
+    h(this, "contextmenu$");
+    h(this, "resize$");
+    h(this, "mousedown$");
+    h(this, "mousemove$");
+    h(this, "mouseup$");
+    h(this, "pointerdown$");
+    h(this, "pointermove$");
+    h(this, "pointercancel$");
+    h(this, "pointerup$");
+    h(this, "touchstart$");
+    h(this, "touchmove$");
+    h(this, "touchend$");
+    h(this, "wheel$");
+    h(this, "keydown$");
+  }
+}
+const Dn = "CONTAINER", Fn = "LOADER_SERIALIZED_LOAD";
+var ft = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
+function qn(e) {
+  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
+}
+function Ln(e) {
+  if (e.__esModule) return e;
+  var t = e.default;
+  if (typeof t == "function") {
+    var r = function n() {
+      return this instanceof n ? Reflect.construct(t, arguments, this.constructor) : t.apply(this, arguments);
+    };
+    r.prototype = t.prototype;
+  } else r = {};
+  return Object.defineProperty(r, "__esModule", { value: !0 }), Object.keys(e).forEach(function(n) {
+    var i = Object.getOwnPropertyDescriptor(e, n);
+    Object.defineProperty(r, n, i.get ? i : {
+      enumerable: !0,
+      get: function() {
+        return e[n];
+      }
+    });
+  }), r;
+}
+var lt = {};
+/*! *****************************************************************************
+Copyright (C) Microsoft. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+var dt;
+function vr() {
+  if (dt) return lt;
+  dt = 1;
+  var e;
+  return function(t) {
+    (function(r) {
+      var n = typeof globalThis == "object" ? globalThis : typeof ft == "object" ? ft : typeof self == "object" ? self : typeof this == "object" ? this : d(), i = o(t);
+      typeof n.Reflect < "u" && (i = o(n.Reflect, i)), r(i, n), typeof n.Reflect > "u" && (n.Reflect = t);
+      function o(f, b) {
+        return function(M, I) {
+          Object.defineProperty(f, M, { configurable: !0, writable: !0, value: I }), b && b(M, I);
+        };
+      }
+      function s() {
+        try {
+          return Function("return this;")();
+        } catch {
+        }
+      }
+      function c() {
+        try {
+          return (0, eval)("(function() { return this; })()");
+        } catch {
+        }
+      }
+      function d() {
+        return s() || c();
+      }
+    })(function(r, n) {
+      var i = Object.prototype.hasOwnProperty, o = typeof Symbol == "function", s = o && typeof Symbol.toPrimitive < "u" ? Symbol.toPrimitive : "@@toPrimitive", c = o && typeof Symbol.iterator < "u" ? Symbol.iterator : "@@iterator", d = typeof Object.create == "function", f = { __proto__: [] } instanceof Array, b = !d && !f, M = {
+        // create an object in dictionary mode (a.k.a. "slow" mode in v8)
+        create: d ? function() {
+          return De(/* @__PURE__ */ Object.create(null));
+        } : f ? function() {
+          return De({ __proto__: null });
+        } : function() {
+          return De({});
+        },
+        has: b ? function(a, u) {
+          return i.call(a, u);
+        } : function(a, u) {
+          return u in a;
+        },
+        get: b ? function(a, u) {
+          return i.call(a, u) ? a[u] : void 0;
+        } : function(a, u) {
+          return a[u];
+        }
+      }, I = Object.getPrototypeOf(Function), O = typeof Map == "function" && typeof Map.prototype.entries == "function" ? Map : er(), x = typeof Set == "function" && typeof Set.prototype.entries == "function" ? Set : tr(), S = typeof WeakMap == "function" ? WeakMap : rr(), R = o ? Symbol.for("@reflect-metadata:registry") : void 0, q = Qt(), G = Xt(q);
+      function B(a, u, l, p) {
+        if (E(l)) {
+          if (!rt(a))
+            throw new TypeError();
+          if (!nt(u))
+            throw new TypeError();
+          return Q(a, u);
+        } else {
+          if (!rt(a))
+            throw new TypeError();
+          if (!D(u))
+            throw new TypeError();
+          if (!D(p) && !E(p) && !ue(p))
+            throw new TypeError();
+          return ue(p) && (p = void 0), l = Y(l), N(a, u, l, p);
+        }
+      }
+      r("decorate", B);
+      function ee(a, u) {
+        function l(p, _) {
+          if (!D(p))
+            throw new TypeError();
+          if (!E(_) && !Zt(_))
+            throw new TypeError();
+          Z(a, u, p, _);
+        }
+        return l;
+      }
+      r("metadata", ee);
+      function te(a, u, l, p) {
+        if (!D(l))
+          throw new TypeError();
+        return E(p) || (p = Y(p)), Z(a, u, l, p);
+      }
+      r("defineMetadata", te);
+      function U(a, u, l) {
+        if (!D(u))
+          throw new TypeError();
+        return E(l) || (l = Y(l)), V(a, u, l);
+      }
+      r("hasMetadata", U);
+      function ge(a, u, l) {
+        if (!D(u))
+          throw new TypeError();
+        return E(l) || (l = Y(l)), he(a, u, l);
+      }
+      r("hasOwnMetadata", ge);
+      function Ae(a, u, l) {
+        if (!D(u))
+          throw new TypeError();
+        return E(l) || (l = Y(l)), _e(a, u, l);
+      }
+      r("getMetadata", Ae);
+      function y(a, u, l) {
+        if (!D(u))
+          throw new TypeError();
+        return E(l) || (l = Y(l)), se(a, u, l);
+      }
+      r("getOwnMetadata", y);
+      function k(a, u) {
+        if (!D(a))
+          throw new TypeError();
+        return E(u) || (u = Y(u)), ae(a, u);
+      }
+      r("getMetadataKeys", k);
+      function $(a, u) {
+        if (!D(a))
+          throw new TypeError();
+        return E(u) || (u = Y(u)), Ke(a, u);
+      }
+      r("getOwnMetadataKeys", $);
+      function z(a, u, l) {
+        if (!D(u))
+          throw new TypeError();
+        if (E(l) || (l = Y(l)), !D(u))
+          throw new TypeError();
+        E(l) || (l = Y(l));
+        var p = pe(
+          u,
+          l,
+          /*Create*/
+          !1
+        );
+        return E(p) ? !1 : p.OrdinaryDeleteMetadata(a, u, l);
+      }
+      r("deleteMetadata", z);
+      function Q(a, u) {
+        for (var l = a.length - 1; l >= 0; --l) {
+          var p = a[l], _ = p(u);
+          if (!E(_) && !ue(_)) {
+            if (!nt(_))
+              throw new TypeError();
+            u = _;
+          }
+        }
+        return u;
+      }
+      function N(a, u, l, p) {
+        for (var _ = a.length - 1; _ >= 0; --_) {
+          var L = a[_], F = L(u, l, p);
+          if (!E(F) && !ue(F)) {
+            if (!D(F))
+              throw new TypeError();
+            p = F;
+          }
+        }
+        return p;
+      }
+      function V(a, u, l) {
+        var p = he(a, u, l);
+        if (p)
+          return !0;
+        var _ = ze(u);
+        return ue(_) ? !1 : V(a, _, l);
+      }
+      function he(a, u, l) {
+        var p = pe(
+          u,
+          l,
+          /*Create*/
+          !1
+        );
+        return E(p) ? !1 : tt(p.OrdinaryHasOwnMetadata(a, u, l));
+      }
+      function _e(a, u, l) {
+        var p = he(a, u, l);
+        if (p)
+          return se(a, u, l);
+        var _ = ze(u);
+        if (!ue(_))
+          return _e(a, _, l);
+      }
+      function se(a, u, l) {
+        var p = pe(
+          u,
+          l,
+          /*Create*/
+          !1
+        );
+        if (!E(p))
+          return p.OrdinaryGetOwnMetadata(a, u, l);
+      }
+      function Z(a, u, l, p) {
+        var _ = pe(
+          l,
+          p,
+          /*Create*/
+          !0
+        );
+        _.OrdinaryDefineOwnMetadata(a, u, l, p);
+      }
+      function ae(a, u) {
+        var l = Ke(a, u), p = ze(a);
+        if (p === null)
+          return l;
+        var _ = ae(p, u);
+        if (_.length <= 0)
+          return l;
+        if (l.length <= 0)
+          return _;
+        for (var L = new x(), F = [], T = 0, v = l; T < v.length; T++) {
+          var m = v[T], w = L.has(m);
+          w || (L.add(m), F.push(m));
+        }
+        for (var g = 0, P = _; g < P.length; g++) {
+          var m = P[g], w = L.has(m);
+          w || (L.add(m), F.push(m));
+        }
+        return F;
+      }
+      function Ke(a, u) {
+        var l = pe(
+          a,
+          u,
+          /*create*/
+          !1
+        );
+        return l ? l.OrdinaryOwnMetadataKeys(a, u) : [];
+      }
+      function et(a) {
+        if (a === null)
+          return 1;
+        switch (typeof a) {
+          case "undefined":
+            return 0;
+          case "boolean":
+            return 2;
+          case "string":
+            return 3;
+          case "symbol":
+            return 4;
+          case "number":
+            return 5;
+          case "object":
+            return a === null ? 1 : 6;
+          default:
+            return 6;
+        }
+      }
+      function E(a) {
+        return a === void 0;
+      }
+      function ue(a) {
+        return a === null;
+      }
+      function Bt(a) {
+        return typeof a == "symbol";
+      }
+      function D(a) {
+        return typeof a == "object" ? a !== null : typeof a == "function";
+      }
+      function Ut(a, u) {
+        switch (et(a)) {
+          case 0:
+            return a;
+          case 1:
+            return a;
+          case 2:
+            return a;
+          case 3:
+            return a;
+          case 4:
+            return a;
+          case 5:
+            return a;
+        }
+        var l = "string", p = it(a, s);
+        if (p !== void 0) {
+          var _ = p.call(a, l);
+          if (D(_))
+            throw new TypeError();
+          return _;
+        }
+        return Vt(a);
+      }
+      function Vt(a, u) {
+        var l, p;
+        {
+          var _ = a.toString;
+          if (Se(_)) {
+            var p = _.call(a);
+            if (!D(p))
+              return p;
+          }
+          var l = a.valueOf;
+          if (Se(l)) {
+            var p = l.call(a);
+            if (!D(p))
+              return p;
+          }
+        }
+        throw new TypeError();
+      }
+      function tt(a) {
+        return !!a;
+      }
+      function Jt(a) {
+        return "" + a;
+      }
+      function Y(a) {
+        var u = Ut(a);
+        return Bt(u) ? u : Jt(u);
+      }
+      function rt(a) {
+        return Array.isArray ? Array.isArray(a) : a instanceof Object ? a instanceof Array : Object.prototype.toString.call(a) === "[object Array]";
+      }
+      function Se(a) {
+        return typeof a == "function";
+      }
+      function nt(a) {
+        return typeof a == "function";
+      }
+      function Zt(a) {
+        switch (et(a)) {
+          case 3:
+            return !0;
+          case 4:
+            return !0;
+          default:
+            return !1;
+        }
+      }
+      function Ce(a, u) {
+        return a === u || a !== a && u !== u;
+      }
+      function it(a, u) {
+        var l = a[u];
+        if (l != null) {
+          if (!Se(l))
+            throw new TypeError();
+          return l;
+        }
+      }
+      function ot(a) {
+        var u = it(a, c);
+        if (!Se(u))
+          throw new TypeError();
+        var l = u.call(a);
+        if (!D(l))
+          throw new TypeError();
+        return l;
+      }
+      function st(a) {
+        return a.value;
+      }
+      function at(a) {
+        var u = a.next();
+        return u.done ? !1 : u;
+      }
+      function ut(a) {
+        var u = a.return;
+        u && u.call(a);
+      }
+      function ze(a) {
+        var u = Object.getPrototypeOf(a);
+        if (typeof a != "function" || a === I || u !== I)
+          return u;
+        var l = a.prototype, p = l && Object.getPrototypeOf(l);
+        if (p == null || p === Object.prototype)
+          return u;
+        var _ = p.constructor;
+        return typeof _ != "function" || _ === a ? u : _;
+      }
+      function Yt() {
+        var a;
+        !E(R) && typeof n.Reflect < "u" && !(R in n.Reflect) && typeof n.Reflect.defineMetadata == "function" && (a = Kt(n.Reflect));
+        var u, l, p, _ = new S(), L = {
+          registerProvider: F,
+          getProvider: v,
+          setProvider: w
+        };
+        return L;
+        function F(g) {
+          if (!Object.isExtensible(L))
+            throw new Error("Cannot add provider to a frozen registry.");
+          switch (!0) {
+            case a === g:
+              break;
+            case E(u):
+              u = g;
+              break;
+            case u === g:
+              break;
+            case E(l):
+              l = g;
+              break;
+            case l === g:
+              break;
+            default:
+              p === void 0 && (p = new x()), p.add(g);
+              break;
+          }
+        }
+        function T(g, P) {
+          if (!E(u)) {
+            if (u.isProviderFor(g, P))
+              return u;
+            if (!E(l)) {
+              if (l.isProviderFor(g, P))
+                return u;
+              if (!E(p))
+                for (var j = ot(p); ; ) {
+                  var C = at(j);
+                  if (!C)
+                    return;
+                  var J = st(C);
+                  if (J.isProviderFor(g, P))
+                    return ut(j), J;
+                }
+            }
+          }
+          if (!E(a) && a.isProviderFor(g, P))
+            return a;
+        }
+        function v(g, P) {
+          var j = _.get(g), C;
+          return E(j) || (C = j.get(P)), E(C) && (C = T(g, P), E(C) || (E(j) && (j = new O(), _.set(g, j)), j.set(P, C))), C;
+        }
+        function m(g) {
+          if (E(g))
+            throw new TypeError();
+          return u === g || l === g || !E(p) && p.has(g);
+        }
+        function w(g, P, j) {
+          if (!m(j))
+            throw new Error("Metadata provider not registered.");
+          var C = v(g, P);
+          if (C !== j) {
+            if (!E(C))
+              return !1;
+            var J = _.get(g);
+            E(J) && (J = new O(), _.set(g, J)), J.set(P, j);
+          }
+          return !0;
+        }
+      }
+      function Qt() {
+        var a;
+        return !E(R) && D(n.Reflect) && Object.isExtensible(n.Reflect) && (a = n.Reflect[R]), E(a) && (a = Yt()), !E(R) && D(n.Reflect) && Object.isExtensible(n.Reflect) && Object.defineProperty(n.Reflect, R, {
+          enumerable: !1,
+          configurable: !1,
+          writable: !1,
+          value: a
+        }), a;
+      }
+      function Xt(a) {
+        var u = new S(), l = {
+          isProviderFor: function(m, w) {
+            var g = u.get(m);
+            return E(g) ? !1 : g.has(w);
+          },
+          OrdinaryDefineOwnMetadata: F,
+          OrdinaryHasOwnMetadata: _,
+          OrdinaryGetOwnMetadata: L,
+          OrdinaryOwnMetadataKeys: T,
+          OrdinaryDeleteMetadata: v
+        };
+        return q.registerProvider(l), l;
+        function p(m, w, g) {
+          var P = u.get(m), j = !1;
+          if (E(P)) {
+            if (!g)
+              return;
+            P = new O(), u.set(m, P), j = !0;
+          }
+          var C = P.get(w);
+          if (E(C)) {
+            if (!g)
+              return;
+            if (C = new O(), P.set(w, C), !a.setProvider(m, w, l))
+              throw P.delete(w), j && u.delete(m), new Error("Wrong provider for target.");
+          }
+          return C;
+        }
+        function _(m, w, g) {
+          var P = p(
+            w,
+            g,
+            /*Create*/
+            !1
+          );
+          return E(P) ? !1 : tt(P.has(m));
+        }
+        function L(m, w, g) {
+          var P = p(
+            w,
+            g,
+            /*Create*/
+            !1
+          );
+          if (!E(P))
+            return P.get(m);
+        }
+        function F(m, w, g, P) {
+          var j = p(
+            g,
+            P,
+            /*Create*/
+            !0
+          );
+          j.set(m, w);
+        }
+        function T(m, w) {
+          var g = [], P = p(
+            m,
+            w,
+            /*Create*/
+            !1
+          );
+          if (E(P))
+            return g;
+          for (var j = P.keys(), C = ot(j), J = 0; ; ) {
+            var ct = at(C);
+            if (!ct)
+              return g.length = J, g;
+            var nr = st(ct);
+            try {
+              g[J] = nr;
+            } catch (ir) {
+              try {
+                ut(C);
+              } finally {
+                throw ir;
+              }
+            }
+            J++;
+          }
+        }
+        function v(m, w, g) {
+          var P = p(
+            w,
+            g,
+            /*Create*/
+            !1
+          );
+          if (E(P) || !P.delete(m))
+            return !1;
+          if (P.size === 0) {
+            var j = u.get(w);
+            E(j) || (j.delete(g), j.size === 0 && u.delete(j));
+          }
+          return !0;
+        }
+      }
+      function Kt(a) {
+        var u = a.defineMetadata, l = a.hasOwnMetadata, p = a.getOwnMetadata, _ = a.getOwnMetadataKeys, L = a.deleteMetadata, F = new S(), T = {
+          isProviderFor: function(v, m) {
+            var w = F.get(v);
+            return !E(w) && w.has(m) ? !0 : _(v, m).length ? (E(w) && (w = new x(), F.set(v, w)), w.add(m), !0) : !1;
+          },
+          OrdinaryDefineOwnMetadata: u,
+          OrdinaryHasOwnMetadata: l,
+          OrdinaryGetOwnMetadata: p,
+          OrdinaryOwnMetadataKeys: _,
+          OrdinaryDeleteMetadata: L
+        };
+        return T;
+      }
+      function pe(a, u, l) {
+        var p = q.getProvider(a, u);
+        if (!E(p))
+          return p;
+        if (l) {
+          if (q.setProvider(a, u, G))
+            return G;
+          throw new Error("Illegal state.");
+        }
+      }
+      function er() {
+        var a = {}, u = [], l = (
+          /** @class */
+          function() {
+            function T(v, m, w) {
+              this._index = 0, this._keys = v, this._values = m, this._selector = w;
+            }
+            return T.prototype["@@iterator"] = function() {
+              return this;
+            }, T.prototype[c] = function() {
+              return this;
+            }, T.prototype.next = function() {
+              var v = this._index;
+              if (v >= 0 && v < this._keys.length) {
+                var m = this._selector(this._keys[v], this._values[v]);
+                return v + 1 >= this._keys.length ? (this._index = -1, this._keys = u, this._values = u) : this._index++, { value: m, done: !1 };
+              }
+              return { value: void 0, done: !0 };
+            }, T.prototype.throw = function(v) {
+              throw this._index >= 0 && (this._index = -1, this._keys = u, this._values = u), v;
+            }, T.prototype.return = function(v) {
+              return this._index >= 0 && (this._index = -1, this._keys = u, this._values = u), { value: v, done: !0 };
+            }, T;
+          }()
+        ), p = (
+          /** @class */
+          function() {
+            function T() {
+              this._keys = [], this._values = [], this._cacheKey = a, this._cacheIndex = -2;
+            }
+            return Object.defineProperty(T.prototype, "size", {
+              get: function() {
+                return this._keys.length;
+              },
+              enumerable: !0,
+              configurable: !0
+            }), T.prototype.has = function(v) {
+              return this._find(
+                v,
+                /*insert*/
+                !1
+              ) >= 0;
+            }, T.prototype.get = function(v) {
+              var m = this._find(
+                v,
+                /*insert*/
+                !1
+              );
+              return m >= 0 ? this._values[m] : void 0;
+            }, T.prototype.set = function(v, m) {
+              var w = this._find(
+                v,
+                /*insert*/
+                !0
+              );
+              return this._values[w] = m, this;
+            }, T.prototype.delete = function(v) {
+              var m = this._find(
+                v,
+                /*insert*/
+                !1
+              );
+              if (m >= 0) {
+                for (var w = this._keys.length, g = m + 1; g < w; g++)
+                  this._keys[g - 1] = this._keys[g], this._values[g - 1] = this._values[g];
+                return this._keys.length--, this._values.length--, Ce(v, this._cacheKey) && (this._cacheKey = a, this._cacheIndex = -2), !0;
+              }
+              return !1;
+            }, T.prototype.clear = function() {
+              this._keys.length = 0, this._values.length = 0, this._cacheKey = a, this._cacheIndex = -2;
+            }, T.prototype.keys = function() {
+              return new l(this._keys, this._values, _);
+            }, T.prototype.values = function() {
+              return new l(this._keys, this._values, L);
+            }, T.prototype.entries = function() {
+              return new l(this._keys, this._values, F);
+            }, T.prototype["@@iterator"] = function() {
+              return this.entries();
+            }, T.prototype[c] = function() {
+              return this.entries();
+            }, T.prototype._find = function(v, m) {
+              if (!Ce(this._cacheKey, v)) {
+                this._cacheIndex = -1;
+                for (var w = 0; w < this._keys.length; w++)
+                  if (Ce(this._keys[w], v)) {
+                    this._cacheIndex = w;
+                    break;
+                  }
+              }
+              return this._cacheIndex < 0 && m && (this._cacheIndex = this._keys.length, this._keys.push(v), this._values.push(void 0)), this._cacheIndex;
+            }, T;
+          }()
+        );
+        return p;
+        function _(T, v) {
+          return T;
+        }
+        function L(T, v) {
+          return v;
+        }
+        function F(T, v) {
+          return [T, v];
+        }
+      }
+      function tr() {
+        var a = (
+          /** @class */
+          function() {
+            function u() {
+              this._map = new O();
+            }
+            return Object.defineProperty(u.prototype, "size", {
+              get: function() {
+                return this._map.size;
+              },
+              enumerable: !0,
+              configurable: !0
+            }), u.prototype.has = function(l) {
+              return this._map.has(l);
+            }, u.prototype.add = function(l) {
+              return this._map.set(l, l), this;
+            }, u.prototype.delete = function(l) {
+              return this._map.delete(l);
+            }, u.prototype.clear = function() {
+              this._map.clear();
+            }, u.prototype.keys = function() {
+              return this._map.keys();
+            }, u.prototype.values = function() {
+              return this._map.keys();
+            }, u.prototype.entries = function() {
+              return this._map.entries();
+            }, u.prototype["@@iterator"] = function() {
+              return this.keys();
+            }, u.prototype[c] = function() {
+              return this.keys();
+            }, u;
+          }()
+        );
+        return a;
+      }
+      function rr() {
+        var a = 16, u = M.create(), l = p();
+        return (
+          /** @class */
+          function() {
+            function v() {
+              this._key = p();
+            }
+            return v.prototype.has = function(m) {
+              var w = _(
+                m,
+                /*create*/
+                !1
+              );
+              return w !== void 0 ? M.has(w, this._key) : !1;
+            }, v.prototype.get = function(m) {
+              var w = _(
+                m,
+                /*create*/
+                !1
+              );
+              return w !== void 0 ? M.get(w, this._key) : void 0;
+            }, v.prototype.set = function(m, w) {
+              var g = _(
+                m,
+                /*create*/
+                !0
+              );
+              return g[this._key] = w, this;
+            }, v.prototype.delete = function(m) {
+              var w = _(
+                m,
+                /*create*/
+                !1
+              );
+              return w !== void 0 ? delete w[this._key] : !1;
+            }, v.prototype.clear = function() {
+              this._key = p();
+            }, v;
+          }()
+        );
+        function p() {
+          var v;
+          do
+            v = "@@WeakMap@@" + T();
+          while (M.has(u, v));
+          return u[v] = !0, v;
+        }
+        function _(v, m) {
+          if (!i.call(v, l)) {
+            if (!m)
+              return;
+            Object.defineProperty(v, l, { value: M.create() });
+          }
+          return v[l];
+        }
+        function L(v, m) {
+          for (var w = 0; w < m; ++w)
+            v[w] = Math.random() * 255 | 0;
+          return v;
+        }
+        function F(v) {
+          if (typeof Uint8Array == "function") {
+            var m = new Uint8Array(v);
+            return typeof crypto < "u" ? crypto.getRandomValues(m) : typeof msCrypto < "u" ? msCrypto.getRandomValues(m) : L(m, v), m;
+          }
+          return L(new Array(v), v);
+        }
+        function T() {
+          var v = F(a);
+          v[6] = v[6] & 79 | 64, v[8] = v[8] & 191 | 128;
+          for (var m = "", w = 0; w < a; ++w) {
+            var g = v[w];
+            (w === 4 || w === 6 || w === 8) && (m += "-"), g < 16 && (m += "0"), m += g.toString(16).toLowerCase();
+          }
+          return m;
+        }
+      }
+      function De(a) {
+        return a.__ = void 0, delete a.__, a;
+      }
+    });
+  }(e || (e = {})), lt;
+}
+vr();
+var yr = Object.defineProperty, br = (e, t, r) => t in e ? yr(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r, ve = (e, t, r) => br(e, typeof t != "symbol" ? t + "" : t, r);
+class Nn extends ar {
+  constructor() {
+    super(), ve(this, "style", {}), ve(this, "width", 0), ve(this, "height", 0), ve(this, "left", 0), ve(this, "top", 0), this.getRootNode = this.getRootNode.bind(this), this.handleEvent = this.handleEvent.bind(this);
+  }
+  get clientWidth() {
+    return this.width;
+  }
+  get clientHeight() {
+    return this.height;
+  }
+  setPointerCapture() {
+  }
+  releasePointerCapture() {
+  }
+  getRootNode() {
+    return this;
+  }
+  getBoundingClientRect() {
+    return {
+      left: this.left,
+      top: this.top,
+      width: this.width,
+      height: this.height,
+      right: this.left + this.width,
+      bottom: this.top + this.height
+    };
+  }
+  handleEvent(t) {
+    if (t.type === "resize") {
+      this.left = t.left ?? 0, this.top = t.top ?? 0, this.width = t.width ?? 0, this.height = t.height ?? 0;
+      return;
+    }
+    t.preventDefault = () => {
+    }, t.stopPropagation = () => {
+    }, this.dispatchEvent(t);
+  }
+  focus() {
+  }
+}
+const Wn = (e) => e === void 0, Hn = (e) => typeof e == "boolean", Gn = (e) => !!e && typeof e == "function", Bn = (e) => {
+  var t, r;
+  const n = e.toJSON();
+  return JSON.stringify({
+    ...n,
+    object: {
+      ...n.object,
+      position: ["x", "y", "z"].map(
+        (i) => e.position[i]
+      ),
+      rotation: ["x", "y", "z", "order"].map(
+        (i) => e.rotation[i]
+      ),
+      children: ((r = (t = n == null ? void 0 : n.object) == null ? void 0 : t.children) == null ? void 0 : r.map((i, o) => ({
+        ...typeof i == "object" ? i : typeof i == "string" ? JSON.parse(i) : {},
+        position: ["x", "y", "z"].map(
+          (s) => {
+            var c;
+            return (c = e.children[o]) == null ? void 0 : c.position[s];
+          }
+        ),
+        rotation: ["x", "y", "z", "order"].map(
+          (s) => {
+            var c;
+            return (c = e.children[o]) == null ? void 0 : c.rotation[s];
+          }
+        )
+      }))) ?? []
+    },
+    isSerialized: !0
+  });
+}, Un = (e, t = new ur()) => {
+  const r = JSON.parse(e);
+  if (r != null && r.metadata && r.object && r.isSerialized) {
+    const n = t.parse(r);
+    return n.position.set(
+      ...r.object.position
+    ), n.rotation.set(
+      ...r.object.rotation
+    ), n.children.map((i, o) => {
+      i.position.set(
+        ...r.object.children[o].position
+      );
+    }), n.children.map((i, o) => {
+      i.rotation.set(
+        ...r.object.children[o].rotation
+      );
+    }), n;
+  }
+  return r;
+}, Vn = (e, t) => {
+  const r = {
+    type: e == null ? void 0 : e.type
+  };
+  for (const n of t)
+    e[n] !== void 0 && (r[n] = e[n]);
+  return r;
+}, Jn = (e, t) => {
+  const r = {
+    type: e == null ? void 0 : e.type
+  };
+  for (const [n, i] of Object.entries(e))
+    t.includes(n) || (r[n] = i);
+  return r;
+};
+var He;
+(function(e) {
+  e[e.Transient = 0] = "Transient", e[e.Singleton = 1] = "Singleton", e[e.ResolutionScoped = 2] = "ResolutionScoped", e[e.ContainerScoped = 3] = "ContainerScoped";
+})(He || (He = {}));
+const W = He;
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+var Ge = function(e, t) {
+  return Ge = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(r, n) {
+    r.__proto__ = n;
+  } || function(r, n) {
+    for (var i in n) n.hasOwnProperty(i) && (r[i] = n[i]);
+  }, Ge(e, t);
+};
+function Ze(e, t) {
+  Ge(e, t);
+  function r() {
+    this.constructor = e;
+  }
+  e.prototype = t === null ? Object.create(t) : (r.prototype = t.prototype, new r());
+}
+function mr(e, t, r, n) {
+  function i(o) {
+    return o instanceof r ? o : new r(function(s) {
+      s(o);
+    });
+  }
+  return new (r || (r = Promise))(function(o, s) {
+    function c(b) {
+      try {
+        f(n.next(b));
+      } catch (M) {
+        s(M);
+      }
+    }
+    function d(b) {
+      try {
+        f(n.throw(b));
+      } catch (M) {
+        s(M);
+      }
+    }
+    function f(b) {
+      b.done ? o(b.value) : i(b.value).then(c, d);
+    }
+    f((n = n.apply(e, [])).next());
+  });
+}
+function wr(e, t) {
+  var r = { label: 0, sent: function() {
+    if (o[0] & 1) throw o[1];
+    return o[1];
+  }, trys: [], ops: [] }, n, i, o, s;
+  return s = { next: c(0), throw: c(1), return: c(2) }, typeof Symbol == "function" && (s[Symbol.iterator] = function() {
+    return this;
+  }), s;
+  function c(f) {
+    return function(b) {
+      return d([f, b]);
+    };
+  }
+  function d(f) {
+    if (n) throw new TypeError("Generator is already executing.");
+    for (; r; ) try {
+      if (n = 1, i && (o = f[0] & 2 ? i.return : f[0] ? i.throw || ((o = i.return) && o.call(i), 0) : i.next) && !(o = o.call(i, f[1])).done) return o;
+      switch (i = 0, o && (f = [f[0] & 2, o.value]), f[0]) {
+        case 0:
+        case 1:
+          o = f;
+          break;
+        case 4:
+          return r.label++, { value: f[1], done: !1 };
+        case 5:
+          r.label++, i = f[1], f = [0];
+          continue;
+        case 7:
+          f = r.ops.pop(), r.trys.pop();
+          continue;
+        default:
+          if (o = r.trys, !(o = o.length > 0 && o[o.length - 1]) && (f[0] === 6 || f[0] === 2)) {
+            r = 0;
+            continue;
+          }
+          if (f[0] === 3 && (!o || f[1] > o[0] && f[1] < o[3])) {
+            r.label = f[1];
+            break;
+          }
+          if (f[0] === 6 && r.label < o[1]) {
+            r.label = o[1], o = f;
+            break;
+          }
+          if (o && r.label < o[2]) {
+            r.label = o[2], r.ops.push(f);
+            break;
+          }
+          o[2] && r.ops.pop(), r.trys.pop();
+          continue;
+      }
+      f = t.call(e, r);
+    } catch (b) {
+      f = [6, b], i = 0;
+    } finally {
+      n = o = 0;
+    }
+    if (f[0] & 5) throw f[1];
+    return { value: f[0] ? f[1] : void 0, done: !0 };
+  }
+}
+function Me(e) {
+  var t = typeof Symbol == "function" && Symbol.iterator, r = t && e[t], n = 0;
+  if (r) return r.call(e);
+  if (e && typeof e.length == "number") return {
+    next: function() {
+      return e && n >= e.length && (e = void 0), { value: e && e[n++], done: !e };
+    }
+  };
+  throw new TypeError(t ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function Ie(e, t) {
+  var r = typeof Symbol == "function" && e[Symbol.iterator];
+  if (!r) return e;
+  var n = r.call(e), i, o = [], s;
+  try {
+    for (; (t === void 0 || t-- > 0) && !(i = n.next()).done; ) o.push(i.value);
+  } catch (c) {
+    s = { error: c };
+  } finally {
+    try {
+      i && !i.done && (r = n.return) && r.call(n);
+    } finally {
+      if (s) throw s.error;
+    }
+  }
+  return o;
+}
+function oe() {
+  for (var e = [], t = 0; t < arguments.length; t++)
+    e = e.concat(Ie(arguments[t]));
+  return e;
+}
+var Be = "injectionTokens";
+function gr(e) {
+  var t = Reflect.getMetadata("design:paramtypes", e) || [], r = Reflect.getOwnMetadata(Be, e) || {};
+  return Object.keys(r).forEach(function(n) {
+    t[+n] = r[n];
+  }), t;
+}
+function _r(e, t) {
+  return function(r, n, i) {
+    var o = Reflect.getOwnMetadata(Be, r) || {};
+    o[i] = e, Reflect.defineMetadata(Be, o, r);
+  };
+}
+function It(e) {
+  return !!e.useClass;
+}
+function Ue(e) {
+  return !!e.useFactory;
+}
+var xt = function() {
+  function e(t) {
+    this.wrap = t, this.reflectMethods = [
+      "get",
+      "getPrototypeOf",
+      "setPrototypeOf",
+      "getOwnPropertyDescriptor",
+      "defineProperty",
+      "has",
+      "set",
+      "deleteProperty",
+      "apply",
+      "construct",
+      "ownKeys"
+    ];
+  }
+  return e.prototype.createProxy = function(t) {
+    var r = this, n = {}, i = !1, o, s = function() {
+      return i || (o = t(r.wrap()), i = !0), o;
+    };
+    return new Proxy(n, this.createHandler(s));
+  }, e.prototype.createHandler = function(t) {
+    var r = {}, n = function(i) {
+      r[i] = function() {
+        for (var o = [], s = 0; s < arguments.length; s++)
+          o[s] = arguments[s];
+        o[0] = t();
+        var c = Reflect[i];
+        return c.apply(void 0, oe(o));
+      };
+    };
+    return this.reflectMethods.forEach(n), r;
+  }, e;
+}();
+function ce(e) {
+  return typeof e == "string" || typeof e == "symbol";
+}
+function Sr(e) {
+  return typeof e == "object" && "token" in e && "multiple" in e;
+}
+function ht(e) {
+  return typeof e == "object" && "token" in e && "transform" in e;
+}
+function Mr(e) {
+  return typeof e == "function" || e instanceof xt;
+}
+function Re(e) {
+  return !!e.useToken;
+}
+function Pe(e) {
+  return e.useValue != null;
+}
+function Er(e) {
+  return It(e) || Pe(e) || Re(e) || Ue(e);
+}
+var Ye = function() {
+  function e() {
+    this._registryMap = /* @__PURE__ */ new Map();
+  }
+  return e.prototype.entries = function() {
+    return this._registryMap.entries();
+  }, e.prototype.getAll = function(t) {
+    return this.ensure(t), this._registryMap.get(t);
+  }, e.prototype.get = function(t) {
+    this.ensure(t);
+    var r = this._registryMap.get(t);
+    return r[r.length - 1] || null;
+  }, e.prototype.set = function(t, r) {
+    this.ensure(t), this._registryMap.get(t).push(r);
+  }, e.prototype.setAll = function(t, r) {
+    this._registryMap.set(t, r);
+  }, e.prototype.has = function(t) {
+    return this.ensure(t), this._registryMap.get(t).length > 0;
+  }, e.prototype.clear = function() {
+    this._registryMap.clear();
+  }, e.prototype.ensure = function(t) {
+    this._registryMap.has(t) || this._registryMap.set(t, []);
+  }, e;
+}(), Or = function(e) {
+  Ze(t, e);
+  function t() {
+    return e !== null && e.apply(this, arguments) || this;
+  }
+  return t;
+}(Ye), Ee = /* @__PURE__ */ function() {
+  function e() {
+    this.scopedResolutions = /* @__PURE__ */ new Map();
+  }
+  return e;
+}();
+function Tr(e, t) {
+  if (e === null)
+    return "at position #" + t;
+  var r = e.split(",")[t].trim();
+  return '"' + r + '" at position #' + t;
+}
+function Rr(e, t, r) {
+  return r === void 0 && (r = "    "), oe([e], t.message.split(`
+`).map(function(n) {
+    return r + n;
+  })).join(`
+`);
+}
+function Pr(e, t, r) {
+  var n = Ie(e.toString().match(/constructor\(([\w, ]+)\)/) || [], 2), i = n[1], o = i === void 0 ? null : i, s = Tr(o, t);
+  return Rr("Cannot inject the dependency " + s + ' of "' + e.name + '" constructor. Reason:', r);
+}
+function kr(e) {
+  if (typeof e.dispose != "function")
+    return !1;
+  var t = e.dispose;
+  return !(t.length > 0);
+}
+var Ir = function(e) {
+  Ze(t, e);
+  function t() {
+    return e !== null && e.apply(this, arguments) || this;
+  }
+  return t;
+}(Ye), xr = function(e) {
+  Ze(t, e);
+  function t() {
+    return e !== null && e.apply(this, arguments) || this;
+  }
+  return t;
+}(Ye), $r = /* @__PURE__ */ function() {
+  function e() {
+    this.preResolution = new Ir(), this.postResolution = new xr();
+  }
+  return e;
+}(), $t = /* @__PURE__ */ new Map(), jr = function() {
+  function e(t) {
+    this.parent = t, this._registry = new Or(), this.interceptors = new $r(), this.disposed = !1, this.disposables = /* @__PURE__ */ new Set();
+  }
+  return e.prototype.register = function(t, r, n) {
+    n === void 0 && (n = { lifecycle: W.Transient }), this.ensureNotDisposed();
+    var i;
+    if (Er(r) ? i = r : i = { useClass: r }, Re(i))
+      for (var o = [t], s = i; s != null; ) {
+        var c = s.useToken;
+        if (o.includes(c))
+          throw new Error("Token registration cycle detected! " + oe(o, [c]).join(" -> "));
+        o.push(c);
+        var d = this._registry.get(c);
+        d && Re(d.provider) ? s = d.provider : s = null;
+      }
+    if ((n.lifecycle === W.Singleton || n.lifecycle == W.ContainerScoped || n.lifecycle == W.ResolutionScoped) && (Pe(i) || Ue(i)))
+      throw new Error('Cannot use lifecycle "' + W[n.lifecycle] + '" with ValueProviders or FactoryProviders');
+    return this._registry.set(t, { provider: i, options: n }), this;
+  }, e.prototype.registerType = function(t, r) {
+    return this.ensureNotDisposed(), ce(r) ? this.register(t, {
+      useToken: r
+    }) : this.register(t, {
+      useClass: r
+    });
+  }, e.prototype.registerInstance = function(t, r) {
+    return this.ensureNotDisposed(), this.register(t, {
+      useValue: r
+    });
+  }, e.prototype.registerSingleton = function(t, r) {
+    if (this.ensureNotDisposed(), ce(t)) {
+      if (ce(r))
+        return this.register(t, {
+          useToken: r
+        }, { lifecycle: W.Singleton });
+      if (r)
+        return this.register(t, {
+          useClass: r
+        }, { lifecycle: W.Singleton });
+      throw new Error('Cannot register a type name as a singleton without a "to" token');
+    }
+    var n = t;
+    return r && !ce(r) && (n = r), this.register(t, {
+      useClass: n
+    }, { lifecycle: W.Singleton });
+  }, e.prototype.resolve = function(t, r, n) {
+    r === void 0 && (r = new Ee()), n === void 0 && (n = !1), this.ensureNotDisposed();
+    var i = this.getRegistration(t);
+    if (!i && ce(t)) {
+      if (n)
+        return;
+      throw new Error('Attempted to resolve unregistered dependency token: "' + t.toString() + '"');
+    }
+    if (this.executePreResolutionInterceptor(t, "Single"), i) {
+      var o = this.resolveRegistration(i, r);
+      return this.executePostResolutionInterceptor(t, o, "Single"), o;
+    }
+    if (Mr(t)) {
+      var o = this.construct(t, r);
+      return this.executePostResolutionInterceptor(t, o, "Single"), o;
+    }
+    throw new Error("Attempted to construct an undefined constructor. Could mean a circular dependency problem. Try using `delay` function.");
+  }, e.prototype.executePreResolutionInterceptor = function(t, r) {
+    var n, i;
+    if (this.interceptors.preResolution.has(t)) {
+      var o = [];
+      try {
+        for (var s = Me(this.interceptors.preResolution.getAll(t)), c = s.next(); !c.done; c = s.next()) {
+          var d = c.value;
+          d.options.frequency != "Once" && o.push(d), d.callback(t, r);
+        }
+      } catch (f) {
+        n = { error: f };
+      } finally {
+        try {
+          c && !c.done && (i = s.return) && i.call(s);
+        } finally {
+          if (n) throw n.error;
+        }
+      }
+      this.interceptors.preResolution.setAll(t, o);
+    }
+  }, e.prototype.executePostResolutionInterceptor = function(t, r, n) {
+    var i, o;
+    if (this.interceptors.postResolution.has(t)) {
+      var s = [];
+      try {
+        for (var c = Me(this.interceptors.postResolution.getAll(t)), d = c.next(); !d.done; d = c.next()) {
+          var f = d.value;
+          f.options.frequency != "Once" && s.push(f), f.callback(t, r, n);
+        }
+      } catch (b) {
+        i = { error: b };
+      } finally {
+        try {
+          d && !d.done && (o = c.return) && o.call(c);
+        } finally {
+          if (i) throw i.error;
+        }
+      }
+      this.interceptors.postResolution.setAll(t, s);
+    }
+  }, e.prototype.resolveRegistration = function(t, r) {
+    if (this.ensureNotDisposed(), t.options.lifecycle === W.ResolutionScoped && r.scopedResolutions.has(t))
+      return r.scopedResolutions.get(t);
+    var n = t.options.lifecycle === W.Singleton, i = t.options.lifecycle === W.ContainerScoped, o = n || i, s;
+    return Pe(t.provider) ? s = t.provider.useValue : Re(t.provider) ? s = o ? t.instance || (t.instance = this.resolve(t.provider.useToken, r)) : this.resolve(t.provider.useToken, r) : It(t.provider) ? s = o ? t.instance || (t.instance = this.construct(t.provider.useClass, r)) : this.construct(t.provider.useClass, r) : Ue(t.provider) ? s = t.provider.useFactory(this) : s = this.construct(t.provider, r), t.options.lifecycle === W.ResolutionScoped && r.scopedResolutions.set(t, s), s;
+  }, e.prototype.resolveAll = function(t, r, n) {
+    var i = this;
+    r === void 0 && (r = new Ee()), n === void 0 && (n = !1), this.ensureNotDisposed();
+    var o = this.getAllRegistrations(t);
+    if (!o && ce(t)) {
+      if (n)
+        return [];
+      throw new Error('Attempted to resolve unregistered dependency token: "' + t.toString() + '"');
+    }
+    if (this.executePreResolutionInterceptor(t, "All"), o) {
+      var s = o.map(function(d) {
+        return i.resolveRegistration(d, r);
+      });
+      return this.executePostResolutionInterceptor(t, s, "All"), s;
+    }
+    var c = [this.construct(t, r)];
+    return this.executePostResolutionInterceptor(t, c, "All"), c;
+  }, e.prototype.isRegistered = function(t, r) {
+    return r === void 0 && (r = !1), this.ensureNotDisposed(), this._registry.has(t) || r && (this.parent || !1) && this.parent.isRegistered(t, !0);
+  }, e.prototype.reset = function() {
+    this.ensureNotDisposed(), this._registry.clear(), this.interceptors.preResolution.clear(), this.interceptors.postResolution.clear();
+  }, e.prototype.clearInstances = function() {
+    var t, r;
+    this.ensureNotDisposed();
+    try {
+      for (var n = Me(this._registry.entries()), i = n.next(); !i.done; i = n.next()) {
+        var o = Ie(i.value, 2), s = o[0], c = o[1];
+        this._registry.setAll(s, c.filter(function(d) {
+          return !Pe(d.provider);
+        }).map(function(d) {
+          return d.instance = void 0, d;
+        }));
+      }
+    } catch (d) {
+      t = { error: d };
+    } finally {
+      try {
+        i && !i.done && (r = n.return) && r.call(n);
+      } finally {
+        if (t) throw t.error;
+      }
+    }
+  }, e.prototype.createChildContainer = function() {
+    var t, r;
+    this.ensureNotDisposed();
+    var n = new e(this);
+    try {
+      for (var i = Me(this._registry.entries()), o = i.next(); !o.done; o = i.next()) {
+        var s = Ie(o.value, 2), c = s[0], d = s[1];
+        d.some(function(f) {
+          var b = f.options;
+          return b.lifecycle === W.ContainerScoped;
+        }) && n._registry.setAll(c, d.map(function(f) {
+          return f.options.lifecycle === W.ContainerScoped ? {
+            provider: f.provider,
+            options: f.options
+          } : f;
+        }));
+      }
+    } catch (f) {
+      t = { error: f };
+    } finally {
+      try {
+        o && !o.done && (r = i.return) && r.call(i);
+      } finally {
+        if (t) throw t.error;
+      }
+    }
+    return n;
+  }, e.prototype.beforeResolution = function(t, r, n) {
+    n === void 0 && (n = { frequency: "Always" }), this.interceptors.preResolution.set(t, {
+      callback: r,
+      options: n
+    });
+  }, e.prototype.afterResolution = function(t, r, n) {
+    n === void 0 && (n = { frequency: "Always" }), this.interceptors.postResolution.set(t, {
+      callback: r,
+      options: n
+    });
+  }, e.prototype.dispose = function() {
+    return mr(this, void 0, void 0, function() {
+      var t;
+      return wr(this, function(r) {
+        switch (r.label) {
+          case 0:
+            return this.disposed = !0, t = [], this.disposables.forEach(function(n) {
+              var i = n.dispose();
+              i && t.push(i);
+            }), [4, Promise.all(t)];
+          case 1:
+            return r.sent(), [2];
+        }
+      });
+    });
+  }, e.prototype.getRegistration = function(t) {
+    return this.isRegistered(t) ? this._registry.get(t) : this.parent ? this.parent.getRegistration(t) : null;
+  }, e.prototype.getAllRegistrations = function(t) {
+    return this.isRegistered(t) ? this._registry.getAll(t) : this.parent ? this.parent.getAllRegistrations(t) : null;
+  }, e.prototype.construct = function(t, r) {
+    var n = this;
+    if (t instanceof xt)
+      return t.createProxy(function(o) {
+        return n.resolve(o, r);
+      });
+    var i = function() {
+      var o = $t.get(t);
+      if (!o || o.length === 0) {
+        if (t.length === 0)
+          return new t();
+        throw new Error('TypeInfo not known for "' + t.name + '"');
+      }
+      var s = o.map(n.resolveParams(r, t));
+      return new (t.bind.apply(t, oe([void 0], s)))();
+    }();
+    return kr(i) && this.disposables.add(i), i;
+  }, e.prototype.resolveParams = function(t, r) {
+    var n = this;
+    return function(i, o) {
+      var s, c, d;
+      try {
+        return Sr(i) ? ht(i) ? i.multiple ? (s = n.resolve(i.transform)).transform.apply(s, oe([n.resolveAll(i.token, new Ee(), i.isOptional)], i.transformArgs)) : (c = n.resolve(i.transform)).transform.apply(c, oe([n.resolve(i.token, t, i.isOptional)], i.transformArgs)) : i.multiple ? n.resolveAll(i.token, new Ee(), i.isOptional) : n.resolve(i.token, t, i.isOptional) : ht(i) ? (d = n.resolve(i.transform, t)).transform.apply(d, oe([n.resolve(i.token, t)], i.transformArgs)) : n.resolve(i, t);
+      } catch (f) {
+        throw new Error(Pr(r, o, f));
+      }
+    };
+  }, e.prototype.ensureNotDisposed = function() {
+    if (this.disposed)
+      throw new Error("This container has been disposed, you cannot interact with a disposed container");
+  }, e;
+}(), Ar = new jr();
+function Zn(e, t) {
+  var r = {
+    token: e,
+    multiple: !1,
+    isOptional: t
+  };
+  return _r(r);
+}
+function Cr(e) {
+  return function(t) {
+    $t.set(t, gr(t));
+  };
+}
+function Yn(e, t) {
+  return function(r) {
+    Cr()(r), Ar.register(r, r, {
+      lifecycle: e
+    });
+  };
+}
+if (typeof Reflect > "u" || !Reflect.getMetadata)
+  throw new Error(`tsyringe requires a reflect polyfill. Please add 'import "reflect-metadata"' to the top of your entry point.`);
+var X = {}, re = {}, pt;
+function zr() {
+  if (pt) return re;
+  pt = 1, Object.defineProperty(re, "__esModule", { value: !0 }), re.DefaultSerializer = re.extendSerializer = void 0;
+  function e(n, i) {
+    const o = n.deserialize.bind(n), s = n.serialize.bind(n);
+    return {
+      deserialize(c) {
+        return i.deserialize(c, o);
+      },
+      serialize(c) {
+        return i.serialize(c, s);
+      }
+    };
+  }
+  re.extendSerializer = e;
+  const t = {
+    deserialize(n) {
+      return Object.assign(Error(n.message), {
+        name: n.name,
+        stack: n.stack
+      });
+    },
+    serialize(n) {
+      return {
+        __error_marker: "$$error",
+        message: n.message,
+        name: n.name,
+        stack: n.stack
+      };
+    }
+  }, r = (n) => n && typeof n == "object" && "__error_marker" in n && n.__error_marker === "$$error";
+  return re.DefaultSerializer = {
+    deserialize(n) {
+      return r(n) ? t.deserialize(n) : n;
+    },
+    serialize(n) {
+      return n instanceof Error ? t.serialize(n) : n;
+    }
+  }, re;
+}
+var vt;
+function yt() {
+  if (vt) return X;
+  vt = 1, Object.defineProperty(X, "__esModule", { value: !0 }), X.serialize = X.deserialize = X.registerSerializer = void 0;
+  const e = /* @__PURE__ */ zr();
+  let t = e.DefaultSerializer;
+  function r(o) {
+    t = e.extendSerializer(t, o);
+  }
+  X.registerSerializer = r;
+  function n(o) {
+    return t.deserialize(o);
+  }
+  X.deserialize = n;
+  function i(o) {
+    return t.serialize(o);
+  }
+  return X.serialize = i, X;
+}
+var H = {}, bt;
+function Dr() {
+  return bt || (bt = 1, Object.defineProperty(H, "__esModule", { value: !0 }), H.$worker = H.$transferable = H.$terminate = H.$events = H.$errors = void 0, H.$errors = Symbol("thread.errors"), H.$events = Symbol("thread.events"), H.$terminate = Symbol("thread.terminate"), H.$transferable = Symbol("thread.transferable"), H.$worker = Symbol("thread.worker")), H;
+}
+var ne = {}, mt;
+function wt() {
+  if (mt) return ne;
+  mt = 1, Object.defineProperty(ne, "__esModule", { value: !0 }), ne.Transfer = ne.isTransferDescriptor = void 0;
+  const e = /* @__PURE__ */ Dr();
+  function t(i) {
+    return !(!i || typeof i != "object");
+  }
+  function r(i) {
+    return i && typeof i == "object" && i[e.$transferable];
+  }
+  ne.isTransferDescriptor = r;
+  function n(i, o) {
+    if (!o) {
+      if (!t(i))
+        throw Error();
+      o = [i];
+    }
+    return {
+      [e.$transferable]: !0,
+      send: i,
+      transferables: o
+    };
+  }
+  return ne.Transfer = n, ne;
+}
+var Fe = {}, gt;
+function Fr() {
+  return gt || (gt = 1, function(e) {
+    Object.defineProperty(e, "__esModule", { value: !0 }), e.WorkerMessageType = e.MasterMessageType = void 0, function(t) {
+      t.cancel = "cancel", t.run = "run";
+    }(e.MasterMessageType || (e.MasterMessageType = {})), function(t) {
+      t.error = "error", t.init = "init", t.result = "result", t.running = "running", t.uncaughtError = "uncaughtError";
+    }(e.WorkerMessageType || (e.WorkerMessageType = {}));
+  }(Fe)), Fe;
+}
+var ie = {}, qe, _t;
+function qr() {
+  return _t || (_t = 1, qe = (e) => e ? typeof Symbol.observable == "symbol" && typeof e[Symbol.observable] == "function" ? e === e[Symbol.observable]() : typeof e["@@observable"] == "function" ? e === e["@@observable"]() : !1 : !1), qe;
+}
+var Oe = {}, St;
+function Lr() {
+  if (St) return Oe;
+  St = 1, Object.defineProperty(Oe, "__esModule", { value: !0 });
+  const e = function() {
+    const i = typeof self < "u" && typeof Window < "u" && self instanceof Window;
+    return !!(typeof self < "u" && self.postMessage && !i);
+  }, t = function(i, o) {
+    self.postMessage(i, o);
+  }, r = function(i) {
+    const o = (c) => {
+      i(c.data);
+    }, s = () => {
+      self.removeEventListener("message", o);
+    };
+    return self.addEventListener("message", o), s;
+  };
+  return Oe.default = {
+    isWorkerRuntime: e,
+    postMessageToMaster: t,
+    subscribeToMasterMessages: r
+  }, Oe;
+}
+var Mt;
+function Qn() {
+  return Mt || (Mt = 1, function(e) {
+    var t = ie && ie.__awaiter || function(y, k, $, z) {
+      function Q(N) {
+        return N instanceof $ ? N : new $(function(V) {
+          V(N);
+        });
+      }
+      return new ($ || ($ = Promise))(function(N, V) {
+        function he(Z) {
+          try {
+            se(z.next(Z));
+          } catch (ae) {
+            V(ae);
+          }
+        }
+        function _e(Z) {
+          try {
+            se(z.throw(Z));
+          } catch (ae) {
+            V(ae);
+          }
+        }
+        function se(Z) {
+          Z.done ? N(Z.value) : Q(Z.value).then(he, _e);
+        }
+        se((z = z.apply(y, k || [])).next());
+      });
+    }, r = ie && ie.__importDefault || function(y) {
+      return y && y.__esModule ? y : { default: y };
+    };
+    Object.defineProperty(e, "__esModule", { value: !0 }), e.expose = e.isWorkerRuntime = e.Transfer = e.registerSerializer = void 0;
+    const n = r(qr()), i = /* @__PURE__ */ yt(), o = /* @__PURE__ */ wt(), s = /* @__PURE__ */ Fr(), c = r(/* @__PURE__ */ Lr());
+    var d = /* @__PURE__ */ yt();
+    Object.defineProperty(e, "registerSerializer", { enumerable: !0, get: function() {
+      return d.registerSerializer;
+    } });
+    var f = /* @__PURE__ */ wt();
+    Object.defineProperty(e, "Transfer", { enumerable: !0, get: function() {
+      return f.Transfer;
+    } }), e.isWorkerRuntime = c.default.isWorkerRuntime;
+    let b = !1;
+    const M = /* @__PURE__ */ new Map(), I = (y) => y && y.type === s.MasterMessageType.cancel, O = (y) => y && y.type === s.MasterMessageType.run, x = (y) => n.default(y) || S(y);
+    function S(y) {
+      return y && typeof y == "object" && typeof y.subscribe == "function";
+    }
+    function R(y) {
+      return o.isTransferDescriptor(y) ? { payload: y.send, transferables: y.transferables } : { payload: y, transferables: void 0 };
+    }
+    function q() {
+      const y = {
+        type: s.WorkerMessageType.init,
+        exposed: {
+          type: "function"
+        }
+      };
+      c.default.postMessageToMaster(y);
+    }
+    function G(y) {
+      const k = {
+        type: s.WorkerMessageType.init,
+        exposed: {
+          type: "module",
+          methods: y
+        }
+      };
+      c.default.postMessageToMaster(k);
+    }
+    function B(y, k) {
+      const { payload: $, transferables: z } = R(k), Q = {
+        type: s.WorkerMessageType.error,
+        uid: y,
+        error: i.serialize($)
+      };
+      c.default.postMessageToMaster(Q, z);
+    }
+    function ee(y, k, $) {
+      const { payload: z, transferables: Q } = R($), N = {
+        type: s.WorkerMessageType.result,
+        uid: y,
+        complete: k ? !0 : void 0,
+        payload: z
+      };
+      c.default.postMessageToMaster(N, Q);
+    }
+    function te(y, k) {
+      const $ = {
+        type: s.WorkerMessageType.running,
+        uid: y,
+        resultType: k
+      };
+      c.default.postMessageToMaster($);
+    }
+    function U(y) {
+      try {
+        const k = {
+          type: s.WorkerMessageType.uncaughtError,
+          error: i.serialize(y)
+        };
+        c.default.postMessageToMaster(k);
+      } catch (k) {
+        console.error(`Not reporting uncaught error back to master thread as it occured while reporting an uncaught error already.
+Latest error:`, k, `
+Original error:`, y);
+      }
+    }
+    function ge(y, k, $) {
+      return t(this, void 0, void 0, function* () {
+        let z;
+        try {
+          z = k(...$);
+        } catch (N) {
+          return B(y, N);
+        }
+        const Q = x(z) ? "observable" : "promise";
+        if (te(y, Q), x(z)) {
+          const N = z.subscribe((V) => ee(y, !1, i.serialize(V)), (V) => {
+            B(y, i.serialize(V)), M.delete(y);
+          }, () => {
+            ee(y, !0), M.delete(y);
+          });
+          M.set(y, N);
+        } else
+          try {
+            const N = yield z;
+            ee(y, !0, i.serialize(N));
+          } catch (N) {
+            B(y, i.serialize(N));
+          }
+      });
+    }
+    function Ae(y) {
+      if (!c.default.isWorkerRuntime())
+        throw Error("expose() called in the master thread.");
+      if (b)
+        throw Error("expose() called more than once. This is not possible. Pass an object to expose() if you want to expose multiple functions.");
+      if (b = !0, typeof y == "function")
+        c.default.subscribeToMasterMessages((k) => {
+          O(k) && !k.method && ge(k.uid, y, k.args.map(i.deserialize));
+        }), q();
+      else if (typeof y == "object" && y) {
+        c.default.subscribeToMasterMessages(($) => {
+          O($) && $.method && ge($.uid, y[$.method], $.args.map(i.deserialize));
+        });
+        const k = Object.keys(y).filter(($) => typeof y[$] == "function");
+        G(k);
+      } else
+        throw Error(`Invalid argument passed to expose(). Expected a function or an object, got: ${y}`);
+      c.default.subscribeToMasterMessages((k) => {
+        if (I(k)) {
+          const $ = k.uid, z = M.get($);
+          z && (z.unsubscribe(), M.delete($));
+        }
+      });
+    }
+    e.expose = Ae, typeof self < "u" && typeof self.addEventListener == "function" && c.default.isWorkerRuntime() && (self.addEventListener("error", (y) => {
+      setTimeout(() => U(y.error || y), 250);
+    }), self.addEventListener("unhandledrejection", (y) => {
+      const k = y.reason;
+      k && typeof k.message == "string" && setTimeout(() => U(k), 250);
+    })), typeof process < "u" && typeof process.on == "function" && c.default.isWorkerRuntime() && (process.on("uncaughtException", (y) => {
+      setTimeout(() => U(y), 250);
+    }), process.on("unhandledRejection", (y) => {
+      y && typeof y.message == "string" && setTimeout(() => U(y), 250);
+    }));
+  }(ie)), ie;
+}
+var Ve = function(e, t) {
+  return Ve = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(r, n) {
+    r.__proto__ = n;
+  } || function(r, n) {
+    for (var i in n) Object.prototype.hasOwnProperty.call(n, i) && (r[i] = n[i]);
+  }, Ve(e, t);
+};
+function me(e, t) {
+  if (typeof t != "function" && t !== null)
+    throw new TypeError("Class extends value " + String(t) + " is not a constructor or null");
+  Ve(e, t);
+  function r() {
+    this.constructor = e;
+  }
+  e.prototype = t === null ? Object.create(t) : (r.prototype = t.prototype, new r());
+}
+function Nr(e, t, r, n) {
+  function i(o) {
+    return o instanceof r ? o : new r(function(s) {
+      s(o);
+    });
+  }
+  return new (r || (r = Promise))(function(o, s) {
+    function c(b) {
+      try {
+        f(n.next(b));
+      } catch (M) {
+        s(M);
+      }
+    }
+    function d(b) {
+      try {
+        f(n.throw(b));
+      } catch (M) {
+        s(M);
+      }
+    }
+    function f(b) {
+      b.done ? o(b.value) : i(b.value).then(c, d);
+    }
+    f((n = n.apply(e, t || [])).next());
+  });
+}
+function jt(e, t) {
+  var r = { label: 0, sent: function() {
+    if (o[0] & 1) throw o[1];
+    return o[1];
+  }, trys: [], ops: [] }, n, i, o, s = Object.create((typeof Iterator == "function" ? Iterator : Object).prototype);
+  return s.next = c(0), s.throw = c(1), s.return = c(2), typeof Symbol == "function" && (s[Symbol.iterator] = function() {
+    return this;
+  }), s;
+  function c(f) {
+    return function(b) {
+      return d([f, b]);
+    };
+  }
+  function d(f) {
+    if (n) throw new TypeError("Generator is already executing.");
+    for (; s && (s = 0, f[0] && (r = 0)), r; ) try {
+      if (n = 1, i && (o = f[0] & 2 ? i.return : f[0] ? i.throw || ((o = i.return) && o.call(i), 0) : i.next) && !(o = o.call(i, f[1])).done) return o;
+      switch (i = 0, o && (f = [f[0] & 2, o.value]), f[0]) {
+        case 0:
+        case 1:
+          o = f;
+          break;
+        case 4:
+          return r.label++, { value: f[1], done: !1 };
+        case 5:
+          r.label++, i = f[1], f = [0];
+          continue;
+        case 7:
+          f = r.ops.pop(), r.trys.pop();
+          continue;
+        default:
+          if (o = r.trys, !(o = o.length > 0 && o[o.length - 1]) && (f[0] === 6 || f[0] === 2)) {
+            r = 0;
+            continue;
+          }
+          if (f[0] === 3 && (!o || f[1] > o[0] && f[1] < o[3])) {
+            r.label = f[1];
+            break;
+          }
+          if (f[0] === 6 && r.label < o[1]) {
+            r.label = o[1], o = f;
+            break;
+          }
+          if (o && r.label < o[2]) {
+            r.label = o[2], r.ops.push(f);
+            break;
+          }
+          o[2] && r.ops.pop(), r.trys.pop();
+          continue;
+      }
+      f = t.call(e, r);
+    } catch (b) {
+      f = [6, b], i = 0;
+    } finally {
+      n = o = 0;
+    }
+    if (f[0] & 5) throw f[1];
+    return { value: f[0] ? f[1] : void 0, done: !0 };
+  }
+}
+function le(e) {
+  var t = typeof Symbol == "function" && Symbol.iterator, r = t && e[t], n = 0;
+  if (r) return r.call(e);
+  if (e && typeof e.length == "number") return {
+    next: function() {
+      return e && n >= e.length && (e = void 0), { value: e && e[n++], done: !e };
+    }
+  };
+  throw new TypeError(t ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function de(e, t) {
+  var r = typeof Symbol == "function" && e[Symbol.iterator];
+  if (!r) return e;
+  var n = r.call(e), i, o = [], s;
+  try {
+    for (; (t === void 0 || t-- > 0) && !(i = n.next()).done; ) o.push(i.value);
+  } catch (c) {
+    s = { error: c };
+  } finally {
+    try {
+      i && !i.done && (r = n.return) && r.call(n);
+    } finally {
+      if (s) throw s.error;
+    }
+  }
+  return o;
+}
+function ye(e, t, r) {
+  if (r || arguments.length === 2) for (var n = 0, i = t.length, o; n < i; n++)
+    (o || !(n in t)) && (o || (o = Array.prototype.slice.call(t, 0, n)), o[n] = t[n]);
+  return e.concat(o || Array.prototype.slice.call(t));
+}
+function fe(e) {
+  return this instanceof fe ? (this.v = e, this) : new fe(e);
+}
+function Wr(e, t, r) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var n = r.apply(e, t || []), i, o = [];
+  return i = Object.create((typeof AsyncIterator == "function" ? AsyncIterator : Object).prototype), c("next"), c("throw"), c("return", s), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i;
+  function s(O) {
+    return function(x) {
+      return Promise.resolve(x).then(O, M);
+    };
+  }
+  function c(O, x) {
+    n[O] && (i[O] = function(S) {
+      return new Promise(function(R, q) {
+        o.push([O, S, R, q]) > 1 || d(O, S);
+      });
+    }, x && (i[O] = x(i[O])));
+  }
+  function d(O, x) {
+    try {
+      f(n[O](x));
+    } catch (S) {
+      I(o[0][3], S);
+    }
+  }
+  function f(O) {
+    O.value instanceof fe ? Promise.resolve(O.value.v).then(b, M) : I(o[0][2], O);
+  }
+  function b(O) {
+    d("next", O);
+  }
+  function M(O) {
+    d("throw", O);
+  }
+  function I(O, x) {
+    O(x), o.shift(), o.length && d(o[0][0], o[0][1]);
+  }
+}
+function Hr(e) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var t = e[Symbol.asyncIterator], r;
+  return t ? t.call(e) : (e = typeof le == "function" ? le(e) : e[Symbol.iterator](), r = {}, n("next"), n("throw"), n("return"), r[Symbol.asyncIterator] = function() {
+    return this;
+  }, r);
+  function n(o) {
+    r[o] = e[o] && function(s) {
+      return new Promise(function(c, d) {
+        s = e[o](s), i(c, d, s.done, s.value);
+      });
+    };
+  }
+  function i(o, s, c, d) {
+    Promise.resolve(d).then(function(f) {
+      o({ value: f, done: c });
+    }, s);
+  }
+}
+function A(e) {
+  return typeof e == "function";
+}
+function At(e) {
+  var t = function(n) {
+    Error.call(n), n.stack = new Error().stack;
+  }, r = e(t);
+  return r.prototype = Object.create(Error.prototype), r.prototype.constructor = r, r;
+}
+var Le = At(function(e) {
+  return function(r) {
+    e(this), this.message = r ? r.length + ` errors occurred during unsubscription:
+` + r.map(function(n, i) {
+      return i + 1 + ") " + n.toString();
+    }).join(`
+  `) : "", this.name = "UnsubscriptionError", this.errors = r;
+  };
+});
+function Je(e, t) {
+  if (e) {
+    var r = e.indexOf(t);
+    0 <= r && e.splice(r, 1);
+  }
+}
+var $e = function() {
+  function e(t) {
+    this.initialTeardown = t, this.closed = !1, this._parentage = null, this._finalizers = null;
+  }
+  return e.prototype.unsubscribe = function() {
+    var t, r, n, i, o;
+    if (!this.closed) {
+      this.closed = !0;
+      var s = this._parentage;
+      if (s)
+        if (this._parentage = null, Array.isArray(s))
+          try {
+            for (var c = le(s), d = c.next(); !d.done; d = c.next()) {
+              var f = d.value;
+              f.remove(this);
+            }
+          } catch (S) {
+            t = { error: S };
+          } finally {
+            try {
+              d && !d.done && (r = c.return) && r.call(c);
+            } finally {
+              if (t) throw t.error;
+            }
+          }
+        else
+          s.remove(this);
+      var b = this.initialTeardown;
+      if (A(b))
+        try {
+          b();
+        } catch (S) {
+          o = S instanceof Le ? S.errors : [S];
+        }
+      var M = this._finalizers;
+      if (M) {
+        this._finalizers = null;
+        try {
+          for (var I = le(M), O = I.next(); !O.done; O = I.next()) {
+            var x = O.value;
+            try {
+              Et(x);
+            } catch (S) {
+              o = o ?? [], S instanceof Le ? o = ye(ye([], de(o)), de(S.errors)) : o.push(S);
+            }
+          }
+        } catch (S) {
+          n = { error: S };
+        } finally {
+          try {
+            O && !O.done && (i = I.return) && i.call(I);
+          } finally {
+            if (n) throw n.error;
+          }
+        }
+      }
+      if (o)
+        throw new Le(o);
+    }
+  }, e.prototype.add = function(t) {
+    var r;
+    if (t && t !== this)
+      if (this.closed)
+        Et(t);
+      else {
+        if (t instanceof e) {
+          if (t.closed || t._hasParent(this))
+            return;
+          t._addParent(this);
+        }
+        (this._finalizers = (r = this._finalizers) !== null && r !== void 0 ? r : []).push(t);
+      }
+  }, e.prototype._hasParent = function(t) {
+    var r = this._parentage;
+    return r === t || Array.isArray(r) && r.includes(t);
+  }, e.prototype._addParent = function(t) {
+    var r = this._parentage;
+    this._parentage = Array.isArray(r) ? (r.push(t), r) : r ? [r, t] : t;
+  }, e.prototype._removeParent = function(t) {
+    var r = this._parentage;
+    r === t ? this._parentage = null : Array.isArray(r) && Je(r, t);
+  }, e.prototype.remove = function(t) {
+    var r = this._finalizers;
+    r && Je(r, t), t instanceof e && t._removeParent(this);
+  }, e.EMPTY = function() {
+    var t = new e();
+    return t.closed = !0, t;
+  }(), e;
+}(), Ct = $e.EMPTY;
+function zt(e) {
+  return e instanceof $e || e && "closed" in e && A(e.remove) && A(e.add) && A(e.unsubscribe);
+}
+function Et(e) {
+  A(e) ? e() : e.unsubscribe();
+}
+var Dt = {
+  onUnhandledError: null,
+  onStoppedNotification: null,
+  Promise: void 0,
+  useDeprecatedSynchronousErrorHandling: !1,
+  useDeprecatedNextContext: !1
+}, Ft = {
+  setTimeout: function(e, t) {
+    for (var r = [], n = 2; n < arguments.length; n++)
+      r[n - 2] = arguments[n];
+    return setTimeout.apply(void 0, ye([e, t], de(r)));
+  },
+  clearTimeout: function(e) {
+    var t = Ft.delegate;
+    return ((t == null ? void 0 : t.clearTimeout) || clearTimeout)(e);
+  },
+  delegate: void 0
+};
+function qt(e) {
+  Ft.setTimeout(function() {
+    throw e;
+  });
+}
+function Ot() {
+}
+function ke(e) {
+  e();
+}
+var Qe = function(e) {
+  me(t, e);
+  function t(r) {
+    var n = e.call(this) || this;
+    return n.isStopped = !1, r ? (n.destination = r, zt(r) && r.add(n)) : n.destination = Vr, n;
+  }
+  return t.create = function(r, n, i) {
+    return new be(r, n, i);
+  }, t.prototype.next = function(r) {
+    this.isStopped || this._next(r);
+  }, t.prototype.error = function(r) {
+    this.isStopped || (this.isStopped = !0, this._error(r));
+  }, t.prototype.complete = function() {
+    this.isStopped || (this.isStopped = !0, this._complete());
+  }, t.prototype.unsubscribe = function() {
+    this.closed || (this.isStopped = !0, e.prototype.unsubscribe.call(this), this.destination = null);
+  }, t.prototype._next = function(r) {
+    this.destination.next(r);
+  }, t.prototype._error = function(r) {
+    try {
+      this.destination.error(r);
+    } finally {
+      this.unsubscribe();
+    }
+  }, t.prototype._complete = function() {
+    try {
+      this.destination.complete();
+    } finally {
+      this.unsubscribe();
+    }
+  }, t;
+}($e), Gr = Function.prototype.bind;
+function Ne(e, t) {
+  return Gr.call(e, t);
+}
+var Br = function() {
+  function e(t) {
+    this.partialObserver = t;
+  }
+  return e.prototype.next = function(t) {
+    var r = this.partialObserver;
+    if (r.next)
+      try {
+        r.next(t);
+      } catch (n) {
+        Te(n);
+      }
+  }, e.prototype.error = function(t) {
+    var r = this.partialObserver;
+    if (r.error)
+      try {
+        r.error(t);
+      } catch (n) {
+        Te(n);
+      }
+    else
+      Te(t);
+  }, e.prototype.complete = function() {
+    var t = this.partialObserver;
+    if (t.complete)
+      try {
+        t.complete();
+      } catch (r) {
+        Te(r);
+      }
+  }, e;
+}(), be = function(e) {
+  me(t, e);
+  function t(r, n, i) {
+    var o = e.call(this) || this, s;
+    if (A(r) || !r)
+      s = {
+        next: r ?? void 0,
+        error: n ?? void 0,
+        complete: i ?? void 0
+      };
+    else {
+      var c;
+      o && Dt.useDeprecatedNextContext ? (c = Object.create(r), c.unsubscribe = function() {
+        return o.unsubscribe();
+      }, s = {
+        next: r.next && Ne(r.next, c),
+        error: r.error && Ne(r.error, c),
+        complete: r.complete && Ne(r.complete, c)
+      }) : s = r;
+    }
+    return o.destination = new Br(s), o;
+  }
+  return t;
+}(Qe);
+function Te(e) {
+  qt(e);
+}
+function Ur(e) {
+  throw e;
+}
+var Vr = {
+  closed: !0,
+  next: Ot,
+  error: Ur,
+  complete: Ot
+}, Xe = function() {
+  return typeof Symbol == "function" && Symbol.observable || "@@observable";
+}();
+function Jr(e) {
+  return e;
+}
+function Zr(e) {
+  return e.length === 0 ? Jr : e.length === 1 ? e[0] : function(r) {
+    return e.reduce(function(n, i) {
+      return i(n);
+    }, r);
+  };
+}
+var K = function() {
+  function e(t) {
+    t && (this._subscribe = t);
+  }
+  return e.prototype.lift = function(t) {
+    var r = new e();
+    return r.source = this, r.operator = t, r;
+  }, e.prototype.subscribe = function(t, r, n) {
+    var i = this, o = Qr(t) ? t : new be(t, r, n);
+    return ke(function() {
+      var s = i, c = s.operator, d = s.source;
+      o.add(c ? c.call(o, d) : d ? i._subscribe(o) : i._trySubscribe(o));
+    }), o;
+  }, e.prototype._trySubscribe = function(t) {
+    try {
+      return this._subscribe(t);
+    } catch (r) {
+      t.error(r);
+    }
+  }, e.prototype.forEach = function(t, r) {
+    var n = this;
+    return r = Tt(r), new r(function(i, o) {
+      var s = new be({
+        next: function(c) {
+          try {
+            t(c);
+          } catch (d) {
+            o(d), s.unsubscribe();
+          }
+        },
+        error: o,
+        complete: i
+      });
+      n.subscribe(s);
+    });
+  }, e.prototype._subscribe = function(t) {
+    var r;
+    return (r = this.source) === null || r === void 0 ? void 0 : r.subscribe(t);
+  }, e.prototype[Xe] = function() {
+    return this;
+  }, e.prototype.pipe = function() {
+    for (var t = [], r = 0; r < arguments.length; r++)
+      t[r] = arguments[r];
+    return Zr(t)(this);
+  }, e.prototype.toPromise = function(t) {
+    var r = this;
+    return t = Tt(t), new t(function(n, i) {
+      var o;
+      r.subscribe(function(s) {
+        return o = s;
+      }, function(s) {
+        return i(s);
+      }, function() {
+        return n(o);
+      });
+    });
+  }, e.create = function(t) {
+    return new e(t);
+  }, e;
+}();
+function Tt(e) {
+  var t;
+  return (t = e ?? Dt.Promise) !== null && t !== void 0 ? t : Promise;
+}
+function Yr(e) {
+  return e && A(e.next) && A(e.error) && A(e.complete);
+}
+function Qr(e) {
+  return e && e instanceof Qe || Yr(e) && zt(e);
+}
+function Xr(e) {
+  return A(e == null ? void 0 : e.lift);
+}
+function je(e) {
+  return function(t) {
+    if (Xr(t))
+      return t.lift(function(r) {
+        try {
+          return e(r, this);
+        } catch (n) {
+          this.error(n);
+        }
+      });
+    throw new TypeError("Unable to lift unknown Observable type");
+  };
+}
+function xe(e, t, r, n, i) {
+  return new Kr(e, t, r, n, i);
+}
+var Kr = function(e) {
+  me(t, e);
+  function t(r, n, i, o, s, c) {
+    var d = e.call(this, r) || this;
+    return d.onFinalize = s, d.shouldUnsubscribe = c, d._next = n ? function(f) {
+      try {
+        n(f);
+      } catch (b) {
+        r.error(b);
+      }
+    } : e.prototype._next, d._error = o ? function(f) {
+      try {
+        o(f);
+      } catch (b) {
+        r.error(b);
+      } finally {
+        this.unsubscribe();
+      }
+    } : e.prototype._error, d._complete = i ? function() {
+      try {
+        i();
+      } catch (f) {
+        r.error(f);
+      } finally {
+        this.unsubscribe();
+      }
+    } : e.prototype._complete, d;
+  }
+  return t.prototype.unsubscribe = function() {
+    var r;
+    if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+      var n = this.closed;
+      e.prototype.unsubscribe.call(this), !n && ((r = this.onFinalize) === null || r === void 0 || r.call(this));
+    }
+  }, t;
+}(Qe), en = At(function(e) {
+  return function() {
+    e(this), this.name = "ObjectUnsubscribedError", this.message = "object unsubscribed";
+  };
+}), Lt = function(e) {
+  me(t, e);
+  function t() {
+    var r = e.call(this) || this;
+    return r.closed = !1, r.currentObservers = null, r.observers = [], r.isStopped = !1, r.hasError = !1, r.thrownError = null, r;
+  }
+  return t.prototype.lift = function(r) {
+    var n = new Rt(this, this);
+    return n.operator = r, n;
+  }, t.prototype._throwIfClosed = function() {
+    if (this.closed)
+      throw new en();
+  }, t.prototype.next = function(r) {
+    var n = this;
+    ke(function() {
+      var i, o;
+      if (n._throwIfClosed(), !n.isStopped) {
+        n.currentObservers || (n.currentObservers = Array.from(n.observers));
+        try {
+          for (var s = le(n.currentObservers), c = s.next(); !c.done; c = s.next()) {
+            var d = c.value;
+            d.next(r);
+          }
+        } catch (f) {
+          i = { error: f };
+        } finally {
+          try {
+            c && !c.done && (o = s.return) && o.call(s);
+          } finally {
+            if (i) throw i.error;
+          }
+        }
+      }
+    });
+  }, t.prototype.error = function(r) {
+    var n = this;
+    ke(function() {
+      if (n._throwIfClosed(), !n.isStopped) {
+        n.hasError = n.isStopped = !0, n.thrownError = r;
+        for (var i = n.observers; i.length; )
+          i.shift().error(r);
+      }
+    });
+  }, t.prototype.complete = function() {
+    var r = this;
+    ke(function() {
+      if (r._throwIfClosed(), !r.isStopped) {
+        r.isStopped = !0;
+        for (var n = r.observers; n.length; )
+          n.shift().complete();
+      }
+    });
+  }, t.prototype.unsubscribe = function() {
+    this.isStopped = this.closed = !0, this.observers = this.currentObservers = null;
+  }, Object.defineProperty(t.prototype, "observed", {
+    get: function() {
+      var r;
+      return ((r = this.observers) === null || r === void 0 ? void 0 : r.length) > 0;
+    },
+    enumerable: !1,
+    configurable: !0
+  }), t.prototype._trySubscribe = function(r) {
+    return this._throwIfClosed(), e.prototype._trySubscribe.call(this, r);
+  }, t.prototype._subscribe = function(r) {
+    return this._throwIfClosed(), this._checkFinalizedStatuses(r), this._innerSubscribe(r);
+  }, t.prototype._innerSubscribe = function(r) {
+    var n = this, i = this, o = i.hasError, s = i.isStopped, c = i.observers;
+    return o || s ? Ct : (this.currentObservers = null, c.push(r), new $e(function() {
+      n.currentObservers = null, Je(c, r);
+    }));
+  }, t.prototype._checkFinalizedStatuses = function(r) {
+    var n = this, i = n.hasError, o = n.thrownError, s = n.isStopped;
+    i ? r.error(o) : s && r.complete();
+  }, t.prototype.asObservable = function() {
+    var r = new K();
+    return r.source = this, r;
+  }, t.create = function(r, n) {
+    return new Rt(r, n);
+  }, t;
+}(K), Rt = function(e) {
+  me(t, e);
+  function t(r, n) {
+    var i = e.call(this) || this;
+    return i.destination = r, i.source = n, i;
+  }
+  return t.prototype.next = function(r) {
+    var n, i;
+    (i = (n = this.destination) === null || n === void 0 ? void 0 : n.next) === null || i === void 0 || i.call(n, r);
+  }, t.prototype.error = function(r) {
+    var n, i;
+    (i = (n = this.destination) === null || n === void 0 ? void 0 : n.error) === null || i === void 0 || i.call(n, r);
+  }, t.prototype.complete = function() {
+    var r, n;
+    (n = (r = this.destination) === null || r === void 0 ? void 0 : r.complete) === null || n === void 0 || n.call(r);
+  }, t.prototype._subscribe = function(r) {
+    var n, i;
+    return (i = (n = this.source) === null || n === void 0 ? void 0 : n.subscribe(r)) !== null && i !== void 0 ? i : Ct;
+  }, t;
+}(Lt), Nt = function(e) {
+  return e && typeof e.length == "number" && typeof e != "function";
+};
+function tn(e) {
+  return A(e == null ? void 0 : e.then);
+}
+function rn(e) {
+  return A(e[Xe]);
+}
+function nn(e) {
+  return Symbol.asyncIterator && A(e == null ? void 0 : e[Symbol.asyncIterator]);
+}
+function on(e) {
+  return new TypeError("You provided " + (e !== null && typeof e == "object" ? "an invalid object" : "'" + e + "'") + " where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.");
+}
+function sn() {
+  return typeof Symbol != "function" || !Symbol.iterator ? "@@iterator" : Symbol.iterator;
+}
+var an = sn();
+function un(e) {
+  return A(e == null ? void 0 : e[an]);
+}
+function cn(e) {
+  return Wr(this, arguments, function() {
+    var r, n, i, o;
+    return jt(this, function(s) {
+      switch (s.label) {
+        case 0:
+          r = e.getReader(), s.label = 1;
+        case 1:
+          s.trys.push([1, , 9, 10]), s.label = 2;
+        case 2:
+          return [4, fe(r.read())];
+        case 3:
+          return n = s.sent(), i = n.value, o = n.done, o ? [4, fe(void 0)] : [3, 5];
+        case 4:
+          return [2, s.sent()];
+        case 5:
+          return [4, fe(i)];
+        case 6:
+          return [4, s.sent()];
+        case 7:
+          return s.sent(), [3, 2];
+        case 8:
+          return [3, 10];
+        case 9:
+          return r.releaseLock(), [7];
+        case 10:
+          return [2];
+      }
+    });
+  });
+}
+function fn(e) {
+  return A(e == null ? void 0 : e.getReader);
+}
+function we(e) {
+  if (e instanceof K)
+    return e;
+  if (e != null) {
+    if (rn(e))
+      return ln(e);
+    if (Nt(e))
+      return dn(e);
+    if (tn(e))
+      return hn(e);
+    if (nn(e))
+      return Wt(e);
+    if (un(e))
+      return pn(e);
+    if (fn(e))
+      return vn(e);
+  }
+  throw on(e);
+}
+function ln(e) {
+  return new K(function(t) {
+    var r = e[Xe]();
+    if (A(r.subscribe))
+      return r.subscribe(t);
+    throw new TypeError("Provided object does not correctly implement Symbol.observable");
+  });
+}
+function dn(e) {
+  return new K(function(t) {
+    for (var r = 0; r < e.length && !t.closed; r++)
+      t.next(e[r]);
+    t.complete();
+  });
+}
+function hn(e) {
+  return new K(function(t) {
+    e.then(function(r) {
+      t.closed || (t.next(r), t.complete());
+    }, function(r) {
+      return t.error(r);
+    }).then(null, qt);
+  });
+}
+function pn(e) {
+  return new K(function(t) {
+    var r, n;
+    try {
+      for (var i = le(e), o = i.next(); !o.done; o = i.next()) {
+        var s = o.value;
+        if (t.next(s), t.closed)
+          return;
+      }
+    } catch (c) {
+      r = { error: c };
+    } finally {
+      try {
+        o && !o.done && (n = i.return) && n.call(i);
+      } finally {
+        if (r) throw r.error;
+      }
+    }
+    t.complete();
+  });
+}
+function Wt(e) {
+  return new K(function(t) {
+    yn(e, t).catch(function(r) {
+      return t.error(r);
+    });
+  });
+}
+function vn(e) {
+  return Wt(cn(e));
+}
+function yn(e, t) {
+  var r, n, i, o;
+  return Nr(this, void 0, void 0, function() {
+    var s, c;
+    return jt(this, function(d) {
+      switch (d.label) {
+        case 0:
+          d.trys.push([0, 5, 6, 11]), r = Hr(e), d.label = 1;
+        case 1:
+          return [4, r.next()];
+        case 2:
+          if (n = d.sent(), !!n.done) return [3, 4];
+          if (s = n.value, t.next(s), t.closed)
+            return [2];
+          d.label = 3;
+        case 3:
+          return [3, 1];
+        case 4:
+          return [3, 11];
+        case 5:
+          return c = d.sent(), i = { error: c }, [3, 11];
+        case 6:
+          return d.trys.push([6, , 9, 10]), n && !n.done && (o = r.return) ? [4, o.call(r)] : [3, 8];
+        case 7:
+          d.sent(), d.label = 8;
+        case 8:
+          return [3, 10];
+        case 9:
+          if (i) throw i.error;
+          return [7];
+        case 10:
+          return [7];
+        case 11:
+          return t.complete(), [2];
+      }
+    });
+  });
+}
+function Ht(e, t) {
+  return je(function(r, n) {
+    var i = 0;
+    r.subscribe(xe(n, function(o) {
+      n.next(e.call(t, o, i++));
+    }));
+  });
+}
+var bn = Array.isArray;
+function mn(e, t) {
+  return bn(t) ? e.apply(void 0, ye([], de(t))) : e(t);
+}
+function wn(e) {
+  return Ht(function(t) {
+    return mn(e, t);
+  });
+}
+function gn(e, t, r, n, i, o, s, c) {
+  var d = [], f = 0, b = 0, M = !1, I = function() {
+    M && !d.length && !f && t.complete();
+  }, O = function(S) {
+    return f < n ? x(S) : d.push(S);
+  }, x = function(S) {
+    f++;
+    var R = !1;
+    we(r(S, b++)).subscribe(xe(t, function(q) {
+      t.next(q);
+    }, function() {
+      R = !0;
+    }, void 0, function() {
+      if (R)
+        try {
+          f--;
+          for (var q = function() {
+            var G = d.shift();
+            s || x(G);
+          }; d.length && f < n; )
+            q();
+          I();
+        } catch (G) {
+          t.error(G);
+        }
+    }));
+  };
+  return e.subscribe(xe(t, O, function() {
+    M = !0, I();
+  })), function() {
+  };
+}
+function Gt(e, t, r) {
+  return r === void 0 && (r = 1 / 0), A(t) ? Gt(function(n, i) {
+    return Ht(function(o, s) {
+      return t(n, o, i, s);
+    })(we(e(n, i)));
+  }, r) : (typeof t == "number" && (r = t), je(function(n, i) {
+    return gn(n, i, e, r);
+  }));
+}
+var _n = ["addListener", "removeListener"], Sn = ["addEventListener", "removeEventListener"], Mn = ["on", "off"];
+function Pt(e, t, r, n) {
+  if (A(r) && (n = r, r = void 0), n)
+    return Pt(e, t, r).pipe(wn(n));
+  var i = de(Tn(e) ? Sn.map(function(c) {
+    return function(d) {
+      return e[c](t, d, r);
+    };
+  }) : En(e) ? _n.map(kt(e, t)) : On(e) ? Mn.map(kt(e, t)) : [], 2), o = i[0], s = i[1];
+  if (!o && Nt(e))
+    return Gt(function(c) {
+      return Pt(c, t, r);
+    })(we(e));
+  if (!o)
+    throw new TypeError("Invalid event target");
+  return new K(function(c) {
+    var d = function() {
+      for (var f = [], b = 0; b < arguments.length; b++)
+        f[b] = arguments[b];
+      return c.next(1 < f.length ? f : f[0]);
+    };
+    return o(d), function() {
+      return s(d);
+    };
+  });
+}
+function kt(e, t) {
+  return function(r) {
+    return function(n) {
+      return e[r](t, n);
+    };
+  };
+}
+function En(e) {
+  return A(e.addListener) && A(e.removeListener);
+}
+function On(e) {
+  return A(e.on) && A(e.off);
+}
+function Tn(e) {
+  return A(e.addEventListener) && A(e.removeEventListener);
+}
+function Xn(e, t) {
+  return je(function(r, n) {
+    var i = 0;
+    r.subscribe(xe(n, function(o) {
+      return e.call(t, o, i++) && n.next(o);
+    }));
+  });
+}
+function Kn(e) {
+  e === void 0 && (e = {});
+  var t = e.connector, r = t === void 0 ? function() {
+    return new Lt();
+  } : t, n = e.resetOnError, i = n === void 0 ? !0 : n, o = e.resetOnComplete, s = o === void 0 ? !0 : o, c = e.resetOnRefCountZero, d = c === void 0 ? !0 : c;
+  return function(f) {
+    var b, M, I, O = 0, x = !1, S = !1, R = function() {
+      M == null || M.unsubscribe(), M = void 0;
+    }, q = function() {
+      R(), b = I = void 0, x = S = !1;
+    }, G = function() {
+      var B = b;
+      q(), B == null || B.unsubscribe();
+    };
+    return je(function(B, ee) {
+      O++, !S && !x && R();
+      var te = I = I ?? r();
+      ee.add(function() {
+        O--, O === 0 && !S && !x && (M = We(G, d));
+      }), te.subscribe(ee), !b && O > 0 && (b = new be({
+        next: function(U) {
+          return te.next(U);
+        },
+        error: function(U) {
+          S = !0, R(), M = We(q, i, U), te.error(U);
+        },
+        complete: function() {
+          x = !0, R(), M = We(q, s), te.complete();
+        }
+      }), we(B).subscribe(b));
+    })(f);
+  };
+}
+function We(e, t) {
+  for (var r = [], n = 2; n < arguments.length; n++)
+    r[n - 2] = arguments[n];
+  if (t === !0) {
+    e();
+    return;
+  }
+  if (t !== !1) {
+    var i = new be({
+      next: function() {
+        i.unsubscribe(), e();
+      }
+    });
+    return we(t.apply(void 0, ye([], de(r)))).subscribe(i);
+  }
+}
+class ei extends cr {
+  constructor(t) {
+    super(t);
+  }
+  load(t, r, n, i) {
+    const o = this, s = new fr(this.manager);
+    s.setPath(this.path), s.setRequestHeader(this.requestHeader), s.setWithCredentials(this.withCredentials), s.load(t, function(c) {
+      const d = o.parse(JSON.parse(c));
+      r && r(d);
+    }, n, i);
+  }
+  parse(t) {
+    return new Rn(t);
+  }
+}
+class Rn {
+  constructor(t) {
+    this.isFont = !0, this.type = "Font", this.data = t;
+  }
+  generateShapes(t, r = 100) {
+    const n = [], i = Pn(t, r, this.data);
+    for (let o = 0, s = i.length; o < s; o++)
+      n.push(...i[o].toShapes());
+    return n;
+  }
+}
+function Pn(e, t, r) {
+  const n = Array.from(e), i = t / r.resolution, o = (r.boundingBox.yMax - r.boundingBox.yMin + r.underlineThickness) * i, s = [];
+  let c = 0, d = 0;
+  for (let f = 0; f < n.length; f++) {
+    const b = n[f];
+    if (b === `
+`)
+      c = 0, d -= o;
+    else {
+      const M = kn(b, i, c, d, r);
+      c += M.offsetX, s.push(M.path);
+    }
+  }
+  return s;
+}
+function kn(e, t, r, n, i) {
+  const o = i.glyphs[e] || i.glyphs["?"];
+  if (!o) {
+    console.error('THREE.Font: character "' + e + '" does not exists in font family ' + i.familyName + ".");
+    return;
+  }
+  const s = new lr();
+  let c, d, f, b, M, I, O, x;
+  if (o.o) {
+    const S = o._cachedOutline || (o._cachedOutline = o.o.split(" "));
+    for (let R = 0, q = S.length; R < q; )
+      switch (S[R++]) {
+        case "m":
+          c = S[R++] * t + r, d = S[R++] * t + n, s.moveTo(c, d);
+          break;
+        case "l":
+          c = S[R++] * t + r, d = S[R++] * t + n, s.lineTo(c, d);
+          break;
+        case "q":
+          f = S[R++] * t + r, b = S[R++] * t + n, M = S[R++] * t + r, I = S[R++] * t + n, s.quadraticCurveTo(M, I, f, b);
+          break;
+        case "b":
+          f = S[R++] * t + r, b = S[R++] * t + n, M = S[R++] * t + r, I = S[R++] * t + n, O = S[R++] * t + r, x = S[R++] * t + n, s.bezierCurveTo(M, I, O, x, f, b);
+          break;
+      }
+  }
+  return { offsetX: o.ha * t, path: s };
+}
+export {
+  Cn as A,
+  xe as B,
+  Dn as C,
+  dr as D,
+  Jn as E,
+  ei as F,
+  Jr as G,
+  A as H,
+  Nn as I,
+  Un as J,
+  $n as K,
+  W as L,
+  Rn as M,
+  Hn as N,
+  K as O,
+  An as P,
+  Vn as R,
+  Lt as S,
+  ye as _,
+  Fr as a,
+  yt as b,
+  wt as c,
+  Qn as d,
+  zr as e,
+  qn as f,
+  Ln as g,
+  jn as h,
+  Zn as i,
+  Pt as j,
+  Xn as k,
+  Kn as l,
+  Ht as m,
+  Bn as n,
+  zn as o,
+  Fn as p,
+  Ar as q,
+  Dr as r,
+  Yn as s,
+  Gn as t,
+  hr as u,
+  pr as v,
+  $e as w,
+  Wn as x,
+  de as y,
+  je as z
+};