storybook
Version:
Storybook: Develop, document, and test UI components in isolation
1,498 lines (1,496 loc) • 95.3 kB
JavaScript
"use strict";
var gr = Object.create;
var X = Object.defineProperty;
var xr = Object.getOwnPropertyDescriptor;
var hr = Object.getOwnPropertyNames;
var Jr = Object.getPrototypeOf, wr = Object.prototype.hasOwnProperty;
var r = (n, s) => X(n, "name", { value: s, configurable: !0 });
var Pr = (n, s) => () => (s || n((s = { exports: {} }).exports, s), s.exports), br = (n, s) => {
for (var a in s)
X(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))
!wr.call(n, c) && c !== a && X(n, c, { get: () => s[c], enumerable: !(p = xr(s, c)) || p.enumerable });
return n;
};
var Er = (n, s, a) => (a = n != null ? gr(Jr(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 ? X(a, "default", { value: n, enumerable: !0 }) : a,
n
)), Sr = (n) => it(X({}, "__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 P(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(P, "getIdentifier");
let b = /^(NaN|-?((\d*\.\d+|\d+)([Ee][+-]?\d+)?|Infinity))/;
function ye(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(ye, "getNumber");
let $ = /* @__PURE__ */ r((e) => {
let t = P(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 = ye(e);
return t === null ? null : {
type: "Number",
text: t
};
}, "numberRule"), Ft = [
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"),
E("asserts"),
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 Ft) {
let l = i(t);
if (l !== null) {
let f = Object.assign(Object.assign({}, l), { startOfLine: o });
return t = t.slice(f.text.length), { text: t, token: f };
}
}
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 w(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(w, "assertRootResult");
function ge(e) {
return e.type === "JsdocTypeKeyValue" ? Z(e) : w(e);
}
r(ge, "assertPlainKeyValueOrRootResult");
function Vt(e) {
return e.type === "JsdocTypeName" ? e : Z(e);
}
r(Vt, "assertPlainKeyValueOrNameResult");
function Z(e) {
if (e.type !== "JsdocTypeKeyValue")
throw new c(e);
return e;
}
r(Z, "assertPlainKeyValueResult");
function Lt(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(Lt, "assertNumberOrVariadicNameResult");
function xe(e) {
return e.type === "JsdocTypeIndexSignature" || e.type === "JsdocTypeMappedType";
}
r(xe, "isSquaredProperty");
var y;
(function(e) {
e[e.ALL = 0] = "ALL", e[e.PARAMETER_LIST = 1] = "PARAMETER_LIST", e[e.OBJECT = 2] = "OBJECT", e[e.KEY_VALUE = 3] = "KEY_VALUE", e[e.INDEX_BRACKETS =
4] = "INDEX_BRACKETS", e[e.UNION = 5] = "UNION", e[e.INTERSECTION = 6] = "INTERSECTION", e[e.PREFIX = 7] = "PREFIX", e[e.INFIX = 8] = "\
INFIX", e[e.TUPLE = 9] = "TUPLE", e[e.SYMBOL = 10] = "SYMBOL", e[e.OPTIONAL = 11] = "OPTIONAL", e[e.NULLABLE = 12] = "NULLABLE", e[e.KEY_OF_TYPE_OF =
13] = "KEY_OF_TYPE_OF", e[e.FUNCTION = 14] = "FUNCTION", e[e.ARROW = 15] = "ARROW", e[e.ARRAY_BRACKETS = 16] = "ARRAY_BRACKETS", e[e.GENERIC =
17] = "GENERIC", e[e.NAME_PATH = 18] = "NAME_PATH", e[e.PARENTHESIS = 19] = "PARENTHESIS", e[e.SPECIAL_TYPES = 20] = "SPECIAL_TYPES";
})(y || (y = {}));
class L {
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(y.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 w(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 Xe(e) {
return e === "EOF" || e === "|" || e === "," || e === ")" || e === ">";
}
r(Xe, "isQuestionMarkUnknownType");
let he = /* @__PURE__ */ r((e, t, o) => {
let i = e.lexer.current.type, l = e.lexer.next.type;
return o == null && i === "?" && !Xe(l) || o != null && i === "?" ? (e.consume("?"), o == null ? {
type: "JsdocTypeNullable",
element: e.parseType(y.NULLABLE),
meta: {
position: "prefix"
}
} : {
type: "JsdocTypeNullable",
element: w(o),
meta: {
position: "suffix"
}
}) : null;
}, "nullableParslet");
function x(e) {
let t = /* @__PURE__ */ r((o, i, l) => {
let f = o.lexer.current.type, d = o.lexer.next.type;
if (l === null) {
if ("parsePrefix" in e && e.accept(f, d))
return e.parsePrefix(o);
} else if ("parseInfix" in e && e.precedence > i && e.accept(f, d))
return e.parseInfix(o, l);
return null;
}, "parslet");
return Object.defineProperty(t, "name", {
value: e.name
}), t;
}
r(x, "composeParslet");
let ee = x({
name: "optionalParslet",
accept: /* @__PURE__ */ r((e) => e === "=", "accept"),
precedence: y.OPTIONAL,
parsePrefix: /* @__PURE__ */ r((e) => (e.consume("="), {
type: "JsdocTypeOptional",
element: e.parseType(y.OPTIONAL),
meta: {
position: "prefix"
}
}), "parsePrefix"),
parseInfix: /* @__PURE__ */ r((e, t) => (e.consume("="), {
type: "JsdocTypeOptional",
element: w(t),
meta: {
position: "suffix"
}
}), "parseInfix")
}), te = x({
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 = x({
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(y.ALL);
if (!e.consume(")"))
throw new Error("Unterminated parenthesis");
return t.type === "JsdocTypeParameterList" ? t : t.type === "JsdocTypeKeyValue" ? {
type: "JsdocTypeParameterList",
elements: [t]
} : {
type: "JsdocTypeParenthesis",
element: w(t)
};
}, "parsePrefix")
}), Bt = x({
name: "specialTypesParslet",
accept: /* @__PURE__ */ r((e, t) => e === "?" && Xe(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 = x({
name: "notNullableParslet",
accept: /* @__PURE__ */ r((e) => e === "!", "accept"),
precedence: y.NULLABLE,
parsePrefix: /* @__PURE__ */ r((e) => (e.consume("!"), {
type: "JsdocTypeNotNullable",
element: e.parseType(y.NULLABLE),
meta: {
position: "prefix"
}
}), "parsePrefix"),
parseInfix: /* @__PURE__ */ r((e, t) => (e.consume("!"), {
type: "JsdocTypeNotNullable",
element: w(t),
meta: {
position: "suffix"
}
}), "parseInfix")
});
function Mt({ allowTrailingComma: e }) {
return x({
name: "parameterListParslet",
accept: /* @__PURE__ */ r((t) => t === ",", "accept"),
precedence: y.PARAMETER_LIST,
parseInfix: /* @__PURE__ */ r((t, o) => {
let i = [
ge(o)
];
t.consume(",");
do
try {
let l = t.parseIntermediateType(y.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 = x({
name: "genericParslet",
accept: /* @__PURE__ */ r((e, t) => e === "<" || e === "." && t === "<", "accept"),
precedence: y.GENERIC,
parseInfix: /* @__PURE__ */ r((e, t) => {
let o = e.consume(".");
e.consume("<");
let i = [];
do
i.push(e.parseType(y.PARAMETER_LIST));
while (e.consume(","));
if (!e.consume(">"))
throw new Error("Unterminated generic parameter list");
return {
type: "JsdocTypeGeneric",
left: w(t),
elements: i,
meta: {
brackets: "angle",
dot: o
}
};
}, "parseInfix")
}), $t = x({
name: "unionParslet",
accept: /* @__PURE__ */ r((e) => e === "|", "accept"),
precedence: y.UNION,
parseInfix: /* @__PURE__ */ r((e, t) => {
e.consume("|");
let o = [];
do
o.push(e.parseType(y.UNION));
while (e.consume("|"));
return {
type: "JsdocTypeUnion",
elements: [w(t), ...o]
};
}, "parseInfix")
}), Je = [
he,
ee,
te,
Ut,
Bt,
Ct,
Mt({
allowTrailingComma: !0
}),
Kt,
$t,
ee
];
function re({ allowSquareBracketsOnAnyType: e, allowJsdocNamePaths: t, pathGrammar: o }) {
return /* @__PURE__ */ r(function(l, f, d) {
if (d == null || f >= y.NAME_PATH)
return null;
let h = l.lexer.current.type, O = l.lexer.next.type;
if (!(h === "." && O !== "<" || h === "[" && (e || d.type === "JsdocTypeName") || t && (h === "~" || h === "#")))
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 L(o, l.lexer, l) : l, k = st.parseIntermediateType(y.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: w(d),
right: G,
pathType: D
};
}, "namePathParslet");
}
r(re, "createNamePathParslet");
function I({ allowedAdditionalTokens: e }) {
return x({
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(I, "createNameParslet");
let Y = x({
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 x({
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, f = o.lexer.current;
if (o.consume("StringValue"))
l = {
type: "JsdocTypeSpecialNamePath",
value: f.text.slice(1, -1),
specialType: i,
meta: {
quote: f.text[0] === "'" ? "single" : "double"
}
};
else {
let O = "", S = ["Identifier", "@", "/"];
for (; S.some((D) => o.consume(D)); )
O += f.text, f = o.lexer.current;
l = {
type: "JsdocTypeSpecialNamePath",
value: O,
specialType: i,
meta: {
quote: void 0
}
};
}
let d = new L(e, o.lexer, o), h = d.parseInfixIntermediateType(l, y.ALL);
return o.acceptLexerState(d), w(h);
}, "parsePrefix")
});
}
r(ne, "createSpecialNamePathParslet");
let ze = [
I({
allowedAdditionalTokens: ["external", "module"]
}),
Y,
te,
re({
allowSquareBracketsOnAnyType: !1,
allowJsdocNamePaths: !0,
pathGrammar: null
})
], U = [
...ze,
ne({
allowedTypes: ["event"],
pathGrammar: ze
})
];
function we(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(we, "getParameters");
function qt(e) {
let t = we(e);
if (t.some((o) => o.type === "JsdocTypeKeyValue"))
throw new Error("No parameter should be named");
return t;
}
r(qt, "getUnnamedParameters");
function Pe({ allowNamedParameters: e, allowNoReturnType: t, allowWithoutParenthesis: o, allowNewAsFunctionKeyword: i }) {
return x({
name: "functionParslet",
accept: /* @__PURE__ */ r((l, f) => l === "function" || i && l === "new" && f === "(", "accept"),
parsePrefix: /* @__PURE__ */ r((l) => {
let f = 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 h = {
type: "JsdocTypeFunction",
parameters: [],
arrow: !1,
constructor: f,
parenthesis: d
}, O = l.parseIntermediateType(y.FUNCTION);
if (e === void 0)
h.parameters = qt(O);
else {
if (f && O.type === "JsdocTypeFunction" && O.arrow)
return h = O, h.constructor = !0, h;
h.parameters = we(O);
for (let S of h.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(":"))
h.returnType = l.parseType(y.PREFIX);
else if (!t)
throw new Error("function is missing return type");
return h;
}, "parsePrefix")
});
}
r(Pe, "createFunctionParslet");
function be({ allowPostfix: e, allowEnclosingBrackets: t }) {
return x({
name: "variadicParslet",
accept: /* @__PURE__ */ r((o) => o === "...", "accept"),
precedence: y.PREFIX,
parsePrefix: /* @__PURE__ */ r((o) => {
o.consume("...");
let i = t && o.consume("[");
try {
let l = o.parseType(y.PREFIX);
if (i && !o.consume("]"))
throw new Error("Unterminated variadic type. Missing ']'");
return {
type: "JsdocTypeVariadic",
element: w(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: w(i),
meta: {
position: "suffix",
squareBrackets: !1
}
}) : void 0
});
}
r(be, "createVariadicParslet");
let He = x({
name: "symbolParslet",
accept: /* @__PURE__ */ r((e) => e === "(", "accept"),
precedence: y.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(y.SYMBOL);
if (o.element = Lt(i), !e.consume(")"))
throw new Error("Symbol does not end after value");
}
return o;
}, "parseInfix")
}), Qe = x({
name: "arrayBracketsParslet",
precedence: y.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: [
w(t)
],
meta: {
brackets: "square",
dot: !1
}
}), "parseInfix")
});
function Ee({ objectFieldGrammar: e, allowKeyTypes: t }) {
return x({
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, f = new L(e, o.lexer, o);
for (; ; ) {
f.acceptLexerState(o);
let d = f.parseIntermediateType(y.OBJECT);
o.acceptLexerState(f), d === void 0 && t && (d = o.parseIntermediateType(y.OBJECT));
let h = !1;
if (d.type === "JsdocTypeNullable" && (h = !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: h,
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 x({
name: "objectFieldParslet",
precedence: y.KEY_VALUE,
accept: /* @__PURE__ */ r((l) => l === ":", "accept"),
parseInfix: /* @__PURE__ */ r((l, f) => {
var d;
let h = !1, O = !1;
i && f.type === "JsdocTypeNullable" && (h = !0, f = f.element), o && f.type === "JsdocTypeReadonlyProperty" && (O = !0, f = f.element);
let S = (d = l.baseParser) !== null && d !== void 0 ? d : l;
if (S.acceptLexerState(l), f.type === "JsdocTypeNumber" || f.type === "JsdocTypeName" || f.type === "JsdocTypeStringValue" || xe(f)) {
if (xe(f) && !e)
throw new c(f);
S.consume(":");
let D;
f.type === "JsdocTypeStringValue" && (D = f.meta.quote);
let se = S.parseType(y.KEY_VALUE);
return l.acceptLexerState(S), {
type: "JsdocTypeObjectField",
key: xe(f) ? f : f.value.toString(),
right: se,
optional: h,
readonly: O,
meta: {
quote: D
}
};
} else {
if (!t)
throw new c(f);
S.consume(":");
let D = S.parseType(y.KEY_VALUE);
return l.acceptLexerState(S), {
type: "JsdocTypeJsdocObjectField",
left: w(f),
right: D
};
}
}, "parseInfix")
});
}
r(Se, "createObjectFieldParslet");
function Ne({ allowOptional: e, allowVariadic: t }) {
return x({
name: "keyValueParslet",
precedence: y.KEY_VALUE,
accept: /* @__PURE__ */ r((o) => o === ":", "accept"),
parseInfix: /* @__PURE__ */ r((o, i) => {
let l = !1, f = !1;
if (e && i.type === "JsdocTypeNullable" && (l = !0, i = i.element), t && i.type === "JsdocTypeVariadic" && i.element !== void 0 &&
(f = !0, i = i.element), i.type !== "JsdocTypeName")
throw new c(i);
o.consume(":");
let d = o.parseType(y.KEY_VALUE);
return {
type: "JsdocTypeKeyValue",
key: i.value,
right: d,
optional: l,
variadic: f
};
}, "parseInfix")
});
}
r(Ne, "createKeyValueParslet");
let Ze = [
...Je,
Pe({
allowWithoutParenthesis: !0,
allowNamedParameters: ["this", "new"],
allowNoReturnType: !0,
allowNewAsFunctionKeyword: !1
}),
Y,
ne({
allowedTypes: ["module", "external", "event"],
pathGrammar: U
}),
be({
allowEnclosingBrackets: !0,
allowPostfix: !0
}),
I({
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: [
I({
allowedAdditionalTokens: ["module", "in"]
}),
Se({
allowSquaredProperties: !1,
allowKeyTypes: !0,
allowOptional: !1,
allowReadonly: !1
}),
...Ze
],
allowKeyTypes: !0
}),
Ne({
allowOptional: !0,
allowVariadic: !0
})
], et = x({
name: "typeOfParslet",
accept: /* @__PURE__ */ r((e) => e === "typeof", "accept"),
parsePrefix: /* @__PURE__ */ r((e) => (e.consume("typeof"), {
type: "JsdocTypeTypeof",
element: w(e.parseType(y.KEY_OF_TYPE_OF))
}), "parsePrefix")
}), Wt = [
I({
allowedAdditionalTokens: ["module", "keyof", "event", "external", "in"]
}),
he,
ee,
Y,
te,
Se({
allowSquaredProperties: !1,
allowKeyTypes: !1,
allowOptional: !1,
allowReadonly: !1
})
], Gt = [
...Je,
Ee({
allowKeyTypes: !1,
objectFieldGrammar: Wt
}),
I({
allowedAdditionalTokens: ["event", "external", "in"]
}),
et,
Pe({
allowWithoutParenthesis: !1,
allowNamedParameters: ["this", "new"],
allowNoReturnType: !0,
allowNewAsFunctionKeyword: !1
}),
be({
allowEnclosingBrackets: !1,
allowPostfix: !1
}),
// additional name parslet is needed for some special cases
I({
allowedAdditionalTokens: ["keyof"]
}),
ne({
allowedTypes: ["module"],
pathGrammar: U
}),
re({
allowSquareBracketsOnAnyType: !1,
allowJsdocNamePaths: !0,
pathGrammar: U
}),
Ne({
allowOptional: !1,
allowVariadic: !1
}),
He
], Xt = x({
name: "assertsParslet",
accept: /* @__PURE__ */ r((e) => e === "asserts", "accept"),
parsePrefix: /* @__PURE__ */ r((e) => {
e.consume("asserts");
let t = e.parseIntermediateType(y.SYMBOL);
if (t.type !== "JsdocTypeName")
throw new c(t, "A typescript asserts always has to have a name on the left side.");
return e.consume("is"), {
type: "JsdocTypeAsserts",
left: t,
right: w(e.parseIntermediateType(y.INFIX))
};
}, "parsePrefix")
});
function zt({ allowQuestionMark: e }) {
return x({
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(y.ALL);
if (i.type === "JsdocTypeParameterList" ? i.elements[0].type === "JsdocTypeKeyValue" ? o.elements = i.elements.map(Z) : o.elements =
i.elements.map(w) : i.type === "JsdocTypeKeyValue" ? o.elements = [Z(i)] : o.elements = [w(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 Ht = x({
name: "keyOfParslet",
accept: /* @__PURE__ */ r((e) => e === "keyof", "accept"),
parsePrefix: /* @__PURE__ */ r((e) => (e.consume("keyof"), {
type: "JsdocTypeKeyof",
element: w(e.parseType(y.KEY_OF_TYPE_OF))
}), "parsePrefix")
}), Qt = x({
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(y.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")
}), Zt = x({
name: "readonlyPropertyParslet",
accept: /* @__PURE__ */ r((e) => e === "readonly", "accept"),
parsePrefix: /* @__PURE__ */ r((e) => (e.consume("readonly"), {
type: "JsdocTypeReadonlyProperty",
element: e.parseType(y.KEY_VALUE)
}), "parsePrefix")
}), er = x({
name: "arrowFunctionParslet",
precedence: y.ARROW,
accept: /* @__PURE__ */ r((e) => e === "=>", "accept"),
parseInfix: /* @__PURE__ */ r((e, t) => (e.consume("=>"), {
type: "JsdocTypeFunction",
parameters: we(t).map(Vt),
arrow: !0,
constructor: !1,
parenthesis: !0,
returnType: e.parseType(y.OBJECT)
}), "parseInfix")
}), tr = x({
name: "intersectionParslet",
accept: /* @__PURE__ */ r((e) => e === "&", "accept"),
precedence: y.INTERSECTION,
parseInfix: /* @__PURE__ */ r((e, t) => {
e.consume("&");
let o = [];
do
o.push(e.parseType(y.INTERSECTION));
while (e.consume("&"));
return {
type: "JsdocTypeIntersection",
elements: [w(t), ...o]
};
}, "parseInfix")
}), rr = x({
name: "predicateParslet",
precedence: y.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: w(e.parseIntermediateType(y.INFIX))
};
}, "parseInfix")
}), nr = x({
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(y.INDEX_BRACKETS)
}, e.acceptLexerState(i);
} else if (e.consume("in")) {
let i = e.baseParser;
i.acceptLexerState(e), o = {
type: "JsdocTypeMappedType",
key: t,
right: i.parseType(y.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")
}), or = [
Zt,
I({
allowedAdditionalTokens: ["module", "event", "keyof", "event", "external", "in"]
}),
he,
ee,
Y,
te,
Se({
allowSquaredProperties: !0,
allowKeyTypes: !1,
allowOptional: !0,
allowReadonly: !0
}),
nr
], sr = [
...Je,
Ee({
allowKeyTypes: !1,
objectFieldGrammar: or
}),
et,
Ht,
Qt,
Y,
Pe({
allowWithoutParenthesis: !0,
allowNoReturnType: !1,
allowNamedParameters: ["this", "new", "args"],
allowNewAsFunctionKeyword: !0
}),
zt({
allowQuestionMark: !1
}),
be({
allowEnclosingBrackets: !1,
allowPostfix: !1
}),
Xt,
I({
allowedAdditionalTokens: ["event", "external", "in"]
}),
ne({
allowedTypes: ["module"],
pathGrammar: U
}),
Qe,
er,
re({
allowSquareBracketsOnAnyType: !0,
allowJsdocNamePaths: !1,
pathGrammar: U
}),
tr,
rr,
Ne({
allowVariadic: !0,
allowOptional: !0
})
];
function tt(e, t) {
switch (t) {
case "closure":
return new L(Gt, e).parse();
case "jsdoc":
return new L(Yt, e).parse();
case "typescript":
return new L(sr, e).parse();
}
}
r(tt, "parse");
function ar(e, t = ["typescript", "closure", "jsdoc"]) {
let o;
for (let i of t)
try {
return tt(e, i);
} catch (l) {
o = l;
}
throw o;
}
r(ar, "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 N(e) {
throw new Error("This transform is not available. Are you trying the correct parsing mode?");
}
r(N, "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 R(e, t) {
switch (t) {
case "double":
return `"${e}"`;
case "single":
return `'${e}'`;
case void 0:
return e;
}
}
r(R, "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) => R(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 += R(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}:${R(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) => R(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"),
JsdocTypeAsserts: /* @__PURE__ */ r((e, t) => `asserts ${t(e.left)} is ${t(e.right)}`, "JsdocTypeAsserts")
};
}
r(nt, "stringifyRules");
let ir = nt();
function pr(e) {
return W(ir, e);
}
r(pr, "stringify");
let cr = [
"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 j(e) {
let t = {
type: "NameExpression",
name: e
};
return cr.includes(e) && (t.reservedWord = !0), t;
}
r(j, "makeName");
let lr = {
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) => j(R(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) => j(e.specialType + ":" + R(e.value, e.meta.quote)), "JsdocTypeSpecialNamePath"),
JsdocTypeName: /* @__PURE__ */ r((e) => e.value !== "function" ? j(e.value) : {
type: "FunctionType",
params: []
}, "JsdocTypeName"),
JsdocTypeNumber: /* @__PURE__ */ r((e) => j(e.value.toString()), "JsdocTypeNumber"),
JsdocTypeObject: /* @__PURE__ */ r((e, t) => {
let o = {
type: "RecordType",
fields: []
};