@ibyar/expressions 0.8.2-dev.20221008 → 0.8.4

package/v8/inline.js

@@ -1,52 +1,24 @@
-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, ParseFunctionFlag, ParsingArrowHeadFlag, PropertyKind, PropertyKindInfo, PropertyPosition, SubFunctionKind, VariableDeclarationContext } from './enums.js';
-import { DebuggerStatement } from '../api/computing/debugger.js';
-import { isSloppy, isStrict, LanguageMode, } from './language.js';
+import { TokenStream } from './stream.js';
+import { Token } from './token.js';
+import { ExpressionNodeFactory, ExpressionNodeSourcePosition } from './factory.js';
+import { isSloppy, isStrict, LanguageMode } from './language.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);
     }
+    constructor(scanner, factory, acceptIN) {
+        this.scanner = scanner;
+        this.factory = factory;
+        this.previousAcceptIN = [];
+        this.previousFunctionKind = [];
+        this.previousAcceptIN.push(this.acceptIN = acceptIN ?? false);
+        this.previousFunctionKind.push(this.functionKind = FunctionKind.NormalFunction);
+    }
     position() {
         return this.scanner.getPos();
     }
@@ -93,10 +65,27 @@ export class AbstractParser {
     peekPosition() {
         return this.scanner.peekPosition();
     }
+    createRange(start) {
+        if (Number.isNaN(start?.range?.[0])) {
+            return;
+        }
+        return [start.range[0], this.scanner.getPos()];
+    }
+    createRangeByStart(start) {
+        return [start.range[0], this.scanner.getPos()];
+    }
+    createStartPosition() {
+        return [this.scanner.getPos(), -1];
+    }
+    updateRangeEnd(range) {
+        range[1] = this.scanner.getPos();
+    }
     consume(token) {
-        if (this.scanner.next().isNotType(token)) {
+        const next = this.scanner.next();
+        if (next.isNotType(token)) {
             throw new Error(this.errorMessage(`Parsing ${JSON.stringify(token)}`));
         }
+        return next;
     }
     check(token) {
         const next = this.scanner.peek();
@@ -127,6 +116,7 @@ export class AbstractParser {
         if (current.isNotType(token)) {
             throw new Error(this.errorMessage(`Unexpected Token: ${JSON.stringify(token)}, current is ${JSON.stringify(current)}`));
         }
+        return current;
     }
     expectAndGetValue(token) {
         const current = this.scanner.next();
@@ -136,32 +126,30 @@ export class AbstractParser {
         return current.getValue();
     }
     checkInOrOf() {
-        if (this.check(Token.IN)) {
-            return 'IN';
-        }
-        else if (this.checkValue(OfNode)) {
-            return 'OF';
+        const result = this.peekInOrOf();
+        if (result) {
+            this.scanner.next();
         }
-        return false;
+        return result;
     }
     peekInOrOf() {
         var next = this.peek();
         if (next.isType(Token.IN)) {
             return 'IN';
         }
-        else if (next.value === OfNode) {
+        else if (this.factory.isIdentifier(next.value) && next.value.getName() === 'of') {
             return 'OF';
         }
         return false;
     }
-    isArguments(name) {
-        return name instanceof Identifier && name.getName() === 'arguments';
+    isArguments(node) {
+        return this.factory.isIdentifier(node) && node.getName() === 'arguments';
     }
-    isEval(name) {
-        return name instanceof Identifier && name.getName() === 'eval';
+    isEval(node) {
+        return this.factory.isIdentifier(node) && node.getName() === 'eval';
     }
-    isEvalOrArguments(name) {
-        return name instanceof Identifier && (name.getName() === 'eval' || name.getName() === 'arguments');
+    isEvalOrArguments(node) {
+        return this.factory.isIdentifier(node) && (node.getName() === 'eval' || node.getName() === 'arguments');
     }
     isNextLetKeyword() {
         if (this.peek().isNotType(Token.LET)) {
@@ -188,9 +176,6 @@ export class AbstractParser {
                 return false;
         }
     }
-    isIdentifier(expression) {
-        return expression instanceof Identifier;
-    }
     markParenthesized(expression) {
         Reflect.set(expression, 'parenthesized', true);
     }
@@ -202,7 +187,7 @@ export class AbstractParser {
     }
     isAssignableIdentifier(expression) {
         // return expression instanceof AssignmentNode;
-        if (!(expression instanceof Identifier)) {
+        if (!(this.factory.isIdentifier(expression))) {
             return false;
         }
         if (isStrict(this.languageMode) && this.isEvalOrArguments(expression)) {
@@ -210,23 +195,8 @@ export class AbstractParser {
         }
         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);
+        return this.isAssignableIdentifier(expression) || this.factory.isPropertyOrMemberExpression(expression);
     }
     expectSemicolon() {
         const tok = this.peek();
@@ -299,24 +269,29 @@ export class AbstractParser {
     }
 }
 export class JavaScriptInlineParser extends AbstractParser {
-    static parse(source, { mode, acceptIN } = {}) {
+    static parse(source, { mode, acceptIN, factory, addLocation } = {}) {
         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);
+        if (factory == undefined) {
+            const sourcePositionFactory = addLocation && typeof source === 'string' ? new ExpressionNodeSourcePosition(source) : undefined;
+            factory = new ExpressionNodeFactory(sourcePositionFactory);
+        }
+        const parser = new JavaScriptInlineParser(stream, factory, acceptIN);
         return parser.scan();
     }
-    constructor(scanner, acceptIN) {
-        super(scanner, acceptIN);
+    constructor(scanner, factory, acceptIN) {
+        super(scanner, factory, acceptIN);
     }
     scan() {
+        const start = this.scanner.getPos();
         const list = this.parseStatementList(Token.EOS);
         if (list.length === 1) {
             return list[0];
         }
-        return new ExpressionStatement(list);
+        return this.factory.createExpressionStatement(list, [start, this.scanner.getPos()]);
     }
     /**
      * Statement ::
@@ -341,8 +316,8 @@ export class JavaScriptInlineParser extends AbstractParser {
             case Token.LBRACE:
                 return this.parseBlock();
             case Token.SEMICOLON:
-                this.consume(Token.SEMICOLON);
-                return EmptyStatement.INSTANCE;
+                const semicolon = this.consume(Token.SEMICOLON);
+                return this.factory.createEmptyStatement(semicolon.range);
             case Token.IF:
                 return this.parseIfStatement();
             case Token.DO:
@@ -366,6 +341,8 @@ export class JavaScriptInlineParser extends AbstractParser {
                 return this.parseTryStatement();
             case Token.SWITCH:
                 return this.parseSwitchStatement();
+            case Token.WITH:
+                return this.parseWithStatement();
             case Token.FUNCTION:
                 throw new SyntaxError(this.errorMessage(`FunctionDeclaration only allowed as a StatementListItem not in an arbitrary Statement position.`));
             case Token.DEBUGGER:
@@ -381,9 +358,9 @@ export class JavaScriptInlineParser extends AbstractParser {
         }
     }
     parseDebuggerStatement() {
-        this.consume(Token.DEBUGGER);
+        const token = this.consume(Token.DEBUGGER);
         this.expectSemicolon();
-        return DebuggerStatement.INSTANCE;
+        return this.factory.createDebuggerStatement(token.range);
     }
     parseTryStatement() {
         // TryStatement ::
@@ -396,8 +373,9 @@ export class JavaScriptInlineParser extends AbstractParser {
         //
         // Finally ::
         //   'finally' Block
-        this.consume(Token.TRY);
+        const tryToken = this.consume(Token.TRY);
         const tryBlock = this.parseBlock();
+        let range;
         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`));
@@ -416,13 +394,15 @@ export class JavaScriptInlineParser extends AbstractParser {
                 this.expect(Token.RPAREN);
             }
             const block = this.parseBlock();
-            catchBlock = new CatchClauseNode(block, identifier);
+            catchBlock = this.factory.createCatchClause(block, identifier, this.createRange(peek));
+            range = this.createRange(tryToken);
         }
         let finallyBlock;
         if (this.check(Token.FINALLY)) {
             finallyBlock = this.parseBlock();
+            range = this.createRange(tryToken);
         }
-        return new TryCatchNode(tryBlock, catchBlock, finallyBlock);
+        return this.factory.createTryStatement(tryBlock, catchBlock, finallyBlock, range);
     }
     parseNonRestrictedIdentifier() {
         const result = this.parseIdentifier();
@@ -432,20 +412,22 @@ export class JavaScriptInlineParser extends AbstractParser {
         return result;
     }
     parseBlock() {
-        this.expect(Token.LBRACE);
+        const start = this.expect(Token.LBRACE);
         const statements = [];
-        const block = new BlockStatement(statements);
+        const range = this.createRangeByStart(start);
+        const block = this.factory.createBlock(statements, range);
         while (this.peek().isNotType(Token.RBRACE)) {
             const stat = this.parseStatementListItem();
             if (!stat) {
                 return block;
             }
-            else if (stat instanceof EmptyStatement) {
+            else if (this.factory.isEmptyStatement(stat)) {
                 continue;
             }
             statements.push(stat);
         }
         this.expect(Token.RBRACE);
+        this.updateRangeEnd(range);
         return block;
     }
     /**
@@ -469,10 +451,10 @@ export class JavaScriptInlineParser extends AbstractParser {
     parseStatementListItem() {
         switch (this.peek().token) {
             case Token.FUNCTION:
-                return this.parseHoistableDeclaration(undefined, false);
+                return this.parseHoistableDeclaration(undefined, false, this.peek());
             case Token.CLASS:
-                this.consume(Token.CLASS);
-                return this.parseClassDeclaration(undefined, false);
+                const classToken = this.consume(Token.CLASS);
+                return this.parseClassDeclaration(undefined, false, classToken);
             case Token.VAR:
             case Token.CONST:
                 return this.parseVariableDeclarations(VariableDeclarationContext.StatementListItem);
@@ -483,8 +465,8 @@ export class JavaScriptInlineParser extends AbstractParser {
                 break;
             case Token.ASYNC:
                 if (this.peekAhead().isType(Token.FUNCTION) && !this.scanner.hasLineTerminatorAfterNext()) {
-                    this.consume(Token.ASYNC);
-                    return this.parseAsyncFunctionDeclaration(undefined, false);
+                    const start = this.consume(Token.ASYNC);
+                    return this.parseAsyncFunctionDeclaration(undefined, false, start);
                 }
                 break;
             default:
@@ -493,7 +475,7 @@ export class JavaScriptInlineParser extends AbstractParser {
         return this.parseStatement(AllowLabelledFunctionStatement.AllowLabelledFunctionStatement);
     }
     parseFunctionExpression() {
-        this.consume(Token.FUNCTION);
+        const start = this.consume(Token.FUNCTION);
         const functionKind = this.check(Token.MUL) ? FunctionKind.GeneratorFunction : FunctionKind.NormalFunction;
         let name;
         let functionSyntaxKind = FunctionSyntaxKind.AnonymousExpression;
@@ -502,9 +484,9 @@ export class JavaScriptInlineParser extends AbstractParser {
             name = this.parseIdentifier(this.getLastFunctionKind());
             functionSyntaxKind = FunctionSyntaxKind.NamedExpression;
         }
-        return this.parseFunctionLiteral(functionKind, functionSyntaxKind, name);
+        return this.parseFunctionLiteral(functionKind, functionSyntaxKind, name, start);
     }
-    parseAsyncFunctionDeclaration(names, defaultExport) {
+    parseAsyncFunctionDeclaration(names, defaultExport, start) {
         // AsyncFunctionDeclaration ::
         //   async [no LineTerminator here] function BindingIdentifier[Await]
         //       ( FormalParameters[Await] ) { AsyncFunctionBody }
@@ -512,20 +494,22 @@ export class JavaScriptInlineParser extends AbstractParser {
             throw new SyntaxError(this.errorMessage('Line Terminator Before `function` parsing `async function`.'));
         }
         this.consume(Token.FUNCTION);
-        return this.parseHoistableDeclaration01(FunctionKind.AsyncFunction, names, defaultExport);
+        return this.parseHoistableDeclaration01(FunctionKind.AsyncFunction, names, defaultExport, start);
     }
     parseIfStatement() {
-        this.consume(Token.IF);
+        const ifToken = this.consume(Token.IF);
         this.consume(Token.LPAREN);
         const condition = this.parseExpression();
         this.consume(Token.RPAREN);
         const thenStatement = this.parseScopedStatement();
+        let range;
         let elseStatement;
         if (this.peek().isType(Token.ELSE)) {
             this.consume(Token.ELSE);
             elseStatement = this.parseScopedStatement();
         }
-        return new IfStatement(condition, thenStatement, elseStatement);
+        range = this.createRange(ifToken);
+        return this.factory.createIfStatement(condition, thenStatement, elseStatement, range);
     }
     parseScopedStatement() {
         if (isStrict(this.languageMode) || this.peek().isNotType(Token.FUNCTION)) {
@@ -538,35 +522,36 @@ export class JavaScriptInlineParser extends AbstractParser {
     parseDoWhileStatement() {
         // DoStatement ::
         //   'do' Statement 'while' '(' Expression ')' ';'
-        this.consume(Token.DO);
+        const start = 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);
+        return this.factory.createDoStatement(condition, body, this.createRange(start));
     }
     parseWhileStatement() {
         // WhileStatement ::
         //   'while' '(' Expression ')' Statement
-        this.consume(Token.WHILE);
+        const start = 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);
+        return this.factory.createWhileStatement(condition, body, this.createRange(start));
     }
     parseThrowStatement() {
         // ThrowStatement ::
         //   'throw' Expression ';'
-        this.consume(Token.THROW);
+        const throwToken = this.consume(Token.THROW);
         if (this.scanner.hasLineTerminatorBeforeNext()) {
             throw new Error(this.scanner.createError(`New line After Throw`));
         }
         const exception = this.parseExpression();
+        const range = this.createRange(throwToken);
         this.expectSemicolon();
-        return new ThrowStatement(exception);
+        return this.factory.createThrowStatement(exception, range);
     }
     parseSwitchStatement() {
         // SwitchStatement ::
@@ -574,19 +559,21 @@ export class JavaScriptInlineParser extends AbstractParser {
         // CaseClause ::
         //   'case' Expression ':' StatementList
         //   'default' ':' StatementList
-        this.consume(Token.SWITCH);
+        const start = this.consume(Token.SWITCH);
+        const range = this.createRangeByStart(start);
         this.expect(Token.LPAREN);
         const tag = this.parseExpression();
         this.expect(Token.RPAREN);
         const cases = [];
-        const switchStatement = new SwitchStatement(tag, cases);
+        const switchStatement = this.factory.createSwitchStatement(tag, cases, range);
         let defaultSeen = false;
         this.expect(Token.LBRACE);
         while (this.peek().isNotType(Token.RBRACE)) {
             const statements = [];
-            let label;
+            let test;
+            const caseStart = this.scanner.peek();
             if (this.check(Token.CASE)) {
-                label = this.parseExpression();
+                test = this.parseExpression();
             }
             else {
                 this.expect(Token.DEFAULT);
@@ -595,21 +582,25 @@ export class JavaScriptInlineParser extends AbstractParser {
                 }
                 defaultSeen = true;
             }
-            this.expect(Token.COLON);
+            const blockStart = 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)) {
+                if (!statement || this.factory.isEmptyStatement(statement)) {
                     continue;
                 }
                 statements.push(statement);
             }
-            const block = new BlockStatement(statements);
-            const clause = defaultSeen ? new DefaultExpression(block) : new SwitchCase(label, block);
+            const block = this.factory.createBlock(statements, this.createRange(blockStart));
+            const caseRange = this.createRange(caseStart);
+            const clause = defaultSeen
+                ? this.factory.createDefaultClause(block, caseRange)
+                : this.factory.createCaseBlock(test, block, caseRange);
             cases.push(clause);
         }
         this.expect(Token.RBRACE);
+        this.updateRangeEnd(range);
         return switchStatement;
     }
     parseForStatement() {
@@ -621,7 +612,7 @@ export class JavaScriptInlineParser extends AbstractParser {
         // We parse a declaration/expression after the 'for (' and then read the first
         // expression/declaration before we know if this is a for or a for-each.
         //   typename FunctionState::LoopScope loop_scope(function_state_);
-        this.consume(Token.FOR);
+        const start = this.consume(Token.FOR);
         this.expect(Token.LPAREN);
         const peek = this.peek();
         const starts_with_let = peek.isType(Token.LET);
@@ -635,13 +626,13 @@ export class JavaScriptInlineParser extends AbstractParser {
             const initializer = this.parseVariableDeclarations(VariableDeclarationContext.ForStatement);
             const forMode = this.checkInOrOf();
             if (forMode) {
-                return this.parseForEachStatementWithDeclarations(initializer, forMode);
+                return this.parseForEachStatementWithDeclarations(initializer, forMode, start);
             }
             this.expect(Token.SEMICOLON);
             // Parse the remaining code in the inner block scope since the declaration
             // above was parsed there. We'll finalize the unnecessary outer block scope
             // after parsing the rest of the loop.
-            return this.parseStandardForLoopWithLexicalDeclarations(initializer);
+            return this.parseStandardForLoopWithLexicalDeclarations(initializer, start);
         }
         let initializer;
         if (peek.isType(Token.VAR)) {
@@ -651,7 +642,7 @@ export class JavaScriptInlineParser extends AbstractParser {
             // for_info.position = scanner() -> location().beg_pos;
             const forMode = this.checkInOrOf();
             if (forMode) {
-                return this.parseForEachStatementWithDeclarations(initializer, forMode);
+                return this.parseForEachStatementWithDeclarations(initializer, forMode, start);
             }
             // init = impl() -> BuildInitializationBlock(& for_info.parsing_result);
         }
@@ -671,25 +662,25 @@ export class JavaScriptInlineParser extends AbstractParser {
                 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);
+                return this.parseForEachStatementWithoutDeclarations(initializer, forMode, start);
             }
         }
         this.expect(Token.SEMICOLON);
-        return this.parseStandardForLoop(initializer);
+        return this.parseStandardForLoop(initializer, start);
     }
-    parseStandardForLoopWithLexicalDeclarations(initializer) {
+    parseStandardForLoopWithLexicalDeclarations(initializer, start) {
         // The condition and the next statement of the for loop must be parsed
         // in a new scope.
-        return this.parseStandardForLoop(initializer);
+        return this.parseStandardForLoop(initializer, start);
     }
-    parseForEachStatementWithDeclarations(initializer, forMode) {
+    parseForEachStatementWithDeclarations(initializer, forMode, start) {
         // Just one declaration followed by in/of.
         if (initializer.getDeclarations().length != 1) {
             throw new SyntaxError(this.errorMessage('For In/Of loop Multi Bindings'));
         }
-        return this.parseForEachStatementWithoutDeclarations(initializer, forMode);
+        return this.parseForEachStatementWithoutDeclarations(initializer, forMode, start);
     }
-    parseForEachStatementWithoutDeclarations(initializer, forMode) {
+    parseForEachStatementWithoutDeclarations(initializer, forMode, start) {
         let enumerable;
         if (forMode == 'OF') {
             this.setAcceptIN(true);
@@ -701,32 +692,31 @@ export class JavaScriptInlineParser extends AbstractParser {
         }
         this.expect(Token.RPAREN);
         const body = this.parseStatement();
+        const range = this.createRange(start);
         if (forMode === 'OF') {
-            return new ForOfNode(initializer, enumerable, body);
+            return this.factory.createForOfStatement(initializer, enumerable, body, range);
         }
         else if (forMode === 'IN') {
-            return new ForInNode(initializer, enumerable, body);
-        }
-        else {
-            throw new Error(this.errorMessage(`parsing for loop: ${this.position()}`));
+            return this.factory.createForInStatement(initializer, enumerable, body, range);
         }
+        throw new Error(this.errorMessage(`parsing for loop: ${this.position()}`));
     }
-    parseStandardForLoop(initializer) {
+    parseStandardForLoop(initializer, start) {
         // CheckStackOverflow();
         //   ForStatementT loop = factory() -> NewForStatement(stmt_pos);
         //   Target target(this, loop, labels, own_labels, Target:: TARGET_FOR_ANONYMOUS);
-        let cond = new EmptyStatement();
+        let cond = this.factory.createEmptyStatement();
         if (this.peek().isNotType(Token.SEMICOLON)) {
             cond = this.parseExpression();
         }
         this.expect(Token.SEMICOLON);
-        let next = new EmptyStatement();
+        let next = this.factory.createEmptyStatement();
         if (this.peek().isNotType(Token.RPAREN)) {
             next = this.parseExpression();
         }
         this.expect(Token.RPAREN);
         const body = this.parseStatement();
-        return new ForNode(body, initializer, cond, next);
+        return this.factory.createForStatement(body, initializer, cond, next, this.createRange(start));
     }
     parseForAwaitStatement() {
         // for await '(' ForDeclaration of AssignmentExpression ')'
@@ -735,7 +725,7 @@ export class JavaScriptInlineParser extends AbstractParser {
         if (!this.isAwaitAllowed()) {
             throw new SyntaxError(this.errorMessage('"await" is not allowed'));
         }
-        this.expect(Token.FOR);
+        const start = this.expect(Token.FOR);
         this.expect(Token.AWAIT);
         this.expect(Token.LPAREN);
         let hasDeclarations = false;
@@ -772,14 +762,16 @@ export class JavaScriptInlineParser extends AbstractParser {
         this.restoreAcceptIN();
         this.expect(Token.RPAREN);
         const body = this.parseStatement();
-        return new ForAwaitOfNode(eachVariable, iterable, body);
+        const range = this.createRange(start);
+        return this.factory.createForAwaitOfStatement(eachVariable, iterable, body, range);
     }
     parseVariableDeclarations(varContext) {
         // VariableDeclarations ::
         //   ('var' | 'const' | 'let') (Identifier ('=' AssignmentExpression)?)+[',']
         // var converted into ==> 'let' by parser
         let mode;
-        const token = this.peek().token;
+        const start = this.peek();
+        const token = start.token;
         switch (token) {
             case Token.CONST:
                 this.consume(token);
@@ -799,6 +791,7 @@ export class JavaScriptInlineParser extends AbstractParser {
         do {
             let name;
             let value;
+            const range = this.createStartPosition();
             // Check for an identifier first, so that we can elide the pattern in cases
             // where there is no initializer (and so no proxy needs to be created).
             if (Token.isAnyIdentifier(this.peek().token)) {
@@ -826,9 +819,11 @@ export class JavaScriptInlineParser extends AbstractParser {
                 }
                 // value = undefined;
             }
-            variables.push(new VariableDeclarator(name, value));
+            this.updateRangeEnd(range);
+            variables.push(this.factory.createVariableDeclaration(name, value, range));
         } while (this.check(Token.COMMA));
-        return new VariableDeclarationNode(variables, mode);
+        const range = this.createRange(start);
+        return this.factory.createVariableStatement(variables, mode, range);
     }
     parseBindingPattern(isPattern) {
         // Pattern ::
@@ -849,9 +844,7 @@ export class JavaScriptInlineParser extends AbstractParser {
         else if (token == Token.LBRACE) {
             return this.parseObjectLiteral(isPattern);
         }
-        else {
-            throw new Error(this.errorMessage(`Unexpected Token: ${this.next().getValue()}`));
-        }
+        throw new Error(this.errorMessage(`Unexpected Token: ${this.next().getValue()}`));
     }
     parseAndClassifyIdentifier(next) {
         // Updates made here must be reflected on ClassifyPropertyIdentifier.
@@ -874,29 +867,31 @@ export class JavaScriptInlineParser extends AbstractParser {
         // ContinueStatement ::
         //   'continue' ';'
         // Identifier? is not supported
-        this.consume(Token.CONTINUE);
+        const start = this.consume(Token.CONTINUE);
         let label;
         if (!this.scanner.hasLineTerminatorBeforeNext() &&
             !Token.isAutoSemicolon(this.peek().token)) {
             // ECMA allows "eval" or "arguments" as labels even in strict mode.
             label = this.parseIdentifier();
         }
+        const range = this.createRange(start);
         this.expectSemicolon();
-        return label ? new ContinueStatement(label) : ContinueStatement.CONTINUE_INSTANCE;
+        return this.factory.createContinueStatement(label, range);
     }
     parseBreakStatement() {
         // BreakStatement ::
         //   'break' ';'
         // Identifier? is not supported
-        this.consume(Token.BREAK);
+        const start = this.consume(Token.BREAK);
         let label;
         if (!this.scanner.hasLineTerminatorBeforeNext() &&
             !Token.isAutoSemicolon(this.peek().token)) {
             // ECMA allows "eval" or "arguments" as labels even in strict mode.
             label = this.parseIdentifier();
         }
+        const range = this.createRange(start);
         this.expectSemicolon();
-        return label ? new BreakStatement(label) : BreakStatement.BREAK_INSTANCE;
+        return this.factory.createBreakStatement(label, range);
     }
     parseReturnStatement() {
         // ReturnStatement ::
@@ -904,7 +899,7 @@ export class JavaScriptInlineParser extends AbstractParser {
         // Consume the return token. It is necessary to do that before
         // reporting any errors on it, because of the way errors are
         // reported (underlining).
-        this.consume(Token.RETURN);
+        const start = this.consume(Token.RETURN);
         const tokenExp = this.peek();
         let returnValue;
         // ExpressionT return_value = impl() -> NullExpression();
@@ -917,8 +912,9 @@ export class JavaScriptInlineParser extends AbstractParser {
         else {
             returnValue = this.parseExpression();
         }
+        const range = this.createRange(start);
         this.expectSemicolon();
-        return new ReturnStatement(returnValue);
+        return this.factory.createReturnStatement(returnValue, range);
     }
     parseExpressionOrLabelledStatement(allowFunction) {
         // ExpressionStatement | LabelledStatement ::
@@ -947,10 +943,11 @@ export class JavaScriptInlineParser extends AbstractParser {
             default:
                 break;
         }
+        const range = this.createStartPosition();
         const startsWithIdentifier = Token.isAnyIdentifier(this.peek().token);
         this.setAcceptIN(true);
         const expression = this.parseExpressionCoverGrammar();
-        if (this.peek().isType(Token.COLON) && startsWithIdentifier && this.isIdentifier(expression)) {
+        if (this.peek().isType(Token.COLON) && startsWithIdentifier && this.factory.isIdentifier(expression)) {
             // The whole expression was a single identifier, and not, e.g.,
             // something starting with an identifier or a parenthesized identifier.
             // Remove the "ghost" variable that turned out to be a label from the top
@@ -963,11 +960,13 @@ export class JavaScriptInlineParser extends AbstractParser {
                 && allowFunction == AllowLabelledFunctionStatement.AllowLabelledFunctionStatement) {
                 const result = this.parseFunctionDeclaration();
                 this.restoreAcceptIN();
-                return new LabeledStatement(expression, result);
+                this.updateRangeEnd(range);
+                return this.factory.createLabeledStatement(expression, result, range);
             }
             const result = this.parseStatement(allowFunction);
             this.restoreAcceptIN();
-            return new LabeledStatement(expression, result);
+            this.updateRangeEnd(range);
+            return this.factory.createLabeledStatement(expression, result, range);
         }
         this.restoreAcceptIN();
         // Parsed expression statement, followed by semicolon.
@@ -981,11 +980,11 @@ export class JavaScriptInlineParser extends AbstractParser {
         return result;
     }
     parseFunctionDeclaration() {
-        this.consume(Token.FUNCTION);
+        const start = 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);
+        return this.parseHoistableDeclaration01(FunctionKind.NormalFunction, undefined, false, start);
     }
     parseAsyncFunctionLiteral() {
         // AsyncFunctionLiteral ::
@@ -997,7 +996,7 @@ export class JavaScriptInlineParser extends AbstractParser {
         if (this.current().isNotType(Token.ASYNC)) {
             throw new SyntaxError(this.errorMessage('invalid token'));
         }
-        this.consume(Token.FUNCTION);
+        const start = this.consume(Token.FUNCTION);
         let name;
         let syntaxKind = FunctionSyntaxKind.AnonymousExpression;
         let flags = FunctionKind.AsyncFunction;
@@ -1008,17 +1007,17 @@ export class JavaScriptInlineParser extends AbstractParser {
             syntaxKind = FunctionSyntaxKind.NamedExpression;
             name = this.parseIdentifier(this.getLastFunctionKind());
         }
-        return this.parseFunctionLiteral(flags, syntaxKind, name);
+        return this.parseFunctionLiteral(flags, syntaxKind, name, start);
     }
-    parseHoistableDeclaration(names, defaultExport) {
+    parseHoistableDeclaration(names, defaultExport, start) {
         this.consume(Token.FUNCTION);
         let flags = FunctionKind.NormalFunction;
         if (this.check(Token.MUL)) {
             flags = FunctionKind.GeneratorFunction;
         }
-        return this.parseHoistableDeclaration01(flags, names, defaultExport);
+        return this.parseHoistableDeclaration01(flags, names, defaultExport, start);
     }
-    parseHoistableDeclaration01(flag, names, defaultExport) {
+    parseHoistableDeclaration01(flag, names, defaultExport, start) {
         // FunctionDeclaration ::
         //   'function' Identifier '(' FormalParameters ')' '{' FunctionBody '}'
         //   'function' '(' FormalParameters ')' '{' FunctionBody '}'
@@ -1037,7 +1036,7 @@ export class JavaScriptInlineParser extends AbstractParser {
         let name;
         if (this.peek().isType(Token.LPAREN)) {
             if (defaultExport) {
-                name = new Identifier('default');
+                name = this.factory.createIdentifier('default', this.createRange(start));
             }
             else {
                 throw new SyntaxError(this.errorMessage('Missing Function Name'));
@@ -1047,7 +1046,7 @@ export class JavaScriptInlineParser extends AbstractParser {
             name = this.parseIdentifier(this.getLastFunctionKind());
         }
         names?.push(name.toString());
-        return this.parseFunctionLiteral(flag, FunctionSyntaxKind.Declaration, name);
+        return this.parseFunctionLiteral(flag, FunctionSyntaxKind.Declaration, name, start);
     }
     parseIdentifier(kind) {
         kind ?? (kind = this.functionKind);
@@ -1064,9 +1063,9 @@ export class JavaScriptInlineParser extends AbstractParser {
         const current = this.current();
         switch (current.token) {
             case Token.AWAIT:
-                return AwaitIdentifier;
+                return this.factory.createIdentifier('await', current.range);
             case Token.ASYNC:
-                return AsyncIdentifier;
+                return this.factory.createIdentifier('async', current.range);
             case Token.IDENTIFIER:
             case Token.PRIVATE_NAME:
                 return current.getValue();
@@ -1075,20 +1074,20 @@ export class JavaScriptInlineParser extends AbstractParser {
         }
         const name = current.getValue().toString();
         if (name == 'constructor') {
-            return ConstructorIdentifier;
+            return this.factory.createIdentifier('constructor', current.range);
         }
         if (name == 'name') {
-            return NameIdentifier;
+            return this.factory.createIdentifier('name', current.range);
         }
         if (name == 'eval') {
-            return EvalIdentifier;
+            return this.factory.createIdentifier('eval', current.range);
         }
         else if (name == 'arguments') {
-            return ArgumentsIdentifier;
+            return this.factory.createIdentifier('arguments', current.range);
         }
         return current.getValue();
     }
-    parseFunctionLiteral(flag, functionSyntaxKind, name) {
+    parseFunctionLiteral(flag, functionSyntaxKind, name, start) {
         // Function ::
         //   '(' FormalParameterList? ')' '{' FunctionBody '}'
         this.setFunctionKind(flag);
@@ -1096,16 +1095,18 @@ export class JavaScriptInlineParser extends AbstractParser {
         this.expect(Token.LPAREN);
         const formals = this.parseFormalParameterList(functionInfo);
         this.expect(Token.RPAREN);
-        this.expect(Token.LBRACE);
+        const bodyStart = this.expect(Token.LBRACE);
         this.setAcceptIN(true);
         const body = this.parseFunctionBody(flag, FunctionBodyType.BLOCK, functionSyntaxKind);
         this.restoreAcceptIN();
         this.restoreFunctionKind();
-        const bodyBlock = new BlockStatement(body);
+        const bodyRange = this.createRange(bodyStart);
+        const funcRange = this.createRange(start);
+        const bodyBlock = this.factory.createBlock(body, bodyRange);
         if (name) {
-            return new FunctionDeclaration(formals, bodyBlock, isAsyncFunction(flag), isGeneratorFunction(flag), name);
+            return this.factory.createFunctionDeclaration(formals, bodyBlock, isAsyncFunction(flag), isGeneratorFunction(flag), name, funcRange);
         }
-        return new FunctionExpression(formals, bodyBlock, isAsyncFunction(flag), isGeneratorFunction(flag));
+        return this.factory.createFunctionExpression(formals, bodyBlock, isAsyncFunction(flag), isGeneratorFunction(flag), funcRange);
     }
     parseFunctionBody(kind, bodyType, functionSyntaxKind) {
         // Building the parameter initialization block declares the parameters.
@@ -1157,7 +1158,7 @@ export class JavaScriptInlineParser extends AbstractParser {
             if (!stat) {
                 break;
             }
-            if (this.isEmptyStatement(stat)) {
+            if (this.factory.isEmptyStatement(stat)) {
                 continue;
             }
             list.push(stat);
@@ -1199,20 +1200,25 @@ export class JavaScriptInlineParser extends AbstractParser {
     parseFormalParameter(functionInfo) {
         // FormalParameter[Yield,GeneratorParameter] :
         //   BindingElement[?Yield, ?GeneratorParameter]
+        const range = this.createStartPosition();
         functionInfo.rest = this.check(Token.ELLIPSIS);
-        let pattern = this.parseBindingPattern(true);
+        const 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();
+            const right = this.parseAssignmentExpression();
             this.restoreAcceptIN();
-            initializer = new Param(pattern, value);
+            this.updateRangeEnd(range);
+            const left = this.checkParamType(pattern);
+            initializer = this.factory.createAssignmentPattern(left, right, range);
         }
         else {
-            initializer = new Param(pattern);
+            this.updateRangeEnd(range);
+            const param = this.checkParamType(pattern);
+            initializer = functionInfo.rest ? this.factory.createRestElement(param, param.range && [range[0], param.range[1]]) : param;
         }
         return initializer;
     }
@@ -1240,8 +1246,9 @@ export class JavaScriptInlineParser extends AbstractParser {
         return this.expressionListToExpression(list);
     }
     parseArrowParametersWithRest(list) {
-        this.consume(Token.ELLIPSIS);
+        const start = this.consume(Token.ELLIPSIS);
         const pattern = this.parseBindingPattern(true);
+        const range = this.createRange(start);
         if (this.peek().isType(Token.ASSIGN)) {
             throw new Error(this.errorMessage(`Error A rest parameter cannot have an initializer`));
         }
@@ -1254,7 +1261,7 @@ export class JavaScriptInlineParser extends AbstractParser {
         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));
+        list.push(this.factory.createSpreadElement(pattern, range));
         return this.expressionListToExpression(list);
     }
     expressionListToExpression(list) {
@@ -1262,11 +1269,13 @@ export class JavaScriptInlineParser extends AbstractParser {
         if (list.length === 1) {
             return first;
         }
-        if (first instanceof SequenceExpression) {
+        if (this.factory.isSequenceExpression(first)) {
             first.getExpressions().push(...list.slice(1));
             return first;
         }
-        return new SequenceExpression(list);
+        const range = this.createRange(list.at(0));
+        range && this.updateRangeEnd(range);
+        return this.factory.createCommaListExpression(list, range);
     }
     parseMemberExpression() {
         // MemberExpression ::
@@ -1284,15 +1293,6 @@ export class JavaScriptInlineParser extends AbstractParser {
         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() {
         // PrimaryExpression ::
         //   'this'
@@ -1327,28 +1327,22 @@ export class JavaScriptInlineParser extends AbstractParser {
             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);
+                const params = this.factory.isSequenceExpression(name) ? name.getExpressions() : [name];
+                const arrow = this.parseArrowFunctionLiteral(params, kind, this.createRange(token));
                 this.restoreFunctionKind();
                 return arrow;
             }
             return this.parseAndClassifyIdentifier(token);
         }
         if (Token.isLiteral(token.token)) {
-            return expressionFromLiteral(this.next());
+            return this.next().getValue();
         }
         switch (token.token) {
             case Token.NEW:
                 return this.parseMemberWithPresentNewPrefixesExpression();
             case Token.THIS:
                 this.consume(Token.THIS);
-                return ThisNode;
+                return this.factory.createThis(token.range);
             case Token.DIV:
             case Token.DIV_ASSIGN:
                 // case Token.REGEXP_LITERAL:
@@ -1374,7 +1368,7 @@ export class JavaScriptInlineParser extends AbstractParser {
                     if (!this.peek().isType(Token.ARROW)) {
                         throw new Error(this.errorMessage(`Unexpected Token: ${Token.RPAREN.getName()}`));
                     }
-                    const result = new SequenceExpression([]);
+                    const result = this.factory.createCommaListExpression([], this.createRange(token));
                     this.markParenthesized(result);
                     return result;
                 }
@@ -1418,8 +1412,8 @@ export class JavaScriptInlineParser extends AbstractParser {
         // single TEMPLATE_SPAN and no expressions.
         if (next.isType(Token.TEMPLATE_TAIL)) {
             this.consume(Token.TEMPLATE_TAIL);
-            const string = next.getValue().string;
-            return this.createTemplateLiteralExpressionNode([string], [], tag);
+            const template = next.getValue();
+            return this.createTemplateLiteralExpressionNode([template.string], [], tag, template.range);
         }
         this.consume(Token.TEMPLATE_SPAN);
         const expressions = [];
@@ -1449,13 +1443,11 @@ export class JavaScriptInlineParser extends AbstractParser {
         // Once we've reached a TEMPLATE_TAIL, we can close the TemplateLiteral.
         return this.createTemplateLiteralExpressionNode(strings, expressions, tag);
     }
-    createTemplateLiteralExpressionNode(strings, expressions, tag) {
+    createTemplateLiteralExpressionNode(strings, expressions, tag, range) {
         if (tag) {
-            return new TaggedTemplateExpression(tag, strings, expressions);
-        }
-        else {
-            return new TemplateLiteral(strings, expressions);
+            return this.factory.createTaggedTemplateExpression(tag, strings, expressions, range);
         }
+        return this.factory.createTemplateExpression(strings, expressions, range);
     }
     parseMemberWithPresentNewPrefixesExpression() {
         // NewExpression ::
@@ -1476,19 +1468,19 @@ export class JavaScriptInlineParser extends AbstractParser {
         // new new foo() means new (new foo())
         // new new foo().bar().baz means (new (new foo()).bar()).baz
         // new super.x means new (super.x)
-        this.consume(Token.NEW);
+        const start = this.consume(Token.NEW);
         let result;
         // CheckStackOverflow();
         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();
+            result = this.parseNewTargetExpression(start);
             return this.parseMemberExpressionContinuation(result);
         }
         else {
             result = this.parseMemberExpression();
-            if (result === SuperIdentifier) {
+            if (this.factory.isSuper(result)) {
                 // new super() is never allowed
                 throw new SyntaxError(this.errorMessage(`Unexpected Super, new super() is never allowed`));
             }
@@ -1496,14 +1488,14 @@ export class JavaScriptInlineParser extends AbstractParser {
         if (this.peek().isType(Token.LPAREN)) {
             // NewExpression with arguments.
             const args = this.parseArguments();
-            result = new NewExpression(result, args);
+            result = this.factory.createNewExpression(result, args, this.createRange(start));
             // The expression can still continue with . or [ after the arguments.
             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);
+        return this.factory.createNewExpression(result, undefined, this.createRange(start));
     }
     parseArguments(maybeArrow) {
         // Arguments ::
@@ -1511,12 +1503,13 @@ export class JavaScriptInlineParser extends AbstractParser {
         this.consume(Token.LPAREN);
         const args = [];
         while (this.peek().isNotType(Token.RPAREN)) {
+            const range = this.createStartPosition();
             const isSpread = this.check(Token.ELLIPSIS);
             this.setAcceptIN(true);
             let argument = this.parseAssignmentExpressionCoverGrammar();
             if (ParsingArrowHeadFlag.MaybeArrowHead === maybeArrow) {
                 if (isSpread) {
-                    if (argument instanceof AssignmentExpression) {
+                    if (this.factory.isAssignmentExpression(argument)) {
                         this.restoreAcceptIN();
                         throw new Error(this.errorMessage(` Rest parameter may not have a default initializer'`));
                     }
@@ -1527,7 +1520,8 @@ export class JavaScriptInlineParser extends AbstractParser {
                 }
             }
             if (isSpread) {
-                argument = new SpreadElement(argument);
+                this.updateRangeEnd(range);
+                argument = this.factory.createSpreadElement(argument, range);
             }
             args.push(argument);
             this.restoreAcceptIN();
@@ -1545,6 +1539,7 @@ export class JavaScriptInlineParser extends AbstractParser {
         //   ArrowFunction
         //   YieldExpression
         //   LeftHandSideExpression AssignmentOperator AssignmentExpression
+        const range = this.createStartPosition();
         if (this.peek().isType(Token.YIELD) && isGeneratorFunction(this.functionKind)) {
             return this.parseYieldExpression();
         }
@@ -1557,48 +1552,34 @@ export class JavaScriptInlineParser extends AbstractParser {
         ;
         // Arrow functions.
         if (op === Token.ARROW) {
-            if (!this.isIdentifier(expression) && !this.isParenthesized(expression)) {
+            if (!this.factory.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);
+            if (this.factory.isSequenceExpression(expression)) {
+                arrow = this.parseArrowFunctionLiteral(expression.getExpressions(), FunctionKind.NormalFunction, range);
             }
-            else if (expression instanceof GroupingExpression) {
-                arrow = this.parseArrowFunctionLiteral([new Param(expression.getNode())], FunctionKind.NormalFunction);
+            else if (this.factory.isGroupingExpression(expression)) {
+                arrow = this.parseArrowFunctionLiteral([expression.getNode()], FunctionKind.NormalFunction, range);
             }
             else {
                 this.clearParenthesized(expression);
-                arrow = this.parseArrowFunctionLiteral([new Param(expression)], FunctionKind.NormalFunction);
+                arrow = this.parseArrowFunctionLiteral([expression], FunctionKind.NormalFunction, range);
             }
             this.restoreFunctionKind();
             return arrow;
         }
         if (this.isAssignableIdentifier(expression)) {
         }
-        else if (this.isProperty(expression)) {
+        else if (this.factory.isPropertyOrMemberExpression(expression)) {
         }
-        else if (this.isPattern(expression) && Token.isAssignment(op)) {
+        else if (this.factory.canBePattern(expression) && Token.isAssignment(op)) {
             // Destructuring assignment.
-            expression = expression instanceof ObjectExpression
-                ? new ObjectPattern(expression.getProperties())
-                : new ArrayPattern(expression.getElements());
-            // expression_scope() -> ValidateAsPattern(expression, lhs_beg_pos, end_position());
+            expression = this.factory.isObjectExpression(expression)
+                ? this.factory.createObjectBindingPattern(expression.getProperties(), expression.range)
+                : this.factory.createArrayBindingPattern(expression.getElements(), expression.range);
         }
         else {
             if (!this.isValidReferenceExpression(expression)) {
@@ -1615,12 +1596,34 @@ export class JavaScriptInlineParser extends AbstractParser {
         if (!Token.isAssignment(op)) {
             throw new Error(this.errorMessage(`Invalid Destructuring Target`));
         }
-        return new AssignmentExpression(op.getName(), expression, right);
+        this.updateRangeEnd(range);
+        return this.factory.createAssignment(op.getName(), expression, right, range);
     }
     parseAssignmentExpression() {
         return this.parseAssignmentExpressionCoverGrammar();
     }
-    parseArrowFunctionLiteral(parameters, kind) {
+    checkParamType(node) {
+        if (this.factory.isArrayExpression(node)) {
+            return this.factory.createArrayBindingPattern(node.getElements(), node.range);
+        }
+        else if (this.factory.isObjectExpression(node)) {
+            return this.factory.createObjectBindingPattern(node.getProperties(), node.range);
+        }
+        else if (this.factory.isSpreadElement(node)) {
+            let arg = node.getArgument();
+            // let param = arg;
+            if (this.factory.isArrayExpression(arg)) {
+                arg = this.factory.createArrayBindingPattern(arg.getElements(), arg.range);
+            }
+            else if (this.factory.isObjectExpression(arg)) {
+                arg = this.factory.createObjectBindingPattern(arg.getProperties(), arg.range);
+            }
+            return this.factory.createRestElement(arg, node.range);
+        }
+        return node;
+    }
+    parseArrowFunctionLiteral(parameters, kind, range) {
+        parameters = parameters.map(node => this.checkParamType(node));
         if (this.peek().isNotType(Token.ARROW)) {
             throw new SyntaxError(this.errorMessage('SyntaxError Expecting Arrow Token'));
         }
@@ -1640,7 +1643,8 @@ export class JavaScriptInlineParser extends AbstractParser {
             has_braces = false;
             body = this.parseFunctionBody(kind, FunctionBodyType.EXPRESSION, FunctionSyntaxKind.AnonymousExpression);
         }
-        return new ArrowFunctionExpression(parameters, body, !has_braces, isAsyncFunction(kind));
+        this.updateRangeEnd(range);
+        return this.factory.createArrowFunction(parameters, body, !has_braces, isAsyncFunction(kind), range);
     }
     parseRegExpLiteral() {
         if (!this.scanner.scanRegExpPattern()) {
@@ -1651,23 +1655,24 @@ export class JavaScriptInlineParser extends AbstractParser {
     parseArrayLiteral(isPattern) {
         // ArrayLiteral ::
         //   '[' Expression? (',' Expression?)* ']'
-        this.consume(Token.LBRACK);
+        const start = this.consume(Token.LBRACK);
         let first_spread_index = -1;
         const values = [];
         while (!this.check(Token.RBRACK)) {
             let elem;
-            if (this.peek().isType(Token.COMMA)) {
+            const peek = this.peek();
+            if (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);
+                elem = this.factory.createSpreadElement(argument, this.createRange(peek));
                 if (first_spread_index < 0) {
                     first_spread_index = values.length;
                 }
-                if (argument instanceof AssignmentExpression && isPattern) {
+                if (this.factory.isAssignmentExpression(argument) && isPattern) {
                     throw new SyntaxError(this.errorMessage('Invalid Destructuring Target'));
                 }
                 if (this.peek().isType(Token.COMMA)) {
@@ -1684,7 +1689,11 @@ export class JavaScriptInlineParser extends AbstractParser {
                 this.expect(Token.COMMA);
             }
         }
-        return new (isPattern ? ArrayPattern : ArrayExpression)(values);
+        const range = this.createRange(start);
+        if (isPattern) {
+            return this.factory.createArrayBindingPattern(values, range);
+        }
+        return this.factory.createArrayLiteralExpression(values, range);
     }
     parsePossibleDestructuringSubPattern() {
         return this.parseAssignmentExpressionCoverGrammar();
@@ -1692,7 +1701,7 @@ export class JavaScriptInlineParser extends AbstractParser {
     parseObjectLiteral(isPattern) {
         // ObjectLiteral ::
         // '{' (PropertyDefinition (',' PropertyDefinition)* ','? )? '}'
-        this.consume(Token.LBRACE);
+        const start = this.consume(Token.LBRACE);
         const properties = [];
         while (!this.check(Token.RBRACE)) {
             const property = this.parseObjectPropertyDefinition(isPattern);
@@ -1701,10 +1710,11 @@ export class JavaScriptInlineParser extends AbstractParser {
                 this.expect(Token.COMMA);
             }
         }
+        const range = this.createRange(start);
         if (isPattern) {
-            return new ObjectPattern(properties);
+            return this.factory.createObjectBindingPattern(properties, range);
         }
-        return new ObjectExpression(properties);
+        return this.factory.createObjectLiteralExpression(properties, range);
     }
     parseObjectPropertyDefinition(isPattern) {
         const propInfo = new PropertyKindInfo();
@@ -1713,15 +1723,17 @@ export class JavaScriptInlineParser extends AbstractParser {
             case PropertyKind.Spread:
                 let value = nameExpression;
                 if (isPattern) {
-                    value = new RestElement(value.getArgument());
+                    value = this.factory.createRestElement(value.getArgument(), value.range);
                 }
-                return new Property(value.getArgument(), value, 'init', false, false, propInfo.isComputedName);
+                const range = this.createRange(propInfo.rangeStart);
+                return this.factory.createPropertyDeclaration(value.getArgument(), value, 'init', false, false, propInfo.isComputedName, range);
             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);
+                const range = this.createRange(propInfo.rangeStart);
+                return this.factory.createPropertyDeclaration(nameExpression, value, 'init', false, false, propInfo.isComputedName, range);
             }
             case PropertyKind.Assign:
             case PropertyKind.ShorthandOrClassField:
@@ -1732,7 +1744,7 @@ export class JavaScriptInlineParser extends AbstractParser {
                 //
                 // CoverInitializedName
                 //    IdentifierReference Initializer?
-                const lhs = new Identifier(propInfo.name);
+                const lhs = this.factory.createIdentifier(propInfo.name, this.createRange(propInfo.rangeStart));
                 if (!this.isAssignableIdentifier(lhs)) {
                     throw new Error(this.errorMessage('Strict Eval Arguments'));
                 }
@@ -1742,46 +1754,51 @@ export class JavaScriptInlineParser extends AbstractParser {
                     this.setAcceptIN(true);
                     const rhs = this.parseAssignmentExpression();
                     this.restoreAcceptIN();
-                    value = new AssignmentExpression(Token.ASSIGN.getName(), lhs, rhs);
+                    value = this.factory.createAssignment(Token.ASSIGN.getName(), lhs, rhs, this.createRange(propInfo.rangeStart));
                 }
                 else {
                     value = lhs;
                 }
-                return new Property(nameExpression, value, 'init', false, propInfo.kind !== PropertyKind.Assign, propInfo.isComputedName);
+                const range = this.createRange(propInfo.rangeStart);
+                return this.factory.createPropertyDeclaration(nameExpression, value, 'init', false, propInfo.kind !== PropertyKind.Assign, propInfo.isComputedName, range);
             }
             case PropertyKind.Method: {
                 // MethodDefinition
                 //    PropertyName '(' StrictFormalParameters ')' '{' FunctionBody '}'
                 //    '*' PropertyName '(' StrictFormalParameters ')' '{' FunctionBody '}'
                 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);
+                const value = this.parseFunctionLiteral(kind, FunctionSyntaxKind.AccessorOrMethod, propInfo.name ? this.factory.createIdentifier(propInfo.name) : undefined, propInfo.rangeStart);
+                const range = this.createRange(propInfo.rangeStart);
+                return this.factory.createPropertyDeclaration(nameExpression, value, 'init', true, false, propInfo.isComputedName, range);
             }
             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);
+                const value = this.parseFunctionLiteral(kind, FunctionSyntaxKind.AccessorOrMethod, propInfo.name ? this.factory.createIdentifier(propInfo.name, this.createRange(propInfo.rangeStart)) : undefined, propInfo.rangeStart);
+                const range = this.createRange(propInfo.rangeStart);
+                return this.factory.createPropertyDeclaration(nameExpression, value, isGet ? 'get' : 'set', false, false, propInfo.isComputedName, range);
             }
             case PropertyKind.ClassField:
             case PropertyKind.NotSet:
-                return NullNode;
+                return this.factory.createNull(this.createRange(propInfo.rangeStart));
         }
     }
     parseProperty(propInfo) {
         let nextToken = this.peek();
+        propInfo.rangeStart = nextToken;
         if (this.check(Token.ASYNC)) {
             // async
             nextToken = this.peek();
             if (nextToken.isNotType(Token.MUL)
                 && propInfo.parsePropertyKindFromToken(nextToken.token)
                 || this.scanner.hasLineTerminatorBeforeNext()) {
-                return AsyncIdentifier;
+                return this.factory.createIdentifier('async', this.createRange(propInfo.rangeStart));
             }
             propInfo.kind = PropertyKind.Method;
             propInfo.funcFlag = ParseFunctionFlag.IsAsync;
         }
+        nextToken = this.peek();
         if (this.check(Token.MUL)) {
             // async*
             propInfo.kind = PropertyKind.Method;
@@ -1791,7 +1808,7 @@ export class JavaScriptInlineParser extends AbstractParser {
         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;
+                return this.factory.createIdentifier(nextToken.isType(Token.GET) ? 'get' : 'set', this.createRange(propInfo.rangeStart));
             }
             if (token.isType(Token.GET)) {
                 propInfo.kind = PropertyKind.AccessorGetter;
@@ -1851,7 +1868,7 @@ export class JavaScriptInlineParser extends AbstractParser {
                     }
                     propInfo.name = propertyName.toString();
                     this.restoreAcceptIN();
-                    return new SpreadElement(propertyName);
+                    return this.factory.createSpreadElement(propertyName, this.createRange(nextToken));
                 }
             default:
                 propertyName = this.parsePropertyOrPrivatePropertyName();
@@ -1880,7 +1897,7 @@ export class JavaScriptInlineParser extends AbstractParser {
                     this.consume(Token.LBRACK);
                     this.setAcceptIN(true);
                     const index = this.parseExpressionCoverGrammar();
-                    expression = new MemberExpression(expression, index, true);
+                    expression = this.factory.createPropertyAssignment(expression, index, true, false, this.createRange(expression));
                     this.expect(Token.RBRACK);
                     this.restoreAcceptIN();
                     break;
@@ -1888,7 +1905,7 @@ export class JavaScriptInlineParser extends AbstractParser {
                 case Token.PERIOD: {
                     this.consume(Token.PERIOD);
                     const key = this.parsePropertyOrPrivatePropertyName();
-                    expression = new MemberExpression(expression, key, false);
+                    expression = this.factory.createPropertyAssignment(expression, key, false, false, this.createRange(expression));
                     break;
                 }
                 case Token.TEMPLATE_SPAN:
@@ -1909,7 +1926,7 @@ export class JavaScriptInlineParser extends AbstractParser {
         }
         // check keyword as identifier
         if (Token.isPropertyName(next.token) && next.isNotType(Token.EOS)) {
-            return new Identifier(next.token.getName());
+            return this.factory.createIdentifier(next.token.getName(), next.range);
         }
         throw new SyntaxError(this.errorMessage(`Parsing property expression: Unexpected Token`));
     }
@@ -1949,13 +1966,13 @@ export class JavaScriptInlineParser extends AbstractParser {
                 break;
         }
         if (body) {
-            return new PipelineExpression(lhs, body);
+            return this.factory.createPipelineExpression(lhs, body, undefined, this.createRange(lhs));
         }
         if (token.isType(Token.LPAREN)) {
             // parse arrow function
             // x |> ( y => y+1 )
             body = this.parsePrimaryExpression();
-            return new PipelineExpression(lhs, body);
+            return this.factory.createPipelineExpression(lhs, body, undefined, this.createRange(lhs));
         }
         // parse angular-like and f# and partial operator syntax
         const func = this.parseMemberExpression(); //this.parseLogicalExpression();
@@ -1965,6 +1982,7 @@ export class JavaScriptInlineParser extends AbstractParser {
                 // support angular pipeline syntax
                 do {
                     this.consume(Token.COLON);
+                    const peek = this.peek();
                     const isSpread = this.check(Token.ELLIPSIS);
                     if (this.peek().isType(Token.CONDITIONAL)) {
                         this.consume(Token.CONDITIONAL);
@@ -1978,7 +1996,7 @@ export class JavaScriptInlineParser extends AbstractParser {
                     else {
                         const arg = this.parseAssignmentExpressionCoverGrammar();
                         if (isSpread) {
-                            args.push(new SpreadElement(arg));
+                            args.push(this.factory.createSpreadElement(arg, this.createRange(peek)));
                         }
                         else {
                             args.push(arg);
@@ -1991,6 +2009,7 @@ export class JavaScriptInlineParser extends AbstractParser {
                 this.consume(Token.LPAREN);
                 let indexed = false;
                 while (this.peek().isNotType(Token.RPAREN)) {
+                    const peek = this.peek();
                     const isSpread = this.check(Token.ELLIPSIS);
                     if (this.peek().isType(Token.CONDITIONAL)) {
                         this.consume(Token.CONDITIONAL);
@@ -2005,7 +2024,7 @@ export class JavaScriptInlineParser extends AbstractParser {
                     else {
                         const arg = this.parseAssignmentExpressionCoverGrammar();
                         if (isSpread) {
-                            args.push(new SpreadElement(arg));
+                            args.push(this.factory.createSpreadElement(arg, this.createRange(peek)));
                         }
                         else {
                             args.push(arg);
@@ -2017,14 +2036,14 @@ export class JavaScriptInlineParser extends AbstractParser {
                 // should be indexed, has partial operator
                 if (!indexed) {
                     // z |> method(x, y) === method(x, y)(z)
-                    body = new CallExpression(func, args);
-                    return new PipelineExpression(lhs, body);
+                    body = this.factory.createCallExpression(func, args, false, this.createRange(func));
+                    return this.factory.createPipelineExpression(lhs, body, undefined, this.createRange(lhs));
                 }
                 break;
             default:
                 break;
         }
-        return new PipelineExpression(lhs, func, args);
+        return this.factory.createPipelineExpression(lhs, func, args, this.createRange(lhs));
     }
     parseConditionalExpression() {
         // ConditionalExpression ::
@@ -2059,9 +2078,9 @@ export class JavaScriptInlineParser extends AbstractParser {
             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);
+                const isRightAssociative = op.isType(Token.EXP);
+                const nextPrecedence = isRightAssociative ? prec1 : prec1 + 1;
+                y = this.parseBinaryExpression(nextPrecedence);
                 // For now we distinguish between comparisons and other binary
                 // operations.  (We could combine the two and get rid of this
                 // code and AST node eventually.)
@@ -2077,14 +2096,14 @@ export class JavaScriptInlineParser extends AbstractParser {
                             break;
                         default: break;
                     }
-                    x = shortcutNumericLiteralBinaryExpression(x, y, cmp);
+                    x = this.factory.createInfixExpression(cmp.getName(), x, y, this.createRange(x));
                     if (op.isNotType(cmp)) {
                         // The comparison was negated - add a NOT.
-                        x = buildUnaryExpression(x, Token.NOT);
+                        x = this.factory.createUnaryExpression(Token.NOT.getName(), x, this.createRange(x));
                     }
                 }
                 else {
-                    x = shortcutNumericLiteralBinaryExpression(x, y, op.token);
+                    x = this.factory.createInfixExpression(op.token.getName(), x, y, this.createRange(x));
                 }
             }
             --prec1;
@@ -2137,11 +2156,11 @@ export class JavaScriptInlineParser extends AbstractParser {
         const expression = this.parseUnaryExpression();
         if (Token.isUnary(op.token)) {
             if (op.isType(Token.DELETE)) {
-                if (this.isIdentifier(expression) && isStrict(this.languageMode)) {
+                if (this.factory.isIdentifier(expression) && isStrict(this.languageMode)) {
                     // "delete identifier" is a syntax error in strict mode.
                     throw new Error(this.errorMessage(`"delete identifier" is a syntax error in strict mode`));
                 }
-                if (expression instanceof MemberExpression && expression.getProperty().toString().startsWith('#')) {
+                if (this.factory.isMemberExpression(expression) && expression.getProperty().toString().startsWith('#')) {
                     throw new Error(this.errorMessage(`"Delete Private Field" is a syntax error`));
                 }
             }
@@ -2151,7 +2170,7 @@ export class JavaScriptInlineParser extends AbstractParser {
         }
         if (Token.isCount(op.token) || Token.isUnary(op.token)) {
             // Allow the parser to rewrite the expression.
-            return buildUnaryExpression(expression, op.token);
+            return this.factory.createUnaryExpression(op.token.getName(), expression, op.range);
         }
         throw new Error(this.errorMessage(`while rewrite unary operation`));
     }
@@ -2169,7 +2188,7 @@ export class JavaScriptInlineParser extends AbstractParser {
             throw new Error(this.errorMessage(`Invalid LHS In Postfix Op.`));
         }
         const op = this.next();
-        return buildPostfixExpression(expression, op.token);
+        return this.factory.createUpdateExpression(op.token.getName(), expression, false, this.createRange(expression));
     }
     parseLeftHandSideExpression() {
         // LeftHandSideExpression ::
@@ -2181,7 +2200,7 @@ export class JavaScriptInlineParser extends AbstractParser {
     }
     parseLeftHandSideContinuation(result) {
         if (this.peek().isType(Token.LPAREN)
-            && this.isIdentifier(result)
+            && this.factory.isIdentifier(result)
             && this.scanner.currentToken().isType(Token.ASYNC)
             && !this.scanner.hasLineTerminatorBeforeNext()) {
             const args = this.parseArguments(ParsingArrowHeadFlag.AsyncArrowFunction);
@@ -2192,7 +2211,7 @@ export class JavaScriptInlineParser extends AbstractParser {
                 // async ( Arguments ) => ...
                 return this.expressionListToExpression(args);
             }
-            result = new CallExpression(result, args);
+            result = this.factory.createCallExpression(result, args, false, this.createRange(result));
             if (!Token.isPropertyOrCall(this.peek().token))
                 return result;
         }
@@ -2211,7 +2230,7 @@ export class JavaScriptInlineParser extends AbstractParser {
                     if (Token.isPropertyOrCall(this.peek().token))
                         continue;
                     const key = this.parsePropertyOrPrivatePropertyName();
-                    result = new MemberExpression(result, key, false, isOptional);
+                    result = this.factory.createPropertyAssignment(result, key, false, isOptional, this.createRange(result));
                     break;
                 }
                 /* Property */
@@ -2220,7 +2239,7 @@ export class JavaScriptInlineParser extends AbstractParser {
                     this.setAcceptIN(true);
                     const index = this.parseExpressionCoverGrammar();
                     this.restoreAcceptIN();
-                    result = new MemberExpression(result, index, true, isOptional);
+                    result = this.factory.createPropertyAssignment(result, index, true, isOptional, this.createRange(result));
                     this.expect(Token.RBRACK);
                     break;
                 }
@@ -2231,13 +2250,13 @@ export class JavaScriptInlineParser extends AbstractParser {
                     }
                     this.consume(Token.PERIOD);
                     const key = this.parsePropertyOrPrivatePropertyName();
-                    result = new MemberExpression(result, key, false, isOptional);
+                    result = this.factory.createPropertyAssignment(result, key, false, isOptional, this.createRange(result));
                     break;
                 }
                 /* Call */
                 case Token.LPAREN: {
                     const args = this.parseArguments();
-                    result = new CallExpression(result, args, isOptional);
+                    result = this.factory.createCallExpression(result, args, isOptional, this.createRange(result));
                     break;
                 }
                 /* bind call */
@@ -2247,7 +2266,7 @@ export class JavaScriptInlineParser extends AbstractParser {
                     }
                     this.consume(Token.BIND);
                     const key = this.parsePropertyOrPrivatePropertyName();
-                    result = new BindExpression(result, key, false, isOptional);
+                    result = this.factory.createBindExpression(result, key, false, isOptional, this.createRange(result));
                     break;
                 }
                 /* chain bind call */
@@ -2259,7 +2278,7 @@ export class JavaScriptInlineParser extends AbstractParser {
                     isOptional = true;
                     optionalChaining = true;
                     const key = this.parsePropertyOrPrivatePropertyName();
-                    result = new BindExpression(result, key, true, isOptional);
+                    result = this.factory.createBindExpression(result, key, true, isOptional, this.createRange(result));
                     break;
                 }
                 default:
@@ -2276,17 +2295,17 @@ export class JavaScriptInlineParser extends AbstractParser {
             }
         } while (Token.isPropertyOrCall(this.peek().token));
         if (optionalChaining) {
-            result = new ChainExpression(result);
+            result = this.factory.createChainExpression(result, this.createRange(result));
         }
         return result;
     }
     parseAwaitExpression() {
-        this.consume(Token.AWAIT);
+        const start = 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);
+        return this.factory.createAwaitExpression(value, this.createRange(start));
     }
     parseNullishExpression(expression) {
         // CoalesceExpression ::
@@ -2307,7 +2326,7 @@ export class JavaScriptInlineParser extends AbstractParser {
         }
         expression = list.pop();
         expression = list.reverse()
-            .reduce((previous, current) => new LogicalExpression(Token.NULLISH.getName(), current, previous), expression);
+            .reduce((previous, current) => this.factory.createLogicalExpression(Token.NULLISH.getName(), current, previous), expression);
         return expression;
     }
     parseConditionalContinuation(expression) {
@@ -2317,7 +2336,7 @@ export class JavaScriptInlineParser extends AbstractParser {
         this.restoreAcceptIN();
         this.expect(Token.COLON);
         const right = this.parseAssignmentExpression();
-        return new ConditionalExpression(expression, left, right);
+        return this.factory.createConditionalExpression(expression, left, right);
     }
     parseYieldExpression() {
         // YieldExpression ::
@@ -2352,15 +2371,15 @@ export class JavaScriptInlineParser extends AbstractParser {
                     break;
             }
         }
-        return new YieldExpression(delegating, expression);
+        return this.factory.createYieldExpression(delegating, expression);
     }
-    parseNewTargetExpression() {
+    parseNewTargetExpression(start) {
         throw new Error(this.errorMessage('Expression (new.target) not supported.'));
     }
     parseClassExpression() {
         throw new Error(this.errorMessage(`Expression (class) not supported.`));
     }
-    parseClassDeclaration(names, defaultExport) {
+    parseClassDeclaration(names, defaultExport, start) {
         throw new Error(this.errorMessage(`Expression (class) not supported.`));
     }
     parseClassLiteral(name, isStrictReserved) {
@@ -2372,5 +2391,8 @@ export class JavaScriptInlineParser extends AbstractParser {
     parseImportExpressions() {
         throw new Error(this.errorMessage('Expression (import) not supported.'));
     }
+    parseWithStatement() {
+        throw new Error(this.errorMessage('Expression (with) not supported.'));
+    }
 }
 //# sourceMappingURL=inline.js.map