@uva-glass/component-library 3.52.10 → 3.53.0

package/dist/chunk-SS2NHR7W-qmI2h7CJ.js

@@ -0,0 +1,4507 @@
+import { _ as $, d as He, a as Ae, b as qe, s as re, l as ke } from "./index-B4NxQN5d.js";
+var st = $({
+  "../node_modules/picoquery/lib/string-util.js"(t) {
+    Object.defineProperty(t, "__esModule", { value: !0 }), t.encodeString = o;
+    var u = Array.from({ length: 256 }, (s, i) => "%" + ((i < 16 ? "0" : "") + i.toString(16)).toUpperCase()), n = new Int8Array([
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      0,
+      0,
+      1,
+      1,
+      1,
+      1,
+      0,
+      0,
+      1,
+      1,
+      0,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      0,
+      0,
+      0,
+      1,
+      0
+    ]);
+    function o(s) {
+      let i = s.length;
+      if (i === 0)
+        return "";
+      let p = "", d = 0, m = 0;
+      e: for (; m < i; m++) {
+        let f = s.charCodeAt(m);
+        for (; f < 128; ) {
+          if (n[f] !== 1 && (d < m && (p += s.slice(d, m)), d = m + 1, p += u[f]), ++m === i)
+            break e;
+          f = s.charCodeAt(m);
+        }
+        if (d < m && (p += s.slice(d, m)), f < 2048) {
+          d = m + 1, p += u[192 | f >> 6] + u[128 | f & 63];
+          continue;
+        }
+        if (f < 55296 || f >= 57344) {
+          d = m + 1, p += u[224 | f >> 12] + u[128 | f >> 6 & 63] + u[128 | f & 63];
+          continue;
+        }
+        if (++m, m >= i)
+          throw new Error("URI malformed");
+        let b = s.charCodeAt(m) & 1023;
+        d = m + 1, f = 65536 + ((f & 1023) << 10 | b), p += u[240 | f >> 18] + u[128 | f >> 12 & 63] + u[128 | f >> 6 & 63] + u[128 | f & 63];
+      }
+      return d === 0 ? s : d < i ? p + s.slice(d) : p;
+    }
+  }
+}), Ke = $({
+  "../node_modules/picoquery/lib/shared.js"(t) {
+    Object.defineProperty(t, "__esModule", { value: !0 }), t.defaultOptions = t.defaultShouldSerializeObject = t.defaultValueSerializer = void 0;
+    var u = st(), n = (i) => {
+      switch (typeof i) {
+        case "string":
+          return (0, u.encodeString)(i);
+        case "bigint":
+        case "boolean":
+          return "" + i;
+        case "number":
+          if (Number.isFinite(i))
+            return i < 1e21 ? "" + i : (0, u.encodeString)("" + i);
+          break;
+      }
+      return i instanceof Date ? (0, u.encodeString)(i.toISOString()) : "";
+    };
+    t.defaultValueSerializer = n;
+    var o = (i) => i instanceof Date;
+    t.defaultShouldSerializeObject = o;
+    var s = (i) => i;
+    t.defaultOptions = {
+      nesting: !0,
+      nestingSyntax: "dot",
+      arrayRepeat: !1,
+      arrayRepeatSyntax: "repeat",
+      delimiter: 38,
+      valueDeserializer: s,
+      valueSerializer: t.defaultValueSerializer,
+      keyDeserializer: s,
+      shouldSerializeObject: t.defaultShouldSerializeObject
+    };
+  }
+}), lt = $({
+  "../node_modules/picoquery/lib/object-util.js"(t) {
+    Object.defineProperty(t, "__esModule", { value: !0 }), t.getDeepObject = s, t.stringifyObject = b;
+    var u = Ke(), n = st();
+    function o(D) {
+      return D === "__proto__" || D === "constructor" || D === "prototype";
+    }
+    function s(D, v, C, F, w) {
+      if (o(v))
+        return D;
+      let L = D[v];
+      return typeof L == "object" && L !== null ? L : !F && (w || typeof C == "number" || typeof C == "string" && C * 0 === 0 && C.indexOf(".") === -1) ? D[v] = [] : D[v] = {};
+    }
+    var i = 20, p = "[]", d = "[", m = "]", f = ".";
+    function b(D, v, C = 0, F, w) {
+      let { nestingSyntax: L = u.defaultOptions.nestingSyntax, arrayRepeat: O = u.defaultOptions.arrayRepeat, arrayRepeatSyntax: x = u.defaultOptions.arrayRepeatSyntax, nesting: P = u.defaultOptions.nesting, delimiter: N = u.defaultOptions.delimiter, valueSerializer: Y = u.defaultOptions.valueSerializer, shouldSerializeObject: S = u.defaultOptions.shouldSerializeObject } = v, U = typeof N == "number" ? String.fromCharCode(N) : N, R = w === !0 && O, q = L === "dot" || L === "js" && !w;
+      if (C > i)
+        return "";
+      let _ = "", V = !0, H = !1;
+      for (let T in D) {
+        let c = D[T];
+        if (c === void 0)
+          continue;
+        let y;
+        F ? (y = F, R ? x === "bracket" && (y += p) : q ? (y += f, y += T) : (y += d, y += T, y += m)) : y = T, V || (_ += U), typeof c == "object" && c !== null && !S(c) ? (H = c.pop !== void 0, (P || O && H) && (_ += b(c, v, C + 1, y, H))) : (_ += (0, n.encodeString)(y), _ += "=", _ += Y(c, T)), V && (V = !1);
+      }
+      return _;
+    }
+  }
+}), ir = $({
+  "../node_modules/picoquery/lib/decode-uri-component.js"(t) {
+    Object.defineProperty(t, "__esModule", { value: !0 }), t.decodeURIComponent = s;
+    var u = 12, n = 0, o = [
+      // The first part of the table maps bytes to character to a transition.
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      2,
+      2,
+      2,
+      2,
+      2,
+      2,
+      2,
+      2,
+      2,
+      2,
+      2,
+      2,
+      2,
+      2,
+      2,
+      2,
+      3,
+      3,
+      3,
+      3,
+      3,
+      3,
+      3,
+      3,
+      3,
+      3,
+      3,
+      3,
+      3,
+      3,
+      3,
+      3,
+      3,
+      3,
+      3,
+      3,
+      3,
+      3,
+      3,
+      3,
+      3,
+      3,
+      3,
+      3,
+      3,
+      3,
+      3,
+      3,
+      4,
+      4,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      6,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      8,
+      7,
+      7,
+      10,
+      9,
+      9,
+      9,
+      11,
+      4,
+      4,
+      4,
+      4,
+      4,
+      4,
+      4,
+      4,
+      4,
+      4,
+      4,
+      // The second part of the table maps a state to a new state when adding a
+      // transition.
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      12,
+      0,
+      0,
+      0,
+      0,
+      24,
+      36,
+      48,
+      60,
+      72,
+      84,
+      96,
+      0,
+      12,
+      12,
+      12,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      24,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      24,
+      24,
+      24,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      24,
+      24,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      48,
+      48,
+      48,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      48,
+      48,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      48,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      // The third part maps the current transition to a mask that needs to apply
+      // to the byte.
+      127,
+      63,
+      63,
+      63,
+      0,
+      31,
+      15,
+      15,
+      15,
+      7,
+      7,
+      7
+    ];
+    function s(d) {
+      let m = d.indexOf("%");
+      if (m === -1)
+        return d;
+      let f = d.length, b = "", D = 0, v = 0, C = m, F = u;
+      for (; m > -1 && m < f; ) {
+        let w = p(d[m + 1], 4), L = p(d[m + 2], 0), O = w | L, x = o[O];
+        if (F = o[256 + F + x], v = v << 6 | O & o[364 + x], F === u)
+          b += d.slice(D, C), b += v <= 65535 ? String.fromCharCode(v) : String.fromCharCode(55232 + (v >> 10), 56320 + (v & 1023)), v = 0, D = m + 3, m = C = d.indexOf("%", D);
+        else {
+          if (F === n)
+            return null;
+          if (m += 3, m < f && d.charCodeAt(m) === 37)
+            continue;
+          return null;
+        }
+      }
+      return b + d.slice(D);
+    }
+    var i = {
+      0: 0,
+      1: 1,
+      2: 2,
+      3: 3,
+      4: 4,
+      5: 5,
+      6: 6,
+      7: 7,
+      8: 8,
+      9: 9,
+      a: 10,
+      A: 10,
+      b: 11,
+      B: 11,
+      c: 12,
+      C: 12,
+      d: 13,
+      D: 13,
+      e: 14,
+      E: 14,
+      f: 15,
+      F: 15
+    };
+    function p(d, m) {
+      let f = i[d];
+      return f === void 0 ? 255 : f << m;
+    }
+  }
+}), sr = $({
+  "../node_modules/picoquery/lib/parse.js"(t) {
+    Object.defineProperty(t, "__esModule", { value: !0 }), t.numberValueDeserializer = t.numberKeyDeserializer = void 0, t.parse = f;
+    var u = lt(), n = Ke(), o = ir(), s = (b) => {
+      let D = Number(b);
+      return Number.isNaN(D) ? b : D;
+    };
+    t.numberKeyDeserializer = s;
+    var i = (b) => {
+      let D = Number(b);
+      return Number.isNaN(D) ? b : D;
+    };
+    t.numberValueDeserializer = i;
+    var p = /\+/g, d = function() {
+    };
+    d.prototype = /* @__PURE__ */ Object.create(null);
+    function m(b, D, v, C, F) {
+      let w = b.substring(D, v);
+      return C && (w = w.replace(p, " ")), F && (w = (0, o.decodeURIComponent)(w) || w), w;
+    }
+    function f(b, D) {
+      let { valueDeserializer: v = n.defaultOptions.valueDeserializer, keyDeserializer: C = n.defaultOptions.keyDeserializer, arrayRepeatSyntax: F = n.defaultOptions.arrayRepeatSyntax, nesting: w = n.defaultOptions.nesting, arrayRepeat: L = n.defaultOptions.arrayRepeat, nestingSyntax: O = n.defaultOptions.nestingSyntax, delimiter: x = n.defaultOptions.delimiter } = D ?? {}, P = typeof x == "string" ? x.charCodeAt(0) : x, N = O === "js", Y = new d();
+      if (typeof b != "string")
+        return Y;
+      let S = b.length, U = "", R = -1, q = -1, _ = -1, V = Y, H, T = "", c = "", y = !1, h = !1, A = !1, J = !1, k = !1, X = !1, I = 0, G = -1, ie = -1, Te = -1;
+      for (let z = 0; z < S + 1; z++) {
+        if (I = z !== S ? b.charCodeAt(z) : P, I === P) {
+          if (X = q > R, X || (q = z), _ !== q - 1 && (c = m(b, _ + 1, G > -1 ? G : q, A, y), T = C(c), H !== void 0 && (V = (0, u.getDeepObject)(V, H, T, N && k, void 0))), X || T !== "") {
+            X && (U = b.slice(q + 1, z), J && (U = U.replace(p, " ")), h && (U = (0, o.decodeURIComponent)(U) || U));
+            let te = v(U, T);
+            if (L) {
+              let ue = V[T];
+              ue === void 0 ? G > -1 ? V[T] = [te] : V[T] = te : ue.pop ? ue.push(te) : V[T] = [ue, te];
+            } else
+              V[T] = te;
+          }
+          U = "", R = z, q = z, y = !1, h = !1, A = !1, J = !1, k = !1, G = -1, _ = z, V = Y, H = void 0, T = "";
+        } else I === 93 ? (L && F === "bracket" && Te === 91 && (G = ie), w && (O === "index" || N) && q <= R && (_ !== ie && (c = m(b, _ + 1, z, A, y), T = C(c), H !== void 0 && (V = (0, u.getDeepObject)(V, H, T, void 0, void 0)), H = T, A = !1, y = !1), _ = z, k = !1)) : I === 46 ? w && (O === "dot" || N) && q <= R && (_ !== ie && (c = m(b, _ + 1, z, A, y), T = C(c), H !== void 0 && (V = (0, u.getDeepObject)(V, H, T, N)), H = T, A = !1, y = !1), k = !0, _ = z) : I === 91 ? w && (O === "index" || N) && q <= R && (_ !== ie && (c = m(b, _ + 1, z, A, y), T = C(c), N && H !== void 0 && (V = (0, u.getDeepObject)(V, H, T, N)), H = T, A = !1, y = !1, k = !1), _ = z) : I === 61 ? q <= R ? q = z : h = !0 : I === 43 ? q > R ? J = !0 : A = !0 : I === 37 && (q > R ? h = !0 : y = !0);
+        ie = z, Te = I;
+      }
+      return Y;
+    }
+  }
+}), lr = $({
+  "../node_modules/picoquery/lib/stringify.js"(t) {
+    Object.defineProperty(t, "__esModule", { value: !0 }), t.stringify = n;
+    var u = lt();
+    function n(o, s) {
+      if (o === null || typeof o != "object")
+        return "";
+      let i = s ?? {};
+      return (0, u.stringifyObject)(o, i);
+    }
+  }
+}), Ge = $({
+  "../node_modules/picoquery/lib/main.js"(t) {
+    var u = t && t.__createBinding || (Object.create ? (function(i, p, d, m) {
+      m === void 0 && (m = d);
+      var f = Object.getOwnPropertyDescriptor(p, d);
+      (!f || ("get" in f ? !p.__esModule : f.writable || f.configurable)) && (f = { enumerable: !0, get: function() {
+        return p[d];
+      } }), Object.defineProperty(i, m, f);
+    }) : (function(i, p, d, m) {
+      m === void 0 && (m = d), i[m] = p[d];
+    })), n = t && t.__exportStar || function(i, p) {
+      for (var d in i) d !== "default" && !Object.prototype.hasOwnProperty.call(p, d) && u(p, i, d);
+    };
+    Object.defineProperty(t, "__esModule", { value: !0 }), t.stringify = t.parse = void 0;
+    var o = sr();
+    Object.defineProperty(t, "parse", { enumerable: !0, get: function() {
+      return o.parse;
+    } });
+    var s = lr();
+    Object.defineProperty(t, "stringify", { enumerable: !0, get: function() {
+      return s.stringify;
+    } }), n(Ke(), t);
+  }
+});
+function Me(t) {
+  if (!t || typeof t != "object")
+    return !1;
+  let u = Object.getPrototypeOf(t);
+  return u === null || u === Object.prototype || Object.getPrototypeOf(u) === null ? Object.prototype.toString.call(t) === "[object Object]" : !1;
+}
+function cr(t, u) {
+  let n = {}, o = Object.keys(t);
+  for (let s = 0; s < o.length; s++) {
+    let i = o[s], p = t[i];
+    n[i] = u(p, i, t);
+  }
+  return n;
+}
+function nt({
+  code: t,
+  category: u
+}) {
+  let n = String(t).padStart(4, "0");
+  return `SB_${u}_${n}`;
+}
+function at(t) {
+  if (/^(?!.*storybook\.js\.org)|[?&]ref=error\b/.test(t))
+    return t;
+  try {
+    let u = new URL(t);
+    return u.searchParams.set("ref", "error"), u.toString();
+  } catch {
+    return t;
+  }
+}
+var ct = class pt extends Error {
+  constructor(u) {
+    super(pt.getFullMessage(u)), this.data = {}, this.fromStorybook = !0, this.isHandledError = !1, this.category = u.category, this.documentation = u.documentation ?? !1, this.code = u.code, this.isHandledError = u.isHandledError ?? !1, this.name = u.name;
+  }
+  get fullErrorCode() {
+    return nt({ code: this.code, category: this.category });
+  }
+  /** Overrides the default `Error.name` property in the format: SB_<CATEGORY>_<CODE>. */
+  get name() {
+    let u = this._name || this.constructor.name;
+    return `${this.fullErrorCode} (${u})`;
+  }
+  set name(u) {
+    this._name = u;
+  }
+  /** Generates the error message along with additional documentation link (if applicable). */
+  static getFullMessage({
+    documentation: u,
+    code: n,
+    category: o,
+    message: s
+  }) {
+    let i;
+    return u === !0 ? i = `https://storybook.js.org/error/${nt({ code: n, category: o })}?ref=error` : typeof u == "string" ? i = at(u) : Array.isArray(u) && (i = `
+${u.map((p) => `	- ${at(p)}`).join(`
+`)}`), `${s}${i != null ? `
+
+More info: ${i}
+` : ""}`;
+  }
+}, Zu = class extends ct {
+  constructor(t) {
+    super({
+      name: "ImplicitActionsDuringRendering",
+      category: "PREVIEW_API",
+      code: 2,
+      documentation: "https://github.com/storybookjs/storybook/blob/next/MIGRATION.md#using-implicit-actions-during-rendering-is-deprecated-for-example-in-the-play-function",
+      message: He`
+        We detected that you use an implicit action arg while ${t.phase} of your story.  
+        ${t.deprecated ? `
+This is deprecated and won't work in Storybook 8 anymore.
+` : ""}
+        Please provide an explicit spy to your args like this:
+          import { fn } from 'storybook/test';
+          ... 
+          args: {
+           ${t.name}: fn()
+          }`
+    }), this.data = t;
+  }
+}, dt = class extends ct {
+  constructor(t) {
+    super({
+      name: "UnknownArgTypesError",
+      category: "DOCS-TOOLS",
+      code: 1,
+      documentation: "https://github.com/storybookjs/storybook/issues/26606",
+      message: He`
+        There was a failure when generating detailed ArgTypes in ${t.language} for:
+        ${JSON.stringify(t.type, null, 2)} 
+        
+        Storybook will fall back to use a generic type description instead.
+
+        This type is either not supported or it is a bug in the docgen generation in Storybook.
+        If you think this is a bug, please detail it as much as possible in the Github issue.
+      `
+    }), this.data = t;
+  }
+}, pr = $({
+  "../node_modules/jsdoc-type-pratt-parser/dist/index.js"(t, u) {
+    (function(n, o) {
+      typeof t == "object" && typeof u < "u" ? o(t) : typeof define == "function" && define.amd ? define(["exports"], o) : (n = typeof globalThis < "u" ? globalThis : n || self, o(n.jtpp = {}));
+    })(t, (function(n) {
+      function o(e) {
+        return e.text !== void 0 && e.text !== "" ? `'${e.type}' with value '${e.text}'` : `'${e.type}'`;
+      }
+      class s extends Error {
+        constructor(r) {
+          super(`No parslet found for token: ${o(r)}`), this.token = r, Object.setPrototypeOf(this, s.prototype);
+        }
+        getToken() {
+          return this.token;
+        }
+      }
+      class i extends Error {
+        constructor(r) {
+          super(`The parsing ended early. The next token was: ${o(r)}`), this.token = r, Object.setPrototypeOf(this, i.prototype);
+        }
+        getToken() {
+          return this.token;
+        }
+      }
+      class p extends Error {
+        constructor(r, a) {
+          let l = `Unexpected type: '${r.type}'.`;
+          a !== void 0 && (l += ` Message: ${a}`), super(l), Object.setPrototypeOf(this, p.prototype);
+        }
+      }
+      function d(e) {
+        return (r) => r.startsWith(e) ? { type: e, text: e } : null;
+      }
+      function m(e) {
+        let r = 0, a, l = e[0], g = !1;
+        if (l !== "'" && l !== '"')
+          return null;
+        for (; r < e.length; ) {
+          if (r++, a = e[r], !g && a === l) {
+            r++;
+            break;
+          }
+          g = !g && a === "\\";
+        }
+        if (a !== l)
+          throw new Error("Unterminated String");
+        return e.slice(0, r);
+      }
+      let f = new RegExp("[$_\\p{ID_Start}]|\\\\u\\p{Hex_Digit}{4}|\\\\u\\{0*(?:\\p{Hex_Digit}{1,5}|10\\p{Hex_Digit}{4})\\}", "u"), b = new RegExp("[$\\-\\p{ID_Continue}\\u200C\\u200D]|\\\\u\\p{Hex_Digit}{4}|\\\\u\\{0*(?:\\p{Hex_Digit}{1,5}|10\\p{Hex_Digit}{4})\\}", "u");
+      function D(e) {
+        let r = e[0];
+        if (!f.test(r))
+          return null;
+        let a = 1;
+        do {
+          if (r = e[a], !b.test(r))
+            break;
+          a++;
+        } while (a < e.length);
+        return e.slice(0, a);
+      }
+      let v = /^(NaN|-?((\d*\.\d+|\d+)([Ee][+-]?\d+)?|Infinity))/;
+      function C(e) {
+        var r, a;
+        return (a = (r = v.exec(e)) === null || r === void 0 ? void 0 : r[0]) !== null && a !== void 0 ? a : null;
+      }
+      let F = (e) => {
+        let r = D(e);
+        return r == null ? null : {
+          type: "Identifier",
+          text: r
+        };
+      };
+      function w(e) {
+        return (r) => {
+          if (!r.startsWith(e))
+            return null;
+          let a = r[e.length];
+          return a !== void 0 && b.test(a) ? null : {
+            type: e,
+            text: e
+          };
+        };
+      }
+      let L = (e) => {
+        let r = m(e);
+        return r == null ? null : {
+          type: "StringValue",
+          text: r
+        };
+      }, O = (e) => e.length > 0 ? null : {
+        type: "EOF",
+        text: ""
+      }, x = (e) => {
+        let r = C(e);
+        return r === null ? null : {
+          type: "Number",
+          text: r
+        };
+      }, P = [
+        O,
+        d("=>"),
+        d("("),
+        d(")"),
+        d("{"),
+        d("}"),
+        d("["),
+        d("]"),
+        d("|"),
+        d("&"),
+        d("<"),
+        d(">"),
+        d(","),
+        d(";"),
+        d("*"),
+        d("?"),
+        d("!"),
+        d("="),
+        d(":"),
+        d("..."),
+        d("."),
+        d("#"),
+        d("~"),
+        d("/"),
+        d("@"),
+        w("undefined"),
+        w("null"),
+        w("function"),
+        w("this"),
+        w("new"),
+        w("module"),
+        w("event"),
+        w("extends"),
+        w("external"),
+        w("infer"),
+        w("typeof"),
+        w("keyof"),
+        w("readonly"),
+        w("import"),
+        w("is"),
+        w("in"),
+        w("asserts"),
+        x,
+        F,
+        L
+      ], N = /^\s*\n\s*/;
+      class Y {
+        static create(r) {
+          let a = this.read(r);
+          r = a.text;
+          let l = this.read(r);
+          return r = l.text, new Y(r, void 0, a.token, l.token);
+        }
+        constructor(r, a, l, g) {
+          this.text = "", this.text = r, this.previous = a, this.current = l, this.next = g;
+        }
+        static read(r, a = !1) {
+          a = a || N.test(r), r = r.trim();
+          for (let l of P) {
+            let g = l(r);
+            if (g !== null) {
+              let E = Object.assign(Object.assign({}, g), { startOfLine: a });
+              return r = r.slice(E.text.length), { text: r, token: E };
+            }
+          }
+          throw new Error("Unexpected Token " + r);
+        }
+        advance() {
+          let r = Y.read(this.text);
+          return new Y(r.text, this.current, this.next, r.token);
+        }
+      }
+      function S(e) {
+        if (e === void 0)
+          throw new Error("Unexpected undefined");
+        if (e.type === "JsdocTypeKeyValue" || e.type === "JsdocTypeParameterList" || e.type === "JsdocTypeProperty" || e.type === "JsdocTypeReadonlyProperty" || e.type === "JsdocTypeObjectField" || e.type === "JsdocTypeJsdocObjectField" || e.type === "JsdocTypeIndexSignature" || e.type === "JsdocTypeMappedType" || e.type === "JsdocTypeTypeParameter")
+          throw new p(e);
+        return e;
+      }
+      function U(e) {
+        return e.type === "JsdocTypeKeyValue" ? q(e) : S(e);
+      }
+      function R(e) {
+        return e.type === "JsdocTypeName" ? e : q(e);
+      }
+      function q(e) {
+        if (e.type !== "JsdocTypeKeyValue")
+          throw new p(e);
+        return e;
+      }
+      function _(e) {
+        var r;
+        if (e.type === "JsdocTypeVariadic") {
+          if (((r = e.element) === null || r === void 0 ? void 0 : r.type) === "JsdocTypeName")
+            return e;
+          throw new p(e);
+        }
+        if (e.type !== "JsdocTypeNumber" && e.type !== "JsdocTypeName")
+          throw new p(e);
+        return e;
+      }
+      function V(e) {
+        if (e.type === "JsdocTypeTuple" || e.type === "JsdocTypeGeneric" && e.meta.brackets === "square")
+          return e;
+        throw new p(e);
+      }
+      function H(e) {
+        return e.type === "JsdocTypeIndexSignature" || e.type === "JsdocTypeMappedType";
+      }
+      var T;
+      (function(e) {
+        e[e.ALL = 0] = "ALL", e[e.PARAMETER_LIST = 1] = "PARAMETER_LIST", e[e.OBJECT = 2] = "OBJECT", e[e.KEY_VALUE = 3] = "KEY_VALUE", e[e.INDEX_BRACKETS = 4] = "INDEX_BRACKETS", e[e.UNION = 5] = "UNION", e[e.INTERSECTION = 6] = "INTERSECTION", e[e.PREFIX = 7] = "PREFIX", e[e.INFIX = 8] = "INFIX", e[e.TUPLE = 9] = "TUPLE", e[e.SYMBOL = 10] = "SYMBOL", e[e.OPTIONAL = 11] = "OPTIONAL", e[e.NULLABLE = 12] = "NULLABLE", e[e.KEY_OF_TYPE_OF = 13] = "KEY_OF_TYPE_OF", e[e.FUNCTION = 14] = "FUNCTION", e[e.ARROW = 15] = "ARROW", e[e.ARRAY_BRACKETS = 16] = "ARRAY_BRACKETS", e[e.GENERIC = 17] = "GENERIC", e[e.NAME_PATH = 18] = "NAME_PATH", e[e.PARENTHESIS = 19] = "PARENTHESIS", e[e.SPECIAL_TYPES = 20] = "SPECIAL_TYPES";
+      })(T || (T = {}));
+      class c {
+        constructor(r, a, l) {
+          this.grammar = r, typeof a == "string" ? this._lexer = Y.create(a) : this._lexer = a, this.baseParser = l;
+        }
+        get lexer() {
+          return this._lexer;
+        }
+        /**
+         * Parses a given string and throws an error if the parse ended before the end of the string.
+         */
+        parse() {
+          let r = this.parseType(T.ALL);
+          if (this.lexer.current.type !== "EOF")
+            throw new i(this.lexer.current);
+          return r;
+        }
+        /**
+         * Parses with the current lexer and asserts that the result is a {@link RootResult}.
+         */
+        parseType(r) {
+          return S(this.parseIntermediateType(r));
+        }
+        /**
+         * The main parsing function. First it tries to parse the current state in the prefix step, and then it continues
+         * to parse the state in the infix step.
+         */
+        parseIntermediateType(r) {
+          let a = this.tryParslets(null, r);
+          if (a === null)
+            throw new s(this.lexer.current);
+          return this.parseInfixIntermediateType(a, r);
+        }
+        /**
+         * In the infix parsing step the parser continues to parse the current state with all parslets until none returns
+         * a result.
+         */
+        parseInfixIntermediateType(r, a) {
+          let l = this.tryParslets(r, a);
+          for (; l !== null; )
+            r = l, l = this.tryParslets(r, a);
+          return r;
+        }
+        /**
+         * Tries to parse the current state with all parslets in the grammar and returns the first non null result.
+         */
+        tryParslets(r, a) {
+          for (let l of this.grammar) {
+            let g = l(this, a, r);
+            if (g !== null)
+              return g;
+          }
+          return null;
+        }
+        /**
+         * If the given type equals the current type of the {@link Lexer} advance the lexer. Return true if the lexer was
+         * advanced.
+         */
+        consume(r) {
+          return Array.isArray(r) || (r = [r]), r.includes(this.lexer.current.type) ? (this._lexer = this.lexer.advance(), !0) : !1;
+        }
+        acceptLexerState(r) {
+          this._lexer = r.lexer;
+        }
+      }
+      function y(e) {
+        return e === "}" || e === "EOF" || e === "|" || e === "," || e === ")" || e === ">";
+      }
+      let h = (e, r, a) => {
+        let l = e.lexer.current.type, g = e.lexer.next.type;
+        return a == null && l === "?" && !y(g) || a != null && l === "?" ? (e.consume("?"), a == null ? {
+          type: "JsdocTypeNullable",
+          element: e.parseType(T.NULLABLE),
+          meta: {
+            position: "prefix"
+          }
+        } : {
+          type: "JsdocTypeNullable",
+          element: S(a),
+          meta: {
+            position: "suffix"
+          }
+        }) : null;
+      };
+      function A(e) {
+        let r = (a, l, g) => {
+          let E = a.lexer.current.type, B = a.lexer.next.type;
+          if (g === null) {
+            if ("parsePrefix" in e && e.accept(E, B))
+              return e.parsePrefix(a);
+          } else if ("parseInfix" in e && e.precedence > l && e.accept(E, B))
+            return e.parseInfix(a, g);
+          return null;
+        };
+        return Object.defineProperty(r, "name", {
+          value: e.name
+        }), r;
+      }
+      let J = A({
+        name: "optionalParslet",
+        accept: (e) => e === "=",
+        precedence: T.OPTIONAL,
+        parsePrefix: (e) => (e.consume("="), {
+          type: "JsdocTypeOptional",
+          element: e.parseType(T.OPTIONAL),
+          meta: {
+            position: "prefix"
+          }
+        }),
+        parseInfix: (e, r) => (e.consume("="), {
+          type: "JsdocTypeOptional",
+          element: S(r),
+          meta: {
+            position: "suffix"
+          }
+        })
+      }), k = A({
+        name: "numberParslet",
+        accept: (e) => e === "Number",
+        parsePrefix: (e) => {
+          let r = parseFloat(e.lexer.current.text);
+          return e.consume("Number"), {
+            type: "JsdocTypeNumber",
+            value: r
+          };
+        }
+      }), X = A({
+        name: "parenthesisParslet",
+        accept: (e) => e === "(",
+        parsePrefix: (e) => {
+          if (e.consume("("), e.consume(")"))
+            return {
+              type: "JsdocTypeParameterList",
+              elements: []
+            };
+          let r = e.parseIntermediateType(T.ALL);
+          if (!e.consume(")"))
+            throw new Error("Unterminated parenthesis");
+          return r.type === "JsdocTypeParameterList" ? r : r.type === "JsdocTypeKeyValue" ? {
+            type: "JsdocTypeParameterList",
+            elements: [r]
+          } : {
+            type: "JsdocTypeParenthesis",
+            element: S(r)
+          };
+        }
+      }), I = A({
+        name: "specialTypesParslet",
+        accept: (e, r) => e === "?" && y(r) || e === "null" || e === "undefined" || e === "*",
+        parsePrefix: (e) => {
+          if (e.consume("null"))
+            return {
+              type: "JsdocTypeNull"
+            };
+          if (e.consume("undefined"))
+            return {
+              type: "JsdocTypeUndefined"
+            };
+          if (e.consume("*"))
+            return {
+              type: "JsdocTypeAny"
+            };
+          if (e.consume("?"))
+            return {
+              type: "JsdocTypeUnknown"
+            };
+          throw new Error("Unacceptable token: " + e.lexer.current.text);
+        }
+      }), G = A({
+        name: "notNullableParslet",
+        accept: (e) => e === "!",
+        precedence: T.NULLABLE,
+        parsePrefix: (e) => (e.consume("!"), {
+          type: "JsdocTypeNotNullable",
+          element: e.parseType(T.NULLABLE),
+          meta: {
+            position: "prefix"
+          }
+        }),
+        parseInfix: (e, r) => (e.consume("!"), {
+          type: "JsdocTypeNotNullable",
+          element: S(r),
+          meta: {
+            position: "suffix"
+          }
+        })
+      });
+      function ie({ allowTrailingComma: e }) {
+        return A({
+          name: "parameterListParslet",
+          accept: (r) => r === ",",
+          precedence: T.PARAMETER_LIST,
+          parseInfix: (r, a) => {
+            let l = [
+              U(a)
+            ];
+            r.consume(",");
+            do
+              try {
+                let g = r.parseIntermediateType(T.PARAMETER_LIST);
+                l.push(U(g));
+              } catch (g) {
+                if (g instanceof s)
+                  break;
+                throw g;
+              }
+            while (r.consume(","));
+            if (l.length > 0 && l.slice(0, -1).some((g) => g.type === "JsdocTypeVariadic"))
+              throw new Error("Only the last parameter may be a rest parameter");
+            return {
+              type: "JsdocTypeParameterList",
+              elements: l
+            };
+          }
+        });
+      }
+      let Te = A({
+        name: "genericParslet",
+        accept: (e, r) => e === "<" || e === "." && r === "<",
+        precedence: T.GENERIC,
+        parseInfix: (e, r) => {
+          let a = e.consume(".");
+          e.consume("<");
+          let l = [], g = !1;
+          if (e.consume("infer")) {
+            g = !0;
+            let E = e.parseIntermediateType(T.SYMBOL);
+            if (E.type !== "JsdocTypeName")
+              throw new p(E, "A typescript asserts always has to have a name on the left side.");
+            l.push(E);
+          } else
+            do
+              l.push(e.parseType(T.PARAMETER_LIST));
+            while (e.consume(","));
+          if (!e.consume(">"))
+            throw new Error("Unterminated generic parameter list");
+          return Object.assign(Object.assign({ type: "JsdocTypeGeneric", left: S(r), elements: l }, g ? { infer: !0 } : {}), { meta: {
+            brackets: "angle",
+            dot: a
+          } });
+        }
+      }), z = A({
+        name: "unionParslet",
+        accept: (e) => e === "|",
+        precedence: T.UNION,
+        parseInfix: (e, r) => {
+          e.consume("|");
+          let a = [];
+          do
+            a.push(e.parseType(T.UNION));
+          while (e.consume("|"));
+          return {
+            type: "JsdocTypeUnion",
+            elements: [S(r), ...a]
+          };
+        }
+      }), te = [
+        h,
+        J,
+        k,
+        X,
+        I,
+        G,
+        ie({
+          allowTrailingComma: !0
+        }),
+        Te,
+        z,
+        J
+      ];
+      function ue({ allowSquareBracketsOnAnyType: e, allowJsdocNamePaths: r, pathGrammar: a }) {
+        return function(l, g, E) {
+          if (E == null || g >= T.NAME_PATH)
+            return null;
+          let B = l.lexer.current.type, M = l.lexer.next.type;
+          if (!(B === "." && M !== "<" || B === "[" && (e || E.type === "JsdocTypeName") || r && (B === "~" || B === "#")))
+            return null;
+          let K, Q = !1;
+          l.consume(".") ? K = "property" : l.consume("[") ? (K = "property-brackets", Q = !0) : l.consume("~") ? K = "inner" : (l.consume("#"), K = "instance");
+          let le = a !== null ? new c(a, l.lexer, l) : l, ae = le.parseIntermediateType(T.NAME_PATH);
+          l.acceptLexerState(le);
+          let Fe;
+          switch (ae.type) {
+            case "JsdocTypeName":
+              Fe = {
+                type: "JsdocTypeProperty",
+                value: ae.value,
+                meta: {
+                  quote: void 0
+                }
+              };
+              break;
+            case "JsdocTypeNumber":
+              Fe = {
+                type: "JsdocTypeProperty",
+                value: ae.value.toString(10),
+                meta: {
+                  quote: void 0
+                }
+              };
+              break;
+            case "JsdocTypeStringValue":
+              Fe = {
+                type: "JsdocTypeProperty",
+                value: ae.value,
+                meta: {
+                  quote: ae.meta.quote
+                }
+              };
+              break;
+            case "JsdocTypeSpecialNamePath":
+              if (ae.specialType === "event")
+                Fe = ae;
+              else
+                throw new p(ae, "Type 'JsdocTypeSpecialNamePath' is only allowed with specialType 'event'");
+              break;
+            default:
+              throw new p(ae, "Expecting 'JsdocTypeName', 'JsdocTypeNumber', 'JsdocStringValue' or 'JsdocTypeSpecialNamePath'");
+          }
+          if (Q && !l.consume("]")) {
+            let ut = l.lexer.current;
+            throw new Error(`Unterminated square brackets. Next token is '${ut.type}' with text '${ut.text}'`);
+          }
+          return {
+            type: "JsdocTypeNamePath",
+            left: S(E),
+            right: Fe,
+            pathType: K
+          };
+        };
+      }
+      function ne({ allowedAdditionalTokens: e }) {
+        return A({
+          name: "nameParslet",
+          accept: (r) => r === "Identifier" || r === "this" || r === "new" || e.includes(r),
+          parsePrefix: (r) => {
+            let { type: a, text: l } = r.lexer.current;
+            return r.consume(a), {
+              type: "JsdocTypeName",
+              value: l
+            };
+          }
+        });
+      }
+      let fe = A({
+        name: "stringValueParslet",
+        accept: (e) => e === "StringValue",
+        parsePrefix: (e) => {
+          let r = e.lexer.current.text;
+          return e.consume("StringValue"), {
+            type: "JsdocTypeStringValue",
+            value: r.slice(1, -1),
+            meta: {
+              quote: r[0] === "'" ? "single" : "double"
+            }
+          };
+        }
+      });
+      function oe({ pathGrammar: e, allowedTypes: r }) {
+        return A({
+          name: "specialNamePathParslet",
+          accept: (a) => r.includes(a),
+          parsePrefix: (a) => {
+            let l = a.lexer.current.type;
+            if (a.consume(l), !a.consume(":"))
+              return {
+                type: "JsdocTypeName",
+                value: l
+              };
+            let g, E = a.lexer.current;
+            if (a.consume("StringValue"))
+              g = {
+                type: "JsdocTypeSpecialNamePath",
+                value: E.text.slice(1, -1),
+                specialType: l,
+                meta: {
+                  quote: E.text[0] === "'" ? "single" : "double"
+                }
+              };
+            else {
+              let K = "", Q = ["Identifier", "@", "/"];
+              for (; Q.some((le) => a.consume(le)); )
+                K += E.text, E = a.lexer.current;
+              g = {
+                type: "JsdocTypeSpecialNamePath",
+                value: K,
+                specialType: l,
+                meta: {
+                  quote: void 0
+                }
+              };
+            }
+            let B = new c(e, a.lexer, a), M = B.parseInfixIntermediateType(g, T.ALL);
+            return a.acceptLexerState(B), S(M);
+          }
+        });
+      }
+      let be = [
+        ne({
+          allowedAdditionalTokens: ["external", "module"]
+        }),
+        fe,
+        k,
+        ue({
+          allowSquareBracketsOnAnyType: !1,
+          allowJsdocNamePaths: !0,
+          pathGrammar: null
+        })
+      ], se = [
+        ...be,
+        oe({
+          allowedTypes: ["event"],
+          pathGrammar: be
+        })
+      ];
+      function Ee(e) {
+        let r;
+        if (e.type === "JsdocTypeParameterList")
+          r = e.elements;
+        else if (e.type === "JsdocTypeParenthesis")
+          r = [e.element];
+        else
+          throw new p(e);
+        return r.map((a) => U(a));
+      }
+      function Re(e) {
+        let r = Ee(e);
+        if (r.some((a) => a.type === "JsdocTypeKeyValue"))
+          throw new Error("No parameter should be named");
+        return r;
+      }
+      function Z({ allowNamedParameters: e, allowNoReturnType: r, allowWithoutParenthesis: a, allowNewAsFunctionKeyword: l }) {
+        return A({
+          name: "functionParslet",
+          accept: (g, E) => g === "function" || l && g === "new" && E === "(",
+          parsePrefix: (g) => {
+            let E = g.consume("new");
+            g.consume("function");
+            let B = g.lexer.current.type === "(";
+            if (!B) {
+              if (!a)
+                throw new Error("function is missing parameter list");
+              return {
+                type: "JsdocTypeName",
+                value: "function"
+              };
+            }
+            let M = {
+              type: "JsdocTypeFunction",
+              parameters: [],
+              arrow: !1,
+              constructor: E,
+              parenthesis: B
+            }, K = g.parseIntermediateType(T.FUNCTION);
+            if (e === void 0)
+              M.parameters = Re(K);
+            else {
+              if (E && K.type === "JsdocTypeFunction" && K.arrow)
+                return M = K, M.constructor = !0, M;
+              M.parameters = Ee(K);
+              for (let Q of M.parameters)
+                if (Q.type === "JsdocTypeKeyValue" && !e.includes(Q.key))
+                  throw new Error(`only allowed named parameters are ${e.join(", ")} but got ${Q.type}`);
+            }
+            if (g.consume(":"))
+              M.returnType = g.parseType(T.PREFIX);
+            else if (!r)
+              throw new Error("function is missing return type");
+            return M;
+          }
+        });
+      }
+      function ee({ allowPostfix: e, allowEnclosingBrackets: r }) {
+        return A({
+          name: "variadicParslet",
+          accept: (a) => a === "...",
+          precedence: T.PREFIX,
+          parsePrefix: (a) => {
+            a.consume("...");
+            let l = r && a.consume("[");
+            try {
+              let g = a.parseType(T.PREFIX);
+              if (l && !a.consume("]"))
+                throw new Error("Unterminated variadic type. Missing ']'");
+              return {
+                type: "JsdocTypeVariadic",
+                element: S(g),
+                meta: {
+                  position: "prefix",
+                  squareBrackets: l
+                }
+              };
+            } catch (g) {
+              if (g instanceof s) {
+                if (l)
+                  throw new Error("Empty square brackets for variadic are not allowed.");
+                return {
+                  type: "JsdocTypeVariadic",
+                  meta: {
+                    position: void 0,
+                    squareBrackets: !1
+                  }
+                };
+              } else
+                throw g;
+            }
+          },
+          parseInfix: e ? (a, l) => (a.consume("..."), {
+            type: "JsdocTypeVariadic",
+            element: S(l),
+            meta: {
+              position: "suffix",
+              squareBrackets: !1
+            }
+          }) : void 0
+        });
+      }
+      let he = A({
+        name: "symbolParslet",
+        accept: (e) => e === "(",
+        precedence: T.SYMBOL,
+        parseInfix: (e, r) => {
+          if (r.type !== "JsdocTypeName")
+            throw new Error("Symbol expects a name on the left side. (Reacting on '(')");
+          e.consume("(");
+          let a = {
+            type: "JsdocTypeSymbol",
+            value: r.value
+          };
+          if (!e.consume(")")) {
+            let l = e.parseIntermediateType(T.SYMBOL);
+            if (a.element = _(l), !e.consume(")"))
+              throw new Error("Symbol does not end after value");
+          }
+          return a;
+        }
+      }), ve = A({
+        name: "arrayBracketsParslet",
+        precedence: T.ARRAY_BRACKETS,
+        accept: (e, r) => e === "[" && r === "]",
+        parseInfix: (e, r) => (e.consume("["), e.consume("]"), {
+          type: "JsdocTypeGeneric",
+          left: {
+            type: "JsdocTypeName",
+            value: "Array"
+          },
+          elements: [
+            S(r)
+          ],
+          meta: {
+            brackets: "square",
+            dot: !1
+          }
+        })
+      });
+      function we({ objectFieldGrammar: e, allowKeyTypes: r }) {
+        return A({
+          name: "objectParslet",
+          accept: (a) => a === "{",
+          parsePrefix: (a) => {
+            a.consume("{");
+            let l = {
+              type: "JsdocTypeObject",
+              meta: {
+                separator: "comma"
+              },
+              elements: []
+            };
+            if (!a.consume("}")) {
+              let g, E = new c(e, a.lexer, a);
+              for (; ; ) {
+                E.acceptLexerState(a);
+                let B = E.parseIntermediateType(T.OBJECT);
+                a.acceptLexerState(E), B === void 0 && r && (B = a.parseIntermediateType(T.OBJECT));
+                let M = !1;
+                if (B.type === "JsdocTypeNullable" && (M = !0, B = B.element), B.type === "JsdocTypeNumber" || B.type === "JsdocTypeName" || B.type === "JsdocTypeStringValue") {
+                  let K;
+                  B.type === "JsdocTypeStringValue" && (K = B.meta.quote), l.elements.push({
+                    type: "JsdocTypeObjectField",
+                    key: B.value.toString(),
+                    right: void 0,
+                    optional: M,
+                    readonly: !1,
+                    meta: {
+                      quote: K
+                    }
+                  });
+                } else if (B.type === "JsdocTypeObjectField" || B.type === "JsdocTypeJsdocObjectField")
+                  l.elements.push(B);
+                else
+                  throw new p(B);
+                if (a.lexer.current.startOfLine)
+                  g = "linebreak", a.consume(",") || a.consume(";");
+                else if (a.consume(","))
+                  g = "comma";
+                else if (a.consume(";"))
+                  g = "semicolon";
+                else
+                  break;
+                if (a.lexer.current.type === "}")
+                  break;
+              }
+              if (l.meta.separator = g ?? "comma", g === "linebreak" && (l.meta.propertyIndent = "  "), !a.consume("}"))
+                throw new Error("Unterminated record type. Missing '}'");
+            }
+            return l;
+          }
+        });
+      }
+      function Ce({ allowSquaredProperties: e, allowKeyTypes: r, allowReadonly: a, allowOptional: l }) {
+        return A({
+          name: "objectFieldParslet",
+          precedence: T.KEY_VALUE,
+          accept: (g) => g === ":",
+          parseInfix: (g, E) => {
+            var B;
+            let M = !1, K = !1;
+            l && E.type === "JsdocTypeNullable" && (M = !0, E = E.element), a && E.type === "JsdocTypeReadonlyProperty" && (K = !0, E = E.element);
+            let Q = (B = g.baseParser) !== null && B !== void 0 ? B : g;
+            if (Q.acceptLexerState(g), E.type === "JsdocTypeNumber" || E.type === "JsdocTypeName" || E.type === "JsdocTypeStringValue" || H(E)) {
+              if (H(E) && !e)
+                throw new p(E);
+              Q.consume(":");
+              let le;
+              E.type === "JsdocTypeStringValue" && (le = E.meta.quote);
+              let ae = Q.parseType(T.KEY_VALUE);
+              return g.acceptLexerState(Q), {
+                type: "JsdocTypeObjectField",
+                key: H(E) ? E : E.value.toString(),
+                right: ae,
+                optional: M,
+                readonly: K,
+                meta: {
+                  quote: le
+                }
+              };
+            } else {
+              if (!r)
+                throw new p(E);
+              Q.consume(":");
+              let le = Q.parseType(T.KEY_VALUE);
+              return g.acceptLexerState(Q), {
+                type: "JsdocTypeJsdocObjectField",
+                left: S(E),
+                right: le
+              };
+            }
+          }
+        });
+      }
+      function Ie({ allowOptional: e, allowVariadic: r }) {
+        return A({
+          name: "keyValueParslet",
+          precedence: T.KEY_VALUE,
+          accept: (a) => a === ":",
+          parseInfix: (a, l) => {
+            let g = !1, E = !1;
+            if (e && l.type === "JsdocTypeNullable" && (g = !0, l = l.element), r && l.type === "JsdocTypeVariadic" && l.element !== void 0 && (E = !0, l = l.element), l.type !== "JsdocTypeName")
+              throw new p(l);
+            a.consume(":");
+            let B = a.parseType(T.KEY_VALUE);
+            return {
+              type: "JsdocTypeKeyValue",
+              key: l.value,
+              right: B,
+              optional: g,
+              variadic: E
+            };
+          }
+        });
+      }
+      let $e = [
+        ...te,
+        Z({
+          allowWithoutParenthesis: !0,
+          allowNamedParameters: ["this", "new"],
+          allowNoReturnType: !0,
+          allowNewAsFunctionKeyword: !1
+        }),
+        fe,
+        oe({
+          allowedTypes: ["module", "external", "event"],
+          pathGrammar: se
+        }),
+        ee({
+          allowEnclosingBrackets: !0,
+          allowPostfix: !0
+        }),
+        ne({
+          allowedAdditionalTokens: ["keyof"]
+        }),
+        he,
+        ve,
+        ue({
+          allowSquareBracketsOnAnyType: !1,
+          allowJsdocNamePaths: !0,
+          pathGrammar: se
+        })
+      ], Pt = [
+        ...$e,
+        we({
+          // jsdoc syntax allows full types as keys, so we need to pull in the full grammar here
+          // we leave out the object type deliberately
+          objectFieldGrammar: [
+            ne({
+              allowedAdditionalTokens: ["typeof", "module", "in"]
+            }),
+            Ce({
+              allowSquaredProperties: !1,
+              allowKeyTypes: !0,
+              allowOptional: !1,
+              allowReadonly: !1
+            }),
+            ...$e
+          ],
+          allowKeyTypes: !0
+        }),
+        Ie({
+          allowOptional: !0,
+          allowVariadic: !0
+        })
+      ], Qe = A({
+        name: "typeOfParslet",
+        accept: (e) => e === "typeof",
+        parsePrefix: (e) => (e.consume("typeof"), {
+          type: "JsdocTypeTypeof",
+          element: e.parseType(T.KEY_OF_TYPE_OF)
+        })
+      }), qt = [
+        ne({
+          allowedAdditionalTokens: ["typeof", "module", "keyof", "event", "external", "in"]
+        }),
+        h,
+        J,
+        fe,
+        k,
+        Ce({
+          allowSquaredProperties: !1,
+          allowKeyTypes: !1,
+          allowOptional: !1,
+          allowReadonly: !1
+        })
+      ], kt = [
+        ...te,
+        we({
+          allowKeyTypes: !1,
+          objectFieldGrammar: qt
+        }),
+        ne({
+          allowedAdditionalTokens: ["event", "external", "in"]
+        }),
+        Qe,
+        Z({
+          allowWithoutParenthesis: !1,
+          allowNamedParameters: ["this", "new"],
+          allowNoReturnType: !0,
+          allowNewAsFunctionKeyword: !1
+        }),
+        ee({
+          allowEnclosingBrackets: !1,
+          allowPostfix: !1
+        }),
+        // additional name parslet is needed for some special cases
+        ne({
+          allowedAdditionalTokens: ["keyof"]
+        }),
+        oe({
+          allowedTypes: ["module"],
+          pathGrammar: se
+        }),
+        ue({
+          allowSquareBracketsOnAnyType: !1,
+          allowJsdocNamePaths: !0,
+          pathGrammar: se
+        }),
+        Ie({
+          allowOptional: !1,
+          allowVariadic: !1
+        }),
+        he
+      ], _t = A({
+        name: "assertsParslet",
+        accept: (e) => e === "asserts",
+        parsePrefix: (e) => {
+          e.consume("asserts");
+          let r = e.parseIntermediateType(T.SYMBOL);
+          if (r.type !== "JsdocTypeName")
+            throw new p(r, "A typescript asserts always has to have a name on the left side.");
+          return e.consume("is") ? {
+            type: "JsdocTypeAsserts",
+            left: r,
+            right: S(e.parseIntermediateType(T.INFIX))
+          } : {
+            type: "JsdocTypeAssertsPlain",
+            element: r
+          };
+        }
+      });
+      function Lt({ allowQuestionMark: e }) {
+        return A({
+          name: "tupleParslet",
+          accept: (r) => r === "[",
+          parsePrefix: (r) => {
+            r.consume("[");
+            let a = {
+              type: "JsdocTypeTuple",
+              elements: []
+            };
+            if (r.consume("]"))
+              return a;
+            let l = r.parseIntermediateType(T.ALL);
+            if (l.type === "JsdocTypeParameterList" ? l.elements[0].type === "JsdocTypeKeyValue" ? a.elements = l.elements.map(q) : a.elements = l.elements.map(S) : l.type === "JsdocTypeKeyValue" ? a.elements = [q(l)] : a.elements = [S(l)], !r.consume("]"))
+              throw new Error("Unterminated '['");
+            if (a.elements.some((g) => g.type === "JsdocTypeUnknown"))
+              throw new Error("Question mark in tuple not allowed");
+            return a;
+          }
+        });
+      }
+      let Rt = A({
+        name: "keyOfParslet",
+        accept: (e) => e === "keyof",
+        parsePrefix: (e) => (e.consume("keyof"), {
+          type: "JsdocTypeKeyof",
+          element: S(e.parseType(T.KEY_OF_TYPE_OF))
+        })
+      }), It = A({
+        name: "importParslet",
+        accept: (e) => e === "import",
+        parsePrefix: (e) => {
+          if (e.consume("import"), !e.consume("("))
+            throw new Error("Missing parenthesis after import keyword");
+          let r = e.parseType(T.PREFIX);
+          if (r.type !== "JsdocTypeStringValue")
+            throw new Error("Only string values are allowed as paths for imports");
+          if (!e.consume(")"))
+            throw new Error("Missing closing parenthesis after import keyword");
+          return {
+            type: "JsdocTypeImport",
+            element: r
+          };
+        }
+      }), jt = A({
+        name: "readonlyPropertyParslet",
+        accept: (e) => e === "readonly",
+        parsePrefix: (e) => (e.consume("readonly"), {
+          type: "JsdocTypeReadonlyProperty",
+          element: e.parseIntermediateType(T.KEY_VALUE)
+        })
+      }), Ut = A({
+        name: "arrowFunctionParslet",
+        precedence: T.ARROW,
+        accept: (e) => e === "=>",
+        parseInfix: (e, r) => (e.consume("=>"), {
+          type: "JsdocTypeFunction",
+          parameters: Ee(r).map(R),
+          arrow: !0,
+          constructor: !1,
+          parenthesis: !0,
+          returnType: e.parseType(T.OBJECT)
+        })
+      }), Mt = A({
+        name: "genericArrowFunctionParslet",
+        accept: (e) => e === "<",
+        parsePrefix: (e) => {
+          let r = [];
+          e.consume("<");
+          do {
+            let l, g = e.parseIntermediateType(T.SYMBOL);
+            if (g.type === "JsdocTypeOptional" && (g = g.element, l = e.parseType(T.SYMBOL)), g.type !== "JsdocTypeName")
+              throw new p(g);
+            let E;
+            e.consume("extends") && (E = e.parseType(T.SYMBOL), E.type === "JsdocTypeOptional" && (E = E.element, l = e.parseType(T.SYMBOL)));
+            let B = {
+              type: "JsdocTypeTypeParameter",
+              name: g
+            };
+            if (E !== void 0 && (B.constraint = E), l !== void 0 && (B.defaultValue = l), r.push(B), e.consume(">"))
+              break;
+          } while (e.consume(","));
+          let a = e.parseIntermediateType(T.SYMBOL);
+          return a.typeParameters = r, a;
+        }
+      }), Vt = A({
+        name: "intersectionParslet",
+        accept: (e) => e === "&",
+        precedence: T.INTERSECTION,
+        parseInfix: (e, r) => {
+          e.consume("&");
+          let a = [];
+          do
+            a.push(e.parseType(T.INTERSECTION));
+          while (e.consume("&"));
+          return {
+            type: "JsdocTypeIntersection",
+            elements: [S(r), ...a]
+          };
+        }
+      }), Ht = A({
+        name: "predicateParslet",
+        precedence: T.INFIX,
+        accept: (e) => e === "is",
+        parseInfix: (e, r) => {
+          if (r.type !== "JsdocTypeName")
+            throw new p(r, "A typescript predicate always has to have a name on the left side.");
+          return e.consume("is"), {
+            type: "JsdocTypePredicate",
+            left: r,
+            right: S(e.parseIntermediateType(T.INFIX))
+          };
+        }
+      }), Kt = A({
+        name: "objectSquareBracketPropertyParslet",
+        accept: (e) => e === "[",
+        parsePrefix: (e) => {
+          if (e.baseParser === void 0)
+            throw new Error("Only allowed inside object grammar");
+          e.consume("[");
+          let r = e.lexer.current.text;
+          e.consume("Identifier");
+          let a;
+          if (e.consume(":")) {
+            let l = e.baseParser;
+            l.acceptLexerState(e), a = {
+              type: "JsdocTypeIndexSignature",
+              key: r,
+              right: l.parseType(T.INDEX_BRACKETS)
+            }, e.acceptLexerState(l);
+          } else if (e.consume("in")) {
+            let l = e.baseParser;
+            l.acceptLexerState(e), a = {
+              type: "JsdocTypeMappedType",
+              key: r,
+              right: l.parseType(T.ARRAY_BRACKETS)
+            }, e.acceptLexerState(l);
+          } else
+            throw new Error("Missing ':' or 'in' inside square bracketed property.");
+          if (!e.consume("]"))
+            throw new Error("Unterminated square brackets");
+          return a;
+        }
+      }), Gt = A({
+        name: "readonlyArrayParslet",
+        accept: (e) => e === "readonly",
+        parsePrefix: (e) => (e.consume("readonly"), {
+          type: "JsdocTypeReadonlyArray",
+          element: V(e.parseIntermediateType(T.ALL))
+        })
+      }), zt = A({
+        name: "conditionalParslet",
+        precedence: T.INFIX,
+        accept: (e) => e === "extends",
+        parseInfix: (e, r) => {
+          e.consume("extends");
+          let a = e.parseType(T.KEY_OF_TYPE_OF).element, l = e.parseType(T.INFIX);
+          return e.consume(":"), {
+            type: "JsdocTypeConditional",
+            checksType: S(r),
+            extendsType: a,
+            trueType: l,
+            falseType: e.parseType(T.INFIX)
+          };
+        }
+      }), Yt = [
+        jt,
+        ne({
+          allowedAdditionalTokens: ["typeof", "module", "keyof", "event", "external", "in"]
+        }),
+        h,
+        J,
+        fe,
+        k,
+        Ce({
+          allowSquaredProperties: !0,
+          allowKeyTypes: !1,
+          allowOptional: !0,
+          allowReadonly: !0
+        }),
+        Kt
+      ], Xt = [
+        ...te,
+        we({
+          allowKeyTypes: !1,
+          objectFieldGrammar: Yt
+        }),
+        Gt,
+        Qe,
+        Rt,
+        It,
+        fe,
+        Z({
+          allowWithoutParenthesis: !0,
+          allowNoReturnType: !1,
+          allowNamedParameters: ["this", "new", "args"],
+          allowNewAsFunctionKeyword: !0
+        }),
+        Lt({
+          allowQuestionMark: !1
+        }),
+        ee({
+          allowEnclosingBrackets: !1,
+          allowPostfix: !1
+        }),
+        _t,
+        zt,
+        ne({
+          allowedAdditionalTokens: ["event", "external", "in"]
+        }),
+        oe({
+          allowedTypes: ["module"],
+          pathGrammar: se
+        }),
+        ve,
+        Ut,
+        Mt,
+        ue({
+          allowSquareBracketsOnAnyType: !0,
+          allowJsdocNamePaths: !1,
+          pathGrammar: se
+        }),
+        Vt,
+        Ht,
+        Ie({
+          allowVariadic: !0,
+          allowOptional: !0
+        })
+      ];
+      function Ze(e, r) {
+        switch (r) {
+          case "closure":
+            return new c(kt, e).parse();
+          case "jsdoc":
+            return new c(Pt, e).parse();
+          case "typescript":
+            return new c(Xt, e).parse();
+        }
+      }
+      function Wt(e, r = ["typescript", "closure", "jsdoc"]) {
+        let a;
+        for (let l of r)
+          try {
+            return Ze(e, l);
+          } catch (g) {
+            a = g;
+          }
+        throw a;
+      }
+      function xe(e, r) {
+        let a = e[r.type];
+        if (a === void 0)
+          throw new Error(`In this set of transform rules exists no rule for type ${r.type}.`);
+        return a(r, (l) => xe(e, l));
+      }
+      function j(e) {
+        throw new Error("This transform is not available. Are you trying the correct parsing mode?");
+      }
+      function et(e) {
+        let r = {
+          params: []
+        };
+        for (let a of e.parameters)
+          a.type === "JsdocTypeKeyValue" ? a.key === "this" ? r.this = a.right : a.key === "new" ? r.new = a.right : r.params.push(a) : r.params.push(a);
+        return r;
+      }
+      function Pe(e, r, a) {
+        return e === "prefix" ? a + r : r + a;
+      }
+      function ce(e, r) {
+        switch (r) {
+          case "double":
+            return `"${e}"`;
+          case "single":
+            return `'${e}'`;
+          case void 0:
+            return e;
+        }
+      }
+      function tt() {
+        return {
+          JsdocTypeParenthesis: (e, r) => `(${e.element !== void 0 ? r(e.element) : ""})`,
+          JsdocTypeKeyof: (e, r) => `keyof ${r(e.element)}`,
+          JsdocTypeFunction: (e, r) => {
+            var a;
+            if (e.arrow) {
+              if (e.returnType === void 0)
+                throw new Error("Arrow function needs a return type.");
+              let l = `${e.typeParameters !== void 0 ? `<${(a = e.typeParameters.map(r).join(", ")) !== null && a !== void 0 ? a : ""}>` : ""}(${e.parameters.map(r).join(", ")}) => ${r(e.returnType)}`;
+              return e.constructor && (l = "new " + l), l;
+            } else {
+              let l = e.constructor ? "new" : "function";
+              return e.parenthesis && (l += `(${e.parameters.map(r).join(", ")})`, e.returnType !== void 0 && (l += `: ${r(e.returnType)}`)), l;
+            }
+          },
+          JsdocTypeName: (e) => e.value,
+          JsdocTypeTuple: (e, r) => `[${e.elements.map(r).join(", ")}]`,
+          JsdocTypeVariadic: (e, r) => e.meta.position === void 0 ? "..." : Pe(e.meta.position, r(e.element), "..."),
+          JsdocTypeNamePath: (e, r) => {
+            let a = r(e.left), l = r(e.right);
+            switch (e.pathType) {
+              case "inner":
+                return `${a}~${l}`;
+              case "instance":
+                return `${a}#${l}`;
+              case "property":
+                return `${a}.${l}`;
+              case "property-brackets":
+                return `${a}[${l}]`;
+            }
+          },
+          JsdocTypeStringValue: (e) => ce(e.value, e.meta.quote),
+          JsdocTypeAny: () => "*",
+          JsdocTypeGeneric: (e, r) => {
+            if (e.meta.brackets === "square") {
+              let a = e.elements[0], l = r(a);
+              return a.type === "JsdocTypeUnion" || a.type === "JsdocTypeIntersection" ? `(${l})[]` : `${l}[]`;
+            } else
+              return `${r(e.left)}${e.meta.dot ? "." : ""}<${e.infer === !0 ? "infer " : ""}${e.elements.map(r).join(", ")}>`;
+          },
+          JsdocTypeImport: (e, r) => `import(${r(e.element)})`,
+          JsdocTypeObjectField: (e, r) => {
+            let a = "";
+            return e.readonly && (a += "readonly "), typeof e.key == "string" ? a += ce(e.key, e.meta.quote) : a += r(e.key), e.optional && (a += "?"), e.right === void 0 ? a : a + `: ${r(e.right)}`;
+          },
+          JsdocTypeJsdocObjectField: (e, r) => `${r(e.left)}: ${r(e.right)}`,
+          JsdocTypeKeyValue: (e, r) => {
+            let a = e.key;
+            return e.optional && (a += "?"), e.variadic && (a = "..." + a), e.right === void 0 ? a : a + `: ${r(e.right)}`;
+          },
+          JsdocTypeSpecialNamePath: (e) => `${e.specialType}:${ce(e.value, e.meta.quote)}`,
+          JsdocTypeNotNullable: (e, r) => Pe(e.meta.position, r(e.element), "!"),
+          JsdocTypeNull: () => "null",
+          JsdocTypeNullable: (e, r) => Pe(e.meta.position, r(e.element), "?"),
+          JsdocTypeNumber: (e) => e.value.toString(),
+          JsdocTypeObject: (e, r) => {
+            var a, l;
+            return `{${(e.meta.separator === "linebreak" && e.elements.length > 1 ? `
+` + ((a = e.meta.propertyIndent) !== null && a !== void 0 ? a : "") : "") + e.elements.map(r).join(e.meta.separator === "comma" ? ", " : e.meta.separator === "linebreak" ? `
+` + ((l = e.meta.propertyIndent) !== null && l !== void 0 ? l : "") : "; ") + (e.meta.separator === "linebreak" && e.elements.length > 1 ? `
+` : "")}}`;
+          },
+          JsdocTypeOptional: (e, r) => Pe(e.meta.position, r(e.element), "="),
+          JsdocTypeSymbol: (e, r) => `${e.value}(${e.element !== void 0 ? r(e.element) : ""})`,
+          JsdocTypeTypeof: (e, r) => `typeof ${r(e.element)}`,
+          JsdocTypeUndefined: () => "undefined",
+          JsdocTypeUnion: (e, r) => e.elements.map(r).join(" | "),
+          JsdocTypeUnknown: () => "?",
+          JsdocTypeIntersection: (e, r) => e.elements.map(r).join(" & "),
+          JsdocTypeProperty: (e) => ce(e.value, e.meta.quote),
+          JsdocTypePredicate: (e, r) => `${r(e.left)} is ${r(e.right)}`,
+          JsdocTypeIndexSignature: (e, r) => `[${e.key}: ${r(e.right)}]`,
+          JsdocTypeMappedType: (e, r) => `[${e.key} in ${r(e.right)}]`,
+          JsdocTypeAsserts: (e, r) => `asserts ${r(e.left)} is ${r(e.right)}`,
+          JsdocTypeReadonlyArray: (e, r) => `readonly ${r(e.element)}`,
+          JsdocTypeAssertsPlain: (e, r) => `asserts ${r(e.element)}`,
+          JsdocTypeConditional: (e, r) => `${r(e.checksType)} extends ${r(e.extendsType)} ? ${r(e.trueType)} : ${r(e.falseType)}`,
+          JsdocTypeTypeParameter: (e, r) => `${r(e.name)}${e.constraint !== void 0 ? ` extends ${r(e.constraint)}` : ""}${e.defaultValue !== void 0 ? ` = ${r(e.defaultValue)}` : ""}`
+        };
+      }
+      let $t = tt();
+      function Qt(e) {
+        return xe($t, e);
+      }
+      let Zt = [
+        "null",
+        "true",
+        "false",
+        "break",
+        "case",
+        "catch",
+        "class",
+        "const",
+        "continue",
+        "debugger",
+        "default",
+        "delete",
+        "do",
+        "else",
+        "export",
+        "extends",
+        "finally",
+        "for",
+        "function",
+        "if",
+        "import",
+        "in",
+        "instanceof",
+        "new",
+        "return",
+        "super",
+        "switch",
+        "this",
+        "throw",
+        "try",
+        "typeof",
+        "var",
+        "void",
+        "while",
+        "with",
+        "yield"
+      ];
+      function pe(e) {
+        let r = {
+          type: "NameExpression",
+          name: e
+        };
+        return Zt.includes(e) && (r.reservedWord = !0), r;
+      }
+      let er = {
+        JsdocTypeOptional: (e, r) => {
+          let a = r(e.element);
+          return a.optional = !0, a;
+        },
+        JsdocTypeNullable: (e, r) => {
+          let a = r(e.element);
+          return a.nullable = !0, a;
+        },
+        JsdocTypeNotNullable: (e, r) => {
+          let a = r(e.element);
+          return a.nullable = !1, a;
+        },
+        JsdocTypeVariadic: (e, r) => {
+          if (e.element === void 0)
+            throw new Error("dots without value are not allowed in catharsis mode");
+          let a = r(e.element);
+          return a.repeatable = !0, a;
+        },
+        JsdocTypeAny: () => ({
+          type: "AllLiteral"
+        }),
+        JsdocTypeNull: () => ({
+          type: "NullLiteral"
+        }),
+        JsdocTypeStringValue: (e) => pe(ce(e.value, e.meta.quote)),
+        JsdocTypeUndefined: () => ({
+          type: "UndefinedLiteral"
+        }),
+        JsdocTypeUnknown: () => ({
+          type: "UnknownLiteral"
+        }),
+        JsdocTypeFunction: (e, r) => {
+          let a = et(e), l = {
+            type: "FunctionType",
+            params: a.params.map(r)
+          };
+          return a.this !== void 0 && (l.this = r(a.this)), a.new !== void 0 && (l.new = r(a.new)), e.returnType !== void 0 && (l.result = r(e.returnType)), l;
+        },
+        JsdocTypeGeneric: (e, r) => ({
+          type: "TypeApplication",
+          applications: e.elements.map((a) => r(a)),
+          expression: r(e.left)
+        }),
+        JsdocTypeSpecialNamePath: (e) => pe(e.specialType + ":" + ce(e.value, e.meta.quote)),
+        JsdocTypeName: (e) => e.value !== "function" ? pe(e.value) : {
+          type: "FunctionType",
+          params: []
+        },
+        JsdocTypeNumber: (e) => pe(e.value.toString()),
+        JsdocTypeObject: (e, r) => {
+          let a = {
+            type: "RecordType",
+            fields: []
+          };
+          for (let l of e.elements)
+            l.type !== "JsdocTypeObjectField" && l.type !== "JsdocTypeJsdocObjectField" ? a.fields.push({
+              type: "FieldType",
+              key: r(l),
+              value: void 0
+            }) : a.fields.push(r(l));
+          return a;
+        },
+        JsdocTypeObjectField: (e, r) => {
+          if (typeof e.key != "string")
+            throw new Error("Index signatures and mapped types are not supported");
+          return {
+            type: "FieldType",
+            key: pe(ce(e.key, e.meta.quote)),
+            value: e.right === void 0 ? void 0 : r(e.right)
+          };
+        },
+        JsdocTypeJsdocObjectField: (e, r) => ({
+          type: "FieldType",
+          key: r(e.left),
+          value: r(e.right)
+        }),
+        JsdocTypeUnion: (e, r) => ({
+          type: "TypeUnion",
+          elements: e.elements.map((a) => r(a))
+        }),
+        JsdocTypeKeyValue: (e, r) => ({
+          type: "FieldType",
+          key: pe(e.key),
+          value: e.right === void 0 ? void 0 : r(e.right)
+        }),
+        JsdocTypeNamePath: (e, r) => {
+          let a = r(e.left), l;
+          e.right.type === "JsdocTypeSpecialNamePath" ? l = r(e.right).name : l = ce(e.right.value, e.right.meta.quote);
+          let g = e.pathType === "inner" ? "~" : e.pathType === "instance" ? "#" : ".";
+          return pe(`${a.name}${g}${l}`);
+        },
+        JsdocTypeSymbol: (e) => {
+          let r = "", a = e.element, l = !1;
+          return a?.type === "JsdocTypeVariadic" && (a.meta.position === "prefix" ? r = "..." : l = !0, a = a.element), a?.type === "JsdocTypeName" ? r += a.value : a?.type === "JsdocTypeNumber" && (r += a.value.toString()), l && (r += "..."), pe(`${e.value}(${r})`);
+        },
+        JsdocTypeParenthesis: (e, r) => r(S(e.element)),
+        JsdocTypeMappedType: j,
+        JsdocTypeIndexSignature: j,
+        JsdocTypeImport: j,
+        JsdocTypeKeyof: j,
+        JsdocTypeTuple: j,
+        JsdocTypeTypeof: j,
+        JsdocTypeIntersection: j,
+        JsdocTypeProperty: j,
+        JsdocTypePredicate: j,
+        JsdocTypeAsserts: j,
+        JsdocTypeReadonlyArray: j,
+        JsdocTypeAssertsPlain: j,
+        JsdocTypeConditional: j,
+        JsdocTypeTypeParameter: j
+      };
+      function tr(e) {
+        return xe(er, e);
+      }
+      function ge(e) {
+        switch (e) {
+          case void 0:
+            return "none";
+          case "single":
+            return "single";
+          case "double":
+            return "double";
+        }
+      }
+      function rr(e) {
+        switch (e) {
+          case "inner":
+            return "INNER_MEMBER";
+          case "instance":
+            return "INSTANCE_MEMBER";
+          case "property":
+            return "MEMBER";
+          case "property-brackets":
+            return "MEMBER";
+        }
+      }
+      function je(e, r) {
+        return r.length === 2 ? {
+          type: e,
+          left: r[0],
+          right: r[1]
+        } : {
+          type: e,
+          left: r[0],
+          right: je(e, r.slice(1))
+        };
+      }
+      let ur = {
+        JsdocTypeOptional: (e, r) => ({
+          type: "OPTIONAL",
+          value: r(e.element),
+          meta: {
+            syntax: e.meta.position === "prefix" ? "PREFIX_EQUAL_SIGN" : "SUFFIX_EQUALS_SIGN"
+          }
+        }),
+        JsdocTypeNullable: (e, r) => ({
+          type: "NULLABLE",
+          value: r(e.element),
+          meta: {
+            syntax: e.meta.position === "prefix" ? "PREFIX_QUESTION_MARK" : "SUFFIX_QUESTION_MARK"
+          }
+        }),
+        JsdocTypeNotNullable: (e, r) => ({
+          type: "NOT_NULLABLE",
+          value: r(e.element),
+          meta: {
+            syntax: e.meta.position === "prefix" ? "PREFIX_BANG" : "SUFFIX_BANG"
+          }
+        }),
+        JsdocTypeVariadic: (e, r) => {
+          let a = {
+            type: "VARIADIC",
+            meta: {
+              syntax: e.meta.position === "prefix" ? "PREFIX_DOTS" : e.meta.position === "suffix" ? "SUFFIX_DOTS" : "ONLY_DOTS"
+            }
+          };
+          return e.element !== void 0 && (a.value = r(e.element)), a;
+        },
+        JsdocTypeName: (e) => ({
+          type: "NAME",
+          name: e.value
+        }),
+        JsdocTypeTypeof: (e, r) => ({
+          type: "TYPE_QUERY",
+          name: r(e.element)
+        }),
+        JsdocTypeTuple: (e, r) => ({
+          type: "TUPLE",
+          entries: e.elements.map(r)
+        }),
+        JsdocTypeKeyof: (e, r) => ({
+          type: "KEY_QUERY",
+          value: r(e.element)
+        }),
+        JsdocTypeImport: (e) => ({
+          type: "IMPORT",
+          path: {
+            type: "STRING_VALUE",
+            quoteStyle: ge(e.element.meta.quote),
+            string: e.element.value
+          }
+        }),
+        JsdocTypeUndefined: () => ({
+          type: "NAME",
+          name: "undefined"
+        }),
+        JsdocTypeAny: () => ({
+          type: "ANY"
+        }),
+        JsdocTypeFunction: (e, r) => {
+          let a = et(e), l = {
+            type: e.arrow ? "ARROW" : "FUNCTION",
+            params: a.params.map((g) => {
+              if (g.type === "JsdocTypeKeyValue") {
+                if (g.right === void 0)
+                  throw new Error("Function parameter without ':' is not expected to be 'KEY_VALUE'");
+                return {
+                  type: "NAMED_PARAMETER",
+                  name: g.key,
+                  typeName: r(g.right)
+                };
+              } else
+                return r(g);
+            }),
+            new: null,
+            returns: null
+          };
+          return a.this !== void 0 ? l.this = r(a.this) : e.arrow || (l.this = null), a.new !== void 0 && (l.new = r(a.new)), e.returnType !== void 0 && (l.returns = r(e.returnType)), l;
+        },
+        JsdocTypeGeneric: (e, r) => {
+          let a = {
+            type: "GENERIC",
+            subject: r(e.left),
+            objects: e.elements.map(r),
+            meta: {
+              syntax: e.meta.brackets === "square" ? "SQUARE_BRACKET" : e.meta.dot ? "ANGLE_BRACKET_WITH_DOT" : "ANGLE_BRACKET"
+            }
+          };
+          return e.meta.brackets === "square" && e.elements[0].type === "JsdocTypeFunction" && !e.elements[0].parenthesis && (a.objects[0] = {
+            type: "NAME",
+            name: "function"
+          }), a;
+        },
+        JsdocTypeObjectField: (e, r) => {
+          if (typeof e.key != "string")
+            throw new Error("Index signatures and mapped types are not supported");
+          if (e.right === void 0)
+            return {
+              type: "RECORD_ENTRY",
+              key: e.key,
+              quoteStyle: ge(e.meta.quote),
+              value: null,
+              readonly: !1
+            };
+          let a = r(e.right);
+          return e.optional && (a = {
+            type: "OPTIONAL",
+            value: a,
+            meta: {
+              syntax: "SUFFIX_KEY_QUESTION_MARK"
+            }
+          }), {
+            type: "RECORD_ENTRY",
+            key: e.key.toString(),
+            quoteStyle: ge(e.meta.quote),
+            value: a,
+            readonly: !1
+          };
+        },
+        JsdocTypeJsdocObjectField: () => {
+          throw new Error("Keys may not be typed in jsdoctypeparser.");
+        },
+        JsdocTypeKeyValue: (e, r) => {
+          if (e.right === void 0)
+            return {
+              type: "RECORD_ENTRY",
+              key: e.key,
+              quoteStyle: "none",
+              value: null,
+              readonly: !1
+            };
+          let a = r(e.right);
+          return e.optional && (a = {
+            type: "OPTIONAL",
+            value: a,
+            meta: {
+              syntax: "SUFFIX_KEY_QUESTION_MARK"
+            }
+          }), {
+            type: "RECORD_ENTRY",
+            key: e.key,
+            quoteStyle: "none",
+            value: a,
+            readonly: !1
+          };
+        },
+        JsdocTypeObject: (e, r) => {
+          let a = [];
+          for (let l of e.elements)
+            (l.type === "JsdocTypeObjectField" || l.type === "JsdocTypeJsdocObjectField") && a.push(r(l));
+          return {
+            type: "RECORD",
+            entries: a
+          };
+        },
+        JsdocTypeSpecialNamePath: (e) => {
+          if (e.specialType !== "module")
+            throw new Error(`jsdoctypeparser does not support type ${e.specialType} at this point.`);
+          return {
+            type: "MODULE",
+            value: {
+              type: "FILE_PATH",
+              quoteStyle: ge(e.meta.quote),
+              path: e.value
+            }
+          };
+        },
+        JsdocTypeNamePath: (e, r) => {
+          let a = !1, l, g;
+          e.right.type === "JsdocTypeSpecialNamePath" && e.right.specialType === "event" ? (a = !0, l = e.right.value, g = ge(e.right.meta.quote)) : (l = e.right.value, g = ge(e.right.meta.quote));
+          let E = {
+            type: rr(e.pathType),
+            owner: r(e.left),
+            name: l,
+            quoteStyle: g,
+            hasEventPrefix: a
+          };
+          if (E.owner.type === "MODULE") {
+            let B = E.owner;
+            return E.owner = E.owner.value, B.value = E, B;
+          } else
+            return E;
+        },
+        JsdocTypeUnion: (e, r) => je("UNION", e.elements.map(r)),
+        JsdocTypeParenthesis: (e, r) => ({
+          type: "PARENTHESIS",
+          value: r(S(e.element))
+        }),
+        JsdocTypeNull: () => ({
+          type: "NAME",
+          name: "null"
+        }),
+        JsdocTypeUnknown: () => ({
+          type: "UNKNOWN"
+        }),
+        JsdocTypeStringValue: (e) => ({
+          type: "STRING_VALUE",
+          quoteStyle: ge(e.meta.quote),
+          string: e.value
+        }),
+        JsdocTypeIntersection: (e, r) => je("INTERSECTION", e.elements.map(r)),
+        JsdocTypeNumber: (e) => ({
+          type: "NUMBER_VALUE",
+          number: e.value.toString()
+        }),
+        JsdocTypeSymbol: j,
+        JsdocTypeProperty: j,
+        JsdocTypePredicate: j,
+        JsdocTypeMappedType: j,
+        JsdocTypeIndexSignature: j,
+        JsdocTypeAsserts: j,
+        JsdocTypeReadonlyArray: j,
+        JsdocTypeAssertsPlain: j,
+        JsdocTypeConditional: j,
+        JsdocTypeTypeParameter: j
+      };
+      function nr(e) {
+        return xe(ur, e);
+      }
+      function ar() {
+        return {
+          JsdocTypeIntersection: (e, r) => ({
+            type: "JsdocTypeIntersection",
+            elements: e.elements.map(r)
+          }),
+          JsdocTypeGeneric: (e, r) => ({
+            type: "JsdocTypeGeneric",
+            left: r(e.left),
+            elements: e.elements.map(r),
+            meta: {
+              dot: e.meta.dot,
+              brackets: e.meta.brackets
+            }
+          }),
+          JsdocTypeNullable: (e) => e,
+          JsdocTypeUnion: (e, r) => ({
+            type: "JsdocTypeUnion",
+            elements: e.elements.map(r)
+          }),
+          JsdocTypeUnknown: (e) => e,
+          JsdocTypeUndefined: (e) => e,
+          JsdocTypeTypeof: (e, r) => ({
+            type: "JsdocTypeTypeof",
+            element: r(e.element)
+          }),
+          JsdocTypeSymbol: (e, r) => {
+            let a = {
+              type: "JsdocTypeSymbol",
+              value: e.value
+            };
+            return e.element !== void 0 && (a.element = r(e.element)), a;
+          },
+          JsdocTypeOptional: (e, r) => ({
+            type: "JsdocTypeOptional",
+            element: r(e.element),
+            meta: {
+              position: e.meta.position
+            }
+          }),
+          JsdocTypeObject: (e, r) => ({
+            type: "JsdocTypeObject",
+            meta: {
+              separator: "comma"
+            },
+            elements: e.elements.map(r)
+          }),
+          JsdocTypeNumber: (e) => e,
+          JsdocTypeNull: (e) => e,
+          JsdocTypeNotNullable: (e, r) => ({
+            type: "JsdocTypeNotNullable",
+            element: r(e.element),
+            meta: {
+              position: e.meta.position
+            }
+          }),
+          JsdocTypeSpecialNamePath: (e) => e,
+          JsdocTypeObjectField: (e, r) => ({
+            type: "JsdocTypeObjectField",
+            key: e.key,
+            right: e.right === void 0 ? void 0 : r(e.right),
+            optional: e.optional,
+            readonly: e.readonly,
+            meta: e.meta
+          }),
+          JsdocTypeJsdocObjectField: (e, r) => ({
+            type: "JsdocTypeJsdocObjectField",
+            left: r(e.left),
+            right: r(e.right)
+          }),
+          JsdocTypeKeyValue: (e, r) => ({
+            type: "JsdocTypeKeyValue",
+            key: e.key,
+            right: e.right === void 0 ? void 0 : r(e.right),
+            optional: e.optional,
+            variadic: e.variadic
+          }),
+          JsdocTypeImport: (e, r) => ({
+            type: "JsdocTypeImport",
+            element: r(e.element)
+          }),
+          JsdocTypeAny: (e) => e,
+          JsdocTypeStringValue: (e) => e,
+          JsdocTypeNamePath: (e) => e,
+          JsdocTypeVariadic: (e, r) => {
+            let a = {
+              type: "JsdocTypeVariadic",
+              meta: {
+                position: e.meta.position,
+                squareBrackets: e.meta.squareBrackets
+              }
+            };
+            return e.element !== void 0 && (a.element = r(e.element)), a;
+          },
+          JsdocTypeTuple: (e, r) => ({
+            type: "JsdocTypeTuple",
+            elements: e.elements.map(r)
+          }),
+          JsdocTypeName: (e) => e,
+          JsdocTypeFunction: (e, r) => {
+            let a = {
+              type: "JsdocTypeFunction",
+              arrow: e.arrow,
+              parameters: e.parameters.map(r),
+              constructor: e.constructor,
+              parenthesis: e.parenthesis
+            };
+            return e.returnType !== void 0 && (a.returnType = r(e.returnType)), a;
+          },
+          JsdocTypeKeyof: (e, r) => ({
+            type: "JsdocTypeKeyof",
+            element: r(e.element)
+          }),
+          JsdocTypeParenthesis: (e, r) => ({
+            type: "JsdocTypeParenthesis",
+            element: r(e.element)
+          }),
+          JsdocTypeProperty: (e) => e,
+          JsdocTypePredicate: (e, r) => ({
+            type: "JsdocTypePredicate",
+            left: r(e.left),
+            right: r(e.right)
+          }),
+          JsdocTypeIndexSignature: (e, r) => ({
+            type: "JsdocTypeIndexSignature",
+            key: e.key,
+            right: r(e.right)
+          }),
+          JsdocTypeMappedType: (e, r) => ({
+            type: "JsdocTypeMappedType",
+            key: e.key,
+            right: r(e.right)
+          }),
+          JsdocTypeAsserts: (e, r) => ({
+            type: "JsdocTypeAsserts",
+            left: r(e.left),
+            right: r(e.right)
+          }),
+          JsdocTypeReadonlyArray: (e, r) => ({
+            type: "JsdocTypeReadonlyArray",
+            element: r(e.element)
+          }),
+          JsdocTypeAssertsPlain: (e, r) => ({
+            type: "JsdocTypeAssertsPlain",
+            element: r(e.element)
+          }),
+          JsdocTypeConditional: (e, r) => ({
+            type: "JsdocTypeConditional",
+            checksType: r(e.checksType),
+            extendsType: r(e.extendsType),
+            trueType: r(e.trueType),
+            falseType: r(e.falseType)
+          }),
+          JsdocTypeTypeParameter: (e, r) => ({
+            type: "JsdocTypeTypeParameter",
+            name: r(e.name),
+            constraint: e.constraint !== void 0 ? r(e.constraint) : void 0,
+            defaultValue: e.defaultValue !== void 0 ? r(e.defaultValue) : void 0
+          })
+        };
+      }
+      let rt = {
+        JsdocTypeAny: [],
+        JsdocTypeFunction: ["parameters", "returnType"],
+        JsdocTypeGeneric: ["left", "elements"],
+        JsdocTypeImport: [],
+        JsdocTypeIndexSignature: ["right"],
+        JsdocTypeIntersection: ["elements"],
+        JsdocTypeKeyof: ["element"],
+        JsdocTypeKeyValue: ["right"],
+        JsdocTypeMappedType: ["right"],
+        JsdocTypeName: [],
+        JsdocTypeNamePath: ["left", "right"],
+        JsdocTypeNotNullable: ["element"],
+        JsdocTypeNull: [],
+        JsdocTypeNullable: ["element"],
+        JsdocTypeNumber: [],
+        JsdocTypeObject: ["elements"],
+        JsdocTypeObjectField: ["right"],
+        JsdocTypeJsdocObjectField: ["left", "right"],
+        JsdocTypeOptional: ["element"],
+        JsdocTypeParenthesis: ["element"],
+        JsdocTypeSpecialNamePath: [],
+        JsdocTypeStringValue: [],
+        JsdocTypeSymbol: ["element"],
+        JsdocTypeTuple: ["elements"],
+        JsdocTypeTypeof: ["element"],
+        JsdocTypeUndefined: [],
+        JsdocTypeUnion: ["elements"],
+        JsdocTypeUnknown: [],
+        JsdocTypeVariadic: ["element"],
+        JsdocTypeProperty: [],
+        JsdocTypePredicate: ["left", "right"],
+        JsdocTypeAsserts: ["left", "right"],
+        JsdocTypeReadonlyArray: ["element"],
+        JsdocTypeAssertsPlain: ["element"],
+        JsdocTypeConditional: ["checksType", "extendsType", "trueType", "falseType"],
+        JsdocTypeTypeParameter: ["name", "constraint", "defaultValue"]
+      };
+      function Ue(e, r, a, l, g) {
+        l?.(e, r, a);
+        let E = rt[e.type];
+        for (let B of E) {
+          let M = e[B];
+          if (M !== void 0)
+            if (Array.isArray(M))
+              for (let K of M)
+                Ue(K, e, B, l, g);
+            else
+              Ue(M, e, B, l, g);
+        }
+        g?.(e, r, a);
+      }
+      function or(e, r, a) {
+        Ue(e, void 0, void 0, r, a);
+      }
+      n.catharsisTransform = tr, n.identityTransformRules = ar, n.jtpTransform = nr, n.parse = Ze, n.stringify = Qt, n.stringifyRules = tt, n.transform = xe, n.traverse = or, n.tryParse = Wt, n.visitorKeys = rt;
+    }));
+  }
+}), dr = (t) => t.name === "literal", yr = (t) => t.value.replace(/['|"]/g, ""), mr = (t) => {
+  switch (t.type) {
+    case "function":
+      return { name: "function" };
+    case "object":
+      let u = {};
+      return t.signature.properties.forEach((n) => {
+        u[n.key] = Je(n.value);
+      }), {
+        name: "object",
+        value: u
+      };
+    default:
+      throw new dt({ type: t, language: "Flow" });
+  }
+}, Je = (t) => {
+  let { name: u, raw: n } = t, o = {};
+  switch (typeof n < "u" && (o.raw = n), t.name) {
+    case "literal":
+      return { ...o, name: "other", value: t.value };
+    case "string":
+    case "number":
+    case "symbol":
+    case "boolean":
+      return { ...o, name: u };
+    case "Array":
+      return { ...o, name: "array", value: t.elements.map(Je) };
+    case "signature":
+      return { ...o, ...mr(t) };
+    case "union":
+      return t.elements?.every(dr) ? { ...o, name: "enum", value: t.elements?.map(yr) } : { ...o, name: u, value: t.elements?.map(Je) };
+    case "intersection":
+      return { ...o, name: u, value: t.elements?.map(Je) };
+    default:
+      return { ...o, name: "other", value: u };
+  }
+}, yt = /^['"]|['"]$/g, fr = (t) => t.replace(yt, ""), hr = (t) => yt.test(t), mt = (t) => {
+  let u = fr(t);
+  return hr(t) || Number.isNaN(Number(u)) ? u : Number(u);
+}, gr = /^\(.*\) => /, Se = (t) => {
+  let { name: u, raw: n, computed: o, value: s } = t, i = {};
+  switch (typeof n < "u" && (i.raw = n), u) {
+    case "enum": {
+      let d = o ? s : s.map((m) => mt(m.value));
+      return { ...i, name: u, value: d };
+    }
+    case "string":
+    case "number":
+    case "symbol":
+      return { ...i, name: u };
+    case "func":
+      return { ...i, name: "function" };
+    case "bool":
+    case "boolean":
+      return { ...i, name: "boolean" };
+    case "arrayOf":
+    case "array":
+      return { ...i, name: "array", value: s && Se(s) };
+    case "object":
+      return { ...i, name: u };
+    case "objectOf":
+      return { ...i, name: u, value: Se(s) };
+    case "shape":
+    case "exact":
+      let p = cr(s, (d) => Se(d));
+      return { ...i, name: "object", value: p };
+    case "union":
+      return { ...i, name: "union", value: s.map((d) => Se(d)) };
+    case "instanceOf":
+    case "element":
+    case "elementType":
+    default: {
+      if (u?.indexOf("|") > 0)
+        try {
+          let f = u.split("|").map((b) => JSON.parse(b));
+          return { ...i, name: "enum", value: f };
+        } catch {
+        }
+      let d = s ? `${u}(${s})` : u, m = gr.test(u) ? "function" : "other";
+      return { ...i, name: m, value: d };
+    }
+  }
+}, Ar = (t) => {
+  switch (t.type) {
+    case "function":
+      return { name: "function" };
+    case "object":
+      let u = {};
+      return t.signature.properties.forEach((n) => {
+        u[n.key] = Ne(n.value);
+      }), {
+        name: "object",
+        value: u
+      };
+    default:
+      throw new dt({ type: t, language: "Typescript" });
+  }
+}, Ne = (t) => {
+  let { name: u, raw: n } = t, o = {};
+  switch (typeof n < "u" && (o.raw = n), t.name) {
+    case "string":
+    case "number":
+    case "symbol":
+    case "boolean":
+      return { ...o, name: u };
+    case "Array":
+      return { ...o, name: "array", value: t.elements.map(Ne) };
+    case "signature":
+      return { ...o, ...Ar(t) };
+    case "union":
+      let s;
+      return t.elements?.every((i) => i.name === "literal") ? s = {
+        ...o,
+        name: "enum",
+        // @ts-expect-error fix types
+        value: t.elements?.map((i) => mt(i.value))
+      } : s = { ...o, name: u, value: t.elements?.map(Ne) }, s;
+    case "intersection":
+      return { ...o, name: u, value: t.elements?.map(Ne) };
+    default:
+      return { ...o, name: "other", value: u };
+  }
+}, ze = (t) => {
+  let { type: u, tsType: n, flowType: o } = t;
+  try {
+    if (u != null)
+      return Se(u);
+    if (n != null)
+      return Ne(n);
+    if (o != null)
+      return Je(o);
+  } catch (s) {
+    console.error(s);
+  }
+  return null;
+}, Tr = /* @__PURE__ */ ((t) => (t.JAVASCRIPT = "JavaScript", t.FLOW = "Flow", t.TYPESCRIPT = "TypeScript", t.UNKNOWN = "Unknown", t))(Tr || {}), br = ["null", "undefined"];
+function Ye(t) {
+  return br.some((u) => u === t);
+}
+var Dr = (t) => {
+  if (!t)
+    return "";
+  if (typeof t == "string")
+    return t;
+  throw new Error(`Description: expected string, got: ${JSON.stringify(t)}`);
+};
+function ft(t) {
+  return !!t.__docgenInfo;
+}
+function Er(t) {
+  return t != null && Object.keys(t).length > 0;
+}
+function vr(t, u) {
+  return ft(t) ? t.__docgenInfo[u] : null;
+}
+function wr(t) {
+  return ft(t) ? Dr(t.__docgenInfo.description) : "";
+}
+var ye;
+(function(t) {
+  t.start = "/**", t.nostart = "/***", t.delim = "*", t.end = "*/";
+})(ye = ye || (ye = {}));
+function Cr(t) {
+  return /^\s+$/.test(t);
+}
+function xr(t) {
+  let u = t.match(/\r+$/);
+  return u == null ? ["", t] : [t.slice(-u[0].length), t.slice(0, -u[0].length)];
+}
+function De(t) {
+  let u = t.match(/^\s+/);
+  return u == null ? ["", t] : [t.slice(0, u[0].length), t.slice(u[0].length)];
+}
+function Fr(t) {
+  return t.split(/\n/);
+}
+function Br(t = {}) {
+  return Object.assign({ tag: "", name: "", type: "", optional: !1, description: "", problems: [], source: [] }, t);
+}
+function Sr(t = {}) {
+  return Object.assign({ start: "", delimiter: "", postDelimiter: "", tag: "", postTag: "", name: "", postName: "", type: "", postType: "", description: "", end: "", lineEnd: "" }, t);
+}
+var Jr = /^@\S+/;
+function Nr({ fence: t = "```" } = {}) {
+  let u = Or(t), n = (o, s) => u(o) ? !s : s;
+  return function(o) {
+    let s = [[]], i = !1;
+    for (let p of o)
+      Jr.test(p.tokens.description) && !i ? s.push([p]) : s[s.length - 1].push(p), i = n(p.tokens.description, i);
+    return s;
+  };
+}
+function Or(t) {
+  return typeof t == "string" ? (u) => u.split(t).length % 2 === 0 : t;
+}
+function Pr({ startLine: t = 0, markers: u = ye } = {}) {
+  let n = null, o = t;
+  return function(s) {
+    let i = s, p = Sr();
+    if ([p.lineEnd, i] = xr(i), [p.start, i] = De(i), n === null && i.startsWith(u.start) && !i.startsWith(u.nostart) && (n = [], p.delimiter = i.slice(0, u.start.length), i = i.slice(u.start.length), [p.postDelimiter, i] = De(i)), n === null)
+      return o++, null;
+    let d = i.trimRight().endsWith(u.end);
+    if (p.delimiter === "" && i.startsWith(u.delim) && !i.startsWith(u.end) && (p.delimiter = u.delim, i = i.slice(u.delim.length), [p.postDelimiter, i] = De(i)), d) {
+      let m = i.trimRight();
+      p.end = i.slice(m.length - u.end.length), i = m.slice(0, -u.end.length);
+    }
+    if (p.description = i, n.push({ number: o, source: s, tokens: p }), o++, d) {
+      let m = n.slice();
+      return n = null, m;
+    }
+    return null;
+  };
+}
+function qr({ tokenizers: t }) {
+  return function(u) {
+    var n;
+    let o = Br({ source: u });
+    for (let s of t)
+      if (o = s(o), !((n = o.problems[o.problems.length - 1]) === null || n === void 0) && n.critical)
+        break;
+    return o;
+  };
+}
+function kr() {
+  return (t) => {
+    let { tokens: u } = t.source[0], n = u.description.match(/\s*(@(\S+))(\s*)/);
+    return n === null ? (t.problems.push({
+      code: "spec:tag:prefix",
+      message: 'tag should start with "@" symbol',
+      line: t.source[0].number,
+      critical: !0
+    }), t) : (u.tag = n[1], u.postTag = n[3], u.description = u.description.slice(n[0].length), t.tag = n[2], t);
+  };
+}
+function _r(t = "compact") {
+  let u = Rr(t);
+  return (n) => {
+    let o = 0, s = [];
+    for (let [d, { tokens: m }] of n.source.entries()) {
+      let f = "";
+      if (d === 0 && m.description[0] !== "{")
+        return n;
+      for (let b of m.description)
+        if (b === "{" && o++, b === "}" && o--, f += b, o === 0)
+          break;
+      if (s.push([m, f]), o === 0)
+        break;
+    }
+    if (o !== 0)
+      return n.problems.push({
+        code: "spec:type:unpaired-curlies",
+        message: "unpaired curlies",
+        line: n.source[0].number,
+        critical: !0
+      }), n;
+    let i = [], p = s[0][0].postDelimiter.length;
+    for (let [d, [m, f]] of s.entries())
+      m.type = f, d > 0 && (m.type = m.postDelimiter.slice(p) + f, m.postDelimiter = m.postDelimiter.slice(0, p)), [m.postType, m.description] = De(m.description.slice(f.length)), i.push(m.type);
+    return i[0] = i[0].slice(1), i[i.length - 1] = i[i.length - 1].slice(0, -1), n.type = u(i), n;
+  };
+}
+var Lr = (t) => t.trim();
+function Rr(t) {
+  return t === "compact" ? (u) => u.map(Lr).join("") : t === "preserve" ? (u) => u.join(`
+`) : t;
+}
+var Ir = (t) => t && t.startsWith('"') && t.endsWith('"');
+function jr() {
+  let t = (u, { tokens: n }, o) => n.type === "" ? u : o;
+  return (u) => {
+    let { tokens: n } = u.source[u.source.reduce(t, 0)], o = n.description.trimLeft(), s = o.split('"');
+    if (s.length > 1 && s[0] === "" && s.length % 2 === 1)
+      return u.name = s[1], n.name = `"${s[1]}"`, [n.postName, n.description] = De(o.slice(n.name.length)), u;
+    let i = 0, p = "", d = !1, m;
+    for (let b of o) {
+      if (i === 0 && Cr(b))
+        break;
+      b === "[" && i++, b === "]" && i--, p += b;
+    }
+    if (i !== 0)
+      return u.problems.push({
+        code: "spec:name:unpaired-brackets",
+        message: "unpaired brackets",
+        line: u.source[0].number,
+        critical: !0
+      }), u;
+    let f = p;
+    if (p[0] === "[" && p[p.length - 1] === "]") {
+      d = !0, p = p.slice(1, -1);
+      let b = p.split("=");
+      if (p = b[0].trim(), b[1] !== void 0 && (m = b.slice(1).join("=").trim()), p === "")
+        return u.problems.push({
+          code: "spec:name:empty-name",
+          message: "empty name",
+          line: u.source[0].number,
+          critical: !0
+        }), u;
+      if (m === "")
+        return u.problems.push({
+          code: "spec:name:empty-default",
+          message: "empty default value",
+          line: u.source[0].number,
+          critical: !0
+        }), u;
+      if (!Ir(m) && /=(?!>)/.test(m))
+        return u.problems.push({
+          code: "spec:name:invalid-default",
+          message: "invalid default value syntax",
+          line: u.source[0].number,
+          critical: !0
+        }), u;
+    }
+    return u.optional = d, u.name = p, n.name = f, m !== void 0 && (u.default = m), [n.postName, n.description] = De(o.slice(n.name.length)), u;
+  };
+}
+function Ur(t = "compact", u = ye) {
+  let n = ht(t);
+  return (o) => (o.description = n(o.source, u), o);
+}
+function ht(t) {
+  return t === "compact" ? Mr : t === "preserve" ? Kr : t;
+}
+function Mr(t, u = ye) {
+  return t.map(({ tokens: { description: n } }) => n.trim()).filter((n) => n !== "").join(" ");
+}
+var Vr = (t, { tokens: u }, n) => u.type === "" ? t : n, Hr = ({ tokens: t }) => (t.delimiter === "" ? t.start : t.postDelimiter.slice(1)) + t.description;
+function Kr(t, u = ye) {
+  if (t.length === 0)
+    return "";
+  t[0].tokens.description === "" && t[0].tokens.delimiter === u.start && (t = t.slice(1));
+  let n = t[t.length - 1];
+  return n !== void 0 && n.tokens.description === "" && n.tokens.end.endsWith(u.end) && (t = t.slice(0, -1)), t = t.slice(t.reduce(Vr, 0)), t.map(Hr).join(`
+`);
+}
+function Gr({ startLine: t = 0, fence: u = "```", spacing: n = "compact", markers: o = ye, tokenizers: s = [
+  kr(),
+  _r(n),
+  jr(),
+  Ur(n)
+] } = {}) {
+  if (t < 0 || t % 1 > 0)
+    throw new Error("Invalid startLine");
+  let i = Pr({ startLine: t, markers: o }), p = Nr({ fence: u }), d = qr({ tokenizers: s }), m = ht(n);
+  return function(f) {
+    let b = [];
+    for (let D of Fr(f)) {
+      let v = i(D);
+      if (v === null)
+        continue;
+      let C = p(v), F = C.slice(1).map(d);
+      b.push({
+        description: m(C[0], o),
+        tags: F,
+        source: v,
+        problems: F.reduce((w, L) => w.concat(L.problems), [])
+      });
+    }
+    return b;
+  };
+}
+function zr(t, u = {}) {
+  return Gr(u)(t);
+}
+var Xe = Ae(pr(), 1);
+function Yr(t) {
+  return t != null && t.includes("@");
+}
+function Xr(t) {
+  let u = `/**
+` + (t ?? "").split(`
+`).map((o) => ` * ${o}`).join(`
+`) + `
+*/`, n = zr(u, {
+    spacing: "preserve"
+  });
+  if (!n || n.length === 0)
+    throw new Error("Cannot parse JSDoc tags.");
+  return n[0];
+}
+var Wr = {
+  tags: ["param", "arg", "argument", "returns", "ignore", "deprecated"]
+}, $r = (t, u = Wr) => {
+  if (!Yr(t))
+    return {
+      includesJsDoc: !1,
+      ignore: !1
+    };
+  let n = Xr(t), o = Qr(n, u.tags);
+  return o.ignore ? {
+    includesJsDoc: !0,
+    ignore: !0
+  } : {
+    includesJsDoc: !0,
+    ignore: !1,
+    // Always use the parsed description to ensure JSDoc is removed from the description.
+    description: n.description.trim(),
+    extractedTags: o
+  };
+};
+function Qr(t, u) {
+  let n = {
+    params: null,
+    deprecated: null,
+    returns: null,
+    ignore: !1
+  };
+  for (let o of t.tags)
+    if (!(u !== void 0 && !u.includes(o.tag)))
+      if (o.tag === "ignore") {
+        n.ignore = !0;
+        break;
+      } else
+        switch (o.tag) {
+          // arg & argument are aliases for param.
+          case "param":
+          case "arg":
+          case "argument": {
+            let s = eu(o);
+            s != null && (n.params == null && (n.params = []), n.params.push(s));
+            break;
+          }
+          case "deprecated": {
+            let s = tu(o);
+            s != null && (n.deprecated = s);
+            break;
+          }
+          case "returns": {
+            let s = ru(o);
+            s != null && (n.returns = s);
+            break;
+          }
+        }
+  return n;
+}
+function Zr(t) {
+  return t.replace(/[\.-]$/, "");
+}
+function eu(t) {
+  if (!t.name || t.name === "-")
+    return null;
+  let u = Tt(t.type);
+  return {
+    name: t.name,
+    type: u,
+    description: At(t.description),
+    getPrettyName: () => Zr(t.name),
+    getTypeName: () => u ? bt(u) : null
+  };
+}
+function tu(t) {
+  return t.name ? gt(t.name, t.description) : null;
+}
+function gt(t, u) {
+  let n = t === "" ? u : `${t} ${u}`;
+  return At(n);
+}
+function At(t) {
+  let u = t.replace(/^- /g, "").trim();
+  return u === "" ? null : u;
+}
+function ru(t) {
+  let u = Tt(t.type);
+  return u ? {
+    type: u,
+    description: gt(t.name, t.description),
+    getTypeName: () => bt(u)
+  } : null;
+}
+var me = (0, Xe.stringifyRules)(), uu = me.JsdocTypeObject;
+me.JsdocTypeAny = () => "any";
+me.JsdocTypeObject = (t, u) => `(${uu(t, u)})`;
+me.JsdocTypeOptional = (t, u) => u(t.element);
+me.JsdocTypeNullable = (t, u) => u(t.element);
+me.JsdocTypeNotNullable = (t, u) => u(t.element);
+me.JsdocTypeUnion = (t, u) => t.elements.map(u).join("|");
+function Tt(t) {
+  try {
+    return (0, Xe.parse)(t, "typescript");
+  } catch {
+    return null;
+  }
+}
+function bt(t) {
+  return (0, Xe.transform)(me, t);
+}
+function Dt(t) {
+  return t.length > 90;
+}
+function nu(t) {
+  return t.length > 50;
+}
+function W(t, u) {
+  return t === u ? { summary: t } : { summary: t, detail: u };
+}
+function au(t, u) {
+  if (t != null) {
+    let { value: n } = t;
+    if (!Ye(n))
+      return nu(n) ? W(u?.name, n) : W(n);
+  }
+  return null;
+}
+function Et({ name: t, value: u, elements: n, raw: o }) {
+  return u ?? (n != null ? n.map(Et).join(" | ") : o ?? t);
+}
+function ou({ name: t, raw: u, elements: n }) {
+  return n != null ? W(n.map(Et).join(" | ")) : u != null ? W(u.replace(/^\|\s*/, "")) : W(t);
+}
+function iu({ type: t, raw: u }) {
+  return u != null ? W(u) : W(t);
+}
+function su({ type: t, raw: u }) {
+  return u != null ? Dt(u) ? W(t, u) : W(u) : W(t);
+}
+function lu(t) {
+  let { type: u } = t;
+  return u === "object" ? su(t) : iu(t);
+}
+function cu({ name: t, raw: u }) {
+  return u != null ? Dt(u) ? W(t, u) : W(u) : W(t);
+}
+function pu(t) {
+  if (t == null)
+    return null;
+  switch (t.name) {
+    case "union":
+      return ou(t);
+    case "signature":
+      return lu(t);
+    default:
+      return cu(t);
+  }
+}
+var du = (t, u) => {
+  let { flowType: n, description: o, required: s, defaultValue: i } = u;
+  return {
+    name: t,
+    type: pu(n),
+    required: s,
+    description: o,
+    defaultValue: au(i ?? null, n ?? null)
+  };
+};
+function yu({ defaultValue: t }) {
+  if (t != null) {
+    let { value: u } = t;
+    if (!Ye(u))
+      return W(u);
+  }
+  return null;
+}
+function mu({ tsType: t, required: u }) {
+  if (t == null)
+    return null;
+  let n = t.name;
+  return u || (n = n.replace(" | undefined", "")), W(
+    ["Array", "Record", "signature"].includes(t.name) ? t.raw : n
+  );
+}
+var fu = (t, u) => {
+  let { description: n, required: o } = u;
+  return {
+    name: t,
+    type: mu(u),
+    required: o,
+    description: n,
+    defaultValue: yu(u)
+  };
+};
+function hu(t) {
+  return t != null ? W(t.name) : null;
+}
+function gu(t) {
+  let { computed: u, func: n } = t;
+  return typeof u > "u" && typeof n > "u";
+}
+function Au(t) {
+  return t ? t.name === "string" ? !0 : t.name === "enum" ? Array.isArray(t.value) && t.value.every(
+    ({ value: u }) => typeof u == "string" && u[0] === '"' && u[u.length - 1] === '"'
+  ) : !1 : !1;
+}
+function Tu(t, u) {
+  if (t != null) {
+    let { value: n } = t;
+    if (!Ye(n))
+      return gu(t) && Au(u) ? W(JSON.stringify(n)) : W(n);
+  }
+  return null;
+}
+function vt(t, u, n) {
+  let { description: o, required: s, defaultValue: i } = n;
+  return {
+    name: t,
+    type: hu(u),
+    required: s,
+    description: o,
+    defaultValue: Tu(i, u)
+  };
+}
+function Le(t, u) {
+  if (u?.includesJsDoc) {
+    let { description: n, extractedTags: o } = u;
+    n != null && (t.description = u.description);
+    let s = {
+      ...o,
+      params: o?.params?.map(
+        (i) => ({
+          name: i.getPrettyName(),
+          description: i.description
+        })
+      )
+    };
+    Object.values(s).filter(Boolean).length > 0 && (t.jsDocTags = s);
+  }
+  return t;
+}
+var bu = (t, u, n) => {
+  let o = vt(t, u.type, u);
+  return o.sbType = ze(u), Le(o, n);
+}, Du = (t, u, n) => {
+  let o = fu(t, u);
+  return o.sbType = ze(u), Le(o, n);
+}, Eu = (t, u, n) => {
+  let o = du(t, u);
+  return o.sbType = ze(u), Le(o, n);
+}, vu = (t, u, n) => {
+  let o = vt(t, { name: "unknown" }, u);
+  return Le(o, n);
+}, wt = (t) => {
+  switch (t) {
+    case "JavaScript":
+      return bu;
+    case "TypeScript":
+      return Du;
+    case "Flow":
+      return Eu;
+    default:
+      return vu;
+  }
+}, Ct = (t) => t.type != null ? "JavaScript" : t.flowType != null ? "Flow" : t.tsType != null ? "TypeScript" : "Unknown", wu = (t) => {
+  let u = Ct(t[0]), n = wt(u);
+  return t.map((o) => {
+    let s = o;
+    return o.type?.elements && (s = {
+      ...o,
+      type: {
+        ...o.type,
+        value: o.type.elements
+      }
+    }), xt(s.name, s, u, n);
+  });
+}, Cu = (t) => {
+  let u = Object.keys(t), n = Ct(t[u[0]]), o = wt(n);
+  return u.map((s) => {
+    let i = t[s];
+    return i != null ? xt(s, i, n, o) : null;
+  }).filter(Boolean);
+}, en = (t, u) => {
+  let n = vr(t, u);
+  return Er(n) ? Array.isArray(n) ? wu(n) : Cu(n) : [];
+};
+function xt(t, u, n, o) {
+  let s = $r(u.description);
+  return s.includesJsDoc && s.ignore ? null : {
+    propDef: o(t, u, s),
+    jsDocTags: s.extractedTags,
+    docgenInfo: u,
+    typeSystem: n
+  };
+}
+function tn(t) {
+  return t != null ? wr(t) : "";
+}
+var We = (...t) => {
+  let u = {}, n = t.filter(Boolean), o = n.reduce((s, i) => (Object.entries(i).forEach(([p, d]) => {
+    let m = s[p];
+    Array.isArray(d) || typeof m > "u" ? s[p] = d : Me(d) && Me(m) ? u[p] = !0 : typeof d < "u" && (s[p] = d);
+  }), s), {});
+  return Object.keys(u).forEach((s) => {
+    let i = n.filter(Boolean).map((p) => p[s]).filter((p) => typeof p < "u");
+    i.every((p) => Me(p)) ? o[s] = We(...i) : o[s] = i[i.length - 1];
+  }), o;
+}, rn = (t) => {
+  let {
+    component: u,
+    argTypes: n,
+    parameters: { docs: o = {} }
+  } = t, { extractArgTypes: s } = o;
+  if (!s || !u)
+    return n;
+  let i = s(u);
+  return i ? We(i, n) : n;
+}, xu = "storybook/docs", Fu = `${xu}/snippet-rendered`, Bu = /* @__PURE__ */ ((t) => (t.AUTO = "auto", t.CODE = "code", t.DYNAMIC = "dynamic", t))(Bu || {}), Ft = $({
+  "../node_modules/entities/lib/maps/entities.json"(t, u) {
+    u.exports = { Aacute: "Á", aacute: "á", Abreve: "Ă", abreve: "ă", ac: "∾", acd: "∿", acE: "∾̳", Acirc: "Â", acirc: "â", acute: "´", Acy: "А", acy: "а", AElig: "Æ", aelig: "æ", af: "⁡", Afr: "𝔄", afr: "𝔞", Agrave: "À", agrave: "à", alefsym: "ℵ", aleph: "ℵ", Alpha: "Α", alpha: "α", Amacr: "Ā", amacr: "ā", amalg: "⨿", amp: "&", AMP: "&", andand: "⩕", And: "⩓", and: "∧", andd: "⩜", andslope: "⩘", andv: "⩚", ang: "∠", ange: "⦤", angle: "∠", angmsdaa: "⦨", angmsdab: "⦩", angmsdac: "⦪", angmsdad: "⦫", angmsdae: "⦬", angmsdaf: "⦭", angmsdag: "⦮", angmsdah: "⦯", angmsd: "∡", angrt: "∟", angrtvb: "⊾", angrtvbd: "⦝", angsph: "∢", angst: "Å", angzarr: "⍼", Aogon: "Ą", aogon: "ą", Aopf: "𝔸", aopf: "𝕒", apacir: "⩯", ap: "≈", apE: "⩰", ape: "≊", apid: "≋", apos: "'", ApplyFunction: "⁡", approx: "≈", approxeq: "≊", Aring: "Å", aring: "å", Ascr: "𝒜", ascr: "𝒶", Assign: "≔", ast: "*", asymp: "≈", asympeq: "≍", Atilde: "Ã", atilde: "ã", Auml: "Ä", auml: "ä", awconint: "∳", awint: "⨑", backcong: "≌", backepsilon: "϶", backprime: "‵", backsim: "∽", backsimeq: "⋍", Backslash: "∖", Barv: "⫧", barvee: "⊽", barwed: "⌅", Barwed: "⌆", barwedge: "⌅", bbrk: "⎵", bbrktbrk: "⎶", bcong: "≌", Bcy: "Б", bcy: "б", bdquo: "„", becaus: "∵", because: "∵", Because: "∵", bemptyv: "⦰", bepsi: "϶", bernou: "ℬ", Bernoullis: "ℬ", Beta: "Β", beta: "β", beth: "ℶ", between: "≬", Bfr: "𝔅", bfr: "𝔟", bigcap: "⋂", bigcirc: "◯", bigcup: "⋃", bigodot: "⨀", bigoplus: "⨁", bigotimes: "⨂", bigsqcup: "⨆", bigstar: "★", bigtriangledown: "▽", bigtriangleup: "△", biguplus: "⨄", bigvee: "⋁", bigwedge: "⋀", bkarow: "⤍", blacklozenge: "⧫", blacksquare: "▪", blacktriangle: "▴", blacktriangledown: "▾", blacktriangleleft: "◂", blacktriangleright: "▸", blank: "␣", blk12: "▒", blk14: "░", blk34: "▓", block: "█", bne: "=⃥", bnequiv: "≡⃥", bNot: "⫭", bnot: "⌐", Bopf: "𝔹", bopf: "𝕓", bot: "⊥", bottom: "⊥", bowtie: "⋈", boxbox: "⧉", boxdl: "┐", boxdL: "╕", boxDl: "╖", boxDL: "╗", boxdr: "┌", boxdR: "╒", boxDr: "╓", boxDR: "╔", boxh: "─", boxH: "═", boxhd: "┬", boxHd: "╤", boxhD: "╥", boxHD: "╦", boxhu: "┴", boxHu: "╧", boxhU: "╨", boxHU: "╩", boxminus: "⊟", boxplus: "⊞", boxtimes: "⊠", boxul: "┘", boxuL: "╛", boxUl: "╜", boxUL: "╝", boxur: "└", boxuR: "╘", boxUr: "╙", boxUR: "╚", boxv: "│", boxV: "║", boxvh: "┼", boxvH: "╪", boxVh: "╫", boxVH: "╬", boxvl: "┤", boxvL: "╡", boxVl: "╢", boxVL: "╣", boxvr: "├", boxvR: "╞", boxVr: "╟", boxVR: "╠", bprime: "‵", breve: "˘", Breve: "˘", brvbar: "¦", bscr: "𝒷", Bscr: "ℬ", bsemi: "⁏", bsim: "∽", bsime: "⋍", bsolb: "⧅", bsol: "\\", bsolhsub: "⟈", bull: "•", bullet: "•", bump: "≎", bumpE: "⪮", bumpe: "≏", Bumpeq: "≎", bumpeq: "≏", Cacute: "Ć", cacute: "ć", capand: "⩄", capbrcup: "⩉", capcap: "⩋", cap: "∩", Cap: "⋒", capcup: "⩇", capdot: "⩀", CapitalDifferentialD: "ⅅ", caps: "∩︀", caret: "⁁", caron: "ˇ", Cayleys: "ℭ", ccaps: "⩍", Ccaron: "Č", ccaron: "č", Ccedil: "Ç", ccedil: "ç", Ccirc: "Ĉ", ccirc: "ĉ", Cconint: "∰", ccups: "⩌", ccupssm: "⩐", Cdot: "Ċ", cdot: "ċ", cedil: "¸", Cedilla: "¸", cemptyv: "⦲", cent: "¢", centerdot: "·", CenterDot: "·", cfr: "𝔠", Cfr: "ℭ", CHcy: "Ч", chcy: "ч", check: "✓", checkmark: "✓", Chi: "Χ", chi: "χ", circ: "ˆ", circeq: "≗", circlearrowleft: "↺", circlearrowright: "↻", circledast: "⊛", circledcirc: "⊚", circleddash: "⊝", CircleDot: "⊙", circledR: "®", circledS: "Ⓢ", CircleMinus: "⊖", CirclePlus: "⊕", CircleTimes: "⊗", cir: "○", cirE: "⧃", cire: "≗", cirfnint: "⨐", cirmid: "⫯", cirscir: "⧂", ClockwiseContourIntegral: "∲", CloseCurlyDoubleQuote: "”", CloseCurlyQuote: "’", clubs: "♣", clubsuit: "♣", colon: ":", Colon: "∷", Colone: "⩴", colone: "≔", coloneq: "≔", comma: ",", commat: "@", comp: "∁", compfn: "∘", complement: "∁", complexes: "ℂ", cong: "≅", congdot: "⩭", Congruent: "≡", conint: "∮", Conint: "∯", ContourIntegral: "∮", copf: "𝕔", Copf: "ℂ", coprod: "∐", Coproduct: "∐", copy: "©", COPY: "©", copysr: "℗", CounterClockwiseContourIntegral: "∳", crarr: "↵", cross: "✗", Cross: "⨯", Cscr: "𝒞", cscr: "𝒸", csub: "⫏", csube: "⫑", csup: "⫐", csupe: "⫒", ctdot: "⋯", cudarrl: "⤸", cudarrr: "⤵", cuepr: "⋞", cuesc: "⋟", cularr: "↶", cularrp: "⤽", cupbrcap: "⩈", cupcap: "⩆", CupCap: "≍", cup: "∪", Cup: "⋓", cupcup: "⩊", cupdot: "⊍", cupor: "⩅", cups: "∪︀", curarr: "↷", curarrm: "⤼", curlyeqprec: "⋞", curlyeqsucc: "⋟", curlyvee: "⋎", curlywedge: "⋏", curren: "¤", curvearrowleft: "↶", curvearrowright: "↷", cuvee: "⋎", cuwed: "⋏", cwconint: "∲", cwint: "∱", cylcty: "⌭", dagger: "†", Dagger: "‡", daleth: "ℸ", darr: "↓", Darr: "↡", dArr: "⇓", dash: "‐", Dashv: "⫤", dashv: "⊣", dbkarow: "⤏", dblac: "˝", Dcaron: "Ď", dcaron: "ď", Dcy: "Д", dcy: "д", ddagger: "‡", ddarr: "⇊", DD: "ⅅ", dd: "ⅆ", DDotrahd: "⤑", ddotseq: "⩷", deg: "°", Del: "∇", Delta: "Δ", delta: "δ", demptyv: "⦱", dfisht: "⥿", Dfr: "𝔇", dfr: "𝔡", dHar: "⥥", dharl: "⇃", dharr: "⇂", DiacriticalAcute: "´", DiacriticalDot: "˙", DiacriticalDoubleAcute: "˝", DiacriticalGrave: "`", DiacriticalTilde: "˜", diam: "⋄", diamond: "⋄", Diamond: "⋄", diamondsuit: "♦", diams: "♦", die: "¨", DifferentialD: "ⅆ", digamma: "ϝ", disin: "⋲", div: "÷", divide: "÷", divideontimes: "⋇", divonx: "⋇", DJcy: "Ђ", djcy: "ђ", dlcorn: "⌞", dlcrop: "⌍", dollar: "$", Dopf: "𝔻", dopf: "𝕕", Dot: "¨", dot: "˙", DotDot: "⃜", doteq: "≐", doteqdot: "≑", DotEqual: "≐", dotminus: "∸", dotplus: "∔", dotsquare: "⊡", doublebarwedge: "⌆", DoubleContourIntegral: "∯", DoubleDot: "¨", DoubleDownArrow: "⇓", DoubleLeftArrow: "⇐", DoubleLeftRightArrow: "⇔", DoubleLeftTee: "⫤", DoubleLongLeftArrow: "⟸", DoubleLongLeftRightArrow: "⟺", DoubleLongRightArrow: "⟹", DoubleRightArrow: "⇒", DoubleRightTee: "⊨", DoubleUpArrow: "⇑", DoubleUpDownArrow: "⇕", DoubleVerticalBar: "∥", DownArrowBar: "⤓", downarrow: "↓", DownArrow: "↓", Downarrow: "⇓", DownArrowUpArrow: "⇵", DownBreve: "̑", downdownarrows: "⇊", downharpoonleft: "⇃", downharpoonright: "⇂", DownLeftRightVector: "⥐", DownLeftTeeVector: "⥞", DownLeftVectorBar: "⥖", DownLeftVector: "↽", DownRightTeeVector: "⥟", DownRightVectorBar: "⥗", DownRightVector: "⇁", DownTeeArrow: "↧", DownTee: "⊤", drbkarow: "⤐", drcorn: "⌟", drcrop: "⌌", Dscr: "𝒟", dscr: "𝒹", DScy: "Ѕ", dscy: "ѕ", dsol: "⧶", Dstrok: "Đ", dstrok: "đ", dtdot: "⋱", dtri: "▿", dtrif: "▾", duarr: "⇵", duhar: "⥯", dwangle: "⦦", DZcy: "Џ", dzcy: "џ", dzigrarr: "⟿", Eacute: "É", eacute: "é", easter: "⩮", Ecaron: "Ě", ecaron: "ě", Ecirc: "Ê", ecirc: "ê", ecir: "≖", ecolon: "≕", Ecy: "Э", ecy: "э", eDDot: "⩷", Edot: "Ė", edot: "ė", eDot: "≑", ee: "ⅇ", efDot: "≒", Efr: "𝔈", efr: "𝔢", eg: "⪚", Egrave: "È", egrave: "è", egs: "⪖", egsdot: "⪘", el: "⪙", Element: "∈", elinters: "⏧", ell: "ℓ", els: "⪕", elsdot: "⪗", Emacr: "Ē", emacr: "ē", empty: "∅", emptyset: "∅", EmptySmallSquare: "◻", emptyv: "∅", EmptyVerySmallSquare: "▫", emsp13: " ", emsp14: " ", emsp: " ", ENG: "Ŋ", eng: "ŋ", ensp: " ", Eogon: "Ę", eogon: "ę", Eopf: "𝔼", eopf: "𝕖", epar: "⋕", eparsl: "⧣", eplus: "⩱", epsi: "ε", Epsilon: "Ε", epsilon: "ε", epsiv: "ϵ", eqcirc: "≖", eqcolon: "≕", eqsim: "≂", eqslantgtr: "⪖", eqslantless: "⪕", Equal: "⩵", equals: "=", EqualTilde: "≂", equest: "≟", Equilibrium: "⇌", equiv: "≡", equivDD: "⩸", eqvparsl: "⧥", erarr: "⥱", erDot: "≓", escr: "ℯ", Escr: "ℰ", esdot: "≐", Esim: "⩳", esim: "≂", Eta: "Η", eta: "η", ETH: "Ð", eth: "ð", Euml: "Ë", euml: "ë", euro: "€", excl: "!", exist: "∃", Exists: "∃", expectation: "ℰ", exponentiale: "ⅇ", ExponentialE: "ⅇ", fallingdotseq: "≒", Fcy: "Ф", fcy: "ф", female: "♀", ffilig: "ffi", fflig: "ff", ffllig: "ffl", Ffr: "𝔉", ffr: "𝔣", filig: "fi", FilledSmallSquare: "◼", FilledVerySmallSquare: "▪", fjlig: "fj", flat: "♭", fllig: "fl", fltns: "▱", fnof: "ƒ", Fopf: "𝔽", fopf: "𝕗", forall: "∀", ForAll: "∀", fork: "⋔", forkv: "⫙", Fouriertrf: "ℱ", fpartint: "⨍", frac12: "½", frac13: "⅓", frac14: "¼", frac15: "⅕", frac16: "⅙", frac18: "⅛", frac23: "⅔", frac25: "⅖", frac34: "¾", frac35: "⅗", frac38: "⅜", frac45: "⅘", frac56: "⅚", frac58: "⅝", frac78: "⅞", frasl: "⁄", frown: "⌢", fscr: "𝒻", Fscr: "ℱ", gacute: "ǵ", Gamma: "Γ", gamma: "γ", Gammad: "Ϝ", gammad: "ϝ", gap: "⪆", Gbreve: "Ğ", gbreve: "ğ", Gcedil: "Ģ", Gcirc: "Ĝ", gcirc: "ĝ", Gcy: "Г", gcy: "г", Gdot: "Ġ", gdot: "ġ", ge: "≥", gE: "≧", gEl: "⪌", gel: "⋛", geq: "≥", geqq: "≧", geqslant: "⩾", gescc: "⪩", ges: "⩾", gesdot: "⪀", gesdoto: "⪂", gesdotol: "⪄", gesl: "⋛︀", gesles: "⪔", Gfr: "𝔊", gfr: "𝔤", gg: "≫", Gg: "⋙", ggg: "⋙", gimel: "ℷ", GJcy: "Ѓ", gjcy: "ѓ", gla: "⪥", gl: "≷", glE: "⪒", glj: "⪤", gnap: "⪊", gnapprox: "⪊", gne: "⪈", gnE: "≩", gneq: "⪈", gneqq: "≩", gnsim: "⋧", Gopf: "𝔾", gopf: "𝕘", grave: "`", GreaterEqual: "≥", GreaterEqualLess: "⋛", GreaterFullEqual: "≧", GreaterGreater: "⪢", GreaterLess: "≷", GreaterSlantEqual: "⩾", GreaterTilde: "≳", Gscr: "𝒢", gscr: "ℊ", gsim: "≳", gsime: "⪎", gsiml: "⪐", gtcc: "⪧", gtcir: "⩺", gt: ">", GT: ">", Gt: "≫", gtdot: "⋗", gtlPar: "⦕", gtquest: "⩼", gtrapprox: "⪆", gtrarr: "⥸", gtrdot: "⋗", gtreqless: "⋛", gtreqqless: "⪌", gtrless: "≷", gtrsim: "≳", gvertneqq: "≩︀", gvnE: "≩︀", Hacek: "ˇ", hairsp: " ", half: "½", hamilt: "ℋ", HARDcy: "Ъ", hardcy: "ъ", harrcir: "⥈", harr: "↔", hArr: "⇔", harrw: "↭", Hat: "^", hbar: "ℏ", Hcirc: "Ĥ", hcirc: "ĥ", hearts: "♥", heartsuit: "♥", hellip: "…", hercon: "⊹", hfr: "𝔥", Hfr: "ℌ", HilbertSpace: "ℋ", hksearow: "⤥", hkswarow: "⤦", hoarr: "⇿", homtht: "∻", hookleftarrow: "↩", hookrightarrow: "↪", hopf: "𝕙", Hopf: "ℍ", horbar: "―", HorizontalLine: "─", hscr: "𝒽", Hscr: "ℋ", hslash: "ℏ", Hstrok: "Ħ", hstrok: "ħ", HumpDownHump: "≎", HumpEqual: "≏", hybull: "⁃", hyphen: "‐", Iacute: "Í", iacute: "í", ic: "⁣", Icirc: "Î", icirc: "î", Icy: "И", icy: "и", Idot: "İ", IEcy: "Е", iecy: "е", iexcl: "¡", iff: "⇔", ifr: "𝔦", Ifr: "ℑ", Igrave: "Ì", igrave: "ì", ii: "ⅈ", iiiint: "⨌", iiint: "∭", iinfin: "⧜", iiota: "℩", IJlig: "IJ", ijlig: "ij", Imacr: "Ī", imacr: "ī", image: "ℑ", ImaginaryI: "ⅈ", imagline: "ℐ", imagpart: "ℑ", imath: "ı", Im: "ℑ", imof: "⊷", imped: "Ƶ", Implies: "⇒", incare: "℅", in: "∈", infin: "∞", infintie: "⧝", inodot: "ı", intcal: "⊺", int: "∫", Int: "∬", integers: "ℤ", Integral: "∫", intercal: "⊺", Intersection: "⋂", intlarhk: "⨗", intprod: "⨼", InvisibleComma: "⁣", InvisibleTimes: "⁢", IOcy: "Ё", iocy: "ё", Iogon: "Į", iogon: "į", Iopf: "𝕀", iopf: "𝕚", Iota: "Ι", iota: "ι", iprod: "⨼", iquest: "¿", iscr: "𝒾", Iscr: "ℐ", isin: "∈", isindot: "⋵", isinE: "⋹", isins: "⋴", isinsv: "⋳", isinv: "∈", it: "⁢", Itilde: "Ĩ", itilde: "ĩ", Iukcy: "І", iukcy: "і", Iuml: "Ï", iuml: "ï", Jcirc: "Ĵ", jcirc: "ĵ", Jcy: "Й", jcy: "й", Jfr: "𝔍", jfr: "𝔧", jmath: "ȷ", Jopf: "𝕁", jopf: "𝕛", Jscr: "𝒥", jscr: "𝒿", Jsercy: "Ј", jsercy: "ј", Jukcy: "Є", jukcy: "є", Kappa: "Κ", kappa: "κ", kappav: "ϰ", Kcedil: "Ķ", kcedil: "ķ", Kcy: "К", kcy: "к", Kfr: "𝔎", kfr: "𝔨", kgreen: "ĸ", KHcy: "Х", khcy: "х", KJcy: "Ќ", kjcy: "ќ", Kopf: "𝕂", kopf: "𝕜", Kscr: "𝒦", kscr: "𝓀", lAarr: "⇚", Lacute: "Ĺ", lacute: "ĺ", laemptyv: "⦴", lagran: "ℒ", Lambda: "Λ", lambda: "λ", lang: "⟨", Lang: "⟪", langd: "⦑", langle: "⟨", lap: "⪅", Laplacetrf: "ℒ", laquo: "«", larrb: "⇤", larrbfs: "⤟", larr: "←", Larr: "↞", lArr: "⇐", larrfs: "⤝", larrhk: "↩", larrlp: "↫", larrpl: "⤹", larrsim: "⥳", larrtl: "↢", latail: "⤙", lAtail: "⤛", lat: "⪫", late: "⪭", lates: "⪭︀", lbarr: "⤌", lBarr: "⤎", lbbrk: "❲", lbrace: "{", lbrack: "[", lbrke: "⦋", lbrksld: "⦏", lbrkslu: "⦍", Lcaron: "Ľ", lcaron: "ľ", Lcedil: "Ļ", lcedil: "ļ", lceil: "⌈", lcub: "{", Lcy: "Л", lcy: "л", ldca: "⤶", ldquo: "“", ldquor: "„", ldrdhar: "⥧", ldrushar: "⥋", ldsh: "↲", le: "≤", lE: "≦", LeftAngleBracket: "⟨", LeftArrowBar: "⇤", leftarrow: "←", LeftArrow: "←", Leftarrow: "⇐", LeftArrowRightArrow: "⇆", leftarrowtail: "↢", LeftCeiling: "⌈", LeftDoubleBracket: "⟦", LeftDownTeeVector: "⥡", LeftDownVectorBar: "⥙", LeftDownVector: "⇃", LeftFloor: "⌊", leftharpoondown: "↽", leftharpoonup: "↼", leftleftarrows: "⇇", leftrightarrow: "↔", LeftRightArrow: "↔", Leftrightarrow: "⇔", leftrightarrows: "⇆", leftrightharpoons: "⇋", leftrightsquigarrow: "↭", LeftRightVector: "⥎", LeftTeeArrow: "↤", LeftTee: "⊣", LeftTeeVector: "⥚", leftthreetimes: "⋋", LeftTriangleBar: "⧏", LeftTriangle: "⊲", LeftTriangleEqual: "⊴", LeftUpDownVector: "⥑", LeftUpTeeVector: "⥠", LeftUpVectorBar: "⥘", LeftUpVector: "↿", LeftVectorBar: "⥒", LeftVector: "↼", lEg: "⪋", leg: "⋚", leq: "≤", leqq: "≦", leqslant: "⩽", lescc: "⪨", les: "⩽", lesdot: "⩿", lesdoto: "⪁", lesdotor: "⪃", lesg: "⋚︀", lesges: "⪓", lessapprox: "⪅", lessdot: "⋖", lesseqgtr: "⋚", lesseqqgtr: "⪋", LessEqualGreater: "⋚", LessFullEqual: "≦", LessGreater: "≶", lessgtr: "≶", LessLess: "⪡", lesssim: "≲", LessSlantEqual: "⩽", LessTilde: "≲", lfisht: "⥼", lfloor: "⌊", Lfr: "𝔏", lfr: "𝔩", lg: "≶", lgE: "⪑", lHar: "⥢", lhard: "↽", lharu: "↼", lharul: "⥪", lhblk: "▄", LJcy: "Љ", ljcy: "љ", llarr: "⇇", ll: "≪", Ll: "⋘", llcorner: "⌞", Lleftarrow: "⇚", llhard: "⥫", lltri: "◺", Lmidot: "Ŀ", lmidot: "ŀ", lmoustache: "⎰", lmoust: "⎰", lnap: "⪉", lnapprox: "⪉", lne: "⪇", lnE: "≨", lneq: "⪇", lneqq: "≨", lnsim: "⋦", loang: "⟬", loarr: "⇽", lobrk: "⟦", longleftarrow: "⟵", LongLeftArrow: "⟵", Longleftarrow: "⟸", longleftrightarrow: "⟷", LongLeftRightArrow: "⟷", Longleftrightarrow: "⟺", longmapsto: "⟼", longrightarrow: "⟶", LongRightArrow: "⟶", Longrightarrow: "⟹", looparrowleft: "↫", looparrowright: "↬", lopar: "⦅", Lopf: "𝕃", lopf: "𝕝", loplus: "⨭", lotimes: "⨴", lowast: "∗", lowbar: "_", LowerLeftArrow: "↙", LowerRightArrow: "↘", loz: "◊", lozenge: "◊", lozf: "⧫", lpar: "(", lparlt: "⦓", lrarr: "⇆", lrcorner: "⌟", lrhar: "⇋", lrhard: "⥭", lrm: "‎", lrtri: "⊿", lsaquo: "‹", lscr: "𝓁", Lscr: "ℒ", lsh: "↰", Lsh: "↰", lsim: "≲", lsime: "⪍", lsimg: "⪏", lsqb: "[", lsquo: "‘", lsquor: "‚", Lstrok: "Ł", lstrok: "ł", ltcc: "⪦", ltcir: "⩹", lt: "<", LT: "<", Lt: "≪", ltdot: "⋖", lthree: "⋋", ltimes: "⋉", ltlarr: "⥶", ltquest: "⩻", ltri: "◃", ltrie: "⊴", ltrif: "◂", ltrPar: "⦖", lurdshar: "⥊", luruhar: "⥦", lvertneqq: "≨︀", lvnE: "≨︀", macr: "¯", male: "♂", malt: "✠", maltese: "✠", Map: "⤅", map: "↦", mapsto: "↦", mapstodown: "↧", mapstoleft: "↤", mapstoup: "↥", marker: "▮", mcomma: "⨩", Mcy: "М", mcy: "м", mdash: "—", mDDot: "∺", measuredangle: "∡", MediumSpace: " ", Mellintrf: "ℳ", Mfr: "𝔐", mfr: "𝔪", mho: "℧", micro: "µ", midast: "*", midcir: "⫰", mid: "∣", middot: "·", minusb: "⊟", minus: "−", minusd: "∸", minusdu: "⨪", MinusPlus: "∓", mlcp: "⫛", mldr: "…", mnplus: "∓", models: "⊧", Mopf: "𝕄", mopf: "𝕞", mp: "∓", mscr: "𝓂", Mscr: "ℳ", mstpos: "∾", Mu: "Μ", mu: "μ", multimap: "⊸", mumap: "⊸", nabla: "∇", Nacute: "Ń", nacute: "ń", nang: "∠⃒", nap: "≉", napE: "⩰̸", napid: "≋̸", napos: "ʼn", napprox: "≉", natural: "♮", naturals: "ℕ", natur: "♮", nbsp: " ", nbump: "≎̸", nbumpe: "≏̸", ncap: "⩃", Ncaron: "Ň", ncaron: "ň", Ncedil: "Ņ", ncedil: "ņ", ncong: "≇", ncongdot: "⩭̸", ncup: "⩂", Ncy: "Н", ncy: "н", ndash: "–", nearhk: "⤤", nearr: "↗", neArr: "⇗", nearrow: "↗", ne: "≠", nedot: "≐̸", NegativeMediumSpace: "​", NegativeThickSpace: "​", NegativeThinSpace: "​", NegativeVeryThinSpace: "​", nequiv: "≢", nesear: "⤨", nesim: "≂̸", NestedGreaterGreater: "≫", NestedLessLess: "≪", NewLine: `
+`, nexist: "∄", nexists: "∄", Nfr: "𝔑", nfr: "𝔫", ngE: "≧̸", nge: "≱", ngeq: "≱", ngeqq: "≧̸", ngeqslant: "⩾̸", nges: "⩾̸", nGg: "⋙̸", ngsim: "≵", nGt: "≫⃒", ngt: "≯", ngtr: "≯", nGtv: "≫̸", nharr: "↮", nhArr: "⇎", nhpar: "⫲", ni: "∋", nis: "⋼", nisd: "⋺", niv: "∋", NJcy: "Њ", njcy: "њ", nlarr: "↚", nlArr: "⇍", nldr: "‥", nlE: "≦̸", nle: "≰", nleftarrow: "↚", nLeftarrow: "⇍", nleftrightarrow: "↮", nLeftrightarrow: "⇎", nleq: "≰", nleqq: "≦̸", nleqslant: "⩽̸", nles: "⩽̸", nless: "≮", nLl: "⋘̸", nlsim: "≴", nLt: "≪⃒", nlt: "≮", nltri: "⋪", nltrie: "⋬", nLtv: "≪̸", nmid: "∤", NoBreak: "⁠", NonBreakingSpace: " ", nopf: "𝕟", Nopf: "ℕ", Not: "⫬", not: "¬", NotCongruent: "≢", NotCupCap: "≭", NotDoubleVerticalBar: "∦", NotElement: "∉", NotEqual: "≠", NotEqualTilde: "≂̸", NotExists: "∄", NotGreater: "≯", NotGreaterEqual: "≱", NotGreaterFullEqual: "≧̸", NotGreaterGreater: "≫̸", NotGreaterLess: "≹", NotGreaterSlantEqual: "⩾̸", NotGreaterTilde: "≵", NotHumpDownHump: "≎̸", NotHumpEqual: "≏̸", notin: "∉", notindot: "⋵̸", notinE: "⋹̸", notinva: "∉", notinvb: "⋷", notinvc: "⋶", NotLeftTriangleBar: "⧏̸", NotLeftTriangle: "⋪", NotLeftTriangleEqual: "⋬", NotLess: "≮", NotLessEqual: "≰", NotLessGreater: "≸", NotLessLess: "≪̸", NotLessSlantEqual: "⩽̸", NotLessTilde: "≴", NotNestedGreaterGreater: "⪢̸", NotNestedLessLess: "⪡̸", notni: "∌", notniva: "∌", notnivb: "⋾", notnivc: "⋽", NotPrecedes: "⊀", NotPrecedesEqual: "⪯̸", NotPrecedesSlantEqual: "⋠", NotReverseElement: "∌", NotRightTriangleBar: "⧐̸", NotRightTriangle: "⋫", NotRightTriangleEqual: "⋭", NotSquareSubset: "⊏̸", NotSquareSubsetEqual: "⋢", NotSquareSuperset: "⊐̸", NotSquareSupersetEqual: "⋣", NotSubset: "⊂⃒", NotSubsetEqual: "⊈", NotSucceeds: "⊁", NotSucceedsEqual: "⪰̸", NotSucceedsSlantEqual: "⋡", NotSucceedsTilde: "≿̸", NotSuperset: "⊃⃒", NotSupersetEqual: "⊉", NotTilde: "≁", NotTildeEqual: "≄", NotTildeFullEqual: "≇", NotTildeTilde: "≉", NotVerticalBar: "∤", nparallel: "∦", npar: "∦", nparsl: "⫽⃥", npart: "∂̸", npolint: "⨔", npr: "⊀", nprcue: "⋠", nprec: "⊀", npreceq: "⪯̸", npre: "⪯̸", nrarrc: "⤳̸", nrarr: "↛", nrArr: "⇏", nrarrw: "↝̸", nrightarrow: "↛", nRightarrow: "⇏", nrtri: "⋫", nrtrie: "⋭", nsc: "⊁", nsccue: "⋡", nsce: "⪰̸", Nscr: "𝒩", nscr: "𝓃", nshortmid: "∤", nshortparallel: "∦", nsim: "≁", nsime: "≄", nsimeq: "≄", nsmid: "∤", nspar: "∦", nsqsube: "⋢", nsqsupe: "⋣", nsub: "⊄", nsubE: "⫅̸", nsube: "⊈", nsubset: "⊂⃒", nsubseteq: "⊈", nsubseteqq: "⫅̸", nsucc: "⊁", nsucceq: "⪰̸", nsup: "⊅", nsupE: "⫆̸", nsupe: "⊉", nsupset: "⊃⃒", nsupseteq: "⊉", nsupseteqq: "⫆̸", ntgl: "≹", Ntilde: "Ñ", ntilde: "ñ", ntlg: "≸", ntriangleleft: "⋪", ntrianglelefteq: "⋬", ntriangleright: "⋫", ntrianglerighteq: "⋭", Nu: "Ν", nu: "ν", num: "#", numero: "№", numsp: " ", nvap: "≍⃒", nvdash: "⊬", nvDash: "⊭", nVdash: "⊮", nVDash: "⊯", nvge: "≥⃒", nvgt: ">⃒", nvHarr: "⤄", nvinfin: "⧞", nvlArr: "⤂", nvle: "≤⃒", nvlt: "<⃒", nvltrie: "⊴⃒", nvrArr: "⤃", nvrtrie: "⊵⃒", nvsim: "∼⃒", nwarhk: "⤣", nwarr: "↖", nwArr: "⇖", nwarrow: "↖", nwnear: "⤧", Oacute: "Ó", oacute: "ó", oast: "⊛", Ocirc: "Ô", ocirc: "ô", ocir: "⊚", Ocy: "О", ocy: "о", odash: "⊝", Odblac: "Ő", odblac: "ő", odiv: "⨸", odot: "⊙", odsold: "⦼", OElig: "Œ", oelig: "œ", ofcir: "⦿", Ofr: "𝔒", ofr: "𝔬", ogon: "˛", Ograve: "Ò", ograve: "ò", ogt: "⧁", ohbar: "⦵", ohm: "Ω", oint: "∮", olarr: "↺", olcir: "⦾", olcross: "⦻", oline: "‾", olt: "⧀", Omacr: "Ō", omacr: "ō", Omega: "Ω", omega: "ω", Omicron: "Ο", omicron: "ο", omid: "⦶", ominus: "⊖", Oopf: "𝕆", oopf: "𝕠", opar: "⦷", OpenCurlyDoubleQuote: "“", OpenCurlyQuote: "‘", operp: "⦹", oplus: "⊕", orarr: "↻", Or: "⩔", or: "∨", ord: "⩝", order: "ℴ", orderof: "ℴ", ordf: "ª", ordm: "º", origof: "⊶", oror: "⩖", orslope: "⩗", orv: "⩛", oS: "Ⓢ", Oscr: "𝒪", oscr: "ℴ", Oslash: "Ø", oslash: "ø", osol: "⊘", Otilde: "Õ", otilde: "õ", otimesas: "⨶", Otimes: "⨷", otimes: "⊗", Ouml: "Ö", ouml: "ö", ovbar: "⌽", OverBar: "‾", OverBrace: "⏞", OverBracket: "⎴", OverParenthesis: "⏜", para: "¶", parallel: "∥", par: "∥", parsim: "⫳", parsl: "⫽", part: "∂", PartialD: "∂", Pcy: "П", pcy: "п", percnt: "%", period: ".", permil: "‰", perp: "⊥", pertenk: "‱", Pfr: "𝔓", pfr: "𝔭", Phi: "Φ", phi: "φ", phiv: "ϕ", phmmat: "ℳ", phone: "☎", Pi: "Π", pi: "π", pitchfork: "⋔", piv: "ϖ", planck: "ℏ", planckh: "ℎ", plankv: "ℏ", plusacir: "⨣", plusb: "⊞", pluscir: "⨢", plus: "+", plusdo: "∔", plusdu: "⨥", pluse: "⩲", PlusMinus: "±", plusmn: "±", plussim: "⨦", plustwo: "⨧", pm: "±", Poincareplane: "ℌ", pointint: "⨕", popf: "𝕡", Popf: "ℙ", pound: "£", prap: "⪷", Pr: "⪻", pr: "≺", prcue: "≼", precapprox: "⪷", prec: "≺", preccurlyeq: "≼", Precedes: "≺", PrecedesEqual: "⪯", PrecedesSlantEqual: "≼", PrecedesTilde: "≾", preceq: "⪯", precnapprox: "⪹", precneqq: "⪵", precnsim: "⋨", pre: "⪯", prE: "⪳", precsim: "≾", prime: "′", Prime: "″", primes: "ℙ", prnap: "⪹", prnE: "⪵", prnsim: "⋨", prod: "∏", Product: "∏", profalar: "⌮", profline: "⌒", profsurf: "⌓", prop: "∝", Proportional: "∝", Proportion: "∷", propto: "∝", prsim: "≾", prurel: "⊰", Pscr: "𝒫", pscr: "𝓅", Psi: "Ψ", psi: "ψ", puncsp: " ", Qfr: "𝔔", qfr: "𝔮", qint: "⨌", qopf: "𝕢", Qopf: "ℚ", qprime: "⁗", Qscr: "𝒬", qscr: "𝓆", quaternions: "ℍ", quatint: "⨖", quest: "?", questeq: "≟", quot: '"', QUOT: '"', rAarr: "⇛", race: "∽̱", Racute: "Ŕ", racute: "ŕ", radic: "√", raemptyv: "⦳", rang: "⟩", Rang: "⟫", rangd: "⦒", range: "⦥", rangle: "⟩", raquo: "»", rarrap: "⥵", rarrb: "⇥", rarrbfs: "⤠", rarrc: "⤳", rarr: "→", Rarr: "↠", rArr: "⇒", rarrfs: "⤞", rarrhk: "↪", rarrlp: "↬", rarrpl: "⥅", rarrsim: "⥴", Rarrtl: "⤖", rarrtl: "↣", rarrw: "↝", ratail: "⤚", rAtail: "⤜", ratio: "∶", rationals: "ℚ", rbarr: "⤍", rBarr: "⤏", RBarr: "⤐", rbbrk: "❳", rbrace: "}", rbrack: "]", rbrke: "⦌", rbrksld: "⦎", rbrkslu: "⦐", Rcaron: "Ř", rcaron: "ř", Rcedil: "Ŗ", rcedil: "ŗ", rceil: "⌉", rcub: "}", Rcy: "Р", rcy: "р", rdca: "⤷", rdldhar: "⥩", rdquo: "”", rdquor: "”", rdsh: "↳", real: "ℜ", realine: "ℛ", realpart: "ℜ", reals: "ℝ", Re: "ℜ", rect: "▭", reg: "®", REG: "®", ReverseElement: "∋", ReverseEquilibrium: "⇋", ReverseUpEquilibrium: "⥯", rfisht: "⥽", rfloor: "⌋", rfr: "𝔯", Rfr: "ℜ", rHar: "⥤", rhard: "⇁", rharu: "⇀", rharul: "⥬", Rho: "Ρ", rho: "ρ", rhov: "ϱ", RightAngleBracket: "⟩", RightArrowBar: "⇥", rightarrow: "→", RightArrow: "→", Rightarrow: "⇒", RightArrowLeftArrow: "⇄", rightarrowtail: "↣", RightCeiling: "⌉", RightDoubleBracket: "⟧", RightDownTeeVector: "⥝", RightDownVectorBar: "⥕", RightDownVector: "⇂", RightFloor: "⌋", rightharpoondown: "⇁", rightharpoonup: "⇀", rightleftarrows: "⇄", rightleftharpoons: "⇌", rightrightarrows: "⇉", rightsquigarrow: "↝", RightTeeArrow: "↦", RightTee: "⊢", RightTeeVector: "⥛", rightthreetimes: "⋌", RightTriangleBar: "⧐", RightTriangle: "⊳", RightTriangleEqual: "⊵", RightUpDownVector: "⥏", RightUpTeeVector: "⥜", RightUpVectorBar: "⥔", RightUpVector: "↾", RightVectorBar: "⥓", RightVector: "⇀", ring: "˚", risingdotseq: "≓", rlarr: "⇄", rlhar: "⇌", rlm: "‏", rmoustache: "⎱", rmoust: "⎱", rnmid: "⫮", roang: "⟭", roarr: "⇾", robrk: "⟧", ropar: "⦆", ropf: "𝕣", Ropf: "ℝ", roplus: "⨮", rotimes: "⨵", RoundImplies: "⥰", rpar: ")", rpargt: "⦔", rppolint: "⨒", rrarr: "⇉", Rrightarrow: "⇛", rsaquo: "›", rscr: "𝓇", Rscr: "ℛ", rsh: "↱", Rsh: "↱", rsqb: "]", rsquo: "’", rsquor: "’", rthree: "⋌", rtimes: "⋊", rtri: "▹", rtrie: "⊵", rtrif: "▸", rtriltri: "⧎", RuleDelayed: "⧴", ruluhar: "⥨", rx: "℞", Sacute: "Ś", sacute: "ś", sbquo: "‚", scap: "⪸", Scaron: "Š", scaron: "š", Sc: "⪼", sc: "≻", sccue: "≽", sce: "⪰", scE: "⪴", Scedil: "Ş", scedil: "ş", Scirc: "Ŝ", scirc: "ŝ", scnap: "⪺", scnE: "⪶", scnsim: "⋩", scpolint: "⨓", scsim: "≿", Scy: "С", scy: "с", sdotb: "⊡", sdot: "⋅", sdote: "⩦", searhk: "⤥", searr: "↘", seArr: "⇘", searrow: "↘", sect: "§", semi: ";", seswar: "⤩", setminus: "∖", setmn: "∖", sext: "✶", Sfr: "𝔖", sfr: "𝔰", sfrown: "⌢", sharp: "♯", SHCHcy: "Щ", shchcy: "щ", SHcy: "Ш", shcy: "ш", ShortDownArrow: "↓", ShortLeftArrow: "←", shortmid: "∣", shortparallel: "∥", ShortRightArrow: "→", ShortUpArrow: "↑", shy: "­", Sigma: "Σ", sigma: "σ", sigmaf: "ς", sigmav: "ς", sim: "∼", simdot: "⩪", sime: "≃", simeq: "≃", simg: "⪞", simgE: "⪠", siml: "⪝", simlE: "⪟", simne: "≆", simplus: "⨤", simrarr: "⥲", slarr: "←", SmallCircle: "∘", smallsetminus: "∖", smashp: "⨳", smeparsl: "⧤", smid: "∣", smile: "⌣", smt: "⪪", smte: "⪬", smtes: "⪬︀", SOFTcy: "Ь", softcy: "ь", solbar: "⌿", solb: "⧄", sol: "/", Sopf: "𝕊", sopf: "𝕤", spades: "♠", spadesuit: "♠", spar: "∥", sqcap: "⊓", sqcaps: "⊓︀", sqcup: "⊔", sqcups: "⊔︀", Sqrt: "√", sqsub: "⊏", sqsube: "⊑", sqsubset: "⊏", sqsubseteq: "⊑", sqsup: "⊐", sqsupe: "⊒", sqsupset: "⊐", sqsupseteq: "⊒", square: "□", Square: "□", SquareIntersection: "⊓", SquareSubset: "⊏", SquareSubsetEqual: "⊑", SquareSuperset: "⊐", SquareSupersetEqual: "⊒", SquareUnion: "⊔", squarf: "▪", squ: "□", squf: "▪", srarr: "→", Sscr: "𝒮", sscr: "𝓈", ssetmn: "∖", ssmile: "⌣", sstarf: "⋆", Star: "⋆", star: "☆", starf: "★", straightepsilon: "ϵ", straightphi: "ϕ", strns: "¯", sub: "⊂", Sub: "⋐", subdot: "⪽", subE: "⫅", sube: "⊆", subedot: "⫃", submult: "⫁", subnE: "⫋", subne: "⊊", subplus: "⪿", subrarr: "⥹", subset: "⊂", Subset: "⋐", subseteq: "⊆", subseteqq: "⫅", SubsetEqual: "⊆", subsetneq: "⊊", subsetneqq: "⫋", subsim: "⫇", subsub: "⫕", subsup: "⫓", succapprox: "⪸", succ: "≻", succcurlyeq: "≽", Succeeds: "≻", SucceedsEqual: "⪰", SucceedsSlantEqual: "≽", SucceedsTilde: "≿", succeq: "⪰", succnapprox: "⪺", succneqq: "⪶", succnsim: "⋩", succsim: "≿", SuchThat: "∋", sum: "∑", Sum: "∑", sung: "♪", sup1: "¹", sup2: "²", sup3: "³", sup: "⊃", Sup: "⋑", supdot: "⪾", supdsub: "⫘", supE: "⫆", supe: "⊇", supedot: "⫄", Superset: "⊃", SupersetEqual: "⊇", suphsol: "⟉", suphsub: "⫗", suplarr: "⥻", supmult: "⫂", supnE: "⫌", supne: "⊋", supplus: "⫀", supset: "⊃", Supset: "⋑", supseteq: "⊇", supseteqq: "⫆", supsetneq: "⊋", supsetneqq: "⫌", supsim: "⫈", supsub: "⫔", supsup: "⫖", swarhk: "⤦", swarr: "↙", swArr: "⇙", swarrow: "↙", swnwar: "⤪", szlig: "ß", Tab: "	", target: "⌖", Tau: "Τ", tau: "τ", tbrk: "⎴", Tcaron: "Ť", tcaron: "ť", Tcedil: "Ţ", tcedil: "ţ", Tcy: "Т", tcy: "т", tdot: "⃛", telrec: "⌕", Tfr: "𝔗", tfr: "𝔱", there4: "∴", therefore: "∴", Therefore: "∴", Theta: "Θ", theta: "θ", thetasym: "ϑ", thetav: "ϑ", thickapprox: "≈", thicksim: "∼", ThickSpace: "  ", ThinSpace: " ", thinsp: " ", thkap: "≈", thksim: "∼", THORN: "Þ", thorn: "þ", tilde: "˜", Tilde: "∼", TildeEqual: "≃", TildeFullEqual: "≅", TildeTilde: "≈", timesbar: "⨱", timesb: "⊠", times: "×", timesd: "⨰", tint: "∭", toea: "⤨", topbot: "⌶", topcir: "⫱", top: "⊤", Topf: "𝕋", topf: "𝕥", topfork: "⫚", tosa: "⤩", tprime: "‴", trade: "™", TRADE: "™", triangle: "▵", triangledown: "▿", triangleleft: "◃", trianglelefteq: "⊴", triangleq: "≜", triangleright: "▹", trianglerighteq: "⊵", tridot: "◬", trie: "≜", triminus: "⨺", TripleDot: "⃛", triplus: "⨹", trisb: "⧍", tritime: "⨻", trpezium: "⏢", Tscr: "𝒯", tscr: "𝓉", TScy: "Ц", tscy: "ц", TSHcy: "Ћ", tshcy: "ћ", Tstrok: "Ŧ", tstrok: "ŧ", twixt: "≬", twoheadleftarrow: "↞", twoheadrightarrow: "↠", Uacute: "Ú", uacute: "ú", uarr: "↑", Uarr: "↟", uArr: "⇑", Uarrocir: "⥉", Ubrcy: "Ў", ubrcy: "ў", Ubreve: "Ŭ", ubreve: "ŭ", Ucirc: "Û", ucirc: "û", Ucy: "У", ucy: "у", udarr: "⇅", Udblac: "Ű", udblac: "ű", udhar: "⥮", ufisht: "⥾", Ufr: "𝔘", ufr: "𝔲", Ugrave: "Ù", ugrave: "ù", uHar: "⥣", uharl: "↿", uharr: "↾", uhblk: "▀", ulcorn: "⌜", ulcorner: "⌜", ulcrop: "⌏", ultri: "◸", Umacr: "Ū", umacr: "ū", uml: "¨", UnderBar: "_", UnderBrace: "⏟", UnderBracket: "⎵", UnderParenthesis: "⏝", Union: "⋃", UnionPlus: "⊎", Uogon: "Ų", uogon: "ų", Uopf: "𝕌", uopf: "𝕦", UpArrowBar: "⤒", uparrow: "↑", UpArrow: "↑", Uparrow: "⇑", UpArrowDownArrow: "⇅", updownarrow: "↕", UpDownArrow: "↕", Updownarrow: "⇕", UpEquilibrium: "⥮", upharpoonleft: "↿", upharpoonright: "↾", uplus: "⊎", UpperLeftArrow: "↖", UpperRightArrow: "↗", upsi: "υ", Upsi: "ϒ", upsih: "ϒ", Upsilon: "Υ", upsilon: "υ", UpTeeArrow: "↥", UpTee: "⊥", upuparrows: "⇈", urcorn: "⌝", urcorner: "⌝", urcrop: "⌎", Uring: "Ů", uring: "ů", urtri: "◹", Uscr: "𝒰", uscr: "𝓊", utdot: "⋰", Utilde: "Ũ", utilde: "ũ", utri: "▵", utrif: "▴", uuarr: "⇈", Uuml: "Ü", uuml: "ü", uwangle: "⦧", vangrt: "⦜", varepsilon: "ϵ", varkappa: "ϰ", varnothing: "∅", varphi: "ϕ", varpi: "ϖ", varpropto: "∝", varr: "↕", vArr: "⇕", varrho: "ϱ", varsigma: "ς", varsubsetneq: "⊊︀", varsubsetneqq: "⫋︀", varsupsetneq: "⊋︀", varsupsetneqq: "⫌︀", vartheta: "ϑ", vartriangleleft: "⊲", vartriangleright: "⊳", vBar: "⫨", Vbar: "⫫", vBarv: "⫩", Vcy: "В", vcy: "в", vdash: "⊢", vDash: "⊨", Vdash: "⊩", VDash: "⊫", Vdashl: "⫦", veebar: "⊻", vee: "∨", Vee: "⋁", veeeq: "≚", vellip: "⋮", verbar: "|", Verbar: "‖", vert: "|", Vert: "‖", VerticalBar: "∣", VerticalLine: "|", VerticalSeparator: "❘", VerticalTilde: "≀", VeryThinSpace: " ", Vfr: "𝔙", vfr: "𝔳", vltri: "⊲", vnsub: "⊂⃒", vnsup: "⊃⃒", Vopf: "𝕍", vopf: "𝕧", vprop: "∝", vrtri: "⊳", Vscr: "𝒱", vscr: "𝓋", vsubnE: "⫋︀", vsubne: "⊊︀", vsupnE: "⫌︀", vsupne: "⊋︀", Vvdash: "⊪", vzigzag: "⦚", Wcirc: "Ŵ", wcirc: "ŵ", wedbar: "⩟", wedge: "∧", Wedge: "⋀", wedgeq: "≙", weierp: "℘", Wfr: "𝔚", wfr: "𝔴", Wopf: "𝕎", wopf: "𝕨", wp: "℘", wr: "≀", wreath: "≀", Wscr: "𝒲", wscr: "𝓌", xcap: "⋂", xcirc: "◯", xcup: "⋃", xdtri: "▽", Xfr: "𝔛", xfr: "𝔵", xharr: "⟷", xhArr: "⟺", Xi: "Ξ", xi: "ξ", xlarr: "⟵", xlArr: "⟸", xmap: "⟼", xnis: "⋻", xodot: "⨀", Xopf: "𝕏", xopf: "𝕩", xoplus: "⨁", xotime: "⨂", xrarr: "⟶", xrArr: "⟹", Xscr: "𝒳", xscr: "𝓍", xsqcup: "⨆", xuplus: "⨄", xutri: "△", xvee: "⋁", xwedge: "⋀", Yacute: "Ý", yacute: "ý", YAcy: "Я", yacy: "я", Ycirc: "Ŷ", ycirc: "ŷ", Ycy: "Ы", ycy: "ы", yen: "¥", Yfr: "𝔜", yfr: "𝔶", YIcy: "Ї", yicy: "ї", Yopf: "𝕐", yopf: "𝕪", Yscr: "𝒴", yscr: "𝓎", YUcy: "Ю", yucy: "ю", yuml: "ÿ", Yuml: "Ÿ", Zacute: "Ź", zacute: "ź", Zcaron: "Ž", zcaron: "ž", Zcy: "З", zcy: "з", Zdot: "Ż", zdot: "ż", zeetrf: "ℨ", ZeroWidthSpace: "​", Zeta: "Ζ", zeta: "ζ", zfr: "𝔷", Zfr: "ℨ", ZHcy: "Ж", zhcy: "ж", zigrarr: "⇝", zopf: "𝕫", Zopf: "ℤ", Zscr: "𝒵", zscr: "𝓏", zwj: "‍", zwnj: "‌" };
+  }
+}), Su = $({
+  "../node_modules/entities/lib/maps/legacy.json"(t, u) {
+    u.exports = { Aacute: "Á", aacute: "á", Acirc: "Â", acirc: "â", acute: "´", AElig: "Æ", aelig: "æ", Agrave: "À", agrave: "à", amp: "&", AMP: "&", Aring: "Å", aring: "å", Atilde: "Ã", atilde: "ã", Auml: "Ä", auml: "ä", brvbar: "¦", Ccedil: "Ç", ccedil: "ç", cedil: "¸", cent: "¢", copy: "©", COPY: "©", curren: "¤", deg: "°", divide: "÷", Eacute: "É", eacute: "é", Ecirc: "Ê", ecirc: "ê", Egrave: "È", egrave: "è", ETH: "Ð", eth: "ð", Euml: "Ë", euml: "ë", frac12: "½", frac14: "¼", frac34: "¾", gt: ">", GT: ">", Iacute: "Í", iacute: "í", Icirc: "Î", icirc: "î", iexcl: "¡", Igrave: "Ì", igrave: "ì", iquest: "¿", Iuml: "Ï", iuml: "ï", laquo: "«", lt: "<", LT: "<", macr: "¯", micro: "µ", middot: "·", nbsp: " ", not: "¬", Ntilde: "Ñ", ntilde: "ñ", Oacute: "Ó", oacute: "ó", Ocirc: "Ô", ocirc: "ô", Ograve: "Ò", ograve: "ò", ordf: "ª", ordm: "º", Oslash: "Ø", oslash: "ø", Otilde: "Õ", otilde: "õ", Ouml: "Ö", ouml: "ö", para: "¶", plusmn: "±", pound: "£", quot: '"', QUOT: '"', raquo: "»", reg: "®", REG: "®", sect: "§", shy: "­", sup1: "¹", sup2: "²", sup3: "³", szlig: "ß", THORN: "Þ", thorn: "þ", times: "×", Uacute: "Ú", uacute: "ú", Ucirc: "Û", ucirc: "û", Ugrave: "Ù", ugrave: "ù", uml: "¨", Uuml: "Ü", uuml: "ü", Yacute: "Ý", yacute: "ý", yen: "¥", yuml: "ÿ" };
+  }
+}), Bt = $({
+  "../node_modules/entities/lib/maps/xml.json"(t, u) {
+    u.exports = { amp: "&", apos: "'", gt: ">", lt: "<", quot: '"' };
+  }
+}), Ju = $({
+  "../node_modules/entities/lib/maps/decode.json"(t, u) {
+    u.exports = { 0: 65533, 128: 8364, 130: 8218, 131: 402, 132: 8222, 133: 8230, 134: 8224, 135: 8225, 136: 710, 137: 8240, 138: 352, 139: 8249, 140: 338, 142: 381, 145: 8216, 146: 8217, 147: 8220, 148: 8221, 149: 8226, 150: 8211, 151: 8212, 152: 732, 153: 8482, 154: 353, 155: 8250, 156: 339, 158: 382, 159: 376 };
+  }
+}), Nu = $({
+  "../node_modules/entities/lib/decode_codepoint.js"(t) {
+    var u = t && t.__importDefault || function(i) {
+      return i && i.__esModule ? i : { default: i };
+    };
+    Object.defineProperty(t, "__esModule", { value: !0 });
+    var n = u(Ju()), o = (
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      String.fromCodePoint || function(i) {
+        var p = "";
+        return i > 65535 && (i -= 65536, p += String.fromCharCode(i >>> 10 & 1023 | 55296), i = 56320 | i & 1023), p += String.fromCharCode(i), p;
+      }
+    );
+    function s(i) {
+      return i >= 55296 && i <= 57343 || i > 1114111 ? "�" : (i in n.default && (i = n.default[i]), o(i));
+    }
+    t.default = s;
+  }
+}), ot = $({
+  "../node_modules/entities/lib/decode.js"(t) {
+    var u = t && t.__importDefault || function(b) {
+      return b && b.__esModule ? b : { default: b };
+    };
+    Object.defineProperty(t, "__esModule", { value: !0 }), t.decodeHTML = t.decodeHTMLStrict = t.decodeXML = void 0;
+    var n = u(Ft()), o = u(Su()), s = u(Bt()), i = u(Nu()), p = /&(?:[a-zA-Z0-9]+|#[xX][\da-fA-F]+|#\d+);/g;
+    t.decodeXML = d(s.default), t.decodeHTMLStrict = d(n.default);
+    function d(b) {
+      var D = f(b);
+      return function(v) {
+        return String(v).replace(p, D);
+      };
+    }
+    var m = function(b, D) {
+      return b < D ? 1 : -1;
+    };
+    t.decodeHTML = (function() {
+      for (var b = Object.keys(o.default).sort(m), D = Object.keys(n.default).sort(m), v = 0, C = 0; v < D.length; v++)
+        b[C] === D[v] ? (D[v] += ";?", C++) : D[v] += ";";
+      var F = new RegExp("&(?:" + D.join("|") + "|#[xX][\\da-fA-F]+;?|#\\d+;?)", "g"), w = f(n.default);
+      function L(O) {
+        return O.substr(-1) !== ";" && (O += ";"), w(O);
+      }
+      return function(O) {
+        return String(O).replace(F, L);
+      };
+    })();
+    function f(b) {
+      return function(D) {
+        if (D.charAt(1) === "#") {
+          var v = D.charAt(2);
+          return v === "X" || v === "x" ? i.default(parseInt(D.substr(3), 16)) : i.default(parseInt(D.substr(2), 10));
+        }
+        return b[D.slice(1, -1)] || D;
+      };
+    }
+  }
+}), it = $({
+  "../node_modules/entities/lib/encode.js"(t) {
+    var u = t && t.__importDefault || function(x) {
+      return x && x.__esModule ? x : { default: x };
+    };
+    Object.defineProperty(t, "__esModule", { value: !0 }), t.escapeUTF8 = t.escape = t.encodeNonAsciiHTML = t.encodeHTML = t.encodeXML = void 0;
+    var n = u(Bt()), o = m(n.default), s = f(o);
+    t.encodeXML = O(o);
+    var i = u(Ft()), p = m(i.default), d = f(p);
+    t.encodeHTML = C(p, d), t.encodeNonAsciiHTML = O(p);
+    function m(x) {
+      return Object.keys(x).sort().reduce(function(P, N) {
+        return P[x[N]] = "&" + N + ";", P;
+      }, {});
+    }
+    function f(x) {
+      for (var P = [], N = [], Y = 0, S = Object.keys(x); Y < S.length; Y++) {
+        var U = S[Y];
+        U.length === 1 ? P.push("\\" + U) : N.push(U);
+      }
+      P.sort();
+      for (var R = 0; R < P.length - 1; R++) {
+        for (var q = R; q < P.length - 1 && P[q].charCodeAt(1) + 1 === P[q + 1].charCodeAt(1); )
+          q += 1;
+        var _ = 1 + q - R;
+        _ < 3 || P.splice(R, _, P[R] + "-" + P[q]);
+      }
+      return N.unshift("[" + P.join("") + "]"), new RegExp(N.join("|"), "g");
+    }
+    var b = /(?:[\x80-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])/g, D = (
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      String.prototype.codePointAt != null ? (
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        (function(x) {
+          return x.codePointAt(0);
+        })
+      ) : (
+        // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+        (function(x) {
+          return (x.charCodeAt(0) - 55296) * 1024 + x.charCodeAt(1) - 56320 + 65536;
+        })
+      )
+    );
+    function v(x) {
+      return "&#x" + (x.length > 1 ? D(x) : x.charCodeAt(0)).toString(16).toUpperCase() + ";";
+    }
+    function C(x, P) {
+      return function(N) {
+        return N.replace(P, function(Y) {
+          return x[Y];
+        }).replace(b, v);
+      };
+    }
+    var F = new RegExp(s.source + "|" + b.source, "g");
+    function w(x) {
+      return x.replace(F, v);
+    }
+    t.escape = w;
+    function L(x) {
+      return x.replace(s, v);
+    }
+    t.escapeUTF8 = L;
+    function O(x) {
+      return function(P) {
+        return P.replace(F, function(N) {
+          return x[N] || v(N);
+        });
+      };
+    }
+  }
+}), Ou = $({
+  "../node_modules/entities/lib/index.js"(t) {
+    Object.defineProperty(t, "__esModule", { value: !0 }), t.decodeXMLStrict = t.decodeHTML5Strict = t.decodeHTML4Strict = t.decodeHTML5 = t.decodeHTML4 = t.decodeHTMLStrict = t.decodeHTML = t.decodeXML = t.encodeHTML5 = t.encodeHTML4 = t.escapeUTF8 = t.escape = t.encodeNonAsciiHTML = t.encodeHTML = t.encodeXML = t.encode = t.decodeStrict = t.decode = void 0;
+    var u = ot(), n = it();
+    function o(m, f) {
+      return (!f || f <= 0 ? u.decodeXML : u.decodeHTML)(m);
+    }
+    t.decode = o;
+    function s(m, f) {
+      return (!f || f <= 0 ? u.decodeXML : u.decodeHTMLStrict)(m);
+    }
+    t.decodeStrict = s;
+    function i(m, f) {
+      return (!f || f <= 0 ? n.encodeXML : n.encodeHTML)(m);
+    }
+    t.encode = i;
+    var p = it();
+    Object.defineProperty(t, "encodeXML", { enumerable: !0, get: function() {
+      return p.encodeXML;
+    } }), Object.defineProperty(t, "encodeHTML", { enumerable: !0, get: function() {
+      return p.encodeHTML;
+    } }), Object.defineProperty(t, "encodeNonAsciiHTML", { enumerable: !0, get: function() {
+      return p.encodeNonAsciiHTML;
+    } }), Object.defineProperty(t, "escape", { enumerable: !0, get: function() {
+      return p.escape;
+    } }), Object.defineProperty(t, "escapeUTF8", { enumerable: !0, get: function() {
+      return p.escapeUTF8;
+    } }), Object.defineProperty(t, "encodeHTML4", { enumerable: !0, get: function() {
+      return p.encodeHTML;
+    } }), Object.defineProperty(t, "encodeHTML5", { enumerable: !0, get: function() {
+      return p.encodeHTML;
+    } });
+    var d = ot();
+    Object.defineProperty(t, "decodeXML", { enumerable: !0, get: function() {
+      return d.decodeXML;
+    } }), Object.defineProperty(t, "decodeHTML", { enumerable: !0, get: function() {
+      return d.decodeHTML;
+    } }), Object.defineProperty(t, "decodeHTMLStrict", { enumerable: !0, get: function() {
+      return d.decodeHTMLStrict;
+    } }), Object.defineProperty(t, "decodeHTML4", { enumerable: !0, get: function() {
+      return d.decodeHTML;
+    } }), Object.defineProperty(t, "decodeHTML5", { enumerable: !0, get: function() {
+      return d.decodeHTML;
+    } }), Object.defineProperty(t, "decodeHTML4Strict", { enumerable: !0, get: function() {
+      return d.decodeHTMLStrict;
+    } }), Object.defineProperty(t, "decodeHTML5Strict", { enumerable: !0, get: function() {
+      return d.decodeHTMLStrict;
+    } }), Object.defineProperty(t, "decodeXMLStrict", { enumerable: !0, get: function() {
+      return d.decodeXML;
+    } });
+  }
+}), Pu = $({
+  "../node_modules/ansi-to-html/lib/ansi_to_html.js"(t, u) {
+    function n(c, y) {
+      if (!(c instanceof y))
+        throw new TypeError("Cannot call a class as a function");
+    }
+    function o(c, y) {
+      for (var h = 0; h < y.length; h++) {
+        var A = y[h];
+        A.enumerable = A.enumerable || !1, A.configurable = !0, "value" in A && (A.writable = !0), Object.defineProperty(c, A.key, A);
+      }
+    }
+    function s(c, y, h) {
+      return y && o(c.prototype, y), c;
+    }
+    function i(c, y) {
+      var h = typeof Symbol < "u" && c[Symbol.iterator] || c["@@iterator"];
+      if (!h) {
+        if (Array.isArray(c) || (h = p(c)) || y) {
+          h && (c = h);
+          var A = 0, J = function() {
+          };
+          return { s: J, n: function() {
+            return A >= c.length ? { done: !0 } : { done: !1, value: c[A++] };
+          }, e: function(G) {
+            throw G;
+          }, f: J };
+        }
+        throw new TypeError(`Invalid attempt to iterate non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+      }
+      var k = !0, X = !1, I;
+      return { s: function() {
+        h = h.call(c);
+      }, n: function() {
+        var G = h.next();
+        return k = G.done, G;
+      }, e: function(G) {
+        X = !0, I = G;
+      }, f: function() {
+        try {
+          !k && h.return != null && h.return();
+        } finally {
+          if (X) throw I;
+        }
+      } };
+    }
+    function p(c, y) {
+      if (c) {
+        if (typeof c == "string") return d(c, y);
+        var h = Object.prototype.toString.call(c).slice(8, -1);
+        if (h === "Object" && c.constructor && (h = c.constructor.name), h === "Map" || h === "Set") return Array.from(c);
+        if (h === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(h)) return d(c, y);
+      }
+    }
+    function d(c, y) {
+      (y == null || y > c.length) && (y = c.length);
+      for (var h = 0, A = new Array(y); h < y; h++)
+        A[h] = c[h];
+      return A;
+    }
+    var m = Ou(), f = {
+      fg: "#FFF",
+      bg: "#000",
+      newline: !1,
+      escapeXML: !1,
+      stream: !1,
+      colors: b()
+    };
+    function b() {
+      var c = {
+        0: "#000",
+        1: "#A00",
+        2: "#0A0",
+        3: "#A50",
+        4: "#00A",
+        5: "#A0A",
+        6: "#0AA",
+        7: "#AAA",
+        8: "#555",
+        9: "#F55",
+        10: "#5F5",
+        11: "#FF5",
+        12: "#55F",
+        13: "#F5F",
+        14: "#5FF",
+        15: "#FFF"
+      };
+      return x(0, 5).forEach(function(y) {
+        x(0, 5).forEach(function(h) {
+          x(0, 5).forEach(function(A) {
+            return D(y, h, A, c);
+          });
+        });
+      }), x(0, 23).forEach(function(y) {
+        var h = y + 232, A = v(y * 10 + 8);
+        c[h] = "#" + A + A + A;
+      }), c;
+    }
+    function D(c, y, h, A) {
+      var J = 16 + c * 36 + y * 6 + h, k = c > 0 ? c * 40 + 55 : 0, X = y > 0 ? y * 40 + 55 : 0, I = h > 0 ? h * 40 + 55 : 0;
+      A[J] = C([k, X, I]);
+    }
+    function v(c) {
+      for (var y = c.toString(16); y.length < 2; )
+        y = "0" + y;
+      return y;
+    }
+    function C(c) {
+      var y = [], h = i(c), A;
+      try {
+        for (h.s(); !(A = h.n()).done; ) {
+          var J = A.value;
+          y.push(v(J));
+        }
+      } catch (k) {
+        h.e(k);
+      } finally {
+        h.f();
+      }
+      return "#" + y.join("");
+    }
+    function F(c, y, h, A) {
+      var J;
+      return y === "text" ? J = Y(h, A) : y === "display" ? J = L(c, h, A) : y === "xterm256Foreground" ? J = R(c, A.colors[h]) : y === "xterm256Background" ? J = q(c, A.colors[h]) : y === "rgb" && (J = w(c, h)), J;
+    }
+    function w(c, y) {
+      y = y.substring(2).slice(0, -1);
+      var h = +y.substr(0, 2), A = y.substring(5).split(";"), J = A.map(function(k) {
+        return ("0" + Number(k).toString(16)).substr(-2);
+      }).join("");
+      return U(c, (h === 38 ? "color:#" : "background-color:#") + J);
+    }
+    function L(c, y, h) {
+      y = parseInt(y, 10);
+      var A = {
+        "-1": function() {
+          return "<br/>";
+        },
+        0: function() {
+          return c.length && O(c);
+        },
+        1: function() {
+          return S(c, "b");
+        },
+        3: function() {
+          return S(c, "i");
+        },
+        4: function() {
+          return S(c, "u");
+        },
+        8: function() {
+          return U(c, "display:none");
+        },
+        9: function() {
+          return S(c, "strike");
+        },
+        22: function() {
+          return U(c, "font-weight:normal;text-decoration:none;font-style:normal");
+        },
+        23: function() {
+          return _(c, "i");
+        },
+        24: function() {
+          return _(c, "u");
+        },
+        39: function() {
+          return R(c, h.fg);
+        },
+        49: function() {
+          return q(c, h.bg);
+        },
+        53: function() {
+          return U(c, "text-decoration:overline");
+        }
+      }, J;
+      return A[y] ? J = A[y]() : 4 < y && y < 7 ? J = S(c, "blink") : 29 < y && y < 38 ? J = R(c, h.colors[y - 30]) : 39 < y && y < 48 ? J = q(c, h.colors[y - 40]) : 89 < y && y < 98 ? J = R(c, h.colors[8 + (y - 90)]) : 99 < y && y < 108 && (J = q(c, h.colors[8 + (y - 100)])), J;
+    }
+    function O(c) {
+      var y = c.slice(0);
+      return c.length = 0, y.reverse().map(function(h) {
+        return "</" + h + ">";
+      }).join("");
+    }
+    function x(c, y) {
+      for (var h = [], A = c; A <= y; A++)
+        h.push(A);
+      return h;
+    }
+    function P(c) {
+      return function(y) {
+        return (c === null || y.category !== c) && c !== "all";
+      };
+    }
+    function N(c) {
+      c = parseInt(c, 10);
+      var y = null;
+      return c === 0 ? y = "all" : c === 1 ? y = "bold" : 2 < c && c < 5 ? y = "underline" : 4 < c && c < 7 ? y = "blink" : c === 8 ? y = "hide" : c === 9 ? y = "strike" : 29 < c && c < 38 || c === 39 || 89 < c && c < 98 ? y = "foreground-color" : (39 < c && c < 48 || c === 49 || 99 < c && c < 108) && (y = "background-color"), y;
+    }
+    function Y(c, y) {
+      return y.escapeXML ? m.encodeXML(c) : c;
+    }
+    function S(c, y, h) {
+      return h || (h = ""), c.push(y), "<".concat(y).concat(h ? ' style="'.concat(h, '"') : "", ">");
+    }
+    function U(c, y) {
+      return S(c, "span", y);
+    }
+    function R(c, y) {
+      return S(c, "span", "color:" + y);
+    }
+    function q(c, y) {
+      return S(c, "span", "background-color:" + y);
+    }
+    function _(c, y) {
+      var h;
+      if (c.slice(-1)[0] === y && (h = c.pop()), h)
+        return "</" + y + ">";
+    }
+    function V(c, y, h) {
+      var A = !1, J = 3;
+      function k() {
+        return "";
+      }
+      function X(Z, ee) {
+        return h("xterm256Foreground", ee), "";
+      }
+      function I(Z, ee) {
+        return h("xterm256Background", ee), "";
+      }
+      function G(Z) {
+        return y.newline ? h("display", -1) : h("text", Z), "";
+      }
+      function ie(Z, ee) {
+        A = !0, ee.trim().length === 0 && (ee = "0"), ee = ee.trimRight(";").split(";");
+        var he = i(ee), ve;
+        try {
+          for (he.s(); !(ve = he.n()).done; ) {
+            var we = ve.value;
+            h("display", we);
+          }
+        } catch (Ce) {
+          he.e(Ce);
+        } finally {
+          he.f();
+        }
+        return "";
+      }
+      function Te(Z) {
+        return h("text", Z), "";
+      }
+      function z(Z) {
+        return h("rgb", Z), "";
+      }
+      var te = [{
+        pattern: /^\x08+/,
+        sub: k
+      }, {
+        pattern: /^\x1b\[[012]?K/,
+        sub: k
+      }, {
+        pattern: /^\x1b\[\(B/,
+        sub: k
+      }, {
+        pattern: /^\x1b\[[34]8;2;\d+;\d+;\d+m/,
+        sub: z
+      }, {
+        pattern: /^\x1b\[38;5;(\d+)m/,
+        sub: X
+      }, {
+        pattern: /^\x1b\[48;5;(\d+)m/,
+        sub: I
+      }, {
+        pattern: /^\n/,
+        sub: G
+      }, {
+        pattern: /^\r+\n/,
+        sub: G
+      }, {
+        pattern: /^\r/,
+        sub: G
+      }, {
+        pattern: /^\x1b\[((?:\d{1,3};?)+|)m/,
+        sub: ie
+      }, {
+        // CSI n J
+        // ED - Erase in Display Clears part of the screen.
+        // If n is 0 (or missing), clear from cursor to end of screen.
+        // If n is 1, clear from cursor to beginning of the screen.
+        // If n is 2, clear entire screen (and moves cursor to upper left on DOS ANSI.SYS).
+        // If n is 3, clear entire screen and delete all lines saved in the scrollback buffer
+        //   (this feature was added for xterm and is supported by other terminal applications).
+        pattern: /^\x1b\[\d?J/,
+        sub: k
+      }, {
+        // CSI n ; m f
+        // HVP - Horizontal Vertical Position Same as CUP
+        pattern: /^\x1b\[\d{0,3};\d{0,3}f/,
+        sub: k
+      }, {
+        // catch-all for CSI sequences?
+        pattern: /^\x1b\[?[\d;]{0,3}/,
+        sub: k
+      }, {
+        /**
+         * extracts real text - not containing:
+         * - `\x1b' - ESC - escape (Ascii 27)
+         * - '\x08' - BS - backspace (Ascii 8)
+         * - `\n` - Newline - linefeed (LF) (ascii 10)
+         * - `\r` - Windows Carriage Return (CR)
+         */
+        pattern: /^(([^\x1b\x08\r\n])+)/,
+        sub: Te
+      }];
+      function ue(Z, ee) {
+        ee > J && A || (A = !1, c = c.replace(Z.pattern, Z.sub));
+      }
+      var ne = [], fe = c, oe = fe.length;
+      e: for (; oe > 0; ) {
+        for (var be = 0, se = 0, Ee = te.length; se < Ee; be = ++se) {
+          var Re = te[be];
+          if (ue(Re, be), c.length !== oe) {
+            oe = c.length;
+            continue e;
+          }
+        }
+        if (c.length === oe)
+          break;
+        ne.push(0), oe = c.length;
+      }
+      return ne;
+    }
+    function H(c, y, h) {
+      return y !== "text" && (c = c.filter(P(N(h))), c.push({
+        token: y,
+        data: h,
+        category: N(h)
+      })), c;
+    }
+    var T = (function() {
+      function c(y) {
+        n(this, c), y = y || {}, y.colors && (y.colors = Object.assign({}, f.colors, y.colors)), this.options = Object.assign({}, f, y), this.stack = [], this.stickyStack = [];
+      }
+      return s(c, [{
+        key: "toHtml",
+        value: function(y) {
+          var h = this;
+          y = typeof y == "string" ? [y] : y;
+          var A = this.stack, J = this.options, k = [];
+          return this.stickyStack.forEach(function(X) {
+            var I = F(A, X.token, X.data, J);
+            I && k.push(I);
+          }), V(y.join(""), J, function(X, I) {
+            var G = F(A, X, I, J);
+            G && k.push(G), J.stream && (h.stickyStack = H(h.stickyStack, X, I));
+          }), A.length && k.push(O(A)), k.join("");
+        }
+      }]), c;
+    })();
+    u.exports = T;
+  }
+}), St = $({
+  "../node_modules/memoizerific/memoizerific.js"(t, u) {
+    (function(n) {
+      if (typeof t == "object" && typeof u < "u")
+        u.exports = n();
+      else if (typeof define == "function" && define.amd)
+        define([], n);
+      else {
+        var o;
+        typeof window < "u" ? o = window : typeof global < "u" ? o = global : typeof self < "u" ? o = self : o = this, o.memoizerific = n();
+      }
+    })(function() {
+      return (function n(o, s, i) {
+        function p(f, b) {
+          if (!s[f]) {
+            if (!o[f]) {
+              var D = typeof qe == "function" && qe;
+              if (!b && D) return D(f, !0);
+              if (d) return d(f, !0);
+              var v = new Error("Cannot find module '" + f + "'");
+              throw v.code = "MODULE_NOT_FOUND", v;
+            }
+            var C = s[f] = { exports: {} };
+            o[f][0].call(C.exports, function(F) {
+              var w = o[f][1][F];
+              return p(w || F);
+            }, C, C.exports, n, o, s, i);
+          }
+          return s[f].exports;
+        }
+        for (var d = typeof qe == "function" && qe, m = 0; m < i.length; m++) p(i[m]);
+        return p;
+      })({ 1: [function(n, o, s) {
+        o.exports = function(i) {
+          if (typeof Map != "function" || i) {
+            var p = n("./similar");
+            return new p();
+          } else
+            return /* @__PURE__ */ new Map();
+        };
+      }, { "./similar": 2 }], 2: [function(n, o, s) {
+        function i() {
+          return this.list = [], this.lastItem = void 0, this.size = 0, this;
+        }
+        i.prototype.get = function(p) {
+          var d;
+          if (this.lastItem && this.isEqual(this.lastItem.key, p))
+            return this.lastItem.val;
+          if (d = this.indexOf(p), d >= 0)
+            return this.lastItem = this.list[d], this.list[d].val;
+        }, i.prototype.set = function(p, d) {
+          var m;
+          return this.lastItem && this.isEqual(this.lastItem.key, p) ? (this.lastItem.val = d, this) : (m = this.indexOf(p), m >= 0 ? (this.lastItem = this.list[m], this.list[m].val = d, this) : (this.lastItem = { key: p, val: d }, this.list.push(this.lastItem), this.size++, this));
+        }, i.prototype.delete = function(p) {
+          var d;
+          if (this.lastItem && this.isEqual(this.lastItem.key, p) && (this.lastItem = void 0), d = this.indexOf(p), d >= 0)
+            return this.size--, this.list.splice(d, 1)[0];
+        }, i.prototype.has = function(p) {
+          var d;
+          return this.lastItem && this.isEqual(this.lastItem.key, p) ? !0 : (d = this.indexOf(p), d >= 0 ? (this.lastItem = this.list[d], !0) : !1);
+        }, i.prototype.forEach = function(p, d) {
+          var m;
+          for (m = 0; m < this.size; m++)
+            p.call(d || this, this.list[m].val, this.list[m].key, this);
+        }, i.prototype.indexOf = function(p) {
+          var d;
+          for (d = 0; d < this.size; d++)
+            if (this.isEqual(this.list[d].key, p))
+              return d;
+          return -1;
+        }, i.prototype.isEqual = function(p, d) {
+          return p === d || p !== p && d !== d;
+        }, o.exports = i;
+      }, {}], 3: [function(n, o, s) {
+        var i = n("map-or-similar");
+        o.exports = function(f) {
+          var b = new i(!1), D = [];
+          return function(v) {
+            var C = function() {
+              var F = b, w, L, O = arguments.length - 1, x = Array(O + 1), P = !0, N;
+              if ((C.numArgs || C.numArgs === 0) && C.numArgs !== O + 1)
+                throw new Error("Memoizerific functions should always be called with the same number of arguments");
+              for (N = 0; N < O; N++) {
+                if (x[N] = {
+                  cacheItem: F,
+                  arg: arguments[N]
+                }, F.has(arguments[N])) {
+                  F = F.get(arguments[N]);
+                  continue;
+                }
+                P = !1, w = new i(!1), F.set(arguments[N], w), F = w;
+              }
+              return P && (F.has(arguments[O]) ? L = F.get(arguments[O]) : P = !1), P || (L = v.apply(null, arguments), F.set(arguments[O], L)), f > 0 && (x[O] = {
+                cacheItem: F,
+                arg: arguments[O]
+              }, P ? p(D, x) : D.push(x), D.length > f && d(D.shift())), C.wasMemoized = P, C.numArgs = O + 1, L;
+            };
+            return C.limit = f, C.wasMemoized = !1, C.cache = b, C.lru = D, C;
+          };
+        };
+        function p(f, b) {
+          var D = f.length, v = b.length, C, F, w;
+          for (F = 0; F < D; F++) {
+            for (C = !0, w = 0; w < v; w++)
+              if (!m(f[F][w].arg, b[w].arg)) {
+                C = !1;
+                break;
+              }
+            if (C)
+              break;
+          }
+          f.push(f.splice(F, 1)[0]);
+        }
+        function d(f) {
+          var b = f.length, D = f[b - 1], v, C;
+          for (D.cacheItem.delete(D.arg), C = b - 2; C >= 0 && (D = f[C], v = D.cacheItem.get(D.arg), !v || !v.size); C--)
+            D.cacheItem.delete(D.arg);
+        }
+        function m(f, b) {
+          return f === b || f !== f && b !== b;
+        }
+      }, { "map-or-similar": 1 }] }, {}, [3])(3);
+    });
+  }
+}), qu = (t) => t.transports !== void 0, ku = () => Math.random().toString(16).slice(2), _u = class {
+  constructor(t = {}) {
+    this.sender = ku(), this.events = {}, this.data = {}, this.transports = [], this.isAsync = t.async || !1, qu(t) ? (this.transports = t.transports || [], this.transports.forEach((u) => {
+      u.setHandler((n) => this.handleEvent(n));
+    })) : this.transports = t.transport ? [t.transport] : [], this.transports.forEach((u) => {
+      u.setHandler((n) => this.handleEvent(n));
+    });
+  }
+  get hasTransport() {
+    return this.transports.length > 0;
+  }
+  addListener(t, u) {
+    this.events[t] = this.events[t] || [], this.events[t].push(u);
+  }
+  emit(t, ...u) {
+    let n = { type: t, args: u, from: this.sender }, o = {};
+    u.length >= 1 && u[0] && u[0].options && (o = u[0].options);
+    let s = () => {
+      this.transports.forEach((i) => {
+        i.send(n, o);
+      }), this.handleEvent(n);
+    };
+    this.isAsync ? setImmediate(s) : s();
+  }
+  last(t) {
+    return this.data[t];
+  }
+  eventNames() {
+    return Object.keys(this.events);
+  }
+  listenerCount(t) {
+    let u = this.listeners(t);
+    return u ? u.length : 0;
+  }
+  listeners(t) {
+    return this.events[t] || void 0;
+  }
+  once(t, u) {
+    let n = this.onceListener(t, u);
+    this.addListener(t, n);
+  }
+  removeAllListeners(t) {
+    t ? this.events[t] && delete this.events[t] : this.events = {};
+  }
+  removeListener(t, u) {
+    let n = this.listeners(t);
+    n && (this.events[t] = n.filter((o) => o !== u));
+  }
+  on(t, u) {
+    this.addListener(t, u);
+  }
+  off(t, u) {
+    this.removeListener(t, u);
+  }
+  handleEvent(t) {
+    let u = this.listeners(t.type);
+    u && u.length && u.forEach((n) => {
+      n.apply(t, t.args);
+    }), this.data[t.type] = t.args;
+  }
+  onceListener(t, u) {
+    let n = (...o) => (this.removeListener(t, n), u(...o));
+    return n;
+  }
+}, { document: un, location: nn } = re, { WebSocket: an } = re, { CONFIG_TYPE: on } = re;
+function Lu() {
+  let t = {
+    setHandler: () => {
+    },
+    send: () => {
+    }
+  };
+  return new _u({ transport: t });
+}
+var Ru = class {
+  constructor() {
+    this.getChannel = () => {
+      if (!this.channel) {
+        let t = Lu();
+        return this.setChannel(t), t;
+      }
+      return this.channel;
+    }, this.ready = () => this.promise, this.hasChannel = () => !!this.channel, this.setChannel = (t) => {
+      this.channel = t, this.resolve();
+    }, this.promise = new Promise((t) => {
+      this.resolve = () => t(this.getChannel());
+    });
+  }
+}, Ve = "__STORYBOOK_ADDONS_PREVIEW";
+function Iu() {
+  return re[Ve] || (re[Ve] = new Ru()), re[Ve];
+}
+var ju = Iu(), Uu = (t, u) => t.length === u.length && t.every((n, o) => n === u[o]), Jt = () => new Error("Storybook preview hooks can only be called inside decorators and story functions.");
+function Mu() {
+  return re.STORYBOOK_HOOKS_CONTEXT || null;
+}
+function Nt() {
+  let t = Mu();
+  if (t == null)
+    throw Jt();
+  return t;
+}
+function Vu(t, u, n) {
+  let o = Nt();
+  if (o.currentPhase === "MOUNT") {
+    n != null && !Array.isArray(n) && ke.warn(
+      `${t} received a final argument that is not an array (instead, received ${n}). When specified, the final argument must be an array.`
+    );
+    let s = { name: t, deps: n };
+    return o.currentHooks.push(s), u(s), s;
+  }
+  if (o.currentPhase === "UPDATE") {
+    let s = o.getNextHook();
+    if (s == null)
+      throw new Error("Rendered more hooks than during the previous render.");
+    return s.name !== t && ke.warn(
+      `Storybook has detected a change in the order of Hooks${o.currentDecoratorName ? ` called by ${o.currentDecoratorName}` : ""}. This will lead to bugs and errors if not fixed.`
+    ), n != null && s.deps == null && ke.warn(
+      `${t} received a final argument during this render, but not during the previous render. Even though the final argument is optional, its type cannot change between renders.`
+    ), n != null && s.deps != null && n.length !== s.deps.length && ke.warn(`The final argument passed to ${t} changed size between renders. The order and size of this array must remain constant.
+Previous: ${s.deps}
+Incoming: ${n}`), (n == null || s.deps == null || !Uu(n, s.deps)) && (u(s), s.deps = n), s;
+  }
+  throw Jt();
+}
+function Ot(t, u, n) {
+  let { memoizedState: o } = Vu(
+    t,
+    (s) => {
+      s.memoizedState = u();
+    },
+    n
+  );
+  return o;
+}
+function Hu(t, u) {
+  return Ot(t, () => ({ current: u }), []);
+}
+function sn(t) {
+  return Hu("useRef", t);
+}
+function ln(t, u) {
+  let n = Nt(), o = Ot("useEffect", () => ({ create: t }), u);
+  n.currentEffects.includes(o) || n.currentEffects.push(o);
+}
+Ae(St(), 1);
+var Ku = Ae(St(), 1);
+(0, Ku.default)(1)(
+  (t) => Object.values(t).reduce(
+    (u, n) => (u[n.importPath] = u[n.importPath] || n, u),
+    {}
+  )
+);
+var Gu = (t) => Array.isArray(t) ? t : t ? [t] : [];
+He`
+CSF .story annotations deprecated; annotate story functions directly:
+- StoryFn.story.name => StoryFn.storyName
+- StoryFn.story.(parameters|decorators) => StoryFn.(parameters|decorators)
+See https://github.com/storybookjs/storybook/blob/next/MIGRATION.md#hoisted-csf-annotations for details and codemod.
+`;
+function zu(t, u, n) {
+  let o = n(t);
+  return (s) => u(o, s);
+}
+function Yu({
+  componentId: t,
+  title: u,
+  kind: n,
+  id: o,
+  name: s,
+  story: i,
+  parameters: p,
+  initialArgs: d,
+  argTypes: m,
+  ...f
+} = {}) {
+  return f;
+}
+function cn(t, u) {
+  let n = {}, o = (i) => (p) => {
+    if (!n.value)
+      throw new Error("Decorated function called without init");
+    return n.value = {
+      ...n.value,
+      ...Yu(p)
+    }, i(n.value);
+  }, s = u.reduce(
+    (i, p) => zu(i, p, o),
+    t
+  );
+  return (i) => (n.value = i, s(i));
+}
+var Xu = (t) => async () => {
+  let u = [];
+  for (let n of t) {
+    let o = await n();
+    o && u.unshift(o);
+  }
+  return async () => {
+    for (let n of u)
+      await n();
+  };
+};
+function Wu(t) {
+  return async (u, n, o) => {
+    await t.reduceRight(
+      (s, i) => async () => i(u, s, o),
+      async () => n(o)
+    )();
+  };
+}
+function Oe(t, u) {
+  return t.map((n) => n.default?.[u] ?? n[u]).filter(Boolean);
+}
+function de(t, u, n = {}) {
+  return Oe(t, u).reduce((o, s) => {
+    let i = Gu(s);
+    return n.reverseFileOrder ? [...i, ...o] : [...o, ...i];
+  }, []);
+}
+function _e(t, u) {
+  return Object.assign({}, ...Oe(t, u));
+}
+function Be(t, u) {
+  return Oe(t, u).pop();
+}
+function pn(t) {
+  let u = de(t, "argTypesEnhancers"), n = Oe(t, "runStep"), o = de(t, "beforeAll");
+  return {
+    parameters: We(...Oe(t, "parameters")),
+    decorators: de(t, "decorators", {
+      reverseFileOrder: !(re.FEATURES?.legacyDecoratorFileOrder ?? !1)
+    }),
+    args: _e(t, "args"),
+    argsEnhancers: de(t, "argsEnhancers"),
+    argTypes: _e(t, "argTypes"),
+    argTypesEnhancers: [
+      ...u.filter((s) => !s.secondPass),
+      ...u.filter((s) => s.secondPass)
+    ],
+    initialGlobals: _e(t, "initialGlobals"),
+    globalTypes: _e(t, "globalTypes"),
+    loaders: de(t, "loaders"),
+    beforeAll: Xu(o),
+    beforeEach: de(t, "beforeEach"),
+    afterEach: de(t, "afterEach"),
+    render: Be(t, "render"),
+    renderToCanvas: Be(t, "renderToCanvas"),
+    applyDecorators: Be(t, "applyDecorators"),
+    runStep: Wu(n),
+    tags: de(t, "tags"),
+    mount: Be(t, "mount"),
+    testingLibraryRender: Be(t, "testingLibraryRender")
+  };
+}
+var { fetch: dn } = re;
+Ae(Ge(), 1);
+Ae(Ge(), 1);
+var { history: yn, document: mn } = re, $u = Ae(Pu(), 1);
+Ae(Ge(), 1);
+var { document: fn } = re;
+new $u.default({
+  escapeXML: !0
+});
+var { document: hn } = re;
+async function gn(t, u) {
+  let n = u.parameters?.docs?.source?.transform, { id: o, unmappedArgs: s } = u, i = n && t ? n?.(t, u) : t, p = i ? await i : void 0;
+  ju.getChannel().emit(Fu, {
+    id: o,
+    source: p,
+    args: s
+  });
+}
+export {
+  Zu as I,
+  Bu as S,
+  Tr as T,
+  ju as a,
+  rn as b,
+  W as c,
+  cn as d,
+  tn as e,
+  en as f,
+  Dt as g,
+  ft as h,
+  nu as i,
+  ln as j,
+  gn as k,
+  vr as l,
+  pn as m,
+  sn as u
+};
+//# sourceMappingURL=chunk-SS2NHR7W-qmI2h7CJ.js.map