xmlui 0.8.6 → 0.9.0

package/dist/{lint-B18Ko6Sy.mjs → lint-gX2osbkz.mjs}

@@ -233,6 +233,98 @@ const httpMethodNames = [
   "trace",
   "connect"
 ];
+const T_BLOCK_STATEMENT = 1;
+const T_EMPTY_STATEMENT = 2;
+const T_EXPRESSION_STATEMENT = 3;
+const T_ARROW_EXPRESSION_STATEMENT = 4;
+const T_LET_STATEMENT = 5;
+const T_CONST_STATEMENT = 6;
+const T_VAR_STATEMENT = 7;
+const T_IF_STATEMENT = 8;
+const T_RETURN_STATEMENT = 9;
+const T_BREAK_STATEMENT = 10;
+const T_CONTINUE_STATEMENT = 11;
+const T_WHILE_STATEMENT = 12;
+const T_DO_WHILE_STATEMENT = 13;
+const T_FOR_STATEMENT = 14;
+const T_FOR_IN_STATEMENT = 15;
+const T_FOR_OF_STATEMENT = 16;
+const T_THROW_STATEMENT = 17;
+const T_TRY_STATEMENT = 18;
+const T_SWITCH_STATEMENT = 19;
+const T_FUNCTION_DECLARATION = 20;
+const T_UNARY_EXPRESSION = 100;
+const T_BINARY_EXPRESSION = 101;
+const T_SEQUENCE_EXPRESSION = 102;
+const T_CONDITIONAL_EXPRESSION = 103;
+const T_FUNCTION_INVOCATION_EXPRESSION = 104;
+const T_MEMBER_ACCESS_EXPRESSION = 105;
+const T_CALCULATED_MEMBER_ACCESS_EXPRESSION = 106;
+const T_IDENTIFIER = 107;
+const T_TEMPLATE_LITERAL_EXPRESSION = 108;
+const T_LITERAL = 109;
+const T_ARRAY_LITERAL = 110;
+const T_OBJECT_LITERAL = 111;
+const T_SPREAD_EXPRESSION = 112;
+const T_ASSIGNMENT_EXPRESSION = 113;
+const T_NO_ARG_EXPRESSION = 114;
+const T_ARROW_EXPRESSION = 115;
+const T_PREFIX_OP_EXPRESSION = 116;
+const T_POSTFIX_OP_EXPRESSION = 117;
+const T_REACTIVE_VAR_DECLARATION = 118;
+const T_VAR_DECLARATION = 200;
+const T_DESTRUCTURE = 201;
+const T_ARRAY_DESTRUCTURE = 202;
+const T_OBJECT_DESTRUCTURE = 203;
+const T_SWITCH_CASE = 204;
+class InputStream {
+  // Creates a stream that uses the specified source code
+  constructor(source) {
+    this.source = source;
+    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(n = 1) {
+    return this._pos + n > this.source.length - 1 ? null : this.source[this._pos + n];
+  }
+  // Gets the next character from the stream
+  get() {
+    if (this._pos >= this.source.length) {
+      return null;
+    }
+    const ch = this.source[this._pos++];
+    if (ch === "\n") {
+      this._line++;
+      this._column = 0;
+    } else {
+      this._column++;
+    }
+    return ch;
+  }
+  // Gets the tail of the input stream
+  getTail(start) {
+    var _a;
+    return ((_a = this.source) == null ? void 0 : _a.substring(start)) ?? "";
+  }
+}
 var TokenType = /* @__PURE__ */ ((TokenType2) => {
   TokenType2[TokenType2["Eof"] = -1] = "Eof";
   TokenType2[TokenType2["Ws"] = -2] = "Ws";
@@ -334,166 +426,10 @@ var TokenType = /* @__PURE__ */ ((TokenType2) => {
   TokenType2[TokenType2["Default"] = 93] = "Default";
   TokenType2[TokenType2["Delete"] = 94] = "Delete";
   TokenType2[TokenType2["Function"] = 95] = "Function";
-  TokenType2[TokenType2["Export"] = 96] = "Export";
-  TokenType2[TokenType2["Import"] = 97] = "Import";
-  TokenType2[TokenType2["As"] = 98] = "As";
-  TokenType2[TokenType2["From"] = 99] = "From";
+  TokenType2[TokenType2["As"] = 96] = "As";
+  TokenType2[TokenType2["From"] = 97] = "From";
   return TokenType2;
 })(TokenType || {});
-class InputStream {
-  // Creates a stream that uses the specified source code
-  constructor(source) {
-    this.source = source;
-    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(n = 1) {
-    return this._pos + n > this.source.length - 1 ? null : this.source[this._pos + n];
-  }
-  // Gets the next character from the stream
-  get() {
-    if (this._pos >= this.source.length) {
-      return null;
-    }
-    const ch = this.source[this._pos++];
-    if (ch === "\n") {
-      this._line++;
-      this._column = 0;
-    } else {
-      this._column++;
-    }
-    return ch;
-  }
-  // Gets the tail of the input stream
-  getTail(start) {
-    var _a;
-    return ((_a = this.source) == null ? void 0 : _a.substring(start)) ?? "";
-  }
-}
-const tokenTraits = {
-  [TokenType.Eof]: {},
-  [TokenType.Ws]: {},
-  [TokenType.DollarLBrace]: {},
-  [TokenType.Backtick]: { expressionStart: true },
-  [TokenType.BlockComment]: {},
-  [TokenType.EolComment]: {},
-  [TokenType.Unknown]: {},
-  [TokenType.LParent]: { expressionStart: true },
-  [TokenType.RParent]: {},
-  [TokenType.Identifier]: { expressionStart: true, keywordLike: true, isPropLiteral: true },
-  [TokenType.Exponent]: {},
-  [TokenType.Divide]: {},
-  [TokenType.Multiply]: {},
-  [TokenType.Remainder]: {},
-  [TokenType.Plus]: { expressionStart: true, canBeUnary: true },
-  [TokenType.Minus]: { expressionStart: true, canBeUnary: true },
-  [TokenType.BitwiseXor]: {},
-  [TokenType.BitwiseOr]: {},
-  [TokenType.LogicalOr]: {},
-  [TokenType.BitwiseAnd]: {},
-  [TokenType.LogicalAnd]: {},
-  [TokenType.Assignment]: { isAssignment: true },
-  [TokenType.AddAssignment]: { isAssignment: true },
-  [TokenType.SubtractAssignment]: { isAssignment: true },
-  [TokenType.ExponentAssignment]: { isAssignment: true },
-  [TokenType.MultiplyAssignment]: { isAssignment: true },
-  [TokenType.DivideAssignment]: { isAssignment: true },
-  [TokenType.RemainderAssignment]: { isAssignment: true },
-  [TokenType.ShiftLeftAssignment]: { isAssignment: true },
-  [TokenType.ShiftRightAssignment]: { isAssignment: true },
-  [TokenType.SignedShiftRightAssignment]: { isAssignment: true },
-  [TokenType.BitwiseAndAssignment]: { isAssignment: true },
-  [TokenType.BitwiseXorAssignment]: { isAssignment: true },
-  [TokenType.BitwiseOrAssignment]: { isAssignment: true },
-  [TokenType.LogicalAndAssignment]: { isAssignment: true },
-  [TokenType.LogicalOrAssignment]: { isAssignment: true },
-  [TokenType.NullCoalesceAssignment]: { isAssignment: true },
-  [TokenType.Semicolon]: {},
-  [TokenType.Comma]: {},
-  [TokenType.Colon]: {},
-  [TokenType.LSquare]: { expressionStart: true },
-  [TokenType.RSquare]: {},
-  [TokenType.QuestionMark]: {},
-  [TokenType.NullCoalesce]: {},
-  [TokenType.OptionalChaining]: {},
-  [TokenType.BinaryNot]: { expressionStart: true, canBeUnary: true },
-  [TokenType.LBrace]: { expressionStart: true },
-  [TokenType.RBrace]: {},
-  [TokenType.Equal]: {},
-  [TokenType.StrictEqual]: {},
-  [TokenType.LogicalNot]: { expressionStart: true, canBeUnary: true },
-  [TokenType.NotEqual]: {},
-  [TokenType.StrictNotEqual]: {},
-  [TokenType.LessThan]: {},
-  [TokenType.LessThanOrEqual]: {},
-  [TokenType.ShiftLeft]: {},
-  [TokenType.GreaterThan]: {},
-  [TokenType.GreaterThanOrEqual]: {},
-  [TokenType.ShiftRight]: {},
-  [TokenType.SignedShiftRight]: {},
-  [TokenType.Dot]: {},
-  [TokenType.Spread]: { expressionStart: true, isPropLiteral: true },
-  [TokenType.Global]: { expressionStart: true },
-  [TokenType.DecimalLiteral]: { expressionStart: true, isPropLiteral: true },
-  [TokenType.HexadecimalLiteral]: { expressionStart: true, isPropLiteral: true },
-  [TokenType.BinaryLiteral]: { expressionStart: true, isPropLiteral: true },
-  [TokenType.RealLiteral]: { expressionStart: true, isPropLiteral: true },
-  [TokenType.StringLiteral]: { expressionStart: true, isPropLiteral: true },
-  [TokenType.IncOp]: { expressionStart: true },
-  [TokenType.DecOp]: { expressionStart: true },
-  [TokenType.Infinity]: { expressionStart: true, keywordLike: true },
-  [TokenType.NaN]: { expressionStart: true, keywordLike: true },
-  [TokenType.True]: { expressionStart: true, keywordLike: true, isPropLiteral: true },
-  [TokenType.False]: { expressionStart: true, keywordLike: true, isPropLiteral: true },
-  [TokenType.Typeof]: { expressionStart: true, canBeUnary: true, keywordLike: true },
-  [TokenType.Null]: { expressionStart: true, keywordLike: true },
-  [TokenType.Undefined]: { expressionStart: true, keywordLike: true },
-  [TokenType.In]: { keywordLike: true },
-  [TokenType.Let]: { keywordLike: true },
-  [TokenType.Const]: { keywordLike: true },
-  [TokenType.Var]: { keywordLike: true },
-  [TokenType.If]: { keywordLike: true },
-  [TokenType.Else]: { keywordLike: true },
-  [TokenType.Arrow]: { keywordLike: true },
-  [TokenType.Return]: { keywordLike: true },
-  [TokenType.Break]: { keywordLike: true },
-  [TokenType.Continue]: { keywordLike: true },
-  [TokenType.Do]: { keywordLike: true },
-  [TokenType.While]: { keywordLike: true },
-  [TokenType.For]: { keywordLike: true },
-  [TokenType.Of]: { keywordLike: true },
-  [TokenType.Throw]: { keywordLike: true },
-  [TokenType.Try]: { keywordLike: true },
-  [TokenType.Catch]: { keywordLike: true },
-  [TokenType.Finally]: { keywordLike: true },
-  [TokenType.Switch]: { keywordLike: true },
-  [TokenType.Case]: { keywordLike: true },
-  [TokenType.Default]: { keywordLike: true },
-  [TokenType.Delete]: { expressionStart: true, canBeUnary: true, keywordLike: true },
-  [TokenType.Function]: { keywordLike: true, expressionStart: true },
-  [TokenType.Export]: { keywordLike: true },
-  [TokenType.Import]: { keywordLike: true },
-  [TokenType.As]: { keywordLike: true },
-  [TokenType.From]: { keywordLike: true }
-};
 class Lexer {
   /**
    * Initializes the tokenizer with the input stream
@@ -564,15 +500,14 @@ class Lexer {
    * 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);
+    return this._ahead.length > 0 ? this.input.getTail(this._ahead[0].startPosition) : this.input.getTail(this._lastFetchPosition);
   }
-  /**
-   * Parsing template literals requires a context sensitive lexer.
+  /** 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;
+    this._phaseExternallySet = 34;
   }
   /**
    * Fetches the next character from the input stream
@@ -728,17 +663,6 @@ class Lexer {
               break;
           }
           break;
-        case 6:
-          if (ch === "{") {
-            return completeToken(TokenType.DollarLBrace);
-          }
-          phase = 17;
-          useResolver = true;
-          tokenType = TokenType.Identifier;
-          if (!isIdContinuation(ch)) {
-            makeToken();
-          }
-          break;
         case 1:
           if (ch !== " " && ch !== "	" && ch !== "\r" && ch !== "\n") {
             return makeToken();
@@ -1012,8 +936,19 @@ class Lexer {
             return makeToken();
           }
           break;
-        case 34: {
-          phase = 33;
+        case 6:
+          if (ch === "{") {
+            return completeToken(TokenType.DollarLBrace);
+          }
+          phase = 17;
+          useResolver = true;
+          tokenType = TokenType.Identifier;
+          if (!isIdContinuation(ch)) {
+            makeToken();
+          }
+          break;
+        case 33: {
+          phase = 34;
           const charAhead12 = this.input.ahead(0);
           const charAhead22 = this.input.ahead(1);
           if (charAhead12 === "`" || charAhead12 === "$" && charAhead22 === "{") {
@@ -1021,10 +956,10 @@ class Lexer {
           }
           break;
         }
-        case 33:
+        case 34:
           switch (ch) {
             case "\\":
-              phase = 34;
+              phase = 33;
               tokenType = TokenType.Unknown;
               break phaseSwitch;
             case "`":
@@ -1205,14 +1140,12 @@ class Lexer {
       return {
         text,
         type: tokenType,
-        location: {
-          startPosition: startPos,
-          endPosition: lastEndPos,
-          startLine: line,
-          endLine: line,
-          startColumn,
-          endColumn: lastEndColumn
-        }
+        startPosition: startPos,
+        endPosition: lastEndPos,
+        startLine: line,
+        endLine: line,
+        startColumn,
+        endColumn: lastEndColumn
       };
     }
     function completeToken(suggestedType) {
@@ -1235,7 +1168,7 @@ class Lexer {
    * Fetches the next RegEx token from the input stream
    */
   fetchRegEx() {
-    const tailPosition = this._ahead.length > 0 ? this._ahead[0].location.startPosition : this._lastFetchPosition;
+    const tailPosition = this._ahead.length > 0 ? this._ahead[0].startPosition : this._lastFetchPosition;
     const tail = this.input.getTail(tailPosition);
     try {
       const regexpResult = parseRegExpLiteral(tail);
@@ -1322,8 +1255,6 @@ resolverHash.set("case", TokenType.Case);
 resolverHash.set("default", TokenType.Default);
 resolverHash.set("delete", TokenType.Delete);
 resolverHash.set("function", TokenType.Function);
-resolverHash.set("export", TokenType.Export);
-resolverHash.set("import", TokenType.Import);
 resolverHash.set("as", TokenType.As);
 resolverHash.set("from", TokenType.From);
 function isEof(t) {
@@ -1381,24 +1312,138 @@ const errorMessages$1 = {
   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",
+  W024: "'function' 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",
+  W027: "Cannot declare var ('{0}') in an imported 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 '$'"
 };
+const tokenTraits = {
+  [TokenType.Eof]: {},
+  [TokenType.Ws]: {},
+  [TokenType.DollarLBrace]: {},
+  [TokenType.Backtick]: { expressionStart: true },
+  [TokenType.BlockComment]: {},
+  [TokenType.EolComment]: {},
+  [TokenType.Unknown]: {},
+  [TokenType.LParent]: { expressionStart: true },
+  [TokenType.RParent]: {},
+  [TokenType.Identifier]: { expressionStart: true, keywordLike: true, isPropLiteral: true },
+  [TokenType.Exponent]: {},
+  [TokenType.Divide]: {},
+  [TokenType.Multiply]: {},
+  [TokenType.Remainder]: {},
+  [TokenType.Plus]: { expressionStart: true, canBeUnary: true },
+  [TokenType.Minus]: { expressionStart: true, canBeUnary: true },
+  [TokenType.BitwiseXor]: {},
+  [TokenType.BitwiseOr]: {},
+  [TokenType.LogicalOr]: {},
+  [TokenType.BitwiseAnd]: {},
+  [TokenType.LogicalAnd]: {},
+  [TokenType.Assignment]: { isAssignment: true },
+  [TokenType.AddAssignment]: { isAssignment: true },
+  [TokenType.SubtractAssignment]: { isAssignment: true },
+  [TokenType.ExponentAssignment]: { isAssignment: true },
+  [TokenType.MultiplyAssignment]: { isAssignment: true },
+  [TokenType.DivideAssignment]: { isAssignment: true },
+  [TokenType.RemainderAssignment]: { isAssignment: true },
+  [TokenType.ShiftLeftAssignment]: { isAssignment: true },
+  [TokenType.ShiftRightAssignment]: { isAssignment: true },
+  [TokenType.SignedShiftRightAssignment]: { isAssignment: true },
+  [TokenType.BitwiseAndAssignment]: { isAssignment: true },
+  [TokenType.BitwiseXorAssignment]: { isAssignment: true },
+  [TokenType.BitwiseOrAssignment]: { isAssignment: true },
+  [TokenType.LogicalAndAssignment]: { isAssignment: true },
+  [TokenType.LogicalOrAssignment]: { isAssignment: true },
+  [TokenType.NullCoalesceAssignment]: { isAssignment: true },
+  [TokenType.Semicolon]: {},
+  [TokenType.Comma]: {},
+  [TokenType.Colon]: {},
+  [TokenType.LSquare]: { expressionStart: true },
+  [TokenType.RSquare]: {},
+  [TokenType.QuestionMark]: {},
+  [TokenType.NullCoalesce]: {},
+  [TokenType.OptionalChaining]: {},
+  [TokenType.BinaryNot]: { expressionStart: true, canBeUnary: true },
+  [TokenType.LBrace]: { expressionStart: true },
+  [TokenType.RBrace]: {},
+  [TokenType.Equal]: {},
+  [TokenType.StrictEqual]: {},
+  [TokenType.LogicalNot]: { expressionStart: true, canBeUnary: true },
+  [TokenType.NotEqual]: {},
+  [TokenType.StrictNotEqual]: {},
+  [TokenType.LessThan]: {},
+  [TokenType.LessThanOrEqual]: {},
+  [TokenType.ShiftLeft]: {},
+  [TokenType.GreaterThan]: {},
+  [TokenType.GreaterThanOrEqual]: {},
+  [TokenType.ShiftRight]: {},
+  [TokenType.SignedShiftRight]: {},
+  [TokenType.Dot]: {},
+  [TokenType.Spread]: { expressionStart: true, isPropLiteral: true },
+  [TokenType.Global]: { expressionStart: true },
+  [TokenType.DecimalLiteral]: { expressionStart: true, isPropLiteral: true },
+  [TokenType.HexadecimalLiteral]: { expressionStart: true, isPropLiteral: true },
+  [TokenType.BinaryLiteral]: { expressionStart: true, isPropLiteral: true },
+  [TokenType.RealLiteral]: { expressionStart: true, isPropLiteral: true },
+  [TokenType.StringLiteral]: { expressionStart: true, isPropLiteral: true },
+  [TokenType.IncOp]: { expressionStart: true },
+  [TokenType.DecOp]: { expressionStart: true },
+  [TokenType.Infinity]: { expressionStart: true, keywordLike: true },
+  [TokenType.NaN]: { expressionStart: true, keywordLike: true },
+  [TokenType.True]: { expressionStart: true, keywordLike: true, isPropLiteral: true },
+  [TokenType.False]: { expressionStart: true, keywordLike: true, isPropLiteral: true },
+  [TokenType.Typeof]: { expressionStart: true, canBeUnary: true, keywordLike: true },
+  [TokenType.Null]: { expressionStart: true, keywordLike: true },
+  [TokenType.Undefined]: { expressionStart: true, keywordLike: true },
+  [TokenType.In]: { keywordLike: true },
+  [TokenType.Let]: { keywordLike: true },
+  [TokenType.Const]: { keywordLike: true },
+  [TokenType.Var]: { keywordLike: true },
+  [TokenType.If]: { keywordLike: true },
+  [TokenType.Else]: { keywordLike: true },
+  [TokenType.Arrow]: { keywordLike: true },
+  [TokenType.Return]: { keywordLike: true },
+  [TokenType.Break]: { keywordLike: true },
+  [TokenType.Continue]: { keywordLike: true },
+  [TokenType.Do]: { keywordLike: true },
+  [TokenType.While]: { keywordLike: true },
+  [TokenType.For]: { keywordLike: true },
+  [TokenType.Of]: { keywordLike: true },
+  [TokenType.Throw]: { keywordLike: true },
+  [TokenType.Try]: { keywordLike: true },
+  [TokenType.Catch]: { keywordLike: true },
+  [TokenType.Finally]: { keywordLike: true },
+  [TokenType.Switch]: { keywordLike: true },
+  [TokenType.Case]: { keywordLike: true },
+  [TokenType.Default]: { keywordLike: true },
+  [TokenType.Delete]: { expressionStart: true, canBeUnary: true, keywordLike: true },
+  [TokenType.Function]: { keywordLike: true, expressionStart: true },
+  [TokenType.As]: { keywordLike: true },
+  [TokenType.From]: { keywordLike: true }
+};
+let lastNodeId = 0;
+function createXmlUiTreeNodeId() {
+  return ++lastNodeId;
+}
 class Parser {
   /**
    * Initializes the parser with the specified source code
    * @param source Source code to parse
    */
   constructor(source) {
-    this.source = source;
     this._parseErrors = [];
     this._statementLevel = 0;
+    this._lexer = new Lexer(new InputStream(source ?? ""));
+  }
+  /**
+   * Sets the source code to parse
+   * @param source Source code to parse
+   */
+  setSource(source) {
     this._lexer = new Lexer(new InputStream(source));
   }
   /**
@@ -1448,7 +1493,7 @@ class Parser {
       const statement = this.parseStatement();
       if (!statement) return null;
       statements.push(statement);
-      if (statement.type !== "EmptyS") {
+      if (statement.type !== T_EMPTY_STATEMENT) {
         this.skipToken(TokenType.Semicolon);
       }
     }
@@ -1482,10 +1527,20 @@ class Parser {
           return this.parseReturnStatement();
         case TokenType.Break:
           this._lexer.get();
-          return this.createStatementNode("BrkS", {}, startToken, startToken);
+          return this.createStatementNode(
+            T_BREAK_STATEMENT,
+            {},
+            startToken,
+            startToken
+          );
         case TokenType.Continue:
           this._lexer.get();
-          return this.createStatementNode("ContS", {}, startToken, startToken);
+          return this.createStatementNode(
+            T_CONTINUE_STATEMENT,
+            {},
+            startToken,
+            startToken
+          );
         case TokenType.For:
           return this.parseForStatement();
         case TokenType.Throw:
@@ -1496,20 +1551,8 @@ class Parser {
           return this.parseSwitchStatement();
         case TokenType.Function:
           return this.parseFunctionDeclaration();
-        case TokenType.Export:
-          return this.parseExport();
-        case TokenType.Import:
-          return this.parseImport();
         default:
-          if (startToken.type === TokenType.Eof) {
-            this.reportError("W002", startToken, "EOF");
-            return null;
-          }
-          if (this.isExpressionStart(startToken)) {
-            return this.parseExpressionStatement(allowSequence);
-          }
-          this.reportError("W002", startToken, startToken.text);
-          return null;
+          return this.isExpressionStart(startToken) ? this.parseExpressionStatement(allowSequence) : null;
       }
     } finally {
       this._statementLevel--;
@@ -1524,7 +1567,7 @@ class Parser {
    */
   parseEmptyStatement() {
     const startToken = this._lexer.get();
-    return this.createStatementNode("EmptyS", {}, startToken, startToken);
+    return this.createStatementNode(T_EMPTY_STATEMENT, {}, startToken, startToken);
   }
   /**
    * Parses an expression statement
@@ -1535,14 +1578,14 @@ class Parser {
    */
   parseExpressionStatement(allowSequence = true) {
     const startToken = this._lexer.peek();
-    const expression = this.getExpression(allowSequence);
-    return expression ? this.createStatementNode(
-      "ExprS",
+    const expr = this.getExpression(allowSequence);
+    return expr ? this.createStatementNode(
+      T_EXPRESSION_STATEMENT,
       {
-        expression
+        expr
       },
       startToken,
-      expression.endToken
+      expr.endToken
     ) : null;
   }
   /**
@@ -1555,26 +1598,26 @@ class Parser {
   parseLetStatement() {
     const startToken = this._lexer.get();
     let endToken = startToken;
-    const declarations = [];
+    const decls = [];
     while (true) {
       const declStart = this._lexer.peek();
       let declarationProps = {};
       if (declStart.type === TokenType.LBrace) {
         endToken = this._lexer.ahead(1);
-        const objectDestruct = this.parseObjectDestructure();
-        if (objectDestruct === null) return null;
+        const oDestr = this.parseObjectDestructure();
+        if (oDestr === null) return null;
         declarationProps = {
-          objectDestruct
+          oDestr
         };
-        endToken = objectDestruct.length > 0 ? objectDestruct[objectDestruct.length - 1].endToken : endToken;
+        endToken = oDestr.length > 0 ? oDestr[oDestr.length - 1].endToken : endToken;
       } else if (declStart.type === TokenType.LSquare) {
         endToken = this._lexer.ahead(1);
-        const arrayDestruct = this.parseArrayDestructure();
-        if (arrayDestruct === null) return null;
+        const aDestr = this.parseArrayDestructure();
+        if (aDestr === null) return null;
         declarationProps = {
-          arrayDestruct
+          aDestr
         };
-        endToken = arrayDestruct.length > 0 ? arrayDestruct[arrayDestruct.length - 1].endToken : endToken;
+        endToken = aDestr.length > 0 ? aDestr[aDestr.length - 1].endToken : endToken;
       } else if (declStart.type === TokenType.Identifier) {
         if (declStart.text.startsWith("$")) {
           this.reportError("W031");
@@ -1589,27 +1632,32 @@ class Parser {
         return null;
       }
       const initToken = this._lexer.peek();
-      let expression = null;
+      let expr = null;
       if (initToken.type === TokenType.Assignment) {
         this._lexer.get();
-        expression = this.getExpression(false);
-        if (expression === null) return null;
-        declarationProps.expression = expression;
-        endToken = expression.endToken;
-      } else if (declarationProps.arrayDestruct || declarationProps.objectDestruct) {
+        expr = this.getExpression(false);
+        if (expr === null) return null;
+        declarationProps.expr = expr;
+        endToken = expr.endToken;
+      } else if (declarationProps.aDestr || declarationProps.oDestr) {
         this.reportError("W009", initToken);
         return null;
       }
-      declarations.push(
-        this.createExpressionNode("VarD", declarationProps, declStart, endToken)
+      decls.push(
+        this.createExpressionNode(
+          T_VAR_DECLARATION,
+          declarationProps,
+          declStart,
+          endToken
+        )
       );
       if (this._lexer.peek().type !== TokenType.Comma) break;
       this._lexer.get();
     }
     return this.createStatementNode(
-      "LetS",
+      T_LET_STATEMENT,
       {
-        declarations
+        decls
       },
       startToken,
       endToken
@@ -1625,26 +1673,26 @@ class Parser {
   parseConstStatement() {
     const startToken = this._lexer.get();
     let endToken = startToken;
-    const declarations = [];
+    const decls = [];
     while (true) {
       const declStart = this._lexer.peek();
       let declarationProps = {};
       if (declStart.type === TokenType.LBrace) {
         endToken = this._lexer.ahead(1);
-        const objectDestruct = this.parseObjectDestructure();
-        if (objectDestruct === null) return null;
+        const oDestr = this.parseObjectDestructure();
+        if (oDestr === null) return null;
         declarationProps = {
-          objectDestruct
+          oDestr
         };
-        endToken = objectDestruct.length > 0 ? objectDestruct[objectDestruct.length - 1].endToken : endToken;
+        endToken = oDestr.length > 0 ? oDestr[oDestr.length - 1].endToken : endToken;
       } else if (declStart.type === TokenType.LSquare) {
         endToken = this._lexer.ahead(1);
-        const arrayDestruct = this.parseArrayDestructure();
-        if (arrayDestruct === null) return null;
+        const aDestr = this.parseArrayDestructure();
+        if (aDestr === null) return null;
         declarationProps = {
-          arrayDestruct
+          aDestr
         };
-        endToken = arrayDestruct.length > 0 ? arrayDestruct[arrayDestruct.length - 1].endToken : endToken;
+        endToken = aDestr.length > 0 ? aDestr[aDestr.length - 1].endToken : endToken;
       } else if (declStart.type === TokenType.Identifier) {
         if (declStart.text.startsWith("$")) {
           this.reportError("W031");
@@ -1659,27 +1707,32 @@ class Parser {
         return null;
       }
       this.expectToken(TokenType.Assignment);
-      const expression = this.getExpression(false);
-      if (expression === null) return null;
-      declarationProps.expression = expression;
-      endToken = expression.endToken;
-      declarations.push(
-        this.createExpressionNode("VarD", declarationProps, declStart, endToken)
+      const expr = this.getExpression(false);
+      if (expr === null) return null;
+      declarationProps.expr = expr;
+      endToken = expr.endToken;
+      decls.push(
+        this.createExpressionNode(
+          T_VAR_DECLARATION,
+          declarationProps,
+          declStart,
+          endToken
+        )
       );
       if (this._lexer.peek().type !== TokenType.Comma) break;
       this._lexer.get();
     }
     return this.createStatementNode(
-      "ConstS",
+      T_CONST_STATEMENT,
       {
-        declarations
+        decls
       },
       startToken,
       endToken
     );
   }
   /**
-   * Parses a const statement
+   * Parses a var statement
    *
    * constStatement
    *   : "var" id "=" expression
@@ -1688,7 +1741,7 @@ class Parser {
   parseVarStatement() {
     const startToken = this._lexer.get();
     let endToken = startToken;
-    const declarations = [];
+    const decls = [];
     while (true) {
       const declStart = this._lexer.peek();
       let declarationProps = {};
@@ -1699,20 +1752,25 @@ class Parser {
         }
         endToken = this._lexer.get();
         declarationProps = {
-          id: declStart.text
+          id: {
+            type: T_IDENTIFIER,
+            name: declStart.text,
+            startToken: declStart,
+            endToken
+          }
         };
       } else {
         this.reportError("W003");
         return null;
       }
       this.expectToken(TokenType.Assignment);
-      const expression = this.getExpression(false);
-      if (expression === null) return null;
-      declarationProps.expression = expression;
-      endToken = expression.endToken;
-      declarations.push(
+      const expr = this.getExpression(false);
+      if (expr === null) return null;
+      declarationProps.expr = expr;
+      endToken = expr.endToken;
+      decls.push(
         this.createExpressionNode(
-          "RVarD",
+          T_REACTIVE_VAR_DECLARATION,
           declarationProps,
           declStart,
           endToken
@@ -1722,9 +1780,9 @@ class Parser {
       this._lexer.get();
     }
     return this.createStatementNode(
-      "VarS",
+      T_VAR_STATEMENT,
       {
-        declarations
+        decls
       },
       startToken,
       endToken
@@ -1745,8 +1803,8 @@ class Parser {
         return null;
       }
       let alias;
-      let arrayDestruct;
-      let objectDestruct;
+      let aDestr;
+      let oDestr;
       this._lexer.get();
       nextToken = this._lexer.peek();
       if (nextToken.type === TokenType.Colon) {
@@ -1757,21 +1815,21 @@ class Parser {
           endToken = nextToken;
           this._lexer.get();
         } else if (nextToken.type === TokenType.LSquare) {
-          arrayDestruct = this.parseArrayDestructure();
-          if (arrayDestruct === null) return null;
-          endToken = arrayDestruct[arrayDestruct.length - 1].endToken;
+          aDestr = this.parseArrayDestructure();
+          if (aDestr === null) return null;
+          endToken = aDestr[aDestr.length - 1].endToken;
         } else if (nextToken.type === TokenType.LBrace) {
-          objectDestruct = this.parseObjectDestructure();
-          if (objectDestruct === null) return null;
-          endToken = objectDestruct[objectDestruct.length - 1].endToken;
+          oDestr = this.parseObjectDestructure();
+          if (oDestr === null) return null;
+          endToken = oDestr[oDestr.length - 1].endToken;
         }
       }
       nextToken = this._lexer.peek();
       if (nextToken.type === TokenType.Comma || nextToken.type === TokenType.RBrace) {
         result.push(
           this.createExpressionNode(
-            "ODestr",
-            { id, alias, arrayDestruct, objectDestruct },
+            T_OBJECT_DESTRUCTURE,
+            { id, alias, aDestr, oDestr },
             startToken,
             endToken
           )
@@ -1792,8 +1850,8 @@ class Parser {
     do {
       let nextToken = this._lexer.peek();
       let id;
-      let arrayDestruct;
-      let objectDestruct;
+      let aDestr;
+      let oDestr;
       if (nextToken.type === TokenType.Identifier) {
         id = nextToken.text;
         if (id.startsWith("$")) {
@@ -1803,31 +1861,31 @@ class Parser {
         endToken = nextToken;
         nextToken = this._lexer.get();
       } else if (nextToken.type === TokenType.LSquare) {
-        arrayDestruct = this.parseArrayDestructure();
-        if (arrayDestruct === null) return null;
-        endToken = arrayDestruct[arrayDestruct.length - 1].endToken;
+        aDestr = this.parseArrayDestructure();
+        if (aDestr === null) return null;
+        endToken = aDestr[aDestr.length - 1].endToken;
       } else if (nextToken.type === TokenType.LBrace) {
-        objectDestruct = this.parseObjectDestructure();
-        if (objectDestruct === null) return null;
-        endToken = objectDestruct[objectDestruct.length - 1].endToken;
+        oDestr = this.parseObjectDestructure();
+        if (oDestr === null) return null;
+        endToken = oDestr[oDestr.length - 1].endToken;
       }
       nextToken = this._lexer.peek();
       if (nextToken.type === TokenType.Comma) {
         result.push(
           this.createExpressionNode(
-            "ADestr",
-            { id, arrayDestruct, objectDestruct },
+            T_ARRAY_DESTRUCTURE,
+            { id, aDestr, oDestr },
             startToken,
             endToken
           )
         );
         this._lexer.get();
       } else if (nextToken.type === TokenType.RSquare) {
-        if (id || arrayDestruct || objectDestruct) {
+        if (id || aDestr || oDestr) {
           result.push(
             this.createExpressionNode(
-              "ADestr",
-              { id, arrayDestruct, objectDestruct },
+              T_ARRAY_DESTRUCTURE,
+              { id, aDestr, oDestr },
               startToken,
               endToken
             )
@@ -1851,17 +1909,22 @@ class Parser {
    */
   parseBlockStatement() {
     const startToken = this._lexer.get();
-    const statements = [];
+    const stmts = [];
     while (this._lexer.peek().type !== TokenType.RBrace) {
       const statement = this.parseStatement();
       if (!statement) return null;
-      statements.push(statement);
-      if (statement.type !== "EmptyS") {
+      stmts.push(statement);
+      if (statement.type !== T_EMPTY_STATEMENT) {
         this.skipToken(TokenType.Semicolon);
       }
     }
     const endToken = this._lexer.get();
-    return this.createStatementNode("BlockS", { statements }, startToken, endToken);
+    return this.createStatementNode(
+      T_BLOCK_STATEMENT,
+      { stmts },
+      startToken,
+      endToken
+    );
   }
   /**
    * Parses an if statement
@@ -1874,33 +1937,33 @@ class Parser {
     const startToken = this._lexer.get();
     let endToken = startToken;
     this.expectToken(TokenType.LParent, "W014");
-    const condition = this.getExpression();
-    if (!condition) return null;
+    const cond = this.getExpression();
+    if (!cond) return null;
     this.expectToken(TokenType.RParent, "W006");
-    const thenBranch = this.parseStatement();
-    if (!thenBranch) return null;
-    endToken = thenBranch.endToken;
+    const thenB = this.parseStatement();
+    if (!thenB) return null;
+    endToken = thenB.endToken;
     let elseCanFollow = true;
-    if (thenBranch.type !== "BlockS") {
+    if (thenB.type !== T_BLOCK_STATEMENT) {
       if (this._lexer.peek().type === TokenType.Semicolon) {
         this._lexer.get();
       } else {
         elseCanFollow = false;
       }
     }
-    let elseBranch = null;
+    let elseB = null;
     if (elseCanFollow && this._lexer.peek().type === TokenType.Else) {
       this._lexer.get();
-      elseBranch = this.parseStatement();
-      if (!elseBranch) return null;
-      endToken = elseBranch.endToken;
+      elseB = this.parseStatement();
+      if (!elseB) return null;
+      endToken = elseB.endToken;
     }
     return this.createStatementNode(
-      "IfS",
+      T_IF_STATEMENT,
       {
-        condition,
-        thenBranch,
-        elseBranch
+        cond,
+        thenB,
+        elseB
       },
       startToken,
       endToken
@@ -1916,15 +1979,15 @@ class Parser {
   parseWhileStatement() {
     const startToken = this._lexer.get();
     this.expectToken(TokenType.LParent, "W014");
-    const condition = this.getExpression();
-    if (!condition) return null;
+    const cond = this.getExpression();
+    if (!cond) return null;
     this.expectToken(TokenType.RParent, "W006");
     const body = this.parseStatement();
     if (!body) return null;
     return this.createStatementNode(
-      "WhileS",
+      T_WHILE_STATEMENT,
       {
-        condition,
+        cond,
         body
       },
       startToken,
@@ -1942,19 +2005,19 @@ class Parser {
     const startToken = this._lexer.get();
     const body = this.parseStatement();
     if (!body) return null;
-    if (body.type !== "BlockS" && body.type !== "EmptyS") {
+    if (body.type !== T_BLOCK_STATEMENT && body.type !== T_EMPTY_STATEMENT) {
       this.expectToken(TokenType.Semicolon);
     }
     this.expectToken(TokenType.While);
     this.expectToken(TokenType.LParent, "W014");
-    const condition = this.getExpression();
-    if (!condition) return null;
+    const cond = this.getExpression();
+    if (!cond) return null;
     const endToken = this._lexer.peek();
     this.expectToken(TokenType.RParent, "W006");
     return this.createStatementNode(
-      "DoWS",
+      T_DO_WHILE_STATEMENT,
       {
-        condition,
+        cond,
         body
       },
       startToken,
@@ -1971,16 +2034,16 @@ class Parser {
   parseReturnStatement() {
     const startToken = this._lexer.peek();
     let endToken = this._lexer.get();
-    let expression;
+    let expr;
     if (tokenTraits[this._lexer.peek().type].expressionStart) {
-      expression = this.getExpression();
-      if (expression === null) return null;
-      endToken = expression.endToken;
+      expr = this.getExpression();
+      if (expr === null) return null;
+      endToken = expr.endToken;
     }
     return this.createStatementNode(
-      "RetS",
+      T_RETURN_STATEMENT,
       {
-        expression
+        expr
       },
       startToken,
       endToken
@@ -1999,18 +2062,18 @@ class Parser {
     let nextToken = this._lexer.peek();
     if (nextToken.type === TokenType.Identifier) {
       if (this._lexer.ahead(1).type === TokenType.In) {
-        return this.parseForInOfStatement(startToken, "none", nextToken.text, "ForInS");
+        return this.parseForInOfStatement(startToken, "none", nextToken, T_FOR_IN_STATEMENT);
       } else if (this._lexer.ahead(1).type === TokenType.Of) {
-        return this.parseForInOfStatement(startToken, "none", nextToken.text, "ForOfS");
+        return this.parseForInOfStatement(startToken, "none", nextToken, T_FOR_OF_STATEMENT);
       }
     } else if (nextToken.type === TokenType.Let) {
       const idToken = this._lexer.ahead(1);
       if (idToken.type === TokenType.Identifier) {
         const inOfToken = this._lexer.ahead(2);
         if (inOfToken.type === TokenType.In) {
-          return this.parseForInOfStatement(startToken, "let", idToken.text, "ForInS");
+          return this.parseForInOfStatement(startToken, "let", idToken, T_FOR_IN_STATEMENT);
         } else if (inOfToken.type === TokenType.Of) {
-          return this.parseForInOfStatement(startToken, "let", idToken.text, "ForOfS");
+          return this.parseForInOfStatement(startToken, "let", idToken, T_FOR_OF_STATEMENT);
         }
       }
     } else if (nextToken.type === TokenType.Const) {
@@ -2018,9 +2081,9 @@ class Parser {
       if (idToken.type === TokenType.Identifier) {
         const inOfToken = this._lexer.ahead(2);
         if (inOfToken.type === TokenType.In) {
-          return this.parseForInOfStatement(startToken, "const", idToken.text, "ForInS");
+          return this.parseForInOfStatement(startToken, "const", idToken, T_FOR_IN_STATEMENT);
         } else if (inOfToken.type === TokenType.Of) {
-          return this.parseForInOfStatement(startToken, "const", idToken.text, "ForOfS");
+          return this.parseForInOfStatement(startToken, "const", idToken, T_FOR_OF_STATEMENT);
         }
       }
     }
@@ -2034,7 +2097,7 @@ class Parser {
         return null;
       }
       init = letStmt;
-      if (init.declarations.some((d) => !d.expression)) {
+      if (init.decls.some((d) => !d.expr)) {
         this.reportError("W011");
         return null;
       }
@@ -2047,22 +2110,22 @@ class Parser {
       init = exprStmt;
       this.expectToken(TokenType.Semicolon);
     }
-    let condition;
+    let cond;
     nextToken = this._lexer.peek();
     if (nextToken.type === TokenType.Semicolon) {
       this._lexer.get();
     } else {
-      condition = this.getExpression();
-      if (condition === null) {
+      cond = this.getExpression();
+      if (cond === null) {
         return null;
       }
       this.expectToken(TokenType.Semicolon);
     }
-    let update;
+    let upd;
     nextToken = this._lexer.peek();
     if (nextToken.type !== TokenType.RParent) {
-      update = this.getExpression();
-      if (update === null) {
+      upd = this.getExpression();
+      if (upd === null) {
         return null;
       }
     }
@@ -2070,11 +2133,11 @@ class Parser {
     const body = this.parseStatement();
     if (!body) return null;
     return this.createStatementNode(
-      "ForS",
+      T_FOR_STATEMENT,
       {
         init,
-        condition,
-        update,
+        cond,
+        upd,
         body
       },
       startToken,
@@ -2088,13 +2151,13 @@ class Parser {
    *   ;
    *
    * @param startToken Statement start token
-   * @param varBinding Variable binding of the for..in/of statement
+   * @param varB Variable binding of the for..in/of statement
    * @param id ID name
    * @param type Is it a for..in or a for..of?
    */
-  parseForInOfStatement(startToken, varBinding, id, type) {
-    if (varBinding !== "none") {
-      if (id.startsWith("$")) {
+  parseForInOfStatement(startToken, varB, idToken, type) {
+    if (varB !== "none") {
+      if (idToken.text.startsWith("$")) {
         this.reportError("W031");
         return null;
       }
@@ -2102,26 +2165,36 @@ class Parser {
     }
     this._lexer.get();
     this._lexer.get();
-    const expression = this.getExpression(true);
+    const expr = this.getExpression(true);
     this.expectToken(TokenType.RParent, "W006");
     const body = this.parseStatement();
     if (!body) return null;
-    return type === "ForInS" ? this.createStatementNode(
-      "ForInS",
+    return type === T_FOR_IN_STATEMENT ? this.createStatementNode(
+      T_FOR_IN_STATEMENT,
       {
-        varBinding,
-        id,
-        expression,
+        varB,
+        id: {
+          type: T_IDENTIFIER,
+          name: idToken.text,
+          startToken: idToken,
+          endToken: idToken
+        },
+        expr,
         body
       },
       startToken,
       body.endToken
     ) : this.createStatementNode(
-      "ForOfS",
+      T_FOR_OF_STATEMENT,
       {
-        varBinding,
-        id,
-        expression,
+        varB,
+        id: {
+          type: T_IDENTIFIER,
+          name: idToken.text,
+          startToken: idToken,
+          endToken: idToken
+        },
+        expr,
         body
       },
       startToken,
@@ -2138,16 +2211,16 @@ class Parser {
   parseThrowStatement() {
     const startToken = this._lexer.peek();
     this._lexer.get();
-    let expression;
-    expression = this.getExpression();
-    if (expression === null) return null;
+    let expr;
+    expr = this.getExpression();
+    if (expr === null) return null;
     return this.createStatementNode(
-      "ThrowS",
+      T_THROW_STATEMENT,
       {
-        expression
+        expr
       },
       startToken,
-      expression.endToken
+      expr.endToken
     );
   }
   /**
@@ -2169,10 +2242,10 @@ class Parser {
     const startToken = this._lexer.peek();
     let endToken = this._lexer.get();
     const parser = this;
-    const tryBlock = getBlock();
-    let catchBlock;
-    let catchVariable;
-    let finallyBlock;
+    const tryB = getBlock();
+    let catchB;
+    let catchV;
+    let finallyB;
     let nextToken = this._lexer.peek();
     if (nextToken.type === TokenType.Catch) {
       this._lexer.get();
@@ -2184,32 +2257,38 @@ class Parser {
           this.reportError("W003", nextToken);
           return null;
         }
-        catchVariable = nextToken.text;
+        catchV = {
+          type: T_IDENTIFIER,
+          nodeId: createXmlUiTreeNodeId(),
+          name: nextToken.text,
+          startToken: nextToken,
+          endToken: nextToken
+        };
         this._lexer.get();
         this.expectToken(TokenType.RParent, "W006");
       }
-      catchBlock = getBlock();
-      endToken = catchBlock.endToken;
+      catchB = getBlock();
+      endToken = catchB.endToken;
       if (this._lexer.peek().type === TokenType.Finally) {
         this._lexer.get();
-        finallyBlock = getBlock();
-        endToken = finallyBlock.endToken;
+        finallyB = getBlock();
+        endToken = finallyB.endToken;
       }
     } else if (nextToken.type === TokenType.Finally) {
       this._lexer.get();
-      finallyBlock = getBlock();
-      endToken = finallyBlock.endToken;
+      finallyB = getBlock();
+      endToken = finallyB.endToken;
     } else {
       this.reportError("W013", nextToken);
       return null;
     }
     return this.createStatementNode(
-      "TryS",
+      T_TRY_STATEMENT,
       {
-        tryBlock,
-        catchBlock,
-        catchVariable,
-        finallyBlock
+        tryB,
+        catchB,
+        catchV,
+        finallyB
       },
       startToken,
       endToken
@@ -2238,19 +2317,19 @@ class Parser {
   parseSwitchStatement() {
     const startToken = this._lexer.get();
     this.expectToken(TokenType.LParent, "W014");
-    const expression = this.getExpression();
-    if (!expression) return null;
+    const expr = this.getExpression();
+    if (!expr) return null;
     this.expectToken(TokenType.RParent, "W006");
     this.expectToken(TokenType.LBrace, "W012");
     const cases = [];
     let defaultCaseFound = false;
     while (true) {
       let nextToken = this._lexer.peek();
-      let caseExpression;
+      let caseE;
       if (nextToken.type === TokenType.Case) {
         this._lexer.get();
-        caseExpression = this.getExpression();
-        if (!caseExpression) return null;
+        caseE = this.getExpression();
+        if (!caseE) return null;
       } else if (nextToken.type === TokenType.Default) {
         if (defaultCaseFound) {
           this.reportError("W016");
@@ -2265,7 +2344,7 @@ class Parser {
         return null;
       }
       this.expectToken(TokenType.Colon, "W008");
-      let statements = [];
+      let stmts = [];
       let collected = false;
       while (!collected) {
         const stmtToken = this._lexer.peek();
@@ -2281,18 +2360,18 @@ class Parser {
               collected = true;
               break;
             }
-            statements.push(stmt);
-            if (stmt.type !== "EmptyS") {
+            stmts.push(stmt);
+            if (stmt.type !== T_EMPTY_STATEMENT) {
               this.skipToken(TokenType.Semicolon);
             }
         }
       }
       cases.push(
         this.createNode(
-          "SwitchC",
+          T_SWITCH_CASE,
           {
-            caseExpression,
-            statements
+            caseE,
+            stmts
           },
           startToken
         )
@@ -2301,9 +2380,9 @@ class Parser {
     const endToken = this._lexer.peek();
     this.expectToken(TokenType.RBrace, "W004");
     return this.createStatementNode(
-      "SwitchS",
+      T_SWITCH_STATEMENT,
       {
-        expression,
+        expr,
         cases
       },
       startToken,
@@ -2347,28 +2426,28 @@ class Parser {
     let isValid;
     const args = [];
     switch (exprList.type) {
-      case "NoArgE":
+      case T_NO_ARG_EXPRESSION:
         isValid = true;
         break;
-      case "IdE":
+      case T_IDENTIFIER:
         isValid = (exprList.parenthesized ?? 0) <= 1;
         args.push(exprList);
         break;
-      case "SeqE":
+      case T_SEQUENCE_EXPRESSION:
         isValid = exprList.parenthesized === 1;
         let spreadFound = false;
         if (isValid) {
-          for (const expr of exprList.expressions) {
+          for (const expr of exprList.exprs) {
             if (spreadFound) {
               isValid = false;
               break;
             }
             switch (expr.type) {
-              case "IdE":
+              case T_IDENTIFIER:
                 isValid = !expr.parenthesized;
                 args.push(expr);
                 break;
-              case "OLitE": {
+              case T_OBJECT_LITERAL: {
                 isValid = !expr.parenthesized;
                 if (isValid) {
                   const des = this.convertToObjectDestructure(expr);
@@ -2376,7 +2455,7 @@ class Parser {
                 }
                 break;
               }
-              case "ALitE": {
+              case T_ARRAY_LITERAL: {
                 isValid = !expr.parenthesized;
                 if (isValid) {
                   const des = this.convertToArrayDestructure(expr);
@@ -2384,9 +2463,9 @@ class Parser {
                 }
                 break;
               }
-              case "SpreadE": {
+              case T_SPREAD_EXPRESSION: {
                 spreadFound = true;
-                if (expr.operand.type !== "IdE") {
+                if (expr.expr.type !== T_IDENTIFIER) {
                   isValid = false;
                   break;
                 }
@@ -2400,22 +2479,22 @@ class Parser {
           }
         }
         break;
-      case "OLitE":
+      case T_OBJECT_LITERAL:
         isValid = exprList.parenthesized === 1;
         if (isValid) {
           const des = this.convertToObjectDestructure(exprList);
           if (des) args.push(des);
         }
         break;
-      case "ALitE":
+      case T_ARRAY_LITERAL:
         isValid = exprList.parenthesized === 1;
         if (isValid) {
           const des = this.convertToArrayDestructure(exprList);
           if (des) args.push(des);
         }
         break;
-      case "SpreadE":
-        if (exprList.operand.type !== "IdE") {
+      case T_SPREAD_EXPRESSION:
+        if (exprList.expr.type !== T_IDENTIFIER) {
           isValid = false;
           break;
         }
@@ -2433,114 +2512,17 @@ class Parser {
       this.reportError("W012", this._lexer.peek());
       return null;
     }
-    const body = this.parseBlockStatement();
-    if (!body) return null;
+    const stmt = this.parseBlockStatement();
+    if (!stmt) return null;
     return this.createStatementNode(
-      "FuncD",
+      T_FUNCTION_DECLARATION,
       {
-        name: functionName,
+        id: { type: T_IDENTIFIER, name: functionName },
         args,
-        statement: body
-      },
-      startToken,
-      body.endToken
-    );
-  }
-  /**
-   * Parses an export statement
-   *
-   * exportStatement
-   *   : "export" (constStatement | functionDeclaration)
-   *   ;
-   */
-  parseExport() {
-    this._lexer.get();
-    const nextToken = this._lexer.peek();
-    if (nextToken.type === TokenType.Const) {
-      if (this._statementLevel > 1) {
-        this.reportError("W030", nextToken);
-        return null;
-      }
-      const constStmt = this.parseConstStatement();
-      return constStmt === null ? null : { ...constStmt, isExported: true };
-    } else if (nextToken.type === TokenType.Function) {
-      if (this._statementLevel > 1) {
-        this.reportError("W030", nextToken);
-        return null;
-      }
-      const funcDecl = this.parseFunctionDeclaration();
-      return funcDecl === null ? null : { ...funcDecl, isExported: true };
-    }
-    this.reportError("W024", nextToken);
-    return null;
-  }
-  /**
-   * Parse an import declaration
-   *
-   * importDeclaration
-   *   : "import" "{" importItem ("," importItem)* [ "," ] "}" from module
-   *   ;
-   *
-   * importItem
-   *   : identifier [ "as" identifier ]
-   *   ;
-   */
-  parseImport() {
-    const startToken = this._lexer.get();
-    this.expectToken(TokenType.LBrace, "W012");
-    const imports = {};
-    let nextToken = this._lexer.peek();
-    while (nextToken.type !== TokenType.RBrace) {
-      if (nextToken.type !== TokenType.Identifier) {
-        this.reportError("W003", nextToken);
-        return null;
-      }
-      const id = nextToken.text;
-      this._lexer.get();
-      nextToken = this._lexer.peek();
-      if (nextToken.type === TokenType.As) {
-        this._lexer.get();
-        nextToken = this._lexer.peek();
-        if (nextToken.type !== TokenType.Identifier) {
-          this.reportError("W003", nextToken);
-          return null;
-        }
-        if (imports[nextToken.text]) {
-          this.reportError("W019", nextToken, nextToken.text);
-          return null;
-        }
-        imports[nextToken.text] = id;
-        this._lexer.get();
-      } else {
-        if (imports[id]) {
-          this.reportError("W019", nextToken, id);
-          return null;
-        }
-        imports[id] = id;
-      }
-      nextToken = this._lexer.peek();
-      if (nextToken.type === TokenType.Comma) {
-        this._lexer.get();
-        nextToken = this._lexer.peek();
-      }
-    }
-    this._lexer.get();
-    this.expectToken(TokenType.From, "W025");
-    const moduleToken = this._lexer.peek();
-    if (moduleToken.type !== TokenType.StringLiteral) {
-      this.reportError("W026", moduleToken);
-      return null;
-    }
-    this._lexer.get();
-    const literal = this.parseStringLiteral(moduleToken);
-    return this.createStatementNode(
-      "ImportD",
-      {
-        imports,
-        moduleFile: literal.value
+        stmt
       },
       startToken,
-      moduleToken
+      stmt.endToken
     );
   }
   // ==========================================================================
@@ -2567,16 +2549,16 @@ class Parser {
       return null;
     }
     endToken = leftExpr.endToken;
-    const expressions = [];
+    const exprs = [];
     let loose = false;
     if (this._lexer.peek().type === TokenType.Comma) {
-      expressions.push(leftExpr);
+      exprs.push(leftExpr);
       while (this.skipToken(TokenType.Comma)) {
         if (this._lexer.peek().type === TokenType.Comma) {
           loose = true;
           endToken = this._lexer.peek();
-          expressions.push(
-            this.createExpressionNode("NoArgE", {}, endToken, endToken)
+          exprs.push(
+            this.createExpressionNode(T_NO_ARG_EXPRESSION, {}, endToken, endToken)
           );
         } else {
           const nextExpr = this.parseCondOrSpreadOrAsgnOrArrowExpr();
@@ -2584,17 +2566,17 @@ class Parser {
             break;
           }
           endToken = nextExpr.endToken;
-          expressions.push(nextExpr);
+          exprs.push(nextExpr);
         }
       }
     }
-    if (!expressions.length) {
+    if (!exprs.length) {
       return leftExpr;
     }
     leftExpr = this.createExpressionNode(
-      "SeqE",
+      T_SEQUENCE_EXPRESSION,
       {
-        expressions,
+        exprs,
         loose
       },
       start,
@@ -2618,9 +2600,9 @@ class Parser {
       this._lexer.get();
       const spreadOperand = this.parseNullCoalescingExpr();
       return spreadOperand ? this.createExpressionNode(
-        "SpreadE",
+        T_SPREAD_EXPRESSION,
         {
-          operand: spreadOperand
+          expr: spreadOperand
         },
         startToken,
         spreadOperand.endToken
@@ -2629,11 +2611,11 @@ class Parser {
     if (startToken.type === TokenType.Function) {
       const funcDecl = this.parseFunctionDeclaration(true);
       return funcDecl ? this.createExpressionNode(
-        "ArrowE",
+        T_ARROW_EXPRESSION,
         {
-          name: funcDecl.name,
+          name: funcDecl.id.name,
           args: funcDecl.args,
-          statement: funcDecl.statement
+          statement: funcDecl.stmt
         },
         startToken,
         funcDecl.endToken
@@ -2653,11 +2635,11 @@ class Parser {
       this.expectToken(TokenType.Colon);
       const falseExpr = this.getExpression(false);
       return this.createExpressionNode(
-        "CondE",
+        T_CONDITIONAL_EXPRESSION,
         {
-          condition: otherExpr,
-          consequent: trueExpr,
-          alternate: falseExpr
+          cond: otherExpr,
+          thenE: trueExpr,
+          elseE: falseExpr
         },
         startToken,
         falseExpr.endToken
@@ -2665,16 +2647,16 @@ class Parser {
     }
     if (tokenTraits[nextToken.type].isAssignment) {
       this._lexer.get();
-      const operand = this.getExpression();
-      return operand ? this.createExpressionNode(
-        "AsgnE",
+      const expr = this.getExpression();
+      return expr ? this.createExpressionNode(
+        T_ASSIGNMENT_EXPRESSION,
         {
           leftValue: otherExpr,
-          operator: nextToken.text,
-          operand
+          op: nextToken.text,
+          expr
         },
         startToken,
-        operand.endToken
+        expr.endToken
       ) : null;
     }
     return otherExpr;
@@ -2688,28 +2670,28 @@ class Parser {
     let isValid;
     const args = [];
     switch (left.type) {
-      case "NoArgE":
+      case T_NO_ARG_EXPRESSION:
         isValid = true;
         break;
-      case "IdE":
+      case T_IDENTIFIER:
         isValid = (left.parenthesized ?? 0) <= 1;
         args.push(left);
         break;
-      case "SeqE":
+      case T_SEQUENCE_EXPRESSION:
         isValid = left.parenthesized === 1;
         let spreadFound = false;
         if (isValid) {
-          for (const expr of left.expressions) {
+          for (const expr of left.exprs) {
             if (spreadFound) {
               isValid = false;
               break;
             }
             switch (expr.type) {
-              case "IdE":
+              case T_IDENTIFIER:
                 isValid = !expr.parenthesized;
                 args.push(expr);
                 break;
-              case "OLitE": {
+              case T_OBJECT_LITERAL: {
                 isValid = !expr.parenthesized;
                 if (isValid) {
                   const des = this.convertToObjectDestructure(expr);
@@ -2717,7 +2699,7 @@ class Parser {
                 }
                 break;
               }
-              case "ALitE": {
+              case T_ARRAY_LITERAL: {
                 isValid = !expr.parenthesized;
                 if (isValid) {
                   const des = this.convertToArrayDestructure(expr);
@@ -2725,9 +2707,9 @@ class Parser {
                 }
                 break;
               }
-              case "SpreadE": {
+              case T_SPREAD_EXPRESSION: {
                 spreadFound = true;
-                if (expr.operand.type !== "IdE") {
+                if (expr.expr.type !== T_IDENTIFIER) {
                   isValid = false;
                   break;
                 }
@@ -2741,22 +2723,22 @@ class Parser {
           }
         }
         break;
-      case "OLitE":
+      case T_OBJECT_LITERAL:
         isValid = left.parenthesized === 1;
         if (isValid) {
           const des = this.convertToObjectDestructure(left);
           if (des) args.push(des);
         }
         break;
-      case "ALitE":
+      case T_ARRAY_LITERAL:
         isValid = left.parenthesized === 1;
         if (isValid) {
           const des = this.convertToArrayDestructure(left);
           if (des) args.push(des);
         }
         break;
-      case "SpreadE":
-        isValid = left.operand.type === "IdE";
+      case T_SPREAD_EXPRESSION:
+        isValid = left.expr.type === T_IDENTIFIER;
         if (isValid) {
           args.push(left);
         }
@@ -2771,7 +2753,7 @@ class Parser {
     this._lexer.get();
     const statement = this.parseStatement(false);
     return statement ? this.createExpressionNode(
-      "ArrowE",
+      T_ARROW_EXPRESSION,
       {
         args,
         statement
@@ -2799,9 +2781,9 @@ class Parser {
       }
       let endToken = rightExpr.endToken;
       leftExpr = this.createExpressionNode(
-        "BinaryE",
+        T_BINARY_EXPRESSION,
         {
-          operator: "??",
+          op: "??",
           left: leftExpr,
           right: rightExpr
         },
@@ -2830,9 +2812,9 @@ class Parser {
       }
       let endToken = rightExpr.endToken;
       leftExpr = this.createExpressionNode(
-        "BinaryE",
+        T_BINARY_EXPRESSION,
         {
-          operator: "||",
+          op: "||",
           left: leftExpr,
           right: rightExpr
         },
@@ -2861,9 +2843,9 @@ class Parser {
       }
       let endToken = rightExpr.endToken;
       leftExpr = this.createExpressionNode(
-        "BinaryE",
+        T_BINARY_EXPRESSION,
         {
-          operator: "&&",
+          op: "&&",
           left: leftExpr,
           right: rightExpr
         },
@@ -2892,9 +2874,9 @@ class Parser {
       }
       let endToken = rightExpr.endToken;
       leftExpr = this.createExpressionNode(
-        "BinaryE",
+        T_BINARY_EXPRESSION,
         {
-          operator: "|",
+          op: "|",
           left: leftExpr,
           right: rightExpr
         },
@@ -2923,9 +2905,9 @@ class Parser {
       }
       let endToken = rightExpr.endToken;
       leftExpr = this.createExpressionNode(
-        "BinaryE",
+        T_BINARY_EXPRESSION,
         {
-          operator: "^",
+          op: "^",
           left: leftExpr,
           right: rightExpr
         },
@@ -2954,9 +2936,9 @@ class Parser {
       }
       let endToken = rightExpr.endToken;
       leftExpr = this.createExpressionNode(
-        "BinaryE",
+        T_BINARY_EXPRESSION,
         {
-          operator: "&",
+          op: "&",
           left: leftExpr,
           right: rightExpr
         },
@@ -2991,10 +2973,9 @@ class Parser {
       }
       let endToken = rightExpr.endToken;
       leftExpr = this.createExpressionNode(
-        "BinaryE",
+        T_BINARY_EXPRESSION,
         {
-          type: "BinaryE",
-          operator: opType.text,
+          op: opType.text,
           left: leftExpr,
           right: rightExpr
         },
@@ -3030,9 +3011,9 @@ class Parser {
       }
       let endToken = rightExpr.endToken;
       leftExpr = this.createExpressionNode(
-        "BinaryE",
+        T_BINARY_EXPRESSION,
         {
-          operator: opType.text,
+          op: opType.text,
           left: leftExpr,
           right: rightExpr
         },
@@ -3066,9 +3047,9 @@ class Parser {
       }
       let endToken = rightExpr.endToken;
       leftExpr = this.createExpressionNode(
-        "BinaryE",
+        T_BINARY_EXPRESSION,
         {
-          operator: opType.text,
+          op: opType.text,
           left: leftExpr,
           right: rightExpr
         },
@@ -3098,9 +3079,9 @@ class Parser {
       }
       let endToken = rightExpr.endToken;
       leftExpr = this.createExpressionNode(
-        "BinaryE",
+        T_BINARY_EXPRESSION,
         {
-          operator: opType.text,
+          op: opType.text,
           left: leftExpr,
           right: rightExpr
         },
@@ -3130,9 +3111,9 @@ class Parser {
       }
       let endToken = rightExpr.endToken;
       leftExpr = this.createExpressionNode(
-        "BinaryE",
+        T_BINARY_EXPRESSION,
         {
-          operator: opType.text,
+          op: opType.text,
           left: leftExpr,
           right: rightExpr
         },
@@ -3164,9 +3145,9 @@ class Parser {
       let endToken = rightExpr.endToken;
       if (count === 0) {
         leftExpr = this.createExpressionNode(
-          "BinaryE",
+          T_BINARY_EXPRESSION,
           {
-            operator: opType.text,
+            op: opType.text,
             left: leftExpr,
             right: rightExpr
           },
@@ -3176,13 +3157,13 @@ class Parser {
       } else {
         const prevLeft = leftExpr;
         leftExpr = this.createExpressionNode(
-          "BinaryE",
+          T_BINARY_EXPRESSION,
           {
-            operator: opType.text,
+            op: opType.text,
             left: prevLeft.left,
             right: {
-              type: "BinaryE",
-              operator: opType.text,
+              type: T_BINARY_EXPRESSION,
+              op: opType.text,
               left: prevLeft.right,
               right: rightExpr
             }
@@ -3210,10 +3191,10 @@ class Parser {
         return null;
       }
       return this.createExpressionNode(
-        "UnaryE",
+        T_UNARY_EXPRESSION,
         {
-          operator: startToken.text,
-          operand: unaryOperand
+          op: startToken.text,
+          expr: unaryOperand
         },
         startToken,
         unaryOperand.endToken
@@ -3226,10 +3207,10 @@ class Parser {
         return null;
       }
       return this.createExpressionNode(
-        "PrefE",
+        T_PREFIX_OP_EXPRESSION,
         {
-          operator: startToken.text,
-          operand: prefixOperand
+          op: startToken.text,
+          expr: prefixOperand
         },
         startToken,
         prefixOperand.endToken
@@ -3264,14 +3245,14 @@ class Parser {
               this.reportError("W001");
               return null;
             }
-            args = expr.type === "SeqE" ? expr.expressions : [expr];
+            args = expr.type === T_SEQUENCE_EXPRESSION ? expr.exprs : [expr];
           }
           const endToken2 = this._lexer.peek();
           this.expectToken(TokenType.RParent, "W006");
           primary = this.createExpressionNode(
-            "InvokeE",
+            T_FUNCTION_INVOCATION_EXPRESSION,
             {
-              object: primary,
+              obj: primary,
               arguments: args
             },
             startToken,
@@ -3289,11 +3270,11 @@ class Parser {
             return null;
           }
           primary = this.createExpressionNode(
-            "MembE",
+            T_MEMBER_ACCESS_EXPRESSION,
             {
-              object: primary,
+              obj: primary,
               member: member.text,
-              isOptional: currentStart.type === TokenType.OptionalChaining
+              opt: currentStart.type === TokenType.OptionalChaining
             },
             startToken,
             member
@@ -3308,9 +3289,9 @@ class Parser {
           const endToken = this._lexer.peek();
           this.expectToken(TokenType.RSquare, "W005");
           primary = this.createExpressionNode(
-            "CMembE",
+            T_CALCULATED_MEMBER_ACCESS_EXPRESSION,
             {
-              object: primary,
+              obj: primary,
               member: memberExpr
             },
             startToken,
@@ -3326,10 +3307,10 @@ class Parser {
     if (nextToken.type === TokenType.IncOp || nextToken.type === TokenType.DecOp) {
       this._lexer.get();
       return this.createExpressionNode(
-        "PostfE",
+        T_POSTFIX_OP_EXPRESSION,
         {
-          operator: nextToken.text,
-          operand: primary
+          op: nextToken.text,
+          expr: primary
         },
         startToken,
         nextToken
@@ -3353,30 +3334,29 @@ class Parser {
         this._lexer.get();
         if (this._lexer.peek().type === TokenType.RParent) {
           const endToken2 = this._lexer.get();
-          return this.createExpressionNode("NoArgE", {}, start, endToken2);
+          return this.createExpressionNode(
+            T_NO_ARG_EXPRESSION,
+            {},
+            start,
+            endToken2
+          );
         }
-        const parenthesizedExpr = this.parseExpr();
+        let parenthesizedExpr = this.parseExpr();
         if (!parenthesizedExpr) {
           return null;
         }
         const endToken = this._lexer.peek();
         this.expectToken(TokenType.RParent, "W006");
-        parenthesizedExpr.parenthesized ?? (parenthesizedExpr.parenthesized = 0);
-        parenthesizedExpr.parenthesized++;
-        parenthesizedExpr.startToken = start;
-        parenthesizedExpr.startPosition = start.location.startPosition;
-        parenthesizedExpr.startLine = start.location.startLine;
-        parenthesizedExpr.startColumn = start.location.startColumn;
-        parenthesizedExpr.endToken = endToken;
-        parenthesizedExpr.endPosition = endToken.location.endPosition;
-        parenthesizedExpr.endLine = endToken.location.endLine;
-        parenthesizedExpr.endColumn = endToken.location.endColumn;
-        parenthesizedExpr.source = this.getSource(start, endToken);
-        return parenthesizedExpr;
+        return {
+          ...parenthesizedExpr,
+          parenthesized: (parenthesizedExpr.parenthesized ?? 0) + 1,
+          startToken: start,
+          endToken
+        };
       case TokenType.Identifier: {
         const idToken = this._lexer.get();
         return this.createExpressionNode(
-          "IdE",
+          T_IDENTIFIER,
           {
             name: idToken.text
           },
@@ -3392,7 +3372,7 @@ class Parser {
           return null;
         }
         return this.createExpressionNode(
-          "IdE",
+          T_IDENTIFIER,
           {
             name: idToken.text,
             isGlobal: true
@@ -3407,7 +3387,7 @@ class Parser {
       case TokenType.True:
         this._lexer.get();
         return this.createExpressionNode(
-          "LitE",
+          T_LITERAL,
           {
             value: start.type === TokenType.True
           },
@@ -3432,7 +3412,7 @@ class Parser {
       case TokenType.Infinity:
         this._lexer.get();
         return this.createExpressionNode(
-          "LitE",
+          T_LITERAL,
           {
             value: Infinity
           },
@@ -3442,7 +3422,7 @@ class Parser {
       case TokenType.NaN:
         this._lexer.get();
         return this.createExpressionNode(
-          "LitE",
+          T_LITERAL,
           {
             value: NaN
           },
@@ -3452,7 +3432,7 @@ class Parser {
       case TokenType.Null:
         this._lexer.get();
         return this.createExpressionNode(
-          "LitE",
+          T_LITERAL,
           {
             value: null
           },
@@ -3462,7 +3442,7 @@ class Parser {
       case TokenType.Undefined:
         this._lexer.get();
         return this.createExpressionNode(
-          "LitE",
+          T_LITERAL,
           {
             value: void 0
           },
@@ -3505,7 +3485,7 @@ class Parser {
     }
     const endToken = this._lexer.get();
     return this.createExpressionNode(
-      "TempLitE",
+      T_TEMPLATE_LITERAL_EXPRESSION,
       { segments },
       startToken,
       endToken
@@ -3520,13 +3500,13 @@ class Parser {
     if (this._lexer.peek().type !== TokenType.RSquare) {
       const expr = this.getExpression();
       if (expr) {
-        expressions = expr.type === "SeqE" ? expr.expressions : [expr];
+        expressions = expr.type === T_SEQUENCE_EXPRESSION ? expr.exprs : [expr];
       }
     }
     const endToken = this._lexer.peek();
     this.expectToken(TokenType.RSquare);
     return this.createExpressionNode(
-      "ALitE",
+      T_ARRAY_LITERAL,
       {
         items: expressions
       },
@@ -3554,9 +3534,9 @@ class Parser {
             }
             this.expectToken(TokenType.RSquare, "W005");
             nameExpr = this.createExpressionNode(
-              "SeqE",
+              T_SEQUENCE_EXPRESSION,
               {
-                expressions: [nameExpr]
+                exprs: [nameExpr]
               },
               start
             );
@@ -3565,7 +3545,7 @@ class Parser {
             if (!nameExpr) {
               return null;
             }
-            if (nameExpr.type !== "IdE" && nameExpr.type !== "LitE" && nameExpr.type !== "SpreadE") {
+            if (nameExpr.type !== T_IDENTIFIER && nameExpr.type !== T_LITERAL && nameExpr.type !== T_SPREAD_EXPRESSION) {
               this.reportError("W007");
               return null;
             }
@@ -3575,16 +3555,9 @@ class Parser {
           }
         } else if (traits.keywordLike) {
           nameExpr = {
-            type: "IdE",
+            type: T_IDENTIFIER,
+            nodeId: createXmlUiTreeNodeId(),
             name: nextToken.text,
-            value: void 0,
-            startPosition: nextToken.location.startPosition,
-            startLine: nextToken.location.startLine,
-            startColumn: nextToken.location.startColumn,
-            endPosition: nextToken.location.endPosition,
-            endLine: nextToken.location.endLine,
-            endColumn: nextToken.location.endColumn,
-            source: nextToken.text,
             startToken: nextToken,
             endToken: nextToken
           };
@@ -3594,10 +3567,10 @@ class Parser {
           return null;
         }
         const nameType = nameExpr.type;
-        if (nameType === "SpreadE") {
+        if (nameType === T_SPREAD_EXPRESSION) {
           props.push(nameExpr);
         } else {
-          if (nameType === "LitE") {
+          if (nameType === T_LITERAL) {
             const val = nameExpr.value;
             if (typeof val !== "number" && typeof val !== "string") {
               this.expectToken(TokenType.RBrace, "W007");
@@ -3605,7 +3578,7 @@ class Parser {
             }
           }
           let valueExpr = null;
-          if (nameType === "IdE") {
+          if (nameType === T_IDENTIFIER) {
             const nameFollowerToken = this._lexer.peek();
             if (nameFollowerToken.type === TokenType.Comma || nameFollowerToken.type === TokenType.RBrace) {
               valueExpr = { ...nameExpr };
@@ -3633,7 +3606,7 @@ class Parser {
     const endToken = this._lexer.peek();
     this.expectToken(TokenType.RBrace, "W004");
     return this.createExpressionNode(
-      "OLitE",
+      T_OBJECT_LITERAL,
       {
         props
       },
@@ -3646,7 +3619,7 @@ class Parser {
     const result = this._lexer.getRegEx();
     if (result.success) {
       return this.createExpressionNode(
-        "LitE",
+        T_LITERAL,
         {
           value: new RegExp(result.pattern, result.flags)
         },
@@ -3728,10 +3701,7 @@ class Parser {
     }
     this._parseErrors.push({
       code: errorCode,
-      text: errorText,
-      line: token.location.startLine,
-      column: token.location.startColumn,
-      position: token.location.startPosition
+      text: errorText
     });
     throw new ParserError$1(errorText, errorCode);
     function replace(input, placeholder, replacement) {
@@ -3749,21 +3719,14 @@ class Parser {
    * @param endToken The token that ends the expression
    * @param source Expression source code to store to the node
    */
-  createNode(type, stump, startToken, endToken, source) {
+  createNode(type, stump, startToken, endToken) {
     if (!endToken) {
       endToken = this._lexer.peek();
     }
-    const startPosition = startToken.location.startPosition;
-    const endPosition = endToken.location.startPosition;
     return Object.assign({}, stump, {
       type,
-      startPosition,
-      endPosition,
-      startLine: startToken.location.startLine,
-      startColumn: startToken.location.startColumn,
-      endLine: endToken.location.endLine,
-      endColumn: endToken.location.endColumn,
-      source: source ?? this.getSource(startToken, endToken)
+      startToken,
+      endToken
     });
   }
   /**
@@ -3774,24 +3737,16 @@ class Parser {
    * @param endToken The token that ends the expression
    * @param source Expression source code to store to the node
    */
-  createExpressionNode(type, stump = {}, startToken, endToken, source) {
+  createExpressionNode(type, stump = {}, startToken, endToken) {
     if (!endToken) {
       endToken = this._lexer.peek();
     }
     if (!startToken) {
       startToken = endToken;
     }
-    const startPosition = startToken.location.startPosition;
-    const endPosition = endToken.location.endPosition;
     return Object.assign({}, stump, {
       type,
-      startPosition,
-      endPosition,
-      startLine: startToken.location.startLine,
-      startColumn: startToken.location.startColumn,
-      endLine: endToken.location.endLine,
-      endColumn: endToken.location.endColumn,
-      source: source ?? this.getSource(startToken, endToken),
+      nodeId: createXmlUiTreeNodeId(),
       startToken,
       endToken
     });
@@ -3804,35 +3759,13 @@ class Parser {
    * @param endToken The token that ends the statement
    */
   createStatementNode(type, stump, startToken, endToken) {
-    var _a, _b, _c, _d, _e;
-    const startPosition = (_a = startToken == null ? void 0 : startToken.location) == null ? void 0 : _a.startPosition;
-    const currentToken = this._lexer.peek();
-    const endPosition = endToken ? endToken.location.endPosition : currentToken.type === TokenType.Eof ? currentToken.location.startPosition + 1 : currentToken.location.startPosition;
     return Object.assign({}, stump, {
       type,
-      startPosition,
-      endPosition,
-      startLine: (_b = startToken == null ? void 0 : startToken.location) == null ? void 0 : _b.startLine,
-      startColumn: (_c = startToken == null ? void 0 : startToken.location) == null ? void 0 : _c.startColumn,
-      endLine: endToken ? endToken.location.endLine : (_d = startToken == null ? void 0 : startToken.location) == null ? void 0 : _d.endLine,
-      endColumn: endToken ? endToken.location.endColumn : (_e = startToken == null ? void 0 : startToken.location) == null ? void 0 : _e.endColumn,
-      source: this.source && startPosition !== void 0 && endPosition !== void 0 ? this.source.substring(startPosition, endPosition) : void 0,
+      nodeId: createXmlUiTreeNodeId(),
       startToken,
       endToken
     });
   }
-  /**
-   * 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(start, end) {
-    return this.source.substring(
-      start.location.startPosition,
-      end.type === TokenType.Eof ? end.location.startPosition : end.location.endPosition
-    );
-  }
   /**
    * Parses a binary literal
    * @param token Literal token
@@ -3846,7 +3779,7 @@ class Parser {
       value = parseInt(token.text.substring(2).replace(/[_']/g, ""), 2);
     }
     return this.createExpressionNode(
-      "LitE",
+      T_LITERAL,
       {
         value
       },
@@ -3867,7 +3800,7 @@ class Parser {
       value = parseInt(token.text.replace(/[_']/g, ""), 10);
     }
     return this.createExpressionNode(
-      "LitE",
+      T_LITERAL,
       {
         value
       },
@@ -3888,7 +3821,7 @@ class Parser {
       value = parseInt(token.text.substring(2).replace(/[_']/g, ""), 16);
     }
     return this.createExpressionNode(
-      "LitE",
+      T_LITERAL,
       {
         value
       },
@@ -3903,7 +3836,7 @@ class Parser {
   parseRealLiteral(token) {
     let value = parseFloat(token.text.replace(/[_']/g, ""));
     return this.createExpressionNode(
-      "LitE",
+      T_LITERAL,
       {
         value
       },
@@ -4123,7 +4056,7 @@ class Parser {
         break;
     }
     return this.createExpressionNode(
-      "LitE",
+      T_LITERAL,
       {
         value: result
       },
@@ -4136,45 +4069,45 @@ class Parser {
   }
   convertToArrayDestructure(seq) {
     var _a;
-    const items = seq.type === "SeqE" ? seq.expressions : seq.items;
+    const items = seq.type === T_SEQUENCE_EXPRESSION ? seq.exprs : seq.items;
     const result = this.createExpressionNode(
-      "Destr",
-      { arrayDestruct: [] },
+      T_DESTRUCTURE,
+      { aDestr: [] },
       seq.startToken,
       seq.endToken
     );
     for (const item of items) {
       let arrayD;
       switch (item.type) {
-        case "NoArgE":
+        case T_NO_ARG_EXPRESSION:
           arrayD = this.createExpressionNode(
-            "ADestr",
+            T_ARRAY_DESTRUCTURE,
             {},
             item.startToken,
             item.endToken
           );
           break;
-        case "IdE":
+        case T_IDENTIFIER:
           arrayD = this.createExpressionNode(
-            "ADestr",
+            T_ARRAY_DESTRUCTURE,
             { id: item.name },
             item.startToken,
             item.endToken
           );
           break;
-        case "Destr":
-          result.arrayDestruct.push(...item.arrayDestruct);
+        case T_DESTRUCTURE:
+          result.aDestr.push(...item.aDestr);
           break;
-        case "ADestr":
+        case T_ARRAY_DESTRUCTURE:
           arrayD = item;
           break;
-        case "ALitE": {
+        case T_ARRAY_LITERAL: {
           const destructure = this.convertToArrayDestructure(item);
           if (destructure) {
             arrayD = this.createExpressionNode(
-              "ADestr",
+              T_ARRAY_DESTRUCTURE,
               {
-                arrayDestruct: destructure.arrayDestruct
+                aDestr: destructure.aDestr
               },
               item.startToken,
               item.endToken
@@ -4182,23 +4115,23 @@ class Parser {
           }
           break;
         }
-        case "ODestr":
+        case T_OBJECT_DESTRUCTURE:
           arrayD = this.createExpressionNode(
-            "ADestr",
+            T_ARRAY_DESTRUCTURE,
             {
-              objectDestruct: item
+              oDestr: item
             },
             item.startToken,
             item.endToken
           );
           break;
-        case "OLitE": {
+        case T_OBJECT_LITERAL: {
           const destructure = this.convertToObjectDestructure(item);
           if (destructure) {
             arrayD = this.createExpressionNode(
-              "ADestr",
+              T_ARRAY_DESTRUCTURE,
               {
-                objectDestruct: destructure.objectDestruct
+                oDestr: destructure.oDestr
               },
               item.startToken,
               item.endToken
@@ -4210,42 +4143,42 @@ class Parser {
           this.reportError("W017");
           return null;
       }
-      if (arrayD) (_a = result.arrayDestruct) == null ? void 0 : _a.push(arrayD);
+      if (arrayD) (_a = result.aDestr) == null ? void 0 : _a.push(arrayD);
     }
     return result;
   }
   convertToObjectDestructure(objLit) {
     var _a;
     const result = this.createExpressionNode(
-      "Destr",
-      { objectDestruct: [] },
+      T_DESTRUCTURE,
+      { oDestr: [] },
       objLit.startToken,
       objLit.endToken
     );
     for (const prop of objLit.props) {
       if (Array.isArray(prop)) ;
       else {
-        this.reportError("W018");
+        reportError("W018");
         return null;
       }
       const [propKey, propValue] = prop;
-      if (propKey.type !== "IdE") {
-        this.reportError("W018");
+      if (propKey.type !== T_IDENTIFIER) {
+        reportError("W018");
         return null;
       }
       let objD;
       switch (propValue.type) {
-        case "IdE":
+        case T_IDENTIFIER:
           if (propValue.name === propKey.name) {
             objD = this.createExpressionNode(
-              "ODestr",
+              T_OBJECT_DESTRUCTURE,
               { id: propKey.name },
               propValue.startToken,
               propValue.endToken
             );
           } else {
             objD = this.createExpressionNode(
-              "ODestr",
+              T_OBJECT_DESTRUCTURE,
               {
                 id: propKey.name,
                 alias: propValue.name
@@ -4255,26 +4188,26 @@ class Parser {
             );
           }
           break;
-        case "ADestr": {
+        case T_ARRAY_DESTRUCTURE: {
           objD = this.createExpressionNode(
-            "ODestr",
+            T_OBJECT_DESTRUCTURE,
             {
               id: propKey.name,
-              arrayDestruct: propValue
+              aDestr: propValue
             },
             propKey.startToken,
             propValue.endToken
           );
           break;
         }
-        case "ALitE": {
+        case T_ARRAY_LITERAL: {
           const destructure = this.convertToArrayDestructure(propValue);
           if (destructure) {
             objD = this.createExpressionNode(
-              "ODestr",
+              T_OBJECT_DESTRUCTURE,
               {
                 id: propKey.name,
-                arrayDestruct: destructure.arrayDestruct
+                aDestr: destructure.aDestr
               },
               propKey.startToken,
               propValue.endToken
@@ -4282,17 +4215,17 @@ class Parser {
           }
           break;
         }
-        case "ODestr":
+        case T_OBJECT_DESTRUCTURE:
           objD = propValue;
           break;
-        case "OLitE": {
+        case T_OBJECT_LITERAL: {
           const destructure = this.convertToObjectDestructure(propValue);
           if (destructure) {
             objD = this.createExpressionNode(
-              "ODestr",
+              T_OBJECT_DESTRUCTURE,
               {
                 id: propKey.name,
-                objectDestruct: destructure.objectDestruct
+                oDestr: destructure.oDestr
               },
               propKey.startToken,
               propValue.endToken
@@ -4304,7 +4237,7 @@ class Parser {
           this.reportError("W018");
           return null;
       }
-      if (objD) (_a = result.objectDestruct) == null ? void 0 : _a.push(objD);
+      if (objD) (_a = result.oDestr) == null ? void 0 : _a.push(objD);
     }
     return result;
   }
@@ -4328,11 +4261,11 @@ function visitNode(subject, state, stmtVisitor, exprVisitor, parent, tag) {
     return state;
   }
   switch (subject.type) {
-    case "BlockS": {
+    case T_BLOCK_STATEMENT: {
       state = (stmtVisitor == null ? void 0 : stmtVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
-        for (const statement of subject.statements) {
+        for (const statement of subject.stmts) {
           state = visitNode(statement, state, stmtVisitor, exprVisitor, subject, "statements");
           if (state.cancel) return state;
         }
@@ -4340,28 +4273,28 @@ function visitNode(subject, state, stmtVisitor, exprVisitor, parent, tag) {
       state = (stmtVisitor == null ? void 0 : stmtVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "EmptyS": {
+    case T_EMPTY_STATEMENT: {
       state = (stmtVisitor == null ? void 0 : stmtVisitor(true, subject, state, parent, tag)) || state;
       return state;
     }
-    case "ExprS": {
+    case T_EXPRESSION_STATEMENT: {
       state = (stmtVisitor == null ? void 0 : stmtVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
-        state = visitNode(subject.expression, state, stmtVisitor, exprVisitor, subject, "expression");
+        state = visitNode(subject.expr, state, stmtVisitor, exprVisitor, subject, "expression");
         if (state.cancel) return state;
       }
       state = (stmtVisitor == null ? void 0 : stmtVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "ArrowS": {
+    case T_ARROW_EXPRESSION_STATEMENT: {
       return state;
     }
-    case "LetS": {
+    case T_LET_STATEMENT: {
       state = (stmtVisitor == null ? void 0 : stmtVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
-        for (const declaration of subject.declarations) {
+        for (const declaration of subject.decls) {
           state = visitNode(declaration, state, stmtVisitor, exprVisitor, subject, "declarations");
           if (state.cancel) return state;
         }
@@ -4369,11 +4302,11 @@ function visitNode(subject, state, stmtVisitor, exprVisitor, parent, tag) {
       state = (stmtVisitor == null ? void 0 : stmtVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "ConstS": {
+    case T_CONST_STATEMENT: {
       state = (stmtVisitor == null ? void 0 : stmtVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
-        for (const declaration of subject.declarations) {
+        for (const declaration of subject.decls) {
           state = visitNode(declaration, state, stmtVisitor, exprVisitor, subject, "declarations");
           if (state.cancel) return state;
         }
@@ -4381,11 +4314,11 @@ function visitNode(subject, state, stmtVisitor, exprVisitor, parent, tag) {
       state = (stmtVisitor == null ? void 0 : stmtVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "VarS": {
+    case T_VAR_STATEMENT: {
       state = (stmtVisitor == null ? void 0 : stmtVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
-        for (const declaration of subject.declarations) {
+        for (const declaration of subject.decls) {
           state = visitNode(declaration, state, stmtVisitor, exprVisitor, subject, "declarations");
           if (state.cancel) return state;
         }
@@ -4393,49 +4326,49 @@ function visitNode(subject, state, stmtVisitor, exprVisitor, parent, tag) {
       state = (stmtVisitor == null ? void 0 : stmtVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "IfS": {
+    case T_IF_STATEMENT: {
       state = (stmtVisitor == null ? void 0 : stmtVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
-        state = visitNode(subject.condition, state, stmtVisitor, exprVisitor, subject, "condition");
+        state = visitNode(subject.cond, state, stmtVisitor, exprVisitor, subject, "condition");
         if (state.cancel) return state;
-        if (subject.thenBranch) {
-          state = visitNode(subject.thenBranch, state, stmtVisitor, exprVisitor, subject, "thenBranch");
+        if (subject.thenB) {
+          state = visitNode(subject.thenB, state, stmtVisitor, exprVisitor, subject, "thenBranch");
         }
         if (state.cancel) return state;
-        if (subject.elseBranch) {
-          state = visitNode(subject.elseBranch, state, stmtVisitor, exprVisitor, subject, "elseBranch");
+        if (subject.elseB) {
+          state = visitNode(subject.elseB, state, stmtVisitor, exprVisitor, subject, "elseBranch");
         }
         if (state.cancel) return state;
       }
       state = (stmtVisitor == null ? void 0 : stmtVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "RetS": {
+    case T_RETURN_STATEMENT: {
       state = (stmtVisitor == null ? void 0 : stmtVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
-        if (subject.expression) {
-          state = visitNode(subject.expression, state, stmtVisitor, exprVisitor, subject, "expression");
+        if (subject.expr) {
+          state = visitNode(subject.expr, state, stmtVisitor, exprVisitor, subject, "expression");
         }
         if (state.cancel) return state;
       }
       state = (stmtVisitor == null ? void 0 : stmtVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "BrkS": {
+    case T_BREAK_STATEMENT: {
       state = (stmtVisitor == null ? void 0 : stmtVisitor(true, subject, state, parent, tag)) || state;
       return state;
     }
-    case "ContS": {
+    case T_CONTINUE_STATEMENT: {
       state = (stmtVisitor == null ? void 0 : stmtVisitor(true, subject, state, parent, tag)) || state;
       return state;
     }
-    case "WhileS": {
+    case T_WHILE_STATEMENT: {
       state = (stmtVisitor == null ? void 0 : stmtVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
-        state = visitNode(subject.condition, state, stmtVisitor, exprVisitor, subject, "condition");
+        state = visitNode(subject.cond, state, stmtVisitor, exprVisitor, subject, "condition");
         if (state.cancel) return state;
         state = visitNode(subject.body, state, stmtVisitor, exprVisitor, subject, "body");
         if (state.cancel) return state;
@@ -4443,19 +4376,19 @@ function visitNode(subject, state, stmtVisitor, exprVisitor, parent, tag) {
       state = (stmtVisitor == null ? void 0 : stmtVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "DoWS": {
+    case T_DO_WHILE_STATEMENT: {
       state = (stmtVisitor == null ? void 0 : stmtVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
         state = visitNode(subject.body, state, stmtVisitor, exprVisitor, subject, "body");
         if (state.cancel) return state;
-        state = visitNode(subject.condition, state, stmtVisitor, exprVisitor, subject, "condition");
+        state = visitNode(subject.cond, state, stmtVisitor, exprVisitor, subject, "condition");
         if (state.cancel) return state;
       }
       state = (stmtVisitor == null ? void 0 : stmtVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "ForS": {
+    case T_FOR_STATEMENT: {
       state = (stmtVisitor == null ? void 0 : stmtVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
@@ -4463,12 +4396,12 @@ function visitNode(subject, state, stmtVisitor, exprVisitor, parent, tag) {
           state = visitNode(subject.init, state, stmtVisitor, exprVisitor, subject, "init");
         }
         if (state.cancel) return state;
-        if (subject.condition) {
-          state = visitNode(subject.condition, state, stmtVisitor, exprVisitor, subject, "condition");
+        if (subject.cond) {
+          state = visitNode(subject.cond, state, stmtVisitor, exprVisitor, subject, "condition");
         }
         if (state.cancel) return state;
-        if (subject.update) {
-          state = visitNode(subject.update, state, stmtVisitor, exprVisitor, subject, "update");
+        if (subject.upd) {
+          state = visitNode(subject.upd, state, stmtVisitor, exprVisitor, subject, "update");
         }
         if (state.cancel) return state;
         state = visitNode(subject.body, state, stmtVisitor, exprVisitor, subject, "body");
@@ -4477,11 +4410,11 @@ function visitNode(subject, state, stmtVisitor, exprVisitor, parent, tag) {
       state = (stmtVisitor == null ? void 0 : stmtVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "ForInS": {
+    case T_FOR_IN_STATEMENT: {
       state = (stmtVisitor == null ? void 0 : stmtVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
-        state = visitNode(subject.expression, state, stmtVisitor, exprVisitor, subject, "expression");
+        state = visitNode(subject.expr, state, stmtVisitor, exprVisitor, subject, "expression");
         if (state.cancel) return state;
         state = visitNode(subject.body, state, stmtVisitor, exprVisitor, subject, "body");
         if (state.cancel) return state;
@@ -4489,11 +4422,11 @@ function visitNode(subject, state, stmtVisitor, exprVisitor, parent, tag) {
       state = (stmtVisitor == null ? void 0 : stmtVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "ForOfS": {
+    case T_FOR_OF_STATEMENT: {
       state = (stmtVisitor == null ? void 0 : stmtVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
-        state = visitNode(subject.expression, state, stmtVisitor, exprVisitor, subject, "expression");
+        state = visitNode(subject.expr, state, stmtVisitor, exprVisitor, subject, "expression");
         if (state.cancel) return state;
         state = visitNode(subject.body, state, stmtVisitor, exprVisitor, subject, "body");
         if (state.cancel) return state;
@@ -4501,49 +4434,70 @@ function visitNode(subject, state, stmtVisitor, exprVisitor, parent, tag) {
       state = (stmtVisitor == null ? void 0 : stmtVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "ThrowS": {
+    case T_THROW_STATEMENT: {
       state = (stmtVisitor == null ? void 0 : stmtVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
-        state = visitNode(subject.expression, state, stmtVisitor, exprVisitor, subject, "expression");
+        state = visitNode(subject.expr, state, stmtVisitor, exprVisitor, subject, "expression");
         if (state.cancel) return state;
       }
       state = (stmtVisitor == null ? void 0 : stmtVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "TryS": {
+    case T_TRY_STATEMENT: {
       state = (stmtVisitor == null ? void 0 : stmtVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
-        if (subject.tryBlock) {
-          state = visitNode(subject.tryBlock, state, stmtVisitor, exprVisitor, subject, "tryBlock");
+        if (subject.tryB) {
+          state = visitNode(subject.tryB, state, stmtVisitor, exprVisitor, subject, "tryBlock");
         }
         if (state.cancel) return state;
-        if (subject.catchBlock) {
-          state = visitNode(subject.catchBlock, state, stmtVisitor, exprVisitor, subject, "catchBlock");
+        if (subject.catchB) {
+          state = visitNode(subject.catchB, state, stmtVisitor, exprVisitor, subject, "catchBlock");
         }
         if (state.cancel) return state;
-        if (subject.finallyBlock) {
-          state = visitNode(subject.finallyBlock, state, stmtVisitor, exprVisitor, subject, "finallyBlock");
+        if (subject.finallyB) {
+          state = visitNode(
+            subject.finallyB,
+            state,
+            stmtVisitor,
+            exprVisitor,
+            subject,
+            "finallyBlock"
+          );
         }
         if (state.cancel) return state;
       }
       state = (stmtVisitor == null ? void 0 : stmtVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "SwitchS": {
+    case T_SWITCH_STATEMENT: {
       state = (stmtVisitor == null ? void 0 : stmtVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
-        state = visitNode(subject.expression, state, stmtVisitor, exprVisitor, subject, "expression");
+        state = visitNode(subject.expr, state, stmtVisitor, exprVisitor, subject, "expression");
         if (state.cancel) return state;
         for (const switchCase of subject.cases) {
-          if (switchCase.caseExpression)
-            state = visitNode(switchCase.caseExpression, state, stmtVisitor, exprVisitor, subject, "caseExpression");
+          if (switchCase.caseE)
+            state = visitNode(
+              switchCase.caseE,
+              state,
+              stmtVisitor,
+              exprVisitor,
+              subject,
+              "caseExpression"
+            );
           if (state.cancel) return state;
-          if (switchCase.statements === void 0) continue;
-          for (const statement of switchCase.statements) {
-            state = visitNode(statement, state, stmtVisitor, exprVisitor, subject, "switchStatement");
+          if (switchCase.stmts === void 0) continue;
+          for (const statement of switchCase.stmts) {
+            state = visitNode(
+              statement,
+              state,
+              stmtVisitor,
+              exprVisitor,
+              subject,
+              "switchStatement"
+            );
             if (state.cancel) return state;
           }
         }
@@ -4551,7 +4505,7 @@ function visitNode(subject, state, stmtVisitor, exprVisitor, parent, tag) {
       state = (stmtVisitor == null ? void 0 : stmtVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "FuncD": {
+    case T_FUNCTION_DECLARATION: {
       state = (stmtVisitor == null ? void 0 : stmtVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
@@ -4559,29 +4513,23 @@ function visitNode(subject, state, stmtVisitor, exprVisitor, parent, tag) {
           state = visitNode(expr, state, stmtVisitor, exprVisitor, subject, "arg");
           if (state.cancel) return state;
         }
-        state = visitNode(subject.statement, state, stmtVisitor, exprVisitor, subject, "statement");
+        state = visitNode(subject.stmt, state, stmtVisitor, exprVisitor, subject, "statement");
         if (state.cancel) return state;
       }
       state = (stmtVisitor == null ? void 0 : stmtVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "ImportD": {
-      state = (stmtVisitor == null ? void 0 : stmtVisitor(true, subject, state, parent, tag)) || state;
-      if (state.cancel) return state;
-      state = (stmtVisitor == null ? void 0 : stmtVisitor(false, subject, state, parent, tag)) || state;
-      return state;
-    }
-    case "UnaryE": {
+    case T_UNARY_EXPRESSION: {
       state = (exprVisitor == null ? void 0 : exprVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
-        state = visitNode(subject.operand, state, stmtVisitor, exprVisitor, subject, "operand");
+        state = visitNode(subject.expr, state, stmtVisitor, exprVisitor, subject, "operand");
         if (state.cancel) return state;
       }
       state = (exprVisitor == null ? void 0 : exprVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "BinaryE": {
+    case T_BINARY_EXPRESSION: {
       state = (exprVisitor == null ? void 0 : exprVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
@@ -4593,11 +4541,11 @@ function visitNode(subject, state, stmtVisitor, exprVisitor, parent, tag) {
       state = (exprVisitor == null ? void 0 : exprVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "SeqE": {
+    case T_SEQUENCE_EXPRESSION: {
       state = (exprVisitor == null ? void 0 : exprVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
-        for (const expr of subject.expressions) {
+        for (const expr of subject.exprs) {
           state = visitNode(expr, state, stmtVisitor, exprVisitor, subject, "expression");
           if (state.cancel) return state;
         }
@@ -4605,21 +4553,21 @@ function visitNode(subject, state, stmtVisitor, exprVisitor, parent, tag) {
       state = (exprVisitor == null ? void 0 : exprVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "CondE": {
+    case T_CONDITIONAL_EXPRESSION: {
       state = (exprVisitor == null ? void 0 : exprVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
-        state = visitNode(subject.condition, state, stmtVisitor, exprVisitor, subject, "condition");
+        state = visitNode(subject.cond, state, stmtVisitor, exprVisitor, subject, "condition");
         if (state.cancel) return state;
-        state = visitNode(subject.consequent, state, stmtVisitor, exprVisitor, subject, "consequent");
+        state = visitNode(subject.thenE, state, stmtVisitor, exprVisitor, subject, "consequent");
         if (state.cancel) return state;
-        state = visitNode(subject.alternate, state, stmtVisitor, exprVisitor, subject, "alternate");
+        state = visitNode(subject.elseE, state, stmtVisitor, exprVisitor, subject, "alternate");
         if (state.cancel) return state;
       }
       state = (exprVisitor == null ? void 0 : exprVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "InvokeE": {
+    case T_FUNCTION_INVOCATION_EXPRESSION: {
       state = (exprVisitor == null ? void 0 : exprVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
@@ -4627,27 +4575,27 @@ function visitNode(subject, state, stmtVisitor, exprVisitor, parent, tag) {
           state = visitNode(arg, state, stmtVisitor, exprVisitor, subject, "argument");
           if (state.cancel) return state;
         }
-        state = visitNode(subject.object, state, stmtVisitor, exprVisitor, subject, "object");
+        state = visitNode(subject.obj, state, stmtVisitor, exprVisitor, subject, "object");
         if (state.cancel) return state;
       }
       state = (exprVisitor == null ? void 0 : exprVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "MembE": {
+    case T_MEMBER_ACCESS_EXPRESSION: {
       state = (exprVisitor == null ? void 0 : exprVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
-        state = visitNode(subject.object, state, stmtVisitor, exprVisitor, subject, "object");
+        state = visitNode(subject.obj, state, stmtVisitor, exprVisitor, subject, "object");
         if (state.cancel) return state;
       }
       state = (exprVisitor == null ? void 0 : exprVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "CMembE": {
+    case T_CALCULATED_MEMBER_ACCESS_EXPRESSION: {
       state = (exprVisitor == null ? void 0 : exprVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
-        state = visitNode(subject.object, state, stmtVisitor, exprVisitor, subject, "object");
+        state = visitNode(subject.obj, state, stmtVisitor, exprVisitor, subject, "object");
         if (state.cancel) return state;
         state = visitNode(subject.member, state, stmtVisitor, exprVisitor, subject, "member");
         if (state.cancel) return state;
@@ -4655,15 +4603,15 @@ function visitNode(subject, state, stmtVisitor, exprVisitor, parent, tag) {
       state = (exprVisitor == null ? void 0 : exprVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "IdE": {
+    case T_IDENTIFIER: {
       state = (exprVisitor == null ? void 0 : exprVisitor(true, subject, state, parent, tag)) || state;
       return state;
     }
-    case "LitE": {
+    case T_LITERAL: {
       state = (exprVisitor == null ? void 0 : exprVisitor(true, subject, state, parent, tag)) || state;
       return state;
     }
-    case "ALitE": {
+    case T_ARRAY_LITERAL: {
       state = (exprVisitor == null ? void 0 : exprVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
@@ -4675,7 +4623,7 @@ function visitNode(subject, state, stmtVisitor, exprVisitor, parent, tag) {
       state = (exprVisitor == null ? void 0 : exprVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "OLitE": {
+    case T_OBJECT_LITERAL: {
       state = (exprVisitor == null ? void 0 : exprVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
@@ -4695,21 +4643,21 @@ function visitNode(subject, state, stmtVisitor, exprVisitor, parent, tag) {
       state = (exprVisitor == null ? void 0 : exprVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "SpreadE": {
+    case T_SPREAD_EXPRESSION: {
       state = (exprVisitor == null ? void 0 : exprVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
-        state = visitNode(subject.operand, state, stmtVisitor, exprVisitor, subject, "operand");
+        state = visitNode(subject.expr, state, stmtVisitor, exprVisitor, subject, "operand");
         if (state.cancel) return state;
       }
       state = (exprVisitor == null ? void 0 : exprVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "AsgnE": {
+    case T_ASSIGNMENT_EXPRESSION: {
       state = (exprVisitor == null ? void 0 : exprVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
-        state = visitNode(subject.operand, state, stmtVisitor, exprVisitor, subject, "operand");
+        state = visitNode(subject.expr, state, stmtVisitor, exprVisitor, subject, "operand");
         if (state.cancel) return state;
         state = visitNode(subject.leftValue, state, stmtVisitor, exprVisitor, subject, "leftValue");
         if (state.cancel) return state;
@@ -4717,11 +4665,11 @@ function visitNode(subject, state, stmtVisitor, exprVisitor, parent, tag) {
       state = (exprVisitor == null ? void 0 : exprVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "NoArgE": {
+    case T_NO_ARG_EXPRESSION: {
       state = (exprVisitor == null ? void 0 : exprVisitor(true, subject, state, parent, tag)) || state;
       return state;
     }
-    case "ArrowE": {
+    case T_ARROW_EXPRESSION: {
       state = (exprVisitor == null ? void 0 : exprVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
@@ -4735,55 +4683,55 @@ function visitNode(subject, state, stmtVisitor, exprVisitor, parent, tag) {
       state = (exprVisitor == null ? void 0 : exprVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "PrefE":
-    case "PostfE": {
+    case T_PREFIX_OP_EXPRESSION:
+    case T_POSTFIX_OP_EXPRESSION: {
       state = (exprVisitor == null ? void 0 : exprVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
-        state = visitNode(subject.operand, state, stmtVisitor, exprVisitor, subject, "operand");
+        state = visitNode(subject.expr, state, stmtVisitor, exprVisitor, subject, "operand");
         if (state.cancel) return state;
       }
       state = (exprVisitor == null ? void 0 : exprVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "VarD": {
+    case T_VAR_DECLARATION: {
       state = (exprVisitor == null ? void 0 : exprVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
-        if (subject.arrayDestruct !== void 0) {
-          for (const expr of subject.arrayDestruct) {
+        if (subject.aDestr !== void 0) {
+          for (const expr of subject.aDestr) {
             state = visitNode(expr, state, stmtVisitor, exprVisitor, subject);
             if (state.cancel) return state;
           }
         }
-        if (subject.objectDestruct !== void 0) {
-          for (const expr of subject.objectDestruct) {
+        if (subject.oDestr !== void 0) {
+          for (const expr of subject.oDestr) {
             state = visitNode(expr, state, stmtVisitor, exprVisitor, subject);
             if (state.cancel) return state;
           }
         }
-        if (subject.expression) {
-          state = visitNode(subject.expression, state, stmtVisitor, exprVisitor, subject, "expression");
+        if (subject.expr) {
+          state = visitNode(subject.expr, state, stmtVisitor, exprVisitor, subject, "expression");
         }
         if (state.cancel) return state;
       }
       state = (exprVisitor == null ? void 0 : exprVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "Destr":
-    case "ODestr":
-    case "ADestr": {
+    case T_DESTRUCTURE:
+    case T_OBJECT_DESTRUCTURE:
+    case T_ARRAY_DESTRUCTURE: {
       state = (exprVisitor == null ? void 0 : exprVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
-        if (subject.arrayDestruct !== void 0) {
-          for (const expr of subject.arrayDestruct) {
+        if (subject.aDestr !== void 0) {
+          for (const expr of subject.aDestr) {
             state = visitNode(expr, state, stmtVisitor, exprVisitor, subject);
             if (state.cancel) return state;
           }
         }
-        if (subject.objectDestruct !== void 0) {
-          for (const expr of subject.objectDestruct) {
+        if (subject.oDestr !== void 0) {
+          for (const expr of subject.oDestr) {
             state = visitNode(expr, state, stmtVisitor, exprVisitor, subject);
             if (state.cancel) return state;
           }
@@ -4792,19 +4740,21 @@ function visitNode(subject, state, stmtVisitor, exprVisitor, parent, tag) {
       state = (exprVisitor == null ? void 0 : exprVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "RVarD": {
+    case T_REACTIVE_VAR_DECLARATION: {
       state = (exprVisitor == null ? void 0 : exprVisitor(true, subject, state, parent, tag)) || state;
       if (state.cancel) return state;
       if (!state.skipChildren) {
-        if (subject.expression) {
-          state = visitNode(subject.expression, state, stmtVisitor, exprVisitor, subject, "expression");
+        if (subject.expr) {
+          state = visitNode(subject.expr, state, stmtVisitor, exprVisitor, subject, "expression");
         }
         if (state.cancel) return state;
       }
       state = (exprVisitor == null ? void 0 : exprVisitor(false, subject, state, parent, tag)) || state;
       return state;
     }
-    case "TempLitE":
+    case T_TEMPLATE_LITERAL_EXPRESSION:
+      return state;
+    case T_SWITCH_CASE:
       return state;
     default:
       return state;
@@ -4813,13 +4763,12 @@ function visitNode(subject, state, stmtVisitor, exprVisitor, parent, tag) {
 function isModuleErrors(result) {
   return result.type !== "ScriptModule";
 }
-function parseScriptModule(moduleName, source, moduleResolver, restrictiveMode = false) {
+function parseScriptModule(moduleName, source) {
   const parsedModules = /* @__PURE__ */ new Map();
   const moduleErrors = {};
-  const parsedModule = doParseModule(moduleName, source, moduleResolver, true);
+  const parsedModule = doParseModule(moduleName, source);
   return !parsedModule || Object.keys(moduleErrors).length > 0 ? moduleErrors : parsedModule;
-  function doParseModule(moduleName2, source2, moduleResolver2, topLevel = false) {
-    var _a;
+  function doParseModule(moduleName2, source2) {
     if (parsedModules.has(moduleName2)) {
       return parsedModules.get(moduleName2);
     }
@@ -4837,133 +4786,39 @@ function parseScriptModule(moduleName, source, moduleResolver, restrictiveMode =
       moduleErrors[moduleName2].push({
         code: "W002",
         text: errorMessages$1["W002"].replace(/\{(\d+)}/g, () => lastToken.text),
-        position: lastToken.location.startLine,
-        line: lastToken.location.startLine,
-        column: lastToken.location.startColumn
+        position: lastToken.startLine,
+        line: lastToken.startLine,
+        column: lastToken.startColumn
       });
       return null;
     }
     const errors = [];
-    const emptyState = {
-      data: null,
-      cancel: false,
-      skipChildren: false
-    };
-    visitNode(statements, emptyState, (before, stmt, state, parent, tag) => {
-      if (!before) return state;
-      if (topLevel) {
-        switch (stmt.type) {
-          case "VarS":
-            if (parent) {
-              addErrorMessage("W027", stmt);
-            }
-            break;
-          case "FuncD":
-          case "ImportD":
-            break;
-          default:
-            if (restrictiveMode && !parent) {
-              addErrorMessage("W028", stmt, stmt.type);
-            }
-            break;
-        }
-      } else {
-        switch (stmt.type) {
-          case "VarS":
-            addErrorMessage("W027", stmt);
-            break;
-          case "FuncD":
-            if (restrictiveMode && !stmt.isExported) {
-              addErrorMessage("W029", stmt);
-            }
-            break;
-          case "ImportD":
-            break;
-          default:
-            if (restrictiveMode && !parent) {
-              addErrorMessage("W028", stmt, stmt.type);
-            }
-            break;
-        }
-      }
-      return state;
-    });
     const functions = {};
-    statements.filter((stmt) => stmt.type === "FuncD").forEach((stmt) => {
+    statements.filter((stmt) => stmt.type === T_FUNCTION_DECLARATION).forEach((stmt) => {
       const func = stmt;
-      if (functions[func.name]) {
-        addErrorMessage("W020", stmt, func.name);
+      if (functions[func.id.name]) {
+        addErrorMessage("W020", stmt, func.id.name);
         return;
       }
-      functions[func.name] = func;
-    });
-    const exports = /* @__PURE__ */ new Map();
-    statements.forEach((stmt) => {
-      if (stmt.type === "ConstS" && stmt.isExported) {
-        visitLetConstDeclarations(stmt, (id) => {
-          if (exports.has(id)) {
-            addErrorMessage("W021", stmt, id);
-          } else {
-            exports.set(id, stmt);
-          }
-        });
-      } else if (stmt.type === "FuncD" && stmt.isExported) {
-        if (exports.has(stmt.name)) {
-          addErrorMessage("W021", stmt, stmt.name);
-        } else {
-          exports.set(stmt.name, stmt);
-        }
-      }
+      functions[func.id.name] = func;
     });
     const parsedModule2 = {
       type: "ScriptModule",
       name: moduleName2,
       exports,
-      importedModules: [],
-      imports: {},
       functions,
       statements,
+      sources: /* @__PURE__ */ new Map(),
       executed: false
     };
     parsedModules.set(moduleName2, parsedModule2);
-    const importedModules = [];
-    const imports = {};
-    for (let i = 0; i < statements.length; i++) {
-      const stmt = statements[i];
-      if (stmt.type !== "ImportD") {
-        continue;
-      }
-      const source3 = moduleResolver2(moduleName2, stmt.moduleFile);
-      if (source3 === null) {
-        addErrorMessage("W022", stmt, stmt.moduleFile);
-        continue;
-      }
-      const imported = doParseModule(stmt.moduleFile, source3, moduleResolver2);
-      if (!imported) {
-        return;
-      }
-      importedModules.push(imported);
-      const importedItems = Object.keys(stmt.imports);
-      if (importedItems.length > 0) {
-        imports[_a = stmt.moduleFile] ?? (imports[_a] = {});
-      }
-      for (const key of importedItems) {
-        if (imported.exports.has(stmt.imports[key])) {
-          imports[stmt.moduleFile][key] = imported.exports.get(stmt.imports[key]);
-        } else {
-          addErrorMessage("W023", stmt, stmt.moduleFile, key);
-        }
-      }
-    }
     if (errors.length > 0) {
       moduleErrors[moduleName2] = errors;
       return null;
     }
-    importedModules.forEach((m) => m.parent = parsedModule2);
-    parsedModule2.importedModules = importedModules;
-    parsedModule2.imports = imports;
     return parsedModule2;
     function addErrorMessage(code, stmt, ...args) {
+      var _a, _b, _c;
       let errorText = errorMessages$1[code];
       if (args) {
         args.forEach(
@@ -4973,150 +4828,70 @@ function parseScriptModule(moduleName, source, moduleResolver, restrictiveMode =
       errors.push({
         code,
         text: errorMessages$1[code].replace(/\{(\d+)}/g, (_, index) => args[index]),
-        position: stmt.startPosition,
-        line: stmt.startLine,
-        column: stmt.startColumn
+        position: (_a = stmt.startToken) == null ? void 0 : _a.startPosition,
+        line: (_b = stmt.startToken) == null ? void 0 : _b.startLine,
+        column: (_c = stmt.startToken) == null ? void 0 : _c.startColumn
       });
     }
   }
 }
-function obtainClosures(thread) {
-  var _a;
-  const closures = ((_a = thread.blocks) == null ? void 0 : _a.slice(0)) ?? [];
-  return thread.parent ? [...obtainClosures(thread.parent), ...closures] : closures;
-}
-function visitLetConstDeclarations(declaration, visitor) {
-  for (let i = 0; i < declaration.declarations.length; i++) {
-    const decl = declaration.declarations[i];
-    visitDeclaration(decl, visitor);
-  }
-  function visitDeclaration(varDecl, visitor2) {
-    if (varDecl.id) {
-      visitor2(varDecl.id);
-    } else if (varDecl.arrayDestruct) {
-      visitArrayDestruct(varDecl.arrayDestruct, visitor2);
-    } else if (varDecl.objectDestruct) {
-      visitObjectDestruct(varDecl.objectDestruct, visitor2);
-    } else {
-      throw new Error("Unknown declaration specifier");
-    }
-  }
-  function visitArrayDestruct(arrayD, visitor2) {
-    for (let i = 0; i < arrayD.length; i++) {
-      const arrDecl = arrayD[i];
-      if (arrDecl.id) {
-        visitor2(arrDecl.id);
-      } else if (arrDecl.arrayDestruct) {
-        visitArrayDestruct(arrDecl.arrayDestruct, visitor2);
-      } else if (arrDecl.objectDestruct) {
-        visitObjectDestruct(arrDecl.objectDestruct, visitor2);
-      }
-    }
-  }
-  function visitObjectDestruct(objectD, visitor2) {
-    for (let i = 0; i < objectD.length; i++) {
-      const objDecl = objectD[i];
-      if (objDecl.arrayDestruct) {
-        visitArrayDestruct(objDecl.arrayDestruct, visitor2);
-      } else if (objDecl.objectDestruct) {
-        visitObjectDestruct(objDecl.objectDestruct, visitor2);
-      } else {
-        visitor2(objDecl.alias ?? objDecl.id);
-      }
-    }
-  }
-}
 const PARSED_MARK_PROP = "__PARSED__";
-function collectCodeBehindFromSource(moduleName, source, moduleResolver, moduleNameResolver) {
+function collectCodeBehindFromSource(moduleName, source) {
   const result = {
     vars: {},
     moduleErrors: {},
     functions: {}
   };
   const collectedFunctions = {};
-  const parsedModule = parseScriptModule(moduleName, source, moduleResolver, true);
+  const parsedModule = parseScriptModule(moduleName, source);
   if (isModuleErrors(parsedModule)) {
     return { ...result, moduleErrors: parsedModule };
   }
-  const mainModuleResolvedName = moduleNameResolver(parsedModule.name);
   parsedModule.statements.forEach((stmt) => {
     switch (stmt.type) {
-      case "VarS":
-        stmt.declarations.forEach((decl) => {
-          if (decl.id in result.vars) {
-            throw new Error(`Duplicated var declaration: '${decl.id}'`);
+      case T_VAR_STATEMENT:
+        stmt.decls.forEach((decl) => {
+          if (decl.id.name in result.vars) {
+            throw new Error(`Duplicated var declaration: '${decl.id.name}'`);
           }
-          result.vars[decl.id] = {
+          result.vars[decl.id.name] = {
             [PARSED_MARK_PROP]: true,
-            source: decl.expression.source,
-            tree: decl.expression
+            tree: decl.expr
           };
         });
         break;
-      case "FuncD":
-        addFunctionDeclaration(mainModuleResolvedName, stmt);
-        break;
-      case "ImportD":
+      case T_FUNCTION_DECLARATION:
+        addFunctionDeclaration(stmt);
         break;
       default:
         throw new Error(`'${stmt.type}' is not allowed in a code-behind module.`);
     }
   });
-  collectFuncs(parsedModule);
   return result;
-  function collectFuncs(currentModule) {
-    var _a;
-    const resolvedModuleName = moduleNameResolver(currentModule.name);
-    if ((_a = collectedFunctions == null ? void 0 : collectedFunctions[resolvedModuleName]) == null ? void 0 : _a.collectedImportsFrom) {
-      return;
-    }
-    for (const modName in currentModule.imports) {
-      const resolvedImportedModuleName = moduleNameResolver(modName);
-      const mod = currentModule.imports[modName];
-      for (const obj of Object.values(mod)) {
-        if (obj.type === "FuncD") {
-          addFunctionDeclaration(resolvedImportedModuleName, obj);
-        }
-      }
-    }
-    collectedFunctions[resolvedModuleName] ?? (collectedFunctions[resolvedModuleName] = { collectedImportsFrom: true });
-    collectedFunctions[resolvedModuleName].collectedImportsFrom = true;
-    for (let nextModule of currentModule.importedModules) {
-      collectFuncs(nextModule);
-    }
-  }
-  function addFunctionDeclaration(resolvedModuleName, stmt) {
-    var _a2, _b, _c, _d;
-    var _a;
-    if (((_b = (_a2 = collectedFunctions == null ? void 0 : collectedFunctions[resolvedModuleName]) == null ? void 0 : _a2.functions) == null ? void 0 : _b[stmt.name]) !== void 0) {
+  function addFunctionDeclaration(stmt) {
+    if ((collectedFunctions == null ? void 0 : collectedFunctions[stmt.id.name]) !== void 0) {
       return;
     }
-    if (stmt.name in result.functions) {
-      throw new Error(`Duplicated function declaration: '${stmt.name}'`);
+    if (stmt.id.name in result.functions) {
+      throw new Error(`Duplicated function declaration: '${stmt.id.name}'`);
     }
-    const funcSource = stmt.args.length === 1 ? `${stmt.args[0].source} => ${stmt.statement.source}` : `(${stmt.args.map((a) => a.source).join(", ")}) => ${stmt.statement.source}`;
     const arrow = {
-      type: "ArrowE",
+      type: T_ARROW_EXPRESSION,
       args: stmt.args.slice(),
-      statement: stmt.statement,
-      closureContext: obtainClosures({
-        blocks: [{ vars: {} }]
-      })
+      statement: stmt.stmt
+      // closureContext: obtainClosures({
+      //   childThreads: [],
+      //   blocks: [{ vars: {} }],
+      //   loops: [],
+      //   breakLabelValue: -1,
+      // }),
     };
-    const functionSelf = (_d = (_c = arrow.closureContext[0]) == null ? void 0 : _c.vars) == null ? void 0 : _d[stmt.name];
-    if (functionSelf == null ? void 0 : functionSelf.closureContext) {
-      delete functionSelf.closureContext;
-    }
-    collectedFunctions[resolvedModuleName] ?? (collectedFunctions[resolvedModuleName] = { functions: {}, collectedImportsFrom: false });
-    (_a = collectedFunctions[resolvedModuleName]).functions ?? (_a.functions = {});
-    collectedFunctions[resolvedModuleName].functions[stmt.name] = {
+    collectedFunctions[stmt.id.name] = {
       [PARSED_MARK_PROP]: true,
-      source: funcSource,
       tree: arrow
     };
-    result.functions[stmt.name] = {
+    result.functions[stmt.id.name] = {
       [PARSED_MARK_PROP]: true,
-      source: funcSource,
       tree: arrow
     };
   }
@@ -5138,12 +4913,6 @@ function removeCodeBehindTokensFromTree(declarations) {
     const nodeVisitor = (before, visited, state2) => {
       if (before) {
         if (visited) {
-          delete visited.startPosition;
-          delete visited.endPosition;
-          delete visited.startLine;
-          delete visited.endLine;
-          delete visited.startColumn;
-          delete visited.endColumn;
           delete visited.startToken;
           delete visited.endToken;
         }
@@ -5226,7 +4995,7 @@ const HelperNode = {
   item: "item",
   field: "field"
 };
-function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () => "") {
+function nodeToComponentDef(node, originalGetText, fileId) {
   const getText = (node2) => {
     return node2.text ?? originalGetText(node2);
   };
@@ -5256,7 +5025,7 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
   function transformInnerElement(usesStack2, node2) {
     const name = getNamespaceResolvedComponentName(node2, getText, namespaceStack);
     if (name === COMPOUND_COMP_ID) {
-      reportError("T006");
+      reportError$1("T006");
     }
     let component = {
       type: name,
@@ -5275,10 +5044,10 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
     const attrs = getAttributes(node2).map(segmentAttr);
     const compoundName = attrs.find((attr) => attr.name === "name");
     if (!compoundName) {
-      reportError("T003");
+      reportError$1("T003");
     }
     if (!UCRegex.test(compoundName.value)) {
-      reportError("T004");
+      reportError$1("T004");
     }
     let api;
     const apiAttrs = attrs.filter((attr) => attr.startSegment === "method");
@@ -5325,10 +5094,7 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
     attrs.filter((attr) => attr.namespace === "xmlns").forEach((attr) => {
       addToNamespaces(namespaceStack, element2, attr.unsegmentedName, attr.value);
     });
-    let nestedComponent = transformInnerElement(
-      usesStack,
-      element2
-    );
+    let nestedComponent = transformInnerElement(usesStack, element2);
     namespaceStack.pop();
     const component = {
       name: compoundName.value,
@@ -5370,7 +5136,7 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
     childNodes.forEach((child) => {
       if (child.kind === SyntaxKind.Script) {
         if (getAttributes(child).length > 0) {
-          reportError("T022");
+          reportError$1("T022");
         }
         const scriptText = getText(child);
         const scriptContent = scriptText.slice(
@@ -5440,7 +5206,7 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
             },
             (name) => {
               if (onPrefixRegex.test(name)) {
-                reportError("T008", name);
+                reportError$1("T008", name);
               }
             }
           );
@@ -5483,7 +5249,7 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
           );
           return;
         default:
-          reportError("T009", childName);
+          reportError$1("T009", childName);
           return;
       }
     });
@@ -5494,12 +5260,7 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
     const parser = new Parser(comp.script);
     try {
       parser.parseStatements();
-      comp.scriptCollected = collectCodeBehindFromSource(
-        "Main",
-        comp.script,
-        moduleResolver,
-        (a) => a
-      );
+      comp.scriptCollected = collectCodeBehindFromSource("Main", comp.script);
     } catch (err) {
       if (parser.errors && parser.errors.length > 0) {
         comp.scriptError = parser.errors;
@@ -5520,14 +5281,14 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
     const isCompound = !isComponent(comp);
     if (isCompound) {
       if (startSegment && startSegment !== "method" && startSegment !== "var") {
-        reportError("T021");
+        reportError$1("T021");
         return;
       }
       if (name === "name" && !startSegment) {
         return;
       }
       if (!startSegment && name) {
-        reportError("T021", name);
+        reportError$1("T021", name);
       }
       return;
     }
@@ -5574,7 +5335,7 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
       if (child.kind !== SyntaxKind.ElementNode) return;
       const childName = getComponentName(child, getText);
       if (childName !== "field" && childName !== "item") {
-        reportError("T016");
+        reportError$1("T016");
         return;
       }
       if (childName === "field") {
@@ -5582,7 +5343,7 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
           nestedElementType = childName;
           result = {};
         } else if (nestedElementType !== childName) {
-          reportError("T017");
+          reportError$1("T017");
           return;
         }
       } else if (childName === "item") {
@@ -5590,7 +5351,7 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
           nestedElementType = childName;
           result = [];
         } else if (nestedElementType !== childName) {
-          reportError("T017");
+          reportError$1("T017");
           return;
         }
       }
@@ -5618,30 +5379,30 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
     const attributes = getAttributes(element2).map(segmentAttr);
     const attrProps = attributes.filter((attr) => propAttrs.indexOf(attr.name) >= 0);
     if (attributes.length > attrProps.length) {
-      reportError("T011", elementName);
+      reportError$1("T011", elementName);
       return null;
     }
     const nameAttr = attrProps.find((attr) => attr.name === "name");
     if (allowName) {
       if (!(nameAttr == null ? void 0 : nameAttr.value)) {
-        reportError("T012", elementName);
+        reportError$1("T012", elementName);
         return null;
       }
     } else {
       if (nameAttr) {
-        reportError("T018", elementName);
+        reportError$1("T018", elementName);
         return null;
       }
     }
     const name = nameAttr == null ? void 0 : nameAttr.value;
     const valueAttr = attrProps.find((attr) => attr.name === "value");
     if (valueAttr && valueAttr.value === void 0) {
-      reportError("T019", elementName);
+      reportError$1("T019", elementName);
       return null;
     }
     if (name && nestedComponents.length >= 1) {
       if (nestedElements.length > 0) {
-        reportError("T020");
+        reportError$1("T020");
         return null;
       }
       const nestedComps = nestedComponents.map((nc) => transformInnerElement(usesStack2, nc));
@@ -5662,7 +5423,7 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
   function collectLoadersElements(usesStack2, comp, loaders) {
     var _a;
     if (!isComponent(comp)) {
-      reportError("T009", "loaders");
+      reportError$1("T009", "loaders");
       return;
     }
     const children = getChildNodes(loaders);
@@ -5671,29 +5432,29 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
     }
     const hasAttribute = (_a = loaders.children) == null ? void 0 : _a.some((c) => c.kind === SyntaxKind.AttributeListNode);
     if (hasAttribute) {
-      reportError("T014", "attributes");
+      reportError$1("T014", "attributes");
       return;
     }
     children.forEach((loader) => {
       if (loader.kind === SyntaxKind.TextNode) {
-        reportError("T010", "loader");
+        reportError$1("T010", "loader");
         return;
       }
       const loaderDef = transformInnerElement(usesStack2, loader);
       if (!loaderDef.uid) {
-        reportError("T013");
+        reportError$1("T013");
         return;
       }
       if (loaderDef.vars) {
-        reportError("T014", "vars");
+        reportError$1("T014", "vars");
         return;
       }
       if (loaderDef.loaders) {
-        reportError("T014", "loaders");
+        reportError$1("T014", "loaders");
         return;
       }
       if (loaderDef.uses) {
-        reportError("T014", "uses");
+        reportError$1("T014", "uses");
         return;
       }
       comp.loaders ?? (comp.loaders = []);
@@ -5720,13 +5481,13 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
   }
   function collectUsesElements(comp, uses) {
     if (!isComponent(comp)) {
-      reportError("T009", "uses");
+      reportError$1("T009", "uses");
       return;
     }
     const attributes = getAttributes(uses).map(segmentAttr);
     const valueAttr = attributes.find((attr) => attr.name === "value");
     if (!(valueAttr == null ? void 0 : valueAttr.value) || attributes.length !== 1) {
-      reportError("T015", "uses");
+      reportError$1("T015", "uses");
       return;
     }
     comp.uses ?? (comp.uses = valueAttr.value.split(",").map((v) => v.trim()));
@@ -5741,7 +5502,7 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
     let unsegmentedName = getText(key.children[key.children.length - 1]);
     const segments = unsegmentedName.split(".");
     if (segments.length > 2) {
-      reportError("T007", attr, key);
+      reportError$1("T007", attr, key);
     }
     let name;
     let startSegment;
@@ -5749,7 +5510,7 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
       startSegment = segments[0];
       name = segments[1];
       if (name.trim() === "") {
-        reportError("T007", attr, name);
+        reportError$1("T007", attr, name);
       }
     } else {
       name = unsegmentedName;
@@ -6032,7 +5793,7 @@ function createTextNodeElement(textValue) {
     ]
   };
 }
-function reportError(errorCode, ...options) {
+function reportError$1(errorCode, ...options) {
   let errorText = errorMessages[errorCode] ?? "Unknown error";
   if (options) {
     options.forEach((o, idx) => errorText = replace(errorText, `{${idx}}`, o.toString()));
@@ -6135,17 +5896,17 @@ function desugarQuotelessAttrs(attrs, getText) {
 function addToNamespaces(namespaceStack, comp, nsKey, value) {
   let nsCommaSeparated = value.split(":");
   if (nsCommaSeparated.length > 2) {
-    return reportError("T028", value, "Namespace cannot contain multiple ':' (colon).");
+    return reportError$1("T028", value, "Namespace cannot contain multiple ':' (colon).");
   }
   let nsValue = value;
   if (nsCommaSeparated.length === 2) {
     if (nsCommaSeparated[0] != COMPONENT_NAMESPACE_SCHEME) {
-      return reportError("T029", value, COMPONENT_NAMESPACE_SCHEME);
+      return reportError$1("T029", value, COMPONENT_NAMESPACE_SCHEME);
     }
     nsValue = nsCommaSeparated[1];
   }
   if (nsValue.includes("#")) {
-    return reportError("T028", nsValue, "Namespace cannot contain character '#'.");
+    return reportError$1("T028", nsValue, "Namespace cannot contain character '#'.");
   }
   switch (nsValue) {
     case COMPONENT_NAMESPACE_SCHEME:
@@ -6160,7 +5921,7 @@ function addToNamespaces(namespaceStack, comp, nsKey, value) {
   }
   const compNamespaces = namespaceStack[namespaceStack.length - 1];
   if (compNamespaces.has(nsKey)) {
-    return reportError("T025", nsKey);
+    return reportError$1("T025", nsKey);
   }
   compNamespaces.set(nsKey, nsValue);
   comp.namespaces ?? (comp.namespaces = {});
@@ -6168,11 +5929,11 @@ function addToNamespaces(namespaceStack, comp, nsKey, value) {
 }
 function getTopLvlElement(node, getText) {
   if (node.children.length !== 2) {
-    reportError("T001");
+    reportError$1("T001");
   }
   const element = node.children[0];
   if (element.kind !== SyntaxKind.ElementNode) {
-    reportError("T001");
+    reportError$1("T001");
   }
   return element;
 }
@@ -6189,7 +5950,7 @@ function getNamespaceResolvedComponentName(node, getText, namespaceStack) {
   }
   const namespace = getText(nameTokens[0]);
   if (namespaceStack.length === 0) {
-    reportError("T026");
+    reportError$1("T026");
   }
   let resolvedNamespace = void 0;
   for (let i = namespaceStack.length - 1; i >= 0; --i) {
@@ -6199,7 +5960,7 @@ function getNamespaceResolvedComponentName(node, getText, namespaceStack) {
     }
   }
   if (resolvedNamespace === void 0) {
-    reportError("T027", namespace);
+    reportError$1("T027", namespace);
   }
   return resolvedNamespace + "." + name;
 }
@@ -6452,50 +6213,89 @@ function implicitProp(name) {
   return implicitPropNames.includes(name);
 }
 export {
-  getLintSeverity as A,
-  LintSeverity as B,
-  lintApp as C,
-  printComponentLints as D,
-  lintErrorsComponent as E,
-  collectCodeBehindFromSource as F,
-  removeCodeBehindTokensFromTree as G,
-  COMPOUND_COMP_ID as H,
-  moduleFileExtension as I,
-  LintDiagKind as J,
-  lint as K,
+  VariantPropsKeys as $,
+  T_DO_WHILE_STATEMENT as A,
+  T_WHILE_STATEMENT as B,
+  T_RETURN_STATEMENT as C,
+  T_IF_STATEMENT as D,
+  T_CONST_STATEMENT as E,
+  T_LET_STATEMENT as F,
+  T_ARROW_EXPRESSION_STATEMENT as G,
+  T_BLOCK_STATEMENT as H,
+  T_VAR_STATEMENT as I,
+  T_ASSIGNMENT_EXPRESSION as J,
+  T_LITERAL as K,
   LinkTargetMd as L,
-  ParserError2 as M,
-  errorMessages as N,
-  onPrefixRegex as O,
+  T_SPREAD_EXPRESSION as M,
+  T_FUNCTION_INVOCATION_EXPRESSION as N,
+  T_POSTFIX_OP_EXPRESSION as O,
   Parser as P,
-  CORE_NAMESPACE_VALUE as Q,
-  TextVariantElement as T,
-  UCRegex as U,
-  VariantPropsKeys as V,
+  T_CONDITIONAL_EXPRESSION as Q,
+  T_BINARY_EXPRESSION as R,
+  T_UNARY_EXPRESSION as S,
+  T_CALCULATED_MEMBER_ACCESS_EXPRESSION as T,
+  T_OBJECT_LITERAL as U,
+  T_ARRAY_LITERAL as V,
+  T_SEQUENCE_EXPRESSION as W,
+  T_TEMPLATE_LITERAL_EXPRESSION as X,
+  T_VAR_DECLARATION as Y,
+  T_DESTRUCTURE as Z,
+  TextVariantElement as _,
   alignmentOptionValues as a,
+  variantOptionsMd as a0,
+  scrollAnchoringValues as a1,
+  buttonThemeNames as a2,
+  iconPositionNames as a3,
+  buttonVariantNames as a4,
+  nodeToComponentDef as a5,
+  triggerPositionNames as a6,
+  statusColorMd as a7,
+  placementMd as a8,
+  httpMethodNames as a9,
+  PARSED_MARK_PROP as aa,
+  layoutOptionKeys as ab,
+  viewportSizeNames as ac,
+  componentFileExtension as ad,
+  codeBehindFileExtension as ae,
+  getLintSeverity as af,
+  LintSeverity as ag,
+  lintApp as ah,
+  printComponentLints as ai,
+  lintErrorsComponent as aj,
+  collectCodeBehindFromSource as ak,
+  removeCodeBehindTokensFromTree as al,
+  COMPOUND_COMP_ID as am,
+  moduleFileExtension as an,
+  LintDiagKind as ao,
+  lint as ap,
+  ParserError2 as aq,
+  errorMessages as ar,
+  UCRegex as as,
+  onPrefixRegex as at,
+  CORE_NAMESPACE_VALUE as au,
   alignmentOptionMd as b,
   buttonTypesMd as c,
   buttonThemeMd as d,
   buttonVariantMd as e,
-  obtainClosures as f,
-  variantOptionsMd as g,
-  scrollAnchoringValues as h,
+  T_MEMBER_ACCESS_EXPRESSION as f,
+  T_IDENTIFIER as g,
+  T_PREFIX_OP_EXPRESSION as h,
   iconPositionMd as i,
-  buttonThemeNames as j,
-  iconPositionNames as k,
+  T_FUNCTION_DECLARATION as j,
+  T_ARROW_EXPRESSION as k,
   labelPositionMd as l,
-  buttonVariantNames as m,
-  nodeToComponentDef as n,
+  createXmlUiTreeNodeId as m,
+  T_EMPTY_STATEMENT as n,
   orientationOptionMd as o,
-  statusColorMd as p,
-  placementMd as q,
-  httpMethodNames as r,
+  T_SWITCH_STATEMENT as p,
+  T_TRY_STATEMENT as q,
+  T_THROW_STATEMENT as r,
   sizeMd as s,
-  triggerPositionNames as t,
-  PARSED_MARK_PROP as u,
+  T_FOR_OF_STATEMENT as t,
+  T_FOR_IN_STATEMENT as u,
   validationStatusMd as v,
-  layoutOptionKeys as w,
-  viewportSizeNames as x,
-  componentFileExtension as y,
-  codeBehindFileExtension as z
+  T_FOR_STATEMENT as w,
+  T_EXPRESSION_STATEMENT as x,
+  T_BREAK_STATEMENT as y,
+  T_CONTINUE_STATEMENT as z
 };