xmlui 0.9.0 → 0.9.2

package/dist/scripts/src/parsers/scripting/Parser.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Parser = void 0;
-const Token_1 = require("../../abstractions/scripting/Token");
+exports.createXmlUiTreeNodeId = createXmlUiTreeNodeId;
+const ScriptingSourceTree_1 = require("../../abstractions/scripting/ScriptingSourceTree");
 const InputStream_1 = require("../common/InputStream");
-const TokenTrait_1 = require("./TokenTrait");
 const Lexer_1 = require("./Lexer");
 const ParserError_1 = require("./ParserError");
+const TokenTrait_1 = require("./TokenTrait");
+const TokenType_1 = require("./TokenType");
 /**
  * States of the string parsing
  */
@@ -27,6 +29,10 @@ var StrParseState;
     StrParseState[StrParseState["Ucp6"] = 13] = "Ucp6";
     StrParseState[StrParseState["UcpTail"] = 14] = "UcpTail";
 })(StrParseState || (StrParseState = {}));
+let lastNodeId = 0;
+function createXmlUiTreeNodeId() {
+    return ++lastNodeId;
+}
 /**
  * This class parses a binding expression and transforms it into an evaluable expression tree
  */
@@ -36,11 +42,17 @@ class Parser {
      * @param source Source code to parse
      */
     constructor(source) {
-        this.source = source;
         // --- Keep track of error messages
         this._parseErrors = [];
         // --- Indicates the parsing level
         this._statementLevel = 0;
+        this._lexer = new Lexer_1.Lexer(new InputStream_1.InputStream(source !== null && source !== void 0 ? source : ""));
+    }
+    /**
+     * Sets the source code to parse
+     * @param source Source code to parse
+     */
+    setSource(source) {
         this._lexer = new Lexer_1.Lexer(new InputStream_1.InputStream(source));
     }
     /**
@@ -59,7 +71,7 @@ class Parser {
      * Checks if we're at the end of the expression
      */
     get isEof() {
-        return this._lexer.peek().type === Token_1.TokenType.Eof;
+        return this._lexer.peek().type === TokenType_1.TokenType.Eof;
     }
     /**
      * Gets the characters remaining after parsing
@@ -91,8 +103,8 @@ class Parser {
             if (!statement)
                 return null;
             statements.push(statement);
-            if (statement.type !== "EmptyS") {
-                this.skipToken(Token_1.TokenType.Semicolon);
+            if (statement.type !== ScriptingSourceTree_1.T_EMPTY_STATEMENT) {
+                this.skipToken(TokenType_1.TokenType.Semicolon);
             }
         }
         return statements;
@@ -105,54 +117,44 @@ class Parser {
         try {
             const startToken = this._lexer.peek();
             switch (startToken.type) {
-                case Token_1.TokenType.Semicolon:
+                case TokenType_1.TokenType.Semicolon:
                     return this.parseEmptyStatement();
-                case Token_1.TokenType.Let:
+                case TokenType_1.TokenType.Let:
                     return this.parseLetStatement();
-                case Token_1.TokenType.Const:
+                case TokenType_1.TokenType.Const:
                     return this.parseConstStatement();
-                case Token_1.TokenType.Var:
+                case TokenType_1.TokenType.Var:
                     return this.parseVarStatement();
-                case Token_1.TokenType.LBrace:
+                case TokenType_1.TokenType.LBrace:
                     return this.parseBlockStatement();
-                case Token_1.TokenType.If:
+                case TokenType_1.TokenType.If:
                     return this.parseIfStatement();
-                case Token_1.TokenType.Do:
+                case TokenType_1.TokenType.Do:
                     return this.parseDoWhileStatement();
-                case Token_1.TokenType.While:
+                case TokenType_1.TokenType.While:
                     return this.parseWhileStatement();
-                case Token_1.TokenType.Return:
+                case TokenType_1.TokenType.Return:
                     return this.parseReturnStatement();
-                case Token_1.TokenType.Break:
+                case TokenType_1.TokenType.Break:
                     this._lexer.get();
-                    return this.createStatementNode("BrkS", {}, startToken, startToken);
-                case Token_1.TokenType.Continue:
+                    return this.createStatementNode(ScriptingSourceTree_1.T_BREAK_STATEMENT, {}, startToken, startToken);
+                case TokenType_1.TokenType.Continue:
                     this._lexer.get();
-                    return this.createStatementNode("ContS", {}, startToken, startToken);
-                case Token_1.TokenType.For:
+                    return this.createStatementNode(ScriptingSourceTree_1.T_CONTINUE_STATEMENT, {}, startToken, startToken);
+                case TokenType_1.TokenType.For:
                     return this.parseForStatement();
-                case Token_1.TokenType.Throw:
+                case TokenType_1.TokenType.Throw:
                     return this.parseThrowStatement();
-                case Token_1.TokenType.Try:
+                case TokenType_1.TokenType.Try:
                     return this.parseTryStatement();
-                case Token_1.TokenType.Switch:
+                case TokenType_1.TokenType.Switch:
                     return this.parseSwitchStatement();
-                case Token_1.TokenType.Function:
+                case TokenType_1.TokenType.Function:
                     return this.parseFunctionDeclaration();
-                case Token_1.TokenType.Export:
-                    return this.parseExport();
-                case Token_1.TokenType.Import:
-                    return this.parseImport();
                 default:
-                    if (startToken.type === Token_1.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 {
@@ -168,7 +170,7 @@ class Parser {
      */
     parseEmptyStatement() {
         const startToken = this._lexer.get();
-        return this.createStatementNode("EmptyS", {}, startToken, startToken);
+        return this.createStatementNode(ScriptingSourceTree_1.T_EMPTY_STATEMENT, {}, startToken, startToken);
     }
     /**
      * Parses an expression statement
@@ -179,11 +181,11 @@ class Parser {
      */
     parseExpressionStatement(allowSequence = true) {
         const startToken = this._lexer.peek();
-        const expression = this.getExpression(allowSequence);
-        return expression
-            ? this.createStatementNode("ExprS", {
-                expression,
-            }, startToken, expression.endToken)
+        const expr = this.getExpression(allowSequence);
+        return expr
+            ? this.createStatementNode(ScriptingSourceTree_1.T_EXPRESSION_STATEMENT, {
+                expr,
+            }, startToken, expr.endToken)
             : null;
     }
     /**
@@ -196,35 +198,33 @@ 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 === Token_1.TokenType.LBrace) {
+            if (declStart.type === TokenType_1.TokenType.LBrace) {
                 // --- This is object destructure
                 endToken = this._lexer.ahead(1);
-                const objectDestruct = this.parseObjectDestructure();
-                if (objectDestruct === 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 === Token_1.TokenType.LSquare) {
+            else if (declStart.type === TokenType_1.TokenType.LSquare) {
                 // --- This is array destructure
                 endToken = this._lexer.ahead(1);
-                const arrayDestruct = this.parseArrayDestructure();
-                if (arrayDestruct === 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 === Token_1.TokenType.Identifier) {
+            else if (declStart.type === TokenType_1.TokenType.Identifier) {
                 if (declStart.text.startsWith("$")) {
                     this.reportError("W031");
                     return null;
@@ -240,29 +240,29 @@ class Parser {
             }
             // --- Optional initialization
             const initToken = this._lexer.peek();
-            let expression = null;
-            if (initToken.type === Token_1.TokenType.Assignment) {
+            let expr = null;
+            if (initToken.type === TokenType_1.TokenType.Assignment) {
                 this._lexer.get();
-                expression = this.getExpression(false);
-                if (expression === null)
+                expr = this.getExpression(false);
+                if (expr === null)
                     return null;
-                declarationProps.expression = expression;
-                endToken = expression.endToken;
+                declarationProps.expr = expr;
+                endToken = expr.endToken;
             }
-            else if (declarationProps.arrayDestruct || declarationProps.objectDestruct) {
+            else if (declarationProps.aDestr || declarationProps.oDestr) {
                 this.reportError("W009", initToken);
                 return null;
             }
             // --- New declaration reached
-            declarations.push(this.createExpressionNode("VarD", declarationProps, declStart, endToken));
+            decls.push(this.createExpressionNode(ScriptingSourceTree_1.T_VAR_DECLARATION, declarationProps, declStart, endToken));
             // --- Check for more declarations
-            if (this._lexer.peek().type !== Token_1.TokenType.Comma)
+            if (this._lexer.peek().type !== TokenType_1.TokenType.Comma)
                 break;
             this._lexer.get();
         }
         // --- Done
-        return this.createStatementNode("LetS", {
-            declarations,
+        return this.createStatementNode(ScriptingSourceTree_1.T_LET_STATEMENT, {
+            decls,
         }, startToken, endToken);
     }
     /**
@@ -275,35 +275,33 @@ 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 === Token_1.TokenType.LBrace) {
+            if (declStart.type === TokenType_1.TokenType.LBrace) {
                 // --- This is object destructure
                 endToken = this._lexer.ahead(1);
-                const objectDestruct = this.parseObjectDestructure();
-                if (objectDestruct === 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 === Token_1.TokenType.LSquare) {
+            else if (declStart.type === TokenType_1.TokenType.LSquare) {
                 // --- This is array destructure
                 endToken = this._lexer.ahead(1);
-                const arrayDestruct = this.parseArrayDestructure();
-                if (arrayDestruct === 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 === Token_1.TokenType.Identifier) {
+            else if (declStart.type === TokenType_1.TokenType.Identifier) {
                 if (declStart.text.startsWith("$")) {
                     this.reportError("W031");
                     return null;
@@ -317,26 +315,26 @@ class Parser {
                 this.reportError("W003");
                 return null;
             }
-            this.expectToken(Token_1.TokenType.Assignment);
-            const expression = this.getExpression(false);
-            if (expression === null)
+            this.expectToken(TokenType_1.TokenType.Assignment);
+            const expr = this.getExpression(false);
+            if (expr === null)
                 return null;
-            declarationProps.expression = expression;
-            endToken = expression.endToken;
+            declarationProps.expr = expr;
+            endToken = expr.endToken;
             // --- New declaration reached
-            declarations.push(this.createExpressionNode("VarD", declarationProps, declStart, endToken));
+            decls.push(this.createExpressionNode(ScriptingSourceTree_1.T_VAR_DECLARATION, declarationProps, declStart, endToken));
             // --- Check for more declarations
-            if (this._lexer.peek().type !== Token_1.TokenType.Comma)
+            if (this._lexer.peek().type !== TokenType_1.TokenType.Comma)
                 break;
             this._lexer.get();
         }
         // --- Done
-        return this.createStatementNode("ConstS", {
-            declarations,
+        return this.createStatementNode(ScriptingSourceTree_1.T_CONST_STATEMENT, {
+            decls,
         }, startToken, endToken);
     }
     /**
-     * Parses a const statement
+     * Parses a var statement
      *
      * constStatement
      *   : "var" id "=" expression
@@ -345,18 +343,23 @@ class Parser {
     parseVarStatement() {
         const startToken = this._lexer.get();
         let endToken = startToken;
-        const declarations = [];
+        const decls = [];
         while (true) {
             const declStart = this._lexer.peek();
             let declarationProps = {};
-            if (declStart.type === Token_1.TokenType.Identifier) {
+            if (declStart.type === TokenType_1.TokenType.Identifier) {
                 if (declStart.text.startsWith("$")) {
                     this.reportError("W031");
                     return null;
                 }
                 endToken = this._lexer.get();
                 declarationProps = {
-                    id: declStart.text,
+                    id: {
+                        type: ScriptingSourceTree_1.T_IDENTIFIER,
+                        name: declStart.text,
+                        startToken: declStart,
+                        endToken,
+                    },
                 };
             }
             else {
@@ -364,22 +367,22 @@ class Parser {
                 return null;
             }
             // --- Mandatory initialization
-            this.expectToken(Token_1.TokenType.Assignment);
-            const expression = this.getExpression(false);
-            if (expression === null)
+            this.expectToken(TokenType_1.TokenType.Assignment);
+            const expr = this.getExpression(false);
+            if (expr === null)
                 return null;
-            declarationProps.expression = expression;
-            endToken = expression.endToken;
+            declarationProps.expr = expr;
+            endToken = expr.endToken;
             // --- New declaration reached
-            declarations.push(this.createExpressionNode("RVarD", declarationProps, declStart, endToken));
+            decls.push(this.createExpressionNode(ScriptingSourceTree_1.T_REACTIVE_VAR_DECLARATION, declarationProps, declStart, endToken));
             // --- Check for more declarations
-            if (this._lexer.peek().type !== Token_1.TokenType.Comma)
+            if (this._lexer.peek().type !== TokenType_1.TokenType.Comma)
                 break;
             this._lexer.get();
         }
         // --- Done
-        return this.createStatementNode("VarS", {
-            declarations,
+        return this.createStatementNode(ScriptingSourceTree_1.T_VAR_STATEMENT, {
+            decls,
         }, startToken, endToken);
     }
     /**
@@ -391,7 +394,7 @@ class Parser {
         const startToken = this._lexer.get();
         let endToken = startToken;
         let nextToken = this._lexer.peek();
-        while (nextToken.type === Token_1.TokenType.Identifier) {
+        while (nextToken.type === TokenType_1.TokenType.Identifier) {
             // --- Obtain the ID
             const id = nextToken.text;
             if (id.startsWith("$")) {
@@ -399,37 +402,37 @@ class Parser {
                 return null;
             }
             let alias;
-            let arrayDestruct;
-            let objectDestruct;
+            let aDestr;
+            let oDestr;
             this._lexer.get();
             nextToken = this._lexer.peek();
-            if (nextToken.type === Token_1.TokenType.Colon) {
+            if (nextToken.type === TokenType_1.TokenType.Colon) {
                 // --- Check the available cases
                 this._lexer.get();
                 nextToken = this._lexer.peek();
-                if (nextToken.type === Token_1.TokenType.Identifier) {
+                if (nextToken.type === TokenType_1.TokenType.Identifier) {
                     alias = nextToken.text;
                     endToken = nextToken;
                     this._lexer.get();
                 }
-                else if (nextToken.type === Token_1.TokenType.LSquare) {
-                    arrayDestruct = this.parseArrayDestructure();
-                    if (arrayDestruct === null)
+                else if (nextToken.type === TokenType_1.TokenType.LSquare) {
+                    aDestr = this.parseArrayDestructure();
+                    if (aDestr === null)
                         return null;
-                    endToken = arrayDestruct[arrayDestruct.length - 1].endToken;
+                    endToken = aDestr[aDestr.length - 1].endToken;
                 }
-                else if (nextToken.type === Token_1.TokenType.LBrace) {
-                    objectDestruct = this.parseObjectDestructure();
-                    if (objectDestruct === null)
+                else if (nextToken.type === TokenType_1.TokenType.LBrace) {
+                    oDestr = this.parseObjectDestructure();
+                    if (oDestr === null)
                         return null;
-                    endToken = objectDestruct[objectDestruct.length - 1].endToken;
+                    endToken = oDestr[oDestr.length - 1].endToken;
                 }
             }
             // --- Check for next segment
             nextToken = this._lexer.peek();
-            if (nextToken.type === Token_1.TokenType.Comma || nextToken.type === Token_1.TokenType.RBrace) {
-                result.push(this.createExpressionNode("ODestr", { id, alias, arrayDestruct, objectDestruct }, startToken, endToken));
-                if (nextToken.type === Token_1.TokenType.Comma) {
+            if (nextToken.type === TokenType_1.TokenType.Comma || nextToken.type === TokenType_1.TokenType.RBrace) {
+                result.push(this.createExpressionNode(ScriptingSourceTree_1.T_OBJECT_DESTRUCTURE, { id, alias, aDestr, oDestr }, startToken, endToken));
+                if (nextToken.type === TokenType_1.TokenType.Comma) {
                     // --- Skip the delimiter comma
                     this._lexer.get();
                     nextToken = this._lexer.peek();
@@ -437,7 +440,7 @@ class Parser {
             }
         }
         // --- Expect a closing right brace
-        this.expectToken(Token_1.TokenType.RBrace, "W004");
+        this.expectToken(TokenType_1.TokenType.RBrace, "W004");
         return result;
     }
     parseArrayDestructure() {
@@ -448,9 +451,9 @@ class Parser {
         do {
             let nextToken = this._lexer.peek();
             let id;
-            let arrayDestruct;
-            let objectDestruct;
-            if (nextToken.type === Token_1.TokenType.Identifier) {
+            let aDestr;
+            let oDestr;
+            if (nextToken.type === TokenType_1.TokenType.Identifier) {
                 id = nextToken.text;
                 if (id.startsWith("$")) {
                     this.reportError("W031");
@@ -459,28 +462,28 @@ class Parser {
                 endToken = nextToken;
                 nextToken = this._lexer.get();
             }
-            else if (nextToken.type === Token_1.TokenType.LSquare) {
-                arrayDestruct = this.parseArrayDestructure();
-                if (arrayDestruct === null)
+            else if (nextToken.type === TokenType_1.TokenType.LSquare) {
+                aDestr = this.parseArrayDestructure();
+                if (aDestr === null)
                     return null;
-                endToken = arrayDestruct[arrayDestruct.length - 1].endToken;
+                endToken = aDestr[aDestr.length - 1].endToken;
             }
-            else if (nextToken.type === Token_1.TokenType.LBrace) {
-                objectDestruct = this.parseObjectDestructure();
-                if (objectDestruct === null)
+            else if (nextToken.type === TokenType_1.TokenType.LBrace) {
+                oDestr = this.parseObjectDestructure();
+                if (oDestr === null)
                     return null;
-                endToken = objectDestruct[objectDestruct.length - 1].endToken;
+                endToken = oDestr[oDestr.length - 1].endToken;
             }
             nextToken = this._lexer.peek();
-            if (nextToken.type === Token_1.TokenType.Comma) {
+            if (nextToken.type === TokenType_1.TokenType.Comma) {
                 // --- Store the segment
-                result.push(this.createExpressionNode("ADestr", { id, arrayDestruct, objectDestruct }, startToken, endToken));
+                result.push(this.createExpressionNode(ScriptingSourceTree_1.T_ARRAY_DESTRUCTURE, { id, aDestr, oDestr }, startToken, endToken));
                 this._lexer.get();
             }
-            else if (nextToken.type === Token_1.TokenType.RSquare) {
-                if (id || arrayDestruct || objectDestruct) {
+            else if (nextToken.type === TokenType_1.TokenType.RSquare) {
+                if (id || aDestr || oDestr) {
                     // --- Store a non-empty the segment
-                    result.push(this.createExpressionNode("ADestr", { id, arrayDestruct, objectDestruct }, startToken, endToken));
+                    result.push(this.createExpressionNode(ScriptingSourceTree_1.T_ARRAY_DESTRUCTURE, { id, aDestr, oDestr }, startToken, endToken));
                 }
                 break;
             }
@@ -490,7 +493,7 @@ class Parser {
             }
         } while (true);
         // --- Expect a closing right square
-        this.expectToken(Token_1.TokenType.RSquare, "W005");
+        this.expectToken(TokenType_1.TokenType.RSquare, "W005");
         return result;
     }
     /**
@@ -502,18 +505,18 @@ class Parser {
      */
     parseBlockStatement() {
         const startToken = this._lexer.get();
-        const statements = [];
-        while (this._lexer.peek().type !== Token_1.TokenType.RBrace) {
+        const stmts = [];
+        while (this._lexer.peek().type !== TokenType_1.TokenType.RBrace) {
             const statement = this.parseStatement();
             if (!statement)
                 return null;
-            statements.push(statement);
-            if (statement.type !== "EmptyS") {
-                this.skipToken(Token_1.TokenType.Semicolon);
+            stmts.push(statement);
+            if (statement.type !== ScriptingSourceTree_1.T_EMPTY_STATEMENT) {
+                this.skipToken(TokenType_1.TokenType.Semicolon);
             }
         }
         const endToken = this._lexer.get();
-        return this.createStatementNode("BlockS", { statements }, startToken, endToken);
+        return this.createStatementNode(ScriptingSourceTree_1.T_BLOCK_STATEMENT, { stmts }, startToken, endToken);
     }
     /**
      * Parses an if statement
@@ -525,37 +528,37 @@ class Parser {
     parseIfStatement() {
         const startToken = this._lexer.get();
         let endToken = startToken;
-        this.expectToken(Token_1.TokenType.LParent, "W014");
-        const condition = this.getExpression();
-        if (!condition)
+        this.expectToken(TokenType_1.TokenType.LParent, "W014");
+        const cond = this.getExpression();
+        if (!cond)
             return null;
-        this.expectToken(Token_1.TokenType.RParent, "W006");
-        const thenBranch = this.parseStatement();
-        if (!thenBranch)
+        this.expectToken(TokenType_1.TokenType.RParent, "W006");
+        const thenB = this.parseStatement();
+        if (!thenB)
             return null;
-        endToken = thenBranch.endToken;
+        endToken = thenB.endToken;
         let elseCanFollow = true;
-        if (thenBranch.type !== "BlockS") {
+        if (thenB.type !== ScriptingSourceTree_1.T_BLOCK_STATEMENT) {
             // --- We need a closing semicolon before else
-            if (this._lexer.peek().type === Token_1.TokenType.Semicolon) {
+            if (this._lexer.peek().type === TokenType_1.TokenType.Semicolon) {
                 this._lexer.get();
             }
             else {
                 elseCanFollow = false;
             }
         }
-        let elseBranch = null;
-        if (elseCanFollow && this._lexer.peek().type === Token_1.TokenType.Else) {
+        let elseB = null;
+        if (elseCanFollow && this._lexer.peek().type === TokenType_1.TokenType.Else) {
             this._lexer.get();
-            elseBranch = this.parseStatement();
-            if (!elseBranch)
+            elseB = this.parseStatement();
+            if (!elseB)
                 return null;
-            endToken = elseBranch.endToken;
+            endToken = elseB.endToken;
         }
-        return this.createStatementNode("IfS", {
-            condition,
-            thenBranch,
-            elseBranch,
+        return this.createStatementNode(ScriptingSourceTree_1.T_IF_STATEMENT, {
+            cond,
+            thenB,
+            elseB,
         }, startToken, endToken);
     }
     /**
@@ -567,16 +570,16 @@ class Parser {
      */
     parseWhileStatement() {
         const startToken = this._lexer.get();
-        this.expectToken(Token_1.TokenType.LParent, "W014");
-        const condition = this.getExpression();
-        if (!condition)
+        this.expectToken(TokenType_1.TokenType.LParent, "W014");
+        const cond = this.getExpression();
+        if (!cond)
             return null;
-        this.expectToken(Token_1.TokenType.RParent, "W006");
+        this.expectToken(TokenType_1.TokenType.RParent, "W006");
         const body = this.parseStatement();
         if (!body)
             return null;
-        return this.createStatementNode("WhileS", {
-            condition,
+        return this.createStatementNode(ScriptingSourceTree_1.T_WHILE_STATEMENT, {
+            cond,
             body,
         }, startToken, body.endToken);
     }
@@ -592,18 +595,18 @@ class Parser {
         const body = this.parseStatement();
         if (!body)
             return null;
-        if (body.type !== "BlockS" && body.type !== "EmptyS") {
-            this.expectToken(Token_1.TokenType.Semicolon);
+        if (body.type !== ScriptingSourceTree_1.T_BLOCK_STATEMENT && body.type !== ScriptingSourceTree_1.T_EMPTY_STATEMENT) {
+            this.expectToken(TokenType_1.TokenType.Semicolon);
         }
-        this.expectToken(Token_1.TokenType.While);
-        this.expectToken(Token_1.TokenType.LParent, "W014");
-        const condition = this.getExpression();
-        if (!condition)
+        this.expectToken(TokenType_1.TokenType.While);
+        this.expectToken(TokenType_1.TokenType.LParent, "W014");
+        const cond = this.getExpression();
+        if (!cond)
             return null;
         const endToken = this._lexer.peek();
-        this.expectToken(Token_1.TokenType.RParent, "W006");
-        return this.createStatementNode("DoWS", {
-            condition,
+        this.expectToken(TokenType_1.TokenType.RParent, "W006");
+        return this.createStatementNode(ScriptingSourceTree_1.T_DO_WHILE_STATEMENT, {
+            cond,
             body,
         }, startToken, endToken);
     }
@@ -617,15 +620,15 @@ class Parser {
     parseReturnStatement() {
         const startToken = this._lexer.peek();
         let endToken = this._lexer.get();
-        let expression;
+        let expr;
         if (TokenTrait_1.tokenTraits[this._lexer.peek().type].expressionStart) {
-            expression = this.getExpression();
-            if (expression === null)
+            expr = this.getExpression();
+            if (expr === null)
                 return null;
-            endToken = expression.endToken;
+            endToken = expr.endToken;
         }
-        return this.createStatementNode("RetS", {
-            expression,
+        return this.createStatementNode(ScriptingSourceTree_1.T_RETURN_STATEMENT, {
+            expr,
         }, startToken, endToken);
     }
     /**
@@ -637,60 +640,60 @@ class Parser {
     parseForStatement() {
         const startToken = this._lexer.peek();
         this._lexer.get();
-        this.expectToken(Token_1.TokenType.LParent, "W014");
+        this.expectToken(TokenType_1.TokenType.LParent, "W014");
         // --- Check for..in and for..of
         let nextToken = this._lexer.peek();
-        if (nextToken.type === Token_1.TokenType.Identifier) {
-            if (this._lexer.ahead(1).type === Token_1.TokenType.In) {
-                return this.parseForInOfStatement(startToken, "none", nextToken.text, "ForInS");
+        if (nextToken.type === TokenType_1.TokenType.Identifier) {
+            if (this._lexer.ahead(1).type === TokenType_1.TokenType.In) {
+                return this.parseForInOfStatement(startToken, "none", nextToken, ScriptingSourceTree_1.T_FOR_IN_STATEMENT);
             }
-            else if (this._lexer.ahead(1).type === Token_1.TokenType.Of) {
-                return this.parseForInOfStatement(startToken, "none", nextToken.text, "ForOfS");
+            else if (this._lexer.ahead(1).type === TokenType_1.TokenType.Of) {
+                return this.parseForInOfStatement(startToken, "none", nextToken, ScriptingSourceTree_1.T_FOR_OF_STATEMENT);
             }
         }
-        else if (nextToken.type === Token_1.TokenType.Let) {
+        else if (nextToken.type === TokenType_1.TokenType.Let) {
             const idToken = this._lexer.ahead(1);
-            if (idToken.type === Token_1.TokenType.Identifier) {
+            if (idToken.type === TokenType_1.TokenType.Identifier) {
                 const inOfToken = this._lexer.ahead(2);
-                if (inOfToken.type === Token_1.TokenType.In) {
-                    return this.parseForInOfStatement(startToken, "let", idToken.text, "ForInS");
+                if (inOfToken.type === TokenType_1.TokenType.In) {
+                    return this.parseForInOfStatement(startToken, "let", idToken, ScriptingSourceTree_1.T_FOR_IN_STATEMENT);
                 }
-                else if (inOfToken.type === Token_1.TokenType.Of) {
-                    return this.parseForInOfStatement(startToken, "let", idToken.text, "ForOfS");
+                else if (inOfToken.type === TokenType_1.TokenType.Of) {
+                    return this.parseForInOfStatement(startToken, "let", idToken, ScriptingSourceTree_1.T_FOR_OF_STATEMENT);
                 }
             }
         }
-        else if (nextToken.type === Token_1.TokenType.Const) {
+        else if (nextToken.type === TokenType_1.TokenType.Const) {
             const idToken = this._lexer.ahead(1);
-            if (idToken.type === Token_1.TokenType.Identifier) {
+            if (idToken.type === TokenType_1.TokenType.Identifier) {
                 const inOfToken = this._lexer.ahead(2);
-                if (inOfToken.type === Token_1.TokenType.In) {
-                    return this.parseForInOfStatement(startToken, "const", idToken.text, "ForInS");
+                if (inOfToken.type === TokenType_1.TokenType.In) {
+                    return this.parseForInOfStatement(startToken, "const", idToken, ScriptingSourceTree_1.T_FOR_IN_STATEMENT);
                 }
-                else if (inOfToken.type === Token_1.TokenType.Of) {
-                    return this.parseForInOfStatement(startToken, "const", idToken.text, "ForOfS");
+                else if (inOfToken.type === TokenType_1.TokenType.Of) {
+                    return this.parseForInOfStatement(startToken, "const", idToken, ScriptingSourceTree_1.T_FOR_OF_STATEMENT);
                 }
             }
         }
         // --- We accept only let statement, empty statement, and expression
         let init;
         nextToken = this._lexer.peek();
-        if (nextToken.type === Token_1.TokenType.Semicolon) {
+        if (nextToken.type === TokenType_1.TokenType.Semicolon) {
             // --- Empty statement: no init in the for loop
             this._lexer.get();
         }
-        else if (nextToken.type === Token_1.TokenType.Let) {
+        else if (nextToken.type === TokenType_1.TokenType.Let) {
             // --- Let statement
             const letStmt = this.parseLetStatement();
             if (letStmt === null) {
                 return null;
             }
             init = letStmt;
-            if (init.declarations.some((d) => !d.expression)) {
+            if (init.decls.some((d) => !d.expr)) {
                 this.reportError("W011");
                 return null;
             }
-            this.expectToken(Token_1.TokenType.Semicolon);
+            this.expectToken(TokenType_1.TokenType.Semicolon);
         }
         else if (TokenTrait_1.tokenTraits[nextToken.type].expressionStart) {
             // --- Expression statement
@@ -699,41 +702,41 @@ class Parser {
                 return null;
             }
             init = exprStmt;
-            this.expectToken(Token_1.TokenType.Semicolon);
+            this.expectToken(TokenType_1.TokenType.Semicolon);
         }
         // --- Parse the condition
-        let condition;
+        let cond;
         nextToken = this._lexer.peek();
-        if (nextToken.type === Token_1.TokenType.Semicolon) {
+        if (nextToken.type === TokenType_1.TokenType.Semicolon) {
             // --- No condition
             this._lexer.get();
         }
         else {
-            condition = this.getExpression();
-            if (condition === null) {
+            cond = this.getExpression();
+            if (cond === null) {
                 return null;
             }
-            this.expectToken(Token_1.TokenType.Semicolon);
+            this.expectToken(TokenType_1.TokenType.Semicolon);
         }
         // --- Parse the update expression
-        let update;
+        let upd;
         nextToken = this._lexer.peek();
-        if (nextToken.type !== Token_1.TokenType.RParent) {
-            update = this.getExpression();
-            if (update === null) {
+        if (nextToken.type !== TokenType_1.TokenType.RParent) {
+            upd = this.getExpression();
+            if (upd === null) {
                 return null;
             }
         }
         // --- Close the declaration part
-        this.expectToken(Token_1.TokenType.RParent, "W006");
+        this.expectToken(TokenType_1.TokenType.RParent, "W006");
         // --- Get the body
         const body = this.parseStatement();
         if (!body)
             return null;
-        return this.createStatementNode("ForS", {
+        return this.createStatementNode(ScriptingSourceTree_1.T_FOR_STATEMENT, {
             init,
-            condition,
-            update,
+            cond,
+            upd,
             body,
         }, startToken, body.endToken);
     }
@@ -744,41 +747,51 @@ 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") {
+            // --- Skip variable binding type
+            if (idToken.text.startsWith("$")) {
                 this.reportError("W031");
                 return null;
             }
-            // --- Skip variable binding type
             this._lexer.get();
         }
         // --- Skip variable name, in/of token
         this._lexer.get();
         this._lexer.get();
         // --- Get the expression
-        const expression = this.getExpression(true);
+        const expr = this.getExpression(true);
         // --- Close the declaration part
-        this.expectToken(Token_1.TokenType.RParent, "W006");
+        this.expectToken(TokenType_1.TokenType.RParent, "W006");
         // --- Get the body
         const body = this.parseStatement();
         if (!body)
             return null;
-        return type === "ForInS"
-            ? this.createStatementNode("ForInS", {
-                varBinding,
-                id,
-                expression,
+        return type === ScriptingSourceTree_1.T_FOR_IN_STATEMENT
+            ? this.createStatementNode(ScriptingSourceTree_1.T_FOR_IN_STATEMENT, {
+                varB,
+                id: {
+                    type: ScriptingSourceTree_1.T_IDENTIFIER,
+                    name: idToken.text,
+                    startToken: idToken,
+                    endToken: idToken,
+                },
+                expr,
                 body,
             }, startToken, body.endToken)
-            : this.createStatementNode("ForOfS", {
-                varBinding,
-                id,
-                expression,
+            : this.createStatementNode(ScriptingSourceTree_1.T_FOR_OF_STATEMENT, {
+                varB,
+                id: {
+                    type: ScriptingSourceTree_1.T_IDENTIFIER,
+                    name: idToken.text,
+                    startToken: idToken,
+                    endToken: idToken,
+                },
+                expr,
                 body,
             }, startToken, body.endToken);
     }
@@ -792,13 +805,13 @@ class Parser {
     parseThrowStatement() {
         const startToken = this._lexer.peek();
         this._lexer.get();
-        let expression;
-        expression = this.getExpression();
-        if (expression === null)
+        let expr;
+        expr = this.getExpression();
+        if (expr === null)
             return null;
-        return this.createStatementNode("ThrowS", {
-            expression,
-        }, startToken, expression.endToken);
+        return this.createStatementNode(ScriptingSourceTree_1.T_THROW_STATEMENT, {
+            expr,
+        }, startToken, expr.endToken);
     }
     /**
      * Parses a try..catch..finally statement
@@ -820,56 +833,62 @@ class Parser {
         let endToken = this._lexer.get();
         const parser = this;
         // --- Get "try" block
-        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 === Token_1.TokenType.Catch) {
+        if (nextToken.type === TokenType_1.TokenType.Catch) {
             // --- Catch found
             this._lexer.get();
             nextToken = this._lexer.peek();
-            if (nextToken.type === Token_1.TokenType.LParent) {
+            if (nextToken.type === TokenType_1.TokenType.LParent) {
                 // --- Catch variable found
                 this._lexer.get();
                 nextToken = this._lexer.peek();
-                if (nextToken.type !== Token_1.TokenType.Identifier) {
+                if (nextToken.type !== TokenType_1.TokenType.Identifier) {
                     this.reportError("W003", nextToken);
                     return null;
                 }
-                catchVariable = nextToken.text;
+                catchV = {
+                    type: ScriptingSourceTree_1.T_IDENTIFIER,
+                    nodeId: createXmlUiTreeNodeId(),
+                    name: nextToken.text,
+                    startToken: nextToken,
+                    endToken: nextToken,
+                };
                 this._lexer.get();
-                this.expectToken(Token_1.TokenType.RParent, "W006");
+                this.expectToken(TokenType_1.TokenType.RParent, "W006");
             }
             // --- Get catch block
-            catchBlock = getBlock();
-            endToken = catchBlock.endToken;
-            if (this._lexer.peek().type === Token_1.TokenType.Finally) {
+            catchB = getBlock();
+            endToken = catchB.endToken;
+            if (this._lexer.peek().type === TokenType_1.TokenType.Finally) {
                 // --- Finally after catch
                 this._lexer.get();
-                finallyBlock = getBlock();
-                endToken = finallyBlock.endToken;
+                finallyB = getBlock();
+                endToken = finallyB.endToken;
             }
         }
-        else if (nextToken.type === Token_1.TokenType.Finally) {
+        else if (nextToken.type === TokenType_1.TokenType.Finally) {
             // --- Finally found
             this._lexer.get();
-            finallyBlock = getBlock();
-            endToken = finallyBlock.endToken;
+            finallyB = getBlock();
+            endToken = finallyB.endToken;
         }
         else {
             this.reportError("W013", nextToken);
             return null;
         }
-        return this.createStatementNode("TryS", {
-            tryBlock,
-            catchBlock,
-            catchVariable,
-            finallyBlock,
+        return this.createStatementNode(ScriptingSourceTree_1.T_TRY_STATEMENT, {
+            tryB,
+            catchB,
+            catchV,
+            finallyB,
         }, startToken, endToken);
         function getBlock() {
             const nextToken = parser._lexer.peek();
-            if (nextToken.type !== Token_1.TokenType.LBrace) {
+            if (nextToken.type !== TokenType_1.TokenType.LBrace) {
                 parser.reportError("W012", nextToken);
                 return null;
             }
@@ -891,26 +910,26 @@ class Parser {
     parseSwitchStatement() {
         const startToken = this._lexer.get();
         // --- Parse the switch expression
-        this.expectToken(Token_1.TokenType.LParent, "W014");
-        const expression = this.getExpression();
-        if (!expression)
+        this.expectToken(TokenType_1.TokenType.LParent, "W014");
+        const expr = this.getExpression();
+        if (!expr)
             return null;
-        this.expectToken(Token_1.TokenType.RParent, "W006");
+        this.expectToken(TokenType_1.TokenType.RParent, "W006");
         // --- Parse the case blocks
-        this.expectToken(Token_1.TokenType.LBrace, "W012");
+        this.expectToken(TokenType_1.TokenType.LBrace, "W012");
         const cases = [];
         let defaultCaseFound = false;
         while (true) {
             let nextToken = this._lexer.peek();
-            let caseExpression;
-            if (nextToken.type === Token_1.TokenType.Case) {
+            let caseE;
+            if (nextToken.type === TokenType_1.TokenType.Case) {
                 // --- Process "case"
                 this._lexer.get();
-                caseExpression = this.getExpression();
-                if (!caseExpression)
+                caseE = this.getExpression();
+                if (!caseE)
                     return null;
             }
-            else if (nextToken.type === Token_1.TokenType.Default) {
+            else if (nextToken.type === TokenType_1.TokenType.Default) {
                 // --- Process "default"
                 if (defaultCaseFound) {
                     this.reportError("W016");
@@ -919,7 +938,7 @@ class Parser {
                 defaultCaseFound = true;
                 this._lexer.get();
             }
-            else if (nextToken.type === Token_1.TokenType.RBrace) {
+            else if (nextToken.type === TokenType_1.TokenType.RBrace) {
                 break;
             }
             else {
@@ -927,15 +946,15 @@ class Parser {
                 return null;
             }
             // --- Process label statements
-            this.expectToken(Token_1.TokenType.Colon, "W008");
-            let statements = [];
+            this.expectToken(TokenType_1.TokenType.Colon, "W008");
+            let stmts = [];
             let collected = false;
             while (!collected) {
                 const stmtToken = this._lexer.peek();
                 switch (stmtToken.type) {
-                    case Token_1.TokenType.Case:
-                    case Token_1.TokenType.Default:
-                    case Token_1.TokenType.RBrace:
+                    case TokenType_1.TokenType.Case:
+                    case TokenType_1.TokenType.Default:
+                    case TokenType_1.TokenType.RBrace:
                         // --- No more case to process
                         collected = true;
                         break;
@@ -946,22 +965,22 @@ class Parser {
                             collected = true;
                             break;
                         }
-                        statements.push(stmt);
-                        if (stmt.type !== "EmptyS") {
-                            this.skipToken(Token_1.TokenType.Semicolon);
+                        stmts.push(stmt);
+                        if (stmt.type !== ScriptingSourceTree_1.T_EMPTY_STATEMENT) {
+                            this.skipToken(TokenType_1.TokenType.Semicolon);
                         }
                 }
             }
-            cases.push(this.createNode("SwitchC", {
-                caseExpression,
-                statements,
+            cases.push(this.createNode(ScriptingSourceTree_1.T_SWITCH_CASE, {
+                caseE,
+                stmts,
             }, startToken));
         }
         // --- Closing
         const endToken = this._lexer.peek();
-        this.expectToken(Token_1.TokenType.RBrace, "W004");
-        return this.createStatementNode("SwitchS", {
-            expression,
+        this.expectToken(TokenType_1.TokenType.RBrace, "W004");
+        return this.createStatementNode(ScriptingSourceTree_1.T_SWITCH_STATEMENT, {
+            expr,
             cases,
         }, startToken, endToken);
     }
@@ -979,8 +998,8 @@ class Parser {
         let functionName;
         const funcId = this._lexer.peek();
         if (allowNoName) {
-            if (funcId.type !== Token_1.TokenType.LParent) {
-                if (funcId.type !== Token_1.TokenType.Identifier) {
+            if (funcId.type !== TokenType_1.TokenType.LParent) {
+                if (funcId.type !== TokenType_1.TokenType.Identifier) {
                     this.reportError("W003", funcId);
                     return null;
                 }
@@ -989,7 +1008,7 @@ class Parser {
             }
         }
         else {
-            if (funcId.type !== Token_1.TokenType.Identifier) {
+            if (funcId.type !== TokenType_1.TokenType.Identifier) {
                 this.reportError("W003", funcId);
                 return null;
             }
@@ -998,7 +1017,7 @@ class Parser {
         }
         // --- Get the parameter list;
         const nextToken = this._lexer.peek();
-        if (nextToken.type !== Token_1.TokenType.LParent) {
+        if (nextToken.type !== TokenType_1.TokenType.LParent) {
             this.reportError("W014", nextToken);
             return null;
         }
@@ -1008,29 +1027,29 @@ class Parser {
         let isValid;
         const args = [];
         switch (exprList.type) {
-            case "NoArgE":
+            case ScriptingSourceTree_1.T_NO_ARG_EXPRESSION:
                 isValid = true;
                 break;
-            case "IdE":
+            case ScriptingSourceTree_1.T_IDENTIFIER:
                 isValid = ((_a = exprList.parenthesized) !== null && _a !== void 0 ? _a : 0) <= 1;
                 args.push(exprList);
                 break;
-            case "SeqE":
+            case ScriptingSourceTree_1.T_SEQUENCE_EXPRESSION:
                 isValid = exprList.parenthesized === 1;
                 let spreadFound = false;
                 if (isValid) {
-                    for (const expr of exprList.expressions) {
+                    for (const expr of exprList.exprs) {
                         // --- Spread operator can be used only in the last position
                         if (spreadFound) {
                             isValid = false;
                             break;
                         }
                         switch (expr.type) {
-                            case "IdE":
+                            case ScriptingSourceTree_1.T_IDENTIFIER:
                                 isValid = !expr.parenthesized;
                                 args.push(expr);
                                 break;
-                            case "OLitE": {
+                            case ScriptingSourceTree_1.T_OBJECT_LITERAL: {
                                 isValid = !expr.parenthesized;
                                 if (isValid) {
                                     const des = this.convertToObjectDestructure(expr);
@@ -1039,7 +1058,7 @@ class Parser {
                                 }
                                 break;
                             }
-                            case "ALitE": {
+                            case ScriptingSourceTree_1.T_ARRAY_LITERAL: {
                                 isValid = !expr.parenthesized;
                                 if (isValid) {
                                     const des = this.convertToArrayDestructure(expr);
@@ -1048,9 +1067,9 @@ class Parser {
                                 }
                                 break;
                             }
-                            case "SpreadE": {
+                            case ScriptingSourceTree_1.T_SPREAD_EXPRESSION: {
                                 spreadFound = true;
-                                if (expr.operand.type !== "IdE") {
+                                if (expr.expr.type !== ScriptingSourceTree_1.T_IDENTIFIER) {
                                     isValid = false;
                                     break;
                                 }
@@ -1064,7 +1083,7 @@ class Parser {
                     }
                 }
                 break;
-            case "OLitE":
+            case ScriptingSourceTree_1.T_OBJECT_LITERAL:
                 isValid = exprList.parenthesized === 1;
                 if (isValid) {
                     const des = this.convertToObjectDestructure(exprList);
@@ -1072,7 +1091,7 @@ class Parser {
                         args.push(des);
                 }
                 break;
-            case "ALitE":
+            case ScriptingSourceTree_1.T_ARRAY_LITERAL:
                 isValid = exprList.parenthesized === 1;
                 if (isValid) {
                     const des = this.convertToArrayDestructure(exprList);
@@ -1080,8 +1099,8 @@ class Parser {
                         args.push(des);
                 }
                 break;
-            case "SpreadE":
-                if (exprList.operand.type !== "IdE") {
+            case ScriptingSourceTree_1.T_SPREAD_EXPRESSION:
+                if (exprList.expr.type !== ScriptingSourceTree_1.T_IDENTIFIER) {
                     isValid = false;
                     break;
                 }
@@ -1096,117 +1115,19 @@ class Parser {
             return null;
         }
         // --- Get the function body (statement block)
-        if (this._lexer.peek().type !== Token_1.TokenType.LBrace) {
+        if (this._lexer.peek().type !== TokenType_1.TokenType.LBrace) {
             this.reportError("W012", this._lexer.peek());
             return null;
         }
-        const body = this.parseBlockStatement();
-        if (!body)
+        const stmt = this.parseBlockStatement();
+        if (!stmt)
             return null;
         // --- Done.
-        return this.createStatementNode("FuncD", {
-            name: functionName,
+        return this.createStatementNode(ScriptingSourceTree_1.T_FUNCTION_DECLARATION, {
+            id: { type: ScriptingSourceTree_1.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 === Token_1.TokenType.Const) {
-            if (this._statementLevel > 1) {
-                this.reportError("W030", nextToken);
-                return null;
-            }
-            const constStmt = this.parseConstStatement();
-            return constStmt === null ? null : Object.assign(Object.assign({}, constStmt), { isExported: true });
-        }
-        else if (nextToken.type === Token_1.TokenType.Function) {
-            if (this._statementLevel > 1) {
-                this.reportError("W030", nextToken);
-                return null;
-            }
-            const funcDecl = this.parseFunctionDeclaration();
-            return funcDecl === null ? null : Object.assign(Object.assign({}, 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(Token_1.TokenType.LBrace, "W012");
-        const imports = {};
-        let nextToken = this._lexer.peek();
-        while (nextToken.type !== Token_1.TokenType.RBrace) {
-            if (nextToken.type !== Token_1.TokenType.Identifier) {
-                this.reportError("W003", nextToken);
-                return null;
-            }
-            const id = nextToken.text;
-            this._lexer.get();
-            nextToken = this._lexer.peek();
-            if (nextToken.type === Token_1.TokenType.As) {
-                this._lexer.get();
-                nextToken = this._lexer.peek();
-                if (nextToken.type !== Token_1.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 === Token_1.TokenType.Comma) {
-                this._lexer.get();
-                nextToken = this._lexer.peek();
-            }
-        }
-        // --- Skip the closing brace
-        this._lexer.get();
-        // --- Check for "from"
-        this.expectToken(Token_1.TokenType.From, "W025");
-        // --- Get the module name
-        const moduleToken = this._lexer.peek();
-        if (moduleToken.type !== Token_1.TokenType.StringLiteral) {
-            this.reportError("W026", moduleToken);
-            return null;
-        }
-        this._lexer.get();
-        const literal = this.parseStringLiteral(moduleToken);
-        // --- Done.
-        return this.createStatementNode("ImportD", {
-            imports,
-            moduleFile: literal.value,
-        }, startToken, moduleToken);
+            stmt,
+        }, startToken, stmt.endToken);
     }
     // ==========================================================================
     // Expression parsing
@@ -1234,15 +1155,15 @@ class Parser {
             return null;
         }
         endToken = leftExpr.endToken;
-        const expressions = [];
+        const exprs = [];
         let loose = false;
-        if (this._lexer.peek().type === Token_1.TokenType.Comma) {
-            expressions.push(leftExpr);
-            while (this.skipToken(Token_1.TokenType.Comma)) {
-                if (this._lexer.peek().type === Token_1.TokenType.Comma) {
+        if (this._lexer.peek().type === TokenType_1.TokenType.Comma) {
+            exprs.push(leftExpr);
+            while (this.skipToken(TokenType_1.TokenType.Comma)) {
+                if (this._lexer.peek().type === TokenType_1.TokenType.Comma) {
                     loose = true;
                     endToken = this._lexer.peek();
-                    expressions.push(this.createExpressionNode("NoArgE", {}, endToken, endToken));
+                    exprs.push(this.createExpressionNode(ScriptingSourceTree_1.T_NO_ARG_EXPRESSION, {}, endToken, endToken));
                 }
                 else {
                     const nextExpr = this.parseCondOrSpreadOrAsgnOrArrowExpr();
@@ -1250,17 +1171,17 @@ class Parser {
                         break;
                     }
                     endToken = nextExpr.endToken;
-                    expressions.push(nextExpr);
+                    exprs.push(nextExpr);
                 }
             }
         }
-        if (!expressions.length) {
+        if (!exprs.length) {
             // --- No sequence
             return leftExpr;
         }
         // --- Create the sequence expression
-        leftExpr = this.createExpressionNode("SeqE", {
-            expressions,
+        leftExpr = this.createExpressionNode(ScriptingSourceTree_1.T_SEQUENCE_EXPRESSION, {
+            exprs,
             loose,
         }, start, endToken);
         // --- Check for "loose" sequence expression
@@ -1279,23 +1200,23 @@ class Parser {
      */
     parseCondOrSpreadOrAsgnOrArrowExpr() {
         const startToken = this._lexer.peek();
-        if (startToken.type === Token_1.TokenType.Spread) {
+        if (startToken.type === TokenType_1.TokenType.Spread) {
             // --- Spread expression
             this._lexer.get();
             const spreadOperand = this.parseNullCoalescingExpr();
             return spreadOperand
-                ? this.createExpressionNode("SpreadE", {
-                    operand: spreadOperand,
+                ? this.createExpressionNode(ScriptingSourceTree_1.T_SPREAD_EXPRESSION, {
+                    expr: spreadOperand,
                 }, startToken, spreadOperand.endToken)
                 : null;
         }
-        if (startToken.type === Token_1.TokenType.Function) {
+        if (startToken.type === TokenType_1.TokenType.Function) {
             const funcDecl = this.parseFunctionDeclaration(true);
             return funcDecl
-                ? this.createExpressionNode("ArrowE", {
-                    name: funcDecl.name,
+                ? this.createExpressionNode(ScriptingSourceTree_1.T_ARROW_EXPRESSION, {
+                    name: funcDecl.id.name,
                     args: funcDecl.args,
-                    statement: funcDecl.statement,
+                    statement: funcDecl.stmt,
                 }, startToken, funcDecl.endToken)
                 : null;
         }
@@ -1304,32 +1225,32 @@ class Parser {
             return null;
         }
         const nextToken = this._lexer.peek();
-        if (nextToken.type === Token_1.TokenType.Arrow) {
+        if (nextToken.type === TokenType_1.TokenType.Arrow) {
             // --- It is an arrow expression
             return this.parseArrowExpression(startToken, otherExpr);
         }
-        if (nextToken.type === Token_1.TokenType.QuestionMark) {
+        if (nextToken.type === TokenType_1.TokenType.QuestionMark) {
             this._lexer.get();
             // --- Conditional expression
             const trueExpr = this.getExpression(false);
-            this.expectToken(Token_1.TokenType.Colon);
+            this.expectToken(TokenType_1.TokenType.Colon);
             const falseExpr = this.getExpression(false);
-            return this.createExpressionNode("CondE", {
-                condition: otherExpr,
-                consequent: trueExpr,
-                alternate: falseExpr,
+            return this.createExpressionNode(ScriptingSourceTree_1.T_CONDITIONAL_EXPRESSION, {
+                cond: otherExpr,
+                thenE: trueExpr,
+                elseE: falseExpr,
             }, startToken, falseExpr.endToken);
         }
         if (TokenTrait_1.tokenTraits[nextToken.type].isAssignment) {
             // --- Assignment
             this._lexer.get();
-            const operand = this.getExpression();
-            return operand
-                ? this.createExpressionNode("AsgnE", {
+            const expr = this.getExpression();
+            return expr
+                ? this.createExpressionNode(ScriptingSourceTree_1.T_ASSIGNMENT_EXPRESSION, {
                     leftValue: otherExpr,
-                    operator: nextToken.text,
-                    operand,
-                }, startToken, operand.endToken)
+                    op: nextToken.text,
+                    expr,
+                }, startToken, expr.endToken)
                 : null;
         }
         return otherExpr;
@@ -1345,28 +1266,28 @@ class Parser {
         let isValid;
         const args = [];
         switch (left.type) {
-            case "NoArgE":
+            case ScriptingSourceTree_1.T_NO_ARG_EXPRESSION:
                 isValid = true;
                 break;
-            case "IdE":
+            case ScriptingSourceTree_1.T_IDENTIFIER:
                 isValid = ((_a = left.parenthesized) !== null && _a !== void 0 ? _a : 0) <= 1;
                 args.push(left);
                 break;
-            case "SeqE":
+            case ScriptingSourceTree_1.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 ScriptingSourceTree_1.T_IDENTIFIER:
                                 isValid = !expr.parenthesized;
                                 args.push(expr);
                                 break;
-                            case "OLitE": {
+                            case ScriptingSourceTree_1.T_OBJECT_LITERAL: {
                                 isValid = !expr.parenthesized;
                                 if (isValid) {
                                     const des = this.convertToObjectDestructure(expr);
@@ -1375,7 +1296,7 @@ class Parser {
                                 }
                                 break;
                             }
-                            case "ALitE": {
+                            case ScriptingSourceTree_1.T_ARRAY_LITERAL: {
                                 isValid = !expr.parenthesized;
                                 if (isValid) {
                                     const des = this.convertToArrayDestructure(expr);
@@ -1384,9 +1305,9 @@ class Parser {
                                 }
                                 break;
                             }
-                            case "SpreadE": {
+                            case ScriptingSourceTree_1.T_SPREAD_EXPRESSION: {
                                 spreadFound = true;
-                                if (expr.operand.type !== "IdE") {
+                                if (expr.expr.type !== ScriptingSourceTree_1.T_IDENTIFIER) {
                                     isValid = false;
                                     break;
                                 }
@@ -1400,7 +1321,7 @@ class Parser {
                     }
                 }
                 break;
-            case "OLitE":
+            case ScriptingSourceTree_1.T_OBJECT_LITERAL:
                 isValid = left.parenthesized === 1;
                 if (isValid) {
                     const des = this.convertToObjectDestructure(left);
@@ -1408,7 +1329,7 @@ class Parser {
                         args.push(des);
                 }
                 break;
-            case "ALitE":
+            case ScriptingSourceTree_1.T_ARRAY_LITERAL:
                 isValid = left.parenthesized === 1;
                 if (isValid) {
                     const des = this.convertToArrayDestructure(left);
@@ -1416,8 +1337,8 @@ class Parser {
                         args.push(des);
                 }
                 break;
-            case "SpreadE":
-                isValid = left.operand.type === "IdE";
+            case ScriptingSourceTree_1.T_SPREAD_EXPRESSION:
+                isValid = left.expr.type === ScriptingSourceTree_1.T_IDENTIFIER;
                 if (isValid) {
                     args.push(left);
                 }
@@ -1434,7 +1355,7 @@ class Parser {
         // --- Get arrow expression statements
         const statement = this.parseStatement(false);
         return statement
-            ? this.createExpressionNode("ArrowE", {
+            ? this.createExpressionNode(ScriptingSourceTree_1.T_ARROW_EXPRESSION, {
                 args,
                 statement,
             }, start, statement.endToken)
@@ -1451,15 +1372,15 @@ class Parser {
         if (!leftExpr) {
             return null;
         }
-        while (this.skipToken(Token_1.TokenType.NullCoalesce)) {
+        while (this.skipToken(TokenType_1.TokenType.NullCoalesce)) {
             const rightExpr = this.parseLogicalOrExpr();
             if (!rightExpr) {
                 this.reportError("W001");
                 return null;
             }
             let endToken = rightExpr.endToken;
-            leftExpr = this.createExpressionNode("BinaryE", {
-                operator: "??",
+            leftExpr = this.createExpressionNode(ScriptingSourceTree_1.T_BINARY_EXPRESSION, {
+                op: "??",
                 left: leftExpr,
                 right: rightExpr,
             }, startToken, endToken);
@@ -1477,15 +1398,15 @@ class Parser {
         if (!leftExpr) {
             return null;
         }
-        while (this.skipToken(Token_1.TokenType.LogicalOr)) {
+        while (this.skipToken(TokenType_1.TokenType.LogicalOr)) {
             const rightExpr = this.parseLogicalAndExpr();
             if (!rightExpr) {
                 this.reportError("W001");
                 return null;
             }
             let endToken = rightExpr.endToken;
-            leftExpr = this.createExpressionNode("BinaryE", {
-                operator: "||",
+            leftExpr = this.createExpressionNode(ScriptingSourceTree_1.T_BINARY_EXPRESSION, {
+                op: "||",
                 left: leftExpr,
                 right: rightExpr,
             }, startToken, endToken);
@@ -1503,15 +1424,15 @@ class Parser {
         if (!leftExpr) {
             return null;
         }
-        while (this.skipToken(Token_1.TokenType.LogicalAnd)) {
+        while (this.skipToken(TokenType_1.TokenType.LogicalAnd)) {
             const rightExpr = this.parseBitwiseOrExpr();
             if (!rightExpr) {
                 this.reportError("W001");
                 return null;
             }
             let endToken = rightExpr.endToken;
-            leftExpr = this.createExpressionNode("BinaryE", {
-                operator: "&&",
+            leftExpr = this.createExpressionNode(ScriptingSourceTree_1.T_BINARY_EXPRESSION, {
+                op: "&&",
                 left: leftExpr,
                 right: rightExpr,
             }, startToken, endToken);
@@ -1529,15 +1450,15 @@ class Parser {
         if (!leftExpr) {
             return null;
         }
-        while (this.skipToken(Token_1.TokenType.BitwiseOr)) {
+        while (this.skipToken(TokenType_1.TokenType.BitwiseOr)) {
             const rightExpr = this.parseBitwiseXorExpr();
             if (!rightExpr) {
                 this.reportError("W001");
                 return null;
             }
             let endToken = rightExpr.endToken;
-            leftExpr = this.createExpressionNode("BinaryE", {
-                operator: "|",
+            leftExpr = this.createExpressionNode(ScriptingSourceTree_1.T_BINARY_EXPRESSION, {
+                op: "|",
                 left: leftExpr,
                 right: rightExpr,
             }, startToken, endToken);
@@ -1555,15 +1476,15 @@ class Parser {
         if (!leftExpr) {
             return null;
         }
-        while (this.skipToken(Token_1.TokenType.BitwiseXor)) {
+        while (this.skipToken(TokenType_1.TokenType.BitwiseXor)) {
             const rightExpr = this.parseBitwiseAndExpr();
             if (!rightExpr) {
                 this.reportError("W001");
                 return null;
             }
             let endToken = rightExpr.endToken;
-            leftExpr = this.createExpressionNode("BinaryE", {
-                operator: "^",
+            leftExpr = this.createExpressionNode(ScriptingSourceTree_1.T_BINARY_EXPRESSION, {
+                op: "^",
                 left: leftExpr,
                 right: rightExpr,
             }, startToken, endToken);
@@ -1581,15 +1502,15 @@ class Parser {
         if (!leftExpr) {
             return null;
         }
-        while (this.skipToken(Token_1.TokenType.BitwiseAnd)) {
+        while (this.skipToken(TokenType_1.TokenType.BitwiseAnd)) {
             const rightExpr = this.parseEquExpr();
             if (!rightExpr) {
                 this.reportError("W001");
                 return null;
             }
             let endToken = rightExpr.endToken;
-            leftExpr = this.createExpressionNode("BinaryE", {
-                operator: "&",
+            leftExpr = this.createExpressionNode(ScriptingSourceTree_1.T_BINARY_EXPRESSION, {
+                op: "&",
                 left: leftExpr,
                 right: rightExpr,
             }, startToken, endToken);
@@ -1608,16 +1529,15 @@ class Parser {
             return null;
         }
         let opType;
-        while ((opType = this.skipTokens(Token_1.TokenType.Equal, Token_1.TokenType.StrictEqual, Token_1.TokenType.NotEqual, Token_1.TokenType.StrictNotEqual))) {
+        while ((opType = this.skipTokens(TokenType_1.TokenType.Equal, TokenType_1.TokenType.StrictEqual, TokenType_1.TokenType.NotEqual, TokenType_1.TokenType.StrictNotEqual))) {
             const rightExpr = this.parseRelOrInExpr();
             if (!rightExpr) {
                 this.reportError("W001");
                 return null;
             }
             let endToken = rightExpr.endToken;
-            leftExpr = this.createExpressionNode("BinaryE", {
-                type: "BinaryE",
-                operator: opType.text,
+            leftExpr = this.createExpressionNode(ScriptingSourceTree_1.T_BINARY_EXPRESSION, {
+                op: opType.text,
                 left: leftExpr,
                 right: rightExpr,
             }, startToken, endToken);
@@ -1636,15 +1556,15 @@ class Parser {
             return null;
         }
         let opType;
-        while ((opType = this.skipTokens(Token_1.TokenType.LessThan, Token_1.TokenType.LessThanOrEqual, Token_1.TokenType.GreaterThan, Token_1.TokenType.GreaterThanOrEqual, Token_1.TokenType.In))) {
+        while ((opType = this.skipTokens(TokenType_1.TokenType.LessThan, TokenType_1.TokenType.LessThanOrEqual, TokenType_1.TokenType.GreaterThan, TokenType_1.TokenType.GreaterThanOrEqual, TokenType_1.TokenType.In))) {
             const rightExpr = this.parseShiftExpr();
             if (!rightExpr) {
                 this.reportError("W001");
                 return null;
             }
             let endToken = rightExpr.endToken;
-            leftExpr = this.createExpressionNode("BinaryE", {
-                operator: opType.text,
+            leftExpr = this.createExpressionNode(ScriptingSourceTree_1.T_BINARY_EXPRESSION, {
+                op: opType.text,
                 left: leftExpr,
                 right: rightExpr,
             }, startToken, endToken);
@@ -1663,15 +1583,15 @@ class Parser {
             return null;
         }
         let opType;
-        while ((opType = this.skipTokens(Token_1.TokenType.ShiftLeft, Token_1.TokenType.ShiftRight, Token_1.TokenType.SignedShiftRight))) {
+        while ((opType = this.skipTokens(TokenType_1.TokenType.ShiftLeft, TokenType_1.TokenType.ShiftRight, TokenType_1.TokenType.SignedShiftRight))) {
             const rightExpr = this.parseAddExpr();
             if (!rightExpr) {
                 this.reportError("W001");
                 return null;
             }
             let endToken = rightExpr.endToken;
-            leftExpr = this.createExpressionNode("BinaryE", {
-                operator: opType.text,
+            leftExpr = this.createExpressionNode(ScriptingSourceTree_1.T_BINARY_EXPRESSION, {
+                op: opType.text,
                 left: leftExpr,
                 right: rightExpr,
             }, startToken, endToken);
@@ -1690,15 +1610,15 @@ class Parser {
             return null;
         }
         let opType;
-        while ((opType = this.skipTokens(Token_1.TokenType.Plus, Token_1.TokenType.Minus))) {
+        while ((opType = this.skipTokens(TokenType_1.TokenType.Plus, TokenType_1.TokenType.Minus))) {
             const rightExpr = this.parseMultExpr();
             if (!rightExpr) {
                 this.reportError("W001");
                 return null;
             }
             let endToken = rightExpr.endToken;
-            leftExpr = this.createExpressionNode("BinaryE", {
-                operator: opType.text,
+            leftExpr = this.createExpressionNode(ScriptingSourceTree_1.T_BINARY_EXPRESSION, {
+                op: opType.text,
                 left: leftExpr,
                 right: rightExpr,
             }, startToken, endToken);
@@ -1717,15 +1637,15 @@ class Parser {
             return null;
         }
         let opType;
-        while ((opType = this.skipTokens(Token_1.TokenType.Multiply, Token_1.TokenType.Divide, Token_1.TokenType.Remainder))) {
+        while ((opType = this.skipTokens(TokenType_1.TokenType.Multiply, TokenType_1.TokenType.Divide, TokenType_1.TokenType.Remainder))) {
             const rightExpr = this.parseExponentialExpr();
             if (!rightExpr) {
                 this.reportError("W001");
                 return null;
             }
             let endToken = rightExpr.endToken;
-            leftExpr = this.createExpressionNode("BinaryE", {
-                operator: opType.text,
+            leftExpr = this.createExpressionNode(ScriptingSourceTree_1.T_BINARY_EXPRESSION, {
+                op: opType.text,
                 left: leftExpr,
                 right: rightExpr,
             }, startToken, endToken);
@@ -1745,7 +1665,7 @@ class Parser {
         }
         let opType;
         let count = 0;
-        while ((opType = this.skipToken(Token_1.TokenType.Exponent))) {
+        while ((opType = this.skipToken(TokenType_1.TokenType.Exponent))) {
             let rightExpr = this.parseUnaryOrPrefixExpr();
             if (!rightExpr) {
                 this.reportError("W001");
@@ -1753,20 +1673,20 @@ class Parser {
             }
             let endToken = rightExpr.endToken;
             if (count === 0) {
-                leftExpr = this.createExpressionNode("BinaryE", {
-                    operator: opType.text,
+                leftExpr = this.createExpressionNode(ScriptingSourceTree_1.T_BINARY_EXPRESSION, {
+                    op: opType.text,
                     left: leftExpr,
                     right: rightExpr,
                 }, startToken, endToken);
             }
             else {
                 const prevLeft = leftExpr;
-                leftExpr = this.createExpressionNode("BinaryE", {
-                    operator: opType.text,
+                leftExpr = this.createExpressionNode(ScriptingSourceTree_1.T_BINARY_EXPRESSION, {
+                    op: opType.text,
                     left: prevLeft.left,
                     right: {
-                        type: "BinaryE",
-                        operator: opType.text,
+                        type: ScriptingSourceTree_1.T_BINARY_EXPRESSION,
+                        op: opType.text,
                         left: prevLeft.right,
                         right: rightExpr,
                     },
@@ -1790,20 +1710,20 @@ class Parser {
             if (!unaryOperand) {
                 return null;
             }
-            return this.createExpressionNode("UnaryE", {
-                operator: startToken.text,
-                operand: unaryOperand,
+            return this.createExpressionNode(ScriptingSourceTree_1.T_UNARY_EXPRESSION, {
+                op: startToken.text,
+                expr: unaryOperand,
             }, startToken, unaryOperand.endToken);
         }
-        if (startToken.type === Token_1.TokenType.IncOp || startToken.type === Token_1.TokenType.DecOp) {
+        if (startToken.type === TokenType_1.TokenType.IncOp || startToken.type === TokenType_1.TokenType.DecOp) {
             this._lexer.get();
             const prefixOperand = this.parseMemberOrInvocationExpr();
             if (!prefixOperand) {
                 return null;
             }
-            return this.createExpressionNode("PrefE", {
-                operator: startToken.text,
-                operand: prefixOperand,
+            return this.createExpressionNode(ScriptingSourceTree_1.T_PREFIX_OP_EXPRESSION, {
+                op: startToken.text,
+                expr: prefixOperand,
             }, startToken, prefixOperand.endToken);
         }
         // --- Not unary or prefix
@@ -1827,27 +1747,27 @@ class Parser {
         do {
             const currentStart = this._lexer.peek();
             switch (currentStart.type) {
-                case Token_1.TokenType.LParent: {
+                case TokenType_1.TokenType.LParent: {
                     this._lexer.get();
                     let args = [];
-                    if (this._lexer.peek().type !== Token_1.TokenType.RParent) {
+                    if (this._lexer.peek().type !== TokenType_1.TokenType.RParent) {
                         const expr = this.parseExpr();
                         if (!expr) {
                             this.reportError("W001");
                             return null;
                         }
-                        args = expr.type === "SeqE" ? expr.expressions : [expr];
+                        args = expr.type === ScriptingSourceTree_1.T_SEQUENCE_EXPRESSION ? expr.exprs : [expr];
                     }
                     const endToken = this._lexer.peek();
-                    this.expectToken(Token_1.TokenType.RParent, "W006");
-                    primary = this.createExpressionNode("InvokeE", {
-                        object: primary,
+                    this.expectToken(TokenType_1.TokenType.RParent, "W006");
+                    primary = this.createExpressionNode(ScriptingSourceTree_1.T_FUNCTION_INVOCATION_EXPRESSION, {
+                        obj: primary,
                         arguments: args,
                     }, startToken, endToken);
                     break;
                 }
-                case Token_1.TokenType.Dot:
-                case Token_1.TokenType.OptionalChaining:
+                case TokenType_1.TokenType.Dot:
+                case TokenType_1.TokenType.OptionalChaining:
                     this._lexer.get();
                     const member = this._lexer.get();
                     const memberTrait = TokenTrait_1.tokenTraits[member.type];
@@ -1855,22 +1775,22 @@ class Parser {
                         this.reportError("W003");
                         return null;
                     }
-                    primary = this.createExpressionNode("MembE", {
-                        object: primary,
+                    primary = this.createExpressionNode(ScriptingSourceTree_1.T_MEMBER_ACCESS_EXPRESSION, {
+                        obj: primary,
                         member: member.text,
-                        isOptional: currentStart.type === Token_1.TokenType.OptionalChaining,
+                        opt: currentStart.type === TokenType_1.TokenType.OptionalChaining,
                     }, startToken, member);
                     break;
-                case Token_1.TokenType.LSquare:
+                case TokenType_1.TokenType.LSquare:
                     this._lexer.get();
                     const memberExpr = this.getExpression();
                     if (!memberExpr) {
                         return null;
                     }
                     const endToken = this._lexer.peek();
-                    this.expectToken(Token_1.TokenType.RSquare, "W005");
-                    primary = this.createExpressionNode("CMembE", {
-                        object: primary,
+                    this.expectToken(TokenType_1.TokenType.RSquare, "W005");
+                    primary = this.createExpressionNode(ScriptingSourceTree_1.T_CALCULATED_MEMBER_ACCESS_EXPRESSION, {
+                        obj: primary,
                         member: memberExpr,
                     }, startToken, endToken);
                     break;
@@ -1881,11 +1801,11 @@ class Parser {
         } while (!exitLoop);
         // --- Check for postfix operators
         const nextToken = this._lexer.peek();
-        if (nextToken.type === Token_1.TokenType.IncOp || nextToken.type === Token_1.TokenType.DecOp) {
+        if (nextToken.type === TokenType_1.TokenType.IncOp || nextToken.type === TokenType_1.TokenType.DecOp) {
             this._lexer.get();
-            return this.createExpressionNode("PostfE", {
-                operator: nextToken.text,
-                operand: primary,
+            return this.createExpressionNode(ScriptingSourceTree_1.T_POSTFIX_OP_EXPRESSION, {
+                op: nextToken.text,
+                expr: primary,
             }, startToken, nextToken);
         }
         return primary;
@@ -1903,99 +1823,88 @@ class Parser {
         var _a;
         const start = this._lexer.peek();
         switch (start.type) {
-            case Token_1.TokenType.LParent:
+            case TokenType_1.TokenType.LParent:
                 // --- Parenthesised or no-arg expression
                 this._lexer.get();
-                if (this._lexer.peek().type === Token_1.TokenType.RParent) {
+                if (this._lexer.peek().type === TokenType_1.TokenType.RParent) {
                     // --- No-arg
                     const endToken = this._lexer.get();
-                    return this.createExpressionNode("NoArgE", {}, start, endToken);
+                    return this.createExpressionNode(ScriptingSourceTree_1.T_NO_ARG_EXPRESSION, {}, start, endToken);
                 }
                 // --- Parenthesized
-                const parenthesizedExpr = this.parseExpr();
+                let parenthesizedExpr = this.parseExpr();
                 if (!parenthesizedExpr) {
                     return null;
                 }
                 const endToken = this._lexer.peek();
-                this.expectToken(Token_1.TokenType.RParent, "W006");
-                (_a = parenthesizedExpr.parenthesized) !== null && _a !== void 0 ? _a : (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;
-            case Token_1.TokenType.Identifier: {
+                this.expectToken(TokenType_1.TokenType.RParent, "W006");
+                return Object.assign(Object.assign({}, parenthesizedExpr), { parenthesized: ((_a = parenthesizedExpr.parenthesized) !== null && _a !== void 0 ? _a : 0) + 1, startToken: start, endToken });
+            case TokenType_1.TokenType.Identifier: {
                 const idToken = this._lexer.get();
-                return this.createExpressionNode("IdE", {
+                return this.createExpressionNode(ScriptingSourceTree_1.T_IDENTIFIER, {
                     name: idToken.text,
                 }, idToken, idToken);
             }
-            case Token_1.TokenType.Global: {
+            case TokenType_1.TokenType.Global: {
                 this._lexer.get();
                 const idToken = this._lexer.get();
-                if (idToken.type !== Token_1.TokenType.Identifier) {
+                if (idToken.type !== TokenType_1.TokenType.Identifier) {
                     this.reportError("W003");
                     return null;
                 }
-                return this.createExpressionNode("IdE", {
+                return this.createExpressionNode(ScriptingSourceTree_1.T_IDENTIFIER, {
                     name: idToken.text,
                     isGlobal: true,
                 }, idToken, idToken);
             }
-            case Token_1.TokenType.Backtick:
+            case TokenType_1.TokenType.Backtick:
                 return this.parseTemplateLiteral();
-            case Token_1.TokenType.False:
-            case Token_1.TokenType.True:
+            case TokenType_1.TokenType.False:
+            case TokenType_1.TokenType.True:
                 this._lexer.get();
-                return this.createExpressionNode("LitE", {
-                    value: start.type === Token_1.TokenType.True,
+                return this.createExpressionNode(ScriptingSourceTree_1.T_LITERAL, {
+                    value: start.type === TokenType_1.TokenType.True,
                 }, start, start);
-            case Token_1.TokenType.BinaryLiteral:
+            case TokenType_1.TokenType.BinaryLiteral:
                 this._lexer.get();
                 return this.parseBinaryLiteral(start);
-            case Token_1.TokenType.DecimalLiteral:
+            case TokenType_1.TokenType.DecimalLiteral:
                 this._lexer.get();
                 return this.parseDecimalLiteral(start);
-            case Token_1.TokenType.HexadecimalLiteral:
+            case TokenType_1.TokenType.HexadecimalLiteral:
                 this._lexer.get();
                 return this.parseHexadecimalLiteral(start);
-            case Token_1.TokenType.RealLiteral:
+            case TokenType_1.TokenType.RealLiteral:
                 this._lexer.get();
                 return this.parseRealLiteral(start);
-            case Token_1.TokenType.StringLiteral:
+            case TokenType_1.TokenType.StringLiteral:
                 this._lexer.get();
                 return this.parseStringLiteral(start);
-            case Token_1.TokenType.Infinity:
+            case TokenType_1.TokenType.Infinity:
                 this._lexer.get();
-                return this.createExpressionNode("LitE", {
+                return this.createExpressionNode(ScriptingSourceTree_1.T_LITERAL, {
                     value: Infinity,
                 }, start, start);
-            case Token_1.TokenType.NaN:
+            case TokenType_1.TokenType.NaN:
                 this._lexer.get();
-                return this.createExpressionNode("LitE", {
+                return this.createExpressionNode(ScriptingSourceTree_1.T_LITERAL, {
                     value: NaN,
                 }, start, start);
-            case Token_1.TokenType.Null:
+            case TokenType_1.TokenType.Null:
                 this._lexer.get();
-                return this.createExpressionNode("LitE", {
+                return this.createExpressionNode(ScriptingSourceTree_1.T_LITERAL, {
                     value: null,
                 }, start, start);
-            case Token_1.TokenType.Undefined:
+            case TokenType_1.TokenType.Undefined:
                 this._lexer.get();
-                return this.createExpressionNode("LitE", {
+                return this.createExpressionNode(ScriptingSourceTree_1.T_LITERAL, {
                     value: undefined,
                 }, start, start);
-            case Token_1.TokenType.LSquare:
+            case TokenType_1.TokenType.LSquare:
                 return this.parseArrayLiteral();
-            case Token_1.TokenType.LBrace:
+            case TokenType_1.TokenType.LBrace:
                 return this.parseObjectLiteral();
-            case Token_1.TokenType.Divide:
+            case TokenType_1.TokenType.Divide:
                 return this.parseRegExpLiteral();
         }
         return null;
@@ -2007,26 +1916,26 @@ class Parser {
         loop: while (true) {
             let nextToken = this._lexer.peek();
             switch (nextToken.type) {
-                case Token_1.TokenType.StringLiteral:
+                case TokenType_1.TokenType.StringLiteral:
                     this._lexer.get();
                     const str = this.parseStringLiteral(nextToken, false);
                     segments.push(str);
                     break;
-                case Token_1.TokenType.DollarLBrace:
+                case TokenType_1.TokenType.DollarLBrace:
                     this._lexer.get();
                     const innerExpr = this.parseExpr();
                     segments.push(innerExpr);
-                    this.expectToken(Token_1.TokenType.RBrace, "W004");
+                    this.expectToken(TokenType_1.TokenType.RBrace, "W004");
                     this._lexer.setStartingPhaseToTemplateLiteral();
                     break;
-                case Token_1.TokenType.Backtick:
+                case TokenType_1.TokenType.Backtick:
                     break loop;
                 default:
                     this.reportError("W004");
             }
         }
         const endToken = this._lexer.get();
-        return this.createExpressionNode("TempLitE", { segments }, startToken, endToken);
+        return this.createExpressionNode(ScriptingSourceTree_1.T_TEMPLATE_LITERAL_EXPRESSION, { segments }, startToken, endToken);
     }
     /**
      * Parses an array literal
@@ -2034,15 +1943,15 @@ class Parser {
     parseArrayLiteral() {
         const start = this._lexer.get();
         let expressions = [];
-        if (this._lexer.peek().type !== Token_1.TokenType.RSquare) {
+        if (this._lexer.peek().type !== TokenType_1.TokenType.RSquare) {
             const expr = this.getExpression();
             if (expr) {
-                expressions = expr.type === "SeqE" ? expr.expressions : [expr];
+                expressions = expr.type === ScriptingSourceTree_1.T_SEQUENCE_EXPRESSION ? expr.exprs : [expr];
             }
         }
         const endToken = this._lexer.peek();
-        this.expectToken(Token_1.TokenType.RSquare);
-        return this.createExpressionNode("ALitE", {
+        this.expectToken(TokenType_1.TokenType.RSquare);
+        return this.createExpressionNode(ScriptingSourceTree_1.T_ARRAY_LITERAL, {
             items: expressions,
         }, start, endToken);
     }
@@ -2052,23 +1961,23 @@ class Parser {
     parseObjectLiteral() {
         const start = this._lexer.get();
         let props = [];
-        if (this._lexer.peek().type !== Token_1.TokenType.RBrace) {
-            while (this._lexer.peek().type !== Token_1.TokenType.RBrace) {
+        if (this._lexer.peek().type !== TokenType_1.TokenType.RBrace) {
+            while (this._lexer.peek().type !== TokenType_1.TokenType.RBrace) {
                 // --- Check the next token
                 const nextToken = this._lexer.peek();
                 const traits = TokenTrait_1.tokenTraits[nextToken.type];
                 let nameExpr;
                 // --- Get property name or calculated property name
                 if (traits.expressionStart) {
-                    if (nextToken.type === Token_1.TokenType.LSquare) {
+                    if (nextToken.type === TokenType_1.TokenType.LSquare) {
                         this._lexer.get();
                         nameExpr = this.getExpression();
                         if (!nameExpr) {
                             return null;
                         }
-                        this.expectToken(Token_1.TokenType.RSquare, "W005");
-                        nameExpr = this.createExpressionNode("SeqE", {
-                            expressions: [nameExpr],
+                        this.expectToken(TokenType_1.TokenType.RSquare, "W005");
+                        nameExpr = this.createExpressionNode(ScriptingSourceTree_1.T_SEQUENCE_EXPRESSION, {
+                            exprs: [nameExpr],
                         }, start);
                     }
                     else if (traits.isPropLiteral) {
@@ -2076,9 +1985,9 @@ class Parser {
                         if (!nameExpr) {
                             return null;
                         }
-                        if (nameExpr.type !== "IdE" &&
-                            nameExpr.type !== "LitE" &&
-                            nameExpr.type !== "SpreadE") {
+                        if (nameExpr.type !== ScriptingSourceTree_1.T_IDENTIFIER &&
+                            nameExpr.type !== ScriptingSourceTree_1.T_LITERAL &&
+                            nameExpr.type !== ScriptingSourceTree_1.T_SPREAD_EXPRESSION) {
                             this.reportError("W007");
                             return null;
                         }
@@ -2090,16 +1999,9 @@ class Parser {
                 }
                 else if (traits.keywordLike) {
                     nameExpr = {
-                        type: "IdE",
+                        type: ScriptingSourceTree_1.T_IDENTIFIER,
+                        nodeId: createXmlUiTreeNodeId(),
                         name: nextToken.text,
-                        value: undefined,
-                        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,
                     };
@@ -2110,33 +2012,29 @@ class Parser {
                     return null;
                 }
                 const nameType = nameExpr.type;
-                if (nameType === "SpreadE") {
+                if (nameType === ScriptingSourceTree_1.T_SPREAD_EXPRESSION) {
                     props.push(nameExpr);
                 }
                 else {
-                    if (nameType === "LitE") {
+                    if (nameType === ScriptingSourceTree_1.T_LITERAL) {
                         const val = nameExpr.value;
                         if (typeof val !== "number" && typeof val !== "string") {
-                            this.expectToken(Token_1.TokenType.RBrace, "W007");
+                            this.expectToken(TokenType_1.TokenType.RBrace, "W007");
                             return null;
                         }
                     }
-                    // else if (nameType !== "IdE") {
-                    //   this.expectToken(TokenType.RBrace, "W007");
-                    //   return null;
-                    // }
                     // --- Value is optional, when we have a name
                     let valueExpr = null;
-                    if (nameType === "IdE") {
+                    if (nameType === ScriptingSourceTree_1.T_IDENTIFIER) {
                         const nameFollowerToken = this._lexer.peek();
-                        if (nameFollowerToken.type === Token_1.TokenType.Comma ||
-                            nameFollowerToken.type === Token_1.TokenType.RBrace) {
+                        if (nameFollowerToken.type === TokenType_1.TokenType.Comma ||
+                            nameFollowerToken.type === TokenType_1.TokenType.RBrace) {
                             valueExpr = Object.assign({}, nameExpr);
                         }
                     }
                     // --- Move to property value
                     if (!valueExpr) {
-                        this.expectToken(Token_1.TokenType.Colon, "W008");
+                        this.expectToken(TokenType_1.TokenType.Colon, "W008");
                         valueExpr = this.getExpression(false);
                         if (!valueExpr) {
                             return null;
@@ -2146,19 +2044,19 @@ class Parser {
                 }
                 // --- Test property termination
                 const next = this._lexer.peek().type;
-                if (next === Token_1.TokenType.Comma) {
+                if (next === TokenType_1.TokenType.Comma) {
                     this._lexer.get();
                 }
                 else {
-                    if (next !== Token_1.TokenType.RBrace) {
+                    if (next !== TokenType_1.TokenType.RBrace) {
                         break;
                     }
                 }
             }
         }
         const endToken = this._lexer.peek();
-        this.expectToken(Token_1.TokenType.RBrace, "W004");
-        return this.createExpressionNode("OLitE", {
+        this.expectToken(TokenType_1.TokenType.RBrace, "W004");
+        return this.createExpressionNode(ScriptingSourceTree_1.T_OBJECT_LITERAL, {
             props,
         }, start, endToken);
     }
@@ -2167,7 +2065,7 @@ class Parser {
         const startToken = this._lexer.peek();
         const result = this._lexer.getRegEx();
         if (result.success) {
-            return this.createExpressionNode("LitE", {
+            return this.createExpressionNode(ScriptingSourceTree_1.T_LITERAL, {
                 value: new RegExp(result.pattern, result.flags),
             }, startToken, this._lexer.peek());
         }
@@ -2195,7 +2093,7 @@ class Parser {
      */
     expectToken(type, errorCode, allowEof) {
         const next = this._lexer.peek();
-        if (next.type === type || (allowEof && next.type === Token_1.TokenType.Eof)) {
+        if (next.type === type || (allowEof && next.type === TokenType_1.TokenType.Eof)) {
             // --- Skip the expected token
             return this._lexer.get();
         }
@@ -2246,9 +2144,6 @@ class Parser {
         this._parseErrors.push({
             code: errorCode,
             text: errorText,
-            line: token.location.startLine,
-            column: token.location.startColumn,
-            position: token.location.startPosition,
         });
         throw new ParserError_1.ParserError(errorText, errorCode);
         function replace(input, placeholder, replacement) {
@@ -2266,21 +2161,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 !== null && source !== void 0 ? source : this.getSource(startToken, endToken),
+            startToken,
+            endToken,
         });
     }
     /**
@@ -2291,24 +2179,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 !== null && source !== void 0 ? source : this.getSource(startToken, endToken),
+            nodeId: createXmlUiTreeNodeId(),
             startToken,
             endToken,
         });
@@ -2321,38 +2201,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 || startToken === void 0 ? void 0 : startToken.location) === null || _a === void 0 ? void 0 : _a.startPosition;
-        const currentToken = this._lexer.peek();
-        const endPosition = endToken
-            ? endToken.location.endPosition
-            : currentToken.type === Token_1.TokenType.Eof
-                ? currentToken.location.startPosition + 1
-                : currentToken.location.startPosition;
         return Object.assign({}, stump, {
             type,
-            startPosition,
-            endPosition,
-            startLine: (_b = startToken === null || startToken === void 0 ? void 0 : startToken.location) === null || _b === void 0 ? void 0 : _b.startLine,
-            startColumn: (_c = startToken === null || startToken === void 0 ? void 0 : startToken.location) === null || _c === void 0 ? void 0 : _c.startColumn,
-            endLine: endToken ? endToken.location.endLine : (_d = startToken === null || startToken === void 0 ? void 0 : startToken.location) === null || _d === void 0 ? void 0 : _d.endLine,
-            endColumn: endToken ? endToken.location.endColumn : (_e = startToken === null || startToken === void 0 ? void 0 : startToken.location) === null || _e === void 0 ? void 0 : _e.endColumn,
-            source: this.source && startPosition !== undefined && endPosition !== undefined
-                ? this.source.substring(startPosition, endPosition)
-                : undefined,
+            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 === Token_1.TokenType.Eof ? end.location.startPosition : end.location.endPosition);
-    }
     /**
      * Parses a binary literal
      * @param token Literal token
@@ -2366,7 +2221,7 @@ class Parser {
         else {
             value = parseInt(token.text.substring(2).replace(/[_']/g, ""), 2);
         }
-        return this.createExpressionNode("LitE", {
+        return this.createExpressionNode(ScriptingSourceTree_1.T_LITERAL, {
             value,
         }, token, token);
     }
@@ -2383,7 +2238,7 @@ class Parser {
         else {
             value = parseInt(token.text.replace(/[_']/g, ""), 10);
         }
-        return this.createExpressionNode("LitE", {
+        return this.createExpressionNode(ScriptingSourceTree_1.T_LITERAL, {
             value,
         }, token, token);
     }
@@ -2400,7 +2255,7 @@ class Parser {
         else {
             value = parseInt(token.text.substring(2).replace(/[_']/g, ""), 16);
         }
-        return this.createExpressionNode("LitE", {
+        return this.createExpressionNode(ScriptingSourceTree_1.T_LITERAL, {
             value,
         }, token, token);
     }
@@ -2410,7 +2265,7 @@ class Parser {
      */
     parseRealLiteral(token) {
         let value = parseFloat(token.text.replace(/[_']/g, ""));
-        return this.createExpressionNode("LitE", {
+        return this.createExpressionNode(ScriptingSourceTree_1.T_LITERAL, {
             value,
         }, token, token);
     }
@@ -2640,7 +2495,7 @@ class Parser {
                 break;
         }
         // --- Done
-        return this.createExpressionNode("LitE", {
+        return this.createExpressionNode(ScriptingSourceTree_1.T_LITERAL, {
             value: result,
         }, token, token);
         function isHexaDecimal(ch) {
@@ -2649,43 +2504,43 @@ class Parser {
     }
     convertToArrayDestructure(seq) {
         var _a;
-        const items = seq.type === "SeqE" ? seq.expressions : seq.items;
-        const result = this.createExpressionNode("Destr", { arrayDestruct: [] }, seq.startToken, seq.endToken);
+        const items = seq.type === ScriptingSourceTree_1.T_SEQUENCE_EXPRESSION ? seq.exprs : seq.items;
+        const result = this.createExpressionNode(ScriptingSourceTree_1.T_DESTRUCTURE, { aDestr: [] }, seq.startToken, seq.endToken);
         // --- Convert all items
         for (const item of items) {
             let arrayD;
             switch (item.type) {
-                case "NoArgE":
-                    arrayD = this.createExpressionNode("ADestr", {}, item.startToken, item.endToken);
+                case ScriptingSourceTree_1.T_NO_ARG_EXPRESSION:
+                    arrayD = this.createExpressionNode(ScriptingSourceTree_1.T_ARRAY_DESTRUCTURE, {}, item.startToken, item.endToken);
                     break;
-                case "IdE":
-                    arrayD = this.createExpressionNode("ADestr", { id: item.name }, item.startToken, item.endToken);
+                case ScriptingSourceTree_1.T_IDENTIFIER:
+                    arrayD = this.createExpressionNode(ScriptingSourceTree_1.T_ARRAY_DESTRUCTURE, { id: item.name }, item.startToken, item.endToken);
                     break;
-                case "Destr":
-                    result.arrayDestruct.push(...item.arrayDestruct);
+                case ScriptingSourceTree_1.T_DESTRUCTURE:
+                    result.aDestr.push(...item.aDestr);
                     break;
-                case "ADestr":
+                case ScriptingSourceTree_1.T_ARRAY_DESTRUCTURE:
                     arrayD = item;
                     break;
-                case "ALitE": {
+                case ScriptingSourceTree_1.T_ARRAY_LITERAL: {
                     const destructure = this.convertToArrayDestructure(item);
                     if (destructure) {
-                        arrayD = this.createExpressionNode("ADestr", {
-                            arrayDestruct: destructure.arrayDestruct,
+                        arrayD = this.createExpressionNode(ScriptingSourceTree_1.T_ARRAY_DESTRUCTURE, {
+                            aDestr: destructure.aDestr,
                         }, item.startToken, item.endToken);
                     }
                     break;
                 }
-                case "ODestr":
-                    arrayD = this.createExpressionNode("ADestr", {
-                        objectDestruct: item,
+                case ScriptingSourceTree_1.T_OBJECT_DESTRUCTURE:
+                    arrayD = this.createExpressionNode(ScriptingSourceTree_1.T_ARRAY_DESTRUCTURE, {
+                        oDestr: item,
                     }, item.startToken, item.endToken);
                     break;
-                case "OLitE": {
+                case ScriptingSourceTree_1.T_OBJECT_LITERAL: {
                     const destructure = this.convertToObjectDestructure(item);
                     if (destructure) {
-                        arrayD = this.createExpressionNode("ADestr", {
-                            objectDestruct: destructure.objectDestruct,
+                        arrayD = this.createExpressionNode(ScriptingSourceTree_1.T_ARRAY_DESTRUCTURE, {
+                            oDestr: destructure.oDestr,
                         }, item.startToken, item.endToken);
                     }
                     break;
@@ -2695,66 +2550,66 @@ class Parser {
                     return null;
             }
             if (arrayD)
-                (_a = result.arrayDestruct) === null || _a === void 0 ? void 0 : _a.push(arrayD);
+                (_a = result.aDestr) === null || _a === void 0 ? void 0 : _a.push(arrayD);
         }
         // --- Done.
         return result;
     }
     convertToObjectDestructure(objLit) {
         var _a;
-        const result = this.createExpressionNode("Destr", { objectDestruct: [] }, objLit.startToken, objLit.endToken);
+        const result = this.createExpressionNode(ScriptingSourceTree_1.T_DESTRUCTURE, { oDestr: [] }, objLit.startToken, objLit.endToken);
         // --- Convert all items
         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 !== ScriptingSourceTree_1.T_IDENTIFIER) {
+                reportError("W018");
                 return null;
             }
             let objD;
             switch (propValue.type) {
-                case "IdE":
+                case ScriptingSourceTree_1.T_IDENTIFIER:
                     if (propValue.name === propKey.name) {
-                        objD = this.createExpressionNode("ODestr", { id: propKey.name }, propValue.startToken, propValue.endToken);
+                        objD = this.createExpressionNode(ScriptingSourceTree_1.T_OBJECT_DESTRUCTURE, { id: propKey.name }, propValue.startToken, propValue.endToken);
                     }
                     else {
-                        objD = this.createExpressionNode("ODestr", {
+                        objD = this.createExpressionNode(ScriptingSourceTree_1.T_OBJECT_DESTRUCTURE, {
                             id: propKey.name,
                             alias: propValue.name,
                         }, propValue.startToken, propValue.endToken);
                     }
                     break;
-                case "ADestr": {
-                    objD = this.createExpressionNode("ODestr", {
+                case ScriptingSourceTree_1.T_ARRAY_DESTRUCTURE: {
+                    objD = this.createExpressionNode(ScriptingSourceTree_1.T_OBJECT_DESTRUCTURE, {
                         id: propKey.name,
-                        arrayDestruct: propValue,
+                        aDestr: propValue,
                     }, propKey.startToken, propValue.endToken);
                     break;
                 }
-                case "ALitE": {
+                case ScriptingSourceTree_1.T_ARRAY_LITERAL: {
                     const destructure = this.convertToArrayDestructure(propValue);
                     if (destructure) {
-                        objD = this.createExpressionNode("ODestr", {
+                        objD = this.createExpressionNode(ScriptingSourceTree_1.T_OBJECT_DESTRUCTURE, {
                             id: propKey.name,
-                            arrayDestruct: destructure.arrayDestruct,
+                            aDestr: destructure.aDestr,
                         }, propKey.startToken, propValue.endToken);
                     }
                     break;
                 }
-                case "ODestr":
+                case ScriptingSourceTree_1.T_OBJECT_DESTRUCTURE:
                     objD = propValue;
                     break;
-                case "OLitE": {
+                case ScriptingSourceTree_1.T_OBJECT_LITERAL: {
                     const destructure = this.convertToObjectDestructure(propValue);
                     if (destructure) {
-                        objD = this.createExpressionNode("ODestr", {
+                        objD = this.createExpressionNode(ScriptingSourceTree_1.T_OBJECT_DESTRUCTURE, {
                             id: propKey.name,
-                            objectDestruct: destructure.objectDestruct,
+                            oDestr: destructure.oDestr,
                         }, propKey.startToken, propValue.endToken);
                     }
                     break;
@@ -2764,7 +2619,7 @@ class Parser {
                     return null;
             }
             if (objD)
-                (_a = result.objectDestruct) === null || _a === void 0 ? void 0 : _a.push(objD);
+                (_a = result.oDestr) === null || _a === void 0 ? void 0 : _a.push(objD);
         }
         // --- Done.
         return result;
@@ -2778,4 +2633,3 @@ class Parser {
     }
 }
 exports.Parser = Parser;
-("TypeError: Cannot read properties of undefined (reading 'canBeUnary')\n    at Parser.parseUnaryOrPrefixExpr (/home/ez/code/work/xmlui/xmlui/src/parsers/scripting/Parser.ts:2041:38)\n    at Parser.parseExponentialExpr (/home/ez/code/work/xmlui/xmlui/src/parsers/scripting/Parser.ts:1985:25)\n    at Parser.parseMultExpr (/home/ez/code/work/xmlui/xmlui/src/parsers/scripting/Parser.ts:1951:25)\n    at Parser.parseAddExpr (/home/ez/code/work/xmlui/xmlui/src/parsers/scripting/Parser.ts:1917:25)\n    at Par…nExpr (/home/ez/code/work/xmlui/xmlui/src/parsers/scripting/Parser.ts:1835:25)\n    at Parser.parseEquExpr (/home/ez/code/work/xmlui/xmlui/src/parsers/scripting/Parser.ts:1793:25)\n    at Parser.parseBitwiseAndExpr (/home/ez/code/work/xmlui/xmlui/src/parsers/scripting/Parser.ts:1760:25)\n    at Parser.parseBitwiseXorExpr (/home/ez/code/work/xmlui/xmlui/src/parsers/scripting/Parser.ts:1727:25)\n    at Parser.parseBitwiseOrExpr (/home/ez/code/work/xmlui/xmlui/src/parsers/scripting/Parser.ts:1694:25)");