@ibyar/expressions 0.5.1 → 0.5.6

package/v8/inline.js

@@ -0,0 +1,1973 @@
+import { Token } from './token.js';
+import { TokenStream } from './stream.js';
+import { OfNode, Identifier, ThisNode, GetIdentifier, SetIdentifier, AsyncIdentifier, NullNode, AwaitIdentifier, ConstructorIdentifier, NameIdentifier, EvalIdentifier, ArgumentsIdentifier, TaggedTemplateExpression, TemplateLiteral, SuperIdentifier } from '../api/definition/values.js';
+import { EmptyStatement } from '../api/statement/control/empty.js';
+import { BlockStatement } from '../api/statement/control/block.js';
+import { ArrowFunctionExpression, Param, FunctionExpression, FunctionDeclaration } from '../api/definition/function.js';
+import { IfStatement } from '../api/statement/control/if.js';
+import { NewExpression } from '../api/computing/new.js';
+import { SpreadElement } from '../api/computing/spread.js';
+import { RestElement } from '../api/computing/rest.js';
+import { AssignmentExpression } from '../api/operators/assignment.js';
+import { GroupingExpression } from '../api/operators/grouping.js';
+import { MemberExpression } from '../api/definition/member.js';
+import { BindExpression } from '../api/definition/bind.js';
+import { ObjectExpression, Property, ObjectPattern } from '../api/definition/object.js';
+import { ArrayExpression, ArrayPattern } from '../api/definition/array.js';
+import { CallExpression } from '../api/computing/call.js';
+import { DoWhileNode, WhileNode } from '../api/statement/iterations/while.js';
+import { CatchClauseNode, ThrowStatement, TryCatchNode } from '../api/computing/throw.js';
+import { SwitchCase, DefaultExpression, SwitchStatement } from '../api/statement/control/switch.js';
+import { BreakStatement, ContinueStatement, LabeledStatement } from '../api/statement/control/terminate.js';
+import { ReturnStatement } from '../api/computing/return.js';
+import { YieldExpression } from '../api/computing/yield.js';
+import { VariableDeclarator, VariableDeclarationNode } from '../api/statement/declarations/declares.js';
+import { ForNode, ForOfNode, ForInNode, ForAwaitOfNode } from '../api/statement/iterations/for.js';
+import { ConditionalExpression } from '../api/operators/ternary.js';
+import { PipelineExpression } from '../api/operators/pipeline.js';
+import { LogicalExpression } from '../api/operators/logical.js';
+import { SequenceExpression } from '../api/operators/comma.js';
+import { ChainExpression } from '../api/operators/chaining.js';
+import { ExpressionStatement } from '../api/definition/statement.js';
+import { buildPostfixExpression, buildUnaryExpression, expressionFromLiteral, shortcutNumericLiteralBinaryExpression } from './nodes.js';
+import { AllowLabelledFunctionStatement, FunctionBodyType, FunctionKind, functionKindForImpl, FunctionSyntaxKind, isAsyncFunction, isAsyncGeneratorFunction, isAwaitAsIdentifierDisallowed, isClassMembersInitializerFunction, isGeneratorFunction, isModule, isResumableFunction, isSloppy, isStrict, LanguageMode, ParseFunctionFlag, ParsingArrowHeadFlag, PropertyKind, PropertyKindInfo, PropertyPosition, SubFunctionKind, VariableDeclarationContext } from './enums.js';
+import { DebuggerStatement } from '../api/computing/debugger.js';
+export class AbstractParser {
+    constructor(scanner, acceptIN) {
+        this.scanner = scanner;
+        this.previousAcceptIN = [];
+        this.previousFunctionKind = [];
+        this.previousAcceptIN.push(this.acceptIN = acceptIN ?? false);
+        this.previousFunctionKind.push(this.functionKind = FunctionKind.NormalFunction);
+    }
+    get languageMode() {
+        return this.scanner.getLanguageMode();
+    }
+    set languageMode(mode) {
+        this.scanner.setLanguageMode(mode);
+    }
+    position() {
+        return this.scanner.getPos();
+    }
+    setAcceptIN(acceptIN) {
+        this.previousAcceptIN.push(this.acceptIN);
+        this.acceptIN = acceptIN;
+    }
+    restoreAcceptIN() {
+        this.acceptIN = this.previousAcceptIN.pop() ?? false;
+    }
+    getLastFunctionKind() {
+        return this.previousFunctionKind.at(-2) ?? FunctionKind.NormalFunction;
+    }
+    setFunctionKind(functionKind) {
+        this.previousFunctionKind.push(this.functionKind);
+        this.functionKind = functionKind;
+    }
+    restoreFunctionKind() {
+        this.functionKind = this.previousFunctionKind.pop() ?? FunctionKind.NormalFunction;
+    }
+    setStatue(acceptIN, functionKind) {
+        this.setFunctionKind(functionKind);
+        this.setAcceptIN(acceptIN);
+    }
+    restoreStatue() {
+        this.restoreFunctionKind();
+        this.restoreAcceptIN();
+    }
+    current() {
+        return this.scanner.currentToken();
+    }
+    next() {
+        return this.scanner.next();
+    }
+    peek() {
+        return this.scanner.peek();
+    }
+    peekAhead() {
+        return this.scanner.peekAhead();
+    }
+    peekAheadPosition() {
+        return this.scanner.peekAheadPosition();
+    }
+    peekPosition() {
+        return this.scanner.peekPosition();
+    }
+    consume(token) {
+        if (this.scanner.next().isNotType(token)) {
+            throw new Error(this.errorMessage(`Parsing ${JSON.stringify(token)}`));
+        }
+    }
+    check(token) {
+        const next = this.scanner.peek();
+        if (next.isType(token)) {
+            this.scanner.next();
+            return true;
+        }
+        return false;
+    }
+    checkAndGetValue(token) {
+        const next = this.scanner.peek();
+        if (next.isType(token)) {
+            this.scanner.next();
+            return next.value;
+        }
+        return undefined;
+    }
+    checkValue(value) {
+        const next = this.scanner.peek();
+        if (next.value == value) {
+            this.scanner.next();
+            return true;
+        }
+        return false;
+    }
+    expect(token) {
+        const current = this.scanner.next();
+        if (current.isNotType(token)) {
+            throw new Error(this.errorMessage(`Unexpected Token: ${JSON.stringify(token)}, current is ${JSON.stringify(current)}`));
+        }
+    }
+    expectAndGetValue(token) {
+        const current = this.scanner.next();
+        if (current.isNotType(token)) {
+            throw new Error(this.errorMessage(`Unexpected Token: ${JSON.stringify(token)}, current is ${JSON.stringify(current)}`));
+        }
+        return current.getValue();
+    }
+    checkInOrOf() {
+        if (this.check(Token.IN)) {
+            return 'IN';
+        }
+        else if (this.checkValue(OfNode)) {
+            return 'OF';
+        }
+        return false;
+    }
+    peekInOrOf() {
+        var next = this.peek();
+        if (next.isType(Token.IN)) {
+            return 'IN';
+        }
+        else if (next.value === OfNode) {
+            return 'OF';
+        }
+        return false;
+    }
+    isArguments(name) {
+        return name instanceof Identifier && name.getName() === 'arguments';
+    }
+    isEval(name) {
+        return name instanceof Identifier && name.getName() === 'eval';
+    }
+    isEvalOrArguments(name) {
+        return name instanceof Identifier && (name.getName() === 'eval' || name.getName() === 'arguments');
+    }
+    isNextLetKeyword() {
+        if (this.peek().isNotType(Token.LET)) {
+            return false;
+        }
+        const nextNextToken = this.peekAhead().token;
+        switch (nextNextToken) {
+            case Token.LBRACE:
+            case Token.LBRACK:
+            case Token.IDENTIFIER:
+            case Token.STATIC:
+            case Token.LET:
+            case Token.YIELD:
+            case Token.AWAIT:
+            case Token.GET:
+            case Token.SET:
+            case Token.ASYNC:
+                return true;
+            default:
+                return false;
+        }
+    }
+    isIdentifier(expression) {
+        return expression instanceof Identifier;
+    }
+    markParenthesized(expression) {
+        Reflect.set(expression, 'parenthesized', true);
+    }
+    clearParenthesized(expression) {
+        Reflect.deleteProperty(expression, 'parenthesized');
+    }
+    isParenthesized(expression) {
+        return Reflect.get(expression, 'parenthesized') === true;
+    }
+    isAssignableIdentifier(expression) {
+        if (!(expression instanceof Identifier)) {
+            return false;
+        }
+        if (isStrict(this.languageMode) && this.isEvalOrArguments(expression)) {
+            return false;
+        }
+        return true;
+    }
+    isPattern(expression) {
+        return expression instanceof ObjectExpression || expression instanceof ArrayExpression;
+    }
+    isProperty(expression) {
+        return expression instanceof Property || expression instanceof MemberExpression;
+    }
+    isCallNew(expression) {
+        return expression instanceof NewExpression;
+    }
+    isCall(expression) {
+        return expression instanceof CallExpression;
+    }
+    isEmptyStatement(expression) {
+        return expression instanceof EmptyStatement;
+    }
+    isValidReferenceExpression(expression) {
+        return this.isAssignableIdentifier(expression) || this.isProperty(expression);
+    }
+    expectSemicolon() {
+        const tok = this.peek();
+        if (tok.isType(Token.SEMICOLON)) {
+            this.next();
+            return;
+        }
+        if (this.scanner.hasLineTerminatorBeforeNext() || Token.isAutoSemicolon(tok.token)) {
+            return;
+        }
+        if (this.scanner.currentToken().isType(Token.AWAIT) && !isAsyncFunction(this.functionKind)) {
+            throw new Error(this.errorMessage(`Await Not In Async Context/Function`));
+        }
+    }
+    peekAnyIdentifier() {
+        return Token.isAnyIdentifier(this.peek().token);
+    }
+    expectContextualKeyword(keyword) {
+        const current = this.scanner.next();
+        if (!current.test((token, value) => Token.IDENTIFIER.equal(token) && keyword === value?.toString())) {
+            throw new Error(this.errorMessage(`Unexpected Token: current Token is ${JSON.stringify(current)}`));
+        }
+        return true;
+    }
+    checkContextualKeyword(keyword) {
+        const next = this.scanner.peek();
+        if (next.test((token, value) => Token.IDENTIFIER.equal(token) && keyword === value?.toString())) {
+            this.scanner.next();
+            return true;
+        }
+        return false;
+    }
+    peekContextualKeyword(keyword) {
+        const next = this.scanner.peek();
+        return next.test((token, value) => Token.IDENTIFIER.equal(token) && keyword === value?.toString());
+    }
+    methodKindFor(isStatic, flag) {
+        return functionKindForImpl(isStatic ? SubFunctionKind.StaticMethod : SubFunctionKind.NonStaticMethod, flag);
+    }
+    isGenerator() {
+        return isGeneratorFunction(this.functionKind);
+    }
+    isAsyncFunction() {
+        return isAsyncFunction(this.functionKind);
+    }
+    is_async_function() {
+        return isAsyncFunction(this.functionKind);
+    }
+    is_async_generator() {
+        return isAsyncGeneratorFunction(this.functionKind);
+    }
+    is_resumable() {
+        return isResumableFunction(this.functionKind);
+    }
+    isAwaitAllowed() {
+        return this.isAsyncFunction() || isModule(this.functionKind);
+    }
+    isAwaitAsIdentifierDisallowed() {
+        return isStrict(this.languageMode) ||
+            isAwaitAsIdentifierDisallowed(this.functionKind);
+    }
+    shouldBanArguments() {
+        return isClassMembersInitializerFunction(this.functionKind);
+    }
+    errorMessage(message) {
+        return this.scanner.createError(message);
+    }
+    reportErrorMessage(message) {
+        console.error(this.scanner.createError(message));
+    }
+}
+export class JavaScriptInlineParser extends AbstractParser {
+    static parse(source, { mode, acceptIN } = {}) {
+        mode ?? (mode = LanguageMode.Strict);
+        const stream = (typeof source === 'string')
+            ? TokenStream.getTokenStream(source, mode)
+            : Array.isArray(source) ? TokenStream.getTokenStream(source) : source;
+        acceptIN ?? (acceptIN = false);
+        const parser = new JavaScriptInlineParser(stream, acceptIN);
+        return parser.scan();
+    }
+    constructor(scanner, acceptIN) {
+        super(scanner, acceptIN);
+    }
+    scan() {
+        const list = this.parseStatementList(Token.EOS);
+        if (list.length === 1) {
+            return list[0];
+        }
+        return new ExpressionStatement(list);
+    }
+    parseStatement(allowFunction = AllowLabelledFunctionStatement.DisallowLabelledFunctionStatement) {
+        switch (this.peek().token) {
+            case Token.LBRACE:
+                return this.parseBlock();
+            case Token.SEMICOLON:
+                this.consume(Token.SEMICOLON);
+                return EmptyStatement.INSTANCE;
+            case Token.IF:
+                return this.parseIfStatement();
+            case Token.DO:
+                return this.parseDoWhileStatement();
+            case Token.WHILE:
+                return this.parseWhileStatement();
+            case Token.FOR:
+                if (this.isAwaitAllowed() && this.peekAhead().isType(Token.AWAIT)) {
+                    return this.parseForAwaitStatement();
+                }
+                return this.parseForStatement();
+            case Token.CONTINUE:
+                return this.parseContinueStatement();
+            case Token.BREAK:
+                return this.parseBreakStatement();
+            case Token.RETURN:
+                return this.parseReturnStatement();
+            case Token.THROW:
+                return this.parseThrowStatement();
+            case Token.TRY:
+                return this.parseTryStatement();
+            case Token.SWITCH:
+                return this.parseSwitchStatement();
+            case Token.FUNCTION:
+                throw new SyntaxError(this.errorMessage(`FunctionDeclaration only allowed as a StatementListItem not in an arbitrary Statement position.`));
+            case Token.DEBUGGER:
+                return this.parseDebuggerStatement();
+            case Token.VAR:
+                return this.parseVariableDeclarations(VariableDeclarationContext.Statement);
+            case Token.ASYNC:
+                if (!this.scanner.hasLineTerminatorAfterNext() && this.peekAhead().isType(Token.FUNCTION)) {
+                    throw new SyntaxError(this.errorMessage(`async function in single statement context.`));
+                }
+            default:
+                return this.parseExpressionOrLabelledStatement(allowFunction);
+        }
+    }
+    parseDebuggerStatement() {
+        this.consume(Token.DEBUGGER);
+        this.expectSemicolon();
+        return DebuggerStatement.INSTANCE;
+    }
+    parseTryStatement() {
+        this.consume(Token.TRY);
+        const tryBlock = this.parseBlock();
+        let peek = this.peek();
+        if (peek.isNotType(Token.CATCH) && peek.isNotType(Token.FINALLY)) {
+            throw new Error(this.errorMessage(`Uncaught SyntaxError: Missing catch or finally after try`));
+        }
+        let catchBlock;
+        if (this.check(Token.CATCH)) {
+            let identifier;
+            const hasBinding = this.check(Token.LPAREN);
+            if (hasBinding) {
+                if (this.peekAnyIdentifier()) {
+                    identifier = this.parseNonRestrictedIdentifier();
+                }
+                else {
+                    identifier = this.parseBindingPattern(true);
+                }
+                this.expect(Token.RPAREN);
+            }
+            const block = this.parseBlock();
+            catchBlock = new CatchClauseNode(block, identifier);
+        }
+        let finallyBlock;
+        if (this.check(Token.FINALLY)) {
+            finallyBlock = this.parseBlock();
+        }
+        return new TryCatchNode(tryBlock, catchBlock, finallyBlock);
+    }
+    parseNonRestrictedIdentifier() {
+        const result = this.parseIdentifier();
+        if (isStrict(this.languageMode) && this.isEvalOrArguments(result)) {
+            throw new SyntaxError(this.errorMessage('Strict Eval/Arguments '));
+        }
+        return result;
+    }
+    parseBlock() {
+        this.expect(Token.LBRACE);
+        const statements = [];
+        const block = new BlockStatement(statements);
+        while (this.peek().isNotType(Token.RBRACE)) {
+            const stat = this.parseStatementListItem();
+            if (!stat) {
+                return block;
+            }
+            else if (stat instanceof EmptyStatement) {
+                continue;
+            }
+            statements.push(stat);
+        }
+        this.expect(Token.RBRACE);
+        return block;
+    }
+    parseStatementListItem() {
+        switch (this.peek().token) {
+            case Token.FUNCTION:
+                return this.parseHoistableDeclaration(undefined, false);
+            case Token.CLASS:
+                this.consume(Token.CLASS);
+                return this.parseClassDeclaration(undefined, false);
+            case Token.VAR:
+            case Token.CONST:
+                return this.parseVariableDeclarations(VariableDeclarationContext.StatementListItem);
+            case Token.LET:
+                if (this.isNextLetKeyword()) {
+                    return this.parseVariableDeclarations(VariableDeclarationContext.StatementListItem);
+                }
+                break;
+            case Token.ASYNC:
+                if (this.peekAhead().isType(Token.FUNCTION) && !this.scanner.hasLineTerminatorAfterNext()) {
+                    this.consume(Token.ASYNC);
+                    return this.parseAsyncFunctionDeclaration(undefined, false);
+                }
+                break;
+            default:
+                break;
+        }
+        return this.parseStatement(AllowLabelledFunctionStatement.AllowLabelledFunctionStatement);
+    }
+    parseFunctionExpression() {
+        this.consume(Token.FUNCTION);
+        const functionKind = this.check(Token.MUL) ? FunctionKind.GeneratorFunction : FunctionKind.NormalFunction;
+        let name;
+        let functionSyntaxKind = FunctionSyntaxKind.AnonymousExpression;
+        const peek = this.peek();
+        if (peek.isNotType(Token.LPAREN)) {
+            name = this.parseIdentifier(this.getLastFunctionKind());
+            functionSyntaxKind = FunctionSyntaxKind.NamedExpression;
+        }
+        return this.parseFunctionLiteral(functionKind, functionSyntaxKind, name);
+    }
+    parseAsyncFunctionDeclaration(names, defaultExport) {
+        if (this.scanner.hasLineTerminatorBeforeNext()) {
+            throw new SyntaxError(this.errorMessage('Line Terminator Before `function` parsing `async function`.'));
+        }
+        this.consume(Token.FUNCTION);
+        return this.parseHoistableDeclaration01(FunctionKind.AsyncFunction, names, defaultExport);
+    }
+    parseIfStatement() {
+        this.consume(Token.IF);
+        this.consume(Token.LPAREN);
+        const condition = this.parseExpression();
+        this.consume(Token.RPAREN);
+        const thenStatement = this.parseScopedStatement();
+        let elseStatement;
+        if (this.peek().isType(Token.ELSE)) {
+            this.consume(Token.ELSE);
+            elseStatement = this.parseScopedStatement();
+        }
+        return new IfStatement(condition, thenStatement, elseStatement);
+    }
+    parseScopedStatement() {
+        if (isStrict(this.languageMode) || this.peek().isNotType(Token.FUNCTION)) {
+            return this.parseStatement();
+        }
+        else {
+            return this.parseFunctionDeclaration();
+        }
+    }
+    parseDoWhileStatement() {
+        this.consume(Token.DO);
+        const body = this.parseStatement();
+        this.expect(Token.WHILE);
+        this.expect(Token.LPAREN);
+        const condition = this.parseExpression();
+        this.expect(Token.RPAREN);
+        this.check(Token.SEMICOLON);
+        return new DoWhileNode(condition, body);
+    }
+    parseWhileStatement() {
+        this.consume(Token.WHILE);
+        this.expect(Token.LPAREN);
+        const condition = this.parseExpression();
+        this.expect(Token.RPAREN);
+        const body = this.parseStatement();
+        return new WhileNode(condition, body);
+    }
+    parseThrowStatement() {
+        this.consume(Token.THROW);
+        if (this.scanner.hasLineTerminatorBeforeNext()) {
+            throw new Error(this.scanner.createError(`New line After Throw`));
+        }
+        const exception = this.parseExpression();
+        this.expectSemicolon();
+        return new ThrowStatement(exception);
+    }
+    parseSwitchStatement() {
+        this.consume(Token.SWITCH);
+        this.expect(Token.LPAREN);
+        const tag = this.parseExpression();
+        this.expect(Token.RPAREN);
+        const cases = [];
+        const switchStatement = new SwitchStatement(tag, cases);
+        let defaultSeen = false;
+        this.expect(Token.LBRACE);
+        while (this.peek().isNotType(Token.RBRACE)) {
+            const statements = [];
+            let label;
+            if (this.check(Token.CASE)) {
+                label = this.parseExpression();
+            }
+            else {
+                this.expect(Token.DEFAULT);
+                if (defaultSeen) {
+                    throw new Error(this.errorMessage(`Multiple Defaults In Switch`));
+                }
+                defaultSeen = true;
+            }
+            this.expect(Token.COLON);
+            while (this.peek().isNotType(Token.CASE)
+                && this.peek().isNotType(Token.DEFAULT)
+                && this.peek().isNotType(Token.RBRACE)) {
+                const statement = this.parseStatementListItem();
+                if (!statement || this.isEmptyStatement(statement)) {
+                    continue;
+                }
+                statements.push(statement);
+            }
+            const block = new BlockStatement(statements);
+            const clause = defaultSeen ? new DefaultExpression(block) : new SwitchCase(label, block);
+            cases.push(clause);
+        }
+        this.expect(Token.RBRACE);
+        return switchStatement;
+    }
+    parseForStatement() {
+        this.consume(Token.FOR);
+        this.expect(Token.LPAREN);
+        const peek = this.peek();
+        const starts_with_let = peek.isType(Token.LET);
+        if (peek.isType(Token.CONST) || (starts_with_let && this.isNextLetKeyword())) {
+            const initializer = this.parseVariableDeclarations(VariableDeclarationContext.ForStatement);
+            const forMode = this.checkInOrOf();
+            if (forMode) {
+                return this.parseForEachStatementWithDeclarations(initializer, forMode);
+            }
+            this.expect(Token.SEMICOLON);
+            return this.parseStandardForLoopWithLexicalDeclarations(initializer);
+        }
+        let initializer;
+        if (peek.isType(Token.VAR)) {
+            initializer = this.parseVariableDeclarations(VariableDeclarationContext.ForStatement);
+            const forMode = this.checkInOrOf();
+            if (forMode) {
+                return this.parseForEachStatementWithDeclarations(initializer, forMode);
+            }
+        }
+        else if (this.peek().isNotType(Token.SEMICOLON)) {
+            this.setAcceptIN(false);
+            initializer = this.parseExpressionCoverGrammar();
+            this.restoreAcceptIN();
+            const expression_is_async = this.current().isType(Token.ASYNC);
+            const forMode = this.checkInOrOf();
+            if (forMode) {
+                if (forMode === 'OF' && starts_with_let || expression_is_async) {
+                    throw new SyntaxError(this.errorMessage(starts_with_let ? 'For Of Let' : 'For Of Async'));
+                }
+                return this.parseForEachStatementWithoutDeclarations(initializer, forMode);
+            }
+        }
+        this.expect(Token.SEMICOLON);
+        return this.parseStandardForLoop(initializer);
+    }
+    parseStandardForLoopWithLexicalDeclarations(initializer) {
+        return this.parseStandardForLoop(initializer);
+    }
+    parseForEachStatementWithDeclarations(initializer, forMode) {
+        if (initializer.getDeclarations().length != 1) {
+            throw new SyntaxError(this.errorMessage('For In/Of loop Multi Bindings'));
+        }
+        return this.parseForEachStatementWithoutDeclarations(initializer, forMode);
+    }
+    parseForEachStatementWithoutDeclarations(initializer, forMode) {
+        let enumerable;
+        if (forMode == 'OF') {
+            this.setAcceptIN(true);
+            enumerable = this.parseAssignmentExpression();
+            this.restoreAcceptIN();
+        }
+        else {
+            enumerable = this.parseExpression();
+        }
+        this.expect(Token.RPAREN);
+        const body = this.parseStatement();
+        if (forMode === 'OF') {
+            return new ForOfNode(initializer, enumerable, body);
+        }
+        else if (forMode === 'IN') {
+            return new ForInNode(initializer, enumerable, body);
+        }
+        else {
+            throw new Error(this.errorMessage(`parsing for loop: ${this.position()}`));
+        }
+    }
+    parseStandardForLoop(initializer) {
+        let cond = new EmptyStatement();
+        if (this.peek().isNotType(Token.SEMICOLON)) {
+            cond = this.parseExpression();
+        }
+        this.expect(Token.SEMICOLON);
+        let next = new EmptyStatement();
+        if (this.peek().isNotType(Token.RPAREN)) {
+            next = this.parseExpression();
+        }
+        this.expect(Token.RPAREN);
+        const body = this.parseStatement();
+        return new ForNode(body, initializer, cond, next);
+    }
+    parseForAwaitStatement() {
+        if (!this.isAwaitAllowed()) {
+            throw new SyntaxError(this.errorMessage('"await" is not allowed'));
+        }
+        this.expect(Token.FOR);
+        this.expect(Token.AWAIT);
+        this.expect(Token.LPAREN);
+        let hasDeclarations = false;
+        let eachVariable;
+        let peek = this.peek();
+        let startsWithLet = peek.isType(Token.LET);
+        if (peek.isType(Token.VAR) || peek.isType(Token.CONST)
+            || (startsWithLet && this.isNextLetKeyword())) {
+            hasDeclarations = true;
+            const initializer = this.parseVariableDeclarations(VariableDeclarationContext.ForStatement);
+            if (initializer.getDeclarations().length != 1) {
+                throw new SyntaxError(this.errorMessage('For In/Of Loop MultiBindings, "for-await-of"'));
+            }
+            eachVariable = initializer;
+        }
+        else {
+            if (startsWithLet) {
+                throw new SyntaxError(this.errorMessage('The initializer does not contain declarations, For Of Let, "for-await-of"'));
+            }
+            eachVariable = this.parseLeftHandSideExpression();
+        }
+        this.expectContextualKeyword('of');
+        this.setAcceptIN(true);
+        const iterable = this.parseAssignmentExpression();
+        this.restoreAcceptIN();
+        this.expect(Token.RPAREN);
+        const body = this.parseStatement();
+        return new ForAwaitOfNode(eachVariable, iterable, body);
+    }
+    parseVariableDeclarations(varContext) {
+        let mode;
+        const token = this.peek().token;
+        switch (token) {
+            case Token.CONST:
+                this.consume(token);
+                mode = 'const';
+                break;
+            case Token.VAR:
+                this.consume(token);
+                mode = 'var';
+                break;
+            case Token.LET:
+            default:
+                this.consume(token);
+                mode = 'let';
+                break;
+        }
+        const variables = [];
+        do {
+            let name;
+            let value;
+            if (Token.isAnyIdentifier(this.peek().token)) {
+                name = this.parseAndClassifyIdentifier(this.next());
+                if (isStrict(this.languageMode) && this.isEvalOrArguments(name)) {
+                    throw new Error(this.errorMessage(`Strict Eval Arguments`));
+                }
+            }
+            else {
+                name = this.parseBindingPattern(true);
+            }
+            if (this.check(Token.ASSIGN)) {
+                this.setAcceptIN(varContext !== VariableDeclarationContext.ForStatement);
+                value = this.parseAssignmentExpression();
+                this.restoreAcceptIN();
+            }
+            else if (!this.peekInOrOf()) {
+                if (mode === 'const' && (name === undefined || value === undefined)) {
+                    throw new Error(this.errorMessage(`Declaration Missing Initializer`));
+                }
+            }
+            variables.push(new VariableDeclarator(name, value));
+        } while (this.check(Token.COMMA));
+        return new VariableDeclarationNode(variables, mode);
+    }
+    parseBindingPattern(isPattern) {
+        const token = this.peek().token;
+        if (Token.isAnyIdentifier(token)) {
+            const name = this.parseAndClassifyIdentifier(this.next());
+            if (isStrict(this.languageMode) && this.isEvalOrArguments(name)) {
+                throw new Error(this.errorMessage(`Strict Eval Arguments`));
+            }
+            return name;
+        }
+        if (token == Token.LBRACK) {
+            return this.parseArrayLiteral(isPattern);
+        }
+        else if (token == Token.LBRACE) {
+            return this.parseObjectLiteral(isPattern);
+        }
+        else {
+            throw new Error(this.errorMessage(`Unexpected Token: ${this.next().getValue()}`));
+        }
+    }
+    parseAndClassifyIdentifier(next) {
+        if (Token.isInRangeIdentifierAndAsync(next.token)) {
+            const name = next.getValue();
+            if (this.isArguments(name) && this.shouldBanArguments()) {
+                throw new SyntaxError(this.errorMessage('Arguments Disallowed In Initializer And Static Block'));
+            }
+            return name;
+        }
+        if (!Token.isValidIdentifier(next.token, this.languageMode, this.isGenerator(), this.isAwaitAsIdentifierDisallowed())) {
+            throw new SyntaxError(this.errorMessage('Invalid Identifier'));
+        }
+        if (next.isType(Token.AWAIT)) {
+            return next.getValue();
+        }
+        return next.getValue();
+    }
+    parseContinueStatement() {
+        this.consume(Token.CONTINUE);
+        let label;
+        if (!this.scanner.hasLineTerminatorBeforeNext() &&
+            !Token.isAutoSemicolon(this.peek().token)) {
+            label = this.parseIdentifier();
+        }
+        this.expectSemicolon();
+        return label ? new ContinueStatement(label) : ContinueStatement.CONTINUE_INSTANCE;
+    }
+    parseBreakStatement() {
+        this.consume(Token.BREAK);
+        let label;
+        if (!this.scanner.hasLineTerminatorBeforeNext() &&
+            !Token.isAutoSemicolon(this.peek().token)) {
+            label = this.parseIdentifier();
+        }
+        this.expectSemicolon();
+        return label ? new BreakStatement(label) : BreakStatement.BREAK_INSTANCE;
+    }
+    parseReturnStatement() {
+        this.consume(Token.RETURN);
+        const tokenExp = this.peek();
+        let returnValue;
+        if (this.scanner.hasLineTerminatorBeforeNext() || Token.isAutoSemicolon(tokenExp.token)) {
+        }
+        else {
+            returnValue = this.parseExpression();
+        }
+        this.expectSemicolon();
+        return new ReturnStatement(returnValue);
+    }
+    parseExpressionOrLabelledStatement(allowFunction) {
+        switch (this.peek().token) {
+            case Token.FUNCTION:
+            case Token.LBRACE:
+                throw new Error(this.errorMessage(`Unreachable state`));
+            case Token.CLASS:
+                throw new Error(this.errorMessage(`Unexpected Token ${this.next().getValue().toString()}`));
+            case Token.LET: {
+                const nextNext = this.peekAhead();
+                if (nextNext.isNotType(Token.LBRACK) &&
+                    ((nextNext.isNotType(Token.LBRACE) && nextNext.isNotType(Token.IDENTIFIER)))) {
+                    break;
+                }
+                throw new Error(this.errorMessage(`Unexpected Lexical Declaration ${this.position()}`));
+            }
+            default:
+                break;
+        }
+        const startsWithIdentifier = Token.isAnyIdentifier(this.peek().token);
+        this.setAcceptIN(true);
+        const expression = this.parseExpressionCoverGrammar();
+        if (this.peek().isType(Token.COLON) && startsWithIdentifier && this.isIdentifier(expression)) {
+            this.consume(Token.COLON);
+            if (this.peek().isType(Token.FUNCTION)
+                && isSloppy(this.languageMode)
+                && allowFunction == AllowLabelledFunctionStatement.AllowLabelledFunctionStatement) {
+                const result = this.parseFunctionDeclaration();
+                this.restoreAcceptIN();
+                return new LabeledStatement(expression, result);
+            }
+            const result = this.parseStatement(allowFunction);
+            this.restoreAcceptIN();
+            return new LabeledStatement(expression, result);
+        }
+        this.restoreAcceptIN();
+        this.expectSemicolon();
+        return expression;
+    }
+    parseExpression() {
+        this.setAcceptIN(true);
+        const result = this.parseExpressionCoverGrammar();
+        this.restoreAcceptIN();
+        return result;
+    }
+    parseFunctionDeclaration() {
+        this.consume(Token.FUNCTION);
+        if (this.check(Token.MUL)) {
+            throw new Error(this.errorMessage(`Error Generator In Single Statement Context`));
+        }
+        return this.parseHoistableDeclaration01(FunctionKind.NormalFunction, undefined, false);
+    }
+    parseAsyncFunctionLiteral() {
+        if (this.current().isNotType(Token.ASYNC)) {
+            throw new SyntaxError(this.errorMessage('invalid token'));
+        }
+        this.consume(Token.FUNCTION);
+        let name;
+        let syntaxKind = FunctionSyntaxKind.AnonymousExpression;
+        let flags = FunctionKind.AsyncFunction;
+        if (this.check(Token.MUL)) {
+            flags = FunctionKind.AsyncGeneratorFunction;
+        }
+        if (this.peekAnyIdentifier()) {
+            syntaxKind = FunctionSyntaxKind.NamedExpression;
+            name = this.parseIdentifier(this.getLastFunctionKind());
+        }
+        return this.parseFunctionLiteral(flags, syntaxKind, name);
+    }
+    parseHoistableDeclaration(names, defaultExport) {
+        this.consume(Token.FUNCTION);
+        let flags = FunctionKind.NormalFunction;
+        if (this.check(Token.MUL)) {
+            flags = FunctionKind.GeneratorFunction;
+        }
+        return this.parseHoistableDeclaration01(flags, names, defaultExport);
+    }
+    parseHoistableDeclaration01(flag, names, defaultExport) {
+        if ((flag & ParseFunctionFlag.IsAsync) != 0 && this.check(Token.MUL)) {
+            flag |= ParseFunctionFlag.IsGenerator;
+        }
+        let name;
+        if (this.peek().isType(Token.LPAREN)) {
+            if (defaultExport) {
+                name = new Identifier('default');
+            }
+            else {
+                throw new SyntaxError(this.errorMessage('Missing Function Name'));
+            }
+        }
+        else {
+            name = this.parseIdentifier(this.getLastFunctionKind());
+        }
+        names?.push(name.toString());
+        return this.parseFunctionLiteral(flag, FunctionSyntaxKind.Declaration, name);
+    }
+    parseIdentifier(kind) {
+        kind ?? (kind = this.functionKind);
+        const next = this.next();
+        if (!Token.isValidIdentifier(next.token, this.languageMode, isGeneratorFunction(kind), isAwaitAsIdentifierDisallowed(kind))) {
+            throw new Error(this.errorMessage(`Unexpected Token: ${next.getValue()}`));
+        }
+        if (next.isType(Token.IDENTIFIER)) {
+            return next.getValue();
+        }
+        return this.getIdentifier();
+    }
+    getIdentifier() {
+        const current = this.current();
+        switch (current.token) {
+            case Token.AWAIT:
+                return AwaitIdentifier;
+            case Token.ASYNC:
+                return AsyncIdentifier;
+            case Token.IDENTIFIER:
+            case Token.PRIVATE_NAME:
+                return current.getValue();
+            default:
+                break;
+        }
+        const name = current.getValue().toString();
+        if (name == 'constructor') {
+            return ConstructorIdentifier;
+        }
+        if (name == 'name') {
+            return NameIdentifier;
+        }
+        if (name == 'eval') {
+            return EvalIdentifier;
+        }
+        else if (name == 'arguments') {
+            return ArgumentsIdentifier;
+        }
+        return current.getValue();
+    }
+    parseFunctionLiteral(flag, functionSyntaxKind, name) {
+        this.setFunctionKind(flag);
+        const functionInfo = {};
+        this.expect(Token.LPAREN);
+        const formals = this.parseFormalParameterList(functionInfo);
+        this.expect(Token.RPAREN);
+        this.expect(Token.LBRACE);
+        this.setAcceptIN(true);
+        const body = this.parseFunctionBody(flag, FunctionBodyType.BLOCK, functionSyntaxKind);
+        this.restoreAcceptIN();
+        this.restoreFunctionKind();
+        const bodyBlock = new BlockStatement(body);
+        if (name) {
+            return new FunctionDeclaration(formals, bodyBlock, isAsyncFunction(flag), isGeneratorFunction(flag), name);
+        }
+        return new FunctionExpression(formals, bodyBlock, isAsyncFunction(flag), isGeneratorFunction(flag));
+    }
+    parseFunctionBody(kind, bodyType, functionSyntaxKind) {
+        let innerBody;
+        if (bodyType == FunctionBodyType.EXPRESSION) {
+            innerBody = this.parseAssignmentExpression();
+        }
+        else {
+            const closing_token = functionSyntaxKind == FunctionSyntaxKind.Wrapped ? Token.EOS : Token.RBRACE;
+            if (isAsyncGeneratorFunction(kind)) {
+                innerBody = this.parseAndRewriteAsyncGeneratorFunctionBody(kind);
+            }
+            else if (isGeneratorFunction(kind)) {
+                innerBody = this.parseAndRewriteGeneratorFunctionBody(kind);
+            }
+            else if (isAsyncFunction(kind)) {
+                innerBody = this.parseAsyncFunctionBody();
+            }
+            else {
+                innerBody = this.parseStatementList(closing_token);
+            }
+            this.expect(closing_token);
+        }
+        return innerBody;
+    }
+    parseAndRewriteAsyncGeneratorFunctionBody(kind) {
+        return this.parseStatementList(Token.RBRACE);
+    }
+    parseAndRewriteGeneratorFunctionBody(kind) {
+        return this.parseStatementList(Token.RBRACE);
+    }
+    parseAsyncFunctionBody() {
+        return this.parseStatementList(Token.RBRACE);
+    }
+    parseStatementList(endToken) {
+        if (this.peek().test((token, value) => Token.STRING === token && 'use strict' === value.getValue())) {
+            this.languageMode = LanguageMode.Strict;
+        }
+        const list = [];
+        while (this.peek().isNotType(endToken)) {
+            const stat = this.parseStatementListItem();
+            if (!stat) {
+                break;
+            }
+            if (this.isEmptyStatement(stat)) {
+                continue;
+            }
+            list.push(stat);
+        }
+        return list;
+    }
+    parseFormalParameterList(functionInfo) {
+        const parameters = [];
+        if (this.peek().isNotType(Token.RPAREN)) {
+            while (true) {
+                const param = this.parseFormalParameter(functionInfo);
+                parameters.push(param);
+                if (functionInfo.rest) {
+                    if (this.peek().isType(Token.COMMA)) {
+                        throw new Error(this.errorMessage(`Param After Rest`));
+                    }
+                    break;
+                }
+                if (!this.check(Token.COMMA))
+                    break;
+                if (this.peek().isType(Token.RPAREN)) {
+                    break;
+                }
+            }
+        }
+        return parameters;
+    }
+    parseFormalParameter(functionInfo) {
+        functionInfo.rest = this.check(Token.ELLIPSIS);
+        let pattern = this.parseBindingPattern(true);
+        let initializer;
+        if (this.check(Token.ASSIGN)) {
+            if (functionInfo.rest) {
+                throw new Error(this.errorMessage(`Rest Default Initializer`));
+            }
+            this.setAcceptIN(true);
+            const value = this.parseAssignmentExpression();
+            this.restoreAcceptIN();
+            initializer = new Param(pattern, value);
+        }
+        else {
+            initializer = new Param(pattern);
+        }
+        return initializer;
+    }
+    parseExpressionCoverGrammar() {
+        const list = [];
+        let expression;
+        while (true) {
+            if (this.peek().isType(Token.ELLIPSIS)) {
+                return this.parseArrowParametersWithRest(list);
+            }
+            expression = this.parseAssignmentExpressionCoverGrammar();
+            list.push(expression);
+            if (!this.check(Token.COMMA))
+                break;
+            if (this.peek().isType(Token.RPAREN) && this.peekAhead().isType(Token.ARROW)) {
+                break;
+            }
+        }
+        if (list.length == 1)
+            return expression;
+        return this.expressionListToExpression(list);
+    }
+    parseArrowParametersWithRest(list) {
+        this.consume(Token.ELLIPSIS);
+        const pattern = this.parseBindingPattern(true);
+        if (this.peek().isType(Token.ASSIGN)) {
+            throw new Error(this.errorMessage(`Error A rest parameter cannot have an initializer`));
+        }
+        if (this.peek().isType(Token.COMMA)) {
+            throw new Error(this.errorMessage(`Error A rest parameter or binding pattern may not have a trailing comma`));
+        }
+        if (this.peek().isNotType(Token.RPAREN) || this.peekAhead().isNotType(Token.ARROW)) {
+            throw new Error(this.errorMessage(`Error Unexpected Token At ${this.position()}`));
+        }
+        list.push(new SpreadElement(pattern));
+        return this.expressionListToExpression(list);
+    }
+    expressionListToExpression(list) {
+        const first = list[0];
+        if (list.length === 1) {
+            return first;
+        }
+        if (first instanceof SequenceExpression) {
+            first.getExpressions().push(...list.slice(1));
+            return first;
+        }
+        return new SequenceExpression(list);
+    }
+    parseMemberExpression() {
+        const result = this.parsePrimaryExpression();
+        return this.parseMemberExpressionContinuation(result);
+    }
+    toParamNode(expression) {
+        if (expression instanceof AssignmentExpression) {
+            return new Param(expression.getLeft(), expression.getRight());
+        }
+        if (expression instanceof GroupingExpression) {
+            return new Param(expression.getNode());
+        }
+        return new Param(expression);
+    }
+    parsePrimaryExpression() {
+        let token = this.peek();
+        if (Token.isAnyIdentifier(token.token)) {
+            this.consume(token.token);
+            let kind = FunctionKind.NormalFunction;
+            if (token.isType(Token.ASYNC) && !this.scanner.hasLineTerminatorBeforeNext()) {
+                if (this.peek().isType(Token.FUNCTION)) {
+                    return this.parseAsyncFunctionLiteral();
+                }
+                ;
+                if (Token.isAnyIdentifier(this.peek().token) && this.peekAhead().isType(Token.ARROW)) {
+                    token = this.next();
+                    kind = FunctionKind.AsyncFunction;
+                }
+            }
+            if (this.peek().isType(Token.ARROW)) {
+                this.setFunctionKind(kind);
+                const name = this.parseAndClassifyIdentifier(token);
+                const params = [];
+                if (name instanceof SequenceExpression) {
+                    params.push(...name.getExpressions().map(this.toParamNode));
+                }
+                else {
+                    params.push(this.toParamNode(name));
+                }
+                const arrow = this.parseArrowFunctionLiteral(params, kind);
+                this.restoreFunctionKind();
+                return arrow;
+            }
+            return this.parseAndClassifyIdentifier(token);
+        }
+        if (Token.isLiteral(token.token)) {
+            return expressionFromLiteral(this.next());
+        }
+        switch (token.token) {
+            case Token.NEW:
+                return this.parseMemberWithPresentNewPrefixesExpression();
+            case Token.THIS:
+                this.consume(Token.THIS);
+                return ThisNode;
+            case Token.DIV:
+            case Token.DIV_ASSIGN:
+                return this.parseRegExpLiteral();
+            case Token.FUNCTION:
+                return this.parseFunctionExpression();
+            case Token.SUPER: {
+                return this.parseSuperExpression();
+            }
+            case Token.IMPORT:
+                return this.parseImportExpressions();
+            case Token.LBRACK:
+                return this.parseArrayLiteral(false);
+            case Token.LBRACE:
+                return this.parseObjectLiteral(false);
+            case Token.LPAREN: {
+                this.consume(Token.LPAREN);
+                if (this.check(Token.RPAREN)) {
+                    if (!this.peek().isType(Token.ARROW)) {
+                        throw new Error(this.errorMessage(`Unexpected Token: ${Token.RPAREN.getName()}`));
+                    }
+                    const result = new SequenceExpression([]);
+                    this.markParenthesized(result);
+                    return result;
+                }
+                this.setAcceptIN(true);
+                const expression = this.parseExpressionCoverGrammar();
+                this.markParenthesized(expression);
+                this.expect(Token.RPAREN);
+                this.restoreAcceptIN();
+                return expression;
+            }
+            case Token.CLASS: {
+                return this.parseClassExpression();
+            }
+            case Token.TEMPLATE_SPAN:
+            case Token.TEMPLATE_TAIL:
+                return this.parseTemplateLiteral();
+            default:
+                break;
+        }
+        throw new Error(this.errorMessage(`Unexpected Token: ${JSON.stringify(this.next())}`));
+    }
+    parseTemplateLiteral(tag) {
+        let next = this.peek();
+        if (!Token.isTemplate(next.token)) {
+            throw new SyntaxError(this.errorMessage(`Unexpected Token: ${JSON.stringify(this.next())}`));
+        }
+        if (next.isType(Token.TEMPLATE_TAIL)) {
+            this.consume(Token.TEMPLATE_TAIL);
+            const string = next.getValue().string;
+            return this.createTemplateLiteralExpressionNode([string], [], tag);
+        }
+        this.consume(Token.TEMPLATE_SPAN);
+        const expressions = [];
+        const strings = [];
+        strings.push(next.getValue().string);
+        do {
+            this.setAcceptIN(true);
+            const expression = this.parseExpressionCoverGrammar();
+            expressions.push(expression);
+            next = this.next();
+            if (next.isNotType(Token.RBRACE)) {
+                this.restoreAcceptIN();
+                throw new SyntaxError(this.errorMessage('Unterminated Template Expr'));
+            }
+            next = this.scanner.scanTemplateContinuation();
+            strings.push(next.getValue().string);
+            this.restoreAcceptIN();
+        } while (next.isType(Token.TEMPLATE_SPAN));
+        if (next.isNotType(Token.TEMPLATE_TAIL)) {
+            throw new SyntaxError(this.errorMessage(`Unexpected Token: ${JSON.stringify(next)}`));
+        }
+        return this.createTemplateLiteralExpressionNode(strings, expressions, tag);
+    }
+    createTemplateLiteralExpressionNode(strings, expressions, tag) {
+        if (tag) {
+            return new TaggedTemplateExpression(tag, strings, expressions);
+        }
+        else {
+            return new TemplateLiteral(strings, expressions);
+        }
+    }
+    parseMemberWithPresentNewPrefixesExpression() {
+        this.consume(Token.NEW);
+        let result;
+        if (this.peek().isType(Token.IMPORT) && this.peekAhead().isType(Token.LPAREN)) {
+            throw new SyntaxError(this.errorMessage(`Import Call Not New Expression`));
+        }
+        else if (this.peek().isType(Token.PERIOD)) {
+            result = this.parseNewTargetExpression();
+            return this.parseMemberExpressionContinuation(result);
+        }
+        else {
+            result = this.parseMemberExpression();
+            if (result === SuperIdentifier) {
+                throw new SyntaxError(this.errorMessage(`Unexpected Super, new super() is never allowed`));
+            }
+        }
+        if (this.peek().isType(Token.LPAREN)) {
+            const args = this.parseArguments();
+            result = new NewExpression(result, args);
+            return this.parseMemberExpressionContinuation(result);
+        }
+        if (this.peek().isType(Token.QUESTION_PERIOD)) {
+            throw new SyntaxError(this.errorMessage(`Optional Chaining with New not allowed,  new x?.y()`));
+        }
+        return new NewExpression(result);
+    }
+    parseArguments(maybeArrow) {
+        this.consume(Token.LPAREN);
+        const args = [];
+        while (this.peek().isNotType(Token.RPAREN)) {
+            const isSpread = this.check(Token.ELLIPSIS);
+            this.setAcceptIN(true);
+            let argument = this.parseAssignmentExpressionCoverGrammar();
+            if (ParsingArrowHeadFlag.MaybeArrowHead === maybeArrow) {
+                if (isSpread) {
+                    if (argument instanceof AssignmentExpression) {
+                        this.restoreAcceptIN();
+                        throw new Error(this.errorMessage(` Rest parameter may not have a default initializer'`));
+                    }
+                    if (this.peek().isType(Token.COMMA)) {
+                        this.restoreAcceptIN();
+                        throw new Error(this.errorMessage(`parsing '...spread,arg =>'`));
+                    }
+                }
+            }
+            if (isSpread) {
+                argument = new SpreadElement(argument);
+            }
+            args.push(argument);
+            this.restoreAcceptIN();
+            if (!this.check(Token.COMMA))
+                break;
+        }
+        if (!this.check(Token.RPAREN)) {
+            throw new Error(this.errorMessage(`parsing arguments call, expecting ')'`));
+        }
+        return args;
+    }
+    parseAssignmentExpressionCoverGrammar() {
+        if (this.peek().isType(Token.YIELD) && isGeneratorFunction(this.functionKind)) {
+            return this.parseYieldExpression();
+        }
+        let expression = this.parseConditionalExpression();
+        const op = this.peek().token;
+        if (!Token.isArrowOrAssignmentOp(op)) {
+            this.clearParenthesized(expression);
+            return expression;
+        }
+        ;
+        if (op === Token.ARROW) {
+            if (!this.isIdentifier(expression) && !this.isParenthesized(expression)) {
+                throw new Error(this.errorMessage(`Malformed Arrow Fun Param List`));
+            }
+            const kind = FunctionKind.NormalFunction;
+            this.setFunctionKind(kind);
+            let arrow;
+            if (expression instanceof SequenceExpression) {
+                const params = expression.getExpressions().map(expr => new Param(expr));
+                const last = params.at(-1)?.getIdentifier();
+                if (last instanceof SpreadElement) {
+                    const arg = last.getArgument();
+                    let param = arg;
+                    if (arg instanceof ArrayExpression) {
+                        param = new ArrayPattern(arg.getElements());
+                    }
+                    else if (arg instanceof ObjectExpression) {
+                        param = new ObjectPattern(arg.getProperties());
+                    }
+                    params[params.length - 1] = new Param(new RestElement(param));
+                }
+                arrow = this.parseArrowFunctionLiteral(params, FunctionKind.NormalFunction);
+            }
+            else if (expression instanceof GroupingExpression) {
+                arrow = this.parseArrowFunctionLiteral([new Param(expression.getNode())], FunctionKind.NormalFunction);
+            }
+            else {
+                this.clearParenthesized(expression);
+                arrow = this.parseArrowFunctionLiteral([new Param(expression)], FunctionKind.NormalFunction);
+            }
+            this.restoreFunctionKind();
+            return arrow;
+        }
+        if (this.isAssignableIdentifier(expression)) {
+        }
+        else if (this.isProperty(expression)) {
+        }
+        else if (this.isPattern(expression) && Token.isAssignment(op)) {
+            expression = expression instanceof ObjectExpression
+                ? new ObjectPattern(expression.getProperties())
+                : new ArrayPattern(expression.getElements());
+        }
+        else {
+            if (!this.isValidReferenceExpression(expression)) {
+                throw new Error(this.errorMessage(`Invalid Reference Expression`));
+            }
+            if (Token.isLogicalAssignmentOp(op)) {
+                throw new Error(this.errorMessage(`Invalid Lhs In Assignment`));
+            }
+        }
+        this.consume(op);
+        const right = this.parseAssignmentExpression();
+        if (!Token.isAssignment(op)) {
+            throw new Error(this.errorMessage(`Invalid Destructuring Target`));
+        }
+        return new AssignmentExpression(op.getName(), expression, right);
+    }
+    parseAssignmentExpression() {
+        return this.parseAssignmentExpressionCoverGrammar();
+    }
+    parseArrowFunctionLiteral(parameters, kind) {
+        if (this.peek().isNotType(Token.ARROW)) {
+            throw new SyntaxError(this.errorMessage('SyntaxError Expecting Arrow Token'));
+        }
+        if (this.scanner.hasLineTerminatorBeforeNext()) {
+            throw new SyntaxError(this.errorMessage('Unexpected Token "\n" a line terminator after arrow token"'));
+        }
+        let body;
+        let has_braces = true;
+        this.consume(Token.ARROW);
+        if (this.peek().isType(Token.LBRACE)) {
+            this.consume(Token.LBRACE);
+            this.setStatue(true, kind);
+            body = this.parseFunctionBody(kind, FunctionBodyType.BLOCK, FunctionSyntaxKind.AnonymousExpression);
+            this.restoreStatue();
+        }
+        else {
+            has_braces = false;
+            body = this.parseFunctionBody(kind, FunctionBodyType.EXPRESSION, FunctionSyntaxKind.AnonymousExpression);
+        }
+        return new ArrowFunctionExpression(parameters, body, !has_braces, isAsyncFunction(kind));
+    }
+    parseRegExpLiteral() {
+        if (!this.scanner.scanRegExpPattern()) {
+            throw new Error('Unterminated RegExp');
+        }
+        return this.scanner.currentToken().getValue();
+    }
+    parseArrayLiteral(isPattern) {
+        this.consume(Token.LBRACK);
+        let first_spread_index = -1;
+        const values = [];
+        while (!this.check(Token.RBRACK)) {
+            let elem;
+            if (this.peek().isType(Token.COMMA)) {
+                elem = null;
+            }
+            else if (this.check(Token.ELLIPSIS)) {
+                this.setAcceptIN(true);
+                const argument = this.parsePossibleDestructuringSubPattern();
+                this.restoreAcceptIN();
+                elem = new SpreadElement(argument);
+                if (first_spread_index < 0) {
+                    first_spread_index = values.length;
+                }
+                if (argument instanceof AssignmentExpression && isPattern) {
+                    throw new SyntaxError(this.errorMessage('Invalid Destructuring Target'));
+                }
+                if (this.peek().isType(Token.COMMA)) {
+                    throw new SyntaxError(this.errorMessage('Element After Rest'));
+                }
+            }
+            else {
+                this.setAcceptIN(true);
+                elem = this.parsePossibleDestructuringSubPattern();
+                this.restoreAcceptIN();
+            }
+            values.push(elem);
+            if (this.peek().isNotType(Token.RBRACK)) {
+                this.expect(Token.COMMA);
+            }
+        }
+        return new (isPattern ? ArrayPattern : ArrayExpression)(values);
+    }
+    parsePossibleDestructuringSubPattern() {
+        return this.parseAssignmentExpressionCoverGrammar();
+    }
+    parseObjectLiteral(isPattern) {
+        this.consume(Token.LBRACE);
+        const properties = [];
+        while (!this.check(Token.RBRACE)) {
+            const property = this.parseObjectPropertyDefinition(isPattern);
+            properties.push(property);
+            if (this.peek().isNotType(Token.RBRACE)) {
+                this.expect(Token.COMMA);
+            }
+        }
+        if (isPattern) {
+            return new ObjectPattern(properties);
+        }
+        return new ObjectExpression(properties);
+    }
+    parseObjectPropertyDefinition(isPattern) {
+        const propInfo = new PropertyKindInfo();
+        const nameExpression = this.parseProperty(propInfo);
+        switch (propInfo.kind) {
+            case PropertyKind.Spread:
+                let value = nameExpression;
+                if (isPattern) {
+                    value = new RestElement(value.getArgument());
+                }
+                return new Property(value.getArgument(), value, 'init', false, false, propInfo.isComputedName);
+            case PropertyKind.Value: {
+                this.consume(Token.COLON);
+                this.setAcceptIN(true);
+                const value = this.parsePossibleDestructuringSubPattern();
+                this.restoreAcceptIN();
+                return new Property(nameExpression, value, 'init', false, false, propInfo.isComputedName);
+            }
+            case PropertyKind.Assign:
+            case PropertyKind.ShorthandOrClassField:
+            case PropertyKind.Shorthand: {
+                const lhs = new Identifier(propInfo.name);
+                if (!this.isAssignableIdentifier(lhs)) {
+                    throw new Error(this.errorMessage('Strict Eval Arguments'));
+                }
+                let value;
+                if (this.peek().isType(Token.ASSIGN)) {
+                    this.consume(Token.ASSIGN);
+                    this.setAcceptIN(true);
+                    const rhs = this.parseAssignmentExpression();
+                    this.restoreAcceptIN();
+                    value = new AssignmentExpression(Token.ASSIGN.getName(), lhs, rhs);
+                }
+                else {
+                    value = lhs;
+                }
+                return new Property(nameExpression, value, 'init', false, propInfo.kind !== PropertyKind.Assign, propInfo.isComputedName);
+            }
+            case PropertyKind.Method: {
+                const kind = this.methodKindFor(propInfo.isStatic, propInfo.funcFlag);
+                const value = this.parseFunctionLiteral(kind, FunctionSyntaxKind.AccessorOrMethod, propInfo.name ? new Identifier(propInfo.name) : undefined);
+                return new Property(nameExpression, value, 'init', true, false, propInfo.isComputedName);
+            }
+            case PropertyKind.AccessorGetter:
+            case PropertyKind.AccessorSetter: {
+                const isGet = propInfo.kind == PropertyKind.AccessorGetter;
+                const kind = this.methodKindFor(propInfo.isStatic, propInfo.funcFlag);
+                const value = this.parseFunctionLiteral(kind, FunctionSyntaxKind.AccessorOrMethod, propInfo.name ? new Identifier(propInfo.name) : undefined);
+                return new Property(nameExpression, value, isGet ? 'get' : 'set', false, false, propInfo.isComputedName);
+            }
+            case PropertyKind.ClassField:
+            case PropertyKind.NotSet:
+                return NullNode;
+        }
+    }
+    parseProperty(propInfo) {
+        let nextToken = this.peek();
+        if (this.check(Token.ASYNC)) {
+            nextToken = this.peek();
+            if (nextToken.isNotType(Token.MUL)
+                && propInfo.parsePropertyKindFromToken(nextToken.token)
+                || this.scanner.hasLineTerminatorBeforeNext()) {
+                return AsyncIdentifier;
+            }
+            propInfo.kind = PropertyKind.Method;
+            propInfo.funcFlag = ParseFunctionFlag.IsAsync;
+        }
+        if (this.check(Token.MUL)) {
+            propInfo.kind = PropertyKind.Method;
+            propInfo.funcFlag = ParseFunctionFlag.IsGenerator;
+        }
+        nextToken = this.peek();
+        if (propInfo.kind == PropertyKind.NotSet && nextToken.isType(Token.GET) || nextToken.isType(Token.SET)) {
+            const token = this.next();
+            if (propInfo.parsePropertyKindFromToken(this.peek().token)) {
+                return nextToken.isType(Token.GET) ? GetIdentifier : SetIdentifier;
+            }
+            if (token.isType(Token.GET)) {
+                propInfo.kind = PropertyKind.AccessorGetter;
+            }
+            else if (token.isType(Token.SET)) {
+                propInfo.kind = PropertyKind.AccessorSetter;
+            }
+            nextToken = this.peek();
+        }
+        let propertyName;
+        switch (nextToken.token) {
+            case Token.PRIVATE_NAME:
+                propInfo.isPrivate = true;
+                this.consume(Token.PRIVATE_NAME);
+                if (propInfo.kind == PropertyKind.NotSet) {
+                    propInfo.parsePropertyKindFromToken(this.peek().token);
+                }
+                propertyName = this.getIdentifier();
+                propInfo.name = propertyName.getName();
+                if (propInfo.position == PropertyPosition.ObjectLiteral) {
+                    throw new TypeError(this.errorMessage('UnexpectedToken PRIVATE_NAME'));
+                }
+                break;
+            case Token.STRING:
+            case Token.NUMBER:
+            case Token.BIGINT:
+                this.consume(nextToken.token);
+                propertyName = nextToken.getValue();
+                propInfo.name = propertyName.getValue();
+                break;
+            case Token.LBRACK:
+                this.consume(Token.LBRACK);
+                this.setAcceptIN(true);
+                propertyName = this.parseAssignmentExpression();
+                this.expect(Token.RBRACK);
+                if (propInfo.kind === PropertyKind.NotSet) {
+                    propInfo.parsePropertyKindFromToken(this.peek().token);
+                }
+                propInfo.name = propertyName.toString();
+                this.restoreAcceptIN();
+                return propertyName;
+            case Token.ELLIPSIS:
+                if (propInfo.kind == PropertyKind.NotSet) {
+                    this.consume(Token.ELLIPSIS);
+                    this.setAcceptIN(true);
+                    propertyName = this.parsePossibleDestructuringSubPattern();
+                    propInfo.kind = PropertyKind.Spread;
+                    if (!this.isValidReferenceExpression(propertyName)) {
+                        throw new Error(this.errorMessage('Invalid Rest Binding/Assignment Pattern'));
+                    }
+                    if (this.peek().isNotType(Token.RBRACE)) {
+                        throw new Error(this.errorMessage('Element After Rest'));
+                    }
+                    propInfo.name = propertyName.toString();
+                    this.restoreAcceptIN();
+                    return new SpreadElement(propertyName);
+                }
+            default:
+                propertyName = this.parsePropertyOrPrivatePropertyName();
+                propInfo.name = propertyName.toString();
+                break;
+        }
+        if (propInfo.kind === PropertyKind.NotSet) {
+            propInfo.parsePropertyKindFromToken(this.peek().token);
+        }
+        return propertyName;
+    }
+    parseMemberExpressionContinuation(expression) {
+        if (!Token.isMember(this.peek().token))
+            return expression;
+        return this.doParseMemberExpressionContinuation(expression);
+    }
+    doParseMemberExpressionContinuation(expression) {
+        if (!Token.isMember(this.peek().token)) {
+            throw new Error(this.errorMessage(`Parsing member expression`));
+        }
+        do {
+            switch (this.peek().token) {
+                case Token.LBRACK: {
+                    this.consume(Token.LBRACK);
+                    this.setAcceptIN(true);
+                    const index = this.parseExpressionCoverGrammar();
+                    expression = new MemberExpression(expression, index, true);
+                    this.expect(Token.RBRACK);
+                    this.restoreAcceptIN();
+                    break;
+                }
+                case Token.PERIOD: {
+                    this.consume(Token.PERIOD);
+                    const key = this.parsePropertyOrPrivatePropertyName();
+                    expression = new MemberExpression(expression, key, false);
+                    break;
+                }
+                case Token.TEMPLATE_SPAN:
+                case Token.TEMPLATE_TAIL: {
+                    expression = this.parseTemplateLiteral(expression);
+                    break;
+                }
+                default:
+                    throw new SyntaxError(this.errorMessage('unknown token position'));
+            }
+        } while (Token.isMember(this.peek().token));
+        return expression;
+    }
+    parsePropertyOrPrivatePropertyName() {
+        const next = this.next();
+        if (next.isType(Token.IDENTIFIER) || next.isType(Token.PRIVATE_NAME)) {
+            return next.getValue();
+        }
+        if (Token.isPropertyName(next.token) && next.isNotType(Token.EOS)) {
+            return new Identifier(next.token.getName());
+        }
+        throw new SyntaxError(this.errorMessage(`Parsing property expression: Unexpected Token`));
+    }
+    parsePipelineExpression(expression) {
+        let token;
+        while (Token.isPipelineOperator(token = this.peek().token)) {
+            this.consume(token);
+            expression = this.parsePipelineBody(expression);
+        }
+        return expression;
+    }
+    parsePipelineBody(lhs) {
+        let body;
+        let token = this.peek();
+        switch (token.token) {
+            case Token.FUNCTION:
+                body = this.parseFunctionExpression();
+                break;
+            case Token.ASYNC:
+                this.consume(Token.ASYNC);
+                body = this.parseAsyncFunctionLiteral();
+                break;
+            default:
+                break;
+        }
+        if (body) {
+            return new PipelineExpression(lhs, body);
+        }
+        if (token.isType(Token.LPAREN)) {
+            body = this.parsePrimaryExpression();
+            return new PipelineExpression(lhs, body);
+        }
+        const func = this.parseMemberExpression();
+        let args = [];
+        switch (this.peek().token) {
+            case Token.COLON:
+                do {
+                    this.consume(Token.COLON);
+                    const isSpread = this.check(Token.ELLIPSIS);
+                    if (this.peek().isType(Token.CONDITIONAL)) {
+                        this.consume(Token.CONDITIONAL);
+                        if (isSpread) {
+                            args.push('...?');
+                        }
+                        else {
+                            args.push('?');
+                        }
+                    }
+                    else {
+                        const arg = this.parseAssignmentExpressionCoverGrammar();
+                        if (isSpread) {
+                            args.push(new SpreadElement(arg));
+                        }
+                        else {
+                            args.push(arg);
+                        }
+                    }
+                } while (this.peek().isType(Token.COLON));
+                break;
+            case Token.LPAREN:
+                this.consume(Token.LPAREN);
+                let indexed = false;
+                while (this.peek().isNotType(Token.RPAREN)) {
+                    const isSpread = this.check(Token.ELLIPSIS);
+                    if (this.peek().isType(Token.CONDITIONAL)) {
+                        this.consume(Token.CONDITIONAL);
+                        indexed = true;
+                        if (isSpread) {
+                            args.push('...?');
+                        }
+                        else {
+                            args.push('?');
+                        }
+                    }
+                    else {
+                        const arg = this.parseAssignmentExpressionCoverGrammar();
+                        if (isSpread) {
+                            args.push(new SpreadElement(arg));
+                        }
+                        else {
+                            args.push(arg);
+                        }
+                    }
+                    this.check(Token.COMMA);
+                }
+                this.expect(Token.RPAREN);
+                if (!indexed) {
+                    body = new CallExpression(func, args);
+                    return new PipelineExpression(lhs, body);
+                }
+                break;
+            default:
+                break;
+        }
+        return new PipelineExpression(lhs, func, args);
+    }
+    parseConditionalExpression() {
+        let expression = this.parseLogicalExpression();
+        expression = this.parsePipelineExpression(expression);
+        return this.peek().isType(Token.CONDITIONAL) ? this.parseConditionalContinuation(expression) : expression;
+    }
+    parseLogicalExpression() {
+        let expression = this.parseBinaryExpression(6);
+        const peek = this.peek();
+        if (peek.isType(Token.AND) || peek.isType(Token.OR)) {
+            const precedence = Token.precedence(peek.token, this.acceptIN);
+            expression = this.parseBinaryContinuation(expression, 4, precedence);
+        }
+        else if (peek.isType(Token.NULLISH)) {
+            expression = this.parseNullishExpression(expression);
+        }
+        return expression;
+    }
+    parseBinaryContinuation(x, prec, prec1) {
+        do {
+            while (Token.precedence(this.peek().token, this.acceptIN) === prec1) {
+                let y;
+                let op = this.next();
+                const is_right_associative = op.isType(Token.EXP);
+                const next_prec = is_right_associative ? prec1 : prec1 + 1;
+                y = this.parseBinaryExpression(next_prec);
+                if (Token.isCompare(op.token)) {
+                    let cmp = op.token;
+                    switch (op.token) {
+                        case Token.NE:
+                            cmp = Token.EQ;
+                            break;
+                        case Token.NE_STRICT:
+                            cmp = Token.EQ_STRICT;
+                            break;
+                        default: break;
+                    }
+                    x = shortcutNumericLiteralBinaryExpression(x, y, cmp);
+                    if (op.isNotType(cmp)) {
+                        x = buildUnaryExpression(x, Token.NOT);
+                    }
+                }
+                else {
+                    x = shortcutNumericLiteralBinaryExpression(x, y, op.token);
+                }
+            }
+            --prec1;
+        } while (prec1 >= prec);
+        return x;
+    }
+    parseBinaryExpression(precedence) {
+        if (this.peek().isType(Token.PRIVATE_NAME)) {
+            const x = this.parsePropertyOrPrivatePropertyName();
+            const precedence1 = Token.precedence(this.peek().token, this.acceptIN);
+            if (this.peek().isNotType(Token.IN) || precedence1 < precedence) {
+                throw new SyntaxError(this.errorMessage('Unexpected Token Token.PRIVATE_NAME "#name"'));
+            }
+            return this.parseBinaryContinuation(x, precedence, precedence1);
+        }
+        const x = this.parseUnaryExpression();
+        const precedence1 = Token.precedence(this.peek().token, this.acceptIN);
+        if (precedence1 >= precedence) {
+            return this.parseBinaryContinuation(x, precedence, precedence1);
+        }
+        return x;
+    }
+    parseUnaryExpression() {
+        const op = this.peek();
+        if (Token.isUnaryOrCount(op.token)) {
+            return this.parseUnaryOrPrefixExpression();
+        }
+        if (op.isType(Token.AWAIT) && this.isAwaitAllowed()) {
+            return this.parseAwaitExpression();
+        }
+        return this.parsePostfixExpression();
+    }
+    parseUnaryOrPrefixExpression() {
+        const op = this.next();
+        const expression = this.parseUnaryExpression();
+        if (Token.isUnary(op.token)) {
+            if (op.isType(Token.DELETE)) {
+                if (this.isIdentifier(expression) && isStrict(this.languageMode)) {
+                    throw new Error(this.errorMessage(`"delete identifier" is a syntax error in strict mode`));
+                }
+                if (expression instanceof MemberExpression && expression.getProperty().toString().startsWith('#')) {
+                    throw new Error(this.errorMessage(`"Delete Private Field" is a syntax error`));
+                }
+            }
+            if (this.peek().isType(Token.EXP)) {
+                throw new Error(this.errorMessage(`Unexpected Token Unary Exponentiation`));
+            }
+        }
+        if (Token.isCount(op.token) || Token.isUnary(op.token)) {
+            return buildUnaryExpression(expression, op.token);
+        }
+        throw new Error(this.errorMessage(`while rewrite unary operation`));
+    }
+    parsePostfixExpression() {
+        const expression = this.parseLeftHandSideExpression();
+        if (!Token.isCount(this.peek().token) || this.scanner.hasLineTerminatorBeforeNext()) {
+            return expression;
+        }
+        return this.parsePostfixContinuation(expression);
+    }
+    parsePostfixContinuation(expression) {
+        if (!this.isValidReferenceExpression(expression)) {
+            throw new Error(this.errorMessage(`Invalid LHS In Postfix Op.`));
+        }
+        const op = this.next();
+        return buildPostfixExpression(expression, op.token);
+    }
+    parseLeftHandSideExpression() {
+        const result = this.parseMemberExpression();
+        if (!Token.isPropertyOrCall(this.peek().token))
+            return result;
+        return this.parseLeftHandSideContinuation(result);
+    }
+    parseLeftHandSideContinuation(result) {
+        if (this.peek().isType(Token.LPAREN)
+            && this.isIdentifier(result)
+            && this.scanner.currentToken().isType(Token.ASYNC)
+            && !this.scanner.hasLineTerminatorBeforeNext()) {
+            const args = this.parseArguments(ParsingArrowHeadFlag.AsyncArrowFunction);
+            if (this.peek().isType(Token.ARROW)) {
+                if (!args.length)
+                    return new EmptyStatement;
+                return this.expressionListToExpression(args);
+            }
+            result = new CallExpression(result, args);
+            if (!Token.isPropertyOrCall(this.peek().token))
+                return result;
+        }
+        let optionalChaining = false;
+        let isOptional = false;
+        do {
+            switch (this.peek().token) {
+                case Token.QUESTION_PERIOD: {
+                    if (isOptional) {
+                        throw new Error(this.errorMessage(`Failure Expression`));
+                    }
+                    this.consume(Token.QUESTION_PERIOD);
+                    isOptional = true;
+                    optionalChaining = true;
+                    if (Token.isPropertyOrCall(this.peek().token))
+                        continue;
+                    const key = this.parsePropertyOrPrivatePropertyName();
+                    result = new MemberExpression(result, key, false, isOptional);
+                    break;
+                }
+                case Token.LBRACK: {
+                    this.consume(Token.LBRACK);
+                    this.setAcceptIN(true);
+                    const index = this.parseExpressionCoverGrammar();
+                    this.restoreAcceptIN();
+                    result = new MemberExpression(result, index, true, isOptional);
+                    this.expect(Token.RBRACK);
+                    break;
+                }
+                case Token.PERIOD: {
+                    if (isOptional) {
+                        throw new Error(this.errorMessage(`Unexpected Token:${this.position()}`));
+                    }
+                    this.consume(Token.PERIOD);
+                    const key = this.parsePropertyOrPrivatePropertyName();
+                    result = new MemberExpression(result, key, false, isOptional);
+                    break;
+                }
+                case Token.LPAREN: {
+                    const args = this.parseArguments();
+                    result = new CallExpression(result, args, isOptional);
+                    break;
+                }
+                case Token.BIND: {
+                    if (isOptional) {
+                        throw new Error(this.errorMessage(`Unexpected Token:${this.position()}`));
+                    }
+                    this.consume(Token.BIND);
+                    const key = this.parsePropertyOrPrivatePropertyName();
+                    result = new BindExpression(result, key, false, isOptional);
+                    break;
+                }
+                case Token.QUESTION_BIND: {
+                    if (isOptional) {
+                        throw new Error(this.errorMessage(`Failure Expression`));
+                    }
+                    this.consume(Token.QUESTION_BIND);
+                    isOptional = true;
+                    optionalChaining = true;
+                    const key = this.parsePropertyOrPrivatePropertyName();
+                    result = new BindExpression(result, key, true, isOptional);
+                    break;
+                }
+                default:
+                    if (optionalChaining) {
+                        throw new Error(this.errorMessage(`Optional Chaining No Template support`));
+                    }
+                    result = this.parseTemplateLiteral(result);
+                    break;
+            }
+            if (isOptional) {
+                isOptional = false;
+            }
+        } while (Token.isPropertyOrCall(this.peek().token));
+        if (optionalChaining) {
+            result = new ChainExpression(result);
+        }
+        return result;
+    }
+    parseAwaitExpression() {
+        this.consume(Token.AWAIT);
+        const value = this.parseUnaryExpression();
+        if (this.peek().isType(Token.EXP)) {
+            throw new Error(this.scanner.createError(`Unexpected Token Unary Exponentiation`));
+        }
+        return buildUnaryExpression(value, Token.AWAIT);
+    }
+    parseNullishExpression(expression) {
+        const list = [];
+        list.push(expression);
+        while (this.peek().isType(Token.NULLISH)) {
+            this.consume(Token.NULLISH);
+            expression = this.parseBinaryExpression(6);
+            list.push(expression);
+        }
+        expression = list.pop();
+        expression = list.reverse()
+            .reduce((previous, current) => new LogicalExpression(Token.NULLISH.getName(), current, previous), expression);
+        return expression;
+    }
+    parseConditionalContinuation(expression) {
+        this.consume(Token.CONDITIONAL);
+        this.setAcceptIN(true);
+        const left = this.parseAssignmentExpression();
+        this.restoreAcceptIN();
+        this.expect(Token.COLON);
+        const right = this.parseAssignmentExpression();
+        return new ConditionalExpression(expression, left, right);
+    }
+    parseYieldExpression() {
+        this.consume(Token.YIELD);
+        let delegating = false;
+        let expression;
+        if (!this.scanner.hasLineTerminatorBeforeNext()) {
+            if (this.check(Token.MUL)) {
+                delegating = true;
+            }
+            switch (this.peek().token) {
+                case Token.EOS:
+                case Token.SEMICOLON:
+                case Token.RBRACE:
+                case Token.RBRACK:
+                case Token.RPAREN:
+                case Token.COLON:
+                case Token.COMMA:
+                case Token.IN:
+                    if (!delegating)
+                        break;
+                    throw new Error(this.errorMessage(`Delegating yields require an RHS`));
+                default:
+                    expression = this.parseAssignmentExpressionCoverGrammar();
+                    break;
+            }
+        }
+        return new YieldExpression(delegating, expression);
+    }
+    parseNewTargetExpression() {
+        throw new Error(this.errorMessage('Expression (new.target) not supported.'));
+    }
+    parseClassExpression() {
+        throw new Error(this.errorMessage(`Expression (class) not supported.`));
+    }
+    parseClassDeclaration(names, defaultExport) {
+        throw new Error(this.errorMessage(`Expression (class) not supported.`));
+    }
+    parseClassLiteral(name, isStrictReserved) {
+        throw new Error(this.errorMessage(`Expression (class) not supported.`));
+    }
+    parseSuperExpression() {
+        throw new Error(this.errorMessage('Expression (supper) not supported.'));
+    }
+    parseImportExpressions() {
+        throw new Error(this.errorMessage('Expression (import) not supported.'));
+    }
+}
+//# sourceMappingURL=inline.js.map