xmlui 0.7.33 → 0.8.0

package/dist/lint-BN6SMVda.mjs

@@ -0,0 +1,4902 @@
+import { parseRegExpLiteral as de } from "@eslint-community/regexpp";
+import { S as k, C as R } from "./parser-Bko8vvFS.mjs";
+const fr = [
+  {
+    value: "_self",
+    description: "The link will open in the same frame as it was clicked."
+  },
+  {
+    value: "_blank",
+    description: "The link will open in a new window or tab."
+  },
+  {
+    value: "_parent",
+    description: "The link will open in the parent frame. If no parent, behaves as _self."
+  },
+  {
+    value: "_top",
+    description: "The topmost browsing context. The link will open in the full body of the window. If no ancestors, behaves as _self."
+  },
+  {
+    value: "_unfencedTop",
+    description: "Allows embedded fenced frames to navigate the top-level frame, i.e. traversing beyond the root of the fenced frame."
+  }
+], ye = [
+  {
+    value: "xs",
+    description: "Extra small devices (e.g., a small smartphone with low screen resolution)"
+  },
+  { value: "sm", description: "Small devices (e.g., a smartphone in landscape view)" },
+  { value: "md", description: "Medium devices (e.g., a tablet)" },
+  { value: "lg", description: "Large devices (e.g., a laptop)" },
+  { value: "xl", description: 'Extra large devices (e.g., a standard 20" monitor)' },
+  { value: "xxl", description: 'Extra extra large devices (e.g., a large 29" monitor)' }
+], pr = Object.keys(ye), Ie = [
+  { value: "xs", description: "Extra small button" },
+  { value: "sm", description: "Small button" },
+  { value: "md", description: "Medium button" },
+  { value: "lg", description: "Large button" }
+], Oe = Object.keys(Ie);
+[...Oe];
+const We = ["attention", "primary", "secondary"], gr = [...We], kr = [
+  { value: "attention", description: "Attention state theme color" },
+  { value: "primary", description: "Primary theme color" },
+  { value: "secondary", description: "Secondary theme color" }
+], Er = [
+  {
+    value: "button",
+    description: "Regular behavior that only executes logic if explicitly determined."
+  },
+  {
+    value: "submit",
+    description: "The button submits the form data to the server. This is the default for buttons in a Form or NativeForm component."
+  },
+  {
+    value: "reset",
+    description: "Resets all the controls to their initial values. Using it is ill advised for UX reasons."
+  }
+], Be = ["solid", "outlined", "ghost"], xr = [...Be], mr = [
+  { value: "solid", description: "A button with a border and a filled background." },
+  {
+    value: "outlined",
+    description: "The button is displayed with a border and a transparent background."
+  },
+  {
+    value: "ghost",
+    description: "A button with no border and fill. Only the label is visible; the background is colored when hovered or clicked."
+  }
+], Pe = ["start", "center", "end"];
+[...Pe];
+const Sr = [
+  { value: "center", description: "Place the content in the middle" },
+  {
+    value: "start",
+    description: "Justify the content to the left (to the right if in right-to-left)"
+  },
+  {
+    value: "end",
+    description: "Justify the content to the right (to the left if in right-to-left)"
+  }
+], _r = [
+  { value: "horizontal", description: "The component will fill the available space horizontally" },
+  { value: "vertical", description: "The component will fill the available space vertically" }
+], Re = ["start", "end"], Lr = [...Re], wr = [
+  {
+    value: "start",
+    description: "The icon will appear at the start (left side when the left-to-right direction is set)"
+  },
+  {
+    value: "end",
+    description: "The icon will appear at the end (right side when the left-to-right direction is set)"
+  }
+], Cr = [
+  { value: "primary", description: "Primary theme color, no default icon" },
+  { value: "secondary", description: "Secondary theme color, no default icon" },
+  { value: "success", description: 'Success theme color, "success" icon' },
+  { value: "danger", description: 'Warning theme color, "warning" icon' },
+  { value: "warning", description: 'Danger theme color, "danger" icon' },
+  { value: "info", description: 'Info theme color, "info" icon' },
+  { value: "light", description: "Light theme color, no default icon" },
+  { value: "dark", description: "Dark theme color, no default icon" }
+], Ar = [
+  {
+    value: "start",
+    description: "The left side of the window (left-to-right) or the right side of the window (right-to-left)"
+  },
+  {
+    value: "end",
+    description: "The right side of the window (left-to-right) or the left side of the window (right-to-left)"
+  },
+  { value: "top", description: "The top of the window" },
+  { value: "bottom", description: "The bottom of the window" }
+], vr = [
+  {
+    value: "start",
+    description: "The left side of the input (left-to-right) or the right side of the input (right-to-left)"
+  },
+  {
+    value: "end",
+    description: "The right side of the input (left-to-right) or the left side of the input (right-to-left)"
+  },
+  { value: "top", description: "The top of the input" },
+  { value: "bottom", description: "The bottom of the input" }
+], Fe = ["start", "end"], yr = [...Fe], br = [
+  // { value: "none", description: "No indicator" },
+  { value: "valid", description: "Visual indicator for an input that is accepted" },
+  { value: "warning", description: "Visual indicator for an input that produced a warning" },
+  { value: "error", description: "Visual indicator for an input that produced an error" }
+], Ue = ["top", "bottom"];
+[...Ue];
+const Nr = {
+  abbr: "abbr",
+  cite: "cite",
+  code: "code",
+  codefence: "pre",
+  deleted: "del",
+  inserted: "ins",
+  keyboard: "kbd",
+  marked: "mark",
+  sample: "samp",
+  sub: "sub",
+  sup: "sup",
+  var: "var",
+  mono: "pre",
+  strong: "strong",
+  em: "em",
+  title: "span",
+  subtitle: "span",
+  small: "span",
+  caption: "span",
+  placeholder: "span",
+  paragraph: "p",
+  subheading: "h6",
+  tableheading: "h6",
+  secondary: "span"
+}, Dr = [
+  { value: "abbr", description: "Represents an abbreviation or acronym" },
+  { value: "caption", description: "Represents the caption (or title) of a table" },
+  { value: "cite", description: "Is used to mark up the title of a cited work" },
+  { value: "code", description: "Represents a line of code" },
+  {
+    value: "codefence",
+    description: "Handles the display of code blocks if combined with a `code` variant"
+  },
+  { value: "deleted", description: "Represents text that has been deleted" },
+  { value: "em", description: "Marks text to stress emphasis" },
+  {
+    value: "inserted",
+    description: "Represents a range of text that has been added to a document"
+  },
+  {
+    value: "keyboard",
+    description: "Represents a span of text denoting textual user input from a keyboard or voice input"
+  },
+  {
+    value: "marked",
+    description: "Represents text which is marked or highlighted for reference or notation"
+  },
+  { value: "mono", description: "Text using a mono style font family" },
+  { value: "paragraph", description: "Represents a paragraph" },
+  {
+    value: "placeholder",
+    description: "Text that is mostly used as the placeholder style in input controls"
+  },
+  { value: "sample", description: "Represents sample (or quoted) output from a computer program" },
+  { value: "secondary", description: "Represents a bit dimmed secondary text" },
+  { value: "small", description: "Represents side-comments and small print" },
+  { value: "sub", description: "Specifies inline text as subscript" },
+  { value: "strong", description: "Contents have strong importance" },
+  { value: "subheading", description: "Indicates that the text is the subtitle in a heading" },
+  {
+    value: "subtitle",
+    description: "Indicates that the text is the subtitle of some other content"
+  },
+  { value: "sup", description: "Specifies inline text as superscript" },
+  { value: "tableheading", description: "Indicates that the text is a table heading" },
+  { value: "title", description: "Indicates that the text is the title of some other content" },
+  { value: "var", description: "Represents the name of a variable in a mathematical expression" }
+], Me = ["title"], qe = ["cite", "dateTime"], Ir = [...Me, ...qe], Or = [
+  "get",
+  "post",
+  "put",
+  "delete",
+  "patch",
+  "head",
+  "options",
+  "trace",
+  "connect"
+];
+var i = /* @__PURE__ */ ((n) => (n[n.Eof = -1] = "Eof", n[n.Ws = -2] = "Ws", n[n.BlockComment = -3] = "BlockComment", n[n.EolComment = -4] = "EolComment", n[n.Unknown = 0] = "Unknown", n[n.LParent = 1] = "LParent", n[n.RParent = 2] = "RParent", n[n.Identifier = 3] = "Identifier", n[n.Exponent = 4] = "Exponent", n[n.Divide = 5] = "Divide", n[n.Multiply = 6] = "Multiply", n[n.Remainder = 7] = "Remainder", n[n.Plus = 8] = "Plus", n[n.Minus = 9] = "Minus", n[n.BitwiseXor = 10] = "BitwiseXor", n[n.BitwiseOr = 11] = "BitwiseOr", n[n.LogicalOr = 12] = "LogicalOr", n[n.BitwiseAnd = 13] = "BitwiseAnd", n[n.LogicalAnd = 14] = "LogicalAnd", n[n.IncOp = 15] = "IncOp", n[n.DecOp = 16] = "DecOp", n[n.Assignment = 17] = "Assignment", n[n.AddAssignment = 18] = "AddAssignment", n[n.SubtractAssignment = 19] = "SubtractAssignment", n[n.ExponentAssignment = 20] = "ExponentAssignment", n[n.MultiplyAssignment = 21] = "MultiplyAssignment", n[n.DivideAssignment = 22] = "DivideAssignment", n[n.RemainderAssignment = 23] = "RemainderAssignment", n[n.ShiftLeftAssignment = 24] = "ShiftLeftAssignment", n[n.ShiftRightAssignment = 25] = "ShiftRightAssignment", n[n.SignedShiftRightAssignment = 26] = "SignedShiftRightAssignment", n[n.BitwiseAndAssignment = 27] = "BitwiseAndAssignment", n[n.BitwiseXorAssignment = 28] = "BitwiseXorAssignment", n[n.BitwiseOrAssignment = 29] = "BitwiseOrAssignment", n[n.LogicalAndAssignment = 30] = "LogicalAndAssignment", n[n.LogicalOrAssignment = 31] = "LogicalOrAssignment", n[n.NullCoalesceAssignment = 32] = "NullCoalesceAssignment", n[n.Semicolon = 33] = "Semicolon", n[n.Comma = 34] = "Comma", n[n.Colon = 35] = "Colon", n[n.LSquare = 36] = "LSquare", n[n.RSquare = 37] = "RSquare", n[n.QuestionMark = 38] = "QuestionMark", n[n.NullCoalesce = 39] = "NullCoalesce", n[n.OptionalChaining = 40] = "OptionalChaining", n[n.BinaryNot = 41] = "BinaryNot", n[n.LBrace = 42] = "LBrace", n[n.RBrace = 43] = "RBrace", n[n.Equal = 44] = "Equal", n[n.StrictEqual = 45] = "StrictEqual", n[n.LogicalNot = 46] = "LogicalNot", n[n.NotEqual = 47] = "NotEqual", n[n.StrictNotEqual = 48] = "StrictNotEqual", n[n.LessThan = 49] = "LessThan", n[n.LessThanOrEqual = 50] = "LessThanOrEqual", n[n.ShiftLeft = 51] = "ShiftLeft", n[n.GreaterThan = 52] = "GreaterThan", n[n.GreaterThanOrEqual = 53] = "GreaterThanOrEqual", n[n.ShiftRight = 54] = "ShiftRight", n[n.SignedShiftRight = 55] = "SignedShiftRight", n[n.Dot = 56] = "Dot", n[n.Spread = 57] = "Spread", n[n.Global = 58] = "Global", n[n.Backtick = 59] = "Backtick", n[n.DollarLBrace = 60] = "DollarLBrace", n[n.Arrow = 61] = "Arrow", n[n.DecimalLiteral = 62] = "DecimalLiteral", n[n.HexadecimalLiteral = 63] = "HexadecimalLiteral", n[n.BinaryLiteral = 64] = "BinaryLiteral", n[n.RealLiteral = 65] = "RealLiteral", n[n.StringLiteral = 66] = "StringLiteral", n[n.Infinity = 67] = "Infinity", n[n.NaN = 68] = "NaN", n[n.True = 69] = "True", n[n.False = 70] = "False", n[n.Typeof = 71] = "Typeof", n[n.Null = 72] = "Null", n[n.Undefined = 73] = "Undefined", n[n.In = 74] = "In", n[n.Let = 75] = "Let", n[n.Const = 76] = "Const", n[n.Var = 77] = "Var", n[n.If = 78] = "If", n[n.Else = 79] = "Else", n[n.Return = 80] = "Return", n[n.Break = 81] = "Break", n[n.Continue = 82] = "Continue", n[n.Do = 83] = "Do", n[n.While = 84] = "While", n[n.For = 85] = "For", n[n.Of = 86] = "Of", n[n.Try = 87] = "Try", n[n.Catch = 88] = "Catch", n[n.Finally = 89] = "Finally", n[n.Throw = 90] = "Throw", n[n.Switch = 91] = "Switch", n[n.Case = 92] = "Case", n[n.Default = 93] = "Default", n[n.Delete = 94] = "Delete", n[n.Function = 95] = "Function", n[n.Export = 96] = "Export", n[n.Import = 97] = "Import", n[n.As = 98] = "As", n[n.From = 99] = "From", n))(i || {});
+class $e {
+  // Creates a stream that uses the specified source code
+  constructor(e) {
+    this.source = e, this._pos = 0, this._line = 1, this._column = 0;
+  }
+  // Gets the current position in the stream. Starts from 0.
+  get position() {
+    return this._pos;
+  }
+  // Gets the current line number. Starts from 1.
+  get line() {
+    return this._line;
+  }
+  // Gets the current column number. Starts from 0.
+  get column() {
+    return this._column;
+  }
+  // Peeks the next character in the stream. Returns null, if EOF; otherwise the current source code character
+  peek() {
+    return this.ahead(0);
+  }
+  // Looks ahead with `n` characters in the stream. Returns null, if EOF; otherwise the look-ahead character
+  ahead(e = 1) {
+    return this._pos + e > this.source.length - 1 ? null : this.source[this._pos + e];
+  }
+  // Gets the next character from the stream
+  get() {
+    if (this._pos >= this.source.length)
+      return null;
+    const e = this.source[this._pos++];
+    return e === `
+` ? (this._line++, this._column = 0) : this._column++, e;
+  }
+  // Gets the tail of the input stream
+  getTail(e) {
+    var r;
+    return ((r = this.source) == null ? void 0 : r.substring(e)) ?? "";
+  }
+}
+const j = {
+  [i.Eof]: {},
+  [i.Ws]: {},
+  [i.DollarLBrace]: {},
+  [i.Backtick]: { expressionStart: !0 },
+  [i.BlockComment]: {},
+  [i.EolComment]: {},
+  [i.Unknown]: {},
+  [i.LParent]: { expressionStart: !0 },
+  [i.RParent]: {},
+  [i.Identifier]: { expressionStart: !0, keywordLike: !0, isPropLiteral: !0 },
+  [i.Exponent]: {},
+  [i.Divide]: {},
+  [i.Multiply]: {},
+  [i.Remainder]: {},
+  [i.Plus]: { expressionStart: !0, canBeUnary: !0 },
+  [i.Minus]: { expressionStart: !0, canBeUnary: !0 },
+  [i.BitwiseXor]: {},
+  [i.BitwiseOr]: {},
+  [i.LogicalOr]: {},
+  [i.BitwiseAnd]: {},
+  [i.LogicalAnd]: {},
+  [i.Assignment]: { isAssignment: !0 },
+  [i.AddAssignment]: { isAssignment: !0 },
+  [i.SubtractAssignment]: { isAssignment: !0 },
+  [i.ExponentAssignment]: { isAssignment: !0 },
+  [i.MultiplyAssignment]: { isAssignment: !0 },
+  [i.DivideAssignment]: { isAssignment: !0 },
+  [i.RemainderAssignment]: { isAssignment: !0 },
+  [i.ShiftLeftAssignment]: { isAssignment: !0 },
+  [i.ShiftRightAssignment]: { isAssignment: !0 },
+  [i.SignedShiftRightAssignment]: { isAssignment: !0 },
+  [i.BitwiseAndAssignment]: { isAssignment: !0 },
+  [i.BitwiseXorAssignment]: { isAssignment: !0 },
+  [i.BitwiseOrAssignment]: { isAssignment: !0 },
+  [i.LogicalAndAssignment]: { isAssignment: !0 },
+  [i.LogicalOrAssignment]: { isAssignment: !0 },
+  [i.NullCoalesceAssignment]: { isAssignment: !0 },
+  [i.Semicolon]: {},
+  [i.Comma]: {},
+  [i.Colon]: {},
+  [i.LSquare]: { expressionStart: !0 },
+  [i.RSquare]: {},
+  [i.QuestionMark]: {},
+  [i.NullCoalesce]: {},
+  [i.OptionalChaining]: {},
+  [i.BinaryNot]: { expressionStart: !0, canBeUnary: !0 },
+  [i.LBrace]: { expressionStart: !0 },
+  [i.RBrace]: {},
+  [i.Equal]: {},
+  [i.StrictEqual]: {},
+  [i.LogicalNot]: { expressionStart: !0, canBeUnary: !0 },
+  [i.NotEqual]: {},
+  [i.StrictNotEqual]: {},
+  [i.LessThan]: {},
+  [i.LessThanOrEqual]: {},
+  [i.ShiftLeft]: {},
+  [i.GreaterThan]: {},
+  [i.GreaterThanOrEqual]: {},
+  [i.ShiftRight]: {},
+  [i.SignedShiftRight]: {},
+  [i.Dot]: {},
+  [i.Spread]: { expressionStart: !0, isPropLiteral: !0 },
+  [i.Global]: { expressionStart: !0 },
+  [i.DecimalLiteral]: { expressionStart: !0, isPropLiteral: !0 },
+  [i.HexadecimalLiteral]: { expressionStart: !0, isPropLiteral: !0 },
+  [i.BinaryLiteral]: { expressionStart: !0, isPropLiteral: !0 },
+  [i.RealLiteral]: { expressionStart: !0, isPropLiteral: !0 },
+  [i.StringLiteral]: { expressionStart: !0, isPropLiteral: !0 },
+  [i.IncOp]: { expressionStart: !0 },
+  [i.DecOp]: { expressionStart: !0 },
+  [i.Infinity]: { expressionStart: !0, keywordLike: !0 },
+  [i.NaN]: { expressionStart: !0, keywordLike: !0 },
+  [i.True]: { expressionStart: !0, keywordLike: !0, isPropLiteral: !0 },
+  [i.False]: { expressionStart: !0, keywordLike: !0, isPropLiteral: !0 },
+  [i.Typeof]: { expressionStart: !0, canBeUnary: !0, keywordLike: !0 },
+  [i.Null]: { expressionStart: !0, keywordLike: !0 },
+  [i.Undefined]: { expressionStart: !0, keywordLike: !0 },
+  [i.In]: { keywordLike: !0 },
+  [i.Let]: { keywordLike: !0 },
+  [i.Const]: { keywordLike: !0 },
+  [i.Var]: { keywordLike: !0 },
+  [i.If]: { keywordLike: !0 },
+  [i.Else]: { keywordLike: !0 },
+  [i.Arrow]: { keywordLike: !0 },
+  [i.Return]: { keywordLike: !0 },
+  [i.Break]: { keywordLike: !0 },
+  [i.Continue]: { keywordLike: !0 },
+  [i.Do]: { keywordLike: !0 },
+  [i.While]: { keywordLike: !0 },
+  [i.For]: { keywordLike: !0 },
+  [i.Of]: { keywordLike: !0 },
+  [i.Throw]: { keywordLike: !0 },
+  [i.Try]: { keywordLike: !0 },
+  [i.Catch]: { keywordLike: !0 },
+  [i.Finally]: { keywordLike: !0 },
+  [i.Switch]: { keywordLike: !0 },
+  [i.Case]: { keywordLike: !0 },
+  [i.Default]: { keywordLike: !0 },
+  [i.Delete]: { expressionStart: !0, canBeUnary: !0, keywordLike: !0 },
+  [i.Function]: { keywordLike: !0, expressionStart: !0 },
+  [i.Export]: { keywordLike: !0 },
+  [i.Import]: { keywordLike: !0 },
+  [i.As]: { keywordLike: !0 },
+  [i.From]: { keywordLike: !0 }
+};
+class ze {
+  /**
+   * Initializes the tokenizer with the input stream
+   * @param input Input source code stream
+   */
+  constructor(e) {
+    this.input = e, this._ahead = [], this._prefetched = null, this._prefetchedPos = null, this._prefetchedColumn = null, this._lastFetchPosition = 0, this._phaseExternallySet = null;
+  }
+  /**
+   * Fetches the next token without advancing to its position
+   * @param ws If true, retrieve whitespaces too
+   */
+  peek(e = !1) {
+    return this.ahead(0, e);
+  }
+  /**
+   * Reads tokens ahead
+   * @param n Number of token positions to read ahead
+   * @param ws If true, retrieve whitespaces too
+   */
+  ahead(e = 1, r = !1) {
+    if (e > 16)
+      throw new Error("Cannot look ahead more than 16 tokens");
+    for (; this._ahead.length <= e; ) {
+      const t = this.fetch();
+      if (fe(t))
+        return t;
+      (r || !r && !pe(t)) && this._ahead.push(t);
+    }
+    return this._ahead[e];
+  }
+  /**
+   * Fetches the next token and advances the stream position
+   * @param ws If true, retrieve whitespaces too
+   */
+  get(e = !1) {
+    if (this._ahead.length > 0) {
+      const r = this._ahead.shift();
+      if (!r)
+        throw new Error("Token expected");
+      return r;
+    }
+    for (; ; ) {
+      const r = this.fetch();
+      if (fe(r) || e || !e && !pe(r))
+        return r;
+    }
+  }
+  /**
+   * Gets a RegEx from the current position
+   */
+  getRegEx() {
+    return this.fetchRegEx();
+  }
+  /**
+   * Gets the remaining characters after the parsing phase
+   */
+  getTail() {
+    return this._ahead.length > 0 ? this.input.getTail(this._ahead[0].location.startPosition) : this.input.getTail(this._lastFetchPosition);
+  }
+  /**
+   * Parsing template literals requires a context sensitive lexer.
+   * This method has to be called by the parser when the lexer needs to scan a string inside a template literal.
+   * Call this after the first opening backing and after the parser is done with parsing a placeholder, after the right brace.
+   */
+  setStartingPhaseToTemplateLiteral() {
+    this._phaseExternallySet = 33;
+  }
+  /**
+   * Fetches the next character from the input stream
+   */
+  fetchNextChar() {
+    return this._prefetched || (this._prefetchedPos = this.input.position, this._prefetchedColumn = this.input.column, this._prefetched = this.input.get()), this._prefetched;
+  }
+  /**
+   * Fetches the next token from the input stream
+   */
+  fetch() {
+    const e = this, r = this.input, t = this._prefetchedPos || r.position, l = r.line, a = this._prefetchedColumn || r.column;
+    this._lastFetchPosition = this.input.position;
+    let o = null, c = "", s = i.Eof, D = r.position, L = r.column, u = null, O = !1, p = this.getStartingPhaseThenReset();
+    for (; ; ) {
+      if (u = this.fetchNextChar(), u === null)
+        return m();
+      s === i.Eof && (s = i.Unknown);
+      e: switch (p) {
+        case 0:
+          switch (u) {
+            case " ":
+            case "	":
+            case `
+`:
+            case "\r":
+              p = 1, s = i.Ws;
+              break;
+            case "/":
+              p = 5, s = i.Divide;
+              break;
+            case "$":
+              p = 6, s = i.Identifier;
+              break;
+            case "*":
+              p = 8, s = i.Multiply;
+              break;
+            case "%":
+              p = 54, s = i.Remainder;
+              break;
+            case "+":
+              p = 51, s = i.Plus;
+              break;
+            case "-":
+              p = 52, s = i.Minus;
+              break;
+            case "^":
+              p = 58, s = i.BitwiseXor;
+              break;
+            case "|":
+              p = 7, s = i.BitwiseOr;
+              break;
+            case "&":
+              p = 9, s = i.BitwiseAnd;
+              break;
+            case "?":
+              p = 22, s = i.QuestionMark;
+              break;
+            case ";":
+              return E(i.Semicolon);
+            case ",":
+              return E(i.Comma);
+            case "(":
+              return E(i.LParent);
+            case ")":
+              return E(i.RParent);
+            case ":":
+              p = 20, s = i.Colon;
+              break;
+            case "`":
+              return E(i.Backtick);
+            case "[":
+              return E(i.LSquare);
+            case "]":
+              return E(i.RSquare);
+            case "~":
+              return E(i.BinaryNot);
+            case "{":
+              return E(i.LBrace);
+            case "}":
+              return E(i.RBrace);
+            case "=":
+              p = 10, s = i.Assignment;
+              break;
+            case "!":
+              p = 13, s = i.LogicalNot;
+              break;
+            case "<":
+              p = 14, s = i.LessThan;
+              break;
+            case ">":
+              p = 15, s = i.GreaterThan;
+              break;
+            case "0":
+              p = 21, s = i.DecimalLiteral;
+              break;
+            case ".":
+              p = 18, s = i.Dot;
+              break;
+            case '"':
+            case "'":
+              o = u, p = 35;
+              break;
+            default:
+              ge(u) ? (O = !0, p = 17, s = i.Identifier) : Z(u) ? (p = 27, s = i.DecimalLiteral) : E(i.Unknown);
+              break;
+          }
+          break;
+        case 6:
+          if (u === "{")
+            return E(i.DollarLBrace);
+          p = 17, O = !0, s = i.Identifier, ke(u) || m();
+          break;
+        case 1:
+          if (u !== " " && u !== "	" && u !== "\r" && u !== `
+`)
+            return m();
+          break;
+        case 3:
+          u === "*" && (p = 4);
+          break;
+        case 4:
+          if (u === "/")
+            return E(i.BlockComment);
+          break;
+        case 2:
+          if (u === `
+`)
+            return E();
+          break;
+        case 17:
+          if (!ke(u))
+            return m();
+          break;
+        case 20:
+          return u === ":" ? E(i.Global) : m();
+        case 5:
+          if (u === "*")
+            p = 3;
+          else if (u === "/")
+            p = 2, s = i.EolComment;
+          else return u === "=" ? E(i.DivideAssignment) : m();
+          break;
+        case 51:
+          return u === "+" ? E(i.IncOp) : u === "=" ? E(i.AddAssignment) : m();
+        case 52:
+          return u === "-" ? E(i.DecOp) : u === "=" ? E(i.SubtractAssignment) : m();
+        case 54:
+          return u === "=" ? E(i.RemainderAssignment) : m();
+        case 58:
+          return u === "=" ? E(i.BitwiseXorAssignment) : m();
+        case 7:
+          if (u === "=")
+            return E(i.BitwiseOrAssignment);
+          if (u === "|") {
+            p = 59, s = i.LogicalOr;
+            break;
+          }
+          return m();
+        case 59:
+          return u === "=" ? E(i.LogicalOrAssignment) : m();
+        case 9:
+          if (u === "=")
+            return E(i.BitwiseAndAssignment);
+          if (u === "&") {
+            p = 57, s = i.LogicalAnd;
+            break;
+          }
+          return m();
+        case 57:
+          return u === "=" ? E(i.LogicalAndAssignment) : m();
+        case 8:
+          if (u === "*") {
+            p = 50, s = i.Exponent;
+            break;
+          } else if (u === "=")
+            return E(i.MultiplyAssignment);
+          return m();
+        case 50:
+          return u === "=" ? E(i.ExponentAssignment) : m();
+        case 22:
+          if (u === "?") {
+            p = 60, s = i.NullCoalesce;
+            break;
+          }
+          return u === "." ? E(i.OptionalChaining) : m();
+        case 60:
+          return u === "=" ? E(i.NullCoalesceAssignment) : m();
+        case 10:
+          if (u === ">")
+            return E(i.Arrow);
+          if (u === "=") {
+            p = 11, s = i.Equal;
+            break;
+          }
+          return m();
+        case 11:
+          return u === "=" ? E(i.StrictEqual) : m();
+        case 13:
+          if (u === "=") {
+            p = 12, s = i.NotEqual;
+            break;
+          }
+          return m();
+        case 12:
+          return u === "=" ? E(i.StrictNotEqual) : m();
+        case 14:
+          if (u === "=")
+            return E(i.LessThanOrEqual);
+          if (u === "<") {
+            p = 55, s = i.ShiftLeft;
+            break;
+          }
+          return m();
+        case 55:
+          return u === "=" ? E(i.ShiftLeftAssignment) : m();
+        case 15:
+          if (u === "=")
+            return E(i.GreaterThanOrEqual);
+          if (u === ">") {
+            p = 16, s = i.SignedShiftRight;
+            break;
+          }
+          return m();
+        case 16:
+          if (u === ">") {
+            p = 56, s = i.ShiftRight;
+            break;
+          }
+          return u === "=" ? E(i.SignedShiftRightAssignment) : m();
+        case 56:
+          return u === "=" ? E(i.ShiftRightAssignment) : m();
+        case 21:
+          if (u === "x")
+            p = 23, s = i.Unknown;
+          else if (u === "b")
+            p = 25, s = i.Unknown;
+          else if (Z(u) || u === "_")
+            p = 27;
+          else if (u === ".")
+            p = 28, s = i.Unknown;
+          else if (u === "e" || u === "E")
+            p = 30, s = i.Unknown;
+          else
+            return m();
+          break;
+        case 18:
+          if (u === ".") {
+            p = 19, s = i.Unknown;
+            break;
+          }
+          if (!Z(u))
+            return m();
+          p = 29, s = i.RealLiteral;
+          break;
+        case 19:
+          return u === "." ? E(i.Spread) : m();
+        case 23:
+          if (u === "_")
+            break;
+          if (!z(u))
+            return m();
+          p = 24, s = i.HexadecimalLiteral;
+          break;
+        case 24:
+          if (!z(u) && u !== "_")
+            return m();
+          break;
+        case 25:
+          if (u === "_")
+            break;
+          if (!Ee(u))
+            return m();
+          p = 26, s = i.BinaryLiteral;
+          break;
+        case 26:
+          if (!Ee(u) && u !== "_")
+            return m();
+          s = i.BinaryLiteral;
+          break;
+        case 27:
+          if (Z(u) || u === "_")
+            break;
+          if (u === "." && (this.input.peek() === null || Z(this.input.peek())))
+            p = 28, s = i.Unknown;
+          else if (u === "e" || u === "E")
+            p = 30, s = i.Unknown;
+          else
+            return m();
+          break;
+        case 28:
+          if (Z(u))
+            p = 29, s = i.RealLiteral;
+          else if (u === "e" || u === "E")
+            p = 30;
+          else
+            return m();
+          break;
+        case 29:
+          if (u === "e" || u === "E")
+            p = 30, s = i.Unknown;
+          else if (!Z(u) && u !== "_")
+            return m();
+          break;
+        case 30:
+          if (u === "+" || u === "-")
+            p = 31;
+          else if (Z(u))
+            p = 32, s = i.RealLiteral;
+          else
+            return m();
+          break;
+        case 31:
+          if (Z(u))
+            p = 32, s = i.RealLiteral;
+          else
+            return m();
+          break;
+        case 32:
+          if (!Z(u))
+            return m();
+          break;
+        case 34: {
+          p = 33;
+          const q = this.input.ahead(0), X = this.input.ahead(1);
+          if (q === "`" || q === "$" && X === "{")
+            return E(i.StringLiteral);
+          break;
+        }
+        case 33:
+          switch (u) {
+            case "\\":
+              p = 34, s = i.Unknown;
+              break e;
+            case "`":
+              return E(i.Backtick);
+            case "$":
+              if (this.input.ahead(0) === "{")
+                return U(), this.fetchNextChar(), E(i.DollarLBrace);
+          }
+          const $ = this.input.ahead(0), K = this.input.ahead(1);
+          if ($ === "`" || $ === "$" && K === "{")
+            return E(i.StringLiteral);
+          break;
+        case 35:
+          if (u === o)
+            return E(i.StringLiteral);
+          if (He(u))
+            return E(i.Unknown);
+          u === "\\" && (p = 36, s = i.Unknown);
+          break;
+        case 36:
+          switch (u) {
+            case "b":
+            case "f":
+            case "n":
+            case "r":
+            case "t":
+            case "v":
+            case "S":
+            case "0":
+            case "'":
+            case '"':
+            case "`":
+            case "\\":
+              p = 35;
+              break;
+            case "x":
+              p = 37;
+              break;
+            case "u":
+              p = 39;
+              break;
+            default:
+              p = 35;
+              break;
+          }
+          break;
+        case 37:
+          if (z(u))
+            p = 38;
+          else
+            return E(i.Unknown);
+          break;
+        case 38:
+          if (z(u))
+            p = 35;
+          else
+            return E(i.Unknown);
+          break;
+        case 39:
+          if (u === "{") {
+            p = 43;
+            break;
+          }
+          if (z(u))
+            p = 40;
+          else
+            return E(i.Unknown);
+          break;
+        case 40:
+          if (z(u))
+            p = 41;
+          else
+            return E(i.Unknown);
+          break;
+        case 41:
+          if (z(u))
+            p = 42;
+          else
+            return E(i.Unknown);
+          break;
+        case 42:
+          if (z(u))
+            p = 35;
+          else
+            return E(i.Unknown);
+          break;
+        case 43:
+          if (z(u))
+            p = 44;
+          else
+            return E(i.Unknown);
+          break;
+        case 44:
+          if (u === "}")
+            p = 35;
+          else if (z(u))
+            p = 45;
+          else
+            return E(i.Unknown);
+          break;
+        case 45:
+          if (u === "}")
+            p = 35;
+          else if (z(u))
+            p = 46;
+          else
+            return E(i.Unknown);
+          break;
+        case 46:
+          if (u === "}")
+            p = 35;
+          else if (z(u))
+            p = 47;
+          else
+            return E(i.Unknown);
+          break;
+        case 47:
+          if (u === "}")
+            p = 35;
+          else if (z(u))
+            p = 48;
+          else
+            return E(i.Unknown);
+          break;
+        case 48:
+          if (u === "}")
+            p = 35;
+          else if (z(u))
+            p = 49;
+          else
+            return E(i.Unknown);
+          break;
+        case 49:
+          if (u === "}")
+            p = 35;
+          else
+            return E(i.Unknown);
+          break;
+        default:
+          return m();
+      }
+      U();
+    }
+    function U() {
+      c += u, e._prefetched = null, e._prefetchedPos = null, e._prefetchedColumn = null, D = r.position, L = r.position;
+    }
+    function m() {
+      return O && (s = N.get(c) ?? (ge(c[0]) && c[c.length - 1] !== "'" ? i.Identifier : i.Unknown)), {
+        text: c,
+        type: s,
+        location: {
+          startPosition: t,
+          endPosition: D,
+          startLine: l,
+          endLine: l,
+          startColumn: a,
+          endColumn: L
+        }
+      };
+    }
+    function E($) {
+      return U(), $ !== void 0 && (s = $), m();
+    }
+  }
+  getStartingPhaseThenReset() {
+    if (this._phaseExternallySet !== null) {
+      const e = this._phaseExternallySet;
+      return this._phaseExternallySet = null, e;
+    }
+    return 0;
+  }
+  /**
+   * Fetches the next RegEx token from the input stream
+   */
+  fetchRegEx() {
+    const e = this._ahead.length > 0 ? this._ahead[0].location.startPosition : this._lastFetchPosition, r = this.input.getTail(e);
+    try {
+      const t = de(r), l = t.raw;
+      for (let a = 1; a < l.length; a++)
+        this.fetchNextChar(), this._prefetched = null, this._prefetchedPos = null, this._prefetchedColumn = null;
+      return this._ahead.length = 0, {
+        success: !0,
+        pattern: t.pattern.raw,
+        flags: t.flags.raw,
+        length: l.length
+      };
+    } catch (t) {
+      let l = t.index;
+      if (t.toString().includes("Invalid flag"))
+        for (; l < r.length && "dgimsuy".includes(r[l]); )
+          l++;
+      if (l === void 0)
+        return {
+          success: !1,
+          pattern: r[0]
+        };
+      const a = r.substring(0, l);
+      try {
+        const o = de(a), c = o.raw;
+        for (let s = 1; s < c.length; s++)
+          this.fetchNextChar(), this._prefetched = null, this._prefetchedPos = null, this._prefetchedColumn = null;
+        return this._ahead.length = 0, {
+          success: !0,
+          pattern: o.pattern.raw,
+          flags: o.flags.raw,
+          length: c.length
+        };
+      } catch {
+        return {
+          success: !1,
+          pattern: a
+        };
+      }
+    }
+  }
+}
+const N = /* @__PURE__ */ new Map();
+N.set("typeof", i.Typeof);
+N.set("Infinity", i.Infinity);
+N.set("NaN", i.NaN);
+N.set("true", i.True);
+N.set("false", i.False);
+N.set("undefined", i.Undefined);
+N.set("null", i.Null);
+N.set("in", i.In);
+N.set("let", i.Let);
+N.set("const", i.Const);
+N.set("var", i.Var);
+N.set("if", i.If);
+N.set("else", i.Else);
+N.set("return", i.Return);
+N.set("break", i.Break);
+N.set("continue", i.Continue);
+N.set("do", i.Do);
+N.set("while", i.While);
+N.set("for", i.For);
+N.set("of", i.Of);
+N.set("try", i.Try);
+N.set("catch", i.Catch);
+N.set("finally", i.Finally);
+N.set("throw", i.Throw);
+N.set("switch", i.Switch);
+N.set("case", i.Case);
+N.set("default", i.Default);
+N.set("delete", i.Delete);
+N.set("function", i.Function);
+N.set("export", i.Export);
+N.set("import", i.Import);
+N.set("as", i.As);
+N.set("from", i.From);
+function fe(n) {
+  return n.type === i.Eof;
+}
+function pe(n) {
+  return n.type <= i.Ws;
+}
+function ge(n) {
+  return n >= "a" && n <= "z" || n >= "A" && n <= "Z" || n === "_" || n === "$";
+}
+function ke(n) {
+  return n >= "a" && n <= "z" || n >= "A" && n <= "Z" || n >= "0" && n <= "9" || n === "_" || n === "$";
+}
+function Ee(n) {
+  return n === "0" || n === "1";
+}
+function Z(n) {
+  return n >= "0" && n <= "9";
+}
+function z(n) {
+  return n >= "0" && n <= "9" || n >= "A" && n <= "F" || n >= "a" && n <= "f";
+}
+function He(n) {
+  return n === "\r" || n === `
+` || n === "…" || n === "\u2028" || n === "\u2029";
+}
+let Ge = class be extends Error {
+  constructor(e, r) {
+    super(e), this.code = r, Object.setPrototypeOf(this, be.prototype);
+  }
+};
+const ie = {
+  W001: "An expression expected",
+  W002: "Unexpected token: {0}",
+  W003: "An identifier expected",
+  W004: "'}' expected",
+  W005: "']' expected",
+  W006: "')' expected",
+  W007: "Invalid object property name type",
+  W008: "':' expected",
+  W009: "'=' expected",
+  W010: "Invalid argument list",
+  W011: "For loop variable must be initialized",
+  W012: "'{' expected",
+  W013: "'catch' or 'finally' expected",
+  W014: "'(' or expected",
+  W015: "'case' or 'default' expected",
+  W016: "'default' case can be used only once within a switch statement",
+  W017: "Invalid sequence expression",
+  W018: "Invalid object literal",
+  W019: "Identifier '{0}' is already imported",
+  W020: "Function '{0}' is already defined in the module",
+  W021: "'{0}' is already exported from the module",
+  W022: "Cannot find module '{0}'",
+  W023: "Module '{0}' does not export '{1}'",
+  W024: "'function' or 'const' expected",
+  W025: "'from' expected",
+  W026: "A string literal expected",
+  W027: "Variables can be declared only in the top level module",
+  W028: "Invalid statement used in a module",
+  W029: "An imported module can contain only exported functions",
+  W030: "Nested declarations cannot be exported",
+  W031: "An identifier in a declaration cannot start with '$'"
+};
+class Ne {
+  /**
+   * Initializes the parser with the specified source code
+   * @param source Source code to parse
+   */
+  constructor(e) {
+    this.source = e, this._parseErrors = [], this._statementLevel = 0, this._lexer = new ze(new $e(e));
+  }
+  /**
+   * The errors raised during the parse phase
+   */
+  get errors() {
+    return this._parseErrors;
+  }
+  /**
+   * Gets the current token
+   */
+  get current() {
+    return this._lexer.peek();
+  }
+  /**
+   * Checks if we're at the end of the expression
+   */
+  get isEof() {
+    return this._lexer.peek().type === i.Eof;
+  }
+  /**
+   * Gets the characters remaining after parsing
+   */
+  getTail() {
+    return this._lexer.getTail();
+  }
+  // ==========================================================================
+  // Statement parsing
+  /**
+   * Parses a list of statements:
+   *
+   * statements
+   *   : statement*
+   *   ;
+   *
+   * statement
+   *   : emptyStatement
+   *   | expressionStatement
+   *   | letStatement
+   *   | returnStatement
+   *   ;
+   */
+  parseStatements() {
+    this._statementLevel = 0;
+    const e = [];
+    for (; !this.isEof; ) {
+      const r = this.parseStatement();
+      if (!r) return null;
+      e.push(r), r.type !== "EmptyS" && this.skipToken(i.Semicolon);
+    }
+    return e;
+  }
+  /**
+   * Parses a single statement
+   */
+  parseStatement(e = !0) {
+    this._statementLevel++;
+    try {
+      const r = this._lexer.peek();
+      switch (r.type) {
+        case i.Semicolon:
+          return this.parseEmptyStatement();
+        case i.Let:
+          return this.parseLetStatement();
+        case i.Const:
+          return this.parseConstStatement();
+        case i.Var:
+          return this.parseVarStatement();
+        case i.LBrace:
+          return this.parseBlockStatement();
+        case i.If:
+          return this.parseIfStatement();
+        case i.Do:
+          return this.parseDoWhileStatement();
+        case i.While:
+          return this.parseWhileStatement();
+        case i.Return:
+          return this.parseReturnStatement();
+        case i.Break:
+          return this._lexer.get(), this.createStatementNode("BrkS", {}, r, r);
+        case i.Continue:
+          return this._lexer.get(), this.createStatementNode("ContS", {}, r, r);
+        case i.For:
+          return this.parseForStatement();
+        case i.Throw:
+          return this.parseThrowStatement();
+        case i.Try:
+          return this.parseTryStatement();
+        case i.Switch:
+          return this.parseSwitchStatement();
+        case i.Function:
+          return this.parseFunctionDeclaration();
+        case i.Export:
+          return this.parseExport();
+        case i.Import:
+          return this.parseImport();
+        default:
+          return r.type === i.Eof ? (this.reportError("W002", r, "EOF"), null) : this.isExpressionStart(r) ? this.parseExpressionStatement(e) : (this.reportError("W002", r, r.text), null);
+      }
+    } finally {
+      this._statementLevel--;
+    }
+  }
+  /**
+   * Parses an empty statement
+   *
+   * emptyStatement
+   *   : ";"
+   *   ;
+   */
+  parseEmptyStatement() {
+    const e = this._lexer.get();
+    return this.createStatementNode("EmptyS", {}, e, e);
+  }
+  /**
+   * Parses an expression statement
+   *
+   * expressionStatement
+   *   : expression
+   *   ;
+   */
+  parseExpressionStatement(e = !0) {
+    const r = this._lexer.peek(), t = this.getExpression(e);
+    return t ? this.createStatementNode(
+      "ExprS",
+      {
+        expression: t
+      },
+      r,
+      t.endToken
+    ) : null;
+  }
+  /**
+   * Parses a let statement
+   *
+   * letStatement
+   *   : "let" id ["=" expression] ("," id ["=" expression])*
+   *   ;
+   */
+  parseLetStatement() {
+    const e = this._lexer.get();
+    let r = e;
+    const t = [];
+    for (; ; ) {
+      const l = this._lexer.peek();
+      let a = {};
+      if (l.type === i.LBrace) {
+        r = this._lexer.ahead(1);
+        const s = this.parseObjectDestructure();
+        if (s === null) return null;
+        a = {
+          objectDestruct: s
+        }, r = s.length > 0 ? s[s.length - 1].endToken : r;
+      } else if (l.type === i.LSquare) {
+        r = this._lexer.ahead(1);
+        const s = this.parseArrayDestructure();
+        if (s === null) return null;
+        a = {
+          arrayDestruct: s
+        }, r = s.length > 0 ? s[s.length - 1].endToken : r;
+      } else if (l.type === i.Identifier) {
+        if (l.text.startsWith("$"))
+          return this.reportError("W031"), null;
+        r = this._lexer.get(), a = {
+          id: l.text
+        };
+      } else
+        return this.reportError("W003"), null;
+      const o = this._lexer.peek();
+      let c = null;
+      if (o.type === i.Assignment) {
+        if (this._lexer.get(), c = this.getExpression(!1), c === null) return null;
+        a.expression = c, r = c.endToken;
+      } else if (a.arrayDestruct || a.objectDestruct)
+        return this.reportError("W009", o), null;
+      if (t.push(
+        this.createExpressionNode("VarD", a, l, r)
+      ), this._lexer.peek().type !== i.Comma) break;
+      this._lexer.get();
+    }
+    return this.createStatementNode(
+      "LetS",
+      {
+        declarations: t
+      },
+      e,
+      r
+    );
+  }
+  /**
+   * Parses a const statement
+   *
+   * constStatement
+   *   : "const" id "=" expression
+   *   ;
+   */
+  parseConstStatement() {
+    const e = this._lexer.get();
+    let r = e;
+    const t = [];
+    for (; ; ) {
+      const l = this._lexer.peek();
+      let a = {};
+      if (l.type === i.LBrace) {
+        r = this._lexer.ahead(1);
+        const c = this.parseObjectDestructure();
+        if (c === null) return null;
+        a = {
+          objectDestruct: c
+        }, r = c.length > 0 ? c[c.length - 1].endToken : r;
+      } else if (l.type === i.LSquare) {
+        r = this._lexer.ahead(1);
+        const c = this.parseArrayDestructure();
+        if (c === null) return null;
+        a = {
+          arrayDestruct: c
+        }, r = c.length > 0 ? c[c.length - 1].endToken : r;
+      } else if (l.type === i.Identifier) {
+        if (l.text.startsWith("$"))
+          return this.reportError("W031"), null;
+        r = this._lexer.get(), a = {
+          id: l.text
+        };
+      } else
+        return this.reportError("W003"), null;
+      this.expectToken(i.Assignment);
+      const o = this.getExpression(!1);
+      if (o === null) return null;
+      if (a.expression = o, r = o.endToken, t.push(
+        this.createExpressionNode("VarD", a, l, r)
+      ), this._lexer.peek().type !== i.Comma) break;
+      this._lexer.get();
+    }
+    return this.createStatementNode(
+      "ConstS",
+      {
+        declarations: t
+      },
+      e,
+      r
+    );
+  }
+  /**
+   * Parses a const statement
+   *
+   * constStatement
+   *   : "var" id "=" expression
+   *   ;
+   */
+  parseVarStatement() {
+    const e = this._lexer.get();
+    let r = e;
+    const t = [];
+    for (; ; ) {
+      const l = this._lexer.peek();
+      let a = {};
+      if (l.type === i.Identifier) {
+        if (l.text.startsWith("$"))
+          return this.reportError("W031"), null;
+        r = this._lexer.get(), a = {
+          id: l.text
+        };
+      } else
+        return this.reportError("W003"), null;
+      this.expectToken(i.Assignment);
+      const o = this.getExpression(!1);
+      if (o === null) return null;
+      if (a.expression = o, r = o.endToken, t.push(
+        this.createExpressionNode(
+          "RVarD",
+          a,
+          l,
+          r
+        )
+      ), this._lexer.peek().type !== i.Comma) break;
+      this._lexer.get();
+    }
+    return this.createStatementNode(
+      "VarS",
+      {
+        declarations: t
+      },
+      e,
+      r
+    );
+  }
+  /**
+   * Parses an object destructure expression
+   */
+  parseObjectDestructure() {
+    const e = [], r = this._lexer.get();
+    let t = r, l = this._lexer.peek();
+    for (; l.type === i.Identifier; ) {
+      const a = l.text;
+      if (a.startsWith("$"))
+        return this.reportError("W031"), null;
+      let o, c, s;
+      if (this._lexer.get(), l = this._lexer.peek(), l.type === i.Colon) {
+        if (this._lexer.get(), l = this._lexer.peek(), l.type === i.Identifier)
+          o = l.text, t = l, this._lexer.get();
+        else if (l.type === i.LSquare) {
+          if (c = this.parseArrayDestructure(), c === null) return null;
+          t = c[c.length - 1].endToken;
+        } else if (l.type === i.LBrace) {
+          if (s = this.parseObjectDestructure(), s === null) return null;
+          t = s[s.length - 1].endToken;
+        }
+      }
+      l = this._lexer.peek(), (l.type === i.Comma || l.type === i.RBrace) && (e.push(
+        this.createExpressionNode(
+          "ODestr",
+          { id: a, alias: o, arrayDestruct: c, objectDestruct: s },
+          r,
+          t
+        )
+      ), l.type === i.Comma && (this._lexer.get(), l = this._lexer.peek()));
+    }
+    return this.expectToken(i.RBrace, "W004"), e;
+  }
+  parseArrayDestructure() {
+    const e = [], r = this._lexer.get();
+    let t = r;
+    do {
+      let l = this._lexer.peek(), a, o, c;
+      if (l.type === i.Identifier) {
+        if (a = l.text, a.startsWith("$"))
+          return this.reportError("W031"), null;
+        t = l, l = this._lexer.get();
+      } else if (l.type === i.LSquare) {
+        if (o = this.parseArrayDestructure(), o === null) return null;
+        t = o[o.length - 1].endToken;
+      } else if (l.type === i.LBrace) {
+        if (c = this.parseObjectDestructure(), c === null) return null;
+        t = c[c.length - 1].endToken;
+      }
+      if (l = this._lexer.peek(), l.type === i.Comma)
+        e.push(
+          this.createExpressionNode(
+            "ADestr",
+            { id: a, arrayDestruct: o, objectDestruct: c },
+            r,
+            t
+          )
+        ), this._lexer.get();
+      else if (l.type === i.RSquare) {
+        (a || o || c) && e.push(
+          this.createExpressionNode(
+            "ADestr",
+            { id: a, arrayDestruct: o, objectDestruct: c },
+            r,
+            t
+          )
+        );
+        break;
+      } else
+        return this.reportError("W002", l), null;
+    } while (!0);
+    return this.expectToken(i.RSquare, "W005"), e;
+  }
+  /**
+   * Parses a block statement
+   *
+   * blockStatement
+   *   : "{" (statement [";"])* "}"
+   *   ;
+   */
+  parseBlockStatement() {
+    const e = this._lexer.get(), r = [];
+    for (; this._lexer.peek().type !== i.RBrace; ) {
+      const l = this.parseStatement();
+      if (!l) return null;
+      r.push(l), l.type !== "EmptyS" && this.skipToken(i.Semicolon);
+    }
+    const t = this._lexer.get();
+    return this.createStatementNode("BlockS", { statements: r }, e, t);
+  }
+  /**
+   * Parses an if statement
+   *
+   * ifStatement
+   *   : "if" "(" expression ")" statement ["else" statement]
+   *   ;
+   */
+  parseIfStatement() {
+    const e = this._lexer.get();
+    let r = e;
+    this.expectToken(i.LParent, "W014");
+    const t = this.getExpression();
+    if (!t) return null;
+    this.expectToken(i.RParent, "W006");
+    const l = this.parseStatement();
+    if (!l) return null;
+    r = l.endToken;
+    let a = !0;
+    l.type !== "BlockS" && (this._lexer.peek().type === i.Semicolon ? this._lexer.get() : a = !1);
+    let o = null;
+    if (a && this._lexer.peek().type === i.Else) {
+      if (this._lexer.get(), o = this.parseStatement(), !o) return null;
+      r = o.endToken;
+    }
+    return this.createStatementNode(
+      "IfS",
+      {
+        condition: t,
+        thenBranch: l,
+        elseBranch: o
+      },
+      e,
+      r
+    );
+  }
+  /**
+   * Parses a while statement
+   *
+   * whileStatement
+   *   : "while" "(" condition ")" statement
+   *   ;
+   */
+  parseWhileStatement() {
+    const e = this._lexer.get();
+    this.expectToken(i.LParent, "W014");
+    const r = this.getExpression();
+    if (!r) return null;
+    this.expectToken(i.RParent, "W006");
+    const t = this.parseStatement();
+    return t ? this.createStatementNode(
+      "WhileS",
+      {
+        condition: r,
+        body: t
+      },
+      e,
+      t.endToken
+    ) : null;
+  }
+  /**
+   * Parses a do-while statement
+   *
+   * doWhileStatement
+   *   : "do" statement "while" "(" condition ")"
+   *   ;
+   */
+  parseDoWhileStatement() {
+    const e = this._lexer.get(), r = this.parseStatement();
+    if (!r) return null;
+    r.type !== "BlockS" && r.type !== "EmptyS" && this.expectToken(i.Semicolon), this.expectToken(i.While), this.expectToken(i.LParent, "W014");
+    const t = this.getExpression();
+    if (!t) return null;
+    const l = this._lexer.peek();
+    return this.expectToken(i.RParent, "W006"), this.createStatementNode(
+      "DoWS",
+      {
+        condition: t,
+        body: r
+      },
+      e,
+      l
+    );
+  }
+  /**
+   * Parses an expression statement
+   *
+   * returnStatement
+   *   : "return" expression?
+   *   ;
+   */
+  parseReturnStatement() {
+    const e = this._lexer.peek();
+    let r = this._lexer.get(), t;
+    if (j[this._lexer.peek().type].expressionStart) {
+      if (t = this.getExpression(), t === null) return null;
+      r = t.endToken;
+    }
+    return this.createStatementNode(
+      "RetS",
+      {
+        expression: t
+      },
+      e,
+      r
+    );
+  }
+  /**
+   * forStatement
+   *   : "for" "(" initStatement? ";" expression? ";" expression? ")" statement
+   *   | forInOfStatement
+   *   ;
+   */
+  parseForStatement() {
+    const e = this._lexer.peek();
+    this._lexer.get(), this.expectToken(i.LParent, "W014");
+    let r = this._lexer.peek();
+    if (r.type === i.Identifier) {
+      if (this._lexer.ahead(1).type === i.In)
+        return this.parseForInOfStatement(e, "none", r.text, "ForInS");
+      if (this._lexer.ahead(1).type === i.Of)
+        return this.parseForInOfStatement(e, "none", r.text, "ForOfS");
+    } else if (r.type === i.Let) {
+      const c = this._lexer.ahead(1);
+      if (c.type === i.Identifier) {
+        const s = this._lexer.ahead(2);
+        if (s.type === i.In)
+          return this.parseForInOfStatement(e, "let", c.text, "ForInS");
+        if (s.type === i.Of)
+          return this.parseForInOfStatement(e, "let", c.text, "ForOfS");
+      }
+    } else if (r.type === i.Const) {
+      const c = this._lexer.ahead(1);
+      if (c.type === i.Identifier) {
+        const s = this._lexer.ahead(2);
+        if (s.type === i.In)
+          return this.parseForInOfStatement(e, "const", c.text, "ForInS");
+        if (s.type === i.Of)
+          return this.parseForInOfStatement(e, "const", c.text, "ForOfS");
+      }
+    }
+    let t;
+    if (r = this._lexer.peek(), r.type === i.Semicolon)
+      this._lexer.get();
+    else if (r.type === i.Let) {
+      const c = this.parseLetStatement();
+      if (c === null)
+        return null;
+      if (t = c, t.declarations.some((s) => !s.expression))
+        return this.reportError("W011"), null;
+      this.expectToken(i.Semicolon);
+    } else if (j[r.type].expressionStart) {
+      const c = this.parseExpressionStatement();
+      if (c === null)
+        return null;
+      t = c, this.expectToken(i.Semicolon);
+    }
+    let l;
+    if (r = this._lexer.peek(), r.type === i.Semicolon)
+      this._lexer.get();
+    else {
+      if (l = this.getExpression(), l === null)
+        return null;
+      this.expectToken(i.Semicolon);
+    }
+    let a;
+    if (r = this._lexer.peek(), r.type !== i.RParent && (a = this.getExpression(), a === null))
+      return null;
+    this.expectToken(i.RParent, "W006");
+    const o = this.parseStatement();
+    return o ? this.createStatementNode(
+      "ForS",
+      {
+        init: t,
+        condition: l,
+        update: a,
+        body: o
+      },
+      e,
+      o.endToken
+    ) : null;
+  }
+  /**
+   * forInOfStatement
+   *   : "for" "(" [ "let" | "const" ] identifier ( "in" | "of" ) expression? ")" statement
+   *   | forInOfStatement
+   *   ;
+   *
+   * @param startToken Statement start token
+   * @param varBinding Variable binding of the for..in/of statement
+   * @param id ID name
+   * @param type Is it a for..in or a for..of?
+   */
+  parseForInOfStatement(e, r, t, l) {
+    if (r !== "none") {
+      if (t.startsWith("$"))
+        return this.reportError("W031"), null;
+      this._lexer.get();
+    }
+    this._lexer.get(), this._lexer.get();
+    const a = this.getExpression(!0);
+    this.expectToken(i.RParent, "W006");
+    const o = this.parseStatement();
+    return o ? l === "ForInS" ? this.createStatementNode(
+      "ForInS",
+      {
+        varBinding: r,
+        id: t,
+        expression: a,
+        body: o
+      },
+      e,
+      o.endToken
+    ) : this.createStatementNode(
+      "ForOfS",
+      {
+        varBinding: r,
+        id: t,
+        expression: a,
+        body: o
+      },
+      e,
+      o.endToken
+    ) : null;
+  }
+  /**
+   * Parses a throw statement
+   *
+   * throwStatement
+   *   : "throw" expression
+   *   ;
+   */
+  parseThrowStatement() {
+    const e = this._lexer.peek();
+    this._lexer.get();
+    let r;
+    return r = this.getExpression(), r === null ? null : this.createStatementNode(
+      "ThrowS",
+      {
+        expression: r
+      },
+      e,
+      r.endToken
+    );
+  }
+  /**
+   * Parses a try..catch..finally statement
+   *
+   * tryStatement
+   *   : "try" blockStatement catchClause finallyClause?
+   *   | "try" blockStatement catchClause? finallyClause
+   *   ;
+   *
+   * catchClause
+   *   : "catch" [ "(" identifier ") ]? blockStatement
+   *   ;
+   *
+   * finallyClause
+   *   : "finally" blockStatement
+   */
+  parseTryStatement() {
+    const e = this._lexer.peek();
+    let r = this._lexer.get();
+    const t = this, l = D();
+    let a, o, c, s = this._lexer.peek();
+    if (s.type === i.Catch) {
+      if (this._lexer.get(), s = this._lexer.peek(), s.type === i.LParent) {
+        if (this._lexer.get(), s = this._lexer.peek(), s.type !== i.Identifier)
+          return this.reportError("W003", s), null;
+        o = s.text, this._lexer.get(), this.expectToken(i.RParent, "W006");
+      }
+      a = D(), r = a.endToken, this._lexer.peek().type === i.Finally && (this._lexer.get(), c = D(), r = c.endToken);
+    } else if (s.type === i.Finally)
+      this._lexer.get(), c = D(), r = c.endToken;
+    else
+      return this.reportError("W013", s), null;
+    return this.createStatementNode(
+      "TryS",
+      {
+        tryBlock: l,
+        catchBlock: a,
+        catchVariable: o,
+        finallyBlock: c
+      },
+      e,
+      r
+    );
+    function D() {
+      const L = t._lexer.peek();
+      return L.type !== i.LBrace ? (t.reportError("W012", L), null) : t.parseBlockStatement();
+    }
+  }
+  /**
+   * Parses a switch statement
+   *
+   * switchStatement
+   *   : "switch" "(" expression ")" "{" caseClauses "}"
+   *   ;
+   *
+   * caseClauses
+   *   : "case" expression ":" statement*
+   *   | "default" ":" statement*
+   *   ;
+   */
+  parseSwitchStatement() {
+    const e = this._lexer.get();
+    this.expectToken(i.LParent, "W014");
+    const r = this.getExpression();
+    if (!r) return null;
+    this.expectToken(i.RParent, "W006"), this.expectToken(i.LBrace, "W012");
+    const t = [];
+    let l = !1;
+    for (; ; ) {
+      let o = this._lexer.peek(), c;
+      if (o.type === i.Case) {
+        if (this._lexer.get(), c = this.getExpression(), !c) return null;
+      } else if (o.type === i.Default) {
+        if (l)
+          return this.reportError("W016"), null;
+        l = !0, this._lexer.get();
+      } else {
+        if (o.type === i.RBrace)
+          break;
+        return this.reportError("W015"), null;
+      }
+      this.expectToken(i.Colon, "W008");
+      let s = [], D = !1;
+      for (; !D; )
+        switch (this._lexer.peek().type) {
+          case i.Case:
+          case i.Default:
+          case i.RBrace:
+            D = !0;
+            break;
+          default:
+            const u = this.parseStatement();
+            if (u === null) {
+              D = !0;
+              break;
+            }
+            s.push(u), u.type !== "EmptyS" && this.skipToken(i.Semicolon);
+        }
+      t.push(
+        this.createNode(
+          "SwitchC",
+          {
+            caseExpression: c,
+            statements: s
+          },
+          e
+        )
+      );
+    }
+    const a = this._lexer.peek();
+    return this.expectToken(i.RBrace, "W004"), this.createStatementNode(
+      "SwitchS",
+      {
+        expression: r,
+        cases: t
+      },
+      e,
+      a
+    );
+  }
+  /**
+   * Parses a function declaration
+   *
+   * functionDeclaration
+   *   : "function" identifier "(" [parameterList] ")" blockStatement
+   *   ;
+   */
+  parseFunctionDeclaration(e = !1) {
+    const r = this._lexer.get();
+    let t;
+    const l = this._lexer.peek();
+    if (e) {
+      if (l.type !== i.LParent) {
+        if (l.type !== i.Identifier)
+          return this.reportError("W003", l), null;
+        t = l.text, this._lexer.get();
+      }
+    } else {
+      if (l.type !== i.Identifier)
+        return this.reportError("W003", l), null;
+      t = l.text, this._lexer.get();
+    }
+    const a = this._lexer.peek();
+    if (a.type !== i.LParent)
+      return this.reportError("W014", a), null;
+    const o = this.getExpression(!0);
+    let c;
+    const s = [];
+    switch (o.type) {
+      case "NoArgE":
+        c = !0;
+        break;
+      case "IdE":
+        c = (o.parenthesized ?? 0) <= 1, s.push(o);
+        break;
+      case "SeqE":
+        c = o.parenthesized === 1;
+        let L = !1;
+        if (c)
+          for (const u of o.expressions) {
+            if (L) {
+              c = !1;
+              break;
+            }
+            switch (u.type) {
+              case "IdE":
+                c = !u.parenthesized, s.push(u);
+                break;
+              case "OLitE": {
+                if (c = !u.parenthesized, c) {
+                  const O = this.convertToObjectDestructure(u);
+                  O && s.push(O);
+                }
+                break;
+              }
+              case "ALitE": {
+                if (c = !u.parenthesized, c) {
+                  const O = this.convertToArrayDestructure(u);
+                  O && s.push(O);
+                }
+                break;
+              }
+              case "SpreadE": {
+                if (L = !0, u.operand.type !== "IdE") {
+                  c = !1;
+                  break;
+                }
+                s.push(u);
+                break;
+              }
+              default:
+                c = !1;
+                break;
+            }
+          }
+        break;
+      case "OLitE":
+        if (c = o.parenthesized === 1, c) {
+          const u = this.convertToObjectDestructure(o);
+          u && s.push(u);
+        }
+        break;
+      case "ALitE":
+        if (c = o.parenthesized === 1, c) {
+          const u = this.convertToArrayDestructure(o);
+          u && s.push(u);
+        }
+        break;
+      case "SpreadE":
+        if (o.operand.type !== "IdE") {
+          c = !1;
+          break;
+        }
+        c = !0, s.push(o);
+        break;
+      default:
+        c = !1;
+    }
+    if (!c)
+      return this.reportError("W010", r), null;
+    if (this._lexer.peek().type !== i.LBrace)
+      return this.reportError("W012", this._lexer.peek()), null;
+    const D = this.parseBlockStatement();
+    return D ? this.createStatementNode(
+      "FuncD",
+      {
+        name: t,
+        args: s,
+        statement: D
+      },
+      r,
+      D.endToken
+    ) : null;
+  }
+  /**
+   * Parses an export statement
+   *
+   * exportStatement
+   *   : "export" (constStatement | functionDeclaration)
+   *   ;
+   */
+  parseExport() {
+    this._lexer.get();
+    const e = this._lexer.peek();
+    if (e.type === i.Const) {
+      if (this._statementLevel > 1)
+        return this.reportError("W030", e), null;
+      const r = this.parseConstStatement();
+      return r === null ? null : { ...r, isExported: !0 };
+    } else if (e.type === i.Function) {
+      if (this._statementLevel > 1)
+        return this.reportError("W030", e), null;
+      const r = this.parseFunctionDeclaration();
+      return r === null ? null : { ...r, isExported: !0 };
+    }
+    return this.reportError("W024", e), null;
+  }
+  /**
+   * Parse an import declaration
+   *
+   * importDeclaration
+   *   : "import" "{" importItem ("," importItem)* [ "," ] "}" from module
+   *   ;
+   *
+   * importItem
+   *   : identifier [ "as" identifier ]
+   *   ;
+   */
+  parseImport() {
+    const e = this._lexer.get();
+    this.expectToken(i.LBrace, "W012");
+    const r = {};
+    let t = this._lexer.peek();
+    for (; t.type !== i.RBrace; ) {
+      if (t.type !== i.Identifier)
+        return this.reportError("W003", t), null;
+      const o = t.text;
+      if (this._lexer.get(), t = this._lexer.peek(), t.type === i.As) {
+        if (this._lexer.get(), t = this._lexer.peek(), t.type !== i.Identifier)
+          return this.reportError("W003", t), null;
+        if (r[t.text])
+          return this.reportError("W019", t, t.text), null;
+        r[t.text] = o, this._lexer.get();
+      } else {
+        if (r[o])
+          return this.reportError("W019", t, o), null;
+        r[o] = o;
+      }
+      t = this._lexer.peek(), t.type === i.Comma && (this._lexer.get(), t = this._lexer.peek());
+    }
+    this._lexer.get(), this.expectToken(i.From, "W025");
+    const l = this._lexer.peek();
+    if (l.type !== i.StringLiteral)
+      return this.reportError("W026", l), null;
+    this._lexer.get();
+    const a = this.parseStringLiteral(l);
+    return this.createStatementNode(
+      "ImportD",
+      {
+        imports: r,
+        moduleFile: a.value
+      },
+      e,
+      l
+    );
+  }
+  // ==========================================================================
+  // Expression parsing
+  /**
+   * Parses an expression:
+   *
+   * expr
+   *   : sequenceExpr
+   *   ;
+   */
+  parseExpr(e = !0) {
+    return e ? this.parseSequenceExpression() : this.parseCondOrSpreadOrAsgnOrArrowExpr();
+  }
+  /**
+   * sequenceExpr
+   *   : conditionalExpr ( "," conditionalExpr )?
+   */
+  parseSequenceExpression() {
+    const e = this._lexer.peek();
+    let r = e, t = this.parseCondOrSpreadOrAsgnOrArrowExpr();
+    if (!t)
+      return null;
+    r = t.endToken;
+    const l = [];
+    let a = !1;
+    if (this._lexer.peek().type === i.Comma)
+      for (l.push(t); this.skipToken(i.Comma); )
+        if (this._lexer.peek().type === i.Comma)
+          a = !0, r = this._lexer.peek(), l.push(
+            this.createExpressionNode("NoArgE", {}, r, r)
+          );
+        else {
+          const o = this.parseCondOrSpreadOrAsgnOrArrowExpr();
+          if (!o)
+            break;
+          r = o.endToken, l.push(o);
+        }
+    return l.length && (t = this.createExpressionNode(
+      "SeqE",
+      {
+        expressions: l,
+        loose: a
+      },
+      e,
+      r
+    ), a && (t = this.convertToArrayDestructure(t))), t;
+  }
+  /**
+   * conditionalOrSpreadOrAsgnOrArrowExpr
+   *   : nullCoalescingExpr ( "?" expr ":" expr )?
+   *   | "..." nullCoalescingExpr
+   *   | identifier "=" expr
+   *   ;
+   */
+  parseCondOrSpreadOrAsgnOrArrowExpr() {
+    const e = this._lexer.peek();
+    if (e.type === i.Spread) {
+      this._lexer.get();
+      const l = this.parseNullCoalescingExpr();
+      return l ? this.createExpressionNode(
+        "SpreadE",
+        {
+          operand: l
+        },
+        e,
+        l.endToken
+      ) : null;
+    }
+    if (e.type === i.Function) {
+      const l = this.parseFunctionDeclaration(!0);
+      return l ? this.createExpressionNode(
+        "ArrowE",
+        {
+          name: l.name,
+          args: l.args,
+          statement: l.statement
+        },
+        e,
+        l.endToken
+      ) : null;
+    }
+    const r = this.parseNullCoalescingExpr();
+    if (!r)
+      return null;
+    const t = this._lexer.peek();
+    if (t.type === i.Arrow)
+      return this.parseArrowExpression(e, r);
+    if (t.type === i.QuestionMark) {
+      this._lexer.get();
+      const l = this.getExpression(!1);
+      this.expectToken(i.Colon);
+      const a = this.getExpression(!1);
+      return this.createExpressionNode(
+        "CondE",
+        {
+          condition: r,
+          consequent: l,
+          alternate: a
+        },
+        e,
+        a.endToken
+      );
+    }
+    if (j[t.type].isAssignment) {
+      this._lexer.get();
+      const l = this.getExpression();
+      return l ? this.createExpressionNode(
+        "AsgnE",
+        {
+          leftValue: r,
+          operator: t.text,
+          operand: l
+        },
+        e,
+        l.endToken
+      ) : null;
+    }
+    return r;
+  }
+  /**
+   * Parses an arrow expression
+   * @param start Start token
+   * @param left Expression to the left from the arrow
+   */
+  parseArrowExpression(e, r) {
+    let t;
+    const l = [];
+    switch (r.type) {
+      case "NoArgE":
+        t = !0;
+        break;
+      case "IdE":
+        t = (r.parenthesized ?? 0) <= 1, l.push(r);
+        break;
+      case "SeqE":
+        t = r.parenthesized === 1;
+        let o = !1;
+        if (t)
+          for (const c of r.expressions) {
+            if (o) {
+              t = !1;
+              break;
+            }
+            switch (c.type) {
+              case "IdE":
+                t = !c.parenthesized, l.push(c);
+                break;
+              case "OLitE": {
+                if (t = !c.parenthesized, t) {
+                  const s = this.convertToObjectDestructure(c);
+                  s && l.push(s);
+                }
+                break;
+              }
+              case "ALitE": {
+                if (t = !c.parenthesized, t) {
+                  const s = this.convertToArrayDestructure(c);
+                  s && l.push(s);
+                }
+                break;
+              }
+              case "SpreadE": {
+                if (o = !0, c.operand.type !== "IdE") {
+                  t = !1;
+                  break;
+                }
+                l.push(c);
+                break;
+              }
+              default:
+                t = !1;
+                break;
+            }
+          }
+        break;
+      case "OLitE":
+        if (t = r.parenthesized === 1, t) {
+          const c = this.convertToObjectDestructure(r);
+          c && l.push(c);
+        }
+        break;
+      case "ALitE":
+        if (t = r.parenthesized === 1, t) {
+          const c = this.convertToArrayDestructure(r);
+          c && l.push(c);
+        }
+        break;
+      case "SpreadE":
+        t = r.operand.type === "IdE", t && l.push(r);
+        break;
+      default:
+        t = !1;
+    }
+    if (!t)
+      return this.reportError("W010", e), null;
+    this._lexer.get();
+    const a = this.parseStatement(!1);
+    return a ? this.createExpressionNode(
+      "ArrowE",
+      {
+        args: l,
+        statement: a
+      },
+      e,
+      a.endToken
+    ) : null;
+  }
+  /**
+   * nullCoalescingExpr
+   *   : logicalOrExpr ( "??" logicalOrExpr )?
+   *   ;
+   */
+  parseNullCoalescingExpr() {
+    const e = this._lexer.peek();
+    let r = this.parseLogicalOrExpr();
+    if (!r)
+      return null;
+    for (; this.skipToken(i.NullCoalesce); ) {
+      const t = this.parseLogicalOrExpr();
+      if (!t)
+        return this.reportError("W001"), null;
+      let l = t.endToken;
+      r = this.createExpressionNode(
+        "BinaryE",
+        {
+          operator: "??",
+          left: r,
+          right: t
+        },
+        e,
+        l
+      );
+    }
+    return r;
+  }
+  /**
+   * logicalOrExpr
+   *   : logicalAndExpr ( "||" logicalAndExpr )?
+   *   ;
+   */
+  parseLogicalOrExpr() {
+    const e = this._lexer.peek();
+    let r = this.parseLogicalAndExpr();
+    if (!r)
+      return null;
+    for (; this.skipToken(i.LogicalOr); ) {
+      const t = this.parseLogicalAndExpr();
+      if (!t)
+        return this.reportError("W001"), null;
+      let l = t.endToken;
+      r = this.createExpressionNode(
+        "BinaryE",
+        {
+          operator: "||",
+          left: r,
+          right: t
+        },
+        e,
+        l
+      );
+    }
+    return r;
+  }
+  /**
+   * logicalAndExpr
+   *   : bitwiseOrExpr ( "&&" bitwiseOrExpr )?
+   *   ;
+   */
+  parseLogicalAndExpr() {
+    const e = this._lexer.peek();
+    let r = this.parseBitwiseOrExpr();
+    if (!r)
+      return null;
+    for (; this.skipToken(i.LogicalAnd); ) {
+      const t = this.parseBitwiseOrExpr();
+      if (!t)
+        return this.reportError("W001"), null;
+      let l = t.endToken;
+      r = this.createExpressionNode(
+        "BinaryE",
+        {
+          operator: "&&",
+          left: r,
+          right: t
+        },
+        e,
+        l
+      );
+    }
+    return r;
+  }
+  /**
+   * bitwiseOrExpr
+   *   : bitwiseXorExpr ( "|" bitwiseXorExpr )?
+   *   ;
+   */
+  parseBitwiseOrExpr() {
+    const e = this._lexer.peek();
+    let r = this.parseBitwiseXorExpr();
+    if (!r)
+      return null;
+    for (; this.skipToken(i.BitwiseOr); ) {
+      const t = this.parseBitwiseXorExpr();
+      if (!t)
+        return this.reportError("W001"), null;
+      let l = t.endToken;
+      r = this.createExpressionNode(
+        "BinaryE",
+        {
+          operator: "|",
+          left: r,
+          right: t
+        },
+        e,
+        l
+      );
+    }
+    return r;
+  }
+  /**
+   * bitwiseXorExpr
+   *   : bitwiseAndExpr ( "^" bitwiseAndExpr )?
+   *   ;
+   */
+  parseBitwiseXorExpr() {
+    const e = this._lexer.peek();
+    let r = this.parseBitwiseAndExpr();
+    if (!r)
+      return null;
+    for (; this.skipToken(i.BitwiseXor); ) {
+      const t = this.parseBitwiseAndExpr();
+      if (!t)
+        return this.reportError("W001"), null;
+      let l = t.endToken;
+      r = this.createExpressionNode(
+        "BinaryE",
+        {
+          operator: "^",
+          left: r,
+          right: t
+        },
+        e,
+        l
+      );
+    }
+    return r;
+  }
+  /**
+   * bitwiseAndExpr
+   *   : equExpr ( "&" equExpr )?
+   *   ;
+   */
+  parseBitwiseAndExpr() {
+    const e = this._lexer.peek();
+    let r = this.parseEquExpr();
+    if (!r)
+      return null;
+    for (; this.skipToken(i.BitwiseAnd); ) {
+      const t = this.parseEquExpr();
+      if (!t)
+        return this.reportError("W001"), null;
+      let l = t.endToken;
+      r = this.createExpressionNode(
+        "BinaryE",
+        {
+          operator: "&",
+          left: r,
+          right: t
+        },
+        e,
+        l
+      );
+    }
+    return r;
+  }
+  /**
+   * equExpr
+   *   : relOrInExpr ( ( "==" | "!=" | "===" | "!==" ) relOrInExpr )?
+   *   ;
+   */
+  parseEquExpr() {
+    const e = this._lexer.peek();
+    let r = this.parseRelOrInExpr();
+    if (!r)
+      return null;
+    let t;
+    for (; t = this.skipTokens(
+      i.Equal,
+      i.StrictEqual,
+      i.NotEqual,
+      i.StrictNotEqual
+    ); ) {
+      const l = this.parseRelOrInExpr();
+      if (!l)
+        return this.reportError("W001"), null;
+      let a = l.endToken;
+      r = this.createExpressionNode(
+        "BinaryE",
+        {
+          type: "BinaryE",
+          operator: t.text,
+          left: r,
+          right: l
+        },
+        e,
+        a
+      );
+    }
+    return r;
+  }
+  /**
+   * relOrInExpr
+   *   : shiftExpr ( ( "<" | "<=" | ">" | ">=", "in" ) shiftExpr )?
+   *   ;
+   */
+  parseRelOrInExpr() {
+    const e = this._lexer.peek();
+    let r = this.parseShiftExpr();
+    if (!r)
+      return null;
+    let t;
+    for (; t = this.skipTokens(
+      i.LessThan,
+      i.LessThanOrEqual,
+      i.GreaterThan,
+      i.GreaterThanOrEqual,
+      i.In
+    ); ) {
+      const l = this.parseShiftExpr();
+      if (!l)
+        return this.reportError("W001"), null;
+      let a = l.endToken;
+      r = this.createExpressionNode(
+        "BinaryE",
+        {
+          operator: t.text,
+          left: r,
+          right: l
+        },
+        e,
+        a
+      );
+    }
+    return r;
+  }
+  /**
+   * shiftExpr
+   *   : addExpr ( ( "<<" | ">>" | ">>>" ) addExpr )?
+   *   ;
+   */
+  parseShiftExpr() {
+    const e = this._lexer.peek();
+    let r = this.parseAddExpr();
+    if (!r)
+      return null;
+    let t;
+    for (; t = this.skipTokens(
+      i.ShiftLeft,
+      i.ShiftRight,
+      i.SignedShiftRight
+    ); ) {
+      const l = this.parseAddExpr();
+      if (!l)
+        return this.reportError("W001"), null;
+      let a = l.endToken;
+      r = this.createExpressionNode(
+        "BinaryE",
+        {
+          operator: t.text,
+          left: r,
+          right: l
+        },
+        e,
+        a
+      );
+    }
+    return r;
+  }
+  /**
+   * addExpr
+   *   : multExpr ( ( "+" | "-" ) multExpr )?
+   *   ;
+   */
+  parseAddExpr() {
+    const e = this._lexer.peek();
+    let r = this.parseMultExpr();
+    if (!r)
+      return null;
+    let t;
+    for (; t = this.skipTokens(i.Plus, i.Minus); ) {
+      const l = this.parseMultExpr();
+      if (!l)
+        return this.reportError("W001"), null;
+      let a = l.endToken;
+      r = this.createExpressionNode(
+        "BinaryE",
+        {
+          operator: t.text,
+          left: r,
+          right: l
+        },
+        e,
+        a
+      );
+    }
+    return r;
+  }
+  /**
+   * multExpr
+   *   : exponentialExpr ( ( "*" | "/" | "%") exponentialExpr )?
+   *   ;
+   */
+  parseMultExpr() {
+    const e = this._lexer.peek();
+    let r = this.parseExponentialExpr();
+    if (!r)
+      return null;
+    let t;
+    for (; t = this.skipTokens(i.Multiply, i.Divide, i.Remainder); ) {
+      const l = this.parseExponentialExpr();
+      if (!l)
+        return this.reportError("W001"), null;
+      let a = l.endToken;
+      r = this.createExpressionNode(
+        "BinaryE",
+        {
+          operator: t.text,
+          left: r,
+          right: l
+        },
+        e,
+        a
+      );
+    }
+    return r;
+  }
+  /**
+   * exponentialExpr
+   *   : unaryExpr ( "**" unaryExpr )?
+   *   ;
+   */
+  parseExponentialExpr() {
+    const e = this._lexer.peek();
+    let r = this.parseUnaryOrPrefixExpr();
+    if (!r)
+      return null;
+    let t, l = 0;
+    for (; t = this.skipToken(i.Exponent); ) {
+      let a = this.parseUnaryOrPrefixExpr();
+      if (!a)
+        return this.reportError("W001"), null;
+      let o = a.endToken;
+      if (l === 0)
+        r = this.createExpressionNode(
+          "BinaryE",
+          {
+            operator: t.text,
+            left: r,
+            right: a
+          },
+          e,
+          o
+        );
+      else {
+        const c = r;
+        r = this.createExpressionNode(
+          "BinaryE",
+          {
+            operator: t.text,
+            left: c.left,
+            right: {
+              type: "BinaryE",
+              operator: t.text,
+              left: c.right,
+              right: a
+            }
+          },
+          e,
+          o
+        );
+      }
+      l++;
+    }
+    return r;
+  }
+  /**
+   * unaryExpr
+   *   : ( "typeof" | "delete" | "+" | "-" | "~" | "!" ) memberOrInvocationExpr
+   *   | memberOrInvocationExpr
+   *   ;
+   */
+  parseUnaryOrPrefixExpr() {
+    const e = this._lexer.peek();
+    if (j[e.type].canBeUnary) {
+      this._lexer.get();
+      const r = this.parseUnaryOrPrefixExpr();
+      return r ? this.createExpressionNode(
+        "UnaryE",
+        {
+          operator: e.text,
+          operand: r
+        },
+        e,
+        r.endToken
+      ) : null;
+    }
+    if (e.type === i.IncOp || e.type === i.DecOp) {
+      this._lexer.get();
+      const r = this.parseMemberOrInvocationExpr();
+      return r ? this.createExpressionNode(
+        "PrefE",
+        {
+          operator: e.text,
+          operand: r
+        },
+        e,
+        r.endToken
+      ) : null;
+    }
+    return this.parseMemberOrInvocationExpr();
+  }
+  /**
+   * memberOrInvocationExpr
+   *   : primaryExpr "(" functionArgs ")"
+   *   | primaryExpr "." identifier
+   *   | primaryExpr "?." identifier
+   *   | primaryExpr "[" expr "]"
+   *   ;
+   */
+  parseMemberOrInvocationExpr() {
+    const e = this._lexer.peek();
+    let r = this.parsePrimaryExpr();
+    if (!r)
+      return null;
+    let t = !1;
+    do {
+      const a = this._lexer.peek();
+      switch (a.type) {
+        case i.LParent: {
+          this._lexer.get();
+          let L = [];
+          if (this._lexer.peek().type !== i.RParent) {
+            const O = this.parseExpr();
+            if (!O)
+              return this.reportError("W001"), null;
+            L = O.type === "SeqE" ? O.expressions : [O];
+          }
+          const u = this._lexer.peek();
+          this.expectToken(i.RParent, "W006"), r = this.createExpressionNode(
+            "InvokeE",
+            {
+              object: r,
+              arguments: L
+            },
+            e,
+            u
+          );
+          break;
+        }
+        case i.Dot:
+        case i.OptionalChaining:
+          this._lexer.get();
+          const o = this._lexer.get();
+          if (!j[o.type].keywordLike)
+            return this.reportError("W003"), null;
+          r = this.createExpressionNode(
+            "MembE",
+            {
+              object: r,
+              member: o.text,
+              isOptional: a.type === i.OptionalChaining
+            },
+            e,
+            o
+          );
+          break;
+        case i.LSquare:
+          this._lexer.get();
+          const s = this.getExpression();
+          if (!s)
+            return null;
+          const D = this._lexer.peek();
+          this.expectToken(i.RSquare, "W005"), r = this.createExpressionNode(
+            "CMembE",
+            {
+              object: r,
+              member: s
+            },
+            e,
+            D
+          );
+          break;
+        default:
+          t = !0;
+          break;
+      }
+    } while (!t);
+    const l = this._lexer.peek();
+    return l.type === i.IncOp || l.type === i.DecOp ? (this._lexer.get(), this.createExpressionNode(
+      "PostfE",
+      {
+        operator: l.text,
+        operand: r
+      },
+      e,
+      l
+    )) : r;
+  }
+  /**
+   * primaryExpr
+   *   : literal
+   *   | identifier
+   *   | "::" identifier
+   *   | "$item"
+   *   | "(" expr ")"
+   *   ;
+   */
+  parsePrimaryExpr() {
+    const e = this._lexer.peek();
+    switch (e.type) {
+      case i.LParent:
+        if (this._lexer.get(), this._lexer.peek().type === i.RParent) {
+          const l = this._lexer.get();
+          return this.createExpressionNode("NoArgE", {}, e, l);
+        }
+        const r = this.parseExpr();
+        if (!r)
+          return null;
+        const t = this._lexer.peek();
+        return this.expectToken(i.RParent, "W006"), r.parenthesized ?? (r.parenthesized = 0), r.parenthesized++, r.startToken = e, r.startPosition = e.location.startPosition, r.startLine = e.location.startLine, r.startColumn = e.location.startColumn, r.endToken = t, r.endPosition = t.location.endPosition, r.endLine = t.location.endLine, r.endColumn = t.location.endColumn, r.source = this.getSource(e, t), r;
+      case i.Identifier: {
+        const l = this._lexer.get();
+        return this.createExpressionNode(
+          "IdE",
+          {
+            name: l.text
+          },
+          l,
+          l
+        );
+      }
+      case i.Global: {
+        this._lexer.get();
+        const l = this._lexer.get();
+        return l.type !== i.Identifier ? (this.reportError("W003"), null) : this.createExpressionNode(
+          "IdE",
+          {
+            name: l.text,
+            isGlobal: !0
+          },
+          l,
+          l
+        );
+      }
+      case i.Backtick:
+        return this.parseTemplateLiteral();
+      case i.False:
+      case i.True:
+        return this._lexer.get(), this.createExpressionNode(
+          "LitE",
+          {
+            value: e.type === i.True
+          },
+          e,
+          e
+        );
+      case i.BinaryLiteral:
+        return this._lexer.get(), this.parseBinaryLiteral(e);
+      case i.DecimalLiteral:
+        return this._lexer.get(), this.parseDecimalLiteral(e);
+      case i.HexadecimalLiteral:
+        return this._lexer.get(), this.parseHexadecimalLiteral(e);
+      case i.RealLiteral:
+        return this._lexer.get(), this.parseRealLiteral(e);
+      case i.StringLiteral:
+        return this._lexer.get(), this.parseStringLiteral(e);
+      case i.Infinity:
+        return this._lexer.get(), this.createExpressionNode(
+          "LitE",
+          {
+            value: 1 / 0
+          },
+          e,
+          e
+        );
+      case i.NaN:
+        return this._lexer.get(), this.createExpressionNode(
+          "LitE",
+          {
+            value: NaN
+          },
+          e,
+          e
+        );
+      case i.Null:
+        return this._lexer.get(), this.createExpressionNode(
+          "LitE",
+          {
+            value: null
+          },
+          e,
+          e
+        );
+      case i.Undefined:
+        return this._lexer.get(), this.createExpressionNode(
+          "LitE",
+          {
+            value: void 0
+          },
+          e,
+          e
+        );
+      case i.LSquare:
+        return this.parseArrayLiteral();
+      case i.LBrace:
+        return this.parseObjectLiteral();
+      case i.Divide:
+        return this.parseRegExpLiteral();
+    }
+    return null;
+  }
+  parseTemplateLiteral() {
+    const e = this._lexer.get();
+    this._lexer.setStartingPhaseToTemplateLiteral();
+    const r = [];
+    e: for (; ; ) {
+      let l = this._lexer.peek();
+      switch (l.type) {
+        case i.StringLiteral:
+          this._lexer.get();
+          const a = this.parseStringLiteral(l, !1);
+          r.push(a);
+          break;
+        case i.DollarLBrace:
+          this._lexer.get();
+          const o = this.parseExpr();
+          r.push(o), this.expectToken(i.RBrace, "W004"), this._lexer.setStartingPhaseToTemplateLiteral();
+          break;
+        case i.Backtick:
+          break e;
+        default:
+          this.reportError("W004");
+      }
+    }
+    const t = this._lexer.get();
+    return this.createExpressionNode(
+      "TempLitE",
+      { segments: r },
+      e,
+      t
+    );
+  }
+  /**
+   * Parses an array literal
+   */
+  parseArrayLiteral() {
+    const e = this._lexer.get();
+    let r = [];
+    if (this._lexer.peek().type !== i.RSquare) {
+      const l = this.getExpression();
+      l && (r = l.type === "SeqE" ? l.expressions : [l]);
+    }
+    const t = this._lexer.peek();
+    return this.expectToken(i.RSquare), this.createExpressionNode(
+      "ALitE",
+      {
+        items: r
+      },
+      e,
+      t
+    );
+  }
+  /**
+   * Parses an object literal
+   */
+  parseObjectLiteral() {
+    const e = this._lexer.get();
+    let r = [];
+    if (this._lexer.peek().type !== i.RBrace)
+      for (; this._lexer.peek().type !== i.RBrace; ) {
+        const l = this._lexer.peek(), a = j[l.type];
+        let o;
+        if (a.expressionStart)
+          if (l.type === i.LSquare) {
+            if (this._lexer.get(), o = this.getExpression(), !o)
+              return null;
+            this.expectToken(i.RSquare, "W005"), o = this.createExpressionNode(
+              "SeqE",
+              {
+                expressions: [o]
+              },
+              e
+            );
+          } else if (a.isPropLiteral) {
+            if (o = this.getExpression(!1), !o)
+              return null;
+            if (o.type !== "IdE" && o.type !== "LitE" && o.type !== "SpreadE")
+              return this.reportError("W007"), null;
+          } else
+            return this.reportError("W007"), null;
+        else if (a.keywordLike)
+          o = {
+            type: "IdE",
+            name: l.text,
+            value: void 0,
+            startPosition: l.location.startPosition,
+            startLine: l.location.startLine,
+            startColumn: l.location.startColumn,
+            endPosition: l.location.endPosition,
+            endLine: l.location.endLine,
+            endColumn: l.location.endColumn,
+            source: l.text,
+            startToken: l,
+            endToken: l
+          }, this._lexer.get();
+        else
+          return this.reportError("W001"), null;
+        const c = o.type;
+        if (c === "SpreadE")
+          r.push(o);
+        else {
+          if (c === "LitE") {
+            const L = o.value;
+            if (typeof L != "number" && typeof L != "string")
+              return this.expectToken(i.RBrace, "W007"), null;
+          }
+          let D = null;
+          if (c === "IdE") {
+            const L = this._lexer.peek();
+            (L.type === i.Comma || L.type === i.RBrace) && (D = { ...o });
+          }
+          if (!D && (this.expectToken(i.Colon, "W008"), D = this.getExpression(!1), !D))
+            return null;
+          r.push([o, D]);
+        }
+        const s = this._lexer.peek().type;
+        if (s === i.Comma)
+          this._lexer.get();
+        else if (s !== i.RBrace)
+          break;
+      }
+    const t = this._lexer.peek();
+    return this.expectToken(i.RBrace, "W004"), this.createExpressionNode(
+      "OLitE",
+      {
+        props: r
+      },
+      e,
+      t
+    );
+  }
+  parseRegExpLiteral() {
+    const e = this._lexer.peek(), r = this._lexer.getRegEx();
+    return r.success ? this.createExpressionNode(
+      "LitE",
+      {
+        value: new RegExp(r.pattern, r.flags)
+      },
+      e,
+      this._lexer.peek()
+    ) : (this.reportError("W002", e, r.pattern ?? ""), null);
+  }
+  /**
+   * Gets an expression
+   */
+  getExpression(e = !0) {
+    const r = this.parseExpr(e);
+    return r || (this.reportError("W001"), null);
+  }
+  // ==========================================================================
+  // Helpers
+  /**
+   * Tests the type of the next token
+   * @param type Expected token type
+   * @param errorCode Error to raise if the next token is not expected
+   * @param allowEof Allow an EOF instead of the expected token?
+   */
+  expectToken(e, r, t) {
+    const l = this._lexer.peek();
+    return l.type === e || t && l.type === i.Eof ? this._lexer.get() : (this.reportError(r ?? "W002", l, l.text), null);
+  }
+  /**
+   * Skips the next token if the type is the specified one
+   * @param type Token type to check
+   */
+  skipToken(e) {
+    const r = this._lexer.peek();
+    return r.type === e ? (this._lexer.get(), r) : null;
+  }
+  /**
+   * Skips the next token if the type is the specified one
+   * @param types Token types to check
+   */
+  skipTokens(...e) {
+    const r = this._lexer.peek();
+    for (const t of e)
+      if (r.type === t)
+        return this._lexer.get(), r;
+    return null;
+  }
+  /**
+   * Reports the specified error
+   * @param errorCode Error code
+   * @param token Token that represents the error's position
+   * @param options Error message options
+   */
+  reportError(e, r, ...t) {
+    let l = ie[e] ?? "Unkonwn error";
+    throw t && t.forEach(
+      (o, c) => l = a(l, `{${c}}`, t[c].toString())
+    ), r || (r = this._lexer.peek()), this._parseErrors.push({
+      code: e,
+      text: l,
+      line: r.location.startLine,
+      column: r.location.startColumn,
+      position: r.location.startPosition
+    }), new Ge(l, e);
+    function a(o, c, s) {
+      do
+        o = o.replace(c, s);
+      while (o.includes(c));
+      return o;
+    }
+  }
+  /**
+   * Creates an expression node
+   * @param type Expression type
+   * @param stump Stump properties
+   * @param startToken The token that starts the expression
+   * @param endToken The token that ends the expression
+   * @param source Expression source code to store to the node
+   */
+  createNode(e, r, t, l, a) {
+    l || (l = this._lexer.peek());
+    const o = t.location.startPosition, c = l.location.startPosition;
+    return Object.assign({}, r, {
+      type: e,
+      startPosition: o,
+      endPosition: c,
+      startLine: t.location.startLine,
+      startColumn: t.location.startColumn,
+      endLine: l.location.endLine,
+      endColumn: l.location.endColumn,
+      source: a ?? this.getSource(t, l)
+    });
+  }
+  /**
+   * Creates an expression node
+   * @param type Expression type
+   * @param stump Stump properties
+   * @param startToken The token that starts the expression
+   * @param endToken The token that ends the expression
+   * @param source Expression source code to store to the node
+   */
+  createExpressionNode(e, r = {}, t, l, a) {
+    l || (l = this._lexer.peek()), t || (t = l);
+    const o = t.location.startPosition, c = l.location.endPosition;
+    return Object.assign({}, r, {
+      type: e,
+      startPosition: o,
+      endPosition: c,
+      startLine: t.location.startLine,
+      startColumn: t.location.startColumn,
+      endLine: l.location.endLine,
+      endColumn: l.location.endColumn,
+      source: a ?? this.getSource(t, l),
+      startToken: t,
+      endToken: l
+    });
+  }
+  /**
+   * Creates a statement node
+   * @param type Statement type
+   * @param stump Stump properties
+   * @param startToken The token that starts the statement
+   * @param endToken The token that ends the statement
+   */
+  createStatementNode(e, r, t, l) {
+    var s, D, L, u, O;
+    const a = (s = t == null ? void 0 : t.location) == null ? void 0 : s.startPosition, o = this._lexer.peek(), c = l ? l.location.endPosition : o.type === i.Eof ? o.location.startPosition + 1 : o.location.startPosition;
+    return Object.assign({}, r, {
+      type: e,
+      startPosition: a,
+      endPosition: c,
+      startLine: (D = t == null ? void 0 : t.location) == null ? void 0 : D.startLine,
+      startColumn: (L = t == null ? void 0 : t.location) == null ? void 0 : L.startColumn,
+      endLine: l ? l.location.endLine : (u = t == null ? void 0 : t.location) == null ? void 0 : u.endLine,
+      endColumn: l ? l.location.endColumn : (O = t == null ? void 0 : t.location) == null ? void 0 : O.endColumn,
+      source: this.source && a !== void 0 && c !== void 0 ? this.source.substring(a, c) : void 0,
+      startToken: t,
+      endToken: l
+    });
+  }
+  /**
+   * Gets the source code for the specified token range
+   * @param start Start token
+   * @param end Optional end token
+   * @returns The source code for the token range
+   */
+  getSource(e, r) {
+    return this.source.substring(
+      e.location.startPosition,
+      r.type === i.Eof ? r.location.startPosition : r.location.endPosition
+    );
+  }
+  /**
+   * Parses a binary literal
+   * @param token Literal token
+   */
+  parseBinaryLiteral(e) {
+    let r;
+    const t = BigInt(e.text.replace(/[_']/g, ""));
+    return t < Number.MIN_SAFE_INTEGER || t > Number.MAX_SAFE_INTEGER ? r = t : r = parseInt(e.text.substring(2).replace(/[_']/g, ""), 2), this.createExpressionNode(
+      "LitE",
+      {
+        value: r
+      },
+      e,
+      e
+    );
+  }
+  /**
+   * Parses a decimal literal
+   * @param token Literal token
+   */
+  parseDecimalLiteral(e) {
+    let r;
+    const t = BigInt(e.text.replace(/[_']/g, ""));
+    return t < Number.MIN_SAFE_INTEGER || t > Number.MAX_SAFE_INTEGER ? r = t : r = parseInt(e.text.replace(/[_']/g, ""), 10), this.createExpressionNode(
+      "LitE",
+      {
+        value: r
+      },
+      e,
+      e
+    );
+  }
+  /**
+   * Parses a hexadecimal literal
+   * @param token Literal token
+   */
+  parseHexadecimalLiteral(e) {
+    let r;
+    const t = BigInt(e.text.replace(/[_']/g, ""));
+    return t < Number.MIN_SAFE_INTEGER || t > Number.MAX_SAFE_INTEGER ? r = t : r = parseInt(e.text.substring(2).replace(/[_']/g, ""), 16), this.createExpressionNode(
+      "LitE",
+      {
+        value: r
+      },
+      e,
+      e
+    );
+  }
+  /**
+   * Parses a real literal
+   * @param token Literal token
+   */
+  parseRealLiteral(e) {
+    let r = parseFloat(e.text.replace(/[_']/g, ""));
+    return this.createExpressionNode(
+      "LitE",
+      {
+        value: r
+      },
+      e,
+      e
+    );
+  }
+  /**
+   * Converts a string token to intrinsic string
+   * @param token Literal token
+   */
+  parseStringLiteral(e, r = !0) {
+    let t = e.text;
+    r && (t = e.text.length < 2 ? "" : t.substring(1, t.length - 1));
+    let l = "", a = 0, o = 0;
+    for (const s of t)
+      switch (a) {
+        case 0:
+          s === "\\" ? a = 1 : l += s;
+          break;
+        case 1:
+          switch (a = 0, s) {
+            case "b":
+              l += "\b";
+              break;
+            case "f":
+              l += "\f";
+              break;
+            case "n":
+              l += `
+`;
+              break;
+            case "r":
+              l += "\r";
+              break;
+            case "t":
+              l += "	";
+              break;
+            case "v":
+              l += "\v";
+              break;
+            case "S":
+              l += " ";
+              break;
+            case "0":
+              l += "\0";
+              break;
+            case "'":
+              l += "'";
+              break;
+            case '"':
+              l += '"';
+              break;
+            case "\\":
+              l += "\\";
+              break;
+            case "x":
+              a = 2;
+              break;
+            case "u":
+              a = 4;
+              break;
+            default:
+              l += s;
+              break;
+          }
+          break;
+        case 2:
+          c(s) ? (o = parseInt(s, 16), a = 3) : (l += "x", a = 0);
+          break;
+        case 3:
+          c(s) ? (o = o * 16 + parseInt(s, 16), l += String.fromCharCode(o), a = 0) : (l += String.fromCharCode(o), l += s, a = 0);
+          break;
+        case 4:
+          if (s === "{") {
+            a = 8;
+            break;
+          }
+          c(s) ? (o = parseInt(s, 16), a = 5) : (l += "x", a = 0);
+          break;
+        case 5:
+          c(s) ? (o = o * 16 + parseInt(s, 16), a = 6) : (l += String.fromCharCode(o), l += s, a = 0);
+          break;
+        case 6:
+          c(s) ? (o = o * 16 + parseInt(s, 16), a = 7) : (l += String.fromCharCode(o), l += s, a = 0);
+          break;
+        case 7:
+          c(s) ? (o = o * 16 + parseInt(s, 16), l += String.fromCharCode(o), a = 0) : (l += String.fromCharCode(o), l += s, a = 0);
+          break;
+        case 8:
+          c(s) ? (o = parseInt(s, 16), a = 9) : (l += "x", a = 0);
+          break;
+        case 9:
+          c(s) ? (o = o * 16 + parseInt(s, 16), a = 10) : (l += String.fromCharCode(o), l += s, a = 0);
+          break;
+        case 10:
+          c(s) ? (o = o * 16 + parseInt(s, 16), a = 11) : (l += String.fromCharCode(o), l += s, a = 0);
+          break;
+        case 11:
+          c(s) ? (o = o * 16 + parseInt(s, 16), a = 12) : (l += String.fromCharCode(o), l += s, a = 0);
+          break;
+        case 12:
+          c(s) ? (o = o * 16 + parseInt(s, 16), a = 13) : (l += String.fromCharCode(o), l += s, a = 0);
+          break;
+        case 13:
+          c(s) ? (o = o * 16 + parseInt(s, 16), a = 14) : (l += String.fromCharCode(o), l += s, a = 0);
+          break;
+        case 14:
+          l += String.fromCharCode(o), s !== "}" && (l += s), a = 0;
+          break;
+      }
+    switch (a) {
+      case 1:
+        l += "\\";
+        break;
+      case 2:
+        l += "x";
+        break;
+      case 3:
+        l += String.fromCharCode(o);
+        break;
+    }
+    return this.createExpressionNode(
+      "LitE",
+      {
+        value: l
+      },
+      e,
+      e
+    );
+    function c(s) {
+      return s >= "0" && s <= "9" || s >= "a" && s <= "f" || s >= "A" && s <= "F";
+    }
+  }
+  convertToArrayDestructure(e) {
+    var l;
+    const r = e.type === "SeqE" ? e.expressions : e.items, t = this.createExpressionNode(
+      "Destr",
+      { arrayDestruct: [] },
+      e.startToken,
+      e.endToken
+    );
+    for (const a of r) {
+      let o;
+      switch (a.type) {
+        case "NoArgE":
+          o = this.createExpressionNode(
+            "ADestr",
+            {},
+            a.startToken,
+            a.endToken
+          );
+          break;
+        case "IdE":
+          o = this.createExpressionNode(
+            "ADestr",
+            { id: a.name },
+            a.startToken,
+            a.endToken
+          );
+          break;
+        case "Destr":
+          t.arrayDestruct.push(...a.arrayDestruct);
+          break;
+        case "ADestr":
+          o = a;
+          break;
+        case "ALitE": {
+          const c = this.convertToArrayDestructure(a);
+          c && (o = this.createExpressionNode(
+            "ADestr",
+            {
+              arrayDestruct: c.arrayDestruct
+            },
+            a.startToken,
+            a.endToken
+          ));
+          break;
+        }
+        case "ODestr":
+          o = this.createExpressionNode(
+            "ADestr",
+            {
+              objectDestruct: a
+            },
+            a.startToken,
+            a.endToken
+          );
+          break;
+        case "OLitE": {
+          const c = this.convertToObjectDestructure(a);
+          c && (o = this.createExpressionNode(
+            "ADestr",
+            {
+              objectDestruct: c.objectDestruct
+            },
+            a.startToken,
+            a.endToken
+          ));
+          break;
+        }
+        default:
+          return this.reportError("W017"), null;
+      }
+      o && ((l = t.arrayDestruct) == null || l.push(o));
+    }
+    return t;
+  }
+  convertToObjectDestructure(e) {
+    var t;
+    const r = this.createExpressionNode(
+      "Destr",
+      { objectDestruct: [] },
+      e.startToken,
+      e.endToken
+    );
+    for (const l of e.props) {
+      if (!Array.isArray(l)) return this.reportError("W018"), null;
+      const [a, o] = l;
+      if (a.type !== "IdE")
+        return this.reportError("W018"), null;
+      let c;
+      switch (o.type) {
+        case "IdE":
+          o.name === a.name ? c = this.createExpressionNode(
+            "ODestr",
+            { id: a.name },
+            o.startToken,
+            o.endToken
+          ) : c = this.createExpressionNode(
+            "ODestr",
+            {
+              id: a.name,
+              alias: o.name
+            },
+            o.startToken,
+            o.endToken
+          );
+          break;
+        case "ADestr": {
+          c = this.createExpressionNode(
+            "ODestr",
+            {
+              id: a.name,
+              arrayDestruct: o
+            },
+            a.startToken,
+            o.endToken
+          );
+          break;
+        }
+        case "ALitE": {
+          const s = this.convertToArrayDestructure(o);
+          s && (c = this.createExpressionNode(
+            "ODestr",
+            {
+              id: a.name,
+              arrayDestruct: s.arrayDestruct
+            },
+            a.startToken,
+            o.endToken
+          ));
+          break;
+        }
+        case "ODestr":
+          c = o;
+          break;
+        case "OLitE": {
+          const s = this.convertToObjectDestructure(o);
+          s && (c = this.createExpressionNode(
+            "ODestr",
+            {
+              id: a.name,
+              objectDestruct: s.objectDestruct
+            },
+            a.startToken,
+            o.endToken
+          ));
+          break;
+        }
+        default:
+          return this.reportError("W018"), null;
+      }
+      c && ((t = r.objectDestruct) == null || t.push(c));
+    }
+    return r;
+  }
+  /**
+   * Tests if the specified token can be the start of an expression
+   */
+  isExpressionStart(e) {
+    var r;
+    return ((r = j[e.type]) == null ? void 0 : r.expressionStart) ?? !1;
+  }
+}
+function x(n, e, r, t, l, a) {
+  if (e.cancel)
+    return e;
+  if (e.skipChildren = !1, Array.isArray(n)) {
+    for (const o of n)
+      e = x(o, e, r, t, l, a);
+    return e;
+  }
+  switch (n.type) {
+    case "BlockS": {
+      if (e = (r == null ? void 0 : r(!0, n, e, l, a)) || e, e.cancel) return e;
+      if (!e.skipChildren) {
+        for (const o of n.statements)
+          if (e = x(o, e, r, t, n, "statements"), e.cancel) return e;
+      }
+      return e = (r == null ? void 0 : r(!1, n, e, l, a)) || e, e;
+    }
+    case "EmptyS":
+      return e = (r == null ? void 0 : r(!0, n, e, l, a)) || e, e;
+    case "ExprS":
+      return e = (r == null ? void 0 : r(!0, n, e, l, a)) || e, e.cancel || !e.skipChildren && (e = x(n.expression, e, r, t, n, "expression"), e.cancel) || (e = (r == null ? void 0 : r(!1, n, e, l, a)) || e), e;
+    case "ArrowS":
+      return e;
+    case "LetS": {
+      if (e = (r == null ? void 0 : r(!0, n, e, l, a)) || e, e.cancel) return e;
+      if (!e.skipChildren) {
+        for (const o of n.declarations)
+          if (e = x(o, e, r, t, n, "declarations"), e.cancel) return e;
+      }
+      return e = (r == null ? void 0 : r(!1, n, e, l, a)) || e, e;
+    }
+    case "ConstS": {
+      if (e = (r == null ? void 0 : r(!0, n, e, l, a)) || e, e.cancel) return e;
+      if (!e.skipChildren) {
+        for (const o of n.declarations)
+          if (e = x(o, e, r, t, n, "declarations"), e.cancel) return e;
+      }
+      return e = (r == null ? void 0 : r(!1, n, e, l, a)) || e, e;
+    }
+    case "VarS": {
+      if (e = (r == null ? void 0 : r(!0, n, e, l, a)) || e, e.cancel) return e;
+      if (!e.skipChildren) {
+        for (const o of n.declarations)
+          if (e = x(o, e, r, t, n, "declarations"), e.cancel) return e;
+      }
+      return e = (r == null ? void 0 : r(!1, n, e, l, a)) || e, e;
+    }
+    case "IfS":
+      return e = (r == null ? void 0 : r(!0, n, e, l, a)) || e, e.cancel || !e.skipChildren && (e = x(n.condition, e, r, t, n, "condition"), e.cancel || (n.thenBranch && (e = x(n.thenBranch, e, r, t, n, "thenBranch")), e.cancel) || (n.elseBranch && (e = x(n.elseBranch, e, r, t, n, "elseBranch")), e.cancel)) || (e = (r == null ? void 0 : r(!1, n, e, l, a)) || e), e;
+    case "RetS":
+      return e = (r == null ? void 0 : r(!0, n, e, l, a)) || e, e.cancel || !e.skipChildren && (n.expression && (e = x(n.expression, e, r, t, n, "expression")), e.cancel) || (e = (r == null ? void 0 : r(!1, n, e, l, a)) || e), e;
+    case "BrkS":
+      return e = (r == null ? void 0 : r(!0, n, e, l, a)) || e, e;
+    case "ContS":
+      return e = (r == null ? void 0 : r(!0, n, e, l, a)) || e, e;
+    case "WhileS":
+      return e = (r == null ? void 0 : r(!0, n, e, l, a)) || e, e.cancel || !e.skipChildren && (e = x(n.condition, e, r, t, n, "condition"), e.cancel || (e = x(n.body, e, r, t, n, "body"), e.cancel)) || (e = (r == null ? void 0 : r(!1, n, e, l, a)) || e), e;
+    case "DoWS":
+      return e = (r == null ? void 0 : r(!0, n, e, l, a)) || e, e.cancel || !e.skipChildren && (e = x(n.body, e, r, t, n, "body"), e.cancel || (e = x(n.condition, e, r, t, n, "condition"), e.cancel)) || (e = (r == null ? void 0 : r(!1, n, e, l, a)) || e), e;
+    case "ForS":
+      return e = (r == null ? void 0 : r(!0, n, e, l, a)) || e, e.cancel || !e.skipChildren && (n.init && (e = x(n.init, e, r, t, n, "init")), e.cancel || (n.condition && (e = x(n.condition, e, r, t, n, "condition")), e.cancel) || (n.update && (e = x(n.update, e, r, t, n, "update")), e.cancel) || (e = x(n.body, e, r, t, n, "body"), e.cancel)) || (e = (r == null ? void 0 : r(!1, n, e, l, a)) || e), e;
+    case "ForInS":
+      return e = (r == null ? void 0 : r(!0, n, e, l, a)) || e, e.cancel || !e.skipChildren && (e = x(n.expression, e, r, t, n, "expression"), e.cancel || (e = x(n.body, e, r, t, n, "body"), e.cancel)) || (e = (r == null ? void 0 : r(!1, n, e, l, a)) || e), e;
+    case "ForOfS":
+      return e = (r == null ? void 0 : r(!0, n, e, l, a)) || e, e.cancel || !e.skipChildren && (e = x(n.expression, e, r, t, n, "expression"), e.cancel || (e = x(n.body, e, r, t, n, "body"), e.cancel)) || (e = (r == null ? void 0 : r(!1, n, e, l, a)) || e), e;
+    case "ThrowS":
+      return e = (r == null ? void 0 : r(!0, n, e, l, a)) || e, e.cancel || !e.skipChildren && (e = x(n.expression, e, r, t, n, "expression"), e.cancel) || (e = (r == null ? void 0 : r(!1, n, e, l, a)) || e), e;
+    case "TryS":
+      return e = (r == null ? void 0 : r(!0, n, e, l, a)) || e, e.cancel || !e.skipChildren && (n.tryBlock && (e = x(n.tryBlock, e, r, t, n, "tryBlock")), e.cancel || (n.catchBlock && (e = x(n.catchBlock, e, r, t, n, "catchBlock")), e.cancel) || (n.finallyBlock && (e = x(n.finallyBlock, e, r, t, n, "finallyBlock")), e.cancel)) || (e = (r == null ? void 0 : r(!1, n, e, l, a)) || e), e;
+    case "SwitchS": {
+      if (e = (r == null ? void 0 : r(!0, n, e, l, a)) || e, e.cancel) return e;
+      if (!e.skipChildren) {
+        if (e = x(n.expression, e, r, t, n, "expression"), e.cancel) return e;
+        for (const o of n.cases) {
+          if (o.caseExpression && (e = x(o.caseExpression, e, r, t, n, "caseExpression")), e.cancel) return e;
+          if (o.statements !== void 0) {
+            for (const c of o.statements)
+              if (e = x(c, e, r, t, n, "switchStatement"), e.cancel) return e;
+          }
+        }
+      }
+      return e = (r == null ? void 0 : r(!1, n, e, l, a)) || e, e;
+    }
+    case "FuncD": {
+      if (e = (r == null ? void 0 : r(!0, n, e, l, a)) || e, e.cancel) return e;
+      if (!e.skipChildren) {
+        for (const o of n.args)
+          if (e = x(o, e, r, t, n, "arg"), e.cancel) return e;
+        if (e = x(n.statement, e, r, t, n, "statement"), e.cancel) return e;
+      }
+      return e = (r == null ? void 0 : r(!1, n, e, l, a)) || e, e;
+    }
+    case "ImportD":
+      return e = (r == null ? void 0 : r(!0, n, e, l, a)) || e, e.cancel || (e = (r == null ? void 0 : r(!1, n, e, l, a)) || e), e;
+    case "UnaryE":
+      return e = (t == null ? void 0 : t(!0, n, e, l, a)) || e, e.cancel || !e.skipChildren && (e = x(n.operand, e, r, t, n, "operand"), e.cancel) || (e = (t == null ? void 0 : t(!1, n, e, l, a)) || e), e;
+    case "BinaryE":
+      return e = (t == null ? void 0 : t(!0, n, e, l, a)) || e, e.cancel || !e.skipChildren && (e = x(n.left, e, r, t, n, "left"), e.cancel || (e = x(n.right, e, r, t, n, "right"), e.cancel)) || (e = (t == null ? void 0 : t(!1, n, e, l, a)) || e), e;
+    case "SeqE": {
+      if (e = (t == null ? void 0 : t(!0, n, e, l, a)) || e, e.cancel) return e;
+      if (!e.skipChildren) {
+        for (const o of n.expressions)
+          if (e = x(o, e, r, t, n, "expression"), e.cancel) return e;
+      }
+      return e = (t == null ? void 0 : t(!1, n, e, l, a)) || e, e;
+    }
+    case "CondE":
+      return e = (t == null ? void 0 : t(!0, n, e, l, a)) || e, e.cancel || !e.skipChildren && (e = x(n.condition, e, r, t, n, "condition"), e.cancel || (e = x(n.consequent, e, r, t, n, "consequent"), e.cancel) || (e = x(n.alternate, e, r, t, n, "alternate"), e.cancel)) || (e = (t == null ? void 0 : t(!1, n, e, l, a)) || e), e;
+    case "InvokeE": {
+      if (e = (t == null ? void 0 : t(!0, n, e, l, a)) || e, e.cancel) return e;
+      if (!e.skipChildren) {
+        for (const o of n.arguments)
+          if (e = x(o, e, r, t, n, "argument"), e.cancel) return e;
+        if (e = x(n.object, e, r, t, n, "object"), e.cancel) return e;
+      }
+      return e = (t == null ? void 0 : t(!1, n, e, l, a)) || e, e;
+    }
+    case "MembE":
+      return e = (t == null ? void 0 : t(!0, n, e, l, a)) || e, e.cancel || !e.skipChildren && (e = x(n.object, e, r, t, n, "object"), e.cancel) || (e = (t == null ? void 0 : t(!1, n, e, l, a)) || e), e;
+    case "CMembE":
+      return e = (t == null ? void 0 : t(!0, n, e, l, a)) || e, e.cancel || !e.skipChildren && (e = x(n.object, e, r, t, n, "object"), e.cancel || (e = x(n.member, e, r, t, n, "member"), e.cancel)) || (e = (t == null ? void 0 : t(!1, n, e, l, a)) || e), e;
+    case "IdE":
+      return e = (t == null ? void 0 : t(!0, n, e, l, a)) || e, e;
+    case "LitE":
+      return e = (t == null ? void 0 : t(!0, n, e, l, a)) || e, e;
+    case "ALitE": {
+      if (e = (t == null ? void 0 : t(!0, n, e, l, a)) || e, e.cancel) return e;
+      if (!e.skipChildren) {
+        for (const o of n.items)
+          if (e = x(o, e, r, t, n, "item"), e.cancel) return e;
+      }
+      return e = (t == null ? void 0 : t(!1, n, e, l, a)) || e, e;
+    }
+    case "OLitE": {
+      if (e = (t == null ? void 0 : t(!0, n, e, l, a)) || e, e.cancel) return e;
+      if (!e.skipChildren) {
+        for (const o of n.props)
+          if (Array.isArray(o)) {
+            const [c, s] = o;
+            if (e = x(c, e, r, t, n, "propKey"), e.cancel || (e = x(s, e, r, t, n, "propValue"), e.cancel)) return e;
+          } else if (e = x(o, e, r, t, n, "prop"), e.cancel) return e;
+      }
+      return e = (t == null ? void 0 : t(!1, n, e, l, a)) || e, e;
+    }
+    case "SpreadE":
+      return e = (t == null ? void 0 : t(!0, n, e, l, a)) || e, e.cancel || !e.skipChildren && (e = x(n.operand, e, r, t, n, "operand"), e.cancel) || (e = (t == null ? void 0 : t(!1, n, e, l, a)) || e), e;
+    case "AsgnE":
+      return e = (t == null ? void 0 : t(!0, n, e, l, a)) || e, e.cancel || !e.skipChildren && (e = x(n.operand, e, r, t, n, "operand"), e.cancel || (e = x(n.leftValue, e, r, t, n, "leftValue"), e.cancel)) || (e = (t == null ? void 0 : t(!1, n, e, l, a)) || e), e;
+    case "NoArgE":
+      return e = (t == null ? void 0 : t(!0, n, e, l, a)) || e, e;
+    case "ArrowE": {
+      if (e = (t == null ? void 0 : t(!0, n, e, l, a)) || e, e.cancel) return e;
+      if (!e.skipChildren) {
+        for (const o of n.args)
+          if (e = x(o, e, r, t, n, "arg"), e.cancel) return e;
+        if (e = x(n.statement, e, r, t, n, "statement"), e.cancel) return e;
+      }
+      return e = (t == null ? void 0 : t(!1, n, e, l, a)) || e, e;
+    }
+    case "PrefE":
+    case "PostfE":
+      return e = (t == null ? void 0 : t(!0, n, e, l, a)) || e, e.cancel || !e.skipChildren && (e = x(n.operand, e, r, t, n, "operand"), e.cancel) || (e = (t == null ? void 0 : t(!1, n, e, l, a)) || e), e;
+    case "VarD": {
+      if (e = (t == null ? void 0 : t(!0, n, e, l, a)) || e, e.cancel) return e;
+      if (!e.skipChildren) {
+        if (n.arrayDestruct !== void 0) {
+          for (const o of n.arrayDestruct)
+            if (e = x(o, e, r, t, n), e.cancel) return e;
+        }
+        if (n.objectDestruct !== void 0) {
+          for (const o of n.objectDestruct)
+            if (e = x(o, e, r, t, n), e.cancel) return e;
+        }
+        if (n.expression && (e = x(n.expression, e, r, t, n, "expression")), e.cancel) return e;
+      }
+      return e = (t == null ? void 0 : t(!1, n, e, l, a)) || e, e;
+    }
+    case "Destr":
+    case "ODestr":
+    case "ADestr": {
+      if (e = (t == null ? void 0 : t(!0, n, e, l, a)) || e, e.cancel) return e;
+      if (!e.skipChildren) {
+        if (n.arrayDestruct !== void 0) {
+          for (const o of n.arrayDestruct)
+            if (e = x(o, e, r, t, n), e.cancel) return e;
+        }
+        if (n.objectDestruct !== void 0) {
+          for (const o of n.objectDestruct)
+            if (e = x(o, e, r, t, n), e.cancel) return e;
+        }
+      }
+      return e = (t == null ? void 0 : t(!1, n, e, l, a)) || e, e;
+    }
+    case "RVarD":
+      return e = (t == null ? void 0 : t(!0, n, e, l, a)) || e, e.cancel || !e.skipChildren && (n.expression && (e = x(n.expression, e, r, t, n, "expression")), e.cancel) || (e = (t == null ? void 0 : t(!1, n, e, l, a)) || e), e;
+    case "TempLitE":
+      return e;
+    default:
+      return e;
+  }
+}
+function Xe(n) {
+  return n.type !== "ScriptModule";
+}
+function Te(n, e, r, t = !1) {
+  const l = /* @__PURE__ */ new Map(), a = {}, o = c(n, e, r, !0);
+  return !o || Object.keys(a).length > 0 ? a : o;
+  function c(s, D, L, u = !1) {
+    var O;
+    if (l.has(s))
+      return l.get(s);
+    const p = new Ne(D);
+    let U = [];
+    try {
+      U = p.parseStatements();
+    } catch {
+      return a[s] = p.errors, null;
+    }
+    const m = p.current;
+    if (m.type !== i.Eof)
+      return a[s] ?? (a[s] = []), a[s].push({
+        code: "W002",
+        text: ie.W002.replace(/\{(\d+)}/g, () => m.text),
+        position: m.location.startLine,
+        line: m.location.startLine,
+        column: m.location.startColumn
+      }), null;
+    const E = [];
+    x(U, {
+      data: null,
+      cancel: !1,
+      skipChildren: !1
+    }, (I, v, G, d, h) => {
+      if (!I) return G;
+      if (u)
+        switch (v.type) {
+          case "VarS":
+            d && H("W027", v);
+            break;
+          case "FuncD":
+          case "ImportD":
+            break;
+          default:
+            t && !d && H("W028", v, v.type);
+            break;
+        }
+      else
+        switch (v.type) {
+          case "VarS":
+            H("W027", v);
+            break;
+          case "FuncD":
+            t && !v.isExported && H("W029", v);
+            break;
+          case "ImportD":
+            break;
+          default:
+            t && !d && H("W028", v, v.type);
+            break;
+        }
+      return G;
+    });
+    const K = {};
+    U.filter((I) => I.type === "FuncD").forEach((I) => {
+      const v = I;
+      if (K[v.name]) {
+        H("W020", I, v.name);
+        return;
+      }
+      K[v.name] = v;
+    });
+    const q = /* @__PURE__ */ new Map();
+    U.forEach((I) => {
+      I.type === "ConstS" && I.isExported ? Ke(I, (v) => {
+        q.has(v) ? H("W021", I, v) : q.set(v, I);
+      }) : I.type === "FuncD" && I.isExported && (q.has(I.name) ? H("W021", I, I.name) : q.set(I.name, I));
+    });
+    const X = {
+      type: "ScriptModule",
+      name: s,
+      exports: q,
+      importedModules: [],
+      imports: {},
+      functions: K,
+      statements: U,
+      executed: !1
+    };
+    l.set(s, X);
+    const V = [], ee = {};
+    for (let I = 0; I < U.length; I++) {
+      const v = U[I];
+      if (v.type !== "ImportD")
+        continue;
+      const G = L(s, v.moduleFile);
+      if (G === null) {
+        H("W022", v, v.moduleFile);
+        continue;
+      }
+      const d = c(v.moduleFile, G, L);
+      if (!d)
+        return;
+      V.push(d);
+      const h = Object.keys(v.imports);
+      h.length > 0 && (ee[O = v.moduleFile] ?? (ee[O] = {}));
+      for (const g of h)
+        d.exports.has(v.imports[g]) ? ee[v.moduleFile][g] = d.exports.get(v.imports[g]) : H("W023", v, v.moduleFile, g);
+    }
+    if (E.length > 0)
+      return a[s] = E, null;
+    return V.forEach((I) => I.parent = X), X.importedModules = V, X.imports = ee, X;
+    function H(I, v, ...G) {
+      let d = ie[I];
+      G && G.forEach(
+        (h, g) => d = d.replaceAll(`{${g}}`, G[g].toString())
+      ), E.push({
+        code: I,
+        text: ie[I].replace(/\{(\d+)}/g, (h, g) => G[g]),
+        position: v.startPosition,
+        line: v.startLine,
+        column: v.startColumn
+      });
+    }
+  }
+}
+function De(n) {
+  var r;
+  const e = ((r = n.blocks) == null ? void 0 : r.slice(0)) ?? [];
+  return n.parent ? [...De(n.parent), ...e] : e;
+}
+function Ke(n, e) {
+  for (let a = 0; a < n.declarations.length; a++) {
+    const o = n.declarations[a];
+    r(o, e);
+  }
+  function r(a, o) {
+    if (a.id)
+      o(a.id);
+    else if (a.arrayDestruct)
+      t(a.arrayDestruct, o);
+    else if (a.objectDestruct)
+      l(a.objectDestruct, o);
+    else
+      throw new Error("Unknown declaration specifier");
+  }
+  function t(a, o) {
+    for (let c = 0; c < a.length; c++) {
+      const s = a[c];
+      s.id ? o(s.id) : s.arrayDestruct ? t(s.arrayDestruct, o) : s.objectDestruct && l(s.objectDestruct, o);
+    }
+  }
+  function l(a, o) {
+    for (let c = 0; c < a.length; c++) {
+      const s = a[c];
+      s.arrayDestruct ? t(s.arrayDestruct, o) : s.objectDestruct ? l(s.objectDestruct, o) : o(s.alias ?? s.id);
+    }
+  }
+}
+const le = "__PARSED__";
+function Qe(n, e, r, t) {
+  const l = {
+    vars: {},
+    moduleErrors: {},
+    functions: {}
+  }, a = {}, o = Te(n, e, r, !0);
+  if (Xe(o))
+    return { ...l, moduleErrors: o };
+  const c = t(o.name);
+  return o.statements.forEach((L) => {
+    switch (L.type) {
+      case "VarS":
+        L.declarations.forEach((u) => {
+          if (u.id in l.vars)
+            throw new Error(`Duplicated var declaration: '${u.id}'`);
+          l.vars[u.id] = {
+            [le]: !0,
+            source: u.expression.source,
+            tree: u.expression
+          };
+        });
+        break;
+      case "FuncD":
+        D(c, L);
+        break;
+      case "ImportD":
+        break;
+      default:
+        throw new Error(`'${L.type}' is not allowed in a code-behind module.`);
+    }
+  }), s(o), l;
+  function s(L) {
+    var O;
+    const u = t(L.name);
+    if (!((O = a == null ? void 0 : a[u]) != null && O.collectedImportsFrom)) {
+      for (const p in L.imports) {
+        const U = t(p), m = L.imports[p];
+        for (const E of Object.values(m))
+          E.type === "FuncD" && D(U, E);
+      }
+      a[u] ?? (a[u] = { collectedImportsFrom: !0 }), a[u].collectedImportsFrom = !0;
+      for (let p of L.importedModules)
+        s(p);
+    }
+  }
+  function D(L, u) {
+    var E, $, K, q;
+    var O;
+    if ((($ = (E = a == null ? void 0 : a[L]) == null ? void 0 : E.functions) == null ? void 0 : $[u.name]) !== void 0)
+      return;
+    if (u.name in l.functions)
+      throw new Error(`Duplicated function declaration: '${u.name}'`);
+    const p = u.args.length === 1 ? `${u.args[0].source} => ${u.statement.source}` : `(${u.args.map((X) => X.source).join(", ")}) => ${u.statement.source}`, U = {
+      type: "ArrowE",
+      args: u.args.slice(),
+      statement: u.statement,
+      closureContext: De({
+        blocks: [{ vars: {} }]
+      })
+    }, m = (q = (K = U.closureContext[0]) == null ? void 0 : K.vars) == null ? void 0 : q[u.name];
+    m != null && m.closureContext && delete m.closureContext, a[L] ?? (a[L] = { functions: {}, collectedImportsFrom: !1 }), (O = a[L]).functions ?? (O.functions = {}), a[L].functions[u.name] = {
+      [le]: !0,
+      source: p,
+      tree: U
+    }, l.functions[u.name] = {
+      [le]: !0,
+      source: p,
+      tree: U
+    };
+  }
+}
+function Wr(n) {
+  if (!n) return;
+  const e = {
+    data: null,
+    cancel: !1,
+    skipChildren: !1
+  };
+  Object.keys(n.vars).forEach((t) => {
+    r(n.vars[t]);
+  }), Object.keys(n.functions).forEach((t) => {
+    r(n.functions[t]);
+  });
+  function r(t) {
+    const l = (a, o, c) => (a && o && (delete o.startPosition, delete o.endPosition, delete o.startLine, delete o.endLine, delete o.startColumn, delete o.endColumn, delete o.startToken, delete o.endToken), c);
+    x(t.tree, e, l, l);
+  }
+}
+class ue extends Error {
+  constructor(e, r) {
+    super(`${r ? `${r}: ` : ""}${e}`), this.code = r, Object.setPrototypeOf(this, ue.prototype);
+  }
+}
+const Ze = {
+  U001: "Unexpected token: {0}.",
+  U002: "A component definition can have exactly one XMLUI element.",
+  U003: "A '<' token expected.",
+  U004: "A node identifier expected.",
+  U005: "A '</' token expected.",
+  U006: "A '>' or '/>' token expected.",
+  U007: "An '{0}' ID expected in the closing tag but '{1}' received.",
+  U008: "A '>' token expected.",
+  U009: "An attribute identifier expected.",
+  U010: "An '=' token expected.",
+  U011: "An attribute value expected.",
+  U012: "Duplicated attribute: '{0}'.",
+  U013: "Attribute name cannot start with an uppercase letter.",
+  U014: "An '{0}' ID expected in the closing tag's namespace but '{1}' received.",
+  U015: "Unexpected token in text element: {0}.",
+  T001: "A component definition must have exactly one XMLUI element.",
+  T002: "A component definition's name must start with an uppercase letter.",
+  T003: "A reusable component must have a non-empty name.",
+  T004: "A reusable component's name must start with an uppercase letter.",
+  T005: "A reusable component must have at least one nested component definition.",
+  T006: "A reusable component definition cannot nest another one.",
+  T007: "Invalid attribute name: '{0}'",
+  T008: "Event attribute names should not start with 'on' prefix: '{0}'",
+  T009: "Invalid node name '{0}' in a component definition",
+  T010: "The '{0}' element does not accept a text child",
+  T011: "Only 'name', 'value', and type hint attributes are accepted in '{0}'.",
+  T012: "The 'name' attribute in '{0}' is required.",
+  T013: "A loader element must have an id.",
+  T014: "A loader element must not have '{0}'.",
+  T015: "The uses element must define only a non-empty 'value' attribute.",
+  T016: "Only 'field' or 'item' are accepted as a child element.",
+  T017: "Cannot mix 'field' and 'item' nodes within an element.",
+  T018: "The '{0}' node cannot have a 'name' attribute.",
+  T019: "The 'value' attribute in '{0}' is required.",
+  T020: "Cannot mix nested components and non-component children.",
+  T021: "Invalid reusable component attribute '{0}'.",
+  T022: "The 'script' tag must not have any attribute.",
+  T023: "A 'script' tag cannot nest other child nodes, only text.",
+  T024: "Cannot put a reusable component definitions into a slot.",
+  T025: "Duplicate xmlns found: '{0}'.",
+  T026: "The top level component's name cannot have a namespace.",
+  T027: "Cannot resolve namespace '{0}'. It was not defined in any of the ancestor components.",
+  T028: "Incorrect namespace value '{0}'. {1}",
+  T029: "Incorrect scheme specified before ':' (colon) in namespace {0}. Delete it to get the default '{1}'."
+}, xe = "Component", ae = /^[A-Z]/, me = /^on[A-Z]/, Je = ["name", "value"], Ye = 9, oe = "component-ns", je = "app-ns", Ve = "#app-ns", er = "core-ns", se = "#xmlui-core-ns", Y = {
+  property: "property",
+  event: "event",
+  variable: "variable",
+  loaders: "loaders",
+  uses: "uses",
+  method: "method",
+  item: "item",
+  field: "field"
+};
+function Br(n, e, r, t = () => "") {
+  const l = (d) => d.text ?? e(d), a = ir(n), o = V(a), c = [], s = [];
+  return D(c, o);
+  function D(d, h) {
+    const g = Ce(h, l, s);
+    if (g === xe)
+      return u(h);
+    let f = {
+      type: g,
+      debug: {
+        source: {
+          start: h.start,
+          end: h.end,
+          fileId: r
+        }
+      }
+    };
+    return O(d, f, h), f;
+  }
+  function L(d, h) {
+    const g = Ce(h, l, s);
+    g === xe && b("T006");
+    let f = {
+      type: g,
+      debug: {
+        source: {
+          start: h.start,
+          end: h.end,
+          fileId: r
+        }
+      }
+    };
+    return O(d, f, h), f;
+  }
+  function u(d) {
+    const h = re(d).map(q), g = h.find((W) => W.name === "name");
+    g || b("T003"), ae.test(g.value) || b("T004");
+    let f;
+    const S = h.filter((W) => W.startSegment === "method");
+    S.length > 0 && (f = {}, S.forEach((W) => {
+      f[W.name] = W.value;
+    }));
+    let C;
+    const A = h.filter((W) => W.startSegment === "var");
+    A.length > 0 && (C = {}, A.forEach((W) => {
+      C[W.name] = W.value;
+    }));
+    const P = ne(d), F = P.filter(
+      (W) => W.kind === k.ElementNode && !(J(W, l) in Y)
+    );
+    F.length === 0 && F.push(Se(""));
+    const y = [], M = [];
+    for (let W of P)
+      if (W.kind === k.ElementNode) {
+        const he = J(W, l);
+        he === Y.variable ? M.push(W) : he in Y && y.push(W);
+      }
+    let _;
+    F.length > 1 || M.length > 0 ? _ = _e([...M, ...F]) : _ = F[0], s.push(/* @__PURE__ */ new Map()), h.filter((W) => W.namespace === "xmlns").forEach((W) => {
+      we(s, _, W.unsegmentedName, W.value);
+    });
+    let w = L(
+      c,
+      _
+    );
+    s.pop();
+    const B = {
+      name: g.value,
+      component: w,
+      debug: {
+        source: {
+          start: d.start,
+          end: d.end,
+          fileId: r
+        }
+      }
+    };
+    f && (B.api = f), C && (w.vars = { ...w.vars, ...C }), w.debug = {
+      source: {
+        start: _.start,
+        end: _.end,
+        fileId: r
+      }
+    };
+    const Q = Le(d, y);
+    return O(c, B, Q), B;
+  }
+  function O(d, h, g) {
+    var F;
+    const f = !T(h), S = re(g);
+    if (s.push(/* @__PURE__ */ new Map()), S.forEach((y) => {
+      p(h, y);
+    }), ne(g).forEach((y) => {
+      if (y.kind === k.Script) {
+        re(y).length > 0 && b("T022");
+        const _ = l(y), w = _.slice(
+          _.indexOf(">") + 1,
+          _.lastIndexOf("</")
+        );
+        h.script ?? (h.script = ""), h.script.length > 0 && (h.script += `
+`), h.script += w;
+        return;
+      }
+      if (y.kind === k.TextNode && !f) {
+        h.children = te(h.children, l(y));
+        return;
+      }
+      const M = J(y, l);
+      if (!(f && y.kind === k.ElementNode && !(M in Y))) {
+        if (!(M in Y) && !f) {
+          const _ = L(d, y);
+          _ && (h.children ? typeof h.children == "string" ? h.children = [h.children, _] : Array.isArray(h.children) && h.children.push(_) : h.children = [_]);
+          return;
+        }
+        switch (M) {
+          case "property":
+            $(
+              d,
+              h,
+              y,
+              (_) => {
+                var w;
+                return T(h) ? (w = h.props) == null ? void 0 : w[_] : void 0;
+              },
+              (_, w) => {
+                T(h) && (h.props ?? (h.props = {}), h.props[_] = w);
+              }
+            );
+            return;
+          case "event":
+            $(
+              d,
+              h,
+              y,
+              (_) => {
+                var w;
+                return T(h) ? (w = h.events) == null ? void 0 : w[_] : void 0;
+              },
+              (_, w) => {
+                T(h) && (h.events ?? (h.events = {}), h.events[_] = w);
+              },
+              (_) => {
+                me.test(_) && b("T008", _);
+              }
+            );
+            return;
+          case Y.variable:
+            $(
+              d,
+              h,
+              y,
+              (_) => {
+                var w;
+                return T(h) ? (w = h.vars) == null ? void 0 : w[_] : void 0;
+              },
+              (_, w) => {
+                T(h) && (h.vars ?? (h.vars = {}), h.vars[_] = w);
+              }
+            );
+            return;
+          case "loaders":
+            E(d, h, y);
+            return;
+          case "uses":
+            K(h, y);
+            return;
+          case "method":
+            $(
+              d,
+              h,
+              y,
+              (_) => {
+                var w;
+                return T(h) ? (w = h.api) == null ? void 0 : w[_] : void 0;
+              },
+              (_, w) => {
+                h.api ?? (h.api = {}), h.api[_] = w;
+              }
+            );
+            return;
+          default:
+            b("T009", M);
+            return;
+        }
+      }
+    }), s.pop(), !h.script || h.script.trim().length === 0)
+      return;
+    const A = new Ne(h.script);
+    try {
+      A.parseStatements(), h.scriptCollected = Qe(
+        "Main",
+        h.script,
+        t,
+        (y) => y
+      );
+    } catch (y) {
+      A.errors && A.errors.length > 0 ? h.scriptError = A.errors : h.scriptError = y;
+    }
+    const P = ((F = h.scriptCollected) == null ? void 0 : F.moduleErrors) ?? {};
+    Object.keys(P).length > 0 && (h.scriptError = P);
+  }
+  function p(d, h) {
+    const { namespace: g, startSegment: f, name: S, value: C, unsegmentedName: A } = q(h);
+    if (g === "xmlns")
+      return we(s, d, A, C);
+    if (!T(d)) {
+      if (f && f !== "method" && f !== "var") {
+        b("T021");
+        return;
+      }
+      if (S === "name" && !f)
+        return;
+      !f && S && b("T021", S);
+      return;
+    }
+    switch (S) {
+      case "id":
+        d.uid = C;
+        return;
+      case "testId":
+        d.testId = C;
+        return;
+      case "when":
+        d.when = C;
+        return;
+      default:
+        if (f === "var")
+          d.vars ?? (d.vars = {}), d.vars[S] = C;
+        else if (f === "method")
+          d.api ?? (d.api = {}), d.api[S] = C;
+        else if (f === "event")
+          d.events ?? (d.events = {}), d.events[S] = C;
+        else if (me.test(S)) {
+          d.events ?? (d.events = {});
+          const F = S[2].toLowerCase() + S.substring(3);
+          d.events[F] = C;
+        } else
+          d.props ?? (d.props = {}), d.props[S] = C;
+        return;
+    }
+  }
+  function U(d, h) {
+    let g = null;
+    if (!h) return g;
+    let f = null;
+    return h.forEach((S) => {
+      if (S.kind === k.TextNode) {
+        g = te(g, l(S));
+        return;
+      }
+      if (S.kind !== k.ElementNode) return;
+      const C = J(S, l);
+      if (C !== "field" && C !== "item") {
+        b("T016");
+        return;
+      }
+      if (C === "field") {
+        if (!f)
+          f = C, g = {};
+        else if (f !== C) {
+          b("T017");
+          return;
+        }
+      } else if (C === "item") {
+        if (!f)
+          f = C, g = [];
+        else if (f !== C) {
+          b("T017");
+          return;
+        }
+      }
+      let A = m(d, S, C === "field");
+      if (!A)
+        return null;
+      f === "field" ? g[A.name] = A.value : g.push(A.value);
+    }), g;
+  }
+  function m(d, h, g = !0) {
+    const f = J(h, l), S = ne(h), C = S.filter(
+      (B) => B.kind === k.ElementNode && ae.test(J(B, l))
+    ), A = S.filter(
+      (B) => B.kind === k.ElementNode && !ae.test(J(B, l))
+    ), P = re(h).map(q), F = P.filter((B) => Je.indexOf(B.name) >= 0);
+    if (P.length > F.length)
+      return b("T011", f), null;
+    const y = F.find((B) => B.name === "name");
+    if (g) {
+      if (!(y != null && y.value))
+        return b("T012", f), null;
+    } else if (y)
+      return b("T018", f), null;
+    const M = y == null ? void 0 : y.value, _ = F.find((B) => B.name === "value");
+    if (_ && _.value === void 0)
+      return b("T019", f), null;
+    if (M && C.length >= 1) {
+      if (A.length > 0)
+        return b("T020"), null;
+      const B = C.map((Q) => L(d, Q));
+      return {
+        name: M,
+        value: B.length === 1 ? B[0] : B
+      };
+    }
+    let w = _ == null ? void 0 : _.value;
+    return w === null ? null : typeof w == "string" ? { name: M, value: w } : { name: M, value: U(d, S) };
+  }
+  function E(d, h, g) {
+    var C;
+    if (!T(h)) {
+      b("T009", "loaders");
+      return;
+    }
+    const f = ne(g);
+    if (f.length === 0 && (h.loaders ?? (h.loaders = [])), (C = g.children) == null ? void 0 : C.some((A) => A.kind === k.AttributeListNode)) {
+      b("T014", "attributes");
+      return;
+    }
+    f.forEach((A) => {
+      if (A.kind === k.TextNode) {
+        b("T010", "loader");
+        return;
+      }
+      const P = L(d, A);
+      if (!P.uid) {
+        b("T013");
+        return;
+      }
+      if (P.vars) {
+        b("T014", "vars");
+        return;
+      }
+      if (P.loaders) {
+        b("T014", "loaders");
+        return;
+      }
+      if (P.uses) {
+        b("T014", "uses");
+        return;
+      }
+      h.loaders ?? (h.loaders = []), h.loaders.push(P);
+    });
+  }
+  function $(d, h, g, f, S, C) {
+    const A = m(d, g);
+    if (!A)
+      return;
+    C == null || C((A == null ? void 0 : A.name) ?? "");
+    const P = A.name, F = A.value;
+    if ((A == null ? void 0 : A.value) !== void 0)
+      S(P, te(f(P), F));
+    else {
+      const y = ne(g), M = U(d, y);
+      let _ = f(P);
+      _ = te(_, M), S(P, _);
+    }
+  }
+  function K(d, h) {
+    if (!T(d)) {
+      b("T009", "uses");
+      return;
+    }
+    const g = re(h).map(q), f = g.find((S) => S.name === "value");
+    if (!(f != null && f.value) || g.length !== 1) {
+      b("T015", "uses");
+      return;
+    }
+    d.uses ?? (d.uses = f.value.split(",").map((S) => S.trim()));
+  }
+  function q(d) {
+    let h = d.children[0];
+    const g = h.children.length === 3;
+    let f;
+    g && (f = l(h.children[0]));
+    let S = l(h.children[h.children.length - 1]);
+    const C = S.split(".");
+    C.length > 2 && b("T007", d, h);
+    let A, P;
+    C.length === 2 ? (P = C[0], A = C[1], A.trim() === "" && b("T007", d, A)) : A = S;
+    const F = l(d.children[2]), y = F.substring(1, F.length - 1);
+    return { namespace: f, startSegment: P, name: A, value: y, unsegmentedName: S };
+  }
+  function X(d) {
+    for (let h of d) {
+      const g = h.children[h.children.length - 1], f = v(l(g));
+      f !== null && (g.text = f);
+    }
+  }
+  function V(d) {
+    const h = ne(d), g = J(d, l), S = !(g in Y) || g === "property", C = g !== "event" && g !== "method", A = re(d);
+    nr(A), tr(A, l), X(A), I(h), G(h, C);
+    let P = !1, F = !1;
+    for (let w = 0; w < h.length; ++w) {
+      const B = h[w];
+      let Q;
+      if (B.kind == k.Script) {
+        F = !0;
+        continue;
+      }
+      if (B.kind === k.ElementNode) {
+        Q = V(B), h[w] = Q;
+        continue;
+      }
+      let W = l(B);
+      B.kind === k.StringLiteral ? W = W.slice(1, -1) : B.kind === k.CData ? P = !0 : (B.kind, k.TextNode), S ? P ? Q = rr(W) : Q = Se(W) : Q = {
+        kind: k.TextNode,
+        text: W
+      }, h[w] = Q;
+    }
+    const y = [], M = [];
+    let _ = !1;
+    for (const w of h) {
+      if (w.kind === k.ElementNode) {
+        if ((J(w, l) ?? void 0) in Y) {
+          y.push(w);
+          continue;
+        }
+        _ = !0;
+      }
+      M.push(w);
+    }
+    if (F && _) {
+      const w = _e(M);
+      return y.push(w), Le(d, y);
+    }
+    return d;
+  }
+  function ee(d) {
+    for (let h = 0; h < d.length; ++h)
+      if (d[h].kind === k.StringLiteral || d[h].kind === k.TextNode) {
+        const g = /[\f\n\r\t\v\u0020\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]+/g;
+        d[h].text = l(d[h]).replace(
+          g,
+          " "
+        );
+      }
+  }
+  function H(d) {
+    for (let h = 0; h < d.length; ++h)
+      d[h].kind === k.CData && (d[h].text = l(d[h]).slice(Ye, -3));
+  }
+  function I(d) {
+    for (let h of d)
+      if (h.kind === k.StringLiteral || h.kind === k.TextNode) {
+        const g = v(l(h));
+        g !== null && (h.text = g);
+      }
+  }
+  function v(d) {
+    let h = "", g = 0;
+    for (let f = 0; f < d.length; ++f)
+      if (d.charCodeAt(f) === R.ampersand)
+        switch (d.charCodeAt(f + 1)) {
+          case R.a:
+            switch (d.charCodeAt(f + 2)) {
+              case R.m:
+                d.charCodeAt(f + 3) === R.p && d.charCodeAt(f + 4) === R.semicolon && (h = h + d.substring(g, f) + "&", f += 4, g = f + 1);
+                break;
+              case R.p:
+                d.charCodeAt(f + 3) === R.o && d.charCodeAt(f + 4) === R.s && d.charCodeAt(f + 5) === R.semicolon && (h = h + d.substring(g, f) + "'", f += 5, g = f + 1);
+                break;
+            }
+            break;
+          case R.g:
+            d.charCodeAt(f + 2) === R.t && d.charCodeAt(f + 3) === R.semicolon && (h = h + d.substring(g, f) + ">", f += 3, g = f + 1);
+            break;
+          case R.l:
+            d.charCodeAt(f + 2) === R.t && d.charCodeAt(f + 3) === R.semicolon && (h = h + d.substring(g, f) + "<", f += 3, g = f + 1);
+            break;
+          case R.q:
+            d.charCodeAt(f + 2) === R.u && d.charCodeAt(f + 3) === R.o && d.charCodeAt(f + 4) === R.t && d.charCodeAt(f + 5) === R.semicolon && (h = h + d.substring(g, f) + '"', f += 5, g = f + 1);
+            break;
+          case R.n:
+            d.charCodeAt(f + 2) === R.b && d.charCodeAt(f + 3) === R.s && d.charCodeAt(f + 4) === R.p && d.charCodeAt(f + 5) === R.semicolon && (h = h + d.substring(g, f) + " ", f += 5, g = f + 1);
+            break;
+        }
+    return g === 0 ? null : (h += d.substring(g), h);
+  }
+  function G(d, h) {
+    h && ee(d), H(d);
+    for (let g = d.length - 1; g > 0; --g) {
+      const f = d[g - 1], S = d[g];
+      f.kind === k.StringLiteral && S.kind === k.CData ? (d[g - 1] = {
+        kind: k.CData,
+        text: l(f).slice(1, -1) + l(S)
+      }, d.pop()) : f.kind === k.CData && S.kind === k.StringLiteral ? (d[g - 1] = {
+        kind: k.CData,
+        text: l(f) + l(S).slice(1, -1)
+      }, d.pop()) : f.kind === k.CData && S.kind === k.TextNode ? (d[g - 1] = {
+        kind: k.CData,
+        text: l(f) + l(S)
+      }, d.pop()) : f.kind === k.CData && S.kind === k.CData ? (d[g - 1] = {
+        kind: k.CData,
+        text: l(f) + l(S)
+      }, d.pop()) : f.kind === k.TextNode && S.kind === k.TextNode ? (l(f).endsWith(" ") && l(S).startsWith(" ") && (f.text = l(f).trimEnd()), d[g - 1] = {
+        kind: k.TextNode,
+        text: l(f) + l(S)
+      }, d.pop()) : f.kind === k.TextNode && S.kind === k.CData && (d[g - 1] = {
+        kind: k.CData,
+        text: l(f) + l(S)
+      }, d.pop());
+    }
+  }
+}
+function rr(n) {
+  return {
+    kind: k.ElementNode,
+    children: [
+      { kind: k.OpenNodeStart },
+      {
+        kind: k.TagNameNode,
+        children: [{ kind: k.Identifier, text: "TextNodeCData" }]
+      },
+      {
+        kind: k.AttributeListNode,
+        children: [
+          {
+            kind: k.AttributeNode,
+            children: [
+              {
+                kind: k.AttributeKeyNode,
+                children: [{ kind: k.Identifier, text: "value" }]
+              },
+              { kind: k.Equal },
+              { kind: k.Identifier, text: `"${n}"` }
+            ]
+          }
+        ]
+      },
+      { kind: k.NodeClose }
+    ]
+  };
+}
+function Se(n) {
+  return {
+    kind: k.ElementNode,
+    children: [
+      { kind: k.OpenNodeStart },
+      {
+        kind: k.TagNameNode,
+        children: [{ kind: k.Identifier, text: "TextNode" }]
+      },
+      {
+        kind: k.AttributeListNode,
+        children: [
+          {
+            kind: k.AttributeNode,
+            children: [
+              {
+                kind: k.AttributeKeyNode,
+                children: [{ kind: k.Identifier, text: "value" }]
+              },
+              { kind: k.Equal },
+              { kind: k.Identifier, text: `"${n}"` }
+            ]
+          }
+        ]
+      },
+      { kind: k.NodeClose }
+    ]
+  };
+}
+function b(n, ...e) {
+  let r = Ze[n] ?? "Unknown error";
+  throw e && e.forEach((l, a) => r = t(r, `{${a}}`, l.toString())), new ue(r, n);
+  function t(l, a, o) {
+    do
+      l = l.replace(a, o);
+    while (l.includes(a));
+    return l;
+  }
+}
+function T(n) {
+  return n.type;
+}
+function te(n, e) {
+  return n ? Array.isArray(n) ? typeof n == "string" ? [n, e] : (n.push(e), n) : [n, e] : e;
+}
+function _e(n) {
+  const e = {
+    kind: k.TagNameNode,
+    children: [{ kind: k.Identifier, text: "Fragment" }]
+  };
+  return {
+    kind: k.ElementNode,
+    start: n[0].start,
+    pos: n[0].pos,
+    end: n[n.length - 1].end,
+    children: [
+      { kind: k.OpenNodeStart },
+      e,
+      { kind: k.NodeEnd },
+      { kind: k.ContentListNode, children: n },
+      { kind: k.CloseNodeStart },
+      e,
+      { kind: k.NodeEnd }
+    ]
+  };
+}
+function re(n) {
+  var e, r;
+  return ((r = (e = n.children) == null ? void 0 : e.find((t) => t.kind === k.AttributeListNode)) == null ? void 0 : r.children) ?? [];
+}
+function ne(n) {
+  var e, r;
+  return ((r = (e = n.children) == null ? void 0 : e.find((t) => t.kind === k.ContentListNode)) == null ? void 0 : r.children) ?? [];
+}
+function Le(n, e) {
+  var t;
+  const r = (t = n.children) == null ? void 0 : t.findIndex((l) => l.kind === k.ContentListNode);
+  return r === void 0 || r === -1 ? n : {
+    ...n,
+    children: [
+      ...n.children.slice(0, r),
+      { ...n.children[r], children: e },
+      ...n.children.slice(r)
+    ]
+  };
+}
+function nr(n) {
+  var e;
+  for (let r of n)
+    if (((e = r.children) == null ? void 0 : e.length) === 1) {
+      const t = {
+        kind: k.Equal
+      }, l = {
+        kind: k.StringLiteral,
+        text: '"true"'
+      };
+      r.children.push(t, l);
+    }
+}
+function tr(n, e) {
+  var r, t, l;
+  for (let a of n) {
+    const o = (r = a.children) == null ? void 0 : r[2];
+    ((l = (t = a.children) == null ? void 0 : t[2]) == null ? void 0 : l.kind) === k.Identifier && (o.text = '"' + e(o) + '"');
+  }
+}
+function we(n, e, r, t) {
+  let l = t.split(":");
+  if (l.length > 2)
+    return b("T028", t, "Namespace cannot contain multiple ':' (colon).");
+  let a = t;
+  if (l.length === 2) {
+    if (l[0] != oe)
+      return b("T029", t, oe);
+    a = l[1];
+  }
+  if (a.includes("#"))
+    return b("T028", a, "Namespace cannot contain character '#'.");
+  switch (a) {
+    case oe:
+      a = r;
+      break;
+    case je:
+      a = Ve;
+      break;
+    case er:
+      a = se;
+      break;
+  }
+  const o = n[n.length - 1];
+  if (o.has(r))
+    return b("T025", r);
+  o.set(r, a), e.namespaces ?? (e.namespaces = {}), e.namespaces[r] = a;
+}
+function ir(n, e) {
+  n.children.length !== 2 && b("T001");
+  const r = n.children[0];
+  return r.kind !== k.ElementNode && b("T001"), r;
+}
+function J(n, e) {
+  const r = n.children.find((l) => l.kind === k.TagNameNode).children;
+  return e(r.at(-1));
+}
+function Ce(n, e, r) {
+  const t = n.children.find((c) => c.kind === k.TagNameNode).children, l = e(t.at(-1));
+  if (t.length === 1)
+    return l;
+  const a = e(t[0]);
+  r.length === 0 && b("T026");
+  let o;
+  for (let c = r.length - 1; c >= 0 && (o = r[c].get(a), o === void 0); --c)
+    ;
+  return o === void 0 && b("T027", a), o + "." + l;
+}
+const lr = [
+  "horizontalAlignment",
+  "verticalAlignment",
+  "orientation",
+  "width",
+  "minWidth",
+  "maxWidth",
+  "height",
+  "minHeight",
+  "maxHeight",
+  "gap",
+  "border",
+  "borderTop",
+  "borderRight",
+  "borderBottom",
+  "borderLeft",
+  "borderColor",
+  "borderStyle",
+  "borderWidth",
+  "borderHorizontal",
+  "borderVertical",
+  "borderRadius",
+  "radiusTopLeft",
+  "radiusTopRight",
+  "radiusBottomLeft",
+  "radiusBottomRight",
+  "padding",
+  "paddingHorizontal",
+  "paddingVertical",
+  "paddingTop",
+  "paddingRight",
+  "paddingBottom",
+  "paddingLeft",
+  "backgroundColor",
+  "background",
+  "boxShadow",
+  "direction",
+  "overflowX",
+  "overflowY",
+  "zIndex",
+  "color",
+  "fontFamily",
+  "fontSize",
+  "fontWeight",
+  "fontStyle",
+  "textDecoration",
+  "wrapContent",
+  "canShrink",
+  "margin",
+  "marginHorizontal",
+  "marginVertical",
+  "marginTop",
+  "marginRight",
+  "marginBottom",
+  "marginLeft",
+  "userSelect",
+  "letterSpacing",
+  "textTransform",
+  "lineHeight",
+  "opacity",
+  "cursor",
+  "textWrap",
+  "textAlign",
+  "textAlignLast",
+  "top",
+  "right",
+  "bottom",
+  "left",
+  "zoom",
+  "whiteSpace",
+  "textDecoration",
+  "textDecorationLine",
+  "textDecorationColor",
+  "textDecorationStyle",
+  "textDecorationThickness",
+  "textUnderlineOffset",
+  "outline",
+  "outlineWidth",
+  "outlineColor",
+  "outlineStyle",
+  "outlineOffset"
+], Pr = "xmlui", Rr = "xmlui.xs", Fr = "xs";
+var ar = /* @__PURE__ */ ((n) => (n[n.Skip = 0] = "Skip", n[n.Warning = 1] = "Warning", n[n.Error = 2] = "Error", n))(ar || {}), or = /* @__PURE__ */ ((n) => (n[n.UnrecognisedProp = 0] = "UnrecognisedProp", n))(or || {});
+function Ur(n) {
+  if (!n)
+    return 1;
+  switch (n.toLowerCase()) {
+    case "warning":
+      return 1;
+    case "error":
+      return 2;
+    case "skip":
+      return 0;
+    default:
+      return console.warn(`Invalid lint severity option '${n}'. Must be one of: 'warning', 'error', 'skip'. Defaulting to 'warning'.`), 1;
+  }
+}
+function Mr({
+  appDef: n,
+  metadataByComponent: e
+}) {
+  const r = {
+    componentName: "Main",
+    lints: Ae({
+      component: n.entryPoint,
+      metadataByComponent: e
+    })
+  }, t = (n.components ?? []).map((l) => ({ lints: Ae({
+    component: l,
+    metadataByComponent: e
+  }), componentName: l.name }));
+  return [r, ...t].filter((l) => l.lints.length > 0);
+}
+function qr(n) {
+  console.group(`Validation on '${n.componentName}':`), n.lints.forEach(({ message: e }) => {
+    console.warn(e);
+  }), console.groupEnd();
+}
+function $r(n) {
+  function e() {
+    const r = n.map((l, a) => ({
+      type: "VStack",
+      props: { gap: "0px" },
+      children: [
+        {
+          type: "VStack",
+          props: { backgroundColor: "lightgrey", padding: "10px" },
+          children: [
+            {
+              type: "H2",
+              props: {
+                value: `#${a + 1}: In component '${l.componentName}':`,
+                color: "$color-info"
+              }
+            },
+            {
+              type: "VStack",
+              children: l.lints.map(({ message: o }, c) => ({
+                type: "Text",
+                props: { value: `${a + 1}.${c + 1}: ${o}`, fontWeight: "bold" }
+              }))
+            }
+          ]
+        }
+      ]
+    }));
+    return {
+      type: "VStack",
+      props: { padding: "$padding-normal", gap: 0 },
+      children: [
+        {
+          type: "H1",
+          props: {
+            value: "Errors found while checking Xmlui markup",
+            padding: "$padding-normal",
+            backgroundColor: "$color-error",
+            color: "white"
+          }
+        },
+        {
+          type: "VStack",
+          props: {
+            gap: "$gap-tight",
+            padding: "$padding-normal"
+          },
+          children: r
+        }
+      ]
+    };
+  }
+  return e();
+}
+function Ae({
+  component: n,
+  metadataByComponent: e
+}) {
+  return "component" in n ? ce(n.component, e, []) : ce(n, e, []);
+}
+function ce(n, e, r) {
+  const t = n.type.startsWith(se) ? n.type.slice(se.length + 1) : n.type, l = e[t];
+  if (!n.props || !l || !l.props || l.allowArbitraryProps || sr(n, l, r), !n.children)
+    return r;
+  for (const o of n.children)
+    ce(o, e, r);
+  return r;
+}
+const ve = lr;
+function sr(n, e, r) {
+  const l = Object.keys(n.props).filter((a) => !ur(a) && !(a in e.props));
+  for (const a of l)
+    r.push(cr(n, a));
+}
+function cr(n, e) {
+  return {
+    message: `Unrecognised property '${e}' on component '${n.type}'.`,
+    kind: 0
+    /* UnrecognisedProp */
+  };
+}
+function ur(n) {
+  for (const e of ye) {
+    const r = "-" + e.value;
+    if (n.endsWith(r)) {
+      const t = n.slice(0, -r.length);
+      if (ve.includes(t))
+        return !0;
+    }
+  }
+  return ve.includes(n);
+}
+export {
+  Ur as A,
+  ar as B,
+  Mr as C,
+  qr as D,
+  $r as E,
+  Qe as F,
+  Wr as G,
+  xe as H,
+  Fr as I,
+  or as J,
+  Ae as K,
+  fr as L,
+  ue as M,
+  Ze as N,
+  me as O,
+  Ne as P,
+  se as Q,
+  Nr as T,
+  ae as U,
+  Ir as V,
+  Pe as a,
+  Sr as b,
+  Er as c,
+  kr as d,
+  mr as e,
+  De as f,
+  Dr as g,
+  Ue as h,
+  wr as i,
+  gr as j,
+  Lr as k,
+  vr as l,
+  xr as m,
+  Br as n,
+  _r as o,
+  Cr as p,
+  Ar as q,
+  Or as r,
+  Ie as s,
+  yr as t,
+  le as u,
+  br as v,
+  lr as w,
+  pr as x,
+  Pr as y,
+  Rr as z
+};