storybook 9.0.0-alpha.2 → 9.0.0-alpha.21

package/dist/docs-tools/index.cjs

@@ -1,517 +1,2500 @@
 "use strict";
-var P = Object.defineProperty;
-var Ee = Object.getOwnPropertyDescriptor;
-var je = Object.getOwnPropertyNames;
-var ke = Object.prototype.hasOwnProperty;
-var o = (e, t) => P(e, "name", { value: t, configurable: !0 });
-var Fe = (e, t) => {
-  for (var r in t)
-    P(e, r, { get: t[r], enumerable: !0 });
-}, Je = (e, t, r, n) => {
-  if (t && typeof t == "object" || typeof t == "function")
-    for (let s of je(t))
-      !ke.call(e, s) && s !== r && P(e, s, { get: () => t[s], enumerable: !(n = Ee(t, s)) || n.enumerable });
-  return e;
+var Tr = Object.create;
+var z = Object.defineProperty;
+var gr = Object.getOwnPropertyDescriptor;
+var hr = Object.getOwnPropertyNames;
+var xr = Object.getPrototypeOf, Jr = Object.prototype.hasOwnProperty;
+var r = (n, s) => z(n, "name", { value: s, configurable: !0 });
+var Pr = (n, s) => () => (s || n((s = { exports: {} }).exports, s), s.exports), wr = (n, s) => {
+  for (var a in s)
+    z(n, a, { get: s[a], enumerable: !0 });
+}, it = (n, s, a, p) => {
+  if (s && typeof s == "object" || typeof s == "function")
+    for (let c of hr(s))
+      !Jr.call(n, c) && c !== a && z(n, c, { get: () => s[c], enumerable: !(p = gr(s, c)) || p.enumerable });
+  return n;
 };
-var Ne = (e) => Je(P({}, "__esModule", { value: !0 }), e);
+var br = (n, s, a) => (a = n != null ? Tr(xr(n)) : {}, it(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  s || !n || !n.__esModule ? z(a, "default", { value: n, enumerable: !0 }) : a,
+  n
+)), Er = (n) => it(z({}, "__esModule", { value: !0 }), n);
+
+// ../node_modules/jsdoc-type-pratt-parser/dist/index.js
+var gt = Pr((ue, Tt) => {
+  (function(n, s) {
+    typeof ue == "object" && typeof Tt < "u" ? s(ue) : typeof define == "function" && define.amd ? define(["exports"], s) : (n = typeof globalThis <
+    "u" ? globalThis : n || self, s(n.jtpp = {}));
+  })(ue, function(n) {
+    "use strict";
+    function s(e) {
+      return e.text !== void 0 && e.text !== "" ? `'${e.type}' with value '${e.text}'` : `'${e.type}'`;
+    }
+    r(s, "tokenToString");
+    class a extends Error {
+      static {
+        r(this, "NoParsletFoundError");
+      }
+      constructor(t) {
+        super(`No parslet found for token: ${s(t)}`), this.token = t, Object.setPrototypeOf(this, a.prototype);
+      }
+      getToken() {
+        return this.token;
+      }
+    }
+    class p extends Error {
+      static {
+        r(this, "EarlyEndOfParseError");
+      }
+      constructor(t) {
+        super(`The parsing ended early. The next token was: ${s(t)}`), this.token = t, Object.setPrototypeOf(this, p.prototype);
+      }
+      getToken() {
+        return this.token;
+      }
+    }
+    class c extends Error {
+      static {
+        r(this, "UnexpectedTypeError");
+      }
+      constructor(t, o) {
+        let i = `Unexpected type: '${t.type}'.`;
+        o !== void 0 && (i += ` Message: ${o}`), super(i), Object.setPrototypeOf(this, c.prototype);
+      }
+    }
+    function u(e) {
+      return (t) => t.startsWith(e) ? { type: e, text: e } : null;
+    }
+    r(u, "makePunctuationRule");
+    function m(e) {
+      let t = 0, o, i = e[0], l = !1;
+      if (i !== "'" && i !== '"')
+        return null;
+      for (; t < e.length; ) {
+        if (t++, o = e[t], !l && o === i) {
+          t++;
+          break;
+        }
+        l = !l && o === "\\";
+      }
+      if (o !== i)
+        throw new Error("Unterminated String");
+      return e.slice(0, t);
+    }
+    r(m, "getQuoted");
+    let T = /[$_\p{ID_Start}]|\\u\p{Hex_Digit}{4}|\\u\{0*(?:\p{Hex_Digit}{1,5}|10\p{Hex_Digit}{4})\}/u, g = /[$\-\p{ID_Continue}\u200C\u200D]|\\u\p{Hex_Digit}{4}|\\u\{0*(?:\p{Hex_Digit}{1,5}|10\p{Hex_Digit}{4})\}/u;
+    function w(e) {
+      let t = e[0];
+      if (!T.test(t))
+        return null;
+      let o = 1;
+      do {
+        if (t = e[o], !g.test(t))
+          break;
+        o++;
+      } while (o < e.length);
+      return e.slice(0, o);
+    }
+    r(w, "getIdentifier");
+    let b = /^(NaN|-?((\d*\.\d+|\d+)([Ee][+-]?\d+)?|Infinity))/;
+    function fe(e) {
+      var t, o;
+      return (o = (t = b.exec(e)) === null || t === void 0 ? void 0 : t[0]) !== null && o !== void 0 ? o : null;
+    }
+    r(fe, "getNumber");
+    let $ = /* @__PURE__ */ r((e) => {
+      let t = w(e);
+      return t == null ? null : {
+        type: "Identifier",
+        text: t
+      };
+    }, "identifierRule");
+    function E(e) {
+      return (t) => {
+        if (!t.startsWith(e))
+          return null;
+        let o = t[e.length];
+        return o !== void 0 && g.test(o) ? null : {
+          type: e,
+          text: e
+        };
+      };
+    }
+    r(E, "makeKeyWordRule");
+    let Q = /* @__PURE__ */ r((e) => {
+      let t = m(e);
+      return t == null ? null : {
+        type: "StringValue",
+        text: t
+      };
+    }, "stringValueRule"), de = /* @__PURE__ */ r((e) => e.length > 0 ? null : {
+      type: "EOF",
+      text: ""
+    }, "eofRule"), Te = /* @__PURE__ */ r((e) => {
+      let t = fe(e);
+      return t === null ? null : {
+        type: "Number",
+        text: t
+      };
+    }, "numberRule"), jt = [
+      de,
+      u("=>"),
+      u("("),
+      u(")"),
+      u("{"),
+      u("}"),
+      u("["),
+      u("]"),
+      u("|"),
+      u("&"),
+      u("<"),
+      u(">"),
+      u(","),
+      u(";"),
+      u("*"),
+      u("?"),
+      u("!"),
+      u("="),
+      u(":"),
+      u("..."),
+      u("."),
+      u("#"),
+      u("~"),
+      u("/"),
+      u("@"),
+      E("undefined"),
+      E("null"),
+      E("function"),
+      E("this"),
+      E("new"),
+      E("module"),
+      E("event"),
+      E("external"),
+      E("typeof"),
+      E("keyof"),
+      E("readonly"),
+      E("import"),
+      E("is"),
+      E("in"),
+      Te,
+      $,
+      Q
+    ], _t = /^\s*\n\s*/;
+    class q {
+      static {
+        r(this, "Lexer");
+      }
+      static create(t) {
+        let o = this.read(t);
+        t = o.text;
+        let i = this.read(t);
+        return t = i.text, new q(t, void 0, o.token, i.token);
+      }
+      constructor(t, o, i, l) {
+        this.text = "", this.text = t, this.previous = o, this.current = i, this.next = l;
+      }
+      static read(t, o = !1) {
+        o = o || _t.test(t), t = t.trim();
+        for (let i of jt) {
+          let l = i(t);
+          if (l !== null) {
+            let y = Object.assign(Object.assign({}, l), { startOfLine: o });
+            return t = t.slice(y.text.length), { text: t, token: y };
+          }
+        }
+        throw new Error("Unexpected Token " + t);
+      }
+      advance() {
+        let t = q.read(this.text);
+        return new q(t.text, this.current, this.next, t.token);
+      }
+    }
+    function P(e) {
+      if (e === void 0)
+        throw new Error("Unexpected undefined");
+      if (e.type === "JsdocTypeKeyValue" || e.type === "JsdocTypeParameterList" || e.type === "JsdocTypeProperty" || e.type === "JsdocTypeRe\
+adonlyProperty" || e.type === "JsdocTypeObjectField" || e.type === "JsdocTypeJsdocObjectField" || e.type === "JsdocTypeIndexSignature" || e.
+      type === "JsdocTypeMappedType")
+        throw new c(e);
+      return e;
+    }
+    r(P, "assertRootResult");
+    function ge(e) {
+      return e.type === "JsdocTypeKeyValue" ? Z(e) : P(e);
+    }
+    r(ge, "assertPlainKeyValueOrRootResult");
+    function Lt(e) {
+      return e.type === "JsdocTypeName" ? e : Z(e);
+    }
+    r(Lt, "assertPlainKeyValueOrNameResult");
+    function Z(e) {
+      if (e.type !== "JsdocTypeKeyValue")
+        throw new c(e);
+      return e;
+    }
+    r(Z, "assertPlainKeyValueResult");
+    function Vt(e) {
+      var t;
+      if (e.type === "JsdocTypeVariadic") {
+        if (((t = e.element) === null || t === void 0 ? void 0 : t.type) === "JsdocTypeName")
+          return e;
+        throw new c(e);
+      }
+      if (e.type !== "JsdocTypeNumber" && e.type !== "JsdocTypeName")
+        throw new c(e);
+      return e;
+    }
+    r(Vt, "assertNumberOrVariadicNameResult");
+    function he(e) {
+      return e.type === "JsdocTypeIndexSignature" || e.type === "JsdocTypeMappedType";
+    }
+    r(he, "isSquaredProperty");
+    var f;
+    (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.UNION =
+      4] = "UNION", e[e.INTERSECTION = 5] = "INTERSECTION", e[e.PREFIX = 6] = "PREFIX", e[e.INFIX = 7] = "INFIX", e[e.TUPLE = 8] = "TUPLE", e[e.
+      SYMBOL = 9] = "SYMBOL", e[e.OPTIONAL = 10] = "OPTIONAL", e[e.NULLABLE = 11] = "NULLABLE", e[e.KEY_OF_TYPE_OF = 12] = "KEY_OF_TYPE_OF",
+      e[e.FUNCTION = 13] = "FUNCTION", e[e.ARROW = 14] = "ARROW", e[e.ARRAY_BRACKETS = 15] = "ARRAY_BRACKETS", e[e.GENERIC = 16] = "GENERIC",
+      e[e.NAME_PATH = 17] = "NAME_PATH", e[e.PARENTHESIS = 18] = "PARENTHESIS", e[e.SPECIAL_TYPES = 19] = "SPECIAL_TYPES";
+    })(f || (f = {}));
+    class V {
+      static {
+        r(this, "Parser");
+      }
+      constructor(t, o, i) {
+        this.grammar = t, typeof o == "string" ? this._lexer = q.create(o) : this._lexer = o, this.baseParser = i;
+      }
+      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 t = this.parseType(f.ALL);
+        if (this.lexer.current.type !== "EOF")
+          throw new p(this.lexer.current);
+        return t;
+      }
+      /**
+       * Parses with the current lexer and asserts that the result is a {@link RootResult}.
+       */
+      parseType(t) {
+        return P(this.parseIntermediateType(t));
+      }
+      /**
+       * 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(t) {
+        let o = this.tryParslets(null, t);
+        if (o === null)
+          throw new a(this.lexer.current);
+        return this.parseInfixIntermediateType(o, t);
+      }
+      /**
+       * In the infix parsing step the parser continues to parse the current state with all parslets until none returns
+       * a result.
+       */
+      parseInfixIntermediateType(t, o) {
+        let i = this.tryParslets(t, o);
+        for (; i !== null; )
+          t = i, i = this.tryParslets(t, o);
+        return t;
+      }
+      /**
+       * Tries to parse the current state with all parslets in the grammar and returns the first non null result.
+       */
+      tryParslets(t, o) {
+        for (let i of this.grammar) {
+          let l = i(this, o, t);
+          if (l !== null)
+            return l;
+        }
+        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(t) {
+        return Array.isArray(t) || (t = [t]), t.includes(this.lexer.current.type) ? (this._lexer = this.lexer.advance(), !0) : !1;
+      }
+      acceptLexerState(t) {
+        this._lexer = t.lexer;
+      }
+    }
+    function ze(e) {
+      return e === "EOF" || e === "|" || e === "," || e === ")" || e === ">";
+    }
+    r(ze, "isQuestionMarkUnknownType");
+    let xe = /* @__PURE__ */ r((e, t, o) => {
+      let i = e.lexer.current.type, l = e.lexer.next.type;
+      return o == null && i === "?" && !ze(l) || o != null && i === "?" ? (e.consume("?"), o == null ? {
+        type: "JsdocTypeNullable",
+        element: e.parseType(f.NULLABLE),
+        meta: {
+          position: "prefix"
+        }
+      } : {
+        type: "JsdocTypeNullable",
+        element: P(o),
+        meta: {
+          position: "suffix"
+        }
+      }) : null;
+    }, "nullableParslet");
+    function h(e) {
+      let t = /* @__PURE__ */ r((o, i, l) => {
+        let y = o.lexer.current.type, d = o.lexer.next.type;
+        if (l === null) {
+          if ("parsePrefix" in e && e.accept(y, d))
+            return e.parsePrefix(o);
+        } else if ("parseInfix" in e && e.precedence > i && e.accept(y, d))
+          return e.parseInfix(o, l);
+        return null;
+      }, "parslet");
+      return Object.defineProperty(t, "name", {
+        value: e.name
+      }), t;
+    }
+    r(h, "composeParslet");
+    let ee = h({
+      name: "optionalParslet",
+      accept: /* @__PURE__ */ r((e) => e === "=", "accept"),
+      precedence: f.OPTIONAL,
+      parsePrefix: /* @__PURE__ */ r((e) => (e.consume("="), {
+        type: "JsdocTypeOptional",
+        element: e.parseType(f.OPTIONAL),
+        meta: {
+          position: "prefix"
+        }
+      }), "parsePrefix"),
+      parseInfix: /* @__PURE__ */ r((e, t) => (e.consume("="), {
+        type: "JsdocTypeOptional",
+        element: P(t),
+        meta: {
+          position: "suffix"
+        }
+      }), "parseInfix")
+    }), te = h({
+      name: "numberParslet",
+      accept: /* @__PURE__ */ r((e) => e === "Number", "accept"),
+      parsePrefix: /* @__PURE__ */ r((e) => {
+        let t = parseFloat(e.lexer.current.text);
+        return e.consume("Number"), {
+          type: "JsdocTypeNumber",
+          value: t
+        };
+      }, "parsePrefix")
+    }), Ut = h({
+      name: "parenthesisParslet",
+      accept: /* @__PURE__ */ r((e) => e === "(", "accept"),
+      parsePrefix: /* @__PURE__ */ r((e) => {
+        if (e.consume("("), e.consume(")"))
+          return {
+            type: "JsdocTypeParameterList",
+            elements: []
+          };
+        let t = e.parseIntermediateType(f.ALL);
+        if (!e.consume(")"))
+          throw new Error("Unterminated parenthesis");
+        return t.type === "JsdocTypeParameterList" ? t : t.type === "JsdocTypeKeyValue" ? {
+          type: "JsdocTypeParameterList",
+          elements: [t]
+        } : {
+          type: "JsdocTypeParenthesis",
+          element: P(t)
+        };
+      }, "parsePrefix")
+    }), Bt = h({
+      name: "specialTypesParslet",
+      accept: /* @__PURE__ */ r((e, t) => e === "?" && ze(t) || e === "null" || e === "undefined" || e === "*", "accept"),
+      parsePrefix: /* @__PURE__ */ r((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);
+      }, "parsePrefix")
+    }), Ct = h({
+      name: "notNullableParslet",
+      accept: /* @__PURE__ */ r((e) => e === "!", "accept"),
+      precedence: f.NULLABLE,
+      parsePrefix: /* @__PURE__ */ r((e) => (e.consume("!"), {
+        type: "JsdocTypeNotNullable",
+        element: e.parseType(f.NULLABLE),
+        meta: {
+          position: "prefix"
+        }
+      }), "parsePrefix"),
+      parseInfix: /* @__PURE__ */ r((e, t) => (e.consume("!"), {
+        type: "JsdocTypeNotNullable",
+        element: P(t),
+        meta: {
+          position: "suffix"
+        }
+      }), "parseInfix")
+    });
+    function Mt({ allowTrailingComma: e }) {
+      return h({
+        name: "parameterListParslet",
+        accept: /* @__PURE__ */ r((t) => t === ",", "accept"),
+        precedence: f.PARAMETER_LIST,
+        parseInfix: /* @__PURE__ */ r((t, o) => {
+          let i = [
+            ge(o)
+          ];
+          t.consume(",");
+          do
+            try {
+              let l = t.parseIntermediateType(f.PARAMETER_LIST);
+              i.push(ge(l));
+            } catch (l) {
+              if (e && l instanceof a)
+                break;
+              throw l;
+            }
+          while (t.consume(","));
+          if (i.length > 0 && i.slice(0, -1).some((l) => l.type === "JsdocTypeVariadic"))
+            throw new Error("Only the last parameter may be a rest parameter");
+          return {
+            type: "JsdocTypeParameterList",
+            elements: i
+          };
+        }, "parseInfix")
+      });
+    }
+    r(Mt, "createParameterListParslet");
+    let Kt = h({
+      name: "genericParslet",
+      accept: /* @__PURE__ */ r((e, t) => e === "<" || e === "." && t === "<", "accept"),
+      precedence: f.GENERIC,
+      parseInfix: /* @__PURE__ */ r((e, t) => {
+        let o = e.consume(".");
+        e.consume("<");
+        let i = [];
+        do
+          i.push(e.parseType(f.PARAMETER_LIST));
+        while (e.consume(","));
+        if (!e.consume(">"))
+          throw new Error("Unterminated generic parameter list");
+        return {
+          type: "JsdocTypeGeneric",
+          left: P(t),
+          elements: i,
+          meta: {
+            brackets: "angle",
+            dot: o
+          }
+        };
+      }, "parseInfix")
+    }), $t = h({
+      name: "unionParslet",
+      accept: /* @__PURE__ */ r((e) => e === "|", "accept"),
+      precedence: f.UNION,
+      parseInfix: /* @__PURE__ */ r((e, t) => {
+        e.consume("|");
+        let o = [];
+        do
+          o.push(e.parseType(f.UNION));
+        while (e.consume("|"));
+        return {
+          type: "JsdocTypeUnion",
+          elements: [P(t), ...o]
+        };
+      }, "parseInfix")
+    }), Je = [
+      xe,
+      ee,
+      te,
+      Ut,
+      Bt,
+      Ct,
+      Mt({
+        allowTrailingComma: !0
+      }),
+      Kt,
+      $t,
+      ee
+    ];
+    function re({ allowSquareBracketsOnAnyType: e, allowJsdocNamePaths: t, pathGrammar: o }) {
+      return /* @__PURE__ */ r(function(l, y, d) {
+        if (d == null || y >= f.NAME_PATH)
+          return null;
+        let x = l.lexer.current.type, N = l.lexer.next.type;
+        if (!(x === "." && N !== "<" || x === "[" && (e || d.type === "JsdocTypeName") || t && (x === "~" || x === "#")))
+          return null;
+        let D, se = !1;
+        l.consume(".") ? D = "property" : l.consume("[") ? (D = "property-brackets", se = !0) : l.consume("~") ? D = "inner" : (l.consume("#"),
+        D = "instance");
+        let st = o !== null ? new V(o, l.lexer, l) : l, k = st.parseIntermediateType(f.NAME_PATH);
+        l.acceptLexerState(st);
+        let G;
+        switch (k.type) {
+          case "JsdocTypeName":
+            G = {
+              type: "JsdocTypeProperty",
+              value: k.value,
+              meta: {
+                quote: void 0
+              }
+            };
+            break;
+          case "JsdocTypeNumber":
+            G = {
+              type: "JsdocTypeProperty",
+              value: k.value.toString(10),
+              meta: {
+                quote: void 0
+              }
+            };
+            break;
+          case "JsdocTypeStringValue":
+            G = {
+              type: "JsdocTypeProperty",
+              value: k.value,
+              meta: {
+                quote: k.meta.quote
+              }
+            };
+            break;
+          case "JsdocTypeSpecialNamePath":
+            if (k.specialType === "event")
+              G = k;
+            else
+              throw new c(k, "Type 'JsdocTypeSpecialNamePath' is only allowed with specialType 'event'");
+            break;
+          default:
+            throw new c(k, "Expecting 'JsdocTypeName', 'JsdocTypeNumber', 'JsdocStringValue' or 'JsdocTypeSpecialNamePath'");
+        }
+        if (se && !l.consume("]")) {
+          let at = l.lexer.current;
+          throw new Error(`Unterminated square brackets. Next token is '${at.type}' with text '${at.text}'`);
+        }
+        return {
+          type: "JsdocTypeNamePath",
+          left: P(d),
+          right: G,
+          pathType: D
+        };
+      }, "namePathParslet");
+    }
+    r(re, "createNamePathParslet");
+    function R({ allowedAdditionalTokens: e }) {
+      return h({
+        name: "nameParslet",
+        accept: /* @__PURE__ */ r((t) => t === "Identifier" || t === "this" || t === "new" || e.includes(t), "accept"),
+        parsePrefix: /* @__PURE__ */ r((t) => {
+          let { type: o, text: i } = t.lexer.current;
+          return t.consume(o), {
+            type: "JsdocTypeName",
+            value: i
+          };
+        }, "parsePrefix")
+      });
+    }
+    r(R, "createNameParslet");
+    let Y = h({
+      name: "stringValueParslet",
+      accept: /* @__PURE__ */ r((e) => e === "StringValue", "accept"),
+      parsePrefix: /* @__PURE__ */ r((e) => {
+        let t = e.lexer.current.text;
+        return e.consume("StringValue"), {
+          type: "JsdocTypeStringValue",
+          value: t.slice(1, -1),
+          meta: {
+            quote: t[0] === "'" ? "single" : "double"
+          }
+        };
+      }, "parsePrefix")
+    });
+    function ne({ pathGrammar: e, allowedTypes: t }) {
+      return h({
+        name: "specialNamePathParslet",
+        accept: /* @__PURE__ */ r((o) => t.includes(o), "accept"),
+        parsePrefix: /* @__PURE__ */ r((o) => {
+          let i = o.lexer.current.type;
+          if (o.consume(i), !o.consume(":"))
+            return {
+              type: "JsdocTypeName",
+              value: i
+            };
+          let l, y = o.lexer.current;
+          if (o.consume("StringValue"))
+            l = {
+              type: "JsdocTypeSpecialNamePath",
+              value: y.text.slice(1, -1),
+              specialType: i,
+              meta: {
+                quote: y.text[0] === "'" ? "single" : "double"
+              }
+            };
+          else {
+            let N = "", S = ["Identifier", "@", "/"];
+            for (; S.some((D) => o.consume(D)); )
+              N += y.text, y = o.lexer.current;
+            l = {
+              type: "JsdocTypeSpecialNamePath",
+              value: N,
+              specialType: i,
+              meta: {
+                quote: void 0
+              }
+            };
+          }
+          let d = new V(e, o.lexer, o), x = d.parseInfixIntermediateType(l, f.ALL);
+          return o.acceptLexerState(d), P(x);
+        }, "parsePrefix")
+      });
+    }
+    r(ne, "createSpecialNamePathParslet");
+    let Xe = [
+      R({
+        allowedAdditionalTokens: ["external", "module"]
+      }),
+      Y,
+      te,
+      re({
+        allowSquareBracketsOnAnyType: !1,
+        allowJsdocNamePaths: !0,
+        pathGrammar: null
+      })
+    ], U = [
+      ...Xe,
+      ne({
+        allowedTypes: ["event"],
+        pathGrammar: Xe
+      })
+    ];
+    function Pe(e) {
+      let t;
+      if (e.type === "JsdocTypeParameterList")
+        t = e.elements;
+      else if (e.type === "JsdocTypeParenthesis")
+        t = [e.element];
+      else
+        throw new c(e);
+      return t.map((o) => ge(o));
+    }
+    r(Pe, "getParameters");
+    function qt(e) {
+      let t = Pe(e);
+      if (t.some((o) => o.type === "JsdocTypeKeyValue"))
+        throw new Error("No parameter should be named");
+      return t;
+    }
+    r(qt, "getUnnamedParameters");
+    function we({ allowNamedParameters: e, allowNoReturnType: t, allowWithoutParenthesis: o, allowNewAsFunctionKeyword: i }) {
+      return h({
+        name: "functionParslet",
+        accept: /* @__PURE__ */ r((l, y) => l === "function" || i && l === "new" && y === "(", "accept"),
+        parsePrefix: /* @__PURE__ */ r((l) => {
+          let y = l.consume("new");
+          l.consume("function");
+          let d = l.lexer.current.type === "(";
+          if (!d) {
+            if (!o)
+              throw new Error("function is missing parameter list");
+            return {
+              type: "JsdocTypeName",
+              value: "function"
+            };
+          }
+          let x = {
+            type: "JsdocTypeFunction",
+            parameters: [],
+            arrow: !1,
+            constructor: y,
+            parenthesis: d
+          }, N = l.parseIntermediateType(f.FUNCTION);
+          if (e === void 0)
+            x.parameters = qt(N);
+          else {
+            if (y && N.type === "JsdocTypeFunction" && N.arrow)
+              return x = N, x.constructor = !0, x;
+            x.parameters = Pe(N);
+            for (let S of x.parameters)
+              if (S.type === "JsdocTypeKeyValue" && !e.includes(S.key))
+                throw new Error(`only allowed named parameters are ${e.join(", ")} but got ${S.type}`);
+          }
+          if (l.consume(":"))
+            x.returnType = l.parseType(f.PREFIX);
+          else if (!t)
+            throw new Error("function is missing return type");
+          return x;
+        }, "parsePrefix")
+      });
+    }
+    r(we, "createFunctionParslet");
+    function be({ allowPostfix: e, allowEnclosingBrackets: t }) {
+      return h({
+        name: "variadicParslet",
+        accept: /* @__PURE__ */ r((o) => o === "...", "accept"),
+        precedence: f.PREFIX,
+        parsePrefix: /* @__PURE__ */ r((o) => {
+          o.consume("...");
+          let i = t && o.consume("[");
+          try {
+            let l = o.parseType(f.PREFIX);
+            if (i && !o.consume("]"))
+              throw new Error("Unterminated variadic type. Missing ']'");
+            return {
+              type: "JsdocTypeVariadic",
+              element: P(l),
+              meta: {
+                position: "prefix",
+                squareBrackets: i
+              }
+            };
+          } catch (l) {
+            if (l instanceof a) {
+              if (i)
+                throw new Error("Empty square brackets for variadic are not allowed.");
+              return {
+                type: "JsdocTypeVariadic",
+                meta: {
+                  position: void 0,
+                  squareBrackets: !1
+                }
+              };
+            } else
+              throw l;
+          }
+        }, "parsePrefix"),
+        parseInfix: e ? (o, i) => (o.consume("..."), {
+          type: "JsdocTypeVariadic",
+          element: P(i),
+          meta: {
+            position: "suffix",
+            squareBrackets: !1
+          }
+        }) : void 0
+      });
+    }
+    r(be, "createVariadicParslet");
+    let He = h({
+      name: "symbolParslet",
+      accept: /* @__PURE__ */ r((e) => e === "(", "accept"),
+      precedence: f.SYMBOL,
+      parseInfix: /* @__PURE__ */ r((e, t) => {
+        if (t.type !== "JsdocTypeName")
+          throw new Error("Symbol expects a name on the left side. (Reacting on '(')");
+        e.consume("(");
+        let o = {
+          type: "JsdocTypeSymbol",
+          value: t.value
+        };
+        if (!e.consume(")")) {
+          let i = e.parseIntermediateType(f.SYMBOL);
+          if (o.element = Vt(i), !e.consume(")"))
+            throw new Error("Symbol does not end after value");
+        }
+        return o;
+      }, "parseInfix")
+    }), Qe = h({
+      name: "arrayBracketsParslet",
+      precedence: f.ARRAY_BRACKETS,
+      accept: /* @__PURE__ */ r((e, t) => e === "[" && t === "]", "accept"),
+      parseInfix: /* @__PURE__ */ r((e, t) => (e.consume("["), e.consume("]"), {
+        type: "JsdocTypeGeneric",
+        left: {
+          type: "JsdocTypeName",
+          value: "Array"
+        },
+        elements: [
+          P(t)
+        ],
+        meta: {
+          brackets: "square",
+          dot: !1
+        }
+      }), "parseInfix")
+    });
+    function Ee({ objectFieldGrammar: e, allowKeyTypes: t }) {
+      return h({
+        name: "objectParslet",
+        accept: /* @__PURE__ */ r((o) => o === "{", "accept"),
+        parsePrefix: /* @__PURE__ */ r((o) => {
+          o.consume("{");
+          let i = {
+            type: "JsdocTypeObject",
+            meta: {
+              separator: "comma"
+            },
+            elements: []
+          };
+          if (!o.consume("}")) {
+            let l, y = new V(e, o.lexer, o);
+            for (; ; ) {
+              y.acceptLexerState(o);
+              let d = y.parseIntermediateType(f.OBJECT);
+              o.acceptLexerState(y), d === void 0 && t && (d = o.parseIntermediateType(f.OBJECT));
+              let x = !1;
+              if (d.type === "JsdocTypeNullable" && (x = !0, d = d.element), d.type === "JsdocTypeNumber" || d.type === "JsdocTypeName" || d.
+              type === "JsdocTypeStringValue") {
+                let S;
+                d.type === "JsdocTypeStringValue" && (S = d.meta.quote), i.elements.push({
+                  type: "JsdocTypeObjectField",
+                  key: d.value.toString(),
+                  right: void 0,
+                  optional: x,
+                  readonly: !1,
+                  meta: {
+                    quote: S
+                  }
+                });
+              } else if (d.type === "JsdocTypeObjectField" || d.type === "JsdocTypeJsdocObjectField")
+                i.elements.push(d);
+              else
+                throw new c(d);
+              if (o.lexer.current.startOfLine)
+                l = "linebreak";
+              else if (o.consume(","))
+                l = "comma";
+              else if (o.consume(";"))
+                l = "semicolon";
+              else
+                break;
+              if (o.lexer.current.type === "}")
+                break;
+            }
+            if (i.meta.separator = l ?? "comma", !o.consume("}"))
+              throw new Error("Unterminated record type. Missing '}'");
+          }
+          return i;
+        }, "parsePrefix")
+      });
+    }
+    r(Ee, "createObjectParslet");
+    function Se({ allowSquaredProperties: e, allowKeyTypes: t, allowReadonly: o, allowOptional: i }) {
+      return h({
+        name: "objectFieldParslet",
+        precedence: f.KEY_VALUE,
+        accept: /* @__PURE__ */ r((l) => l === ":", "accept"),
+        parseInfix: /* @__PURE__ */ r((l, y) => {
+          var d;
+          let x = !1, N = !1;
+          i && y.type === "JsdocTypeNullable" && (x = !0, y = y.element), o && y.type === "JsdocTypeReadonlyProperty" && (N = !0, y = y.element);
+          let S = (d = l.baseParser) !== null && d !== void 0 ? d : l;
+          if (S.acceptLexerState(l), y.type === "JsdocTypeNumber" || y.type === "JsdocTypeName" || y.type === "JsdocTypeStringValue" || he(y)) {
+            if (he(y) && !e)
+              throw new c(y);
+            S.consume(":");
+            let D;
+            y.type === "JsdocTypeStringValue" && (D = y.meta.quote);
+            let se = S.parseType(f.KEY_VALUE);
+            return l.acceptLexerState(S), {
+              type: "JsdocTypeObjectField",
+              key: he(y) ? y : y.value.toString(),
+              right: se,
+              optional: x,
+              readonly: N,
+              meta: {
+                quote: D
+              }
+            };
+          } else {
+            if (!t)
+              throw new c(y);
+            S.consume(":");
+            let D = S.parseType(f.KEY_VALUE);
+            return l.acceptLexerState(S), {
+              type: "JsdocTypeJsdocObjectField",
+              left: P(y),
+              right: D
+            };
+          }
+        }, "parseInfix")
+      });
+    }
+    r(Se, "createObjectFieldParslet");
+    function Ne({ allowOptional: e, allowVariadic: t }) {
+      return h({
+        name: "keyValueParslet",
+        precedence: f.KEY_VALUE,
+        accept: /* @__PURE__ */ r((o) => o === ":", "accept"),
+        parseInfix: /* @__PURE__ */ r((o, i) => {
+          let l = !1, y = !1;
+          if (e && i.type === "JsdocTypeNullable" && (l = !0, i = i.element), t && i.type === "JsdocTypeVariadic" && i.element !== void 0 &&
+          (y = !0, i = i.element), i.type !== "JsdocTypeName")
+            throw new c(i);
+          o.consume(":");
+          let d = o.parseType(f.KEY_VALUE);
+          return {
+            type: "JsdocTypeKeyValue",
+            key: i.value,
+            right: d,
+            optional: l,
+            variadic: y
+          };
+        }, "parseInfix")
+      });
+    }
+    r(Ne, "createKeyValueParslet");
+    let Ze = [
+      ...Je,
+      we({
+        allowWithoutParenthesis: !0,
+        allowNamedParameters: ["this", "new"],
+        allowNoReturnType: !0,
+        allowNewAsFunctionKeyword: !1
+      }),
+      Y,
+      ne({
+        allowedTypes: ["module", "external", "event"],
+        pathGrammar: U
+      }),
+      be({
+        allowEnclosingBrackets: !0,
+        allowPostfix: !0
+      }),
+      R({
+        allowedAdditionalTokens: ["keyof"]
+      }),
+      He,
+      Qe,
+      re({
+        allowSquareBracketsOnAnyType: !1,
+        allowJsdocNamePaths: !0,
+        pathGrammar: U
+      })
+    ], Yt = [
+      ...Ze,
+      Ee({
+        // 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: [
+          R({
+            allowedAdditionalTokens: ["module", "in"]
+          }),
+          Se({
+            allowSquaredProperties: !1,
+            allowKeyTypes: !0,
+            allowOptional: !1,
+            allowReadonly: !1
+          }),
+          ...Ze
+        ],
+        allowKeyTypes: !0
+      }),
+      Ne({
+        allowOptional: !0,
+        allowVariadic: !0
+      })
+    ], et = h({
+      name: "typeOfParslet",
+      accept: /* @__PURE__ */ r((e) => e === "typeof", "accept"),
+      parsePrefix: /* @__PURE__ */ r((e) => (e.consume("typeof"), {
+        type: "JsdocTypeTypeof",
+        element: P(e.parseType(f.KEY_OF_TYPE_OF))
+      }), "parsePrefix")
+    }), Wt = [
+      R({
+        allowedAdditionalTokens: ["module", "keyof", "event", "external", "in"]
+      }),
+      xe,
+      ee,
+      Y,
+      te,
+      Se({
+        allowSquaredProperties: !1,
+        allowKeyTypes: !1,
+        allowOptional: !1,
+        allowReadonly: !1
+      })
+    ], Gt = [
+      ...Je,
+      Ee({
+        allowKeyTypes: !1,
+        objectFieldGrammar: Wt
+      }),
+      R({
+        allowedAdditionalTokens: ["event", "external", "in"]
+      }),
+      et,
+      we({
+        allowWithoutParenthesis: !1,
+        allowNamedParameters: ["this", "new"],
+        allowNoReturnType: !0,
+        allowNewAsFunctionKeyword: !1
+      }),
+      be({
+        allowEnclosingBrackets: !1,
+        allowPostfix: !1
+      }),
+      // additional name parslet is needed for some special cases
+      R({
+        allowedAdditionalTokens: ["keyof"]
+      }),
+      ne({
+        allowedTypes: ["module"],
+        pathGrammar: U
+      }),
+      re({
+        allowSquareBracketsOnAnyType: !1,
+        allowJsdocNamePaths: !0,
+        pathGrammar: U
+      }),
+      Ne({
+        allowOptional: !1,
+        allowVariadic: !1
+      }),
+      He
+    ];
+    function zt({ allowQuestionMark: e }) {
+      return h({
+        name: "tupleParslet",
+        accept: /* @__PURE__ */ r((t) => t === "[", "accept"),
+        parsePrefix: /* @__PURE__ */ r((t) => {
+          t.consume("[");
+          let o = {
+            type: "JsdocTypeTuple",
+            elements: []
+          };
+          if (t.consume("]"))
+            return o;
+          let i = t.parseIntermediateType(f.ALL);
+          if (i.type === "JsdocTypeParameterList" ? i.elements[0].type === "JsdocTypeKeyValue" ? o.elements = i.elements.map(Z) : o.elements =
+          i.elements.map(P) : i.type === "JsdocTypeKeyValue" ? o.elements = [Z(i)] : o.elements = [P(i)], !t.consume("]"))
+            throw new Error("Unterminated '['");
+          if (!e && o.elements.some((l) => l.type === "JsdocTypeUnknown"))
+            throw new Error("Question mark in tuple not allowed");
+          return o;
+        }, "parsePrefix")
+      });
+    }
+    r(zt, "createTupleParslet");
+    let Xt = h({
+      name: "keyOfParslet",
+      accept: /* @__PURE__ */ r((e) => e === "keyof", "accept"),
+      parsePrefix: /* @__PURE__ */ r((e) => (e.consume("keyof"), {
+        type: "JsdocTypeKeyof",
+        element: P(e.parseType(f.KEY_OF_TYPE_OF))
+      }), "parsePrefix")
+    }), Ht = h({
+      name: "importParslet",
+      accept: /* @__PURE__ */ r((e) => e === "import", "accept"),
+      parsePrefix: /* @__PURE__ */ r((e) => {
+        if (e.consume("import"), !e.consume("("))
+          throw new Error("Missing parenthesis after import keyword");
+        let t = e.parseType(f.PREFIX);
+        if (t.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: t
+        };
+      }, "parsePrefix")
+    }), Qt = h({
+      name: "readonlyPropertyParslet",
+      accept: /* @__PURE__ */ r((e) => e === "readonly", "accept"),
+      parsePrefix: /* @__PURE__ */ r((e) => (e.consume("readonly"), {
+        type: "JsdocTypeReadonlyProperty",
+        element: e.parseType(f.KEY_VALUE)
+      }), "parsePrefix")
+    }), Zt = h({
+      name: "arrowFunctionParslet",
+      precedence: f.ARROW,
+      accept: /* @__PURE__ */ r((e) => e === "=>", "accept"),
+      parseInfix: /* @__PURE__ */ r((e, t) => (e.consume("=>"), {
+        type: "JsdocTypeFunction",
+        parameters: Pe(t).map(Lt),
+        arrow: !0,
+        constructor: !1,
+        parenthesis: !0,
+        returnType: e.parseType(f.OBJECT)
+      }), "parseInfix")
+    }), er = h({
+      name: "intersectionParslet",
+      accept: /* @__PURE__ */ r((e) => e === "&", "accept"),
+      precedence: f.INTERSECTION,
+      parseInfix: /* @__PURE__ */ r((e, t) => {
+        e.consume("&");
+        let o = [];
+        do
+          o.push(e.parseType(f.INTERSECTION));
+        while (e.consume("&"));
+        return {
+          type: "JsdocTypeIntersection",
+          elements: [P(t), ...o]
+        };
+      }, "parseInfix")
+    }), tr = h({
+      name: "predicateParslet",
+      precedence: f.INFIX,
+      accept: /* @__PURE__ */ r((e) => e === "is", "accept"),
+      parseInfix: /* @__PURE__ */ r((e, t) => {
+        if (t.type !== "JsdocTypeName")
+          throw new c(t, "A typescript predicate always has to have a name on the left side.");
+        return e.consume("is"), {
+          type: "JsdocTypePredicate",
+          left: t,
+          right: P(e.parseIntermediateType(f.INFIX))
+        };
+      }, "parseInfix")
+    }), rr = h({
+      name: "objectSquareBracketPropertyParslet",
+      accept: /* @__PURE__ */ r((e) => e === "[", "accept"),
+      parsePrefix: /* @__PURE__ */ r((e) => {
+        if (e.baseParser === void 0)
+          throw new Error("Only allowed inside object grammar");
+        e.consume("[");
+        let t = e.lexer.current.text;
+        e.consume("Identifier");
+        let o;
+        if (e.consume(":")) {
+          let i = e.baseParser;
+          i.acceptLexerState(e), o = {
+            type: "JsdocTypeIndexSignature",
+            key: t,
+            right: i.parseType(f.ARRAY_BRACKETS)
+          }, e.acceptLexerState(i);
+        } else if (e.consume("in")) {
+          let i = e.baseParser;
+          i.acceptLexerState(e), o = {
+            type: "JsdocTypeMappedType",
+            key: t,
+            right: i.parseType(f.ARRAY_BRACKETS)
+          }, e.acceptLexerState(i);
+        } else
+          throw new Error("Missing ':' or 'in' inside square bracketed property.");
+        if (!e.consume("]"))
+          throw new Error("Unterminated square brackets");
+        return o;
+      }, "parsePrefix")
+    }), nr = [
+      Qt,
+      R({
+        allowedAdditionalTokens: ["module", "event", "keyof", "event", "external", "in"]
+      }),
+      xe,
+      ee,
+      Y,
+      te,
+      Se({
+        allowSquaredProperties: !0,
+        allowKeyTypes: !1,
+        allowOptional: !0,
+        allowReadonly: !0
+      }),
+      rr
+    ], or = [
+      ...Je,
+      Ee({
+        allowKeyTypes: !1,
+        objectFieldGrammar: nr
+      }),
+      et,
+      Xt,
+      Ht,
+      Y,
+      we({
+        allowWithoutParenthesis: !0,
+        allowNoReturnType: !1,
+        allowNamedParameters: ["this", "new", "args"],
+        allowNewAsFunctionKeyword: !0
+      }),
+      zt({
+        allowQuestionMark: !1
+      }),
+      be({
+        allowEnclosingBrackets: !1,
+        allowPostfix: !1
+      }),
+      R({
+        allowedAdditionalTokens: ["event", "external", "in"]
+      }),
+      ne({
+        allowedTypes: ["module"],
+        pathGrammar: U
+      }),
+      Qe,
+      Zt,
+      re({
+        allowSquareBracketsOnAnyType: !0,
+        allowJsdocNamePaths: !1,
+        pathGrammar: U
+      }),
+      er,
+      tr,
+      Ne({
+        allowVariadic: !0,
+        allowOptional: !0
+      })
+    ];
+    function tt(e, t) {
+      switch (t) {
+        case "closure":
+          return new V(Gt, e).parse();
+        case "jsdoc":
+          return new V(Yt, e).parse();
+        case "typescript":
+          return new V(or, e).parse();
+      }
+    }
+    r(tt, "parse");
+    function sr(e, t = ["typescript", "closure", "jsdoc"]) {
+      let o;
+      for (let i of t)
+        try {
+          return tt(e, i);
+        } catch (l) {
+          o = l;
+        }
+      throw o;
+    }
+    r(sr, "tryParse");
+    function W(e, t) {
+      let o = e[t.type];
+      if (o === void 0)
+        throw new Error(`In this set of transform rules exists no rule for type ${t.type}.`);
+      return o(t, (i) => W(e, i));
+    }
+    r(W, "transform");
+    function O(e) {
+      throw new Error("This transform is not available. Are you trying the correct parsing mode?");
+    }
+    r(O, "notAvailableTransform");
+    function rt(e) {
+      let t = {
+        params: []
+      };
+      for (let o of e.parameters)
+        o.type === "JsdocTypeKeyValue" ? o.key === "this" ? t.this = o.right : o.key === "new" ? t.new = o.right : t.params.push(o) : t.params.
+        push(o);
+      return t;
+    }
+    r(rt, "extractSpecialParams");
+    function oe(e, t, o) {
+      return e === "prefix" ? o + t : t + o;
+    }
+    r(oe, "applyPosition");
+    function I(e, t) {
+      switch (t) {
+        case "double":
+          return `"${e}"`;
+        case "single":
+          return `'${e}'`;
+        case void 0:
+          return e;
+      }
+    }
+    r(I, "quote");
+    function nt() {
+      return {
+        JsdocTypeParenthesis: /* @__PURE__ */ r((e, t) => `(${e.element !== void 0 ? t(e.element) : ""})`, "JsdocTypeParenthesis"),
+        JsdocTypeKeyof: /* @__PURE__ */ r((e, t) => `keyof ${t(e.element)}`, "JsdocTypeKeyof"),
+        JsdocTypeFunction: /* @__PURE__ */ r((e, t) => {
+          if (e.arrow) {
+            if (e.returnType === void 0)
+              throw new Error("Arrow function needs a return type.");
+            let o = `(${e.parameters.map(t).join(", ")}) => ${t(e.returnType)}`;
+            return e.constructor && (o = "new " + o), o;
+          } else {
+            let o = e.constructor ? "new" : "function";
+            return e.parenthesis && (o += `(${e.parameters.map(t).join(", ")})`, e.returnType !== void 0 && (o += `: ${t(e.returnType)}`)), o;
+          }
+        }, "JsdocTypeFunction"),
+        JsdocTypeName: /* @__PURE__ */ r((e) => e.value, "JsdocTypeName"),
+        JsdocTypeTuple: /* @__PURE__ */ r((e, t) => `[${e.elements.map(t).join(", ")}]`, "JsdocTypeTuple"),
+        JsdocTypeVariadic: /* @__PURE__ */ r((e, t) => e.meta.position === void 0 ? "..." : oe(e.meta.position, t(e.element), "..."), "Jsdoc\
+TypeVariadic"),
+        JsdocTypeNamePath: /* @__PURE__ */ r((e, t) => {
+          let o = t(e.left), i = t(e.right);
+          switch (e.pathType) {
+            case "inner":
+              return `${o}~${i}`;
+            case "instance":
+              return `${o}#${i}`;
+            case "property":
+              return `${o}.${i}`;
+            case "property-brackets":
+              return `${o}[${i}]`;
+          }
+        }, "JsdocTypeNamePath"),
+        JsdocTypeStringValue: /* @__PURE__ */ r((e) => I(e.value, e.meta.quote), "JsdocTypeStringValue"),
+        JsdocTypeAny: /* @__PURE__ */ r(() => "*", "JsdocTypeAny"),
+        JsdocTypeGeneric: /* @__PURE__ */ r((e, t) => {
+          if (e.meta.brackets === "square") {
+            let o = e.elements[0], i = t(o);
+            return o.type === "JsdocTypeUnion" || o.type === "JsdocTypeIntersection" ? `(${i})[]` : `${i}[]`;
+          } else
+            return `${t(e.left)}${e.meta.dot ? "." : ""}<${e.elements.map(t).join(", ")}>`;
+        }, "JsdocTypeGeneric"),
+        JsdocTypeImport: /* @__PURE__ */ r((e, t) => `import(${t(e.element)})`, "JsdocTypeImport"),
+        JsdocTypeObjectField: /* @__PURE__ */ r((e, t) => {
+          let o = "";
+          return e.readonly && (o += "readonly "), typeof e.key == "string" ? o += I(e.key, e.meta.quote) : o += t(e.key), e.optional && (o +=
+          "?"), e.right === void 0 ? o : o + `: ${t(e.right)}`;
+        }, "JsdocTypeObjectField"),
+        JsdocTypeJsdocObjectField: /* @__PURE__ */ r((e, t) => `${t(e.left)}: ${t(e.right)}`, "JsdocTypeJsdocObjectField"),
+        JsdocTypeKeyValue: /* @__PURE__ */ r((e, t) => {
+          let o = e.key;
+          return e.optional && (o += "?"), e.variadic && (o = "..." + o), e.right === void 0 ? o : o + `: ${t(e.right)}`;
+        }, "JsdocTypeKeyValue"),
+        JsdocTypeSpecialNamePath: /* @__PURE__ */ r((e) => `${e.specialType}:${I(e.value, e.meta.quote)}`, "JsdocTypeSpecialNamePath"),
+        JsdocTypeNotNullable: /* @__PURE__ */ r((e, t) => oe(e.meta.position, t(e.element), "!"), "JsdocTypeNotNullable"),
+        JsdocTypeNull: /* @__PURE__ */ r(() => "null", "JsdocTypeNull"),
+        JsdocTypeNullable: /* @__PURE__ */ r((e, t) => oe(e.meta.position, t(e.element), "?"), "JsdocTypeNullable"),
+        JsdocTypeNumber: /* @__PURE__ */ r((e) => e.value.toString(), "JsdocTypeNumber"),
+        JsdocTypeObject: /* @__PURE__ */ r((e, t) => `{${e.elements.map(t).join((e.meta.separator === "comma" ? "," : ";") + " ")}}`, "Jsdoc\
+TypeObject"),
+        JsdocTypeOptional: /* @__PURE__ */ r((e, t) => oe(e.meta.position, t(e.element), "="), "JsdocTypeOptional"),
+        JsdocTypeSymbol: /* @__PURE__ */ r((e, t) => `${e.value}(${e.element !== void 0 ? t(e.element) : ""})`, "JsdocTypeSymbol"),
+        JsdocTypeTypeof: /* @__PURE__ */ r((e, t) => `typeof ${t(e.element)}`, "JsdocTypeTypeof"),
+        JsdocTypeUndefined: /* @__PURE__ */ r(() => "undefined", "JsdocTypeUndefined"),
+        JsdocTypeUnion: /* @__PURE__ */ r((e, t) => e.elements.map(t).join(" | "), "JsdocTypeUnion"),
+        JsdocTypeUnknown: /* @__PURE__ */ r(() => "?", "JsdocTypeUnknown"),
+        JsdocTypeIntersection: /* @__PURE__ */ r((e, t) => e.elements.map(t).join(" & "), "JsdocTypeIntersection"),
+        JsdocTypeProperty: /* @__PURE__ */ r((e) => I(e.value, e.meta.quote), "JsdocTypeProperty"),
+        JsdocTypePredicate: /* @__PURE__ */ r((e, t) => `${t(e.left)} is ${t(e.right)}`, "JsdocTypePredicate"),
+        JsdocTypeIndexSignature: /* @__PURE__ */ r((e, t) => `[${e.key}: ${t(e.right)}]`, "JsdocTypeIndexSignature"),
+        JsdocTypeMappedType: /* @__PURE__ */ r((e, t) => `[${e.key} in ${t(e.right)}]`, "JsdocTypeMappedType")
+      };
+    }
+    r(nt, "stringifyRules");
+    let ar = nt();
+    function ir(e) {
+      return W(ar, e);
+    }
+    r(ir, "stringify");
+    let pr = [
+      "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 F(e) {
+      let t = {
+        type: "NameExpression",
+        name: e
+      };
+      return pr.includes(e) && (t.reservedWord = !0), t;
+    }
+    r(F, "makeName");
+    let cr = {
+      JsdocTypeOptional: /* @__PURE__ */ r((e, t) => {
+        let o = t(e.element);
+        return o.optional = !0, o;
+      }, "JsdocTypeOptional"),
+      JsdocTypeNullable: /* @__PURE__ */ r((e, t) => {
+        let o = t(e.element);
+        return o.nullable = !0, o;
+      }, "JsdocTypeNullable"),
+      JsdocTypeNotNullable: /* @__PURE__ */ r((e, t) => {
+        let o = t(e.element);
+        return o.nullable = !1, o;
+      }, "JsdocTypeNotNullable"),
+      JsdocTypeVariadic: /* @__PURE__ */ r((e, t) => {
+        if (e.element === void 0)
+          throw new Error("dots without value are not allowed in catharsis mode");
+        let o = t(e.element);
+        return o.repeatable = !0, o;
+      }, "JsdocTypeVariadic"),
+      JsdocTypeAny: /* @__PURE__ */ r(() => ({
+        type: "AllLiteral"
+      }), "JsdocTypeAny"),
+      JsdocTypeNull: /* @__PURE__ */ r(() => ({
+        type: "NullLiteral"
+      }), "JsdocTypeNull"),
+      JsdocTypeStringValue: /* @__PURE__ */ r((e) => F(I(e.value, e.meta.quote)), "JsdocTypeStringValue"),
+      JsdocTypeUndefined: /* @__PURE__ */ r(() => ({
+        type: "UndefinedLiteral"
+      }), "JsdocTypeUndefined"),
+      JsdocTypeUnknown: /* @__PURE__ */ r(() => ({
+        type: "UnknownLiteral"
+      }), "JsdocTypeUnknown"),
+      JsdocTypeFunction: /* @__PURE__ */ r((e, t) => {
+        let o = rt(e), i = {
+          type: "FunctionType",
+          params: o.params.map(t)
+        };
+        return o.this !== void 0 && (i.this = t(o.this)), o.new !== void 0 && (i.new = t(o.new)), e.returnType !== void 0 && (i.result = t(e.
+        returnType)), i;
+      }, "JsdocTypeFunction"),
+      JsdocTypeGeneric: /* @__PURE__ */ r((e, t) => ({
+        type: "TypeApplication",
+        applications: e.elements.map((o) => t(o)),
+        expression: t(e.left)
+      }), "JsdocTypeGeneric"),
+      JsdocTypeSpecialNamePath: /* @__PURE__ */ r((e) => F(e.specialType + ":" + I(e.value, e.meta.quote)), "JsdocTypeSpecialNamePath"),
+      JsdocTypeName: /* @__PURE__ */ r((e) => e.value !== "function" ? F(e.value) : {
+        type: "FunctionType",
+        params: []
+      }, "JsdocTypeName"),
+      JsdocTypeNumber: /* @__PURE__ */ r((e) => F(e.value.toString()), "JsdocTypeNumber"),
+      JsdocTypeObject: /* @__PURE__ */ r((e, t) => {
+        let o = {
+          type: "RecordType",
+          fields: []
+        };
+        for (let i of e.elements)
+          i.type !== "JsdocTypeObjectField" && i.type !== "JsdocTypeJsdocObjectField" ? o.fields.push({
+            type: "FieldType",
+            key: t(i),
+            value: void 0
+          }) : o.fields.push(t(i));
+        return o;
+      }, "JsdocTypeObject"),
+      JsdocTypeObjectField: /* @__PURE__ */ r((e, t) => {
+        if (typeof e.key != "string")
+          throw new Error("Index signatures and mapped types are not supported");
+        return {
+          type: "FieldType",
+          key: F(I(e.key, e.meta.quote)),
+          value: e.right === void 0 ? void 0 : t(e.right)
+        };
+      }, "JsdocTypeObjectField"),
+      JsdocTypeJsdocObjectField: /* @__PURE__ */ r((e, t) => ({
+        type: "FieldType",
+        key: t(e.left),
+        value: t(e.right)
+      }), "JsdocTypeJsdocObjectField"),
+      JsdocTypeUnion: /* @__PURE__ */ r((e, t) => ({
+        type: "TypeUnion",
+        elements: e.elements.map((o) => t(o))
+      }), "JsdocTypeUnion"),
+      JsdocTypeKeyValue: /* @__PURE__ */ r((e, t) => ({
+        type: "FieldType",
+        key: F(e.key),
+        value: e.right === void 0 ? void 0 : t(e.right)
+      }), "JsdocTypeKeyValue"),
+      JsdocTypeNamePath: /* @__PURE__ */ r((e, t) => {
+        let o = t(e.left), i;
+        e.right.type === "JsdocTypeSpecialNamePath" ? i = t(e.right).name : i = I(e.right.value, e.right.meta.quote);
+        let l = e.pathType === "inner" ? "~" : e.pathType === "instance" ? "#" : ".";
+        return F(`${o.name}${l}${i}`);
+      }, "JsdocTypeNamePath"),
+      JsdocTypeSymbol: /* @__PURE__ */ r((e) => {
+        let t = "", o = e.element, i = !1;
+        return o?.type === "JsdocTypeVariadic" && (o.meta.position === "prefix" ? t = "..." : i = !0, o = o.element), o?.type === "JsdocType\
+Name" ? t += o.value : o?.type === "JsdocTypeNumber" && (t += o.value.toString()), i && (t += "..."), F(`${e.value}(${t})`);
+      }, "JsdocTypeSymbol"),
+      JsdocTypeParenthesis: /* @__PURE__ */ r((e, t) => t(P(e.element)), "JsdocTypeParenthesis"),
+      JsdocTypeMappedType: O,
+      JsdocTypeIndexSignature: O,
+      JsdocTypeImport: O,
+      JsdocTypeKeyof: O,
+      JsdocTypeTuple: O,
+      JsdocTypeTypeof: O,
+      JsdocTypeIntersection: O,
+      JsdocTypeProperty: O,
+      JsdocTypePredicate: O
+    };
+    function lr(e) {
+      return W(cr, e);
+    }
+    r(lr, "catharsisTransform");
+    function _(e) {
+      switch (e) {
+        case void 0:
+          return "none";
+        case "single":
+          return "single";
+        case "double":
+          return "double";
+      }
+    }
+    r(_, "getQuoteStyle");
+    function ur(e) {
+      switch (e) {
+        case "inner":
+          return "INNER_MEMBER";
+        case "instance":
+          return "INSTANCE_MEMBER";
+        case "property":
+          return "MEMBER";
+        case "property-brackets":
+          return "MEMBER";
+      }
+    }
+    r(ur, "getMemberType");
+    function Oe(e, t) {
+      return t.length === 2 ? {
+        type: e,
+        left: t[0],
+        right: t[1]
+      } : {
+        type: e,
+        left: t[0],
+        right: Oe(e, t.slice(1))
+      };
+    }
+    r(Oe, "nestResults");
+    let mr = {
+      JsdocTypeOptional: /* @__PURE__ */ r((e, t) => ({
+        type: "OPTIONAL",
+        value: t(e.element),
+        meta: {
+          syntax: e.meta.position === "prefix" ? "PREFIX_EQUAL_SIGN" : "SUFFIX_EQUALS_SIGN"
+        }
+      }), "JsdocTypeOptional"),
+      JsdocTypeNullable: /* @__PURE__ */ r((e, t) => ({
+        type: "NULLABLE",
+        value: t(e.element),
+        meta: {
+          syntax: e.meta.position === "prefix" ? "PREFIX_QUESTION_MARK" : "SUFFIX_QUESTION_MARK"
+        }
+      }), "JsdocTypeNullable"),
+      JsdocTypeNotNullable: /* @__PURE__ */ r((e, t) => ({
+        type: "NOT_NULLABLE",
+        value: t(e.element),
+        meta: {
+          syntax: e.meta.position === "prefix" ? "PREFIX_BANG" : "SUFFIX_BANG"
+        }
+      }), "JsdocTypeNotNullable"),
+      JsdocTypeVariadic: /* @__PURE__ */ r((e, t) => {
+        let o = {
+          type: "VARIADIC",
+          meta: {
+            syntax: e.meta.position === "prefix" ? "PREFIX_DOTS" : e.meta.position === "suffix" ? "SUFFIX_DOTS" : "ONLY_DOTS"
+          }
+        };
+        return e.element !== void 0 && (o.value = t(e.element)), o;
+      }, "JsdocTypeVariadic"),
+      JsdocTypeName: /* @__PURE__ */ r((e) => ({
+        type: "NAME",
+        name: e.value
+      }), "JsdocTypeName"),
+      JsdocTypeTypeof: /* @__PURE__ */ r((e, t) => ({
+        type: "TYPE_QUERY",
+        name: t(e.element)
+      }), "JsdocTypeTypeof"),
+      JsdocTypeTuple: /* @__PURE__ */ r((e, t) => ({
+        type: "TUPLE",
+        entries: e.elements.map(t)
+      }), "JsdocTypeTuple"),
+      JsdocTypeKeyof: /* @__PURE__ */ r((e, t) => ({
+        type: "KEY_QUERY",
+        value: t(e.element)
+      }), "JsdocTypeKeyof"),
+      JsdocTypeImport: /* @__PURE__ */ r((e) => ({
+        type: "IMPORT",
+        path: {
+          type: "STRING_VALUE",
+          quoteStyle: _(e.element.meta.quote),
+          string: e.element.value
+        }
+      }), "JsdocTypeImport"),
+      JsdocTypeUndefined: /* @__PURE__ */ r(() => ({
+        type: "NAME",
+        name: "undefined"
+      }), "JsdocTypeUndefined"),
+      JsdocTypeAny: /* @__PURE__ */ r(() => ({
+        type: "ANY"
+      }), "JsdocTypeAny"),
+      JsdocTypeFunction: /* @__PURE__ */ r((e, t) => {
+        let o = rt(e), i = {
+          type: e.arrow ? "ARROW" : "FUNCTION",
+          params: o.params.map((l) => {
+            if (l.type === "JsdocTypeKeyValue") {
+              if (l.right === void 0)
+                throw new Error("Function parameter without ':' is not expected to be 'KEY_VALUE'");
+              return {
+                type: "NAMED_PARAMETER",
+                name: l.key,
+                typeName: t(l.right)
+              };
+            } else
+              return t(l);
+          }),
+          new: null,
+          returns: null
+        };
+        return o.this !== void 0 ? i.this = t(o.this) : e.arrow || (i.this = null), o.new !== void 0 && (i.new = t(o.new)), e.returnType !==
+        void 0 && (i.returns = t(e.returnType)), i;
+      }, "JsdocTypeFunction"),
+      JsdocTypeGeneric: /* @__PURE__ */ r((e, t) => {
+        let o = {
+          type: "GENERIC",
+          subject: t(e.left),
+          objects: e.elements.map(t),
+          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 && (o.objects[0] = {
+          type: "NAME",
+          name: "function"
+        }), o;
+      }, "JsdocTypeGeneric"),
+      JsdocTypeObjectField: /* @__PURE__ */ r((e, t) => {
+        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: _(e.meta.quote),
+            value: null,
+            readonly: !1
+          };
+        let o = t(e.right);
+        return e.optional && (o = {
+          type: "OPTIONAL",
+          value: o,
+          meta: {
+            syntax: "SUFFIX_KEY_QUESTION_MARK"
+          }
+        }), {
+          type: "RECORD_ENTRY",
+          key: e.key.toString(),
+          quoteStyle: _(e.meta.quote),
+          value: o,
+          readonly: !1
+        };
+      }, "JsdocTypeObjectField"),
+      JsdocTypeJsdocObjectField: /* @__PURE__ */ r(() => {
+        throw new Error("Keys may not be typed in jsdoctypeparser.");
+      }, "JsdocTypeJsdocObjectField"),
+      JsdocTypeKeyValue: /* @__PURE__ */ r((e, t) => {
+        if (e.right === void 0)
+          return {
+            type: "RECORD_ENTRY",
+            key: e.key,
+            quoteStyle: "none",
+            value: null,
+            readonly: !1
+          };
+        let o = t(e.right);
+        return e.optional && (o = {
+          type: "OPTIONAL",
+          value: o,
+          meta: {
+            syntax: "SUFFIX_KEY_QUESTION_MARK"
+          }
+        }), {
+          type: "RECORD_ENTRY",
+          key: e.key,
+          quoteStyle: "none",
+          value: o,
+          readonly: !1
+        };
+      }, "JsdocTypeKeyValue"),
+      JsdocTypeObject: /* @__PURE__ */ r((e, t) => {
+        let o = [];
+        for (let i of e.elements)
+          (i.type === "JsdocTypeObjectField" || i.type === "JsdocTypeJsdocObjectField") && o.push(t(i));
+        return {
+          type: "RECORD",
+          entries: o
+        };
+      }, "JsdocTypeObject"),
+      JsdocTypeSpecialNamePath: /* @__PURE__ */ r((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: _(e.meta.quote),
+            path: e.value
+          }
+        };
+      }, "JsdocTypeSpecialNamePath"),
+      JsdocTypeNamePath: /* @__PURE__ */ r((e, t) => {
+        let o = !1, i, l;
+        e.right.type === "JsdocTypeSpecialNamePath" && e.right.specialType === "event" ? (o = !0, i = e.right.value, l = _(e.right.meta.quote)) :
+        (i = e.right.value, l = _(e.right.meta.quote));
+        let y = {
+          type: ur(e.pathType),
+          owner: t(e.left),
+          name: i,
+          quoteStyle: l,
+          hasEventPrefix: o
+        };
+        if (y.owner.type === "MODULE") {
+          let d = y.owner;
+          return y.owner = y.owner.value, d.value = y, d;
+        } else
+          return y;
+      }, "JsdocTypeNamePath"),
+      JsdocTypeUnion: /* @__PURE__ */ r((e, t) => Oe("UNION", e.elements.map(t)), "JsdocTypeUnion"),
+      JsdocTypeParenthesis: /* @__PURE__ */ r((e, t) => ({
+        type: "PARENTHESIS",
+        value: t(P(e.element))
+      }), "JsdocTypeParenthesis"),
+      JsdocTypeNull: /* @__PURE__ */ r(() => ({
+        type: "NAME",
+        name: "null"
+      }), "JsdocTypeNull"),
+      JsdocTypeUnknown: /* @__PURE__ */ r(() => ({
+        type: "UNKNOWN"
+      }), "JsdocTypeUnknown"),
+      JsdocTypeStringValue: /* @__PURE__ */ r((e) => ({
+        type: "STRING_VALUE",
+        quoteStyle: _(e.meta.quote),
+        string: e.value
+      }), "JsdocTypeStringValue"),
+      JsdocTypeIntersection: /* @__PURE__ */ r((e, t) => Oe("INTERSECTION", e.elements.map(t)), "JsdocTypeIntersection"),
+      JsdocTypeNumber: /* @__PURE__ */ r((e) => ({
+        type: "NUMBER_VALUE",
+        number: e.value.toString()
+      }), "JsdocTypeNumber"),
+      JsdocTypeSymbol: O,
+      JsdocTypeProperty: O,
+      JsdocTypePredicate: O,
+      JsdocTypeMappedType: O,
+      JsdocTypeIndexSignature: O
+    };
+    function yr(e) {
+      return W(mr, e);
+    }
+    r(yr, "jtpTransform");
+    function fr() {
+      return {
+        JsdocTypeIntersection: /* @__PURE__ */ r((e, t) => ({
+          type: "JsdocTypeIntersection",
+          elements: e.elements.map(t)
+        }), "JsdocTypeIntersection"),
+        JsdocTypeGeneric: /* @__PURE__ */ r((e, t) => ({
+          type: "JsdocTypeGeneric",
+          left: t(e.left),
+          elements: e.elements.map(t),
+          meta: {
+            dot: e.meta.dot,
+            brackets: e.meta.brackets
+          }
+        }), "JsdocTypeGeneric"),
+        JsdocTypeNullable: /* @__PURE__ */ r((e) => e, "JsdocTypeNullable"),
+        JsdocTypeUnion: /* @__PURE__ */ r((e, t) => ({
+          type: "JsdocTypeUnion",
+          elements: e.elements.map(t)
+        }), "JsdocTypeUnion"),
+        JsdocTypeUnknown: /* @__PURE__ */ r((e) => e, "JsdocTypeUnknown"),
+        JsdocTypeUndefined: /* @__PURE__ */ r((e) => e, "JsdocTypeUndefined"),
+        JsdocTypeTypeof: /* @__PURE__ */ r((e, t) => ({
+          type: "JsdocTypeTypeof",
+          element: t(e.element)
+        }), "JsdocTypeTypeof"),
+        JsdocTypeSymbol: /* @__PURE__ */ r((e, t) => {
+          let o = {
+            type: "JsdocTypeSymbol",
+            value: e.value
+          };
+          return e.element !== void 0 && (o.element = t(e.element)), o;
+        }, "JsdocTypeSymbol"),
+        JsdocTypeOptional: /* @__PURE__ */ r((e, t) => ({
+          type: "JsdocTypeOptional",
+          element: t(e.element),
+          meta: {
+            position: e.meta.position
+          }
+        }), "JsdocTypeOptional"),
+        JsdocTypeObject: /* @__PURE__ */ r((e, t) => ({
+          type: "JsdocTypeObject",
+          meta: {
+            separator: "comma"
+          },
+          elements: e.elements.map(t)
+        }), "JsdocTypeObject"),
+        JsdocTypeNumber: /* @__PURE__ */ r((e) => e, "JsdocTypeNumber"),
+        JsdocTypeNull: /* @__PURE__ */ r((e) => e, "JsdocTypeNull"),
+        JsdocTypeNotNullable: /* @__PURE__ */ r((e, t) => ({
+          type: "JsdocTypeNotNullable",
+          element: t(e.element),
+          meta: {
+            position: e.meta.position
+          }
+        }), "JsdocTypeNotNullable"),
+        JsdocTypeSpecialNamePath: /* @__PURE__ */ r((e) => e, "JsdocTypeSpecialNamePath"),
+        JsdocTypeObjectField: /* @__PURE__ */ r((e, t) => ({
+          type: "JsdocTypeObjectField",
+          key: e.key,
+          right: e.right === void 0 ? void 0 : t(e.right),
+          optional: e.optional,
+          readonly: e.readonly,
+          meta: e.meta
+        }), "JsdocTypeObjectField"),
+        JsdocTypeJsdocObjectField: /* @__PURE__ */ r((e, t) => ({
+          type: "JsdocTypeJsdocObjectField",
+          left: t(e.left),
+          right: t(e.right)
+        }), "JsdocTypeJsdocObjectField"),
+        JsdocTypeKeyValue: /* @__PURE__ */ r((e, t) => ({
+          type: "JsdocTypeKeyValue",
+          key: e.key,
+          right: e.right === void 0 ? void 0 : t(e.right),
+          optional: e.optional,
+          variadic: e.variadic
+        }), "JsdocTypeKeyValue"),
+        JsdocTypeImport: /* @__PURE__ */ r((e, t) => ({
+          type: "JsdocTypeImport",
+          element: t(e.element)
+        }), "JsdocTypeImport"),
+        JsdocTypeAny: /* @__PURE__ */ r((e) => e, "JsdocTypeAny"),
+        JsdocTypeStringValue: /* @__PURE__ */ r((e) => e, "JsdocTypeStringValue"),
+        JsdocTypeNamePath: /* @__PURE__ */ r((e) => e, "JsdocTypeNamePath"),
+        JsdocTypeVariadic: /* @__PURE__ */ r((e, t) => {
+          let o = {
+            type: "JsdocTypeVariadic",
+            meta: {
+              position: e.meta.position,
+              squareBrackets: e.meta.squareBrackets
+            }
+          };
+          return e.element !== void 0 && (o.element = t(e.element)), o;
+        }, "JsdocTypeVariadic"),
+        JsdocTypeTuple: /* @__PURE__ */ r((e, t) => ({
+          type: "JsdocTypeTuple",
+          elements: e.elements.map(t)
+        }), "JsdocTypeTuple"),
+        JsdocTypeName: /* @__PURE__ */ r((e) => e, "JsdocTypeName"),
+        JsdocTypeFunction: /* @__PURE__ */ r((e, t) => {
+          let o = {
+            type: "JsdocTypeFunction",
+            arrow: e.arrow,
+            parameters: e.parameters.map(t),
+            constructor: e.constructor,
+            parenthesis: e.parenthesis
+          };
+          return e.returnType !== void 0 && (o.returnType = t(e.returnType)), o;
+        }, "JsdocTypeFunction"),
+        JsdocTypeKeyof: /* @__PURE__ */ r((e, t) => ({
+          type: "JsdocTypeKeyof",
+          element: t(e.element)
+        }), "JsdocTypeKeyof"),
+        JsdocTypeParenthesis: /* @__PURE__ */ r((e, t) => ({
+          type: "JsdocTypeParenthesis",
+          element: t(e.element)
+        }), "JsdocTypeParenthesis"),
+        JsdocTypeProperty: /* @__PURE__ */ r((e) => e, "JsdocTypeProperty"),
+        JsdocTypePredicate: /* @__PURE__ */ r((e, t) => ({
+          type: "JsdocTypePredicate",
+          left: t(e.left),
+          right: t(e.right)
+        }), "JsdocTypePredicate"),
+        JsdocTypeIndexSignature: /* @__PURE__ */ r((e, t) => ({
+          type: "JsdocTypeIndexSignature",
+          key: e.key,
+          right: t(e.right)
+        }), "JsdocTypeIndexSignature"),
+        JsdocTypeMappedType: /* @__PURE__ */ r((e, t) => ({
+          type: "JsdocTypeMappedType",
+          key: e.key,
+          right: t(e.right)
+        }), "JsdocTypeMappedType")
+      };
+    }
+    r(fr, "identityTransformRules");
+    let ot = {
+      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"]
+    };
+    function De(e, t, o, i, l) {
+      i?.(e, t, o);
+      let y = ot[e.type];
+      for (let d of y) {
+        let x = e[d];
+        if (x !== void 0)
+          if (Array.isArray(x))
+            for (let N of x)
+              De(N, e, d, i, l);
+          else
+            De(x, e, d, i, l);
+      }
+      l?.(e, t, o);
+    }
+    r(De, "_traverse");
+    function dr(e, t, o) {
+      De(e, void 0, void 0, t, o);
+    }
+    r(dr, "traverse"), n.catharsisTransform = lr, n.identityTransformRules = fr, n.jtpTransform = yr, n.parse = tt, n.stringify = ir, n.stringifyRules =
+    nt, n.transform = W, n.traverse = dr, n.tryParse = sr, n.visitorKeys = ot;
+  });
+});
 
 // src/docs-tools/index.ts
-var Jt = {};
-Fe(Jt, {
-  ADDON_ID: () => K,
-  MAX_DEFAULT_VALUE_SUMMARY_LENGTH: () => at,
-  MAX_TYPE_SUMMARY_LENGTH: () => pt,
-  PANEL_ID: () => wt,
-  PARAM_KEY: () => Et,
-  SNIPPET_RENDERED: () => jt,
-  SourceType: () => Se,
-  TypeSystem: () => te,
-  convert: () => b,
-  createSummaryValue: () => l,
-  enhanceArgTypes: () => vt,
-  extractComponentDescription: () => Ot,
-  extractComponentProps: () => St,
-  extractComponentSectionArray: () => Te,
-  extractComponentSectionObject: () => he,
-  getDocgenDescription: () => C,
-  getDocgenSection: () => V,
-  hasDocgen: () => R,
-  hasDocsOrControls: () => Ft,
-  isDefaultValueBlacklisted: () => d,
-  isTooLongForDefaultValueSummary: () => q,
-  isTooLongForTypeSummary: () => j,
-  isValidDocgenSection: () => A,
-  normalizeNewlines: () => ct,
-  parseJsDoc: () => Y,
-  str: () => N
+var En = {};
+wr(En, {
+  ADDON_ID: () => Ge,
+  MAX_DEFAULT_VALUE_SUMMARY_LENGTH: () => en,
+  MAX_TYPE_SUMMARY_LENGTH: () => Zr,
+  PANEL_ID: () => xn,
+  PARAM_KEY: () => Jn,
+  SNIPPET_RENDERED: () => Pn,
+  SourceType: () => Ft,
+  TypeSystem: () => ut,
+  convert: () => H,
+  createSummaryValue: () => J,
+  enhanceArgTypes: () => hn,
+  extractComponentDescription: () => gn,
+  extractComponentProps: () => Tn,
+  extractComponentSectionArray: () => At,
+  extractComponentSectionObject: () => Rt,
+  getDocgenDescription: () => Fe,
+  getDocgenSection: () => Ie,
+  hasDocgen: () => Ae,
+  hasDocsOrControls: () => bn,
+  isDefaultValueBlacklisted: () => L,
+  isTooLongForDefaultValueSummary: () => qe,
+  isTooLongForTypeSummary: () => me,
+  isValidDocgenSection: () => Re,
+  normalizeNewlines: () => tn,
+  parseJsDoc: () => $e,
+  str: () => ke
 });
-module.exports = Ne(Jt);
+module.exports = Er(En);
 
 // src/docs-tools/argTypes/convert/flow/convert.ts
-var Q = require("storybook/internal/preview-errors");
-var Re = /* @__PURE__ */ o((e) => e.name === "literal", "isLiteral"), Ae = /* @__PURE__ */ o((e) => e.value.replace(/['|"]/g, ""), "toEnumOp\
-tion"), Ve = /* @__PURE__ */ o((e) => {
-  switch (e.type) {
+var pt = require("storybook/internal/preview-errors");
+var Sr = /* @__PURE__ */ r((n) => n.name === "literal", "isLiteral"), Nr = /* @__PURE__ */ r((n) => n.value.replace(/['|"]/g, ""), "toEnumOp\
+tion"), Or = /* @__PURE__ */ r((n) => {
+  switch (n.type) {
     case "function":
       return { name: "function" };
     case "object":
-      let t = {};
-      return e.signature.properties.forEach((r) => {
-        t[r.key] = x(r.value);
+      let s = {};
+      return n.signature.properties.forEach((a) => {
+        s[a.key] = B(a.value);
       }), {
         name: "object",
-        value: t
+        value: s
       };
     default:
-      throw new Q.UnknownArgTypesError({ type: e, language: "Flow" });
+      throw new pt.UnknownArgTypesError({ type: n, language: "Flow" });
   }
-}, "convertSig"), x = /* @__PURE__ */ o((e) => {
-  let { name: t, raw: r } = e, n = {};
-  switch (typeof r < "u" && (n.raw = r), e.name) {
+}, "convertSig"), B = /* @__PURE__ */ r((n) => {
+  let { name: s, raw: a } = n, p = {};
+  switch (typeof a < "u" && (p.raw = a), n.name) {
     case "literal":
-      return { ...n, name: "other", value: e.value };
+      return { ...p, name: "other", value: n.value };
     case "string":
     case "number":
     case "symbol":
     case "boolean":
-      return { ...n, name: t };
+      return { ...p, name: s };
     case "Array":
-      return { ...n, name: "array", value: e.elements.map(x) };
+      return { ...p, name: "array", value: n.elements.map(B) };
     case "signature":
-      return { ...n, ...Ve(e) };
+      return { ...p, ...Or(n) };
     case "union":
-      return e.elements?.every(Re) ? { ...n, name: "enum", value: e.elements?.map(Ae) } : { ...n, name: t, value: e.elements?.map(x) };
+      return n.elements?.every(Sr) ? { ...p, name: "enum", value: n.elements?.map(Nr) } : { ...p, name: s, value: n.elements?.map(B) };
     case "intersection":
-      return { ...n, name: t, value: e.elements?.map(x) };
+      return { ...p, name: s, value: n.elements?.map(B) };
     default:
-      return { ...n, name: "other", value: t };
+      return { ...p, name: "other", value: s };
   }
 }, "convert");
 
+// ../node_modules/es-toolkit/dist/predicate/isPlainObject.mjs
+function X(n) {
+  if (typeof n != "object" || n == null)
+    return !1;
+  if (Object.getPrototypeOf(n) === null)
+    return !0;
+  if (n.toString() !== "[object Object]")
+    return !1;
+  let s = n;
+  for (; Object.getPrototypeOf(s) !== null; )
+    s = Object.getPrototypeOf(s);
+  return Object.getPrototypeOf(n) === s;
+}
+r(X, "isPlainObject");
+
 // ../node_modules/es-toolkit/dist/object/mapValues.mjs
-function J(e, t) {
-  let r = {}, n = Object.keys(e);
-  for (let s = 0; s < n.length; s++) {
-    let i = n[s], p = e[i];
-    r[i] = t(p, i, e);
+function ve(n, s) {
+  let a = {}, p = Object.keys(n);
+  for (let c = 0; c < p.length; c++) {
+    let u = p[c], m = n[u];
+    a[u] = s(m, u, n);
   }
-  return r;
+  return a;
 }
-o(J, "mapValues");
+r(ve, "mapValues");
 
 // src/docs-tools/argTypes/convert/utils.ts
-var Z = /^['"]|['"]$/g, Ce = /* @__PURE__ */ o((e) => e.replace(Z, ""), "trimQuotes"), _e = /* @__PURE__ */ o((e) => Z.test(e), "includesQuo\
-tes"), S = /* @__PURE__ */ o((e) => {
-  let t = Ce(e);
-  return _e(e) || Number.isNaN(Number(t)) ? t : Number(t);
+var ct = /^['"]|['"]$/g, Dr = /* @__PURE__ */ r((n) => n.replace(ct, ""), "trimQuotes"), vr = /* @__PURE__ */ r((n) => ct.test(n), "includes\
+Quotes"), ae = /* @__PURE__ */ r((n) => {
+  let s = Dr(n);
+  return vr(n) || Number.isNaN(Number(s)) ? s : Number(s);
 }, "parseLiteral");
 
 // src/docs-tools/argTypes/convert/proptypes/convert.ts
-var Be = /^\(.*\) => /, D = /* @__PURE__ */ o((e) => {
-  let { name: t, raw: r, computed: n, value: s } = e, i = {};
-  switch (typeof r < "u" && (i.raw = r), t) {
+var kr = /^\(.*\) => /, C = /* @__PURE__ */ r((n) => {
+  let { name: s, raw: a, computed: p, value: c } = n, u = {};
+  switch (typeof a < "u" && (u.raw = a), s) {
     case "enum": {
-      let a = n ? s : s.map((c) => S(c.value));
-      return { ...i, name: t, value: a };
+      let T = p ? c : c.map((g) => ae(g.value));
+      return { ...u, name: s, value: T };
     }
     case "string":
     case "number":
     case "symbol":
-      return { ...i, name: t };
+      return { ...u, name: s };
     case "func":
-      return { ...i, name: "function" };
+      return { ...u, name: "function" };
     case "bool":
     case "boolean":
-      return { ...i, name: "boolean" };
+      return { ...u, name: "boolean" };
     case "arrayOf":
     case "array":
-      return { ...i, name: "array", value: s && D(s) };
+      return { ...u, name: "array", value: c && C(c) };
     case "object":
-      return { ...i, name: t };
+      return { ...u, name: s };
     case "objectOf":
-      return { ...i, name: t, value: D(s) };
+      return { ...u, name: s, value: C(c) };
     case "shape":
     case "exact":
-      let p = J(s, (a) => D(a));
-      return { ...i, name: "object", value: p };
+      let m = ve(c, (T) => C(T));
+      return { ...u, name: "object", value: m };
     case "union":
-      return { ...i, name: "union", value: s.map((a) => D(a)) };
+      return { ...u, name: "union", value: c.map((T) => C(T)) };
     case "instanceOf":
     case "element":
     case "elementType":
     default: {
-      if (t?.indexOf("|") > 0)
+      if (s?.indexOf("|") > 0)
         try {
-          let u = t.split("|").map((m) => JSON.parse(m));
-          return { ...i, name: "enum", value: u };
+          let w = s.split("|").map((b) => JSON.parse(b));
+          return { ...u, name: "enum", value: w };
         } catch {
         }
-      let a = s ? `${t}(${s})` : t, c = Be.test(t) ? "function" : "other";
-      return { ...i, name: c, value: a };
+      let T = c ? `${s}(${c})` : s, g = kr.test(s) ? "function" : "other";
+      return { ...u, name: g, value: T };
     }
   }
 }, "convert");
 
 // src/docs-tools/argTypes/convert/typescript/convert.ts
-var ee = require("storybook/internal/preview-errors");
-var Ie = /* @__PURE__ */ o((e) => {
-  switch (e.type) {
+var lt = require("storybook/internal/preview-errors");
+var Ar = /* @__PURE__ */ r((n) => {
+  switch (n.type) {
     case "function":
       return { name: "function" };
     case "object":
-      let t = {};
-      return e.signature.properties.forEach((r) => {
-        t[r.key] = T(r.value);
+      let s = {};
+      return n.signature.properties.forEach((a) => {
+        s[a.key] = M(a.value);
       }), {
         name: "object",
-        value: t
+        value: s
       };
     default:
-      throw new ee.UnknownArgTypesError({ type: e, language: "Typescript" });
+      throw new lt.UnknownArgTypesError({ type: n, language: "Typescript" });
   }
-}, "convertSig"), T = /* @__PURE__ */ o((e) => {
-  let { name: t, raw: r } = e, n = {};
-  switch (typeof r < "u" && (n.raw = r), e.name) {
+}, "convertSig"), M = /* @__PURE__ */ r((n) => {
+  let { name: s, raw: a } = n, p = {};
+  switch (typeof a < "u" && (p.raw = a), n.name) {
     case "string":
     case "number":
     case "symbol":
     case "boolean":
-      return { ...n, name: t };
+      return { ...p, name: s };
     case "Array":
-      return { ...n, name: "array", value: e.elements.map(T) };
+      return { ...p, name: "array", value: n.elements.map(M) };
     case "signature":
-      return { ...n, ...Ie(e) };
+      return { ...p, ...Ar(n) };
     case "union":
-      let s;
-      return e.elements?.every((i) => i.name === "literal") ? s = {
-        ...n,
+      let c;
+      return n.elements?.every((u) => u.name === "literal") ? c = {
+        ...p,
         name: "enum",
         // @ts-expect-error fix types
-        value: e.elements?.map((i) => S(i.value))
-      } : s = { ...n, name: t, value: e.elements?.map(T) }, s;
+        value: n.elements?.map((u) => ae(u.value))
+      } : c = { ...p, name: s, value: n.elements?.map(M) }, c;
     case "intersection":
-      return { ...n, name: t, value: e.elements?.map(T) };
+      return { ...p, name: s, value: n.elements?.map(M) };
     default:
-      return { ...n, name: "other", value: t };
+      return { ...p, name: "other", value: s };
   }
 }, "convert");
 
 // src/docs-tools/argTypes/convert/index.ts
-var b = /* @__PURE__ */ o((e) => {
-  let { type: t, tsType: r, flowType: n } = e;
+var H = /* @__PURE__ */ r((n) => {
+  let { type: s, tsType: a, flowType: p } = n;
   try {
-    if (t != null)
-      return D(t);
-    if (r != null)
-      return T(r);
-    if (n != null)
-      return x(n);
-  } catch (s) {
-    console.error(s);
+    if (s != null)
+      return C(s);
+    if (a != null)
+      return M(a);
+    if (p != null)
+      return B(p);
+  } catch (c) {
+    console.error(c);
   }
   return null;
 }, "convert");
 
 // src/docs-tools/argTypes/docgen/types.ts
-var te = /* @__PURE__ */ ((s) => (s.JAVASCRIPT = "JavaScript", s.FLOW = "Flow", s.TYPESCRIPT = "TypeScript", s.UNKNOWN = "Unknown", s))(te ||
+var ut = /* @__PURE__ */ ((c) => (c.JAVASCRIPT = "JavaScript", c.FLOW = "Flow", c.TYPESCRIPT = "TypeScript", c.UNKNOWN = "Unknown", c))(ut ||
 {});
 
 // src/docs-tools/argTypes/docgen/utils/defaultValue.ts
-var Le = ["null", "undefined"];
-function d(e) {
-  return Le.some((t) => t === e);
+var Rr = ["null", "undefined"];
+function L(n) {
+  return Rr.some((s) => s === n);
 }
-o(d, "isDefaultValueBlacklisted");
+r(L, "isDefaultValueBlacklisted");
 
 // src/docs-tools/argTypes/docgen/utils/string.ts
-var N = /* @__PURE__ */ o((e) => {
-  if (!e)
+var ke = /* @__PURE__ */ r((n) => {
+  if (!n)
     return "";
-  if (typeof e == "string")
-    return e;
-  throw new Error(`Description: expected string, got: ${JSON.stringify(e)}`);
+  if (typeof n == "string")
+    return n;
+  throw new Error(`Description: expected string, got: ${JSON.stringify(n)}`);
 }, "str");
 
 // src/docs-tools/argTypes/docgen/utils/docgenInfo.ts
-function R(e) {
-  return !!e.__docgenInfo;
+function Ae(n) {
+  return !!n.__docgenInfo;
 }
-o(R, "hasDocgen");
-function A(e) {
-  return e != null && Object.keys(e).length > 0;
+r(Ae, "hasDocgen");
+function Re(n) {
+  return n != null && Object.keys(n).length > 0;
 }
-o(A, "isValidDocgenSection");
-function V(e, t) {
-  return R(e) ? e.__docgenInfo[t] : null;
+r(Re, "isValidDocgenSection");
+function Ie(n, s) {
+  return Ae(n) ? n.__docgenInfo[s] : null;
 }
-o(V, "getDocgenSection");
-function C(e) {
-  return R(e) ? N(e.__docgenInfo.description) : "";
+r(Ie, "getDocgenSection");
+function Fe(n) {
+  return Ae(n) ? ke(n.__docgenInfo.description) : "";
 }
-o(C, "getDocgenDescription");
+r(Fe, "getDocgenDescription");
 
 // ../node_modules/comment-parser/es6/primitives.js
-var f;
-(function(e) {
-  e.start = "/**", e.nostart = "/***", e.delim = "*", e.end = "*/";
-})(f = f || (f = {}));
+var v;
+(function(n) {
+  n.start = "/**", n.nostart = "/***", n.delim = "*", n.end = "*/";
+})(v = v || (v = {}));
 
 // ../node_modules/comment-parser/es6/util.js
-function _(e) {
-  return /^\s+$/.test(e);
+function je(n) {
+  return /^\s+$/.test(n);
 }
-o(_, "isSpace");
-function re(e) {
-  let t = e.match(/\r+$/);
-  return t == null ? ["", e] : [e.slice(-t[0].length), e.slice(0, -t[0].length)];
+r(je, "isSpace");
+function mt(n) {
+  let s = n.match(/\r+$/);
+  return s == null ? ["", n] : [n.slice(-s[0].length), n.slice(0, -s[0].length)];
 }
-o(re, "splitCR");
-function y(e) {
-  let t = e.match(/^\s+/);
-  return t == null ? ["", e] : [e.slice(0, t[0].length), e.slice(t[0].length)];
+r(mt, "splitCR");
+function A(n) {
+  let s = n.match(/^\s+/);
+  return s == null ? ["", n] : [n.slice(0, s[0].length), n.slice(s[0].length)];
 }
-o(y, "splitSpace");
-function oe(e) {
-  return e.split(/\n/);
+r(A, "splitSpace");
+function yt(n) {
+  return n.split(/\n/);
 }
-o(oe, "splitLines");
-function ne(e = {}) {
-  return Object.assign({ tag: "", name: "", type: "", optional: !1, description: "", problems: [], source: [] }, e);
+r(yt, "splitLines");
+function ft(n = {}) {
+  return Object.assign({ tag: "", name: "", type: "", optional: !1, description: "", problems: [], source: [] }, n);
 }
-o(ne, "seedSpec");
-function B(e = {}) {
+r(ft, "seedSpec");
+function _e(n = {}) {
   return Object.assign({ start: "", delimiter: "", postDelimiter: "", tag: "", postTag: "", name: "", postName: "", type: "", postType: "", description: "",
-  end: "", lineEnd: "" }, e);
+  end: "", lineEnd: "" }, n);
 }
-o(B, "seedTokens");
+r(_e, "seedTokens");
 
 // ../node_modules/comment-parser/es6/parser/block-parser.js
-var Ue = /^@\S+/;
-function I({ fence: e = "```" } = {}) {
-  let t = We(e), r = /* @__PURE__ */ o((n, s) => t(n) ? !s : s, "toggleFence");
-  return /* @__PURE__ */ o(function(s) {
-    let i = [[]], p = !1;
-    for (let a of s)
-      Ue.test(a.tokens.description) && !p ? i.push([a]) : i[i.length - 1].push(a), p = r(a.tokens.description, p);
-    return i;
+var Ir = /^@\S+/;
+function Le({ fence: n = "```" } = {}) {
+  let s = Fr(n), a = /* @__PURE__ */ r((p, c) => s(p) ? !c : c, "toggleFence");
+  return /* @__PURE__ */ r(function(c) {
+    let u = [[]], m = !1;
+    for (let T of c)
+      Ir.test(T.tokens.description) && !m ? u.push([T]) : u[u.length - 1].push(T), m = a(T.tokens.description, m);
+    return u;
   }, "parseBlock");
 }
-o(I, "getParser");
-function We(e) {
-  return typeof e == "string" ? (t) => t.split(e).length % 2 === 0 : e;
+r(Le, "getParser");
+function Fr(n) {
+  return typeof n == "string" ? (s) => s.split(n).length % 2 === 0 : n;
 }
-o(We, "getFencer");
+r(Fr, "getFencer");
 
 // ../node_modules/comment-parser/es6/parser/source-parser.js
-function L({ startLine: e = 0, markers: t = f } = {}) {
-  let r = null, n = e;
-  return /* @__PURE__ */ o(function(i) {
-    let p = i, a = B();
-    if ([a.lineEnd, p] = re(p), [a.start, p] = y(p), r === null && p.startsWith(t.start) && !p.startsWith(t.nostart) && (r = [], a.delimiter =
-    p.slice(0, t.start.length), p = p.slice(t.start.length), [a.postDelimiter, p] = y(p)), r === null)
-      return n++, null;
-    let c = p.trimRight().endsWith(t.end);
-    if (a.delimiter === "" && p.startsWith(t.delim) && !p.startsWith(t.end) && (a.delimiter = t.delim, p = p.slice(t.delim.length), [a.postDelimiter,
-    p] = y(p)), c) {
-      let u = p.trimRight();
-      a.end = p.slice(u.length - t.end.length), p = u.slice(0, -t.end.length);
-    }
-    if (a.description = p, r.push({ number: n, source: i, tokens: a }), n++, c) {
-      let u = r.slice();
-      return r = null, u;
+function Ve({ startLine: n = 0, markers: s = v } = {}) {
+  let a = null, p = n;
+  return /* @__PURE__ */ r(function(u) {
+    let m = u, T = _e();
+    if ([T.lineEnd, m] = mt(m), [T.start, m] = A(m), a === null && m.startsWith(s.start) && !m.startsWith(s.nostart) && (a = [], T.delimiter =
+    m.slice(0, s.start.length), m = m.slice(s.start.length), [T.postDelimiter, m] = A(m)), a === null)
+      return p++, null;
+    let g = m.trimRight().endsWith(s.end);
+    if (T.delimiter === "" && m.startsWith(s.delim) && !m.startsWith(s.end) && (T.delimiter = s.delim, m = m.slice(s.delim.length), [T.postDelimiter,
+    m] = A(m)), g) {
+      let w = m.trimRight();
+      T.end = m.slice(w.length - s.end.length), m = w.slice(0, -s.end.length);
+    }
+    if (T.description = m, a.push({ number: p, source: u, tokens: T }), p++, g) {
+      let w = a.slice();
+      return a = null, w;
     }
     return null;
   }, "parseSource");
 }
-o(L, "getParser");
+r(Ve, "getParser");
 
 // ../node_modules/comment-parser/es6/parser/spec-parser.js
-function U({ tokenizers: e }) {
-  return /* @__PURE__ */ o(function(r) {
-    var n;
-    let s = ne({ source: r });
-    for (let i of e)
-      if (s = i(s), !((n = s.problems[s.problems.length - 1]) === null || n === void 0) && n.critical)
+function Ue({ tokenizers: n }) {
+  return /* @__PURE__ */ r(function(a) {
+    var p;
+    let c = ft({ source: a });
+    for (let u of n)
+      if (c = u(c), !((p = c.problems[c.problems.length - 1]) === null || p === void 0) && p.critical)
         break;
-    return s;
+    return c;
   }, "parseSpec");
 }
-o(U, "getParser");
+r(Ue, "getParser");
 
 // ../node_modules/comment-parser/es6/parser/tokenizers/tag.js
-function O() {
-  return (e) => {
-    let { tokens: t } = e.source[0], r = t.description.match(/\s*(@(\S+))(\s*)/);
-    return r === null ? (e.problems.push({
+function ie() {
+  return (n) => {
+    let { tokens: s } = n.source[0], a = s.description.match(/\s*(@(\S+))(\s*)/);
+    return a === null ? (n.problems.push({
       code: "spec:tag:prefix",
       message: 'tag should start with "@" symbol',
-      line: e.source[0].number,
+      line: n.source[0].number,
       critical: !0
-    }), e) : (t.tag = r[1], t.postTag = r[3], t.description = t.description.slice(r[0].length), e.tag = r[2], e);
+    }), n) : (s.tag = a[1], s.postTag = a[3], s.description = s.description.slice(a[0].length), n.tag = a[2], n);
   };
 }
-o(O, "tagTokenizer");
+r(ie, "tagTokenizer");
 
 // ../node_modules/comment-parser/es6/parser/tokenizers/type.js
-function v(e = "compact") {
-  let t = ze(e);
-  return (r) => {
-    let n = 0, s = [];
-    for (let [a, { tokens: c }] of r.source.entries()) {
-      let u = "";
-      if (a === 0 && c.description[0] !== "{")
-        return r;
-      for (let m of c.description)
-        if (m === "{" && n++, m === "}" && n--, u += m, n === 0)
+function pe(n = "compact") {
+  let s = _r(n);
+  return (a) => {
+    let p = 0, c = [];
+    for (let [T, { tokens: g }] of a.source.entries()) {
+      let w = "";
+      if (T === 0 && g.description[0] !== "{")
+        return a;
+      for (let b of g.description)
+        if (b === "{" && p++, b === "}" && p--, w += b, p === 0)
           break;
-      if (s.push([c, u]), n === 0)
+      if (c.push([g, w]), p === 0)
         break;
     }
-    if (n !== 0)
-      return r.problems.push({
+    if (p !== 0)
+      return a.problems.push({
         code: "spec:type:unpaired-curlies",
         message: "unpaired curlies",
-        line: r.source[0].number,
+        line: a.source[0].number,
         critical: !0
-      }), r;
-    let i = [], p = s[0][0].postDelimiter.length;
-    for (let [a, [c, u]] of s.entries())
-      c.type = u, a > 0 && (c.type = c.postDelimiter.slice(p) + u, c.postDelimiter = c.postDelimiter.slice(0, p)), [c.postType, c.description] =
-      y(c.description.slice(u.length)), i.push(c.type);
-    return i[0] = i[0].slice(1), i[i.length - 1] = i[i.length - 1].slice(0, -1), r.type = t(i), r;
+      }), a;
+    let u = [], m = c[0][0].postDelimiter.length;
+    for (let [T, [g, w]] of c.entries())
+      g.type = w, T > 0 && (g.type = g.postDelimiter.slice(m) + w, g.postDelimiter = g.postDelimiter.slice(0, m)), [g.postType, g.description] =
+      A(g.description.slice(w.length)), u.push(g.type);
+    return u[0] = u[0].slice(1), u[u.length - 1] = u[u.length - 1].slice(0, -1), a.type = s(u), a;
   };
 }
-o(v, "typeTokenizer");
-var Me = /* @__PURE__ */ o((e) => e.trim(), "trim");
-function ze(e) {
-  return e === "compact" ? (t) => t.map(Me).join("") : e === "preserve" ? (t) => t.join(`
-`) : e;
+r(pe, "typeTokenizer");
+var jr = /* @__PURE__ */ r((n) => n.trim(), "trim");
+function _r(n) {
+  return n === "compact" ? (s) => s.map(jr).join("") : n === "preserve" ? (s) => s.join(`
+`) : n;
 }
-o(ze, "getJoiner");
+r(_r, "getJoiner");
 
 // ../node_modules/comment-parser/es6/parser/tokenizers/name.js
-var $e = /* @__PURE__ */ o((e) => e && e.startsWith('"') && e.endsWith('"'), "isQuoted");
-function w() {
-  let e = /* @__PURE__ */ o((t, { tokens: r }, n) => r.type === "" ? t : n, "typeEnd");
-  return (t) => {
-    let { tokens: r } = t.source[t.source.reduce(e, 0)], n = r.description.trimLeft(), s = n.split('"');
-    if (s.length > 1 && s[0] === "" && s.length % 2 === 1)
-      return t.name = s[1], r.name = `"${s[1]}"`, [r.postName, r.description] = y(n.slice(r.name.length)), t;
-    let i = 0, p = "", a = !1, c;
-    for (let m of n) {
-      if (i === 0 && _(m))
+var Lr = /* @__PURE__ */ r((n) => n && n.startsWith('"') && n.endsWith('"'), "isQuoted");
+function ce() {
+  let n = /* @__PURE__ */ r((s, { tokens: a }, p) => a.type === "" ? s : p, "typeEnd");
+  return (s) => {
+    let { tokens: a } = s.source[s.source.reduce(n, 0)], p = a.description.trimLeft(), c = p.split('"');
+    if (c.length > 1 && c[0] === "" && c.length % 2 === 1)
+      return s.name = c[1], a.name = `"${c[1]}"`, [a.postName, a.description] = A(p.slice(a.name.length)), s;
+    let u = 0, m = "", T = !1, g;
+    for (let b of p) {
+      if (u === 0 && je(b))
         break;
-      m === "[" && i++, m === "]" && i--, p += m;
+      b === "[" && u++, b === "]" && u--, m += b;
     }
-    if (i !== 0)
-      return t.problems.push({
+    if (u !== 0)
+      return s.problems.push({
         code: "spec:name:unpaired-brackets",
         message: "unpaired brackets",
-        line: t.source[0].number,
+        line: s.source[0].number,
         critical: !0
-      }), t;
-    let u = p;
-    if (p[0] === "[" && p[p.length - 1] === "]") {
-      a = !0, p = p.slice(1, -1);
-      let m = p.split("=");
-      if (p = m[0].trim(), m[1] !== void 0 && (c = m.slice(1).join("=").trim()), p === "")
-        return t.problems.push({
+      }), s;
+    let w = m;
+    if (m[0] === "[" && m[m.length - 1] === "]") {
+      T = !0, m = m.slice(1, -1);
+      let b = m.split("=");
+      if (m = b[0].trim(), b[1] !== void 0 && (g = b.slice(1).join("=").trim()), m === "")
+        return s.problems.push({
           code: "spec:name:empty-name",
           message: "empty name",
-          line: t.source[0].number,
+          line: s.source[0].number,
           critical: !0
-        }), t;
-      if (c === "")
-        return t.problems.push({
+        }), s;
+      if (g === "")
+        return s.problems.push({
           code: "spec:name:empty-default",
           message: "empty default value",
-          line: t.source[0].number,
+          line: s.source[0].number,
           critical: !0
-        }), t;
-      if (!$e(c) && /=(?!>)/.test(c))
-        return t.problems.push({
+        }), s;
+      if (!Lr(g) && /=(?!>)/.test(g))
+        return s.problems.push({
           code: "spec:name:invalid-default",
           message: "invalid default value syntax",
-          line: t.source[0].number,
+          line: s.source[0].number,
           critical: !0
-        }), t;
+        }), s;
     }
-    return t.optional = a, t.name = p, r.name = u, c !== void 0 && (t.default = c), [r.postName, r.description] = y(n.slice(r.name.length)),
-    t;
+    return s.optional = T, s.name = m, a.name = w, g !== void 0 && (s.default = g), [a.postName, a.description] = A(p.slice(a.name.length)),
+    s;
   };
 }
-o(w, "nameTokenizer");
+r(ce, "nameTokenizer");
 
 // ../node_modules/comment-parser/es6/parser/tokenizers/description.js
-function E(e = "compact", t = f) {
-  let r = W(e);
-  return (n) => (n.description = r(n.source, t), n);
-}
-o(E, "descriptionTokenizer");
-function W(e) {
-  return e === "compact" ? Ye : e === "preserve" ? Ke : e;
-}
-o(W, "getJoiner");
-function Ye(e, t = f) {
-  return e.map(({ tokens: { description: r } }) => r.trim()).filter((r) => r !== "").join(" ");
-}
-o(Ye, "compactJoiner");
-var qe = /* @__PURE__ */ o((e, { tokens: t }, r) => t.type === "" ? e : r, "lineNo"), Ge = /* @__PURE__ */ o(({ tokens: e }) => (e.delimiter ===
-"" ? e.start : e.postDelimiter.slice(1)) + e.description, "getDescription");
-function Ke(e, t = f) {
-  if (e.length === 0)
+function le(n = "compact", s = v) {
+  let a = Be(n);
+  return (p) => (p.description = a(p.source, s), p);
+}
+r(le, "descriptionTokenizer");
+function Be(n) {
+  return n === "compact" ? Vr : n === "preserve" ? Cr : n;
+}
+r(Be, "getJoiner");
+function Vr(n, s = v) {
+  return n.map(({ tokens: { description: a } }) => a.trim()).filter((a) => a !== "").join(" ");
+}
+r(Vr, "compactJoiner");
+var Ur = /* @__PURE__ */ r((n, { tokens: s }, a) => s.type === "" ? n : a, "lineNo"), Br = /* @__PURE__ */ r(({ tokens: n }) => (n.delimiter ===
+"" ? n.start : n.postDelimiter.slice(1)) + n.description, "getDescription");
+function Cr(n, s = v) {
+  if (n.length === 0)
     return "";
-  e[0].tokens.description === "" && e[0].tokens.delimiter === t.start && (e = e.slice(1));
-  let r = e[e.length - 1];
-  return r !== void 0 && r.tokens.description === "" && r.tokens.end.endsWith(t.end) && (e = e.slice(0, -1)), e = e.slice(e.reduce(qe, 0)), e.
-  map(Ge).join(`
+  n[0].tokens.description === "" && n[0].tokens.delimiter === s.start && (n = n.slice(1));
+  let a = n[n.length - 1];
+  return a !== void 0 && a.tokens.description === "" && a.tokens.end.endsWith(s.end) && (n = n.slice(0, -1)), n = n.slice(n.reduce(Ur, 0)), n.
+  map(Br).join(`
 `);
 }
-o(Ke, "preserveJoiner");
+r(Cr, "preserveJoiner");
 
 // ../node_modules/comment-parser/es6/parser/index.js
-function M({ startLine: e = 0, fence: t = "```", spacing: r = "compact", markers: n = f, tokenizers: s = [
-  O(),
-  v(r),
-  w(),
-  E(r)
+function Ce({ startLine: n = 0, fence: s = "```", spacing: a = "compact", markers: p = v, tokenizers: c = [
+  ie(),
+  pe(a),
+  ce(),
+  le(a)
 ] } = {}) {
-  if (e < 0 || e % 1 > 0)
+  if (n < 0 || n % 1 > 0)
     throw new Error("Invalid startLine");
-  let i = L({ startLine: e, markers: n }), p = I({ fence: t }), a = U({ tokenizers: s }), c = W(r);
-  return function(u) {
-    let m = [];
-    for (let Oe of oe(u)) {
-      let F = i(Oe);
-      if (F === null)
+  let u = Ve({ startLine: n, markers: p }), m = Le({ fence: s }), T = Ue({ tokenizers: c }), g = Be(a);
+  return function(w) {
+    let b = [];
+    for (let fe of yt(w)) {
+      let $ = u(fe);
+      if ($ === null)
         continue;
-      let X = p(F), H = X.slice(1).map(a);
-      m.push({
-        description: c(X[0], n),
-        tags: H,
-        source: F,
-        problems: H.reduce((ve, we) => ve.concat(we.problems), [])
+      let E = m($), Q = E.slice(1).map(T);
+      b.push({
+        description: g(E[0], p),
+        tags: Q,
+        source: $,
+        problems: Q.reduce((de, Te) => de.concat(Te.problems), [])
       });
     }
-    return m;
+    return b;
   };
 }
-o(M, "getParser");
+r(Ce, "getParser");
 
 // ../node_modules/comment-parser/es6/stringifier/index.js
-function Xe(e) {
-  return e.start + e.delimiter + e.postDelimiter + e.tag + e.postTag + e.type + e.postType + e.name + e.postName + e.description + e.end + e.
+function Mr(n) {
+  return n.start + n.delimiter + n.postDelimiter + n.tag + n.postTag + n.type + n.postType + n.name + n.postName + n.description + n.end + n.
   lineEnd;
 }
-o(Xe, "join");
-function z() {
-  return (e) => e.source.map(({ tokens: t }) => Xe(t)).join(`
+r(Mr, "join");
+function Me() {
+  return (n) => n.source.map(({ tokens: s }) => Mr(s)).join(`
 `);
 }
-o(z, "getStringifier");
+r(Me, "getStringifier");
 
 // ../node_modules/comment-parser/es6/stringifier/inspect.js
-var He = {
+var Kr = {
   line: 0,
   start: 0,
   delimiter: 0,
@@ -526,398 +2509,409 @@ var He = {
   end: 0,
   lineEnd: 0
 };
-var ro = Object.keys(He);
+var Zo = Object.keys(Kr);
 
 // ../node_modules/comment-parser/es6/index.js
-function se(e, t = {}) {
-  return M(t)(e);
+function dt(n, s = {}) {
+  return Ce(s)(n);
 }
-o(se, "parse");
-var Oo = z();
+r(dt, "parse");
+var Js = Me();
 
 // src/docs-tools/argTypes/jsdocParser.ts
-var h = require("jsdoc-type-pratt-parser");
-function Qe(e) {
-  return e != null && e.includes("@");
-}
-o(Qe, "containsJsDoc");
-function Ze(e) {
-  let n = `/**
-` + (e ?? "").split(`
-`).map((i) => ` * ${i}`).join(`
+var K = br(gt(), 1);
+function $r(n) {
+  return n != null && n.includes("@");
+}
+r($r, "containsJsDoc");
+function qr(n) {
+  let p = `/**
+` + (n ?? "").split(`
+`).map((u) => ` * ${u}`).join(`
 `) + `
-*/`, s = se(n, {
+*/`, c = dt(p, {
     spacing: "preserve"
   });
-  if (!s || s.length === 0)
+  if (!c || c.length === 0)
     throw new Error("Cannot parse JSDoc tags.");
-  return s[0];
+  return c[0];
 }
-o(Ze, "parse");
-var et = {
+r(qr, "parse");
+var Yr = {
   tags: ["param", "arg", "argument", "returns", "ignore", "deprecated"]
-}, Y = /* @__PURE__ */ o((e, t = et) => {
-  if (!Qe(e))
+}, $e = /* @__PURE__ */ r((n, s = Yr) => {
+  if (!$r(n))
     return {
       includesJsDoc: !1,
       ignore: !1
     };
-  let r = Ze(e), n = tt(r, t.tags);
-  return n.ignore ? {
+  let a = qr(n), p = Wr(a, s.tags);
+  return p.ignore ? {
     includesJsDoc: !0,
     ignore: !0
   } : {
     includesJsDoc: !0,
     ignore: !1,
     // Always use the parsed description to ensure JSDoc is removed from the description.
-    description: r.description.trim(),
-    extractedTags: n
+    description: a.description.trim(),
+    extractedTags: p
   };
 }, "parseJsDoc");
-function tt(e, t) {
-  let r = {
+function Wr(n, s) {
+  let a = {
     params: null,
     deprecated: null,
     returns: null,
     ignore: !1
   };
-  for (let n of e.tags)
-    if (!(t !== void 0 && !t.includes(n.tag)))
-      if (n.tag === "ignore") {
-        r.ignore = !0;
+  for (let p of n.tags)
+    if (!(s !== void 0 && !s.includes(p.tag)))
+      if (p.tag === "ignore") {
+        a.ignore = !0;
         break;
       } else
-        switch (n.tag) {
+        switch (p.tag) {
           // arg & argument are aliases for param.
           case "param":
           case "arg":
           case "argument": {
-            let s = ot(n);
-            s != null && (r.params == null && (r.params = []), r.params.push(s));
+            let c = zr(p);
+            c != null && (a.params == null && (a.params = []), a.params.push(c));
             break;
           }
           case "deprecated": {
-            let s = nt(n);
-            s != null && (r.deprecated = s);
+            let c = Xr(p);
+            c != null && (a.deprecated = c);
             break;
           }
           case "returns": {
-            let s = st(n);
-            s != null && (r.returns = s);
+            let c = Hr(p);
+            c != null && (a.returns = c);
             break;
           }
           default:
             break;
         }
-  return r;
+  return a;
 }
-o(tt, "extractJsDocTags");
-function rt(e) {
-  return e.replace(/[\.-]$/, "");
+r(Wr, "extractJsDocTags");
+function Gr(n) {
+  return n.replace(/[\.-]$/, "");
 }
-o(rt, "normaliseParamName");
-function ot(e) {
-  if (!e.name || e.name === "-")
+r(Gr, "normaliseParamName");
+function zr(n) {
+  if (!n.name || n.name === "-")
     return null;
-  let t = ae(e.type);
+  let s = Jt(n.type);
   return {
-    name: e.name,
-    type: t,
-    description: pe(e.description),
-    getPrettyName: /* @__PURE__ */ o(() => rt(e.name), "getPrettyName"),
-    getTypeName: /* @__PURE__ */ o(() => t ? ce(t) : null, "getTypeName")
+    name: n.name,
+    type: s,
+    description: xt(n.description),
+    getPrettyName: /* @__PURE__ */ r(() => Gr(n.name), "getPrettyName"),
+    getTypeName: /* @__PURE__ */ r(() => s ? Pt(s) : null, "getTypeName")
   };
 }
-o(ot, "extractParam");
-function nt(e) {
-  return e.name ? ie(e.name, e.description) : null;
-}
-o(nt, "extractDeprecated");
-function ie(e, t) {
-  let r = e === "" ? t : `${e} ${t}`;
-  return pe(r);
-}
-o(ie, "joinNameAndDescription");
-function pe(e) {
-  let t = e.replace(/^- /g, "").trim();
-  return t === "" ? null : t;
-}
-o(pe, "normaliseDescription");
-function st(e) {
-  let t = ae(e.type);
-  return t ? {
-    type: t,
-    description: ie(e.name, e.description),
-    getTypeName: /* @__PURE__ */ o(() => ce(t), "getTypeName")
+r(zr, "extractParam");
+function Xr(n) {
+  return n.name ? ht(n.name, n.description) : null;
+}
+r(Xr, "extractDeprecated");
+function ht(n, s) {
+  let a = n === "" ? s : `${n} ${s}`;
+  return xt(a);
+}
+r(ht, "joinNameAndDescription");
+function xt(n) {
+  let s = n.replace(/^- /g, "").trim();
+  return s === "" ? null : s;
+}
+r(xt, "normaliseDescription");
+function Hr(n) {
+  let s = Jt(n.type);
+  return s ? {
+    type: s,
+    description: ht(n.name, n.description),
+    getTypeName: /* @__PURE__ */ r(() => Pt(s), "getTypeName")
   } : null;
 }
-o(st, "extractReturns");
-var g = (0, h.stringifyRules)(), it = g.JsdocTypeObject;
-g.JsdocTypeAny = () => "any";
-g.JsdocTypeObject = (e, t) => `(${it(e, t)})`;
-g.JsdocTypeOptional = (e, t) => t(e.element);
-g.JsdocTypeNullable = (e, t) => t(e.element);
-g.JsdocTypeNotNullable = (e, t) => t(e.element);
-g.JsdocTypeUnion = (e, t) => e.elements.map(t).join("|");
-function ae(e) {
+r(Hr, "extractReturns");
+var j = (0, K.stringifyRules)(), Qr = j.JsdocTypeObject;
+j.JsdocTypeAny = () => "any";
+j.JsdocTypeObject = (n, s) => `(${Qr(n, s)})`;
+j.JsdocTypeOptional = (n, s) => s(n.element);
+j.JsdocTypeNullable = (n, s) => s(n.element);
+j.JsdocTypeNotNullable = (n, s) => s(n.element);
+j.JsdocTypeUnion = (n, s) => n.elements.map(s).join("|");
+function Jt(n) {
   try {
-    return (0, h.parse)(e, "typescript");
+    return (0, K.parse)(n, "typescript");
   } catch {
     return null;
   }
 }
-o(ae, "extractType");
-function ce(e) {
-  return (0, h.transform)(g, e);
+r(Jt, "extractType");
+function Pt(n) {
+  return (0, K.transform)(j, n);
 }
-o(ce, "extractTypeName");
+r(Pt, "extractTypeName");
 
 // src/docs-tools/argTypes/utils.ts
-var pt = 90, at = 50;
-function j(e) {
-  return e.length > 90;
+var Zr = 90, en = 50;
+function me(n) {
+  return n.length > 90;
 }
-o(j, "isTooLongForTypeSummary");
-function q(e) {
-  return e.length > 50;
+r(me, "isTooLongForTypeSummary");
+function qe(n) {
+  return n.length > 50;
 }
-o(q, "isTooLongForDefaultValueSummary");
-function l(e, t) {
-  return e === t ? { summary: e } : { summary: e, detail: t };
+r(qe, "isTooLongForDefaultValueSummary");
+function J(n, s) {
+  return n === s ? { summary: n } : { summary: n, detail: s };
 }
-o(l, "createSummaryValue");
-var ct = /* @__PURE__ */ o((e) => e.replace(/\\r\\n/g, "\\n"), "normalizeNewlines");
+r(J, "createSummaryValue");
+var tn = /* @__PURE__ */ r((n) => n.replace(/\\r\\n/g, "\\n"), "normalizeNewlines");
 
 // src/docs-tools/argTypes/docgen/flow/createDefaultValue.ts
-function le(e, t) {
-  if (e != null) {
-    let { value: r } = e;
-    if (!d(r))
-      return q(r) ? l(t?.name, r) : l(r);
+function wt(n, s) {
+  if (n != null) {
+    let { value: a } = n;
+    if (!L(a))
+      return qe(a) ? J(s?.name, a) : J(a);
   }
   return null;
 }
-o(le, "createDefaultValue");
+r(wt, "createDefaultValue");
 
 // src/docs-tools/argTypes/docgen/flow/createType.ts
-function ue({ name: e, value: t, elements: r, raw: n }) {
-  return t ?? (r != null ? r.map(ue).join(" | ") : n ?? e);
+function bt({ name: n, value: s, elements: a, raw: p }) {
+  return s ?? (a != null ? a.map(bt).join(" | ") : p ?? n);
 }
-o(ue, "generateUnionElement");
-function lt({ name: e, raw: t, elements: r }) {
-  return r != null ? l(r.map(ue).join(" | ")) : t != null ? l(t.replace(/^\|\s*/, "")) : l(e);
+r(bt, "generateUnionElement");
+function rn({ name: n, raw: s, elements: a }) {
+  return a != null ? J(a.map(bt).join(" | ")) : s != null ? J(s.replace(/^\|\s*/, "")) : J(n);
 }
-o(lt, "generateUnion");
-function ut({ type: e, raw: t }) {
-  return t != null ? l(t) : l(e);
+r(rn, "generateUnion");
+function nn({ type: n, raw: s }) {
+  return s != null ? J(s) : J(n);
 }
-o(ut, "generateFuncSignature");
-function mt({ type: e, raw: t }) {
-  return t != null ? j(t) ? l(e, t) : l(t) : l(e);
+r(nn, "generateFuncSignature");
+function on({ type: n, raw: s }) {
+  return s != null ? me(s) ? J(n, s) : J(s) : J(n);
 }
-o(mt, "generateObjectSignature");
-function ft(e) {
-  let { type: t } = e;
-  return t === "object" ? mt(e) : ut(e);
+r(on, "generateObjectSignature");
+function sn(n) {
+  let { type: s } = n;
+  return s === "object" ? on(n) : nn(n);
 }
-o(ft, "generateSignature");
-function yt({ name: e, raw: t }) {
-  return t != null ? j(t) ? l(e, t) : l(t) : l(e);
+r(sn, "generateSignature");
+function an({ name: n, raw: s }) {
+  return s != null ? me(s) ? J(n, s) : J(s) : J(n);
 }
-o(yt, "generateDefault");
-function me(e) {
-  if (e == null)
+r(an, "generateDefault");
+function Et(n) {
+  if (n == null)
     return null;
-  switch (e.name) {
+  switch (n.name) {
     case "union":
-      return lt(e);
+      return rn(n);
     case "signature":
-      return ft(e);
+      return sn(n);
     default:
-      return yt(e);
+      return an(n);
   }
 }
-o(me, "createType");
+r(Et, "createType");
 
 // src/docs-tools/argTypes/docgen/flow/createPropDef.ts
-var fe = /* @__PURE__ */ o((e, t) => {
-  let { flowType: r, description: n, required: s, defaultValue: i } = t;
+var St = /* @__PURE__ */ r((n, s) => {
+  let { flowType: a, description: p, required: c, defaultValue: u } = s;
   return {
-    name: e,
-    type: me(r),
-    required: s,
-    description: n,
-    defaultValue: le(i ?? null, r ?? null)
+    name: n,
+    type: Et(a),
+    required: c,
+    description: p,
+    defaultValue: wt(u ?? null, a ?? null)
   };
 }, "createFlowPropDef");
 
 // src/docs-tools/argTypes/docgen/typeScript/createDefaultValue.ts
-function ye({ defaultValue: e }) {
-  if (e != null) {
-    let { value: t } = e;
-    if (!d(t))
-      return l(t);
+function Nt({ defaultValue: n }) {
+  if (n != null) {
+    let { value: s } = n;
+    if (!L(s))
+      return J(s);
   }
   return null;
 }
-o(ye, "createDefaultValue");
+r(Nt, "createDefaultValue");
 
 // src/docs-tools/argTypes/docgen/typeScript/createType.ts
-function ge({ tsType: e, required: t }) {
-  if (e == null)
+function Ot({ tsType: n, required: s }) {
+  if (n == null)
     return null;
-  let r = e.name;
-  return t || (r = r.replace(" | undefined", "")), l(
-    ["Array", "Record", "signature"].includes(e.name) ? e.raw : r
+  let a = n.name;
+  return s || (a = a.replace(" | undefined", "")), J(
+    ["Array", "Record", "signature"].includes(n.name) ? n.raw : a
   );
 }
-o(ge, "createType");
+r(Ot, "createType");
 
 // src/docs-tools/argTypes/docgen/typeScript/createPropDef.ts
-var de = /* @__PURE__ */ o((e, t) => {
-  let { description: r, required: n } = t;
+var Dt = /* @__PURE__ */ r((n, s) => {
+  let { description: a, required: p } = s;
   return {
-    name: e,
-    type: ge(t),
-    required: n,
-    description: r,
-    defaultValue: ye(t)
+    name: n,
+    type: Ot(s),
+    required: p,
+    description: a,
+    defaultValue: Nt(s)
   };
 }, "createTsPropDef");
 
 // src/docs-tools/argTypes/docgen/createPropDef.ts
-function gt(e) {
-  return e != null ? l(e.name) : null;
-}
-o(gt, "createType");
-function dt(e) {
-  let { computed: t, func: r } = e;
-  return typeof t > "u" && typeof r > "u";
-}
-o(dt, "isReactDocgenTypescript");
-function xt(e) {
-  return e ? e.name === "string" ? !0 : e.name === "enum" ? Array.isArray(e.value) && e.value.every(
-    ({ value: t }) => typeof t == "string" && t[0] === '"' && t[t.length - 1] === '"'
+function pn(n) {
+  return n != null ? J(n.name) : null;
+}
+r(pn, "createType");
+function cn(n) {
+  let { computed: s, func: a } = n;
+  return typeof s > "u" && typeof a > "u";
+}
+r(cn, "isReactDocgenTypescript");
+function ln(n) {
+  return n ? n.name === "string" ? !0 : n.name === "enum" ? Array.isArray(n.value) && n.value.every(
+    ({ value: s }) => typeof s == "string" && s[0] === '"' && s[s.length - 1] === '"'
   ) : !1 : !1;
 }
-o(xt, "isStringValued");
-function Dt(e, t) {
-  if (e != null) {
-    let { value: r } = e;
-    if (!d(r))
-      return dt(e) && xt(t) ? l(JSON.stringify(r)) : l(r);
+r(ln, "isStringValued");
+function un(n, s) {
+  if (n != null) {
+    let { value: a } = n;
+    if (!L(a))
+      return cn(n) && ln(s) ? J(JSON.stringify(a)) : J(a);
   }
   return null;
 }
-o(Dt, "createDefaultValue");
-function xe(e, t, r) {
-  let { description: n, required: s, defaultValue: i } = r;
+r(un, "createDefaultValue");
+function vt(n, s, a) {
+  let { description: p, required: c, defaultValue: u } = a;
   return {
-    name: e,
-    type: gt(t),
-    required: s,
-    description: n,
-    defaultValue: Dt(i, t)
+    name: n,
+    type: pn(s),
+    required: c,
+    description: p,
+    defaultValue: un(u, s)
   };
 }
-o(xe, "createBasicPropDef");
-function k(e, t) {
-  if (t?.includesJsDoc) {
-    let { description: r, extractedTags: n } = t;
-    r != null && (e.description = t.description);
-    let s = {
-      ...n,
-      params: n?.params?.map(
-        (i) => ({
-          name: i.getPrettyName(),
-          description: i.description
+r(vt, "createBasicPropDef");
+function ye(n, s) {
+  if (s?.includesJsDoc) {
+    let { description: a, extractedTags: p } = s;
+    a != null && (n.description = s.description);
+    let c = {
+      ...p,
+      params: p?.params?.map(
+        (u) => ({
+          name: u.getPrettyName(),
+          description: u.description
         })
       )
     };
-    Object.values(s).filter(Boolean).length > 0 && (e.jsDocTags = s);
+    Object.values(c).filter(Boolean).length > 0 && (n.jsDocTags = c);
   }
-  return e;
-}
-o(k, "applyJsDocResult");
-var Tt = /* @__PURE__ */ o((e, t, r) => {
-  let n = xe(e, t.type, t);
-  return n.sbType = b(t), k(n, r);
-}, "javaScriptFactory"), ht = /* @__PURE__ */ o((e, t, r) => {
-  let n = de(e, t);
-  return n.sbType = b(t), k(n, r);
-}, "tsFactory"), bt = /* @__PURE__ */ o((e, t, r) => {
-  let n = fe(e, t);
-  return n.sbType = b(t), k(n, r);
-}, "flowFactory"), Pt = /* @__PURE__ */ o((e, t, r) => {
-  let n = xe(e, { name: "unknown" }, t);
-  return k(n, r);
-}, "unknownFactory"), G = /* @__PURE__ */ o((e) => {
-  switch (e) {
+  return n;
+}
+r(ye, "applyJsDocResult");
+var mn = /* @__PURE__ */ r((n, s, a) => {
+  let p = vt(n, s.type, s);
+  return p.sbType = H(s), ye(p, a);
+}, "javaScriptFactory"), yn = /* @__PURE__ */ r((n, s, a) => {
+  let p = Dt(n, s);
+  return p.sbType = H(s), ye(p, a);
+}, "tsFactory"), fn = /* @__PURE__ */ r((n, s, a) => {
+  let p = St(n, s);
+  return p.sbType = H(s), ye(p, a);
+}, "flowFactory"), dn = /* @__PURE__ */ r((n, s, a) => {
+  let p = vt(n, { name: "unknown" }, s);
+  return ye(p, a);
+}, "unknownFactory"), Ye = /* @__PURE__ */ r((n) => {
+  switch (n) {
     case "JavaScript":
-      return Tt;
+      return mn;
     case "TypeScript":
-      return ht;
+      return yn;
     case "Flow":
-      return bt;
+      return fn;
     default:
-      return Pt;
+      return dn;
   }
 }, "getPropDefFactory");
 
 // src/docs-tools/argTypes/docgen/extractDocgenProps.ts
-var De = /* @__PURE__ */ o((e) => e.type != null ? "JavaScript" : e.flowType != null ? "Flow" : e.tsType != null ? "TypeScript" : "Unknown",
-"getTypeSystem"), Te = /* @__PURE__ */ o((e) => {
-  let t = De(e[0]), r = G(t);
-  return e.map((n) => {
-    let s = n;
-    return n.type?.elements && (s = {
-      ...n,
+var kt = /* @__PURE__ */ r((n) => n.type != null ? "JavaScript" : n.flowType != null ? "Flow" : n.tsType != null ? "TypeScript" : "Unknown",
+"getTypeSystem"), At = /* @__PURE__ */ r((n) => {
+  let s = kt(n[0]), a = Ye(s);
+  return n.map((p) => {
+    let c = p;
+    return p.type?.elements && (c = {
+      ...p,
       type: {
-        ...n.type,
-        value: n.type.elements
+        ...p.type,
+        value: p.type.elements
       }
-    }), be(s.name, s, t, r);
+    }), It(c.name, c, s, a);
   });
-}, "extractComponentSectionArray"), he = /* @__PURE__ */ o((e) => {
-  let t = Object.keys(e), r = De(e[t[0]]), n = G(r);
-  return t.map((s) => {
-    let i = e[s];
-    return i != null ? be(s, i, r, n) : null;
+}, "extractComponentSectionArray"), Rt = /* @__PURE__ */ r((n) => {
+  let s = Object.keys(n), a = kt(n[s[0]]), p = Ye(a);
+  return s.map((c) => {
+    let u = n[c];
+    return u != null ? It(c, u, a, p) : null;
   }).filter(Boolean);
-}, "extractComponentSectionObject"), St = /* @__PURE__ */ o((e, t) => {
-  let r = V(e, t);
-  return A(r) ? Array.isArray(r) ? Te(r) : he(r) : [];
+}, "extractComponentSectionObject"), Tn = /* @__PURE__ */ r((n, s) => {
+  let a = Ie(n, s);
+  return Re(a) ? Array.isArray(a) ? At(a) : Rt(a) : [];
 }, "extractComponentProps");
-function be(e, t, r, n) {
-  let s = Y(t.description);
-  return s.includesJsDoc && s.ignore ? null : {
-    propDef: n(e, t, s),
-    jsDocTags: s.extractedTags,
-    docgenInfo: t,
-    typeSystem: r
+function It(n, s, a, p) {
+  let c = $e(s.description);
+  return c.includesJsDoc && c.ignore ? null : {
+    propDef: p(n, s, c),
+    jsDocTags: c.extractedTags,
+    docgenInfo: s,
+    typeSystem: a
   };
 }
-o(be, "extractProp");
-function Ot(e) {
-  return e != null ? C(e) : "";
+r(It, "extractProp");
+function gn(n) {
+  return n != null ? Fe(n) : "";
 }
-o(Ot, "extractComponentDescription");
+r(gn, "extractComponentDescription");
+
+// src/preview-api/modules/store/parameters.ts
+var We = /* @__PURE__ */ r((...n) => {
+  let s = {}, a = n.filter(Boolean), p = a.reduce((c, u) => (Object.entries(u).forEach(([m, T]) => {
+    let g = c[m];
+    Array.isArray(T) || typeof g > "u" ? c[m] = T : X(T) && X(g) ? s[m] = !0 : typeof T < "u" && (c[m] = T);
+  }), c), {});
+  return Object.keys(s).forEach((c) => {
+    let u = a.filter(Boolean).map((m) => m[c]).filter((m) => typeof m < "u");
+    u.every((m) => X(m)) ? p[c] = We(...u) : p[c] = u[u.length - 1];
+  }), p;
+}, "combineParameters");
 
 // src/docs-tools/argTypes/enhanceArgTypes.ts
-var Pe = require("storybook/internal/preview-api");
-var vt = /* @__PURE__ */ o((e) => {
+var hn = /* @__PURE__ */ r((n) => {
   let {
-    component: t,
-    argTypes: r,
-    parameters: { docs: n = {} }
-  } = e, { extractArgTypes: s } = n, i = s && t ? s(t) : {};
-  return i ? (0, Pe.combineParameters)(i, r) : r;
+    component: s,
+    argTypes: a,
+    parameters: { docs: p = {} }
+  } = n, { extractArgTypes: c } = p, u = c && s ? c(s) : {};
+  return u ? We(u, a) : a;
 }, "enhanceArgTypes");
 
 // src/docs-tools/shared.ts
-var K = "storybook/docs", wt = `${K}/panel`, Et = "docs", jt = `${K}/snippet-rendered`, Se = /* @__PURE__ */ ((n) => (n.AUTO = "auto", n.CODE =
-"code", n.DYNAMIC = "dynamic", n))(Se || {});
+var Ge = "storybook/docs", xn = `${Ge}/panel`, Jn = "docs", Pn = `${Ge}/snippet-rendered`, Ft = /* @__PURE__ */ ((p) => (p.AUTO = "auto", p.
+CODE = "code", p.DYNAMIC = "dynamic", p))(Ft || {});
 
 // src/docs-tools/hasDocsOrControls.ts
-var kt = /(addons\/|addon-|addon-essentials\/)(docs|controls)/, Ft = /* @__PURE__ */ o((e) => e.presetsList?.some((t) => kt.test(t.name)), "\
+var wn = /(addons\/|addon-|addon-essentials\/)(docs|controls)/, bn = /* @__PURE__ */ r((n) => n.presetsList?.some((s) => wn.test(s.name)), "\
 hasDocsOrControls");