xmlui 0.11.3 → 0.11.6

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

@@ -1,2638 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Parser = void 0;
-exports.createXmlUiTreeNodeId = createXmlUiTreeNodeId;
-const ScriptingSourceTree_1 = require("../../components-core/script-runner/ScriptingSourceTree");
-const InputStream_1 = require("../common/InputStream");
-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
- */
-var StrParseState;
-(function (StrParseState) {
-    StrParseState[StrParseState["Normal"] = 0] = "Normal";
-    StrParseState[StrParseState["Backslash"] = 1] = "Backslash";
-    StrParseState[StrParseState["X"] = 2] = "X";
-    StrParseState[StrParseState["Xh"] = 3] = "Xh";
-    StrParseState[StrParseState["UX1"] = 4] = "UX1";
-    StrParseState[StrParseState["UX2"] = 5] = "UX2";
-    StrParseState[StrParseState["UX3"] = 6] = "UX3";
-    StrParseState[StrParseState["UX4"] = 7] = "UX4";
-    StrParseState[StrParseState["Ucp1"] = 8] = "Ucp1";
-    StrParseState[StrParseState["Ucp2"] = 9] = "Ucp2";
-    StrParseState[StrParseState["Ucp3"] = 10] = "Ucp3";
-    StrParseState[StrParseState["Ucp4"] = 11] = "Ucp4";
-    StrParseState[StrParseState["Ucp5"] = 12] = "Ucp5";
-    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
- */
-class Parser {
-    /**
-     * Initializes the parser with the specified source code
-     * @param source Source code to parse
-     */
-    constructor(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));
-    }
-    /**
-     * The errors raised during the parse phase
-     */
-    get errors() {
-        return this._parseErrors;
-    }
-    /**
-     * Gets the current token
-     */
-    get current() {
-        return this._lexer.peek();
-    }
-    /**
-     * Checks if we're at the end of the expression
-     */
-    get isEof() {
-        return this._lexer.peek().type === TokenType_1.TokenType.Eof;
-    }
-    /**
-     * Gets the characters remaining after parsing
-     */
-    getTail() {
-        return this._lexer.getTail();
-    }
-    // ==========================================================================
-    // Statement parsing
-    /**
-     * Parses a list of statements:
-     *
-     * statements
-     *   : statement*
-     *   ;
-     *
-     * statement
-     *   : emptyStatement
-     *   | expressionStatement
-     *   | letStatement
-     *   | returnStatement
-     *   ;
-     */
-    parseStatements() {
-        this._statementLevel = 0;
-        const statements = [];
-        while (!this.isEof) {
-            const statement = this.parseStatement();
-            if (!statement)
-                return null;
-            statements.push(statement);
-            if (statement.type !== ScriptingSourceTree_1.T_EMPTY_STATEMENT) {
-                this.skipToken(TokenType_1.TokenType.Semicolon);
-            }
-        }
-        return statements;
-    }
-    /**
-     * Parses a single statement
-     */
-    parseStatement(allowSequence = true) {
-        this._statementLevel++;
-        try {
-            const startToken = this._lexer.peek();
-            switch (startToken.type) {
-                case TokenType_1.TokenType.Semicolon:
-                    return this.parseEmptyStatement();
-                case TokenType_1.TokenType.Let:
-                    return this.parseLetStatement();
-                case TokenType_1.TokenType.Const:
-                    return this.parseConstStatement();
-                case TokenType_1.TokenType.Var:
-                    return this.parseVarStatement();
-                case TokenType_1.TokenType.LBrace:
-                    return this.parseBlockStatement();
-                case TokenType_1.TokenType.If:
-                    return this.parseIfStatement();
-                case TokenType_1.TokenType.Do:
-                    return this.parseDoWhileStatement();
-                case TokenType_1.TokenType.While:
-                    return this.parseWhileStatement();
-                case TokenType_1.TokenType.Return:
-                    return this.parseReturnStatement();
-                case TokenType_1.TokenType.Break:
-                    this._lexer.get();
-                    return this.createStatementNode(ScriptingSourceTree_1.T_BREAK_STATEMENT, {}, startToken, startToken);
-                case TokenType_1.TokenType.Continue:
-                    this._lexer.get();
-                    return this.createStatementNode(ScriptingSourceTree_1.T_CONTINUE_STATEMENT, {}, startToken, startToken);
-                case TokenType_1.TokenType.For:
-                    return this.parseForStatement();
-                case TokenType_1.TokenType.Throw:
-                    return this.parseThrowStatement();
-                case TokenType_1.TokenType.Try:
-                    return this.parseTryStatement();
-                case TokenType_1.TokenType.Switch:
-                    return this.parseSwitchStatement();
-                case TokenType_1.TokenType.Function:
-                    return this.parseFunctionDeclaration();
-                default:
-                    if (this.isExpressionStart(startToken)) {
-                        return this.parseExpressionStatement(allowSequence);
-                    }
-                    this.reportError("W002", startToken, startToken.text);
-                    return null;
-            }
-        }
-        finally {
-            this._statementLevel--;
-        }
-    }
-    /**
-     * Parses an empty statement
-     *
-     * emptyStatement
-     *   : ";"
-     *   ;
-     */
-    parseEmptyStatement() {
-        const startToken = this._lexer.get();
-        return this.createStatementNode(ScriptingSourceTree_1.T_EMPTY_STATEMENT, {}, startToken, startToken);
-    }
-    /**
-     * Parses an expression statement
-     *
-     * expressionStatement
-     *   : expression
-     *   ;
-     */
-    parseExpressionStatement(allowSequence = true) {
-        const startToken = this._lexer.peek();
-        const expr = this.getExpression(allowSequence);
-        return expr
-            ? this.createStatementNode(ScriptingSourceTree_1.T_EXPRESSION_STATEMENT, {
-                expr,
-            }, startToken, expr.endToken)
-            : null;
-    }
-    /**
-     * Parses a let statement
-     *
-     * letStatement
-     *   : "let" id ["=" expression] ("," id ["=" expression])*
-     *   ;
-     */
-    parseLetStatement() {
-        const startToken = this._lexer.get();
-        let endToken = startToken;
-        const decls = [];
-        while (true) {
-            const declStart = this._lexer.peek();
-            let declarationProps = {};
-            if (declStart.type === TokenType_1.TokenType.LBrace) {
-                // --- This is object destructure
-                endToken = this._lexer.ahead(1);
-                const oDestr = this.parseObjectDestructure();
-                if (oDestr === null)
-                    return null;
-                declarationProps = {
-                    oDestr,
-                };
-                endToken = oDestr.length > 0 ? oDestr[oDestr.length - 1].endToken : endToken;
-            }
-            else if (declStart.type === TokenType_1.TokenType.LSquare) {
-                // --- This is array destructure
-                endToken = this._lexer.ahead(1);
-                const aDestr = this.parseArrayDestructure();
-                if (aDestr === null)
-                    return null;
-                declarationProps = {
-                    aDestr,
-                };
-                endToken = aDestr.length > 0 ? aDestr[aDestr.length - 1].endToken : endToken;
-            }
-            else if (declStart.type === TokenType_1.TokenType.Identifier) {
-                if (declStart.text.startsWith("$")) {
-                    this.reportError("W031");
-                    return null;
-                }
-                endToken = this._lexer.get();
-                declarationProps = {
-                    id: declStart.text,
-                };
-            }
-            else {
-                this.reportError("W003");
-                return null;
-            }
-            // --- Optional initialization
-            const initToken = this._lexer.peek();
-            let expr = null;
-            if (initToken.type === TokenType_1.TokenType.Assignment) {
-                this._lexer.get();
-                expr = this.getExpression(false);
-                if (expr === null)
-                    return null;
-                declarationProps.expr = expr;
-                endToken = expr.endToken;
-            }
-            else if (declarationProps.aDestr || declarationProps.oDestr) {
-                this.reportError("W009", initToken);
-                return null;
-            }
-            // --- New declaration reached
-            decls.push(this.createExpressionNode(ScriptingSourceTree_1.T_VAR_DECLARATION, declarationProps, declStart, endToken));
-            // --- Check for more declarations
-            if (this._lexer.peek().type !== TokenType_1.TokenType.Comma)
-                break;
-            this._lexer.get();
-        }
-        // --- Done
-        return this.createStatementNode(ScriptingSourceTree_1.T_LET_STATEMENT, {
-            decls,
-        }, startToken, endToken);
-    }
-    /**
-     * Parses a const statement
-     *
-     * constStatement
-     *   : "const" id "=" expression
-     *   ;
-     */
-    parseConstStatement() {
-        const startToken = this._lexer.get();
-        let endToken = startToken;
-        const decls = [];
-        while (true) {
-            const declStart = this._lexer.peek();
-            let declarationProps = {};
-            if (declStart.type === TokenType_1.TokenType.LBrace) {
-                // --- This is object destructure
-                endToken = this._lexer.ahead(1);
-                const oDestr = this.parseObjectDestructure();
-                if (oDestr === null)
-                    return null;
-                declarationProps = {
-                    oDestr,
-                };
-                endToken = oDestr.length > 0 ? oDestr[oDestr.length - 1].endToken : endToken;
-            }
-            else if (declStart.type === TokenType_1.TokenType.LSquare) {
-                // --- This is array destructure
-                endToken = this._lexer.ahead(1);
-                const aDestr = this.parseArrayDestructure();
-                if (aDestr === null)
-                    return null;
-                declarationProps = {
-                    aDestr,
-                };
-                endToken = aDestr.length > 0 ? aDestr[aDestr.length - 1].endToken : endToken;
-            }
-            else if (declStart.type === TokenType_1.TokenType.Identifier) {
-                if (declStart.text.startsWith("$")) {
-                    this.reportError("W031");
-                    return null;
-                }
-                endToken = this._lexer.get();
-                declarationProps = {
-                    id: declStart.text,
-                };
-            }
-            else {
-                this.reportError("W003");
-                return null;
-            }
-            this.expectToken(TokenType_1.TokenType.Assignment);
-            const expr = this.getExpression(false);
-            if (expr === null)
-                return null;
-            declarationProps.expr = expr;
-            endToken = expr.endToken;
-            // --- New declaration reached
-            decls.push(this.createExpressionNode(ScriptingSourceTree_1.T_VAR_DECLARATION, declarationProps, declStart, endToken));
-            // --- Check for more declarations
-            if (this._lexer.peek().type !== TokenType_1.TokenType.Comma)
-                break;
-            this._lexer.get();
-        }
-        // --- Done
-        return this.createStatementNode(ScriptingSourceTree_1.T_CONST_STATEMENT, {
-            decls,
-        }, startToken, endToken);
-    }
-    /**
-     * Parses a var statement
-     *
-     * constStatement
-     *   : "var" id "=" expression
-     *   ;
-     */
-    parseVarStatement() {
-        const startToken = this._lexer.get();
-        let endToken = startToken;
-        const decls = [];
-        while (true) {
-            const declStart = this._lexer.peek();
-            let declarationProps = {};
-            if (declStart.type === TokenType_1.TokenType.Identifier) {
-                if (declStart.text.startsWith("$")) {
-                    this.reportError("W031");
-                    return null;
-                }
-                endToken = this._lexer.get();
-                declarationProps = {
-                    id: {
-                        type: ScriptingSourceTree_1.T_IDENTIFIER,
-                        name: declStart.text,
-                        startToken: declStart,
-                        endToken,
-                    },
-                };
-            }
-            else {
-                this.reportError("W003");
-                return null;
-            }
-            // --- Mandatory initialization
-            this.expectToken(TokenType_1.TokenType.Assignment);
-            const expr = this.getExpression(false);
-            if (expr === null)
-                return null;
-            declarationProps.expr = expr;
-            endToken = expr.endToken;
-            // --- New declaration reached
-            decls.push(this.createExpressionNode(ScriptingSourceTree_1.T_REACTIVE_VAR_DECLARATION, declarationProps, declStart, endToken));
-            // --- Check for more declarations
-            if (this._lexer.peek().type !== TokenType_1.TokenType.Comma)
-                break;
-            this._lexer.get();
-        }
-        // --- Done
-        return this.createStatementNode(ScriptingSourceTree_1.T_VAR_STATEMENT, {
-            decls,
-        }, startToken, endToken);
-    }
-    /**
-     * Parses an object destructure expression
-     */
-    parseObjectDestructure() {
-        const result = [];
-        // --- Skip the starting left brace
-        const startToken = this._lexer.get();
-        let endToken = startToken;
-        let nextToken = this._lexer.peek();
-        while (nextToken.type === TokenType_1.TokenType.Identifier) {
-            // --- Obtain the ID
-            const id = nextToken.text;
-            if (id.startsWith("$")) {
-                this.reportError("W031");
-                return null;
-            }
-            let alias;
-            let aDestr;
-            let oDestr;
-            this._lexer.get();
-            nextToken = this._lexer.peek();
-            if (nextToken.type === TokenType_1.TokenType.Colon) {
-                // --- Check the available cases
-                this._lexer.get();
-                nextToken = this._lexer.peek();
-                if (nextToken.type === TokenType_1.TokenType.Identifier) {
-                    alias = nextToken.text;
-                    endToken = nextToken;
-                    this._lexer.get();
-                }
-                else if (nextToken.type === TokenType_1.TokenType.LSquare) {
-                    aDestr = this.parseArrayDestructure();
-                    if (aDestr === null)
-                        return null;
-                    endToken = aDestr[aDestr.length - 1].endToken;
-                }
-                else if (nextToken.type === TokenType_1.TokenType.LBrace) {
-                    oDestr = this.parseObjectDestructure();
-                    if (oDestr === null)
-                        return null;
-                    endToken = oDestr[oDestr.length - 1].endToken;
-                }
-            }
-            // --- Check for next segment
-            nextToken = this._lexer.peek();
-            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();
-                }
-            }
-        }
-        // --- Expect a closing right brace
-        this.expectToken(TokenType_1.TokenType.RBrace, "W004");
-        return result;
-    }
-    parseArrayDestructure() {
-        const result = [];
-        // --- Skip the starting left square
-        const startToken = this._lexer.get();
-        let endToken = startToken;
-        do {
-            let nextToken = this._lexer.peek();
-            let id;
-            let aDestr;
-            let oDestr;
-            if (nextToken.type === TokenType_1.TokenType.Identifier) {
-                id = nextToken.text;
-                if (id.startsWith("$")) {
-                    this.reportError("W031");
-                    return null;
-                }
-                endToken = nextToken;
-                nextToken = this._lexer.get();
-            }
-            else if (nextToken.type === TokenType_1.TokenType.LSquare) {
-                aDestr = this.parseArrayDestructure();
-                if (aDestr === null)
-                    return null;
-                endToken = aDestr[aDestr.length - 1].endToken;
-            }
-            else if (nextToken.type === TokenType_1.TokenType.LBrace) {
-                oDestr = this.parseObjectDestructure();
-                if (oDestr === null)
-                    return null;
-                endToken = oDestr[oDestr.length - 1].endToken;
-            }
-            nextToken = this._lexer.peek();
-            if (nextToken.type === TokenType_1.TokenType.Comma) {
-                // --- Store the segment
-                result.push(this.createExpressionNode(ScriptingSourceTree_1.T_ARRAY_DESTRUCTURE, { id, aDestr, oDestr }, startToken, endToken));
-                this._lexer.get();
-            }
-            else if (nextToken.type === TokenType_1.TokenType.RSquare) {
-                if (id || aDestr || oDestr) {
-                    // --- Store a non-empty the segment
-                    result.push(this.createExpressionNode(ScriptingSourceTree_1.T_ARRAY_DESTRUCTURE, { id, aDestr, oDestr }, startToken, endToken));
-                }
-                break;
-            }
-            else {
-                this.reportError("W002", nextToken);
-                return null;
-            }
-        } while (true);
-        // --- Expect a closing right square
-        this.expectToken(TokenType_1.TokenType.RSquare, "W005");
-        return result;
-    }
-    /**
-     * Parses a block statement
-     *
-     * blockStatement
-     *   : "{" (statement [";"])* "}"
-     *   ;
-     */
-    parseBlockStatement() {
-        const startToken = this._lexer.get();
-        const stmts = [];
-        while (this._lexer.peek().type !== TokenType_1.TokenType.RBrace) {
-            const statement = this.parseStatement();
-            if (!statement)
-                return null;
-            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(ScriptingSourceTree_1.T_BLOCK_STATEMENT, { stmts }, startToken, endToken);
-    }
-    /**
-     * Parses an if statement
-     *
-     * ifStatement
-     *   : "if" "(" expression ")" statement ["else" statement]
-     *   ;
-     */
-    parseIfStatement() {
-        const startToken = this._lexer.get();
-        let endToken = startToken;
-        this.expectToken(TokenType_1.TokenType.LParent, "W014");
-        const cond = this.getExpression();
-        if (!cond)
-            return null;
-        this.expectToken(TokenType_1.TokenType.RParent, "W006");
-        const thenB = this.parseStatement();
-        if (!thenB)
-            return null;
-        endToken = thenB.endToken;
-        let elseCanFollow = true;
-        if (thenB.type !== ScriptingSourceTree_1.T_BLOCK_STATEMENT) {
-            // --- We need a closing semicolon before else
-            if (this._lexer.peek().type === TokenType_1.TokenType.Semicolon) {
-                this._lexer.get();
-            }
-            else {
-                elseCanFollow = false;
-            }
-        }
-        let elseB = null;
-        if (elseCanFollow && this._lexer.peek().type === TokenType_1.TokenType.Else) {
-            this._lexer.get();
-            elseB = this.parseStatement();
-            if (!elseB)
-                return null;
-            endToken = elseB.endToken;
-        }
-        return this.createStatementNode(ScriptingSourceTree_1.T_IF_STATEMENT, {
-            cond,
-            thenB,
-            elseB,
-        }, startToken, endToken);
-    }
-    /**
-     * Parses a while statement
-     *
-     * whileStatement
-     *   : "while" "(" condition ")" statement
-     *   ;
-     */
-    parseWhileStatement() {
-        const startToken = this._lexer.get();
-        this.expectToken(TokenType_1.TokenType.LParent, "W014");
-        const cond = this.getExpression();
-        if (!cond)
-            return null;
-        this.expectToken(TokenType_1.TokenType.RParent, "W006");
-        const body = this.parseStatement();
-        if (!body)
-            return null;
-        return this.createStatementNode(ScriptingSourceTree_1.T_WHILE_STATEMENT, {
-            cond,
-            body,
-        }, startToken, body.endToken);
-    }
-    /**
-     * Parses a do-while statement
-     *
-     * doWhileStatement
-     *   : "do" statement "while" "(" condition ")"
-     *   ;
-     */
-    parseDoWhileStatement() {
-        const startToken = this._lexer.get();
-        const body = this.parseStatement();
-        if (!body)
-            return null;
-        if (body.type !== ScriptingSourceTree_1.T_BLOCK_STATEMENT && body.type !== ScriptingSourceTree_1.T_EMPTY_STATEMENT) {
-            this.expectToken(TokenType_1.TokenType.Semicolon);
-        }
-        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(TokenType_1.TokenType.RParent, "W006");
-        return this.createStatementNode(ScriptingSourceTree_1.T_DO_WHILE_STATEMENT, {
-            cond,
-            body,
-        }, startToken, endToken);
-    }
-    /**
-     * Parses an expression statement
-     *
-     * returnStatement
-     *   : "return" expression?
-     *   ;
-     */
-    parseReturnStatement() {
-        const startToken = this._lexer.peek();
-        let endToken = this._lexer.get();
-        let expr;
-        if (TokenTrait_1.tokenTraits[this._lexer.peek().type].expressionStart) {
-            expr = this.getExpression();
-            if (expr === null)
-                return null;
-            endToken = expr.endToken;
-        }
-        return this.createStatementNode(ScriptingSourceTree_1.T_RETURN_STATEMENT, {
-            expr,
-        }, startToken, endToken);
-    }
-    /**
-     * forStatement
-     *   : "for" "(" initStatement? ";" expression? ";" expression? ")" statement
-     *   | forInOfStatement
-     *   ;
-     */
-    parseForStatement() {
-        const startToken = this._lexer.peek();
-        this._lexer.get();
-        this.expectToken(TokenType_1.TokenType.LParent, "W014");
-        // --- Check for..in and for..of
-        let nextToken = this._lexer.peek();
-        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 === TokenType_1.TokenType.Of) {
-                return this.parseForInOfStatement(startToken, "none", nextToken, ScriptingSourceTree_1.T_FOR_OF_STATEMENT);
-            }
-        }
-        else if (nextToken.type === TokenType_1.TokenType.Let) {
-            const idToken = this._lexer.ahead(1);
-            if (idToken.type === TokenType_1.TokenType.Identifier) {
-                const inOfToken = this._lexer.ahead(2);
-                if (inOfToken.type === TokenType_1.TokenType.In) {
-                    return this.parseForInOfStatement(startToken, "let", idToken, ScriptingSourceTree_1.T_FOR_IN_STATEMENT);
-                }
-                else if (inOfToken.type === TokenType_1.TokenType.Of) {
-                    return this.parseForInOfStatement(startToken, "let", idToken, ScriptingSourceTree_1.T_FOR_OF_STATEMENT);
-                }
-            }
-        }
-        else if (nextToken.type === TokenType_1.TokenType.Const) {
-            const idToken = this._lexer.ahead(1);
-            if (idToken.type === TokenType_1.TokenType.Identifier) {
-                const inOfToken = this._lexer.ahead(2);
-                if (inOfToken.type === TokenType_1.TokenType.In) {
-                    return this.parseForInOfStatement(startToken, "const", idToken, ScriptingSourceTree_1.T_FOR_IN_STATEMENT);
-                }
-                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 === TokenType_1.TokenType.Semicolon) {
-            // --- Empty statement: no init in the for loop
-            this._lexer.get();
-        }
-        else if (nextToken.type === TokenType_1.TokenType.Let) {
-            // --- Let statement
-            const letStmt = this.parseLetStatement();
-            if (letStmt === null) {
-                return null;
-            }
-            init = letStmt;
-            if (init.decls.some((d) => !d.expr)) {
-                this.reportError("W011");
-                return null;
-            }
-            this.expectToken(TokenType_1.TokenType.Semicolon);
-        }
-        else if (TokenTrait_1.tokenTraits[nextToken.type].expressionStart) {
-            // --- Expression statement
-            const exprStmt = this.parseExpressionStatement();
-            if (exprStmt === null) {
-                return null;
-            }
-            init = exprStmt;
-            this.expectToken(TokenType_1.TokenType.Semicolon);
-        }
-        // --- Parse the condition
-        let cond;
-        nextToken = this._lexer.peek();
-        if (nextToken.type === TokenType_1.TokenType.Semicolon) {
-            // --- No condition
-            this._lexer.get();
-        }
-        else {
-            cond = this.getExpression();
-            if (cond === null) {
-                return null;
-            }
-            this.expectToken(TokenType_1.TokenType.Semicolon);
-        }
-        // --- Parse the update expression
-        let upd;
-        nextToken = this._lexer.peek();
-        if (nextToken.type !== TokenType_1.TokenType.RParent) {
-            upd = this.getExpression();
-            if (upd === null) {
-                return null;
-            }
-        }
-        // --- Close the declaration part
-        this.expectToken(TokenType_1.TokenType.RParent, "W006");
-        // --- Get the body
-        const body = this.parseStatement();
-        if (!body)
-            return null;
-        return this.createStatementNode(ScriptingSourceTree_1.T_FOR_STATEMENT, {
-            init,
-            cond,
-            upd,
-            body,
-        }, startToken, body.endToken);
-    }
-    /**
-     * forInOfStatement
-     *   : "for" "(" [ "let" | "const" ] identifier ( "in" | "of" ) expression? ")" statement
-     *   | forInOfStatement
-     *   ;
-     *
-     * @param startToken Statement start token
-     * @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, varB, idToken, type) {
-        if (varB !== "none") {
-            // --- Skip variable binding type
-            if (idToken.text.startsWith("$")) {
-                this.reportError("W031");
-                return null;
-            }
-            this._lexer.get();
-        }
-        // --- Skip variable name, in/of token
-        this._lexer.get();
-        this._lexer.get();
-        // --- Get the expression
-        const expr = this.getExpression(true);
-        // --- Close the declaration part
-        this.expectToken(TokenType_1.TokenType.RParent, "W006");
-        // --- Get the body
-        const body = this.parseStatement();
-        if (!body)
-            return null;
-        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(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);
-    }
-    /**
-     * Parses a throw statement
-     *
-     * throwStatement
-     *   : "throw" expression
-     *   ;
-     */
-    parseThrowStatement() {
-        const startToken = this._lexer.peek();
-        this._lexer.get();
-        let expr;
-        expr = this.getExpression();
-        if (expr === null)
-            return null;
-        return this.createStatementNode(ScriptingSourceTree_1.T_THROW_STATEMENT, {
-            expr,
-        }, startToken, expr.endToken);
-    }
-    /**
-     * Parses a try..catch..finally statement
-     *
-     * tryStatement
-     *   : "try" blockStatement catchClause finallyClause?
-     *   | "try" blockStatement catchClause? finallyClause
-     *   ;
-     *
-     * catchClause
-     *   : "catch" [ "(" identifier ") ]? blockStatement
-     *   ;
-     *
-     * finallyClause
-     *   : "finally" blockStatement
-     */
-    parseTryStatement() {
-        const getBlock = () => {
-            const nextToken = this._lexer.peek();
-            if (nextToken.type !== TokenType_1.TokenType.LBrace) {
-                this.reportError("W012", nextToken);
-                return null;
-            }
-            return this.parseBlockStatement();
-        };
-        const startToken = this._lexer.peek();
-        let endToken = this._lexer.get();
-        // --- Get "try" block
-        const tryB = getBlock();
-        let catchB;
-        let catchV;
-        let finallyB;
-        let nextToken = this._lexer.peek();
-        if (nextToken.type === TokenType_1.TokenType.Catch) {
-            // --- Catch found
-            this._lexer.get();
-            nextToken = this._lexer.peek();
-            if (nextToken.type === TokenType_1.TokenType.LParent) {
-                // --- Catch variable found
-                this._lexer.get();
-                nextToken = this._lexer.peek();
-                if (nextToken.type !== TokenType_1.TokenType.Identifier) {
-                    this.reportError("W003", nextToken);
-                    return null;
-                }
-                catchV = {
-                    type: ScriptingSourceTree_1.T_IDENTIFIER,
-                    nodeId: createXmlUiTreeNodeId(),
-                    name: nextToken.text,
-                    startToken: nextToken,
-                    endToken: nextToken,
-                };
-                this._lexer.get();
-                this.expectToken(TokenType_1.TokenType.RParent, "W006");
-            }
-            // --- Get catch block
-            catchB = getBlock();
-            endToken = catchB.endToken;
-            if (this._lexer.peek().type === TokenType_1.TokenType.Finally) {
-                // --- Finally after catch
-                this._lexer.get();
-                finallyB = getBlock();
-                endToken = finallyB.endToken;
-            }
-        }
-        else if (nextToken.type === TokenType_1.TokenType.Finally) {
-            // --- Finally found
-            this._lexer.get();
-            finallyB = getBlock();
-            endToken = finallyB.endToken;
-        }
-        else {
-            this.reportError("W013", nextToken);
-            return null;
-        }
-        return this.createStatementNode(ScriptingSourceTree_1.T_TRY_STATEMENT, {
-            tryB,
-            catchB,
-            catchV,
-            finallyB,
-        }, startToken, endToken);
-    }
-    /**
-     * Parses a switch statement
-     *
-     * switchStatement
-     *   : "switch" "(" expression ")" "{" caseClauses "}"
-     *   ;
-     *
-     * caseClauses
-     *   : "case" expression ":" statement*
-     *   | "default" ":" statement*
-     *   ;
-     */
-    parseSwitchStatement() {
-        const startToken = this._lexer.get();
-        // --- Parse the switch expression
-        this.expectToken(TokenType_1.TokenType.LParent, "W014");
-        const expr = this.getExpression();
-        if (!expr)
-            return null;
-        this.expectToken(TokenType_1.TokenType.RParent, "W006");
-        // --- Parse the case blocks
-        this.expectToken(TokenType_1.TokenType.LBrace, "W012");
-        const cases = [];
-        let defaultCaseFound = false;
-        while (true) {
-            let nextToken = this._lexer.peek();
-            let caseE;
-            if (nextToken.type === TokenType_1.TokenType.Case) {
-                // --- Process "case"
-                this._lexer.get();
-                caseE = this.getExpression();
-                if (!caseE)
-                    return null;
-            }
-            else if (nextToken.type === TokenType_1.TokenType.Default) {
-                // --- Process "default"
-                if (defaultCaseFound) {
-                    this.reportError("W016");
-                    return null;
-                }
-                defaultCaseFound = true;
-                this._lexer.get();
-            }
-            else if (nextToken.type === TokenType_1.TokenType.RBrace) {
-                break;
-            }
-            else {
-                this.reportError("W015");
-                return null;
-            }
-            // --- Process label statements
-            this.expectToken(TokenType_1.TokenType.Colon, "W008");
-            let stmts = [];
-            let collected = false;
-            while (!collected) {
-                const stmtToken = this._lexer.peek();
-                switch (stmtToken.type) {
-                    case TokenType_1.TokenType.Case:
-                    case TokenType_1.TokenType.Default:
-                    case TokenType_1.TokenType.RBrace:
-                        // --- No more case to process
-                        collected = true;
-                        break;
-                    default:
-                        // --- Try to get the next statement
-                        const stmt = this.parseStatement();
-                        if (stmt === null) {
-                            collected = true;
-                            break;
-                        }
-                        stmts.push(stmt);
-                        if (stmt.type !== ScriptingSourceTree_1.T_EMPTY_STATEMENT) {
-                            this.skipToken(TokenType_1.TokenType.Semicolon);
-                        }
-                }
-            }
-            cases.push(this.createNode(ScriptingSourceTree_1.T_SWITCH_CASE, {
-                caseE,
-                stmts,
-            }, startToken));
-        }
-        // --- Closing
-        const endToken = this._lexer.peek();
-        this.expectToken(TokenType_1.TokenType.RBrace, "W004");
-        return this.createStatementNode(ScriptingSourceTree_1.T_SWITCH_STATEMENT, {
-            expr,
-            cases,
-        }, startToken, endToken);
-    }
-    /**
-     * Parses a function declaration
-     *
-     * functionDeclaration
-     *   : "function" identifier "(" [parameterList] ")" blockStatement
-     *   ;
-     */
-    parseFunctionDeclaration(allowNoName = false) {
-        var _a;
-        const startToken = this._lexer.get();
-        // --- Get the function name
-        let functionName;
-        const funcId = this._lexer.peek();
-        if (allowNoName) {
-            if (funcId.type !== TokenType_1.TokenType.LParent) {
-                if (funcId.type !== TokenType_1.TokenType.Identifier) {
-                    this.reportError("W003", funcId);
-                    return null;
-                }
-                functionName = funcId.text;
-                this._lexer.get();
-            }
-        }
-        else {
-            if (funcId.type !== TokenType_1.TokenType.Identifier) {
-                this.reportError("W003", funcId);
-                return null;
-            }
-            functionName = funcId.text;
-            this._lexer.get();
-        }
-        // --- Get the parameter list;
-        const nextToken = this._lexer.peek();
-        if (nextToken.type !== TokenType_1.TokenType.LParent) {
-            this.reportError("W014", nextToken);
-            return null;
-        }
-        // --- Now, get the parameter list as an expression
-        const exprList = this.getExpression(true);
-        // --- We turn the expression into a parameter list
-        let isValid;
-        const args = [];
-        switch (exprList.type) {
-            case ScriptingSourceTree_1.T_NO_ARG_EXPRESSION:
-                isValid = true;
-                break;
-            case ScriptingSourceTree_1.T_IDENTIFIER:
-                isValid = ((_a = exprList.parenthesized) !== null && _a !== void 0 ? _a : 0) <= 1;
-                args.push(exprList);
-                break;
-            case ScriptingSourceTree_1.T_SEQUENCE_EXPRESSION:
-                isValid = exprList.parenthesized === 1;
-                let spreadFound = false;
-                if (isValid) {
-                    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 ScriptingSourceTree_1.T_IDENTIFIER:
-                                isValid = !expr.parenthesized;
-                                args.push(expr);
-                                break;
-                            case ScriptingSourceTree_1.T_OBJECT_LITERAL: {
-                                isValid = !expr.parenthesized;
-                                if (isValid) {
-                                    const des = this.convertToObjectDestructure(expr);
-                                    if (des)
-                                        args.push(des);
-                                }
-                                break;
-                            }
-                            case ScriptingSourceTree_1.T_ARRAY_LITERAL: {
-                                isValid = !expr.parenthesized;
-                                if (isValid) {
-                                    const des = this.convertToArrayDestructure(expr);
-                                    if (des)
-                                        args.push(des);
-                                }
-                                break;
-                            }
-                            case ScriptingSourceTree_1.T_SPREAD_EXPRESSION: {
-                                spreadFound = true;
-                                if (expr.expr.type !== ScriptingSourceTree_1.T_IDENTIFIER) {
-                                    isValid = false;
-                                    break;
-                                }
-                                args.push(expr);
-                                break;
-                            }
-                            default:
-                                isValid = false;
-                                break;
-                        }
-                    }
-                }
-                break;
-            case ScriptingSourceTree_1.T_OBJECT_LITERAL:
-                isValid = exprList.parenthesized === 1;
-                if (isValid) {
-                    const des = this.convertToObjectDestructure(exprList);
-                    if (des)
-                        args.push(des);
-                }
-                break;
-            case ScriptingSourceTree_1.T_ARRAY_LITERAL:
-                isValid = exprList.parenthesized === 1;
-                if (isValid) {
-                    const des = this.convertToArrayDestructure(exprList);
-                    if (des)
-                        args.push(des);
-                }
-                break;
-            case ScriptingSourceTree_1.T_SPREAD_EXPRESSION:
-                if (exprList.expr.type !== ScriptingSourceTree_1.T_IDENTIFIER) {
-                    isValid = false;
-                    break;
-                }
-                isValid = true;
-                args.push(exprList);
-                break;
-            default:
-                isValid = false;
-        }
-        if (!isValid) {
-            this.reportError("W010", startToken);
-            return null;
-        }
-        // --- Get the function body (statement block)
-        if (this._lexer.peek().type !== TokenType_1.TokenType.LBrace) {
-            this.reportError("W012", this._lexer.peek());
-            return null;
-        }
-        const stmt = this.parseBlockStatement();
-        if (!stmt)
-            return null;
-        // --- Done.
-        return this.createStatementNode(ScriptingSourceTree_1.T_FUNCTION_DECLARATION, {
-            id: { type: ScriptingSourceTree_1.T_IDENTIFIER, name: functionName },
-            args,
-            stmt,
-        }, startToken, stmt.endToken);
-    }
-    // ==========================================================================
-    // Expression parsing
-    /**
-     * Parses an expression:
-     *
-     * expr
-     *   : sequenceExpr
-     *   ;
-     */
-    parseExpr(allowSequence = true) {
-        return allowSequence
-            ? this.parseSequenceExpression()
-            : this.parseCondOrSpreadOrAsgnOrArrowExpr();
-    }
-    /**
-     * sequenceExpr
-     *   : conditionalExpr ( "," conditionalExpr )?
-     */
-    parseSequenceExpression() {
-        const start = this._lexer.peek();
-        let endToken = start;
-        let leftExpr = this.parseCondOrSpreadOrAsgnOrArrowExpr();
-        if (!leftExpr) {
-            return null;
-        }
-        endToken = leftExpr.endToken;
-        const exprs = [];
-        let loose = false;
-        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();
-                    exprs.push(this.createExpressionNode(ScriptingSourceTree_1.T_NO_ARG_EXPRESSION, {}, endToken, endToken));
-                }
-                else {
-                    const nextExpr = this.parseCondOrSpreadOrAsgnOrArrowExpr();
-                    if (!nextExpr) {
-                        break;
-                    }
-                    endToken = nextExpr.endToken;
-                    exprs.push(nextExpr);
-                }
-            }
-        }
-        if (!exprs.length) {
-            // --- No sequence
-            return leftExpr;
-        }
-        // --- Create the sequence expression
-        leftExpr = this.createExpressionNode(ScriptingSourceTree_1.T_SEQUENCE_EXPRESSION, {
-            exprs,
-            loose,
-        }, start, endToken);
-        // --- Check for "loose" sequence expression
-        if (loose) {
-            leftExpr = this.convertToArrayDestructure(leftExpr);
-        }
-        // --- Done.
-        return leftExpr;
-    }
-    /**
-     * conditionalOrSpreadOrAsgnOrArrowExpr
-     *   : nullCoalescingExpr ( "?" expr ":" expr )?
-     *   | "..." nullCoalescingExpr
-     *   | identifier "=" expr
-     *   ;
-     */
-    parseCondOrSpreadOrAsgnOrArrowExpr() {
-        const startToken = this._lexer.peek();
-        if (startToken.type === TokenType_1.TokenType.Spread) {
-            // --- Spread expression
-            this._lexer.get();
-            const spreadOperand = this.parseNullCoalescingExpr();
-            return spreadOperand
-                ? this.createExpressionNode(ScriptingSourceTree_1.T_SPREAD_EXPRESSION, {
-                    expr: spreadOperand,
-                }, startToken, spreadOperand.endToken)
-                : null;
-        }
-        if (startToken.type === TokenType_1.TokenType.Function) {
-            const funcDecl = this.parseFunctionDeclaration(true);
-            return funcDecl
-                ? this.createExpressionNode(ScriptingSourceTree_1.T_ARROW_EXPRESSION, {
-                    name: funcDecl.id.name,
-                    args: funcDecl.args,
-                    statement: funcDecl.stmt,
-                }, startToken, funcDecl.endToken)
-                : null;
-        }
-        const otherExpr = this.parseNullCoalescingExpr();
-        if (!otherExpr) {
-            return null;
-        }
-        const nextToken = this._lexer.peek();
-        if (nextToken.type === TokenType_1.TokenType.Arrow) {
-            // --- It is an arrow expression
-            return this.parseArrowExpression(startToken, otherExpr);
-        }
-        if (nextToken.type === TokenType_1.TokenType.QuestionMark) {
-            this._lexer.get();
-            // --- Conditional expression
-            const trueExpr = this.getExpression(false);
-            this.expectToken(TokenType_1.TokenType.Colon);
-            const falseExpr = this.getExpression(false);
-            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 expr = this.getExpression();
-            return expr
-                ? this.createExpressionNode(ScriptingSourceTree_1.T_ASSIGNMENT_EXPRESSION, {
-                    leftValue: otherExpr,
-                    op: nextToken.text,
-                    expr,
-                }, startToken, expr.endToken)
-                : null;
-        }
-        return otherExpr;
-    }
-    /**
-     * Parses an arrow expression
-     * @param start Start token
-     * @param left Expression to the left from the arrow
-     */
-    parseArrowExpression(start, left) {
-        var _a;
-        // --- Check the left expression
-        let isValid;
-        const args = [];
-        switch (left.type) {
-            case ScriptingSourceTree_1.T_NO_ARG_EXPRESSION:
-                isValid = true;
-                break;
-            case ScriptingSourceTree_1.T_IDENTIFIER:
-                isValid = ((_a = left.parenthesized) !== null && _a !== void 0 ? _a : 0) <= 1;
-                args.push(left);
-                break;
-            case ScriptingSourceTree_1.T_SEQUENCE_EXPRESSION:
-                isValid = left.parenthesized === 1;
-                let spreadFound = false;
-                if (isValid) {
-                    for (const expr of left.exprs) {
-                        if (spreadFound) {
-                            isValid = false;
-                            break;
-                        }
-                        switch (expr.type) {
-                            case ScriptingSourceTree_1.T_IDENTIFIER:
-                                isValid = !expr.parenthesized;
-                                args.push(expr);
-                                break;
-                            case ScriptingSourceTree_1.T_OBJECT_LITERAL: {
-                                isValid = !expr.parenthesized;
-                                if (isValid) {
-                                    const des = this.convertToObjectDestructure(expr);
-                                    if (des)
-                                        args.push(des);
-                                }
-                                break;
-                            }
-                            case ScriptingSourceTree_1.T_ARRAY_LITERAL: {
-                                isValid = !expr.parenthesized;
-                                if (isValid) {
-                                    const des = this.convertToArrayDestructure(expr);
-                                    if (des)
-                                        args.push(des);
-                                }
-                                break;
-                            }
-                            case ScriptingSourceTree_1.T_SPREAD_EXPRESSION: {
-                                spreadFound = true;
-                                if (expr.expr.type !== ScriptingSourceTree_1.T_IDENTIFIER) {
-                                    isValid = false;
-                                    break;
-                                }
-                                args.push(expr);
-                                break;
-                            }
-                            default:
-                                isValid = false;
-                                break;
-                        }
-                    }
-                }
-                break;
-            case ScriptingSourceTree_1.T_OBJECT_LITERAL:
-                isValid = left.parenthesized === 1;
-                if (isValid) {
-                    const des = this.convertToObjectDestructure(left);
-                    if (des)
-                        args.push(des);
-                }
-                break;
-            case ScriptingSourceTree_1.T_ARRAY_LITERAL:
-                isValid = left.parenthesized === 1;
-                if (isValid) {
-                    const des = this.convertToArrayDestructure(left);
-                    if (des)
-                        args.push(des);
-                }
-                break;
-            case ScriptingSourceTree_1.T_SPREAD_EXPRESSION:
-                isValid = left.expr.type === ScriptingSourceTree_1.T_IDENTIFIER;
-                if (isValid) {
-                    args.push(left);
-                }
-                break;
-            default:
-                isValid = false;
-        }
-        if (!isValid) {
-            this.reportError("W010", start);
-            return null;
-        }
-        // --- Skip the arrow token
-        this._lexer.get();
-        // --- Get arrow expression statements
-        const statement = this.parseStatement(false);
-        return statement
-            ? this.createExpressionNode(ScriptingSourceTree_1.T_ARROW_EXPRESSION, {
-                args,
-                statement,
-            }, start, statement.endToken)
-            : null;
-    }
-    /**
-     * nullCoalescingExpr
-     *   : logicalOrExpr ( "??" logicalOrExpr )?
-     *   ;
-     */
-    parseNullCoalescingExpr() {
-        const startToken = this._lexer.peek();
-        let leftExpr = this.parseLogicalOrExpr();
-        if (!leftExpr) {
-            return null;
-        }
-        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(ScriptingSourceTree_1.T_BINARY_EXPRESSION, {
-                op: "??",
-                left: leftExpr,
-                right: rightExpr,
-            }, startToken, endToken);
-        }
-        return leftExpr;
-    }
-    /**
-     * logicalOrExpr
-     *   : logicalAndExpr ( "||" logicalAndExpr )?
-     *   ;
-     */
-    parseLogicalOrExpr() {
-        const startToken = this._lexer.peek();
-        let leftExpr = this.parseLogicalAndExpr();
-        if (!leftExpr) {
-            return null;
-        }
-        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(ScriptingSourceTree_1.T_BINARY_EXPRESSION, {
-                op: "||",
-                left: leftExpr,
-                right: rightExpr,
-            }, startToken, endToken);
-        }
-        return leftExpr;
-    }
-    /**
-     * logicalAndExpr
-     *   : bitwiseOrExpr ( "&&" bitwiseOrExpr )?
-     *   ;
-     */
-    parseLogicalAndExpr() {
-        const startToken = this._lexer.peek();
-        let leftExpr = this.parseBitwiseOrExpr();
-        if (!leftExpr) {
-            return null;
-        }
-        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(ScriptingSourceTree_1.T_BINARY_EXPRESSION, {
-                op: "&&",
-                left: leftExpr,
-                right: rightExpr,
-            }, startToken, endToken);
-        }
-        return leftExpr;
-    }
-    /**
-     * bitwiseOrExpr
-     *   : bitwiseXorExpr ( "|" bitwiseXorExpr )?
-     *   ;
-     */
-    parseBitwiseOrExpr() {
-        const startToken = this._lexer.peek();
-        let leftExpr = this.parseBitwiseXorExpr();
-        if (!leftExpr) {
-            return null;
-        }
-        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(ScriptingSourceTree_1.T_BINARY_EXPRESSION, {
-                op: "|",
-                left: leftExpr,
-                right: rightExpr,
-            }, startToken, endToken);
-        }
-        return leftExpr;
-    }
-    /**
-     * bitwiseXorExpr
-     *   : bitwiseAndExpr ( "^" bitwiseAndExpr )?
-     *   ;
-     */
-    parseBitwiseXorExpr() {
-        const startToken = this._lexer.peek();
-        let leftExpr = this.parseBitwiseAndExpr();
-        if (!leftExpr) {
-            return null;
-        }
-        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(ScriptingSourceTree_1.T_BINARY_EXPRESSION, {
-                op: "^",
-                left: leftExpr,
-                right: rightExpr,
-            }, startToken, endToken);
-        }
-        return leftExpr;
-    }
-    /**
-     * bitwiseAndExpr
-     *   : equExpr ( "&" equExpr )?
-     *   ;
-     */
-    parseBitwiseAndExpr() {
-        const startToken = this._lexer.peek();
-        let leftExpr = this.parseEquExpr();
-        if (!leftExpr) {
-            return null;
-        }
-        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(ScriptingSourceTree_1.T_BINARY_EXPRESSION, {
-                op: "&",
-                left: leftExpr,
-                right: rightExpr,
-            }, startToken, endToken);
-        }
-        return leftExpr;
-    }
-    /**
-     * equExpr
-     *   : relOrInExpr ( ( "==" | "!=" | "===" | "!==" ) relOrInExpr )?
-     *   ;
-     */
-    parseEquExpr() {
-        const startToken = this._lexer.peek();
-        let leftExpr = this.parseRelOrInExpr();
-        if (!leftExpr) {
-            return null;
-        }
-        let opType;
-        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(ScriptingSourceTree_1.T_BINARY_EXPRESSION, {
-                op: opType.text,
-                left: leftExpr,
-                right: rightExpr,
-            }, startToken, endToken);
-        }
-        return leftExpr;
-    }
-    /**
-     * relOrInExpr
-     *   : shiftExpr ( ( "<" | "<=" | ">" | ">=", "in" ) shiftExpr )?
-     *   ;
-     */
-    parseRelOrInExpr() {
-        const startToken = this._lexer.peek();
-        let leftExpr = this.parseShiftExpr();
-        if (!leftExpr) {
-            return null;
-        }
-        let opType;
-        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(ScriptingSourceTree_1.T_BINARY_EXPRESSION, {
-                op: opType.text,
-                left: leftExpr,
-                right: rightExpr,
-            }, startToken, endToken);
-        }
-        return leftExpr;
-    }
-    /**
-     * shiftExpr
-     *   : addExpr ( ( "<<" | ">>" | ">>>" ) addExpr )?
-     *   ;
-     */
-    parseShiftExpr() {
-        const startToken = this._lexer.peek();
-        let leftExpr = this.parseAddExpr();
-        if (!leftExpr) {
-            return null;
-        }
-        let opType;
-        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(ScriptingSourceTree_1.T_BINARY_EXPRESSION, {
-                op: opType.text,
-                left: leftExpr,
-                right: rightExpr,
-            }, startToken, endToken);
-        }
-        return leftExpr;
-    }
-    /**
-     * addExpr
-     *   : multExpr ( ( "+" | "-" ) multExpr )?
-     *   ;
-     */
-    parseAddExpr() {
-        const startToken = this._lexer.peek();
-        let leftExpr = this.parseMultExpr();
-        if (!leftExpr) {
-            return null;
-        }
-        let opType;
-        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(ScriptingSourceTree_1.T_BINARY_EXPRESSION, {
-                op: opType.text,
-                left: leftExpr,
-                right: rightExpr,
-            }, startToken, endToken);
-        }
-        return leftExpr;
-    }
-    /**
-     * multExpr
-     *   : exponentialExpr ( ( "*" | "/" | "%") exponentialExpr )?
-     *   ;
-     */
-    parseMultExpr() {
-        const startToken = this._lexer.peek();
-        let leftExpr = this.parseExponentialExpr();
-        if (!leftExpr) {
-            return null;
-        }
-        let opType;
-        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(ScriptingSourceTree_1.T_BINARY_EXPRESSION, {
-                op: opType.text,
-                left: leftExpr,
-                right: rightExpr,
-            }, startToken, endToken);
-        }
-        return leftExpr;
-    }
-    /**
-     * exponentialExpr
-     *   : unaryExpr ( "**" unaryExpr )?
-     *   ;
-     */
-    parseExponentialExpr() {
-        const startToken = this._lexer.peek();
-        let leftExpr = this.parseUnaryOrPrefixExpr();
-        if (!leftExpr) {
-            return null;
-        }
-        let opType;
-        let count = 0;
-        while ((opType = this.skipToken(TokenType_1.TokenType.Exponent))) {
-            let rightExpr = this.parseUnaryOrPrefixExpr();
-            if (!rightExpr) {
-                this.reportError("W001");
-                return null;
-            }
-            let endToken = rightExpr.endToken;
-            if (count === 0) {
-                leftExpr = this.createExpressionNode(ScriptingSourceTree_1.T_BINARY_EXPRESSION, {
-                    op: opType.text,
-                    left: leftExpr,
-                    right: rightExpr,
-                }, startToken, endToken);
-            }
-            else {
-                const prevLeft = leftExpr;
-                leftExpr = this.createExpressionNode(ScriptingSourceTree_1.T_BINARY_EXPRESSION, {
-                    op: opType.text,
-                    left: prevLeft.left,
-                    right: {
-                        type: ScriptingSourceTree_1.T_BINARY_EXPRESSION,
-                        op: opType.text,
-                        left: prevLeft.right,
-                        right: rightExpr,
-                    },
-                }, startToken, endToken);
-            }
-            count++;
-        }
-        return leftExpr;
-    }
-    /**
-     * unaryExpr
-     *   : ( "typeof" | "delete" | "+" | "-" | "~" | "!" ) memberOrInvocationExpr
-     *   | memberOrInvocationExpr
-     *   ;
-     */
-    parseUnaryOrPrefixExpr() {
-        const startToken = this._lexer.peek();
-        if (TokenTrait_1.tokenTraits[startToken.type].canBeUnary) {
-            this._lexer.get();
-            const unaryOperand = this.parseUnaryOrPrefixExpr();
-            if (!unaryOperand) {
-                return null;
-            }
-            return this.createExpressionNode(ScriptingSourceTree_1.T_UNARY_EXPRESSION, {
-                op: startToken.text,
-                expr: unaryOperand,
-            }, startToken, unaryOperand.endToken);
-        }
-        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(ScriptingSourceTree_1.T_PREFIX_OP_EXPRESSION, {
-                op: startToken.text,
-                expr: prefixOperand,
-            }, startToken, prefixOperand.endToken);
-        }
-        // --- Not unary or prefix
-        return this.parseMemberOrInvocationExpr();
-    }
-    /**
-     * memberOrInvocationExpr
-     *   : primaryExpr "(" functionArgs ")"
-     *   | primaryExpr "." identifier
-     *   | primaryExpr "?." identifier
-     *   | primaryExpr "[" expr "]"
-     *   ;
-     */
-    parseMemberOrInvocationExpr() {
-        const startToken = this._lexer.peek();
-        let primary = this.parsePrimaryExpr();
-        if (!primary) {
-            return null;
-        }
-        let exitLoop = false;
-        do {
-            const currentStart = this._lexer.peek();
-            switch (currentStart.type) {
-                case TokenType_1.TokenType.LParent: {
-                    this._lexer.get();
-                    let args = [];
-                    if (this._lexer.peek().type !== TokenType_1.TokenType.RParent) {
-                        const expr = this.parseExpr();
-                        if (!expr) {
-                            this.reportError("W001");
-                            return null;
-                        }
-                        args = expr.type === ScriptingSourceTree_1.T_SEQUENCE_EXPRESSION ? expr.exprs : [expr];
-                    }
-                    const endToken = this._lexer.peek();
-                    this.expectToken(TokenType_1.TokenType.RParent, "W006");
-                    primary = this.createExpressionNode(ScriptingSourceTree_1.T_FUNCTION_INVOCATION_EXPRESSION, {
-                        obj: primary,
-                        arguments: args,
-                    }, startToken, endToken);
-                    break;
-                }
-                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];
-                    if (!memberTrait.keywordLike) {
-                        this.reportError("W003");
-                        return null;
-                    }
-                    primary = this.createExpressionNode(ScriptingSourceTree_1.T_MEMBER_ACCESS_EXPRESSION, {
-                        obj: primary,
-                        member: member.text,
-                        opt: currentStart.type === TokenType_1.TokenType.OptionalChaining,
-                    }, startToken, member);
-                    break;
-                case TokenType_1.TokenType.LSquare:
-                    this._lexer.get();
-                    const memberExpr = this.getExpression();
-                    if (!memberExpr) {
-                        return null;
-                    }
-                    const endToken = this._lexer.peek();
-                    this.expectToken(TokenType_1.TokenType.RSquare, "W005");
-                    primary = this.createExpressionNode(ScriptingSourceTree_1.T_CALCULATED_MEMBER_ACCESS_EXPRESSION, {
-                        obj: primary,
-                        member: memberExpr,
-                    }, startToken, endToken);
-                    break;
-                default:
-                    exitLoop = true;
-                    break;
-            }
-        } while (!exitLoop);
-        // --- Check for postfix operators
-        const nextToken = this._lexer.peek();
-        if (nextToken.type === TokenType_1.TokenType.IncOp || nextToken.type === TokenType_1.TokenType.DecOp) {
-            this._lexer.get();
-            return this.createExpressionNode(ScriptingSourceTree_1.T_POSTFIX_OP_EXPRESSION, {
-                op: nextToken.text,
-                expr: primary,
-            }, startToken, nextToken);
-        }
-        return primary;
-    }
-    /**
-     * primaryExpr
-     *   : literal
-     *   | identifier
-     *   | "::" identifier
-     *   | "$item"
-     *   | "(" expr ")"
-     *   ;
-     */
-    parsePrimaryExpr() {
-        var _a;
-        const start = this._lexer.peek();
-        switch (start.type) {
-            case TokenType_1.TokenType.LParent:
-                // --- Parenthesised or no-arg expression
-                this._lexer.get();
-                if (this._lexer.peek().type === TokenType_1.TokenType.RParent) {
-                    // --- No-arg
-                    const endToken = this._lexer.get();
-                    return this.createExpressionNode(ScriptingSourceTree_1.T_NO_ARG_EXPRESSION, {}, start, endToken);
-                }
-                // --- Parenthesized
-                let parenthesizedExpr = this.parseExpr();
-                if (!parenthesizedExpr) {
-                    return null;
-                }
-                const endToken = this._lexer.peek();
-                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(ScriptingSourceTree_1.T_IDENTIFIER, {
-                    name: idToken.text,
-                }, idToken, idToken);
-            }
-            case TokenType_1.TokenType.Global: {
-                this._lexer.get();
-                const idToken = this._lexer.get();
-                if (idToken.type !== TokenType_1.TokenType.Identifier) {
-                    this.reportError("W003");
-                    return null;
-                }
-                return this.createExpressionNode(ScriptingSourceTree_1.T_IDENTIFIER, {
-                    name: idToken.text,
-                    isGlobal: true,
-                }, idToken, idToken);
-            }
-            case TokenType_1.TokenType.Backtick:
-                return this.parseTemplateLiteral();
-            case TokenType_1.TokenType.False:
-            case TokenType_1.TokenType.True:
-                this._lexer.get();
-                return this.createExpressionNode(ScriptingSourceTree_1.T_LITERAL, {
-                    value: start.type === TokenType_1.TokenType.True,
-                }, start, start);
-            case TokenType_1.TokenType.BinaryLiteral:
-                this._lexer.get();
-                return this.parseBinaryLiteral(start);
-            case TokenType_1.TokenType.DecimalLiteral:
-                this._lexer.get();
-                return this.parseDecimalLiteral(start);
-            case TokenType_1.TokenType.HexadecimalLiteral:
-                this._lexer.get();
-                return this.parseHexadecimalLiteral(start);
-            case TokenType_1.TokenType.RealLiteral:
-                this._lexer.get();
-                return this.parseRealLiteral(start);
-            case TokenType_1.TokenType.StringLiteral:
-                this._lexer.get();
-                return this.parseStringLiteral(start);
-            case TokenType_1.TokenType.Infinity:
-                this._lexer.get();
-                return this.createExpressionNode(ScriptingSourceTree_1.T_LITERAL, {
-                    value: Infinity,
-                }, start, start);
-            case TokenType_1.TokenType.NaN:
-                this._lexer.get();
-                return this.createExpressionNode(ScriptingSourceTree_1.T_LITERAL, {
-                    value: NaN,
-                }, start, start);
-            case TokenType_1.TokenType.Null:
-                this._lexer.get();
-                return this.createExpressionNode(ScriptingSourceTree_1.T_LITERAL, {
-                    value: null,
-                }, start, start);
-            case TokenType_1.TokenType.Undefined:
-                this._lexer.get();
-                return this.createExpressionNode(ScriptingSourceTree_1.T_LITERAL, {
-                    value: undefined,
-                }, start, start);
-            case TokenType_1.TokenType.LSquare:
-                return this.parseArrayLiteral();
-            case TokenType_1.TokenType.LBrace:
-                return this.parseObjectLiteral();
-            case TokenType_1.TokenType.Divide:
-                return this.parseRegExpLiteral();
-        }
-        return null;
-    }
-    parseTemplateLiteral() {
-        const startToken = this._lexer.get();
-        this._lexer.setStartingPhaseToTemplateLiteral();
-        const segments = [];
-        loop: while (true) {
-            let nextToken = this._lexer.peek();
-            switch (nextToken.type) {
-                case TokenType_1.TokenType.StringLiteral:
-                    this._lexer.get();
-                    const str = this.parseStringLiteral(nextToken, false);
-                    segments.push(str);
-                    break;
-                case TokenType_1.TokenType.DollarLBrace:
-                    this._lexer.get();
-                    const innerExpr = this.parseExpr();
-                    segments.push(innerExpr);
-                    this.expectToken(TokenType_1.TokenType.RBrace, "W004");
-                    this._lexer.setStartingPhaseToTemplateLiteral();
-                    break;
-                case TokenType_1.TokenType.Backtick:
-                    break loop;
-                default:
-                    this.reportError("W004");
-            }
-        }
-        const endToken = this._lexer.get();
-        return this.createExpressionNode(ScriptingSourceTree_1.T_TEMPLATE_LITERAL_EXPRESSION, { segments }, startToken, endToken);
-    }
-    /**
-     * Parses an array literal
-     */
-    parseArrayLiteral() {
-        const start = this._lexer.get();
-        let expressions = [];
-        if (this._lexer.peek().type !== TokenType_1.TokenType.RSquare) {
-            const expr = this.getExpression();
-            if (expr) {
-                expressions = expr.type === ScriptingSourceTree_1.T_SEQUENCE_EXPRESSION ? expr.exprs : [expr];
-            }
-        }
-        const endToken = this._lexer.peek();
-        this.expectToken(TokenType_1.TokenType.RSquare);
-        return this.createExpressionNode(ScriptingSourceTree_1.T_ARRAY_LITERAL, {
-            items: expressions,
-        }, start, endToken);
-    }
-    /**
-     * Parses an object literal
-     */
-    parseObjectLiteral() {
-        const start = this._lexer.get();
-        let props = [];
-        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 === TokenType_1.TokenType.LSquare) {
-                        this._lexer.get();
-                        nameExpr = this.getExpression();
-                        if (!nameExpr) {
-                            return null;
-                        }
-                        this.expectToken(TokenType_1.TokenType.RSquare, "W005");
-                        nameExpr = this.createExpressionNode(ScriptingSourceTree_1.T_SEQUENCE_EXPRESSION, {
-                            exprs: [nameExpr],
-                        }, start);
-                    }
-                    else if (traits.isPropLiteral) {
-                        nameExpr = this.getExpression(false);
-                        if (!nameExpr) {
-                            return null;
-                        }
-                        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;
-                        }
-                    }
-                    else {
-                        this.reportError("W007");
-                        return null;
-                    }
-                }
-                else if (traits.keywordLike) {
-                    nameExpr = {
-                        type: ScriptingSourceTree_1.T_IDENTIFIER,
-                        nodeId: createXmlUiTreeNodeId(),
-                        name: nextToken.text,
-                        startToken: nextToken,
-                        endToken: nextToken,
-                    };
-                    this._lexer.get();
-                }
-                else {
-                    this.reportError("W001");
-                    return null;
-                }
-                const nameType = nameExpr.type;
-                if (nameType === ScriptingSourceTree_1.T_SPREAD_EXPRESSION) {
-                    props.push(nameExpr);
-                }
-                else {
-                    if (nameType === ScriptingSourceTree_1.T_LITERAL) {
-                        const val = nameExpr.value;
-                        if (typeof val !== "number" && typeof val !== "string") {
-                            this.expectToken(TokenType_1.TokenType.RBrace, "W007");
-                            return null;
-                        }
-                    }
-                    // --- Value is optional, when we have a name
-                    let valueExpr = null;
-                    if (nameType === ScriptingSourceTree_1.T_IDENTIFIER) {
-                        const nameFollowerToken = this._lexer.peek();
-                        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(TokenType_1.TokenType.Colon, "W008");
-                        valueExpr = this.getExpression(false);
-                        if (!valueExpr) {
-                            return null;
-                        }
-                    }
-                    props.push([nameExpr, valueExpr]);
-                }
-                // --- Test property termination
-                const next = this._lexer.peek().type;
-                if (next === TokenType_1.TokenType.Comma) {
-                    this._lexer.get();
-                }
-                else {
-                    if (next !== TokenType_1.TokenType.RBrace) {
-                        break;
-                    }
-                }
-            }
-        }
-        const endToken = this._lexer.peek();
-        this.expectToken(TokenType_1.TokenType.RBrace, "W004");
-        return this.createExpressionNode(ScriptingSourceTree_1.T_OBJECT_LITERAL, {
-            props,
-        }, start, endToken);
-    }
-    parseRegExpLiteral() {
-        var _a;
-        const startToken = this._lexer.peek();
-        const result = this._lexer.getRegEx();
-        if (result.success) {
-            return this.createExpressionNode(ScriptingSourceTree_1.T_LITERAL, {
-                value: new RegExp(result.pattern, result.flags),
-            }, startToken, this._lexer.peek());
-        }
-        this.reportError("W002", startToken, (_a = result.pattern) !== null && _a !== void 0 ? _a : "");
-        return null;
-    }
-    /**
-     * Gets an expression
-     */
-    getExpression(allowSequence = true) {
-        const expr = this.parseExpr(allowSequence);
-        if (expr) {
-            return expr;
-        }
-        this.reportError("W001");
-        return null;
-    }
-    // ==========================================================================
-    // Helpers
-    /**
-     * Tests the type of the next token
-     * @param type Expected token type
-     * @param errorCode Error to raise if the next token is not expected
-     * @param allowEof Allow an EOF instead of the expected token?
-     */
-    expectToken(type, errorCode, allowEof) {
-        const next = this._lexer.peek();
-        if (next.type === type || (allowEof && next.type === TokenType_1.TokenType.Eof)) {
-            // --- Skip the expected token
-            return this._lexer.get();
-        }
-        this.reportError(errorCode !== null && errorCode !== void 0 ? errorCode : "W002", next, next.text);
-        return null;
-    }
-    /**
-     * Skips the next token if the type is the specified one
-     * @param type Token type to check
-     */
-    skipToken(type) {
-        const next = this._lexer.peek();
-        if (next.type === type) {
-            this._lexer.get();
-            return next;
-        }
-        return null;
-    }
-    /**
-     * Skips the next token if the type is the specified one
-     * @param types Token types to check
-     */
-    skipTokens(...types) {
-        const next = this._lexer.peek();
-        for (const type of types) {
-            if (next.type === type) {
-                this._lexer.get();
-                return next;
-            }
-        }
-        return null;
-    }
-    /**
-     * Reports the specified error
-     * @param errorCode Error code
-     * @param token Token that represents the error's position
-     * @param options Error message options
-     */
-    reportError(errorCode, token, ...options) {
-        var _a;
-        let errorText = (_a = ParserError_1.errorMessages[errorCode]) !== null && _a !== void 0 ? _a : "Unkonwn error";
-        if (options) {
-            options.forEach((o, idx) => (errorText = replace(errorText, `{${idx}}`, options[idx].toString())));
-        }
-        if (!token) {
-            token = this._lexer.peek();
-        }
-        this._parseErrors.push({
-            code: errorCode,
-            text: errorText,
-            line: token.startLine,
-            column: token.startColumn,
-        });
-        throw new ParserError_1.ParserError(errorText, errorCode);
-        function replace(input, placeholder, replacement) {
-            do {
-                input = input.replace(placeholder, replacement);
-            } while (input.includes(placeholder));
-            return input;
-        }
-    }
-    /**
-     * Creates an expression node
-     * @param type Expression type
-     * @param stump Stump properties
-     * @param startToken The token that starts the expression
-     * @param endToken The token that ends the expression
-     * @param source Expression source code to store to the node
-     */
-    createNode(type, stump, startToken, endToken) {
-        if (!endToken) {
-            endToken = this._lexer.peek();
-        }
-        return Object.assign({}, stump, {
-            type,
-            startToken,
-            endToken,
-        });
-    }
-    /**
-     * Creates an expression node
-     * @param type Expression type
-     * @param stump Stump properties
-     * @param startToken The token that starts the expression
-     * @param endToken The token that ends the expression
-     * @param source Expression source code to store to the node
-     */
-    createExpressionNode(type, stump = {}, startToken, endToken) {
-        if (!endToken) {
-            endToken = this._lexer.peek();
-        }
-        if (!startToken) {
-            startToken = endToken;
-        }
-        return Object.assign({}, stump, {
-            type,
-            nodeId: createXmlUiTreeNodeId(),
-            startToken,
-            endToken,
-        });
-    }
-    /**
-     * Creates a statement node
-     * @param type Statement type
-     * @param stump Stump properties
-     * @param startToken The token that starts the statement
-     * @param endToken The token that ends the statement
-     */
-    createStatementNode(type, stump, startToken, endToken) {
-        return Object.assign({}, stump, {
-            type,
-            nodeId: createXmlUiTreeNodeId(),
-            startToken,
-            endToken,
-        });
-    }
-    /**
-     * Parses a binary literal
-     * @param token Literal token
-     */
-    parseBinaryLiteral(token) {
-        let value;
-        const bigValue = BigInt(token.text.replace(/[_']/g, ""));
-        if (bigValue < Number.MIN_SAFE_INTEGER || bigValue > Number.MAX_SAFE_INTEGER) {
-            value = bigValue;
-        }
-        else {
-            value = parseInt(token.text.substring(2).replace(/[_']/g, ""), 2);
-        }
-        return this.createExpressionNode(ScriptingSourceTree_1.T_LITERAL, {
-            value,
-        }, token, token);
-    }
-    /**
-     * Parses a decimal literal
-     * @param token Literal token
-     */
-    parseDecimalLiteral(token) {
-        let value;
-        const bigValue = BigInt(token.text.replace(/[_']/g, ""));
-        if (bigValue < Number.MIN_SAFE_INTEGER || bigValue > Number.MAX_SAFE_INTEGER) {
-            value = bigValue;
-        }
-        else {
-            value = parseInt(token.text.replace(/[_']/g, ""), 10);
-        }
-        return this.createExpressionNode(ScriptingSourceTree_1.T_LITERAL, {
-            value,
-        }, token, token);
-    }
-    /**
-     * Parses a hexadecimal literal
-     * @param token Literal token
-     */
-    parseHexadecimalLiteral(token) {
-        let value;
-        const bigValue = BigInt(token.text.replace(/[_']/g, ""));
-        if (bigValue < Number.MIN_SAFE_INTEGER || bigValue > Number.MAX_SAFE_INTEGER) {
-            value = bigValue;
-        }
-        else {
-            value = parseInt(token.text.substring(2).replace(/[_']/g, ""), 16);
-        }
-        return this.createExpressionNode(ScriptingSourceTree_1.T_LITERAL, {
-            value,
-        }, token, token);
-    }
-    /**
-     * Parses a real literal
-     * @param token Literal token
-     */
-    parseRealLiteral(token) {
-        let value = parseFloat(token.text.replace(/[_']/g, ""));
-        return this.createExpressionNode(ScriptingSourceTree_1.T_LITERAL, {
-            value,
-        }, token, token);
-    }
-    /**
-     * Converts a string token to intrinsic string
-     * @param token Literal token
-     */
-    parseStringLiteral(token, quoteSurrounded = true) {
-        let input = token.text;
-        if (quoteSurrounded) {
-            input = token.text.length < 2 ? "" : input.substring(1, input.length - 1);
-        }
-        let result = "";
-        let state = StrParseState.Normal;
-        let collect = 0;
-        for (const ch of input) {
-            switch (state) {
-                case StrParseState.Normal:
-                    if (ch === "\\") {
-                        state = StrParseState.Backslash;
-                    }
-                    else {
-                        result += ch;
-                    }
-                    break;
-                case StrParseState.Backslash:
-                    state = StrParseState.Normal;
-                    switch (ch) {
-                        case "b":
-                            result += "\b";
-                            break;
-                        case "f":
-                            result += "\f";
-                            break;
-                        case "n":
-                            result += "\n";
-                            break;
-                        case "r":
-                            result += "\r";
-                            break;
-                        case "t":
-                            result += "\t";
-                            break;
-                        case "v":
-                            result += "\v";
-                            break;
-                        case "S":
-                            result += "\xa0";
-                            break;
-                        case "0":
-                            result += String.fromCharCode(0x00);
-                            break;
-                        case "'":
-                            result += "'";
-                            break;
-                        case '"':
-                            result += '"';
-                            break;
-                        case "\\":
-                            result += "\\";
-                            break;
-                        case "x":
-                            state = StrParseState.X;
-                            break;
-                        case "u":
-                            state = StrParseState.UX1;
-                            break;
-                        default:
-                            result += ch;
-                            break;
-                    }
-                    break;
-                case StrParseState.X:
-                    if (isHexaDecimal(ch)) {
-                        collect = parseInt(ch, 16);
-                        state = StrParseState.Xh;
-                    }
-                    else {
-                        result += "x";
-                        state = StrParseState.Normal;
-                    }
-                    break;
-                case StrParseState.Xh:
-                    if (isHexaDecimal(ch)) {
-                        collect = collect * 0x10 + parseInt(ch, 16);
-                        result += String.fromCharCode(collect);
-                        state = StrParseState.Normal;
-                    }
-                    else {
-                        result += String.fromCharCode(collect);
-                        result += ch;
-                        state = StrParseState.Normal;
-                    }
-                    break;
-                case StrParseState.UX1:
-                    if (ch === "{") {
-                        state = StrParseState.Ucp1;
-                        break;
-                    }
-                    if (isHexaDecimal(ch)) {
-                        collect = parseInt(ch, 16);
-                        state = StrParseState.UX2;
-                    }
-                    else {
-                        result += "x";
-                        state = StrParseState.Normal;
-                    }
-                    break;
-                case StrParseState.UX2:
-                    if (isHexaDecimal(ch)) {
-                        collect = collect * 0x10 + parseInt(ch, 16);
-                        state = StrParseState.UX3;
-                    }
-                    else {
-                        result += String.fromCharCode(collect);
-                        result += ch;
-                        state = StrParseState.Normal;
-                    }
-                    break;
-                case StrParseState.UX3:
-                    if (isHexaDecimal(ch)) {
-                        collect = collect * 0x10 + parseInt(ch, 16);
-                        state = StrParseState.UX4;
-                    }
-                    else {
-                        result += String.fromCharCode(collect);
-                        result += ch;
-                        state = StrParseState.Normal;
-                    }
-                    break;
-                case StrParseState.UX4:
-                    if (isHexaDecimal(ch)) {
-                        collect = collect * 0x10 + parseInt(ch, 16);
-                        result += String.fromCharCode(collect);
-                        state = StrParseState.Normal;
-                    }
-                    else {
-                        result += String.fromCharCode(collect);
-                        result += ch;
-                        state = StrParseState.Normal;
-                    }
-                    break;
-                case StrParseState.Ucp1:
-                    if (isHexaDecimal(ch)) {
-                        collect = parseInt(ch, 16);
-                        state = StrParseState.Ucp2;
-                    }
-                    else {
-                        result += "x";
-                        state = StrParseState.Normal;
-                    }
-                    break;
-                case StrParseState.Ucp2:
-                    if (isHexaDecimal(ch)) {
-                        collect = collect * 0x10 + parseInt(ch, 16);
-                        state = StrParseState.Ucp3;
-                    }
-                    else {
-                        result += String.fromCharCode(collect);
-                        result += ch;
-                        state = StrParseState.Normal;
-                    }
-                    break;
-                case StrParseState.Ucp3:
-                    if (isHexaDecimal(ch)) {
-                        collect = collect * 0x10 + parseInt(ch, 16);
-                        state = StrParseState.Ucp4;
-                    }
-                    else {
-                        result += String.fromCharCode(collect);
-                        result += ch;
-                        state = StrParseState.Normal;
-                    }
-                    break;
-                case StrParseState.Ucp4:
-                    if (isHexaDecimal(ch)) {
-                        collect = collect * 0x10 + parseInt(ch, 16);
-                        state = StrParseState.Ucp5;
-                    }
-                    else {
-                        result += String.fromCharCode(collect);
-                        result += ch;
-                        state = StrParseState.Normal;
-                    }
-                    break;
-                case StrParseState.Ucp5:
-                    if (isHexaDecimal(ch)) {
-                        collect = collect * 0x10 + parseInt(ch, 16);
-                        state = StrParseState.Ucp6;
-                    }
-                    else {
-                        result += String.fromCharCode(collect);
-                        result += ch;
-                        state = StrParseState.Normal;
-                    }
-                    break;
-                case StrParseState.Ucp6:
-                    if (isHexaDecimal(ch)) {
-                        collect = collect * 0x10 + parseInt(ch, 16);
-                        state = StrParseState.UcpTail;
-                    }
-                    else {
-                        result += String.fromCharCode(collect);
-                        result += ch;
-                        state = StrParseState.Normal;
-                    }
-                    break;
-                case StrParseState.UcpTail:
-                    result += String.fromCharCode(collect);
-                    if (ch !== "}") {
-                        result += ch;
-                    }
-                    state = StrParseState.Normal;
-                    break;
-            }
-        }
-        // --- Handle the final machine state
-        switch (state) {
-            case StrParseState.Backslash:
-                result += "\\";
-                break;
-            case StrParseState.X:
-                result += "x";
-                break;
-            case StrParseState.Xh:
-                result += String.fromCharCode(collect);
-                break;
-        }
-        // --- Done
-        return this.createExpressionNode(ScriptingSourceTree_1.T_LITERAL, {
-            value: result,
-        }, token, token);
-        function isHexaDecimal(ch) {
-            return (ch >= "0" && ch <= "9") || (ch >= "a" && ch <= "f") || (ch >= "A" && ch <= "F");
-        }
-    }
-    convertToArrayDestructure(seq) {
-        var _a;
-        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 ScriptingSourceTree_1.T_NO_ARG_EXPRESSION:
-                    arrayD = this.createExpressionNode(ScriptingSourceTree_1.T_ARRAY_DESTRUCTURE, {}, item.startToken, item.endToken);
-                    break;
-                case ScriptingSourceTree_1.T_IDENTIFIER:
-                    arrayD = this.createExpressionNode(ScriptingSourceTree_1.T_ARRAY_DESTRUCTURE, { id: item.name }, item.startToken, item.endToken);
-                    break;
-                case ScriptingSourceTree_1.T_DESTRUCTURE:
-                    result.aDestr.push(...item.aDestr);
-                    break;
-                case ScriptingSourceTree_1.T_ARRAY_DESTRUCTURE:
-                    arrayD = item;
-                    break;
-                case ScriptingSourceTree_1.T_ARRAY_LITERAL: {
-                    const destructure = this.convertToArrayDestructure(item);
-                    if (destructure) {
-                        arrayD = this.createExpressionNode(ScriptingSourceTree_1.T_ARRAY_DESTRUCTURE, {
-                            aDestr: destructure.aDestr,
-                        }, item.startToken, item.endToken);
-                    }
-                    break;
-                }
-                case ScriptingSourceTree_1.T_OBJECT_DESTRUCTURE:
-                    arrayD = this.createExpressionNode(ScriptingSourceTree_1.T_ARRAY_DESTRUCTURE, {
-                        oDestr: item,
-                    }, item.startToken, item.endToken);
-                    break;
-                case ScriptingSourceTree_1.T_OBJECT_LITERAL: {
-                    const destructure = this.convertToObjectDestructure(item);
-                    if (destructure) {
-                        arrayD = this.createExpressionNode(ScriptingSourceTree_1.T_ARRAY_DESTRUCTURE, {
-                            oDestr: destructure.oDestr,
-                        }, item.startToken, item.endToken);
-                    }
-                    break;
-                }
-                default:
-                    this.reportError("W017");
-                    return null;
-            }
-            if (arrayD)
-                (_a = result.aDestr) === null || _a === void 0 ? void 0 : _a.push(arrayD);
-        }
-        // --- Done.
-        return result;
-    }
-    convertToObjectDestructure(objLit) {
-        var _a;
-        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 {
-                reportError("W018");
-                return null;
-            }
-            const [propKey, propValue] = prop;
-            if (propKey.type !== ScriptingSourceTree_1.T_IDENTIFIER) {
-                reportError("W018");
-                return null;
-            }
-            let objD;
-            switch (propValue.type) {
-                case ScriptingSourceTree_1.T_IDENTIFIER:
-                    if (propValue.name === propKey.name) {
-                        objD = this.createExpressionNode(ScriptingSourceTree_1.T_OBJECT_DESTRUCTURE, { id: propKey.name }, propValue.startToken, propValue.endToken);
-                    }
-                    else {
-                        objD = this.createExpressionNode(ScriptingSourceTree_1.T_OBJECT_DESTRUCTURE, {
-                            id: propKey.name,
-                            alias: propValue.name,
-                        }, propValue.startToken, propValue.endToken);
-                    }
-                    break;
-                case ScriptingSourceTree_1.T_ARRAY_DESTRUCTURE: {
-                    objD = this.createExpressionNode(ScriptingSourceTree_1.T_OBJECT_DESTRUCTURE, {
-                        id: propKey.name,
-                        aDestr: propValue,
-                    }, propKey.startToken, propValue.endToken);
-                    break;
-                }
-                case ScriptingSourceTree_1.T_ARRAY_LITERAL: {
-                    const destructure = this.convertToArrayDestructure(propValue);
-                    if (destructure) {
-                        objD = this.createExpressionNode(ScriptingSourceTree_1.T_OBJECT_DESTRUCTURE, {
-                            id: propKey.name,
-                            aDestr: destructure.aDestr,
-                        }, propKey.startToken, propValue.endToken);
-                    }
-                    break;
-                }
-                case ScriptingSourceTree_1.T_OBJECT_DESTRUCTURE:
-                    objD = propValue;
-                    break;
-                case ScriptingSourceTree_1.T_OBJECT_LITERAL: {
-                    const destructure = this.convertToObjectDestructure(propValue);
-                    if (destructure) {
-                        objD = this.createExpressionNode(ScriptingSourceTree_1.T_OBJECT_DESTRUCTURE, {
-                            id: propKey.name,
-                            oDestr: destructure.oDestr,
-                        }, propKey.startToken, propValue.endToken);
-                    }
-                    break;
-                }
-                default:
-                    this.reportError("W018");
-                    return null;
-            }
-            if (objD)
-                (_a = result.oDestr) === null || _a === void 0 ? void 0 : _a.push(objD);
-        }
-        // --- Done.
-        return result;
-    }
-    /**
-     * Tests if the specified token can be the start of an expression
-     */
-    isExpressionStart(token) {
-        var _a, _b;
-        return (_b = (_a = TokenTrait_1.tokenTraits[token.type]) === null || _a === void 0 ? void 0 : _a.expressionStart) !== null && _b !== void 0 ? _b : false;
-    }
-}
-exports.Parser = Parser;