xmlui 0.4.0

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

@@ -0,0 +1,2647 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+const Token_1 = require("../../abstractions/scripting/Token");
+const InputStream_1 = require("./InputStream");
+const TokenTrait_1 = require("./TokenTrait");
+const Lexer_1 = require("./Lexer");
+const ParserError_1 = require("./ParserError");
+/**
+ * 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 = {}));
+/**
+ * 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) {
+        this.source = source;
+        // --- Keep track of error messages
+        this._parseErrors = [];
+        // --- Indicates the parsing level
+        this._statementLevel = 0;
+        this._lexer = new Lexer_1.Lexer(new InputStream_1.InputStream(source));
+    }
+    /**
+     * 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 === Token_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 !== "EmptyS") {
+                this.skipToken(Token_1.TokenType.Semicolon);
+            }
+        }
+        return statements;
+    }
+    /**
+     * Parses a single statement
+     */
+    parseStatement(allowSequence = true) {
+        this._statementLevel++;
+        try {
+            const startToken = this._lexer.peek();
+            switch (startToken.type) {
+                case Token_1.TokenType.Semicolon:
+                    return this.parseEmptyStatement();
+                case Token_1.TokenType.Let:
+                    return this.parseLetStatement();
+                case Token_1.TokenType.Const:
+                    return this.parseConstStatement();
+                case Token_1.TokenType.Var:
+                    return this.parseVarStatement();
+                case Token_1.TokenType.LBrace:
+                    return this.parseBlockStatement();
+                case Token_1.TokenType.If:
+                    return this.parseIfStatement();
+                case Token_1.TokenType.Do:
+                    return this.parseDoWhileStatement();
+                case Token_1.TokenType.While:
+                    return this.parseWhileStatement();
+                case Token_1.TokenType.Return:
+                    return this.parseReturnStatement();
+                case Token_1.TokenType.Break:
+                    this._lexer.get();
+                    return this.createStatementNode("BrkS", {}, startToken, startToken);
+                case Token_1.TokenType.Continue:
+                    this._lexer.get();
+                    return this.createStatementNode("ContS", {}, startToken, startToken);
+                case Token_1.TokenType.For:
+                    return this.parseForStatement();
+                case Token_1.TokenType.Throw:
+                    return this.parseThrowStatement();
+                case Token_1.TokenType.Try:
+                    return this.parseTryStatement();
+                case Token_1.TokenType.Switch:
+                    return this.parseSwitchStatement();
+                case Token_1.TokenType.Function:
+                    return this.parseFunctionDeclaration();
+                case Token_1.TokenType.Export:
+                    return this.parseExport();
+                case Token_1.TokenType.Import:
+                    return this.parseImport();
+                default:
+                    if (startToken.type === Token_1.TokenType.Eof) {
+                        this.reportError("W002", startToken, "EOF");
+                        return null;
+                    }
+                    if (this.isExpressionStart(startToken)) {
+                        return this.parseExpressionStatement(allowSequence);
+                    }
+                    this.reportError("W002", startToken, startToken.text);
+                    return null;
+            }
+        }
+        finally {
+            this._statementLevel--;
+        }
+    }
+    /**
+     * Parses an empty statement
+     *
+     * emptyStatement
+     *   : ";"
+     *   ;
+     */
+    parseEmptyStatement() {
+        const startToken = this._lexer.get();
+        return this.createStatementNode("EmptyS", {}, startToken, startToken);
+    }
+    /**
+     * Parses an expression statement
+     *
+     * expressionStatement
+     *   : expression
+     *   ;
+     */
+    parseExpressionStatement(allowSequence = true) {
+        const startToken = this._lexer.peek();
+        const expression = this.getExpression(allowSequence);
+        return expression
+            ? this.createStatementNode("ExprS", {
+                expression,
+            }, startToken, expression.endToken)
+            : null;
+    }
+    /**
+     * Parses a let statement
+     *
+     * letStatement
+     *   : "let" id ["=" expression] ("," id ["=" expression])*
+     *   ;
+     */
+    parseLetStatement() {
+        const startToken = this._lexer.get();
+        let endToken = startToken;
+        const declarations = [];
+        while (true) {
+            const declStart = this._lexer.peek();
+            let declarationProps = {};
+            if (declStart.type === Token_1.TokenType.LBrace) {
+                // --- This is object destructure
+                endToken = this._lexer.ahead(1);
+                const objectDestruct = this.parseObjectDestructure();
+                if (objectDestruct === null)
+                    return null;
+                declarationProps = {
+                    objectDestruct,
+                };
+                endToken = objectDestruct.length > 0 ? objectDestruct[objectDestruct.length - 1].endToken : endToken;
+            }
+            else if (declStart.type === Token_1.TokenType.LSquare) {
+                // --- This is array destructure
+                endToken = this._lexer.ahead(1);
+                const arrayDestruct = this.parseArrayDestructure();
+                if (arrayDestruct === null)
+                    return null;
+                declarationProps = {
+                    arrayDestruct,
+                };
+                endToken = arrayDestruct.length > 0 ? arrayDestruct[arrayDestruct.length - 1].endToken : endToken;
+            }
+            else if (declStart.type === Token_1.TokenType.Identifier) {
+                endToken = this._lexer.get();
+                declarationProps = {
+                    id: declStart.text,
+                };
+            }
+            else {
+                this.reportError("W003");
+                return null;
+            }
+            // --- Optional initialization
+            const initToken = this._lexer.peek();
+            let expression = null;
+            if (initToken.type === Token_1.TokenType.Assignment) {
+                this._lexer.get();
+                expression = this.getExpression(false);
+                if (expression === null)
+                    return null;
+                declarationProps.expression = expression;
+                endToken = expression.endToken;
+            }
+            else if (declarationProps.arrayDestruct || declarationProps.objectDestruct) {
+                this.reportError("W009", initToken);
+                return null;
+            }
+            // --- New declaration reached
+            declarations.push(this.createExpressionNode("VarD", declarationProps, declStart, endToken));
+            // --- Check for more declarations
+            if (this._lexer.peek().type !== Token_1.TokenType.Comma)
+                break;
+            this._lexer.get();
+        }
+        // --- Done
+        return this.createStatementNode("LetS", {
+            declarations,
+        }, startToken, endToken);
+    }
+    /**
+     * Parses a const statement
+     *
+     * constStatement
+     *   : "const" id "=" expression
+     *   ;
+     */
+    parseConstStatement() {
+        const startToken = this._lexer.get();
+        let endToken = startToken;
+        const declarations = [];
+        while (true) {
+            const declStart = this._lexer.peek();
+            let declarationProps = {};
+            if (declStart.type === Token_1.TokenType.LBrace) {
+                // --- This is object destructure
+                endToken = this._lexer.ahead(1);
+                const objectDestruct = this.parseObjectDestructure();
+                if (objectDestruct === null)
+                    return null;
+                declarationProps = {
+                    objectDestruct,
+                };
+                endToken = objectDestruct.length > 0 ? objectDestruct[objectDestruct.length - 1].endToken : endToken;
+            }
+            else if (declStart.type === Token_1.TokenType.LSquare) {
+                // --- This is array destructure
+                endToken = this._lexer.ahead(1);
+                const arrayDestruct = this.parseArrayDestructure();
+                if (arrayDestruct === null)
+                    return null;
+                declarationProps = {
+                    arrayDestruct,
+                };
+                endToken = arrayDestruct.length > 0 ? arrayDestruct[arrayDestruct.length - 1].endToken : endToken;
+            }
+            else if (declStart.type === Token_1.TokenType.Identifier) {
+                endToken = this._lexer.get();
+                declarationProps = {
+                    id: declStart.text,
+                };
+            }
+            else {
+                this.reportError("W003");
+                return null;
+            }
+            this.expectToken(Token_1.TokenType.Assignment);
+            const expression = this.getExpression(false);
+            if (expression === null)
+                return null;
+            declarationProps.expression = expression;
+            endToken = expression.endToken;
+            // --- New declaration reached
+            declarations.push(this.createExpressionNode("VarD", declarationProps, declStart, endToken));
+            // --- Check for more declarations
+            if (this._lexer.peek().type !== Token_1.TokenType.Comma)
+                break;
+            this._lexer.get();
+        }
+        // --- Done
+        return this.createStatementNode("ConstS", {
+            declarations,
+        }, startToken, endToken);
+    }
+    /**
+     * Parses a const statement
+     *
+     * constStatement
+     *   : "var" id "=" expression
+     *   ;
+     */
+    parseVarStatement() {
+        const startToken = this._lexer.get();
+        let endToken = startToken;
+        const declarations = [];
+        while (true) {
+            const declStart = this._lexer.peek();
+            let declarationProps = {};
+            if (declStart.type === Token_1.TokenType.Identifier) {
+                endToken = this._lexer.get();
+                declarationProps = {
+                    id: declStart.text,
+                };
+            }
+            else {
+                this.reportError("W003");
+                return null;
+            }
+            // --- Mandatory initialization
+            this.expectToken(Token_1.TokenType.Assignment);
+            const expression = this.getExpression(false);
+            if (expression === null)
+                return null;
+            declarationProps.expression = expression;
+            endToken = expression.endToken;
+            // --- New declaration reached
+            declarations.push(this.createExpressionNode("RVarD", declarationProps, declStart, endToken));
+            // --- Check for more declarations
+            if (this._lexer.peek().type !== Token_1.TokenType.Comma)
+                break;
+            this._lexer.get();
+        }
+        // --- Done
+        return this.createStatementNode("VarS", {
+            declarations,
+        }, 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 === Token_1.TokenType.Identifier) {
+            // --- Obtain the ID
+            const id = nextToken.text;
+            let alias;
+            let arrayDestruct;
+            let objectDestruct;
+            this._lexer.get();
+            nextToken = this._lexer.peek();
+            if (nextToken.type === Token_1.TokenType.Colon) {
+                // --- Check the available cases
+                this._lexer.get();
+                nextToken = this._lexer.peek();
+                if (nextToken.type === Token_1.TokenType.Identifier) {
+                    alias = nextToken.text;
+                    endToken = nextToken;
+                    this._lexer.get();
+                }
+                else if (nextToken.type === Token_1.TokenType.LSquare) {
+                    arrayDestruct = this.parseArrayDestructure();
+                    if (arrayDestruct === null)
+                        return null;
+                    endToken = arrayDestruct[arrayDestruct.length - 1].endToken;
+                }
+                else if (nextToken.type === Token_1.TokenType.LBrace) {
+                    objectDestruct = this.parseObjectDestructure();
+                    if (objectDestruct === null)
+                        return null;
+                    endToken = objectDestruct[objectDestruct.length - 1].endToken;
+                }
+            }
+            // --- Check for next segment
+            nextToken = this._lexer.peek();
+            if (nextToken.type === Token_1.TokenType.Comma || nextToken.type === Token_1.TokenType.RBrace) {
+                result.push(this.createExpressionNode("ODestr", { id, alias, arrayDestruct, objectDestruct }, startToken, endToken));
+                if (nextToken.type === Token_1.TokenType.Comma) {
+                    // --- Skip the delimiter comma
+                    this._lexer.get();
+                    nextToken = this._lexer.peek();
+                }
+            }
+        }
+        // --- Expect a closing right brace
+        this.expectToken(Token_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 arrayDestruct;
+            let objectDestruct;
+            if (nextToken.type === Token_1.TokenType.Identifier) {
+                id = nextToken.text;
+                endToken = nextToken;
+                nextToken = this._lexer.get();
+            }
+            else if (nextToken.type === Token_1.TokenType.LSquare) {
+                arrayDestruct = this.parseArrayDestructure();
+                if (arrayDestruct === null)
+                    return null;
+                endToken = arrayDestruct[arrayDestruct.length - 1].endToken;
+            }
+            else if (nextToken.type === Token_1.TokenType.LBrace) {
+                objectDestruct = this.parseObjectDestructure();
+                if (objectDestruct === null)
+                    return null;
+                endToken = objectDestruct[objectDestruct.length - 1].endToken;
+            }
+            nextToken = this._lexer.peek();
+            if (nextToken.type === Token_1.TokenType.Comma) {
+                // --- Store the segment
+                result.push(this.createExpressionNode("ADestr", { id, arrayDestruct, objectDestruct }, startToken, endToken));
+                this._lexer.get();
+            }
+            else if (nextToken.type === Token_1.TokenType.RSquare) {
+                if (id || arrayDestruct || objectDestruct) {
+                    // --- Store a non-empty the segment
+                    result.push(this.createExpressionNode("ADestr", { id, arrayDestruct, objectDestruct }, startToken, endToken));
+                }
+                break;
+            }
+            else {
+                this.reportError("W002", nextToken);
+                return null;
+            }
+        } while (true);
+        // --- Expect a closing right square
+        this.expectToken(Token_1.TokenType.RSquare, "W005");
+        return result;
+    }
+    /**
+     * Parses a block statement
+     *
+     * blockStatement
+     *   : "{" (statement [";"])* "}"
+     *   ;
+     */
+    parseBlockStatement() {
+        const startToken = this._lexer.get();
+        const statements = [];
+        while (this._lexer.peek().type !== Token_1.TokenType.RBrace) {
+            const statement = this.parseStatement();
+            if (!statement)
+                return null;
+            statements.push(statement);
+            if (statement.type !== "EmptyS") {
+                this.skipToken(Token_1.TokenType.Semicolon);
+            }
+        }
+        const endToken = this._lexer.get();
+        return this.createStatementNode("BlockS", { statements }, startToken, endToken);
+    }
+    /**
+     * Parses an if statement
+     *
+     * ifStatement
+     *   : "if" "(" expression ")" statement ["else" statement]
+     *   ;
+     */
+    parseIfStatement() {
+        const startToken = this._lexer.get();
+        let endToken = startToken;
+        this.expectToken(Token_1.TokenType.LParent, "W014");
+        const condition = this.getExpression();
+        if (!condition)
+            return null;
+        this.expectToken(Token_1.TokenType.RParent, "W006");
+        const thenBranch = this.parseStatement();
+        if (!thenBranch)
+            return null;
+        endToken = thenBranch.endToken;
+        let elseCanFollow = true;
+        if (thenBranch.type !== "BlockS") {
+            // --- We need a closing semicolon before else
+            if (this._lexer.peek().type === Token_1.TokenType.Semicolon) {
+                this._lexer.get();
+            }
+            else {
+                elseCanFollow = false;
+            }
+        }
+        let elseBranch = null;
+        if (elseCanFollow && this._lexer.peek().type === Token_1.TokenType.Else) {
+            this._lexer.get();
+            elseBranch = this.parseStatement();
+            if (!elseBranch)
+                return null;
+            endToken = elseBranch.endToken;
+        }
+        return this.createStatementNode("IfS", {
+            condition,
+            thenBranch,
+            elseBranch,
+        }, startToken, endToken);
+    }
+    /**
+     * Parses a while statement
+     *
+     * whileStatement
+     *   : "while" "(" condition ")" statement
+     *   ;
+     */
+    parseWhileStatement() {
+        const startToken = this._lexer.get();
+        this.expectToken(Token_1.TokenType.LParent, "W014");
+        const condition = this.getExpression();
+        if (!condition)
+            return null;
+        this.expectToken(Token_1.TokenType.RParent, "W006");
+        const body = this.parseStatement();
+        if (!body)
+            return null;
+        return this.createStatementNode("WhileS", {
+            condition,
+            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 !== "BlockS" && body.type !== "EmptyS") {
+            this.expectToken(Token_1.TokenType.Semicolon);
+        }
+        this.expectToken(Token_1.TokenType.While);
+        this.expectToken(Token_1.TokenType.LParent, "W014");
+        const condition = this.getExpression();
+        if (!condition)
+            return null;
+        const endToken = this._lexer.peek();
+        this.expectToken(Token_1.TokenType.RParent, "W006");
+        return this.createStatementNode("DoWS", {
+            condition,
+            body,
+        }, startToken, endToken);
+    }
+    /**
+     * Parses an expression statement
+     *
+     * returnStatement
+     *   : "return" expression?
+     *   ;
+     */
+    parseReturnStatement() {
+        const startToken = this._lexer.peek();
+        let endToken = this._lexer.get();
+        let expression;
+        if (TokenTrait_1.tokenTraits[this._lexer.peek().type].expressionStart) {
+            expression = this.getExpression();
+            if (expression === null)
+                return null;
+            endToken = expression.endToken;
+        }
+        return this.createStatementNode("RetS", {
+            expression,
+        }, startToken, endToken);
+    }
+    /**
+     * forStatement
+     *   : "for" "(" initStatement? ";" expression? ";" expression? ")" statement
+     *   | forInOfStatement
+     *   ;
+     */
+    parseForStatement() {
+        const startToken = this._lexer.peek();
+        this._lexer.get();
+        this.expectToken(Token_1.TokenType.LParent, "W014");
+        // --- Check for..in and for..of
+        let nextToken = this._lexer.peek();
+        if (nextToken.type === Token_1.TokenType.Identifier) {
+            if (this._lexer.ahead(1).type === Token_1.TokenType.In) {
+                return this.parseForInOfStatement(startToken, "none", nextToken.text, "ForInS");
+            }
+            else if (this._lexer.ahead(1).type === Token_1.TokenType.Of) {
+                return this.parseForInOfStatement(startToken, "none", nextToken.text, "ForOfS");
+            }
+        }
+        else if (nextToken.type === Token_1.TokenType.Let) {
+            const idToken = this._lexer.ahead(1);
+            if (idToken.type === Token_1.TokenType.Identifier) {
+                const inOfToken = this._lexer.ahead(2);
+                if (inOfToken.type === Token_1.TokenType.In) {
+                    return this.parseForInOfStatement(startToken, "let", idToken.text, "ForInS");
+                }
+                else if (inOfToken.type === Token_1.TokenType.Of) {
+                    return this.parseForInOfStatement(startToken, "let", idToken.text, "ForOfS");
+                }
+            }
+        }
+        else if (nextToken.type === Token_1.TokenType.Const) {
+            const idToken = this._lexer.ahead(1);
+            if (idToken.type === Token_1.TokenType.Identifier) {
+                const inOfToken = this._lexer.ahead(2);
+                if (inOfToken.type === Token_1.TokenType.In) {
+                    return this.parseForInOfStatement(startToken, "const", idToken.text, "ForInS");
+                }
+                else if (inOfToken.type === Token_1.TokenType.Of) {
+                    return this.parseForInOfStatement(startToken, "const", idToken.text, "ForOfS");
+                }
+            }
+        }
+        // --- We accept only let statement, empty statement, and expression
+        let init;
+        nextToken = this._lexer.peek();
+        if (nextToken.type === Token_1.TokenType.Semicolon) {
+            // --- Empty statement: no init in the for loop
+            this._lexer.get();
+        }
+        else if (nextToken.type === Token_1.TokenType.Let) {
+            // --- Let statement
+            const letStmt = this.parseLetStatement();
+            if (letStmt === null) {
+                return null;
+            }
+            init = letStmt;
+            if (init.declarations.some((d) => !d.expression)) {
+                this.reportError("W011");
+                return null;
+            }
+            this.expectToken(Token_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(Token_1.TokenType.Semicolon);
+        }
+        // --- Parse the condition
+        let condition;
+        nextToken = this._lexer.peek();
+        if (nextToken.type === Token_1.TokenType.Semicolon) {
+            // --- No condition
+            this._lexer.get();
+        }
+        else {
+            condition = this.getExpression();
+            if (condition === null) {
+                return null;
+            }
+            this.expectToken(Token_1.TokenType.Semicolon);
+        }
+        // --- Parse the update expression
+        let update;
+        nextToken = this._lexer.peek();
+        if (nextToken.type !== Token_1.TokenType.RParent) {
+            update = this.getExpression();
+            if (update === null) {
+                return null;
+            }
+        }
+        // --- Close the declaration part
+        this.expectToken(Token_1.TokenType.RParent, "W006");
+        // --- Get the body
+        const body = this.parseStatement();
+        if (!body)
+            return null;
+        return this.createStatementNode("ForS", {
+            init,
+            condition,
+            update,
+            body,
+        }, startToken, body.endToken);
+    }
+    /**
+     * forInOfStatement
+     *   : "for" "(" [ "let" | "const" ] identifier ( "in" | "of" ) expression? ")" statement
+     *   | forInOfStatement
+     *   ;
+     *
+     * @param startToken Statement start token
+     * @param varBinding Variable binding of the for..in/of statement
+     * @param id ID name
+     * @param type Is it a for..in or a for..of?
+     */
+    parseForInOfStatement(startToken, varBinding, id, type) {
+        if (varBinding !== "none") {
+            // --- Skip variable binding type
+            this._lexer.get();
+        }
+        // --- Skip variable name, in/of token
+        this._lexer.get();
+        this._lexer.get();
+        // --- Get the expression
+        const expression = this.getExpression(true);
+        // --- Close the declaration part
+        this.expectToken(Token_1.TokenType.RParent, "W006");
+        // --- Get the body
+        const body = this.parseStatement();
+        if (!body)
+            return null;
+        return type === "ForInS"
+            ? this.createStatementNode("ForInS", {
+                varBinding,
+                id,
+                expression,
+                body,
+            }, startToken, body.endToken)
+            : this.createStatementNode("ForOfS", {
+                varBinding,
+                id,
+                expression,
+                body,
+            }, startToken, body.endToken);
+    }
+    /**
+     * Parses a throw statement
+     *
+     * throwStatement
+     *   : "throw" expression
+     *   ;
+     */
+    parseThrowStatement() {
+        const startToken = this._lexer.peek();
+        this._lexer.get();
+        let expression;
+        expression = this.getExpression();
+        if (expression === null)
+            return null;
+        return this.createStatementNode("ThrowS", {
+            expression,
+        }, startToken, expression.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 startToken = this._lexer.peek();
+        let endToken = this._lexer.get();
+        const parser = this;
+        // --- Get "try" block
+        const tryBlock = getBlock();
+        let catchBlock;
+        let catchVariable;
+        let finallyBlock;
+        let nextToken = this._lexer.peek();
+        if (nextToken.type === Token_1.TokenType.Catch) {
+            // --- Catch found
+            this._lexer.get();
+            nextToken = this._lexer.peek();
+            if (nextToken.type === Token_1.TokenType.LParent) {
+                // --- Catch variable found
+                this._lexer.get();
+                nextToken = this._lexer.peek();
+                if (nextToken.type !== Token_1.TokenType.Identifier) {
+                    this.reportError("W003", nextToken);
+                    return null;
+                }
+                catchVariable = nextToken.text;
+                this._lexer.get();
+                this.expectToken(Token_1.TokenType.RParent, "W006");
+            }
+            // --- Get catch block
+            catchBlock = getBlock();
+            endToken = catchBlock.endToken;
+            if (this._lexer.peek().type === Token_1.TokenType.Finally) {
+                // --- Finally after catch
+                this._lexer.get();
+                finallyBlock = getBlock();
+                endToken = finallyBlock.endToken;
+            }
+        }
+        else if (nextToken.type === Token_1.TokenType.Finally) {
+            // --- Finally found
+            this._lexer.get();
+            finallyBlock = getBlock();
+            endToken = finallyBlock.endToken;
+        }
+        else {
+            this.reportError("W013", nextToken);
+            return null;
+        }
+        return this.createStatementNode("TryS", {
+            tryBlock,
+            catchBlock,
+            catchVariable,
+            finallyBlock,
+        }, startToken, endToken);
+        function getBlock() {
+            const nextToken = parser._lexer.peek();
+            if (nextToken.type !== Token_1.TokenType.LBrace) {
+                parser.reportError("W012", nextToken);
+                return null;
+            }
+            return parser.parseBlockStatement();
+        }
+    }
+    /**
+     * 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(Token_1.TokenType.LParent, "W014");
+        const expression = this.getExpression();
+        if (!expression)
+            return null;
+        this.expectToken(Token_1.TokenType.RParent, "W006");
+        // --- Parse the case blocks
+        this.expectToken(Token_1.TokenType.LBrace, "W012");
+        const cases = [];
+        let defaultCaseFound = false;
+        while (true) {
+            let nextToken = this._lexer.peek();
+            let caseExpression;
+            if (nextToken.type === Token_1.TokenType.Case) {
+                // --- Process "case"
+                this._lexer.get();
+                caseExpression = this.getExpression();
+                if (!caseExpression)
+                    return null;
+            }
+            else if (nextToken.type === Token_1.TokenType.Default) {
+                // --- Process "default"
+                if (defaultCaseFound) {
+                    this.reportError("W016");
+                    return null;
+                }
+                defaultCaseFound = true;
+                this._lexer.get();
+            }
+            else if (nextToken.type === Token_1.TokenType.RBrace) {
+                break;
+            }
+            else {
+                this.reportError("W015");
+                return null;
+            }
+            // --- Process label statements
+            this.expectToken(Token_1.TokenType.Colon, "W008");
+            let statements = [];
+            let collected = false;
+            while (!collected) {
+                const stmtToken = this._lexer.peek();
+                switch (stmtToken.type) {
+                    case Token_1.TokenType.Case:
+                    case Token_1.TokenType.Default:
+                    case Token_1.TokenType.RBrace:
+                        // --- 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;
+                        }
+                        statements.push(stmt);
+                        if (stmt.type !== "EmptyS") {
+                            this.skipToken(Token_1.TokenType.Semicolon);
+                        }
+                }
+            }
+            cases.push(this.createNode("SwitchC", {
+                caseExpression,
+                statements,
+            }, startToken));
+        }
+        // --- Closing
+        const endToken = this._lexer.peek();
+        this.expectToken(Token_1.TokenType.RBrace, "W004");
+        return this.createStatementNode("SwitchS", {
+            expression,
+            cases,
+        }, startToken, endToken);
+    }
+    /**
+     * Parses a function declaration
+     *
+     * functionDeclaration
+     *   : "function" identifier "(" [parameterList] ")" blockStatement
+     *   ;
+     */
+    parseFunctionDeclaration() {
+        var _a;
+        const startToken = this._lexer.get();
+        // --- Get the function name
+        const funcId = this._lexer.peek();
+        if (funcId.type !== Token_1.TokenType.Identifier) {
+            this.reportError("W003", funcId);
+            return null;
+        }
+        this._lexer.get();
+        // --- Get the parameter list;
+        const nextToken = this._lexer.peek();
+        if (nextToken.type !== Token_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 "NoArgE":
+                isValid = true;
+                break;
+            case "IdE":
+                isValid = ((_a = exprList.parenthesized) !== null && _a !== void 0 ? _a : 0) <= 1;
+                args.push(exprList);
+                break;
+            case "SeqE":
+                isValid = exprList.parenthesized === 1;
+                if (isValid) {
+                    for (const expr of exprList.expressions) {
+                        switch (expr.type) {
+                            case "IdE":
+                                isValid = !expr.parenthesized;
+                                args.push(expr);
+                                break;
+                            case "OLitE": {
+                                isValid = !expr.parenthesized;
+                                if (isValid) {
+                                    const des = this.convertToObjectDestructure(expr);
+                                    if (des)
+                                        args.push(des);
+                                }
+                                break;
+                            }
+                            case "ALitE": {
+                                isValid = !expr.parenthesized;
+                                if (isValid) {
+                                    const des = this.convertToArrayDestructure(expr);
+                                    if (des)
+                                        args.push(des);
+                                }
+                                break;
+                            }
+                            default:
+                                isValid = false;
+                                break;
+                        }
+                    }
+                }
+                break;
+            case "OLitE":
+                isValid = exprList.parenthesized === 1;
+                if (isValid) {
+                    const des = this.convertToObjectDestructure(exprList);
+                    if (des)
+                        args.push(des);
+                }
+                break;
+            case "ALitE":
+                isValid = exprList.parenthesized === 1;
+                if (isValid) {
+                    const des = this.convertToArrayDestructure(exprList);
+                    if (des)
+                        args.push(des);
+                }
+                break;
+            default:
+                isValid = false;
+        }
+        if (!isValid) {
+            this.reportError("W010", startToken);
+            return null;
+        }
+        // --- Get the function body (statement block)
+        if (this._lexer.peek().type !== Token_1.TokenType.LBrace) {
+            this.reportError("W012", this._lexer.peek());
+            return null;
+        }
+        const body = this.parseBlockStatement();
+        if (!body)
+            return null;
+        // --- Done.
+        return this.createStatementNode("FuncD", {
+            name: funcId.text,
+            args,
+            statement: body,
+        }, startToken, body.endToken);
+    }
+    /**
+     * Parses an export statement
+     *
+     * exportStatement
+     *   : "export" (constStatement | functionDeclaration)
+     *   ;
+     */
+    parseExport() {
+        this._lexer.get();
+        const nextToken = this._lexer.peek();
+        if (nextToken.type === Token_1.TokenType.Const) {
+            if (this._statementLevel > 1) {
+                this.reportError("W030", nextToken);
+                return null;
+            }
+            const constStmt = this.parseConstStatement();
+            return constStmt === null ? null : Object.assign(Object.assign({}, constStmt), { isExported: true });
+        }
+        else if (nextToken.type === Token_1.TokenType.Function) {
+            if (this._statementLevel > 1) {
+                this.reportError("W030", nextToken);
+                return null;
+            }
+            const funcDecl = this.parseFunctionDeclaration();
+            return funcDecl === null ? null : Object.assign(Object.assign({}, funcDecl), { isExported: true });
+        }
+        this.reportError("W024", nextToken);
+        return null;
+    }
+    /**
+     * Parse an import declaration
+     *
+     * importDeclaration
+     *   : "import" "{" importItem ("," importItem)* [ "," ] "}" from module
+     *   ;
+     *
+     * importItem
+     *   : identifier [ "as" identifier ]
+     *   ;
+     */
+    parseImport() {
+        const startToken = this._lexer.get();
+        this.expectToken(Token_1.TokenType.LBrace, "W012");
+        const imports = {};
+        let nextToken = this._lexer.peek();
+        while (nextToken.type !== Token_1.TokenType.RBrace) {
+            if (nextToken.type !== Token_1.TokenType.Identifier) {
+                this.reportError("W003", nextToken);
+                return null;
+            }
+            const id = nextToken.text;
+            this._lexer.get();
+            nextToken = this._lexer.peek();
+            if (nextToken.type === Token_1.TokenType.As) {
+                this._lexer.get();
+                nextToken = this._lexer.peek();
+                if (nextToken.type !== Token_1.TokenType.Identifier) {
+                    this.reportError("W003", nextToken);
+                    return null;
+                }
+                if (imports[nextToken.text]) {
+                    this.reportError("W019", nextToken, nextToken.text);
+                    return null;
+                }
+                imports[nextToken.text] = id;
+                this._lexer.get();
+            }
+            else {
+                if (imports[id]) {
+                    this.reportError("W019", nextToken, id);
+                    return null;
+                }
+                imports[id] = id;
+            }
+            nextToken = this._lexer.peek();
+            if (nextToken.type === Token_1.TokenType.Comma) {
+                this._lexer.get();
+                nextToken = this._lexer.peek();
+            }
+        }
+        // --- Skip the closing brace
+        this._lexer.get();
+        // --- Check for "from"
+        this.expectToken(Token_1.TokenType.From, "W025");
+        // --- Get the module name
+        const moduleToken = this._lexer.peek();
+        if (moduleToken.type !== Token_1.TokenType.StringLiteral) {
+            this.reportError("W026", moduleToken);
+            return null;
+        }
+        this._lexer.get();
+        const literal = this.parseStringLiteral(moduleToken);
+        // --- Done.
+        return this.createStatementNode("ImportD", {
+            imports,
+            moduleFile: literal.value,
+        }, startToken, moduleToken);
+    }
+    // ==========================================================================
+    // 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 expressions = [];
+        let loose = false;
+        if (this._lexer.peek().type === Token_1.TokenType.Comma) {
+            expressions.push(leftExpr);
+            while (this.skipToken(Token_1.TokenType.Comma)) {
+                if (this._lexer.peek().type === Token_1.TokenType.Comma) {
+                    loose = true;
+                    endToken = this._lexer.peek();
+                    expressions.push(this.createExpressionNode("NoArgE", {}, endToken, endToken));
+                }
+                else {
+                    const nextExpr = this.parseCondOrSpreadOrAsgnOrArrowExpr();
+                    if (!nextExpr) {
+                        break;
+                    }
+                    endToken = nextExpr.endToken;
+                    expressions.push(nextExpr);
+                }
+            }
+        }
+        if (!expressions.length) {
+            // --- No sequence
+            return leftExpr;
+        }
+        // --- Create the sequence expression
+        leftExpr = this.createExpressionNode("SeqE", {
+            expressions,
+            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 === Token_1.TokenType.Spread) {
+            // --- Spread expression
+            this._lexer.get();
+            const spreadOperand = this.parseNullCoalescingExpr();
+            return spreadOperand
+                ? this.createExpressionNode("SpreadE", {
+                    operand: spreadOperand,
+                }, startToken, spreadOperand.endToken)
+                : null;
+        }
+        const otherExpr = this.parseNullCoalescingExpr();
+        if (!otherExpr) {
+            return null;
+        }
+        const nextToken = this._lexer.peek();
+        if (nextToken.type === Token_1.TokenType.Arrow) {
+            // --- It is an arrow expression
+            return this.parseArrowExpression(startToken, otherExpr);
+        }
+        if (nextToken.type === Token_1.TokenType.QuestionMark) {
+            this._lexer.get();
+            // --- Conditional expression
+            const trueExpr = this.getExpression(false);
+            this.expectToken(Token_1.TokenType.Colon);
+            const falseExpr = this.getExpression(false);
+            return this.createExpressionNode("CondE", {
+                condition: otherExpr,
+                consequent: trueExpr,
+                alternate: falseExpr,
+            }, startToken, falseExpr.endToken);
+        }
+        if (TokenTrait_1.tokenTraits[nextToken.type].isAssignment) {
+            // --- Assignment
+            this._lexer.get();
+            const operand = this.getExpression();
+            return operand
+                ? this.createExpressionNode("AsgnE", {
+                    leftValue: otherExpr,
+                    operator: nextToken.text,
+                    operand,
+                }, startToken, operand.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 "NoArgE":
+                isValid = true;
+                break;
+            case "IdE":
+                isValid = ((_a = left.parenthesized) !== null && _a !== void 0 ? _a : 0) <= 1;
+                args.push(left);
+                break;
+            case "SeqE":
+                isValid = left.parenthesized === 1;
+                if (isValid) {
+                    for (const expr of left.expressions) {
+                        switch (expr.type) {
+                            case "IdE":
+                                isValid = !expr.parenthesized;
+                                args.push(expr);
+                                break;
+                            case "OLitE": {
+                                isValid = !expr.parenthesized;
+                                if (isValid) {
+                                    const des = this.convertToObjectDestructure(expr);
+                                    if (des)
+                                        args.push(des);
+                                }
+                                break;
+                            }
+                            case "ALitE": {
+                                isValid = !expr.parenthesized;
+                                if (isValid) {
+                                    const des = this.convertToArrayDestructure(expr);
+                                    if (des)
+                                        args.push(des);
+                                }
+                                break;
+                            }
+                            default:
+                                isValid = false;
+                                break;
+                        }
+                    }
+                }
+                break;
+            case "OLitE":
+                isValid = left.parenthesized === 1;
+                if (isValid) {
+                    const des = this.convertToObjectDestructure(left);
+                    if (des)
+                        args.push(des);
+                }
+                break;
+            case "ALitE":
+                isValid = left.parenthesized === 1;
+                if (isValid) {
+                    const des = this.convertToArrayDestructure(left);
+                    if (des)
+                        args.push(des);
+                }
+                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("ArrowE", {
+                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(Token_1.TokenType.NullCoalesce)) {
+            const rightExpr = this.parseLogicalOrExpr();
+            if (!rightExpr) {
+                this.reportError("W001");
+                return null;
+            }
+            let endToken = rightExpr.endToken;
+            leftExpr = this.createExpressionNode("BinaryE", {
+                operator: "??",
+                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(Token_1.TokenType.LogicalOr)) {
+            const rightExpr = this.parseLogicalAndExpr();
+            if (!rightExpr) {
+                this.reportError("W001");
+                return null;
+            }
+            let endToken = rightExpr.endToken;
+            leftExpr = this.createExpressionNode("BinaryE", {
+                operator: "||",
+                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(Token_1.TokenType.LogicalAnd)) {
+            const rightExpr = this.parseBitwiseOrExpr();
+            if (!rightExpr) {
+                this.reportError("W001");
+                return null;
+            }
+            let endToken = rightExpr.endToken;
+            leftExpr = this.createExpressionNode("BinaryE", {
+                operator: "&&",
+                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(Token_1.TokenType.BitwiseOr)) {
+            const rightExpr = this.parseBitwiseXorExpr();
+            if (!rightExpr) {
+                this.reportError("W001");
+                return null;
+            }
+            let endToken = rightExpr.endToken;
+            leftExpr = this.createExpressionNode("BinaryE", {
+                operator: "|",
+                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(Token_1.TokenType.BitwiseXor)) {
+            const rightExpr = this.parseBitwiseAndExpr();
+            if (!rightExpr) {
+                this.reportError("W001");
+                return null;
+            }
+            let endToken = rightExpr.endToken;
+            leftExpr = this.createExpressionNode("BinaryE", {
+                operator: "^",
+                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(Token_1.TokenType.BitwiseAnd)) {
+            const rightExpr = this.parseEquExpr();
+            if (!rightExpr) {
+                this.reportError("W001");
+                return null;
+            }
+            let endToken = rightExpr.endToken;
+            leftExpr = this.createExpressionNode("BinaryE", {
+                operator: "&",
+                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(Token_1.TokenType.Equal, Token_1.TokenType.StrictEqual, Token_1.TokenType.NotEqual, Token_1.TokenType.StrictNotEqual))) {
+            const rightExpr = this.parseRelOrInExpr();
+            if (!rightExpr) {
+                this.reportError("W001");
+                return null;
+            }
+            let endToken = rightExpr.endToken;
+            leftExpr = this.createExpressionNode("BinaryE", {
+                type: "BinaryE",
+                operator: opType.text,
+                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(Token_1.TokenType.LessThan, Token_1.TokenType.LessThanOrEqual, Token_1.TokenType.GreaterThan, Token_1.TokenType.GreaterThanOrEqual, Token_1.TokenType.In))) {
+            const rightExpr = this.parseShiftExpr();
+            if (!rightExpr) {
+                this.reportError("W001");
+                return null;
+            }
+            let endToken = rightExpr.endToken;
+            leftExpr = this.createExpressionNode("BinaryE", {
+                operator: opType.text,
+                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(Token_1.TokenType.ShiftLeft, Token_1.TokenType.ShiftRight, Token_1.TokenType.SignedShiftRight))) {
+            const rightExpr = this.parseAddExpr();
+            if (!rightExpr) {
+                this.reportError("W001");
+                return null;
+            }
+            let endToken = rightExpr.endToken;
+            leftExpr = this.createExpressionNode("BinaryE", {
+                operator: opType.text,
+                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(Token_1.TokenType.Plus, Token_1.TokenType.Minus))) {
+            const rightExpr = this.parseMultExpr();
+            if (!rightExpr) {
+                this.reportError("W001");
+                return null;
+            }
+            let endToken = rightExpr.endToken;
+            leftExpr = this.createExpressionNode("BinaryE", {
+                operator: opType.text,
+                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(Token_1.TokenType.Multiply, Token_1.TokenType.Divide, Token_1.TokenType.Remainder))) {
+            const rightExpr = this.parseExponentialExpr();
+            if (!rightExpr) {
+                this.reportError("W001");
+                return null;
+            }
+            let endToken = rightExpr.endToken;
+            leftExpr = this.createExpressionNode("BinaryE", {
+                operator: opType.text,
+                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(Token_1.TokenType.Exponent))) {
+            let rightExpr = this.parseUnaryOrPrefixExpr();
+            if (!rightExpr) {
+                this.reportError("W001");
+                return null;
+            }
+            let endToken = rightExpr.endToken;
+            if (count === 0) {
+                leftExpr = this.createExpressionNode("BinaryE", {
+                    operator: opType.text,
+                    left: leftExpr,
+                    right: rightExpr,
+                }, startToken, endToken);
+            }
+            else {
+                const prevLeft = leftExpr;
+                leftExpr = this.createExpressionNode("BinaryE", {
+                    operator: opType.text,
+                    left: prevLeft.left,
+                    right: {
+                        type: "BinaryE",
+                        operator: 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("UnaryE", {
+                operator: startToken.text,
+                operand: unaryOperand,
+            }, startToken, unaryOperand.endToken);
+        }
+        if (startToken.type === Token_1.TokenType.IncOp || startToken.type === Token_1.TokenType.DecOp) {
+            this._lexer.get();
+            const prefixOperand = this.parseMemberOrInvocationExpr();
+            if (!prefixOperand) {
+                return null;
+            }
+            return this.createExpressionNode("PrefE", {
+                operator: startToken.text,
+                operand: 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 Token_1.TokenType.LParent: {
+                    this._lexer.get();
+                    let args = [];
+                    if (this._lexer.peek().type !== Token_1.TokenType.RParent) {
+                        const expr = this.parseExpr();
+                        if (!expr) {
+                            this.reportError("W001");
+                            return null;
+                        }
+                        args = expr.type === "SeqE" ? expr.expressions : [expr];
+                    }
+                    const endToken = this._lexer.peek();
+                    this.expectToken(Token_1.TokenType.RParent, "W006");
+                    primary = this.createExpressionNode("InvokeE", {
+                        object: primary,
+                        arguments: args,
+                    }, startToken, endToken);
+                    break;
+                }
+                case Token_1.TokenType.Dot:
+                case Token_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("MembE", {
+                        object: primary,
+                        member: member.text,
+                        isOptional: currentStart.type === Token_1.TokenType.OptionalChaining,
+                    }, startToken, member);
+                    break;
+                case Token_1.TokenType.LSquare:
+                    this._lexer.get();
+                    const memberExpr = this.getExpression();
+                    if (!memberExpr) {
+                        return null;
+                    }
+                    const endToken = this._lexer.peek();
+                    this.expectToken(Token_1.TokenType.RSquare, "W005");
+                    primary = this.createExpressionNode("CMembE", {
+                        object: primary,
+                        member: memberExpr,
+                    }, startToken, endToken);
+                    break;
+                default:
+                    exitLoop = true;
+                    break;
+            }
+        } while (!exitLoop);
+        // --- Check for postfix operators
+        const nextToken = this._lexer.peek();
+        if (nextToken.type === Token_1.TokenType.IncOp || nextToken.type === Token_1.TokenType.DecOp) {
+            this._lexer.get();
+            return this.createExpressionNode("PostfE", {
+                operator: nextToken.text,
+                operand: primary,
+            }, startToken, nextToken);
+        }
+        return primary;
+    }
+    /**
+     * primaryExpr
+     *   : literal
+     *   | identifier
+     *   | "::" identifier
+     *   | "$item"
+     *   | "(" expr ")"
+     *   ;
+     */
+    parsePrimaryExpr() {
+        var _a;
+        const start = this._lexer.peek();
+        switch (start.type) {
+            case Token_1.TokenType.LParent:
+                // --- Parenthesised or no-arg expression
+                this._lexer.get();
+                if (this._lexer.peek().type === Token_1.TokenType.RParent) {
+                    // --- No-arg
+                    const endToken = this._lexer.get();
+                    return this.createExpressionNode("NoArgE", {}, start, endToken);
+                }
+                // --- Parenthesized
+                const parenthesizedExpr = this.parseExpr();
+                if (!parenthesizedExpr) {
+                    return null;
+                }
+                const endToken = this._lexer.peek();
+                this.expectToken(Token_1.TokenType.RParent, "W006");
+                (_a = parenthesizedExpr.parenthesized) !== null && _a !== void 0 ? _a : (parenthesizedExpr.parenthesized = 0);
+                parenthesizedExpr.parenthesized++;
+                parenthesizedExpr.startToken = start;
+                parenthesizedExpr.startPosition = start.location.startPosition;
+                parenthesizedExpr.startLine = start.location.startLine;
+                parenthesizedExpr.startColumn = start.location.startColumn;
+                parenthesizedExpr.endToken = endToken;
+                parenthesizedExpr.endPosition = endToken.location.endPosition;
+                parenthesizedExpr.endLine = endToken.location.endLine;
+                parenthesizedExpr.endColumn = endToken.location.endColumn;
+                parenthesizedExpr.source = this.getSource(start, endToken);
+                return parenthesizedExpr;
+            case Token_1.TokenType.Identifier: {
+                const idToken = this._lexer.get();
+                return this.createExpressionNode("IdE", {
+                    name: idToken.text,
+                }, idToken, idToken);
+            }
+            case Token_1.TokenType.Global: {
+                this._lexer.get();
+                const idToken = this._lexer.get();
+                if (idToken.type !== Token_1.TokenType.Identifier) {
+                    this.reportError("W003");
+                    return null;
+                }
+                return this.createExpressionNode("IdE", {
+                    name: idToken.text,
+                    isGlobal: true,
+                }, idToken, idToken);
+            }
+            case Token_1.TokenType.False:
+            case Token_1.TokenType.True:
+                this._lexer.get();
+                return this.createExpressionNode("LitE", {
+                    value: start.type === Token_1.TokenType.True,
+                }, start, start);
+            case Token_1.TokenType.BinaryLiteral:
+                this._lexer.get();
+                return this.parseBinaryLiteral(start);
+            case Token_1.TokenType.DecimalLiteral:
+                this._lexer.get();
+                return this.parseDecimalLiteral(start);
+            case Token_1.TokenType.HexadecimalLiteral:
+                this._lexer.get();
+                return this.parseHexadecimalLiteral(start);
+            case Token_1.TokenType.RealLiteral:
+                this._lexer.get();
+                return this.parseRealLiteral(start);
+            case Token_1.TokenType.StringLiteral:
+                this._lexer.get();
+                return this.parseStringLiteral(start);
+            case Token_1.TokenType.Infinity:
+                this._lexer.get();
+                return this.createExpressionNode("LitE", {
+                    value: Infinity,
+                }, start, start);
+            case Token_1.TokenType.NaN:
+                this._lexer.get();
+                return this.createExpressionNode("LitE", {
+                    value: NaN,
+                }, start, start);
+            case Token_1.TokenType.Null:
+                this._lexer.get();
+                return this.createExpressionNode("LitE", {
+                    value: null,
+                }, start, start);
+            case Token_1.TokenType.Undefined:
+                this._lexer.get();
+                return this.createExpressionNode("LitE", {
+                    value: undefined,
+                }, start, start);
+            case Token_1.TokenType.LSquare:
+                return this.parseArrayLiteral();
+            case Token_1.TokenType.LBrace:
+                return this.parseObjectLiteral();
+            case Token_1.TokenType.Divide:
+                return this.parseRegExpLiteral();
+        }
+        return null;
+    }
+    /**
+     * Parses an array literal
+     */
+    parseArrayLiteral() {
+        const start = this._lexer.get();
+        let expressions = [];
+        if (this._lexer.peek().type !== Token_1.TokenType.RSquare) {
+            const expr = this.getExpression();
+            if (expr) {
+                expressions = expr.type === "SeqE" ? expr.expressions : [expr];
+            }
+        }
+        const endToken = this._lexer.peek();
+        this.expectToken(Token_1.TokenType.RSquare);
+        return this.createExpressionNode("ALitE", {
+            items: expressions,
+        }, start, endToken);
+    }
+    /**
+     * Parses an object literal
+     */
+    parseObjectLiteral() {
+        const start = this._lexer.get();
+        let props = [];
+        if (this._lexer.peek().type !== Token_1.TokenType.RBrace) {
+            while (this._lexer.peek().type !== Token_1.TokenType.RBrace) {
+                // --- Check the next token
+                const nextToken = this._lexer.peek();
+                const traits = TokenTrait_1.tokenTraits[nextToken.type];
+                let nameExpr;
+                // --- Get property name or calculated property name
+                if (traits.expressionStart) {
+                    if (nextToken.type === Token_1.TokenType.LSquare) {
+                        this._lexer.get();
+                        nameExpr = this.getExpression();
+                        if (!nameExpr) {
+                            return null;
+                        }
+                        this.expectToken(Token_1.TokenType.RSquare, "W005");
+                        nameExpr = this.createExpressionNode("SeqE", {
+                            expressions: [nameExpr],
+                        }, start);
+                    }
+                    else if (traits.isPropLiteral) {
+                        nameExpr = this.getExpression(false);
+                        if (!nameExpr) {
+                            return null;
+                        }
+                        if (nameExpr.type !== "IdE" && nameExpr.type !== "LitE" && nameExpr.type !== "SpreadE") {
+                            this.reportError("W007");
+                            return null;
+                        }
+                    }
+                    else {
+                        this.reportError("W007");
+                        return null;
+                    }
+                }
+                else if (traits.keywordLike) {
+                    nameExpr = {
+                        type: "IdE",
+                        name: nextToken.text,
+                        value: undefined,
+                        startPosition: nextToken.location.startPosition,
+                        startLine: nextToken.location.startLine,
+                        startColumn: nextToken.location.startColumn,
+                        endPosition: nextToken.location.endPosition,
+                        endLine: nextToken.location.endLine,
+                        endColumn: nextToken.location.endColumn,
+                        source: nextToken.text,
+                        startToken: nextToken,
+                        endToken: nextToken,
+                    };
+                    this._lexer.get();
+                }
+                else {
+                    this.reportError("W001");
+                    return null;
+                }
+                const nameType = nameExpr.type;
+                if (nameType === "SpreadE") {
+                    props.push(nameExpr);
+                }
+                else {
+                    if (nameType === "LitE") {
+                        const val = nameExpr.value;
+                        if (typeof val !== "number" && typeof val !== "string") {
+                            this.expectToken(Token_1.TokenType.RBrace, "W007");
+                            return null;
+                        }
+                    }
+                    // else if (nameType !== "IdE") {
+                    //   this.expectToken(TokenType.RBrace, "W007");
+                    //   return null;
+                    // }
+                    // --- Value is optional, when we have a name
+                    let valueExpr = null;
+                    if (nameType === "IdE") {
+                        const nameFollowerToken = this._lexer.peek();
+                        if (nameFollowerToken.type === Token_1.TokenType.Comma || nameFollowerToken.type === Token_1.TokenType.RBrace) {
+                            valueExpr = Object.assign({}, nameExpr);
+                        }
+                    }
+                    // --- Move to property value
+                    if (!valueExpr) {
+                        this.expectToken(Token_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 === Token_1.TokenType.Comma) {
+                    this._lexer.get();
+                }
+                else {
+                    if (next !== Token_1.TokenType.RBrace) {
+                        break;
+                    }
+                }
+            }
+        }
+        const endToken = this._lexer.peek();
+        this.expectToken(Token_1.TokenType.RBrace, "W004");
+        return this.createExpressionNode("OLitE", {
+            props,
+        }, start, endToken);
+    }
+    parseRegExpLiteral() {
+        var _a;
+        const startToken = this._lexer.peek();
+        const result = this._lexer.getRegEx();
+        if (result.success) {
+            return this.createExpressionNode("LitE", {
+                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 === Token_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.location.startLine,
+            column: token.location.startColumn,
+            position: token.location.startPosition,
+        });
+        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, source) {
+        if (!endToken) {
+            endToken = this._lexer.peek();
+        }
+        const startPosition = startToken.location.startPosition;
+        const endPosition = endToken.location.startPosition;
+        return Object.assign({}, stump, {
+            type,
+            startPosition,
+            endPosition,
+            startLine: startToken.location.startLine,
+            startColumn: startToken.location.startColumn,
+            endLine: endToken.location.endLine,
+            endColumn: endToken.location.endColumn,
+            source: source !== null && source !== void 0 ? source : this.getSource(startToken, endToken),
+        });
+    }
+    /**
+     * 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, source) {
+        if (!endToken) {
+            endToken = this._lexer.peek();
+        }
+        if (!startToken) {
+            startToken = endToken;
+        }
+        const startPosition = startToken.location.startPosition;
+        const endPosition = endToken.location.endPosition;
+        return Object.assign({}, stump, {
+            type,
+            startPosition,
+            endPosition,
+            startLine: startToken.location.startLine,
+            startColumn: startToken.location.startColumn,
+            endLine: endToken.location.endLine,
+            endColumn: endToken.location.endColumn,
+            source: source !== null && source !== void 0 ? source : this.getSource(startToken, endToken),
+            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) {
+        var _a, _b, _c, _d, _e;
+        const startPosition = (_a = startToken === null || startToken === void 0 ? void 0 : startToken.location) === null || _a === void 0 ? void 0 : _a.startPosition;
+        const currentToken = this._lexer.peek();
+        const endPosition = endToken
+            ? endToken.location.endPosition
+            : currentToken.type === Token_1.TokenType.Eof
+                ? currentToken.location.startPosition + 1
+                : currentToken.location.startPosition;
+        return Object.assign({}, stump, {
+            type,
+            startPosition,
+            endPosition,
+            startLine: (_b = startToken === null || startToken === void 0 ? void 0 : startToken.location) === null || _b === void 0 ? void 0 : _b.startLine,
+            startColumn: (_c = startToken === null || startToken === void 0 ? void 0 : startToken.location) === null || _c === void 0 ? void 0 : _c.startColumn,
+            endLine: endToken ? endToken.location.endLine : (_d = startToken === null || startToken === void 0 ? void 0 : startToken.location) === null || _d === void 0 ? void 0 : _d.endLine,
+            endColumn: endToken ? endToken.location.endColumn : (_e = startToken === null || startToken === void 0 ? void 0 : startToken.location) === null || _e === void 0 ? void 0 : _e.endColumn,
+            source: this.source && startPosition !== undefined && endPosition !== undefined
+                ? this.source.substring(startPosition, endPosition)
+                : undefined,
+            startToken,
+            endToken,
+        });
+    }
+    /**
+     * Gets the source code for the specified token range
+     * @param start Start token
+     * @param end Optional end token
+     * @returns The source code for the token range
+     */
+    getSource(start, end) {
+        return this.source.substring(start.location.startPosition, end.type === Token_1.TokenType.Eof ? end.location.startPosition : end.location.endPosition);
+    }
+    /**
+     * Parses a binary literal
+     * @param token Literal token
+     */
+    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("LitE", {
+            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("LitE", {
+            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("LitE", {
+            value,
+        }, token, token);
+    }
+    /**
+     * Parses a real literal
+     * @param token Literal token
+     */
+    parseRealLiteral(token) {
+        let value = parseFloat(token.text.replace(/[_']/g, ""));
+        return this.createExpressionNode("LitE", {
+            value,
+        }, token, token);
+    }
+    /**
+     * Converts a string token to intrinsic string
+     * @param token Literal token
+     */
+    parseStringLiteral(token) {
+        const input = token.text.length < 2 ? "" : token.text.substring(1, token.text.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("LitE", {
+            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 === "SeqE" ? seq.expressions : seq.items;
+        const result = this.createExpressionNode("Destr", { arrayDestruct: [] }, seq.startToken, seq.endToken);
+        // --- Convert all items
+        for (const item of items) {
+            let arrayD;
+            switch (item.type) {
+                case "NoArgE":
+                    arrayD = this.createExpressionNode("ADestr", {}, item.startToken, item.endToken);
+                    break;
+                case "IdE":
+                    arrayD = this.createExpressionNode("ADestr", { id: item.name }, item.startToken, item.endToken);
+                    break;
+                case "Destr":
+                    result.arrayDestruct.push(...item.arrayDestruct);
+                    break;
+                case "ADestr":
+                    arrayD = item;
+                    break;
+                case "ALitE": {
+                    const destructure = this.convertToArrayDestructure(item);
+                    if (destructure) {
+                        arrayD = this.createExpressionNode("ADestr", {
+                            arrayDestruct: destructure.arrayDestruct,
+                        }, item.startToken, item.endToken);
+                    }
+                    break;
+                }
+                case "ODestr":
+                    arrayD = this.createExpressionNode("ADestr", {
+                        objectDestruct: item,
+                    }, item.startToken, item.endToken);
+                    break;
+                case "OLitE": {
+                    const destructure = this.convertToObjectDestructure(item);
+                    if (destructure) {
+                        arrayD = this.createExpressionNode("ADestr", {
+                            objectDestruct: destructure.objectDestruct,
+                        }, item.startToken, item.endToken);
+                    }
+                    break;
+                }
+                default:
+                    this.reportError("W017");
+                    return null;
+            }
+            if (arrayD)
+                (_a = result.arrayDestruct) === null || _a === void 0 ? void 0 : _a.push(arrayD);
+        }
+        // --- Done.
+        return result;
+    }
+    convertToObjectDestructure(objLit) {
+        var _a;
+        const result = this.createExpressionNode("Destr", { objectDestruct: [] }, objLit.startToken, objLit.endToken);
+        // --- 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 !== "IdE") {
+                reportError("W018");
+                return null;
+            }
+            let objD;
+            switch (propValue.type) {
+                case "IdE":
+                    if (propValue.name === propKey.name) {
+                        objD = this.createExpressionNode("ODestr", { id: propKey.name }, propValue.startToken, propValue.endToken);
+                    }
+                    else {
+                        objD = this.createExpressionNode("ODestr", {
+                            id: propKey.name,
+                            alias: propValue.name,
+                        }, propValue.startToken, propValue.endToken);
+                    }
+                    break;
+                case "ADestr": {
+                    objD = this.createExpressionNode("ODestr", {
+                        id: propKey.name,
+                        arrayDestruct: propValue,
+                    }, propKey.startToken, propValue.endToken);
+                    break;
+                }
+                case "ALitE": {
+                    const destructure = this.convertToArrayDestructure(propValue);
+                    if (destructure) {
+                        objD = this.createExpressionNode("ODestr", {
+                            id: propKey.name,
+                            arrayDestruct: destructure.arrayDestruct,
+                        }, propKey.startToken, propValue.endToken);
+                    }
+                    break;
+                }
+                case "ODestr":
+                    objD = propValue;
+                    break;
+                case "OLitE": {
+                    const destructure = this.convertToObjectDestructure(propValue);
+                    if (destructure) {
+                        objD = this.createExpressionNode("ODestr", {
+                            id: propKey.name,
+                            objectDestruct: destructure.objectDestruct,
+                        }, propKey.startToken, propValue.endToken);
+                    }
+                    break;
+                }
+                default:
+                    this.reportError("W018");
+                    return null;
+            }
+            if (objD)
+                (_a = result.objectDestruct) === 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;