meriyah 6.1.0 → 6.1.1

package/dist/meriyah.mjs

@@ -178,31 +178,31 @@ const errorMessages = {
     [177]: 'cannot use "await" in static blocks',
 };
 class ParseError extends SyntaxError {
-    constructor(start, startLine, startColumn, end, endLine, endColumn, type, ...params) {
+    constructor(start, end, type, ...params) {
         const description = errorMessages[type].replace(/%(\d+)/g, (_, i) => params[i]);
-        const message = '[' + startLine + ':' + startColumn + '-' + endLine + ':' + endColumn + ']: ' + description;
+        const message = '[' + start.line + ':' + start.column + '-' + end.line + ':' + end.column + ']: ' + description;
         super(message);
-        this.start = start;
-        this.end = end;
-        this.range = [start, end];
+        this.start = start.index;
+        this.end = end.index;
+        this.range = [start.index, end.index];
         this.loc = {
-            start: { line: startLine, column: startColumn },
-            end: { line: endLine, column: endColumn },
+            start: { line: start.line, column: start.column },
+            end: { line: end.line, column: end.column },
         };
         this.description = description;
     }
 }
 function report(parser, type, ...params) {
-    throw new ParseError(parser.tokenIndex, parser.tokenLine, parser.tokenColumn, parser.index, parser.line, parser.column, type, ...params);
+    throw new ParseError(parser.tokenStart, parser.currentLocation, type, ...params);
 }
 function reportScopeError(scope) {
-    throw new ParseError(scope.tokenIndex, scope.tokenLine, scope.tokenColumn, scope.index, scope.line, scope.column, scope.type, ...scope.params);
+    throw new ParseError(scope.start, scope.end, scope.type, ...scope.params);
 }
-function reportMessageAt(tokenIndex, tokenLine, tokenColumn, index, line, column, type, ...params) {
-    throw new ParseError(tokenIndex, tokenLine, tokenColumn, index, line, column, type, ...params);
+function reportMessageAt(start, end, type, ...params) {
+    throw new ParseError(start, end, type, ...params);
 }
-function reportScannerError(tokenIndex, tokenLine, tokenColumn, index, line, column, type) {
-    throw new ParseError(tokenIndex, tokenLine, tokenColumn, index, line, column, type);
+function reportScannerError(start, end, type) {
+    throw new ParseError(start, end, type);
 }
 
 const unicodeLookup = ((compressed, lookup) => {
@@ -700,7 +700,13 @@ function isIdentifierPart(code) {
         : isIDContinue(code) || (code === 8204 || code === 8205);
 }
 
-const CommentTypes = ['SingleLine', 'MultiLine', 'HTMLOpen', 'HTMLClose', 'HashbangComment'];
+const CommentTypes = [
+    'SingleLine',
+    'MultiLine',
+    'HTMLOpen',
+    'HTMLClose',
+    'HashbangComment',
+];
 function skipHashBang(parser) {
     const { source } = parser;
     if (parser.currentChar === 35 && source.charCodeAt(parser.index + 1) === 33) {
@@ -736,7 +742,7 @@ function skipSingleLineComment(parser, source, state, type, start, line, column)
         parser.tokenLine = parser.line;
         parser.tokenColumn = parser.column;
     }
-    if (parser.onComment) {
+    if (parser.options.onComment) {
         const loc = {
             start: {
                 line,
@@ -747,7 +753,7 @@ function skipSingleLineComment(parser, source, state, type, start, line, column)
                 column: parser.tokenColumn,
             },
         };
-        parser.onComment(CommentTypes[type & 0xff], source.slice(index, parser.tokenIndex), start, parser.tokenIndex, loc);
+        parser.options.onComment(CommentTypes[type & 0xff], source.slice(index, parser.tokenIndex), start, parser.tokenIndex, loc);
     }
     return state | 1;
 }
@@ -763,7 +769,7 @@ function skipMultiLineComment(parser, source, state) {
                 }
                 if (advanceChar(parser) === 47) {
                     advanceChar(parser);
-                    if (parser.onComment) {
+                    if (parser.options.onComment) {
                         const loc = {
                             start: {
                                 line: parser.tokenLine,
@@ -774,7 +780,7 @@ function skipMultiLineComment(parser, source, state) {
                                 column: parser.column,
                             },
                         };
-                        parser.onComment(CommentTypes[1 & 0xff], source.slice(index, parser.index - 2), index - 2, parser.index, loc);
+                        parser.options.onComment(CommentTypes[1 & 0xff], source.slice(index, parser.index - 2), index - 2, parser.index, loc);
                     }
                     parser.tokenIndex = parser.index;
                     parser.tokenLine = parser.line;
@@ -1333,7 +1339,7 @@ function scanNumber(parser, context, kind) {
                     if (char === 95) {
                         char = advanceChar(parser);
                         if (char === 95 || kind & 32) {
-                            reportScannerError(parser.index, parser.line, parser.column, parser.index + 1, parser.line, parser.column, 152);
+                            reportScannerError(parser.currentLocation, { index: parser.index + 1, line: parser.line, column: parser.column }, 152);
                         }
                         allowSeparator = 1;
                         continue;
@@ -1344,7 +1350,7 @@ function scanNumber(parser, context, kind) {
                     --digit;
                 }
                 if (allowSeparator) {
-                    reportScannerError(parser.index, parser.line, parser.column, parser.index + 1, parser.line, parser.column, 153);
+                    reportScannerError(parser.currentLocation, { index: parser.index + 1, line: parser.line, column: parser.column }, 153);
                 }
                 if (digit >= 0 && !isIdentifierStart(char) && char !== 46) {
                     parser.tokenValue = value;
@@ -1409,7 +1415,7 @@ function scanDecimalDigitsOrSeparator(parser, char) {
             const { index } = parser;
             char = advanceChar(parser);
             if (char === 95) {
-                reportScannerError(parser.index, parser.line, parser.column, parser.index + 1, parser.line, parser.column, 152);
+                reportScannerError(parser.currentLocation, { index: parser.index + 1, line: parser.line, column: parser.column }, 152);
             }
             allowSeparator = 1;
             ret += parser.source.substring(start, index);
@@ -1420,7 +1426,7 @@ function scanDecimalDigitsOrSeparator(parser, char) {
         char = advanceChar(parser);
     }
     if (allowSeparator) {
-        reportScannerError(parser.index, parser.line, parser.column, parser.index + 1, parser.line, parser.column, 153);
+        reportScannerError(parser.currentLocation, { index: parser.index + 1, line: parser.line, column: parser.column }, 153);
     }
     return ret + parser.source.substring(start, parser.index);
 }
@@ -1632,10 +1638,10 @@ function scanUnicodeEscape(parser) {
         while (CharTypes[advanceChar(parser)] & 64) {
             codePoint = (codePoint << 4) | toHex(parser.currentChar);
             if (codePoint > 1114111)
-                reportScannerError(begin, parser.line, parser.column, parser.index, parser.line, parser.column, 104);
+                reportScannerError({ index: begin, line: parser.line, column: parser.column }, parser.currentLocation, 104);
         }
         if (parser.currentChar !== 125) {
-            reportScannerError(begin, parser.line, parser.column, parser.index, parser.line, parser.column, 7);
+            reportScannerError({ index: begin, line: parser.line, column: parser.column }, parser.currentLocation, 7);
         }
         advanceChar(parser);
         return codePoint;
@@ -4380,7 +4386,7 @@ function matchOrInsertSemicolon(parser, context) {
         report(parser, 30, KeywordDescTable[parser.getToken() & 255]);
     }
     if (!consumeOpt(parser, context, 1074790417)) {
-        parser.onInsertedSemicolon?.(parser.startIndex);
+        parser.options.onInsertedSemicolon?.(parser.startIndex);
     }
 }
 function isValidStrictMode(parser, index, tokenIndex, tokenValue) {
@@ -4527,29 +4533,6 @@ function validateAndDeclareLabel(parser, labels, name) {
     }
     labels['$' + name] = 1;
 }
-function finishNode(parser, context, start, line, column, node) {
-    if (context & 2) {
-        node.start = start;
-        node.end = parser.startIndex;
-        node.range = [start, parser.startIndex];
-    }
-    if (context & 4) {
-        node.loc = {
-            start: {
-                line,
-                column,
-            },
-            end: {
-                line: parser.startLine,
-                column: parser.startColumn,
-            },
-        };
-        if (parser.sourceFile) {
-            node.loc.source = parser.sourceFile;
-        }
-    }
-    return node;
-}
 function isEqualTagName(elementName) {
     switch (elementName.type) {
         case 'JSXIdentifier':
@@ -4566,16 +4549,11 @@ function createArrowHeadParsingScope(parser, context, value) {
     return scope;
 }
 function recordScopeError(parser, type, ...params) {
-    const { index, line, column, tokenIndex, tokenLine, tokenColumn } = parser;
     return {
         type,
         params,
-        index,
-        line,
-        column,
-        tokenIndex,
-        tokenLine,
-        tokenColumn,
+        start: parser.tokenStart,
+        end: parser.currentLocation,
     };
 }
 function createScope() {
@@ -4695,7 +4673,7 @@ function validatePrivateIdentifierRefs(scope) {
     for (const name in scope.refs) {
         if (!isPrivateIdentifierDefined(name, scope)) {
             const { index, line, column } = scope.refs[name][0];
-            throw new ParseError(index, line, column, index + name.length, line, column + name.length, 4, name);
+            throw new ParseError({ index, line, column }, { index: index + name.length, line, column: column + name.length }, 4, name);
         }
     }
 }
@@ -4712,39 +4690,6 @@ function addBindingToExports(parser, name) {
         parser.exportedBindings['#' + name] = 1;
     }
 }
-function pushComment(context, array) {
-    return function (type, value, start, end, loc) {
-        const comment = {
-            type,
-            value,
-        };
-        if (context & 2) {
-            comment.start = start;
-            comment.end = end;
-            comment.range = [start, end];
-        }
-        if (context & 4) {
-            comment.loc = loc;
-        }
-        array.push(comment);
-    };
-}
-function pushToken(context, array) {
-    return function (token, start, end, loc) {
-        const tokens = {
-            token,
-        };
-        if (context & 2) {
-            tokens.start = start;
-            tokens.end = end;
-            tokens.range = [start, end];
-        }
-        if (context & 4) {
-            tokens.loc = loc;
-        }
-        array.push(tokens);
-    };
-}
 function isValidIdentifier(context, t) {
     if (context & (256 | 262144)) {
         if (context & 512 && t === 209006)
@@ -4765,72 +4710,134 @@ function classifyIdentifier(parser, context, t) {
         report(parser, 0);
 }
 
-function create(source, sourceFile, onComment, onToken, onInsertedSemicolon) {
-    let token = 1048576;
-    let lastOnToken = null;
-    return {
-        source,
-        flags: 0,
-        index: 0,
-        line: 1,
-        column: 0,
-        startIndex: 0,
-        end: source.length,
-        tokenIndex: 0,
-        startColumn: 0,
-        tokenColumn: 0,
-        tokenLine: 1,
-        startLine: 1,
-        sourceFile,
-        tokenValue: '',
-        getToken() {
-            return token;
-        },
-        setToken(value, replaceLast = false) {
-            if (onToken) {
-                if (value !== 1048576) {
-                    const loc = {
-                        start: {
-                            line: this.tokenLine,
-                            column: this.tokenColumn,
-                        },
-                        end: {
-                            line: this.line,
-                            column: this.column,
-                        },
-                    };
-                    if (!replaceLast && lastOnToken) {
-                        onToken(...lastOnToken);
-                    }
-                    lastOnToken = [convertTokenType(value), this.tokenIndex, this.index, loc];
+class Parser {
+    constructor(source, options = {}) {
+        this.source = source;
+        this.options = options;
+        this.lastOnToken = null;
+        this.token = 1048576;
+        this.flags = 0;
+        this.index = 0;
+        this.line = 1;
+        this.column = 0;
+        this.startIndex = 0;
+        this.end = 0;
+        this.tokenIndex = 0;
+        this.startColumn = 0;
+        this.tokenColumn = 0;
+        this.tokenLine = 1;
+        this.startLine = 1;
+        this.tokenValue = '';
+        this.tokenRaw = '';
+        this.tokenRegExp = void 0;
+        this.currentChar = 0;
+        this.exportedNames = {};
+        this.exportedBindings = {};
+        this.assignable = 1;
+        this.destructible = 0;
+        this.leadingDecorators = { decorators: [] };
+        this.end = source.length;
+        this.currentChar = source.charCodeAt(0);
+    }
+    getToken() {
+        return this.token;
+    }
+    setToken(value, replaceLast = false) {
+        this.token = value;
+        const { onToken } = this.options;
+        if (onToken) {
+            if (value !== 1048576) {
+                const loc = {
+                    start: {
+                        line: this.tokenLine,
+                        column: this.tokenColumn,
+                    },
+                    end: {
+                        line: this.line,
+                        column: this.column,
+                    },
+                };
+                if (!replaceLast && this.lastOnToken) {
+                    onToken(...this.lastOnToken);
                 }
-                else {
-                    if (lastOnToken) {
-                        onToken(...lastOnToken);
-                        lastOnToken = null;
-                    }
+                this.lastOnToken = [convertTokenType(value), this.tokenIndex, this.index, loc];
+            }
+            else {
+                if (this.lastOnToken) {
+                    onToken(...this.lastOnToken);
+                    this.lastOnToken = null;
                 }
             }
-            return (token = value);
-        },
-        tokenRaw: '',
-        tokenRegExp: void 0,
-        currentChar: source.charCodeAt(0),
-        exportedNames: [],
-        exportedBindings: [],
-        assignable: 1,
-        destructible: 0,
-        onComment,
-        onToken,
-        onInsertedSemicolon,
-        leadingDecorators: [],
+        }
+        return value;
+    }
+    get tokenStart() {
+        return {
+            index: this.tokenIndex,
+            line: this.tokenLine,
+            column: this.tokenColumn,
+        };
+    }
+    get currentLocation() {
+        return { index: this.index, line: this.line, column: this.column };
+    }
+    finishNode(node, start, end) {
+        if (this.options.shouldAddRanges) {
+            node.start = start.index;
+            const endIndex = end ? end.index : this.startIndex;
+            node.end = endIndex;
+            node.range = [start.index, endIndex];
+        }
+        if (this.options.shouldAddLoc) {
+            node.loc = {
+                start: {
+                    line: start.line,
+                    column: start.column,
+                },
+                end: end ? { line: end.line, column: end.column } : { line: this.startLine, column: this.startColumn },
+            };
+            if (this.options.sourceFile) {
+                node.loc.source = this.options.sourceFile;
+            }
+        }
+        return node;
+    }
+}
+function pushComment(comments, options) {
+    return function (type, value, start, end, loc) {
+        const comment = {
+            type,
+            value,
+        };
+        if (options.shouldAddRanges) {
+            comment.start = start;
+            comment.end = end;
+            comment.range = [start, end];
+        }
+        if (options.shouldAddLoc) {
+            comment.loc = loc;
+        }
+        comments.push(comment);
     };
 }
+function pushToken(tokens, options) {
+    return function (type, start, end, loc) {
+        const token = {
+            token: type,
+        };
+        if (options.shouldAddRanges) {
+            token.start = start;
+            token.end = end;
+            token.range = [start, end];
+        }
+        if (options.shouldAddLoc) {
+            token.loc = loc;
+        }
+        tokens.push(token);
+    };
+}
+
 function parseSource(source, options, context) {
-    let sourceFile = '';
-    let onComment;
-    let onInsertedSemicolon;
-    let onToken;
     if (options != null) {
         if (options.module)
             context |= 512 | 256;
@@ -4856,18 +4863,28 @@ function parseSource(source, options, context) {
             context |= 256;
         if (options.jsx)
             context |= 8;
+    }
+    const parserOptions = {
+        shouldAddLoc: Boolean(context & 4),
+        shouldAddRanges: Boolean(context & 2),
+    };
+    if (options != null) {
         if (options.source)
-            sourceFile = options.source;
+            parserOptions.sourceFile = options.source;
         if (options.onComment != null) {
-            onComment = Array.isArray(options.onComment) ? pushComment(context, options.onComment) : options.onComment;
+            parserOptions.onComment = Array.isArray(options.onComment)
+                ? pushComment(options.onComment, parserOptions)
+                : options.onComment;
         }
         if (options.onInsertedSemicolon != null)
-            onInsertedSemicolon = options.onInsertedSemicolon;
+            parserOptions.onInsertedSemicolon = options.onInsertedSemicolon;
         if (options.onToken != null) {
-            onToken = Array.isArray(options.onToken) ? pushToken(context, options.onToken) : options.onToken;
+            parserOptions.onToken = Array.isArray(options.onToken)
+                ? pushToken(options.onToken, parserOptions)
+                : options.onToken;
         }
     }
-    const parser = create(source, sourceFile, onComment, onToken, onInsertedSemicolon);
+    const parser = new Parser(source, parserOptions);
     skipHashBang(parser);
     const scope = context & 16 ? createScope() : void 0;
     let body = [];
@@ -4885,43 +4902,29 @@ function parseSource(source, options, context) {
     else {
         body = parseStatementList(parser, context | 2048, scope);
     }
-    const node = {
+    return parser.finishNode({
         type: 'Program',
         sourceType,
         body,
-    };
-    if (context & 2) {
-        node.start = 0;
-        node.end = source.length;
-        node.range = [0, source.length];
-    }
-    if (context & 4) {
-        node.loc = {
-            start: { line: 1, column: 0 },
-            end: { line: parser.line, column: parser.column },
-        };
-        if (parser.sourceFile)
-            node.loc.source = sourceFile;
-    }
-    return node;
+    }, { index: 0, line: 1, column: 0 }, parser.currentLocation);
 }
 function parseStatementList(parser, context, scope) {
     nextToken(parser, context | 8192 | 67108864);
     const statements = [];
     while (parser.getToken() === 134283267) {
-        const { index, tokenIndex, tokenValue, tokenLine, tokenColumn } = parser;
+        const { index, tokenValue, tokenStart, tokenIndex } = parser;
         const token = parser.getToken();
         const expr = parseLiteral(parser, context);
         if (isValidStrictMode(parser, index, tokenIndex, tokenValue)) {
             context |= 256;
             if (parser.flags & 64) {
-                reportMessageAt(parser.tokenIndex, parser.tokenLine, parser.tokenColumn, parser.index, parser.line, parser.column, 9);
+                reportMessageAt(parser.tokenStart, parser.currentLocation, 9);
             }
             if (parser.flags & 4096) {
-                reportMessageAt(parser.tokenIndex, parser.tokenLine, parser.tokenColumn, parser.index, parser.line, parser.column, 15);
+                reportMessageAt(parser.tokenStart, parser.currentLocation, 15);
             }
         }
-        statements.push(parseDirective(parser, context, expr, token, tokenIndex, tokenLine, tokenColumn));
+        statements.push(parseDirective(parser, context, expr, token, tokenStart));
     }
     while (parser.getToken() !== 1048576) {
         statements.push(parseStatementListItem(parser, context, scope, undefined, 4, {}));
@@ -4932,9 +4935,9 @@ function parseModuleItemList(parser, context, scope) {
     nextToken(parser, context | 8192);
     const statements = [];
     while (parser.getToken() === 134283267) {
-        const { tokenIndex, tokenLine, tokenColumn } = parser;
+        const { tokenStart } = parser;
         const token = parser.getToken();
-        statements.push(parseDirective(parser, context, parseLiteral(parser, context), token, tokenIndex, tokenLine, tokenColumn));
+        statements.push(parseDirective(parser, context, parseLiteral(parser, context), token, tokenStart));
     }
     while (parser.getToken() !== 1048576) {
         statements.push(parseModuleItem(parser, context, scope));
@@ -4942,7 +4945,12 @@ function parseModuleItemList(parser, context, scope) {
     return statements;
 }
 function parseModuleItem(parser, context, scope) {
-    parser.leadingDecorators = parseDecorators(parser, context, undefined);
+    if (parser.getToken() === 132) {
+        Object.assign(parser.leadingDecorators, {
+            start: parser.tokenStart,
+            decorators: parseDecorators(parser, context, undefined),
+        });
+    }
     let moduleItem;
     switch (parser.getToken()) {
         case 20564:
@@ -4954,77 +4962,75 @@ function parseModuleItem(parser, context, scope) {
         default:
             moduleItem = parseStatementListItem(parser, context, scope, undefined, 4, {});
     }
-    if (parser.leadingDecorators.length) {
+    if (parser.leadingDecorators?.decorators.length) {
         report(parser, 170);
     }
     return moduleItem;
 }
 function parseStatementListItem(parser, context, scope, privateScope, origin, labels) {
-    const start = parser.tokenIndex;
-    const line = parser.tokenLine;
-    const column = parser.tokenColumn;
+    const start = parser.tokenStart;
     switch (parser.getToken()) {
         case 86104:
-            return parseFunctionDeclaration(parser, context, scope, privateScope, origin, 1, 0, 0, start, line, column);
+            return parseFunctionDeclaration(parser, context, scope, privateScope, origin, 1, 0, 0, start);
         case 132:
         case 86094:
-            return parseClassDeclaration(parser, context, scope, privateScope, 0, start, line, column);
+            return parseClassDeclaration(parser, context, scope, privateScope, 0);
         case 86090:
-            return parseLexicalDeclaration(parser, context, scope, privateScope, 16, 0, start, line, column);
+            return parseLexicalDeclaration(parser, context, scope, privateScope, 16, 0);
         case 241737:
-            return parseLetIdentOrVarDeclarationStatement(parser, context, scope, privateScope, origin, start, line, column);
+            return parseLetIdentOrVarDeclarationStatement(parser, context, scope, privateScope, origin);
         case 20564:
             report(parser, 103, 'export');
         case 86106:
             nextToken(parser, context);
             switch (parser.getToken()) {
                 case 67174411:
-                    return parseImportCallDeclaration(parser, context, privateScope, start, line, column);
+                    return parseImportCallDeclaration(parser, context, privateScope, start);
                 case 67108877:
-                    return parseImportMetaDeclaration(parser, context, start, line, column);
+                    return parseImportMetaDeclaration(parser, context);
                 default:
                     report(parser, 103, 'import');
             }
         case 209005:
-            return parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, privateScope, origin, labels, 1, start, line, column);
+            return parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, privateScope, origin, labels, 1);
         default:
-            return parseStatement(parser, context, scope, privateScope, origin, labels, 1, start, line, column);
+            return parseStatement(parser, context, scope, privateScope, origin, labels, 1);
     }
 }
-function parseStatement(parser, context, scope, privateScope, origin, labels, allowFuncDecl, start, line, column) {
+function parseStatement(parser, context, scope, privateScope, origin, labels, allowFuncDecl) {
     switch (parser.getToken()) {
         case 86088:
-            return parseVariableStatement(parser, context, scope, privateScope, 0, start, line, column);
+            return parseVariableStatement(parser, context, scope, privateScope, 0);
         case 20572:
-            return parseReturnStatement(parser, context, privateScope, start, line, column);
+            return parseReturnStatement(parser, context, privateScope);
         case 20569:
-            return parseIfStatement(parser, context, scope, privateScope, labels, start, line, column);
+            return parseIfStatement(parser, context, scope, privateScope, labels);
         case 20567:
-            return parseForStatement(parser, context, scope, privateScope, labels, start, line, column);
+            return parseForStatement(parser, context, scope, privateScope, labels);
         case 20562:
-            return parseDoWhileStatement(parser, context, scope, privateScope, labels, start, line, column);
+            return parseDoWhileStatement(parser, context, scope, privateScope, labels);
         case 20578:
-            return parseWhileStatement(parser, context, scope, privateScope, labels, start, line, column);
+            return parseWhileStatement(parser, context, scope, privateScope, labels);
         case 86110:
-            return parseSwitchStatement(parser, context, scope, privateScope, labels, start, line, column);
+            return parseSwitchStatement(parser, context, scope, privateScope, labels);
         case 1074790417:
-            return parseEmptyStatement(parser, context, start, line, column);
+            return parseEmptyStatement(parser, context);
         case 2162700:
-            return parseBlock(parser, context, scope ? addChildScope(scope, 2) : scope, privateScope, labels, start, line, column);
+            return parseBlock(parser, context, scope ? addChildScope(scope, 2) : scope, privateScope, labels, parser.tokenStart);
         case 86112:
-            return parseThrowStatement(parser, context, privateScope, start, line, column);
+            return parseThrowStatement(parser, context, privateScope);
         case 20555:
-            return parseBreakStatement(parser, context, labels, start, line, column);
+            return parseBreakStatement(parser, context, labels);
         case 20559:
-            return parseContinueStatement(parser, context, labels, start, line, column);
+            return parseContinueStatement(parser, context, labels);
         case 20577:
-            return parseTryStatement(parser, context, scope, privateScope, labels, start, line, column);
+            return parseTryStatement(parser, context, scope, privateScope, labels);
         case 20579:
-            return parseWithStatement(parser, context, scope, privateScope, labels, start, line, column);
+            return parseWithStatement(parser, context, scope, privateScope, labels);
         case 20560:
-            return parseDebuggerStatement(parser, context, start, line, column);
+            return parseDebuggerStatement(parser, context);
         case 209005:
-            return parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, privateScope, origin, labels, 0, start, line, column);
+            return parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, privateScope, origin, labels, 0);
         case 20557:
             report(parser, 162);
         case 20566:
@@ -5038,11 +5044,11 @@ function parseStatement(parser, context, scope, privateScope, origin, labels, al
         case 86094:
             report(parser, 79);
         default:
-            return parseExpressionOrLabelledStatement(parser, context, scope, privateScope, origin, labels, allowFuncDecl, start, line, column);
+            return parseExpressionOrLabelledStatement(parser, context, scope, privateScope, origin, labels, allowFuncDecl);
     }
 }
-function parseExpressionOrLabelledStatement(parser, context, scope, privateScope, origin, labels, allowFuncDecl, start, line, column) {
-    const { tokenValue } = parser;
+function parseExpressionOrLabelledStatement(parser, context, scope, privateScope, origin, labels, allowFuncDecl) {
+    const { tokenValue, tokenStart } = parser;
     const token = parser.getToken();
     let expr;
     switch (token) {
@@ -5054,51 +5060,52 @@ function parseExpressionOrLabelledStatement(parser, context, scope, privateScope
                 report(parser, 84);
             break;
         default:
-            expr = parsePrimaryExpression(parser, context, privateScope, 2, 0, 1, 0, 1, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+            expr = parsePrimaryExpression(parser, context, privateScope, 2, 0, 1, 0, 1, parser.tokenStart);
     }
     if (token & 143360 && parser.getToken() === 21) {
-        return parseLabelledStatement(parser, context, scope, privateScope, origin, labels, tokenValue, expr, token, allowFuncDecl, start, line, column);
+        return parseLabelledStatement(parser, context, scope, privateScope, origin, labels, tokenValue, expr, token, allowFuncDecl, tokenStart);
     }
-    expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 0, 0, start, line, column);
-    expr = parseAssignmentExpression(parser, context, privateScope, 0, 0, start, line, column, expr);
+    expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 0, 0, tokenStart);
+    expr = parseAssignmentExpression(parser, context, privateScope, 0, 0, tokenStart, expr);
     if (parser.getToken() === 18) {
-        expr = parseSequenceExpression(parser, context, privateScope, 0, start, line, column, expr);
+        expr = parseSequenceExpression(parser, context, privateScope, 0, tokenStart, expr);
     }
-    return parseExpressionStatement(parser, context, expr, start, line, column);
+    return parseExpressionStatement(parser, context, expr, tokenStart);
 }
-function parseBlock(parser, context, scope, privateScope, labels, start, line, column, type = 'BlockStatement') {
+function parseBlock(parser, context, scope, privateScope, labels, start, type = 'BlockStatement') {
     const body = [];
     consume(parser, context | 8192, 2162700);
     while (parser.getToken() !== 1074790415) {
         body.push(parseStatementListItem(parser, context, scope, privateScope, 2, { $: labels }));
     }
     consume(parser, context | 8192, 1074790415);
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type,
         body,
-    });
+    }, start);
 }
-function parseReturnStatement(parser, context, privateScope, start, line, column) {
+function parseReturnStatement(parser, context, privateScope) {
     if ((context & 1048576) === 0)
         report(parser, 92);
+    const start = parser.tokenStart;
     nextToken(parser, context | 8192);
     const argument = parser.flags & 1 || parser.getToken() & 1048576
         ? null
-        : parseExpressions(parser, context, privateScope, 0, 1, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+        : parseExpressions(parser, context, privateScope, 0, 1, parser.tokenStart);
     matchOrInsertSemicolon(parser, context | 8192);
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'ReturnStatement',
         argument,
-    });
+    }, start);
 }
-function parseExpressionStatement(parser, context, expression, start, line, column) {
+function parseExpressionStatement(parser, context, expression, start) {
     matchOrInsertSemicolon(parser, context | 8192);
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'ExpressionStatement',
         expression,
-    });
+    }, start);
 }
-function parseLabelledStatement(parser, context, scope, privateScope, origin, labels, value, expr, token, allowFuncDecl, start, line, column) {
+function parseLabelledStatement(parser, context, scope, privateScope, origin, labels, value, expr, token, allowFuncDecl, start) {
     validateBindingIdentifier(parser, context, 0, token, 1);
     validateAndDeclareLabel(parser, labels, value);
     nextToken(parser, context | 8192);
@@ -5106,37 +5113,37 @@ function parseLabelledStatement(parser, context, scope, privateScope, origin, la
         (context & 256) === 0 &&
         context & 64 &&
         parser.getToken() === 86104
-        ? parseFunctionDeclaration(parser, context, addChildScope(scope, 2), privateScope, origin, 0, 0, 0, parser.tokenIndex, parser.tokenLine, parser.tokenColumn)
-        : parseStatement(parser, context, scope, privateScope, origin, labels, allowFuncDecl, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
-    return finishNode(parser, context, start, line, column, {
+        ? parseFunctionDeclaration(parser, context, addChildScope(scope, 2), privateScope, origin, 0, 0, 0, parser.tokenStart)
+        : parseStatement(parser, context, scope, privateScope, origin, labels, allowFuncDecl);
+    return parser.finishNode({
         type: 'LabeledStatement',
         label: expr,
         body,
-    });
+    }, start);
 }
-function parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, privateScope, origin, labels, allowFuncDecl, start, line, column) {
-    const { tokenValue } = parser;
+function parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, privateScope, origin, labels, allowFuncDecl) {
+    const { tokenValue, tokenStart: start } = parser;
     const token = parser.getToken();
     let expr = parseIdentifier(parser, context);
     if (parser.getToken() === 21) {
-        return parseLabelledStatement(parser, context, scope, privateScope, origin, labels, tokenValue, expr, token, 1, start, line, column);
+        return parseLabelledStatement(parser, context, scope, privateScope, origin, labels, tokenValue, expr, token, 1, start);
     }
     const asyncNewLine = parser.flags & 1;
     if (!asyncNewLine) {
         if (parser.getToken() === 86104) {
             if (!allowFuncDecl)
                 report(parser, 123);
-            return parseFunctionDeclaration(parser, context, scope, privateScope, origin, 1, 0, 1, start, line, column);
+            return parseFunctionDeclaration(parser, context, scope, privateScope, origin, 1, 0, 1, start);
         }
         if (isValidIdentifier(context, parser.getToken())) {
-            expr = parseAsyncArrowAfterIdent(parser, context, privateScope, 1, start, line, column);
+            expr = parseAsyncArrowAfterIdent(parser, context, privateScope, 1, start);
             if (parser.getToken() === 18)
-                expr = parseSequenceExpression(parser, context, privateScope, 0, start, line, column, expr);
-            return parseExpressionStatement(parser, context, expr, start, line, column);
+                expr = parseSequenceExpression(parser, context, privateScope, 0, start, expr);
+            return parseExpressionStatement(parser, context, expr, start);
         }
     }
     if (parser.getToken() === 67174411) {
-        expr = parseAsyncArrowOrCallExpression(parser, context, privateScope, expr, 1, 1, 0, asyncNewLine, start, line, column);
+        expr = parseAsyncArrowOrCallExpression(parser, context, privateScope, expr, 1, 1, 0, asyncNewLine, start);
     }
     else {
         if (parser.getToken() === 10) {
@@ -5144,89 +5151,92 @@ function parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, priva
             if ((token & 36864) === 36864) {
                 parser.flags |= 256;
             }
-            expr = parseArrowFromIdentifier(parser, context | 524288, privateScope, parser.tokenValue, expr, 0, 1, 0, start, line, column);
+            expr = parseArrowFromIdentifier(parser, context | 524288, privateScope, parser.tokenValue, expr, 0, 1, 0, start);
         }
         parser.assignable = 1;
     }
-    expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 0, 0, start, line, column);
-    expr = parseAssignmentExpression(parser, context, privateScope, 0, 0, start, line, column, expr);
+    expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 0, 0, start);
+    expr = parseAssignmentExpression(parser, context, privateScope, 0, 0, start, expr);
     parser.assignable = 1;
     if (parser.getToken() === 18) {
-        expr = parseSequenceExpression(parser, context, privateScope, 0, start, line, column, expr);
+        expr = parseSequenceExpression(parser, context, privateScope, 0, start, expr);
     }
-    return parseExpressionStatement(parser, context, expr, start, line, column);
+    return parseExpressionStatement(parser, context, expr, start);
 }
-function parseDirective(parser, context, expression, token, start, line, column) {
+function parseDirective(parser, context, expression, token, start) {
     const endIndex = parser.startIndex;
     if (token !== 1074790417) {
         parser.assignable = 2;
-        expression = parseMemberOrUpdateExpression(parser, context, undefined, expression, 0, 0, start, line, column);
+        expression = parseMemberOrUpdateExpression(parser, context, undefined, expression, 0, 0, start);
         if (parser.getToken() !== 1074790417) {
-            expression = parseAssignmentExpression(parser, context, undefined, 0, 0, start, line, column, expression);
+            expression = parseAssignmentExpression(parser, context, undefined, 0, 0, start, expression);
             if (parser.getToken() === 18) {
-                expression = parseSequenceExpression(parser, context, undefined, 0, start, line, column, expression);
+                expression = parseSequenceExpression(parser, context, undefined, 0, start, expression);
             }
         }
         matchOrInsertSemicolon(parser, context | 8192);
     }
-    return expression.type === 'Literal' && typeof expression.value === 'string'
-        ? finishNode(parser, context, start, line, column, {
-            type: 'ExpressionStatement',
-            expression,
-            directive: parser.source.slice(start + 1, endIndex - 1),
-        })
-        : finishNode(parser, context, start, line, column, {
-            type: 'ExpressionStatement',
-            expression,
-        });
+    const node = {
+        type: 'ExpressionStatement',
+        expression,
+    };
+    if (expression.type === 'Literal' && typeof expression.value === 'string') {
+        node.directive = parser.source.slice(start.index + 1, endIndex - 1);
+    }
+    return parser.finishNode(node, start);
 }
-function parseEmptyStatement(parser, context, start, line, column) {
+function parseEmptyStatement(parser, context) {
+    const start = parser.tokenStart;
     nextToken(parser, context | 8192);
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'EmptyStatement',
-    });
+    }, start);
 }
-function parseThrowStatement(parser, context, privateScope, start, line, column) {
+function parseThrowStatement(parser, context, privateScope) {
+    const start = parser.tokenStart;
     nextToken(parser, context | 8192);
     if (parser.flags & 1)
         report(parser, 90);
-    const argument = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+    const argument = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenStart);
     matchOrInsertSemicolon(parser, context | 8192);
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'ThrowStatement',
         argument,
-    });
+    }, start);
 }
-function parseIfStatement(parser, context, scope, privateScope, labels, start, line, column) {
+function parseIfStatement(parser, context, scope, privateScope, labels) {
+    const start = parser.tokenStart;
     nextToken(parser, context);
     consume(parser, context | 8192, 67174411);
     parser.assignable = 1;
-    const test = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenIndex, parser.line, parser.tokenColumn);
+    const test = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenStart);
     consume(parser, context | 8192, 16);
-    const consequent = parseConsequentOrAlternative(parser, context, scope, privateScope, labels, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+    const consequent = parseConsequentOrAlternative(parser, context, scope, privateScope, labels);
     let alternate = null;
     if (parser.getToken() === 20563) {
         nextToken(parser, context | 8192);
-        alternate = parseConsequentOrAlternative(parser, context, scope, privateScope, labels, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+        alternate = parseConsequentOrAlternative(parser, context, scope, privateScope, labels);
     }
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'IfStatement',
         test,
         consequent,
         alternate,
-    });
+    }, start);
 }
-function parseConsequentOrAlternative(parser, context, scope, privateScope, labels, start, line, column) {
+function parseConsequentOrAlternative(parser, context, scope, privateScope, labels) {
+    const { tokenStart } = parser;
     return context & 256 ||
         (context & 64) === 0 ||
         parser.getToken() !== 86104
-        ? parseStatement(parser, context, scope, privateScope, 0, { $: labels }, 0, parser.tokenIndex, parser.tokenLine, parser.tokenColumn)
-        : parseFunctionDeclaration(parser, context, addChildScope(scope, 2), privateScope, 0, 0, 0, 0, start, line, column);
+        ? parseStatement(parser, context, scope, privateScope, 0, { $: labels }, 0)
+        : parseFunctionDeclaration(parser, context, addChildScope(scope, 2), privateScope, 0, 0, 0, 0, tokenStart);
 }
-function parseSwitchStatement(parser, context, scope, privateScope, labels, start, line, column) {
+function parseSwitchStatement(parser, context, scope, privateScope, labels) {
+    const start = parser.tokenStart;
     nextToken(parser, context);
     consume(parser, context | 8192, 67174411);
-    const discriminant = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+    const discriminant = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenStart);
     consume(parser, context, 16);
     consume(parser, context, 2162700);
     const cases = [];
@@ -5234,11 +5244,11 @@ function parseSwitchStatement(parser, context, scope, privateScope, labels, star
     if (scope)
         scope = addChildScope(scope, 8);
     while (parser.getToken() !== 1074790415) {
-        const { tokenIndex, tokenLine, tokenColumn } = parser;
+        const { tokenStart } = parser;
         let test = null;
         const consequent = [];
         if (consumeOpt(parser, context | 8192, 20556)) {
-            test = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+            test = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenStart);
         }
         else {
             consume(parser, context | 8192, 20561);
@@ -5254,37 +5264,39 @@ function parseSwitchStatement(parser, context, scope, privateScope, labels, star
                 $: labels,
             }));
         }
-        cases.push(finishNode(parser, context, tokenIndex, tokenLine, tokenColumn, {
+        cases.push(parser.finishNode({
             type: 'SwitchCase',
             test,
             consequent,
-        }));
+        }, tokenStart));
     }
     consume(parser, context | 8192, 1074790415);
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'SwitchStatement',
         discriminant,
         cases,
-    });
+    }, start);
 }
-function parseWhileStatement(parser, context, scope, privateScope, labels, start, line, column) {
+function parseWhileStatement(parser, context, scope, privateScope, labels) {
+    const start = parser.tokenStart;
     nextToken(parser, context);
     consume(parser, context | 8192, 67174411);
-    const test = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+    const test = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenStart);
     consume(parser, context | 8192, 16);
     const body = parseIterationStatementBody(parser, context, scope, privateScope, labels);
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'WhileStatement',
         test,
         body,
-    });
+    }, start);
 }
 function parseIterationStatementBody(parser, context, scope, privateScope, labels) {
-    return parseStatement(parser, ((context | 33554432) ^ 33554432) | 32768, scope, privateScope, 0, { loop: 1, $: labels }, 0, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+    return parseStatement(parser, ((context | 33554432) ^ 33554432) | 32768, scope, privateScope, 0, { loop: 1, $: labels }, 0);
 }
-function parseContinueStatement(parser, context, labels, start, line, column) {
+function parseContinueStatement(parser, context, labels) {
     if ((context & 32768) === 0)
         report(parser, 68);
+    const start = parser.tokenStart;
     nextToken(parser, context);
     let label = null;
     if ((parser.flags & 1) === 0 && parser.getToken() & 143360) {
@@ -5294,12 +5306,13 @@ function parseContinueStatement(parser, context, labels, start, line, column) {
             report(parser, 138, tokenValue);
     }
     matchOrInsertSemicolon(parser, context | 8192);
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'ContinueStatement',
         label,
-    });
+    }, start);
 }
-function parseBreakStatement(parser, context, labels, start, line, column) {
+function parseBreakStatement(parser, context, labels) {
+    const start = parser.tokenStart;
     nextToken(parser, context | 8192);
     let label = null;
     if ((parser.flags & 1) === 0 && parser.getToken() & 143360) {
@@ -5312,58 +5325,61 @@ function parseBreakStatement(parser, context, labels, start, line, column) {
         report(parser, 69);
     }
     matchOrInsertSemicolon(parser, context | 8192);
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'BreakStatement',
         label,
-    });
+    }, start);
 }
-function parseWithStatement(parser, context, scope, privateScope, labels, start, line, column) {
+function parseWithStatement(parser, context, scope, privateScope, labels) {
+    const start = parser.tokenStart;
     nextToken(parser, context);
     if (context & 256)
         report(parser, 91);
     consume(parser, context | 8192, 67174411);
-    const object = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+    const object = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenStart);
     consume(parser, context | 8192, 16);
-    const body = parseStatement(parser, context, scope, privateScope, 2, labels, 0, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
-    return finishNode(parser, context, start, line, column, {
+    const body = parseStatement(parser, context, scope, privateScope, 2, labels, 0);
+    return parser.finishNode({
         type: 'WithStatement',
         object,
         body,
-    });
+    }, start);
 }
-function parseDebuggerStatement(parser, context, start, line, column) {
+function parseDebuggerStatement(parser, context) {
+    const start = parser.tokenStart;
     nextToken(parser, context | 8192);
     matchOrInsertSemicolon(parser, context | 8192);
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'DebuggerStatement',
-    });
+    }, start);
 }
-function parseTryStatement(parser, context, scope, privateScope, labels, start, line, column) {
+function parseTryStatement(parser, context, scope, privateScope, labels) {
+    const start = parser.tokenStart;
     nextToken(parser, context | 8192);
     const firstScope = scope ? addChildScope(scope, 32) : void 0;
-    const block = parseBlock(parser, context, firstScope, privateScope, { $: labels }, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
-    const { tokenIndex, tokenLine, tokenColumn } = parser;
+    const block = parseBlock(parser, context, firstScope, privateScope, { $: labels }, parser.tokenStart);
+    const { tokenStart } = parser;
     const handler = consumeOpt(parser, context | 8192, 20557)
-        ? parseCatchBlock(parser, context, scope, privateScope, labels, tokenIndex, tokenLine, tokenColumn)
+        ? parseCatchBlock(parser, context, scope, privateScope, labels, tokenStart)
         : null;
     let finalizer = null;
     if (parser.getToken() === 20566) {
         nextToken(parser, context | 8192);
         const finalizerScope = firstScope ? addChildScope(scope, 4) : void 0;
-        const block = parseBlock(parser, context, finalizerScope, privateScope, { $: labels }, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+        const block = parseBlock(parser, context, finalizerScope, privateScope, { $: labels }, parser.tokenStart);
         finalizer = block;
     }
     if (!handler && !finalizer) {
         report(parser, 88);
     }
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'TryStatement',
         block,
         handler,
         finalizer,
-    });
+    }, start);
 }
-function parseCatchBlock(parser, context, scope, privateScope, labels, start, line, column) {
+function parseCatchBlock(parser, context, scope, privateScope, labels, start) {
     let param = null;
     let additionalScope = scope;
     if (consumeOpt(parser, context, 67174411)) {
@@ -5371,7 +5387,7 @@ function parseCatchBlock(parser, context, scope, privateScope, labels, start, li
             scope = addChildScope(scope, 4);
         param = parseBindingPattern(parser, context, scope, privateScope, (parser.getToken() & 2097152) === 2097152
             ? 256
-            : 512, 0, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+            : 512, 0);
         if (parser.getToken() === 18) {
             report(parser, 86);
         }
@@ -5382,14 +5398,14 @@ function parseCatchBlock(parser, context, scope, privateScope, labels, start, li
     }
     if (scope)
         additionalScope = addChildScope(scope, 64);
-    const body = parseBlock(parser, context, additionalScope, privateScope, { $: labels }, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
-    return finishNode(parser, context, start, line, column, {
+    const body = parseBlock(parser, context, additionalScope, privateScope, { $: labels }, parser.tokenStart);
+    return parser.finishNode({
         type: 'CatchClause',
         param,
         body,
-    });
+    }, start);
 }
-function parseStaticBlock(parser, context, scope, privateScope, start, line, column) {
+function parseStaticBlock(parser, context, scope, privateScope, start) {
     if (scope)
         scope = addChildScope(scope, 2);
     const ctorContext = 131072 | 1048576 | 262144 | 1024 | 32768;
@@ -5399,76 +5415,79 @@ function parseStaticBlock(parser, context, scope, privateScope, start, line, col
             524288 |
             268435456 |
             16777216;
-    return parseBlock(parser, context, scope, privateScope, {}, start, line, column, 'StaticBlock');
+    return parseBlock(parser, context, scope, privateScope, {}, start, 'StaticBlock');
 }
-function parseDoWhileStatement(parser, context, scope, privateScope, labels, start, line, column) {
+function parseDoWhileStatement(parser, context, scope, privateScope, labels) {
+    const start = parser.tokenStart;
     nextToken(parser, context | 8192);
     const body = parseIterationStatementBody(parser, context, scope, privateScope, labels);
     consume(parser, context, 20578);
     consume(parser, context | 8192, 67174411);
-    const test = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+    const test = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenStart);
     consume(parser, context | 8192, 16);
     consumeOpt(parser, context | 8192, 1074790417);
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'DoWhileStatement',
         body,
         test,
-    });
+    }, start);
 }
-function parseLetIdentOrVarDeclarationStatement(parser, context, scope, privateScope, origin, start, line, column) {
-    const { tokenValue } = parser;
+function parseLetIdentOrVarDeclarationStatement(parser, context, scope, privateScope, origin) {
+    const { tokenValue, tokenStart } = parser;
     const token = parser.getToken();
     let expr = parseIdentifier(parser, context);
     if (parser.getToken() & (143360 | 2097152)) {
         const declarations = parseVariableDeclarationList(parser, context, scope, privateScope, 8, 0);
         matchOrInsertSemicolon(parser, context | 8192);
-        return finishNode(parser, context, start, line, column, {
+        return parser.finishNode({
             type: 'VariableDeclaration',
             kind: 'let',
             declarations,
-        });
+        }, tokenStart);
     }
     parser.assignable = 1;
     if (context & 256)
         report(parser, 85);
     if (parser.getToken() === 21) {
-        return parseLabelledStatement(parser, context, scope, privateScope, origin, {}, tokenValue, expr, token, 0, start, line, column);
+        return parseLabelledStatement(parser, context, scope, privateScope, origin, {}, tokenValue, expr, token, 0, tokenStart);
     }
     if (parser.getToken() === 10) {
         let scope = void 0;
         if (context & 16)
             scope = createArrowHeadParsingScope(parser, context, tokenValue);
         parser.flags = (parser.flags | 128) ^ 128;
-        expr = parseArrowFunctionExpression(parser, context, scope, privateScope, [expr], 0, start, line, column);
+        expr = parseArrowFunctionExpression(parser, context, scope, privateScope, [expr], 0, tokenStart);
     }
     else {
-        expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 0, 0, start, line, column);
-        expr = parseAssignmentExpression(parser, context, privateScope, 0, 0, start, line, column, expr);
+        expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 0, 0, tokenStart);
+        expr = parseAssignmentExpression(parser, context, privateScope, 0, 0, tokenStart, expr);
     }
     if (parser.getToken() === 18) {
-        expr = parseSequenceExpression(parser, context, privateScope, 0, start, line, column, expr);
+        expr = parseSequenceExpression(parser, context, privateScope, 0, tokenStart, expr);
     }
-    return parseExpressionStatement(parser, context, expr, start, line, column);
+    return parseExpressionStatement(parser, context, expr, tokenStart);
 }
-function parseLexicalDeclaration(parser, context, scope, privateScope, kind, origin, start, line, column) {
+function parseLexicalDeclaration(parser, context, scope, privateScope, kind, origin) {
+    const start = parser.tokenStart;
     nextToken(parser, context);
     const declarations = parseVariableDeclarationList(parser, context, scope, privateScope, kind, origin);
     matchOrInsertSemicolon(parser, context | 8192);
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'VariableDeclaration',
         kind: kind & 8 ? 'let' : 'const',
         declarations,
-    });
+    }, start);
 }
-function parseVariableStatement(parser, context, scope, privateScope, origin, start, line, column) {
+function parseVariableStatement(parser, context, scope, privateScope, origin) {
+    const start = parser.tokenStart;
     nextToken(parser, context);
     const declarations = parseVariableDeclarationList(parser, context, scope, privateScope, 4, origin);
     matchOrInsertSemicolon(parser, context | 8192);
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'VariableDeclaration',
         kind: 'var',
         declarations,
-    });
+    }, start);
 }
 function parseVariableDeclarationList(parser, context, scope, privateScope, kind, origin) {
     let bindingCount = 1;
@@ -5485,18 +5504,18 @@ function parseVariableDeclarationList(parser, context, scope, privateScope, kind
     return list;
 }
 function parseVariableDeclaration(parser, context, scope, privateScope, kind, origin) {
-    const { tokenIndex, tokenLine, tokenColumn } = parser;
+    const { tokenStart } = parser;
     const token = parser.getToken();
     let init = null;
-    const id = parseBindingPattern(parser, context, scope, privateScope, kind, origin, tokenIndex, tokenLine, tokenColumn);
+    const id = parseBindingPattern(parser, context, scope, privateScope, kind, origin);
     if (parser.getToken() === 1077936155) {
         nextToken(parser, context | 8192);
-        init = parseExpression(parser, context, privateScope, 1, 0, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+        init = parseExpression(parser, context, privateScope, 1, 0, parser.tokenStart);
         if (origin & 32 || (token & 2097152) === 0) {
             if (parser.getToken() === 471156 ||
                 (parser.getToken() === 8673330 &&
                     (token & 2097152 || (kind & 4) === 0 || context & 256))) {
-                reportMessageAt(tokenIndex, tokenLine, tokenColumn, parser.index, parser.line, parser.column, 60, parser.getToken() === 471156 ? 'of' : 'in');
+                reportMessageAt(tokenStart, parser.currentLocation, 60, parser.getToken() === 471156 ? 'of' : 'in');
             }
         }
     }
@@ -5504,13 +5523,14 @@ function parseVariableDeclaration(parser, context, scope, privateScope, kind, or
         (parser.getToken() & 262144) !== 262144) {
         report(parser, 59, kind & 16 ? 'const' : 'destructuring');
     }
-    return finishNode(parser, context, tokenIndex, tokenLine, tokenColumn, {
+    return parser.finishNode({
         type: 'VariableDeclarator',
         id,
         init,
-    });
+    }, tokenStart);
 }
-function parseForStatement(parser, context, scope, privateScope, labels, start, line, column) {
+function parseForStatement(parser, context, scope, privateScope, labels) {
+    const start = parser.tokenStart;
     nextToken(parser, context);
     const forAwait = ((context & 524288) > 0 || ((context & 512) > 0 && (context & 2048) > 0)) &&
         consumeOpt(parser, context, 209006);
@@ -5525,7 +5545,7 @@ function parseForStatement(parser, context, scope, privateScope, labels, start,
         parser.getToken() === 241737 ||
         parser.getToken() === 86090;
     let right;
-    const { tokenIndex, tokenLine, tokenColumn } = parser;
+    const { tokenStart } = parser;
     const token = parser.getToken();
     if (isVarDecl) {
         if (token === 241737) {
@@ -5536,11 +5556,11 @@ function parseForStatement(parser, context, scope, privateScope, labels, start,
                         report(parser, 67);
                 }
                 else {
-                    init = finishNode(parser, context, tokenIndex, tokenLine, tokenColumn, {
+                    init = parser.finishNode({
                         type: 'VariableDeclaration',
                         kind: 'let',
                         declarations: parseVariableDeclarationList(parser, context | 33554432, scope, privateScope, 8, 32),
-                    });
+                    }, tokenStart);
                 }
                 parser.assignable = 1;
             }
@@ -5550,14 +5570,14 @@ function parseForStatement(parser, context, scope, privateScope, labels, start,
             else {
                 isVarDecl = false;
                 parser.assignable = 1;
-                init = parseMemberOrUpdateExpression(parser, context, privateScope, init, 0, 0, tokenIndex, tokenLine, tokenColumn);
+                init = parseMemberOrUpdateExpression(parser, context, privateScope, init, 0, 0, tokenStart);
                 if (parser.getToken() === 471156)
                     report(parser, 115);
             }
         }
         else {
             nextToken(parser, context);
-            init = finishNode(parser, context, tokenIndex, tokenLine, tokenColumn, token === 86088
+            init = parser.finishNode(token === 86088
                 ? {
                     type: 'VariableDeclaration',
                     kind: 'var',
@@ -5567,7 +5587,7 @@ function parseForStatement(parser, context, scope, privateScope, labels, start,
                     type: 'VariableDeclaration',
                     kind: 'const',
                     declarations: parseVariableDeclarationList(parser, context | 33554432, scope, privateScope, 16, 32),
-                });
+                }, tokenStart);
             parser.assignable = 1;
         }
     }
@@ -5576,20 +5596,21 @@ function parseForStatement(parser, context, scope, privateScope, labels, start,
             report(parser, 82);
     }
     else if ((token & 2097152) === 2097152) {
+        const patternStart = parser.tokenStart;
         init =
             token === 2162700
-                ? parseObjectLiteralOrPattern(parser, context, void 0, privateScope, 1, 0, 0, 2, 32, tokenIndex, tokenLine, tokenColumn)
-                : parseArrayExpressionOrPattern(parser, context, void 0, privateScope, 1, 0, 0, 2, 32, tokenIndex, tokenLine, tokenColumn);
+                ? parseObjectLiteralOrPattern(parser, context, void 0, privateScope, 1, 0, 0, 2, 32)
+                : parseArrayExpressionOrPattern(parser, context, void 0, privateScope, 1, 0, 0, 2, 32);
         destructible = parser.destructible;
         if (destructible & 64) {
             report(parser, 63);
         }
         parser.assignable =
             destructible & 16 ? 2 : 1;
-        init = parseMemberOrUpdateExpression(parser, context | 33554432, privateScope, init, 0, 0, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+        init = parseMemberOrUpdateExpression(parser, context | 33554432, privateScope, init, 0, 0, patternStart);
     }
     else {
-        init = parseLeftHandSideExpression(parser, context | 33554432, privateScope, 1, 0, 1, tokenIndex, tokenLine, tokenColumn);
+        init = parseLeftHandSideExpression(parser, context | 33554432, privateScope, 1, 0, 1);
     }
     if ((parser.getToken() & 262144) === 262144) {
         if (parser.getToken() === 471156) {
@@ -5597,16 +5618,16 @@ function parseForStatement(parser, context, scope, privateScope, labels, start,
                 report(parser, 80, forAwait ? 'await' : 'of');
             reinterpretToPattern(parser, init);
             nextToken(parser, context | 8192);
-            right = parseExpression(parser, context, privateScope, 1, 0, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+            right = parseExpression(parser, context, privateScope, 1, 0, parser.tokenStart);
             consume(parser, context | 8192, 16);
             const body = parseIterationStatementBody(parser, context, scope, privateScope, labels);
-            return finishNode(parser, context, start, line, column, {
+            return parser.finishNode({
                 type: 'ForOfStatement',
                 left: init,
                 right,
                 body,
                 await: forAwait,
-            });
+            }, start);
         }
         if (parser.assignable & 2)
             report(parser, 80, 'in');
@@ -5614,15 +5635,15 @@ function parseForStatement(parser, context, scope, privateScope, labels, start,
         nextToken(parser, context | 8192);
         if (forAwait)
             report(parser, 82);
-        right = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+        right = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenStart);
         consume(parser, context | 8192, 16);
         const body = parseIterationStatementBody(parser, context, scope, privateScope, labels);
-        return finishNode(parser, context, start, line, column, {
+        return parser.finishNode({
             type: 'ForInStatement',
             body,
             left: init,
             right,
-        });
+        }, start);
     }
     if (forAwait)
         report(parser, 82);
@@ -5630,25 +5651,25 @@ function parseForStatement(parser, context, scope, privateScope, labels, start,
         if (destructible & 8 && parser.getToken() !== 1077936155) {
             report(parser, 80, 'loop');
         }
-        init = parseAssignmentExpression(parser, context | 33554432, privateScope, 0, 0, tokenIndex, tokenLine, tokenColumn, init);
+        init = parseAssignmentExpression(parser, context | 33554432, privateScope, 0, 0, tokenStart, init);
     }
     if (parser.getToken() === 18)
-        init = parseSequenceExpression(parser, context, privateScope, 0, parser.tokenIndex, parser.tokenLine, parser.tokenColumn, init);
+        init = parseSequenceExpression(parser, context, privateScope, 0, parser.tokenStart, init);
     consume(parser, context | 8192, 1074790417);
     if (parser.getToken() !== 1074790417)
-        test = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+        test = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenStart);
     consume(parser, context | 8192, 1074790417);
     if (parser.getToken() !== 16)
-        update = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+        update = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenStart);
     consume(parser, context | 8192, 16);
     const body = parseIterationStatementBody(parser, context, scope, privateScope, labels);
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'ForStatement',
         init,
         test,
         update,
         body,
-    });
+    }, start);
 }
 function parseRestrictedIdentifier(parser, context, scope) {
     if (!isValidIdentifier(context, parser.getToken()))
@@ -5660,12 +5681,10 @@ function parseRestrictedIdentifier(parser, context, scope) {
     return parseIdentifier(parser, context);
 }
 function parseImportDeclaration(parser, context, scope) {
-    const start = parser.tokenIndex;
-    const line = parser.tokenLine;
-    const column = parser.tokenColumn;
+    const start = parser.tokenStart;
     nextToken(parser, context);
     let source = null;
-    const { tokenIndex, tokenLine, tokenColumn } = parser;
+    const { tokenStart } = parser;
     let specifiers = [];
     if (parser.getToken() === 134283267) {
         source = parseLiteral(parser, context);
@@ -5674,10 +5693,10 @@ function parseImportDeclaration(parser, context, scope) {
         if (parser.getToken() & 143360) {
             const local = parseRestrictedIdentifier(parser, context, scope);
             specifiers = [
-                finishNode(parser, context, tokenIndex, tokenLine, tokenColumn, {
+                parser.finishNode({
                     type: 'ImportDefaultSpecifier',
                     local,
-                }),
+                }, tokenStart),
             ];
             if (consumeOpt(parser, context, 18)) {
                 switch (parser.getToken()) {
@@ -5701,9 +5720,9 @@ function parseImportDeclaration(parser, context, scope) {
                     parseImportSpecifierOrNamedImports(parser, context, scope, specifiers);
                     break;
                 case 67174411:
-                    return parseImportCallDeclaration(parser, context, undefined, start, line, column);
+                    return parseImportCallDeclaration(parser, context, undefined, start);
                 case 67108877:
-                    return parseImportMetaDeclaration(parser, context, start, line, column);
+                    return parseImportMetaDeclaration(parser, context);
                 default:
                     report(parser, 30, KeywordDescTable[parser.getToken() & 255]);
             }
@@ -5718,19 +5737,19 @@ function parseImportDeclaration(parser, context, scope) {
         attributes,
     };
     matchOrInsertSemicolon(parser, context | 8192);
-    return finishNode(parser, context, start, line, column, node);
+    return parser.finishNode(node, start);
 }
 function parseImportNamespaceSpecifier(parser, context, scope) {
-    const { tokenIndex, tokenLine, tokenColumn } = parser;
+    const { tokenStart } = parser;
     nextToken(parser, context);
     consume(parser, context, 77932);
     if ((parser.getToken() & 134217728) === 134217728) {
-        reportMessageAt(tokenIndex, tokenLine, tokenColumn, parser.index, parser.line, parser.column, 30, KeywordDescTable[parser.getToken() & 255]);
+        reportMessageAt(tokenStart, parser.currentLocation, 30, KeywordDescTable[parser.getToken() & 255]);
     }
-    return finishNode(parser, context, tokenIndex, tokenLine, tokenColumn, {
+    return parser.finishNode({
         type: 'ImportNamespaceSpecifier',
         local: parseRestrictedIdentifier(parser, context, scope),
-    });
+    }, tokenStart);
 }
 function parseModuleSpecifier(parser, context) {
     consume(parser, context, 209011);
@@ -5741,7 +5760,7 @@ function parseModuleSpecifier(parser, context) {
 function parseImportSpecifierOrNamedImports(parser, context, scope, specifiers) {
     nextToken(parser, context);
     while (parser.getToken() & 143360 || parser.getToken() === 134283267) {
-        let { tokenValue, tokenIndex, tokenLine, tokenColumn } = parser;
+        let { tokenValue, tokenStart } = parser;
         const token = parser.getToken();
         const imported = parseModuleExportName(parser, context);
         let local;
@@ -5765,41 +5784,40 @@ function parseImportSpecifierOrNamedImports(parser, context, scope, specifiers)
         }
         if (scope)
             addBlockName(parser, context, scope, tokenValue, 8, 0);
-        specifiers.push(finishNode(parser, context, tokenIndex, tokenLine, tokenColumn, {
+        specifiers.push(parser.finishNode({
             type: 'ImportSpecifier',
             local,
             imported,
-        }));
+        }, tokenStart));
         if (parser.getToken() !== 1074790415)
             consume(parser, context, 18);
     }
     consume(parser, context, 1074790415);
     return specifiers;
 }
-function parseImportMetaDeclaration(parser, context, start, line, column) {
-    let expr = parseImportMetaExpression(parser, context, finishNode(parser, context, start, line, column, {
+function parseImportMetaDeclaration(parser, context) {
+    const start = parser.tokenStart;
+    let expr = parseImportMetaExpression(parser, context, parser.finishNode({
         type: 'Identifier',
         name: 'import',
-    }), start, line, column);
-    expr = parseMemberOrUpdateExpression(parser, context, undefined, expr, 0, 0, start, line, column);
-    expr = parseAssignmentExpression(parser, context, undefined, 0, 0, start, line, column, expr);
+    }, start));
+    expr = parseMemberOrUpdateExpression(parser, context, undefined, expr, 0, 0, start);
+    expr = parseAssignmentExpression(parser, context, undefined, 0, 0, start, expr);
     if (parser.getToken() === 18) {
-        expr = parseSequenceExpression(parser, context, undefined, 0, start, line, column, expr);
+        expr = parseSequenceExpression(parser, context, undefined, 0, start, expr);
     }
-    return parseExpressionStatement(parser, context, expr, start, line, column);
+    return parseExpressionStatement(parser, context, expr, start);
 }
-function parseImportCallDeclaration(parser, context, privateScope, start, line, column) {
-    let expr = parseImportExpression(parser, context, privateScope, 0, start, line, column);
-    expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 0, 0, start, line, column);
+function parseImportCallDeclaration(parser, context, privateScope, start) {
+    let expr = parseImportExpression(parser, context, privateScope, 0, start);
+    expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 0, 0, start);
     if (parser.getToken() === 18) {
-        expr = parseSequenceExpression(parser, context, privateScope, 0, start, line, column, expr);
+        expr = parseSequenceExpression(parser, context, privateScope, 0, start, expr);
     }
-    return parseExpressionStatement(parser, context, expr, start, line, column);
+    return parseExpressionStatement(parser, context, expr, start);
 }
 function parseExportDeclaration(parser, context, scope) {
-    const start = parser.tokenIndex;
-    const line = parser.tokenLine;
-    const column = parser.tokenColumn;
+    const start = parser.leadingDecorators.decorators.length ? parser.leadingDecorators.start : parser.tokenStart;
     nextToken(parser, context | 8192);
     const specifiers = [];
     let declaration = null;
@@ -5808,47 +5826,47 @@ function parseExportDeclaration(parser, context, scope) {
     if (consumeOpt(parser, context | 8192, 20561)) {
         switch (parser.getToken()) {
             case 86104: {
-                declaration = parseFunctionDeclaration(parser, context, scope, undefined, 4, 1, 1, 0, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+                declaration = parseFunctionDeclaration(parser, context, scope, undefined, 4, 1, 1, 0, parser.tokenStart);
                 break;
             }
             case 132:
             case 86094:
-                declaration = parseClassDeclaration(parser, context, scope, undefined, 1, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+                declaration = parseClassDeclaration(parser, context, scope, undefined, 1);
                 break;
             case 209005: {
-                const { tokenIndex, tokenLine, tokenColumn } = parser;
+                const { tokenStart } = parser;
                 declaration = parseIdentifier(parser, context);
                 const { flags } = parser;
                 if ((flags & 1) === 0) {
                     if (parser.getToken() === 86104) {
-                        declaration = parseFunctionDeclaration(parser, context, scope, undefined, 4, 1, 1, 1, tokenIndex, tokenLine, tokenColumn);
+                        declaration = parseFunctionDeclaration(parser, context, scope, undefined, 4, 1, 1, 1, tokenStart);
                     }
                     else {
                         if (parser.getToken() === 67174411) {
-                            declaration = parseAsyncArrowOrCallExpression(parser, context, undefined, declaration, 1, 1, 0, flags, tokenIndex, tokenLine, tokenColumn);
-                            declaration = parseMemberOrUpdateExpression(parser, context, undefined, declaration, 0, 0, tokenIndex, tokenLine, tokenColumn);
-                            declaration = parseAssignmentExpression(parser, context, undefined, 0, 0, tokenIndex, tokenLine, tokenColumn, declaration);
+                            declaration = parseAsyncArrowOrCallExpression(parser, context, undefined, declaration, 1, 1, 0, flags, tokenStart);
+                            declaration = parseMemberOrUpdateExpression(parser, context, undefined, declaration, 0, 0, tokenStart);
+                            declaration = parseAssignmentExpression(parser, context, undefined, 0, 0, tokenStart, declaration);
                         }
                         else if (parser.getToken() & 143360) {
                             if (scope)
                                 scope = createArrowHeadParsingScope(parser, context, parser.tokenValue);
                             declaration = parseIdentifier(parser, context);
-                            declaration = parseArrowFunctionExpression(parser, context, scope, undefined, [declaration], 1, tokenIndex, tokenLine, tokenColumn);
+                            declaration = parseArrowFunctionExpression(parser, context, scope, undefined, [declaration], 1, tokenStart);
                         }
                     }
                 }
                 break;
             }
             default:
-                declaration = parseExpression(parser, context, undefined, 1, 0, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+                declaration = parseExpression(parser, context, undefined, 1, 0, parser.tokenStart);
                 matchOrInsertSemicolon(parser, context | 8192);
         }
         if (scope)
             declareUnboundVariable(parser, 'default');
-        return finishNode(parser, context, start, line, column, {
+        return parser.finishNode({
             type: 'ExportDefaultDeclaration',
             declaration,
-        });
+        }, start);
     }
     switch (parser.getToken()) {
         case 8391476: {
@@ -5872,7 +5890,7 @@ function parseExportDeclaration(parser, context, scope) {
                 attributes,
             };
             matchOrInsertSemicolon(parser, context | 8192);
-            return finishNode(parser, context, start, line, column, node);
+            return parser.finishNode(node, start);
         }
         case 2162700: {
             nextToken(parser, context);
@@ -5880,7 +5898,7 @@ function parseExportDeclaration(parser, context, scope) {
             const tmpExportedBindings = [];
             let hasLiteralLocal = 0;
             while (parser.getToken() & 143360 || parser.getToken() === 134283267) {
-                const { tokenIndex, tokenValue, tokenLine, tokenColumn } = parser;
+                const { tokenStart, tokenValue } = parser;
                 const local = parseModuleExportName(parser, context);
                 if (local.type === 'Literal') {
                     hasLiteralLocal = 1;
@@ -5904,11 +5922,11 @@ function parseExportDeclaration(parser, context, scope) {
                     }
                     exported = local;
                 }
-                specifiers.push(finishNode(parser, context, tokenIndex, tokenLine, tokenColumn, {
+                specifiers.push(parser.finishNode({
                     type: 'ExportSpecifier',
                     local,
                     exported,
-                }));
+                }, tokenStart));
                 if (parser.getToken() !== 1074790415)
                     consume(parser, context, 18);
             }
@@ -5934,26 +5952,27 @@ function parseExportDeclaration(parser, context, scope) {
             matchOrInsertSemicolon(parser, context | 8192);
             break;
         }
+        case 132:
         case 86094:
-            declaration = parseClassDeclaration(parser, context, scope, undefined, 2, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+            declaration = parseClassDeclaration(parser, context, scope, undefined, 2);
             break;
         case 86104:
-            declaration = parseFunctionDeclaration(parser, context, scope, undefined, 4, 1, 2, 0, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+            declaration = parseFunctionDeclaration(parser, context, scope, undefined, 4, 1, 2, 0, parser.tokenStart);
             break;
         case 241737:
-            declaration = parseLexicalDeclaration(parser, context, scope, undefined, 8, 64, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+            declaration = parseLexicalDeclaration(parser, context, scope, undefined, 8, 64);
             break;
         case 86090:
-            declaration = parseLexicalDeclaration(parser, context, scope, undefined, 16, 64, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+            declaration = parseLexicalDeclaration(parser, context, scope, undefined, 16, 64);
             break;
         case 86088:
-            declaration = parseVariableStatement(parser, context, scope, undefined, 64, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+            declaration = parseVariableStatement(parser, context, scope, undefined, 64);
             break;
         case 209005: {
-            const { tokenIndex, tokenLine, tokenColumn } = parser;
+            const { tokenStart } = parser;
             nextToken(parser, context);
             if ((parser.flags & 1) === 0 && parser.getToken() === 86104) {
-                declaration = parseFunctionDeclaration(parser, context, scope, undefined, 4, 1, 2, 1, tokenIndex, tokenLine, tokenColumn);
+                declaration = parseFunctionDeclaration(parser, context, scope, undefined, 4, 1, 2, 1, tokenStart);
                 break;
             }
         }
@@ -5967,30 +5986,30 @@ function parseExportDeclaration(parser, context, scope) {
         source,
         attributes: attributes,
     };
-    return finishNode(parser, context, start, line, column, node);
+    return parser.finishNode(node, start);
 }
-function parseExpression(parser, context, privateScope, canAssign, inGroup, start, line, column) {
-    let expr = parsePrimaryExpression(parser, context, privateScope, 2, 0, canAssign, inGroup, 1, start, line, column);
-    expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, inGroup, 0, start, line, column);
-    return parseAssignmentExpression(parser, context, privateScope, inGroup, 0, start, line, column, expr);
+function parseExpression(parser, context, privateScope, canAssign, inGroup, start) {
+    let expr = parsePrimaryExpression(parser, context, privateScope, 2, 0, canAssign, inGroup, 1, start);
+    expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, inGroup, 0, start);
+    return parseAssignmentExpression(parser, context, privateScope, inGroup, 0, start, expr);
 }
-function parseSequenceExpression(parser, context, privateScope, inGroup, start, line, column, expr) {
+function parseSequenceExpression(parser, context, privateScope, inGroup, start, expr) {
     const expressions = [expr];
     while (consumeOpt(parser, context | 8192, 18)) {
-        expressions.push(parseExpression(parser, context, privateScope, 1, inGroup, parser.tokenIndex, parser.tokenLine, parser.tokenColumn));
+        expressions.push(parseExpression(parser, context, privateScope, 1, inGroup, parser.tokenStart));
     }
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'SequenceExpression',
         expressions,
-    });
+    }, start);
 }
-function parseExpressions(parser, context, privateScope, inGroup, canAssign, start, line, column) {
-    const expr = parseExpression(parser, context, privateScope, canAssign, inGroup, start, line, column);
+function parseExpressions(parser, context, privateScope, inGroup, canAssign, start) {
+    const expr = parseExpression(parser, context, privateScope, canAssign, inGroup, start);
     return parser.getToken() === 18
-        ? parseSequenceExpression(parser, context, privateScope, inGroup, start, line, column, expr)
+        ? parseSequenceExpression(parser, context, privateScope, inGroup, start, expr)
         : expr;
 }
-function parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, start, line, column, left) {
+function parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, start, left) {
     const token = parser.getToken();
     if ((token & 4194304) === 4194304) {
         if (parser.assignable & 2)
@@ -6000,9 +6019,9 @@ function parseAssignmentExpression(parser, context, privateScope, inGroup, isPat
             reinterpretToPattern(parser, left);
         }
         nextToken(parser, context | 8192);
-        const right = parseExpression(parser, context, privateScope, 1, inGroup, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+        const right = parseExpression(parser, context, privateScope, 1, inGroup, parser.tokenStart);
         parser.assignable = 2;
-        return finishNode(parser, context, start, line, column, isPattern
+        return parser.finishNode(isPattern
             ? {
                 type: 'AssignmentPattern',
                 left,
@@ -6013,21 +6032,21 @@ function parseAssignmentExpression(parser, context, privateScope, inGroup, isPat
                 left,
                 operator: KeywordDescTable[token & 255],
                 right,
-            });
+            }, start);
     }
     if ((token & 8388608) === 8388608) {
-        left = parseBinaryExpression(parser, context, privateScope, inGroup, start, line, column, 4, token, left);
+        left = parseBinaryExpression(parser, context, privateScope, inGroup, start, 4, token, left);
     }
     if (consumeOpt(parser, context | 8192, 22)) {
-        left = parseConditionalExpression(parser, context, privateScope, left, start, line, column);
+        left = parseConditionalExpression(parser, context, privateScope, left, start);
     }
     return left;
 }
-function parseAssignmentExpressionOrPattern(parser, context, privateScope, inGroup, isPattern, start, line, column, left) {
+function parseAssignmentExpressionOrPattern(parser, context, privateScope, inGroup, isPattern, start, left) {
     const token = parser.getToken();
     nextToken(parser, context | 8192);
-    const right = parseExpression(parser, context, privateScope, 1, inGroup, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
-    left = finishNode(parser, context, start, line, column, isPattern
+    const right = parseExpression(parser, context, privateScope, 1, inGroup, parser.tokenStart);
+    left = parser.finishNode(isPattern
         ? {
             type: 'AssignmentPattern',
             left,
@@ -6038,24 +6057,24 @@ function parseAssignmentExpressionOrPattern(parser, context, privateScope, inGro
             left,
             operator: KeywordDescTable[token & 255],
             right,
-        });
+        }, start);
     parser.assignable = 2;
     return left;
 }
-function parseConditionalExpression(parser, context, privateScope, test, start, line, column) {
-    const consequent = parseExpression(parser, (context | 33554432) ^ 33554432, privateScope, 1, 0, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+function parseConditionalExpression(parser, context, privateScope, test, start) {
+    const consequent = parseExpression(parser, (context | 33554432) ^ 33554432, privateScope, 1, 0, parser.tokenStart);
     consume(parser, context | 8192, 21);
     parser.assignable = 1;
-    const alternate = parseExpression(parser, context, privateScope, 1, 0, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+    const alternate = parseExpression(parser, context, privateScope, 1, 0, parser.tokenStart);
     parser.assignable = 2;
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'ConditionalExpression',
         test,
         consequent,
         alternate,
-    });
+    }, start);
 }
-function parseBinaryExpression(parser, context, privateScope, inGroup, start, line, column, minPrecedence, operator, left) {
+function parseBinaryExpression(parser, context, privateScope, inGroup, start, minPrecedence, operator, left) {
     const bit = -((context & 33554432) > 0) & 8673330;
     let t;
     let precedence;
@@ -6069,23 +6088,24 @@ function parseBinaryExpression(parser, context, privateScope, inGroup, start, li
         if (precedence + ((t === 8391735) << 8) - ((bit === t) << 12) <= minPrecedence)
             break;
         nextToken(parser, context | 8192);
-        left = finishNode(parser, context, start, line, column, {
+        left = parser.finishNode({
             type: t & 524288 || t & 268435456 ? 'LogicalExpression' : 'BinaryExpression',
             left,
-            right: parseBinaryExpression(parser, context, privateScope, inGroup, parser.tokenIndex, parser.tokenLine, parser.tokenColumn, precedence, t, parseLeftHandSideExpression(parser, context, privateScope, 0, inGroup, 1, parser.tokenIndex, parser.tokenLine, parser.tokenColumn)),
+            right: parseBinaryExpression(parser, context, privateScope, inGroup, parser.tokenStart, precedence, t, parseLeftHandSideExpression(parser, context, privateScope, 0, inGroup, 1)),
             operator: KeywordDescTable[t & 255],
-        });
+        }, start);
     }
     if (parser.getToken() === 1077936155)
         report(parser, 26);
     return left;
 }
-function parseUnaryExpression(parser, context, privateScope, isLHS, start, line, column, inGroup) {
+function parseUnaryExpression(parser, context, privateScope, isLHS, inGroup) {
     if (!isLHS)
         report(parser, 0);
+    const { tokenStart } = parser;
     const unaryOperator = parser.getToken();
     nextToken(parser, context | 8192);
-    const arg = parseLeftHandSideExpression(parser, context, privateScope, 0, inGroup, 1, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+    const arg = parseLeftHandSideExpression(parser, context, privateScope, 0, inGroup, 1);
     if (parser.getToken() === 8391735)
         report(parser, 33);
     if (context & 256 && unaryOperator === 16863276) {
@@ -6097,20 +6117,20 @@ function parseUnaryExpression(parser, context, privateScope, isLHS, start, line,
         }
     }
     parser.assignable = 2;
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'UnaryExpression',
         operator: KeywordDescTable[unaryOperator & 255],
         argument: arg,
         prefix: true,
-    });
+    }, tokenStart);
 }
-function parseAsyncExpression(parser, context, privateScope, inGroup, isLHS, canAssign, inNew, start, line, column) {
+function parseAsyncExpression(parser, context, privateScope, inGroup, isLHS, canAssign, inNew, start) {
     const token = parser.getToken();
     const expr = parseIdentifier(parser, context);
     const { flags } = parser;
     if ((flags & 1) === 0) {
         if (parser.getToken() === 86104) {
-            return parseFunctionExpression(parser, context, privateScope, 1, inGroup, start, line, column);
+            return parseFunctionExpression(parser, context, privateScope, 1, inGroup, start);
         }
         if (isValidIdentifier(context, parser.getToken())) {
             if (!isLHS)
@@ -6118,11 +6138,11 @@ function parseAsyncExpression(parser, context, privateScope, inGroup, isLHS, can
             if ((parser.getToken() & 36864) === 36864) {
                 parser.flags |= 256;
             }
-            return parseAsyncArrowAfterIdent(parser, context, privateScope, canAssign, start, line, column);
+            return parseAsyncArrowAfterIdent(parser, context, privateScope, canAssign, start);
         }
     }
     if (!inNew && parser.getToken() === 67174411) {
-        return parseAsyncArrowOrCallExpression(parser, context, privateScope, expr, canAssign, 1, 0, flags, start, line, column);
+        return parseAsyncArrowOrCallExpression(parser, context, privateScope, expr, canAssign, 1, 0, flags, start);
     }
     if (parser.getToken() === 10) {
         classifyIdentifier(parser, context, token);
@@ -6131,12 +6151,12 @@ function parseAsyncExpression(parser, context, privateScope, inGroup, isLHS, can
         if ((token & 36864) === 36864) {
             parser.flags |= 256;
         }
-        return parseArrowFromIdentifier(parser, context, privateScope, parser.tokenValue, expr, inNew, canAssign, 0, start, line, column);
+        return parseArrowFromIdentifier(parser, context, privateScope, parser.tokenValue, expr, inNew, canAssign, 0, start);
     }
     parser.assignable = 1;
     return expr;
 }
-function parseYieldExpressionOrIdentifier(parser, context, privateScope, inGroup, canAssign, start, line, column) {
+function parseYieldExpressionOrIdentifier(parser, context, privateScope, inGroup, canAssign, start) {
     if (inGroup)
         parser.destructible |= 256;
     if (context & 262144) {
@@ -6152,83 +6172,83 @@ function parseYieldExpressionOrIdentifier(parser, context, privateScope, inGroup
         if ((parser.flags & 1) === 0) {
             delegate = consumeOpt(parser, context | 8192, 8391476);
             if (parser.getToken() & (12288 | 65536) || delegate) {
-                argument = parseExpression(parser, context, privateScope, 1, 0, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+                argument = parseExpression(parser, context, privateScope, 1, 0, parser.tokenStart);
             }
         }
         else if (parser.getToken() === 8391476) {
             report(parser, 30, KeywordDescTable[parser.getToken() & 255]);
         }
         parser.assignable = 2;
-        return finishNode(parser, context, start, line, column, {
+        return parser.finishNode({
             type: 'YieldExpression',
             argument,
             delegate,
-        });
+        }, start);
     }
     if (context & 256)
         report(parser, 97, 'yield');
-    return parseIdentifierOrArrow(parser, context, privateScope, start, line, column);
+    return parseIdentifierOrArrow(parser, context, privateScope);
 }
-function parseAwaitExpressionOrIdentifier(parser, context, privateScope, inNew, inGroup, start, line, column) {
+function parseAwaitExpressionOrIdentifier(parser, context, privateScope, inNew, inGroup, start) {
     if (inGroup)
         parser.destructible |= 128;
     if (context & 268435456)
         report(parser, 177);
-    const possibleIdentifierOrArrowFunc = parseIdentifierOrArrow(parser, context, privateScope, start, line, column);
+    const possibleIdentifierOrArrowFunc = parseIdentifierOrArrow(parser, context, privateScope);
     const isIdentifier = possibleIdentifierOrArrowFunc.type === 'ArrowFunctionExpression' ||
         (parser.getToken() & 65536) === 0;
     if (isIdentifier) {
         if (context & 524288)
-            reportMessageAt(start, line, column, parser.startIndex, parser.startLine, parser.startColumn, 176);
+            reportMessageAt(start, { index: parser.startIndex, line: parser.startLine, column: parser.startColumn }, 176);
         if (context & 512)
-            reportMessageAt(start, line, column, parser.startIndex, parser.startLine, parser.startColumn, 110);
+            reportMessageAt(start, { index: parser.startIndex, line: parser.startLine, column: parser.startColumn }, 110);
         if (context & 2097152 && context & 524288)
-            reportMessageAt(start, line, column, parser.startIndex, parser.startLine, parser.startColumn, 110);
+            reportMessageAt(start, { index: parser.startIndex, line: parser.startLine, column: parser.startColumn }, 110);
         return possibleIdentifierOrArrowFunc;
     }
     if (context & 2097152) {
-        reportMessageAt(start, line, column, parser.startIndex, parser.startLine, parser.startColumn, 31);
+        reportMessageAt(start, { index: parser.startIndex, line: parser.startLine, column: parser.startColumn }, 31);
     }
     if (context & 524288 || (context & 512 && context & 2048)) {
         if (inNew)
-            reportMessageAt(start, line, column, parser.startIndex, parser.startLine, parser.startColumn, 0);
-        const argument = parseLeftHandSideExpression(parser, context, privateScope, 0, 0, 1, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+            reportMessageAt(start, { index: parser.startIndex, line: parser.startLine, column: parser.startColumn }, 0);
+        const argument = parseLeftHandSideExpression(parser, context, privateScope, 0, 0, 1);
         if (parser.getToken() === 8391735)
             report(parser, 33);
         parser.assignable = 2;
-        return finishNode(parser, context, start, line, column, {
+        return parser.finishNode({
             type: 'AwaitExpression',
             argument,
-        });
+        }, start);
     }
     if (context & 512)
-        reportMessageAt(start, line, column, parser.startIndex, parser.startLine, parser.startColumn, 98);
+        reportMessageAt(start, { index: parser.startIndex, line: parser.startLine, column: parser.startColumn }, 98);
     return possibleIdentifierOrArrowFunc;
 }
 function parseFunctionBody(parser, context, scope, privateScope, origin, funcNameToken, scopeError) {
-    const { tokenIndex, tokenLine, tokenColumn } = parser;
+    const { tokenStart } = parser;
     consume(parser, context | 8192, 2162700);
     const body = [];
     if (parser.getToken() !== 1074790415) {
         while (parser.getToken() === 134283267) {
-            const { index, tokenIndex, tokenValue } = parser;
+            const { index, tokenStart, tokenIndex, tokenValue } = parser;
             const token = parser.getToken();
             const expr = parseLiteral(parser, context);
             if (isValidStrictMode(parser, index, tokenIndex, tokenValue)) {
                 context |= 256;
                 if (parser.flags & 128) {
-                    reportMessageAt(tokenIndex, tokenLine, tokenColumn, parser.index, parser.line, parser.column, 66);
+                    reportMessageAt(tokenStart, parser.currentLocation, 66);
                 }
                 if (parser.flags & 64) {
-                    reportMessageAt(tokenIndex, tokenLine, tokenColumn, parser.index, parser.line, parser.column, 9);
+                    reportMessageAt(tokenStart, parser.currentLocation, 9);
                 }
                 if (parser.flags & 4096) {
-                    reportMessageAt(tokenIndex, tokenLine, tokenColumn, parser.index, parser.line, parser.column, 15);
+                    reportMessageAt(tokenStart, parser.currentLocation, 15);
                 }
                 if (scopeError)
                     reportScopeError(scopeError);
             }
-            body.push(parseDirective(parser, context, expr, token, tokenIndex, parser.tokenLine, parser.tokenColumn));
+            body.push(parseDirective(parser, context, expr, token, tokenStart));
         }
         if (context & 256) {
             if (funcNameToken) {
@@ -6256,12 +6276,13 @@ function parseFunctionBody(parser, context, scope, privateScope, origin, funcNam
     parser.flags &= -4289;
     if (parser.getToken() === 1077936155)
         report(parser, 26);
-    return finishNode(parser, context, tokenIndex, tokenLine, tokenColumn, {
+    return parser.finishNode({
         type: 'BlockStatement',
         body,
-    });
+    }, tokenStart);
 }
-function parseSuperExpression(parser, context, start, line, column) {
+function parseSuperExpression(parser, context) {
+    const { tokenStart } = parser;
     nextToken(parser, context);
     switch (parser.getToken()) {
         case 67108990:
@@ -6282,28 +6303,29 @@ function parseSuperExpression(parser, context, start, line, column) {
         default:
             report(parser, 30, 'super');
     }
-    return finishNode(parser, context, start, line, column, { type: 'Super' });
+    return parser.finishNode({ type: 'Super' }, tokenStart);
 }
-function parseLeftHandSideExpression(parser, context, privateScope, canAssign, inGroup, isLHS, start, line, column) {
-    const expression = parsePrimaryExpression(parser, context, privateScope, 2, 0, canAssign, inGroup, isLHS, start, line, column);
-    return parseMemberOrUpdateExpression(parser, context, privateScope, expression, inGroup, 0, start, line, column);
+function parseLeftHandSideExpression(parser, context, privateScope, canAssign, inGroup, isLHS) {
+    const start = parser.tokenStart;
+    const expression = parsePrimaryExpression(parser, context, privateScope, 2, 0, canAssign, inGroup, isLHS, start);
+    return parseMemberOrUpdateExpression(parser, context, privateScope, expression, inGroup, 0, start);
 }
-function parseUpdateExpression(parser, context, expr, start, line, column) {
+function parseUpdateExpression(parser, context, expr, start) {
     if (parser.assignable & 2)
         report(parser, 55);
     const token = parser.getToken();
     nextToken(parser, context);
     parser.assignable = 2;
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'UpdateExpression',
         argument: expr,
         operator: KeywordDescTable[token & 255],
         prefix: false,
-    });
+    }, start);
 }
-function parseMemberOrUpdateExpression(parser, context, privateScope, expr, inGroup, inChain, start, line, column) {
+function parseMemberOrUpdateExpression(parser, context, privateScope, expr, inGroup, inChain, start) {
     if ((parser.getToken() & 33619968) === 33619968 && (parser.flags & 1) === 0) {
-        expr = parseUpdateExpression(parser, context, expr, start, line, column);
+        expr = parseUpdateExpression(parser, context, expr, start);
     }
     else if ((parser.getToken() & 67108864) === 67108864) {
         context = (context | 33554432) ^ 33554432;
@@ -6315,12 +6337,13 @@ function parseMemberOrUpdateExpression(parser, context, privateScope, expr, inGr
                 }
                 parser.assignable = 1;
                 const property = parsePropertyOrPrivatePropertyName(parser, context | 16384, privateScope);
-                expr = finishNode(parser, context, start, line, column, {
+                expr = parser.finishNode({
                     type: 'MemberExpression',
                     object: expr,
                     computed: false,
                     property,
-                });
+                    optional: false,
+                }, start);
                 break;
             }
             case 69271571: {
@@ -6330,16 +6353,17 @@ function parseMemberOrUpdateExpression(parser, context, privateScope, expr, inGr
                     parser.flags = (parser.flags | 2048) ^ 2048;
                 }
                 nextToken(parser, context | 8192);
-                const { tokenIndex, tokenLine, tokenColumn } = parser;
-                const property = parseExpressions(parser, context, privateScope, inGroup, 1, tokenIndex, tokenLine, tokenColumn);
+                const { tokenStart } = parser;
+                const property = parseExpressions(parser, context, privateScope, inGroup, 1, tokenStart);
                 consume(parser, context, 20);
                 parser.assignable = 1;
-                expr = finishNode(parser, context, start, line, column, {
+                expr = parser.finishNode({
                     type: 'MemberExpression',
                     object: expr,
                     computed: true,
                     property,
-                });
+                    optional: false,
+                }, start);
                 if (restoreHasOptionalChaining) {
                     parser.flags |= 2048;
                 }
@@ -6357,11 +6381,12 @@ function parseMemberOrUpdateExpression(parser, context, privateScope, expr, inGr
                 }
                 const args = parseArguments(parser, context, privateScope, inGroup);
                 parser.assignable = 2;
-                expr = finishNode(parser, context, start, line, column, {
+                expr = parser.finishNode({
                     type: 'CallExpression',
                     callee: expr,
                     arguments: args,
-                });
+                    optional: false,
+                }, start);
                 if (restoreHasOptionalChaining) {
                     parser.flags |= 2048;
                 }
@@ -6371,7 +6396,7 @@ function parseMemberOrUpdateExpression(parser, context, privateScope, expr, inGr
                 nextToken(parser, (context | 67108864 | 2048) ^ 2048);
                 parser.flags |= 2048;
                 parser.assignable = 2;
-                expr = parseOptionalChain(parser, context, privateScope, expr, start, line, column);
+                expr = parseOptionalChain(parser, context, privateScope, expr, start);
                 break;
             }
             default:
@@ -6379,26 +6404,26 @@ function parseMemberOrUpdateExpression(parser, context, privateScope, expr, inGr
                     report(parser, 166);
                 }
                 parser.assignable = 2;
-                expr = finishNode(parser, context, start, line, column, {
+                expr = parser.finishNode({
                     type: 'TaggedTemplateExpression',
                     tag: expr,
                     quasi: parser.getToken() === 67174408
                         ? parseTemplate(parser, context | 16384, privateScope)
-                        : parseTemplateLiteral(parser, context, parser.tokenIndex, parser.tokenLine, parser.tokenColumn),
-                });
+                        : parseTemplateLiteral(parser, context, parser.tokenStart),
+                }, start);
         }
-        expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 0, 1, start, line, column);
+        expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 0, 1, start);
     }
     if (inChain === 0 && (parser.flags & 2048) === 2048) {
         parser.flags = (parser.flags | 2048) ^ 2048;
-        expr = finishNode(parser, context, start, line, column, {
+        expr = parser.finishNode({
             type: 'ChainExpression',
             expression: expr,
-        });
+        }, start);
     }
     return expr;
 }
-function parseOptionalChain(parser, context, privateScope, expr, start, line, column) {
+function parseOptionalChain(parser, context, privateScope, expr, start) {
     let restoreHasOptionalChaining = false;
     let node;
     if (parser.getToken() === 69271571 || parser.getToken() === 67174411) {
@@ -6409,38 +6434,38 @@ function parseOptionalChain(parser, context, privateScope, expr, start, line, co
     }
     if (parser.getToken() === 69271571) {
         nextToken(parser, context | 8192);
-        const { tokenIndex, tokenLine, tokenColumn } = parser;
-        const property = parseExpressions(parser, context, privateScope, 0, 1, tokenIndex, tokenLine, tokenColumn);
+        const { tokenStart } = parser;
+        const property = parseExpressions(parser, context, privateScope, 0, 1, tokenStart);
         consume(parser, context, 20);
         parser.assignable = 2;
-        node = finishNode(parser, context, start, line, column, {
+        node = parser.finishNode({
             type: 'MemberExpression',
             object: expr,
             computed: true,
             optional: true,
             property,
-        });
+        }, start);
     }
     else if (parser.getToken() === 67174411) {
         const args = parseArguments(parser, context, privateScope, 0);
         parser.assignable = 2;
-        node = finishNode(parser, context, start, line, column, {
+        node = parser.finishNode({
             type: 'CallExpression',
             callee: expr,
             arguments: args,
             optional: true,
-        });
+        }, start);
     }
     else {
         const property = parsePropertyOrPrivatePropertyName(parser, context, privateScope);
         parser.assignable = 2;
-        node = finishNode(parser, context, start, line, column, {
+        node = parser.finishNode({
             type: 'MemberExpression',
             object: expr,
             computed: false,
             optional: true,
             property,
-        });
+        }, start);
     }
     if (restoreHasOptionalChaining) {
         parser.flags |= 2048;
@@ -6455,37 +6480,37 @@ function parsePropertyOrPrivatePropertyName(parser, context, privateScope) {
         report(parser, 160);
     }
     return parser.getToken() === 130
-        ? parsePrivateIdentifier(parser, context, privateScope, 0, parser.tokenIndex, parser.tokenLine, parser.tokenColumn)
+        ? parsePrivateIdentifier(parser, context, privateScope, 0)
         : parseIdentifier(parser, context);
 }
-function parseUpdateExpressionPrefixed(parser, context, privateScope, inNew, isLHS, start, line, column) {
+function parseUpdateExpressionPrefixed(parser, context, privateScope, inNew, isLHS, start) {
     if (inNew)
         report(parser, 56);
     if (!isLHS)
         report(parser, 0);
     const token = parser.getToken();
     nextToken(parser, context | 8192);
-    const arg = parseLeftHandSideExpression(parser, context, privateScope, 0, 0, 1, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+    const arg = parseLeftHandSideExpression(parser, context, privateScope, 0, 0, 1);
     if (parser.assignable & 2) {
         report(parser, 55);
     }
     parser.assignable = 2;
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'UpdateExpression',
         argument: arg,
         operator: KeywordDescTable[token & 255],
         prefix: true,
-    });
+    }, start);
 }
-function parsePrimaryExpression(parser, context, privateScope, kind, inNew, canAssign, inGroup, isLHS, start, line, column) {
+function parsePrimaryExpression(parser, context, privateScope, kind, inNew, canAssign, inGroup, isLHS, start) {
     if ((parser.getToken() & 143360) === 143360) {
         switch (parser.getToken()) {
             case 209006:
-                return parseAwaitExpressionOrIdentifier(parser, context, privateScope, inNew, inGroup, start, line, column);
+                return parseAwaitExpressionOrIdentifier(parser, context, privateScope, inNew, inGroup, start);
             case 241771:
-                return parseYieldExpressionOrIdentifier(parser, context, privateScope, inGroup, canAssign, start, line, column);
+                return parseYieldExpressionOrIdentifier(parser, context, privateScope, inGroup, canAssign, start);
             case 209005:
-                return parseAsyncExpression(parser, context, privateScope, inGroup, isLHS, canAssign, inNew, start, line, column);
+                return parseAsyncExpression(parser, context, privateScope, inGroup, isLHS, canAssign, inNew, start);
         }
         const { tokenValue } = parser;
         const token = parser.getToken();
@@ -6497,7 +6522,7 @@ function parsePrimaryExpression(parser, context, privateScope, kind, inNew, canA
             if ((token & 36864) === 36864) {
                 parser.flags |= 256;
             }
-            return parseArrowFromIdentifier(parser, context, privateScope, tokenValue, expr, inNew, canAssign, 0, start, line, column);
+            return parseArrowFromIdentifier(parser, context, privateScope, tokenValue, expr, inNew, canAssign, 0, start);
         }
         if (context & 4096 &&
             !(context & 8388608) &&
@@ -6522,7 +6547,7 @@ function parsePrimaryExpression(parser, context, privateScope, kind, inNew, canA
     switch (parser.getToken()) {
         case 33619993:
         case 33619994:
-            return parseUpdateExpressionPrefixed(parser, context, privateScope, inNew, isLHS, start, line, column);
+            return parseUpdateExpressionPrefixed(parser, context, privateScope, inNew, isLHS, start);
         case 16863276:
         case 16842798:
         case 16842799:
@@ -6530,63 +6555,64 @@ function parsePrimaryExpression(parser, context, privateScope, kind, inNew, canA
         case 25233969:
         case 16863275:
         case 16863277:
-            return parseUnaryExpression(parser, context, privateScope, isLHS, start, line, column, inGroup);
+            return parseUnaryExpression(parser, context, privateScope, isLHS, inGroup);
         case 86104:
-            return parseFunctionExpression(parser, context, privateScope, 0, inGroup, start, line, column);
+            return parseFunctionExpression(parser, context, privateScope, 0, inGroup, start);
         case 2162700:
-            return parseObjectLiteral(parser, context, privateScope, canAssign ? 0 : 1, inGroup, start, line, column);
+            return parseObjectLiteral(parser, context, privateScope, canAssign ? 0 : 1, inGroup);
         case 69271571:
-            return parseArrayLiteral(parser, context, privateScope, canAssign ? 0 : 1, inGroup, start, line, column);
+            return parseArrayLiteral(parser, context, privateScope, canAssign ? 0 : 1, inGroup);
         case 67174411:
-            return parseParenthesizedExpression(parser, context | 16384, privateScope, canAssign, 1, 0, start, line, column);
+            return parseParenthesizedExpression(parser, context | 16384, privateScope, canAssign, 1, 0, start);
         case 86021:
         case 86022:
         case 86023:
-            return parseNullOrTrueOrFalseLiteral(parser, context, start, line, column);
+            return parseNullOrTrueOrFalseLiteral(parser, context);
         case 86111:
             return parseThisExpression(parser, context);
         case 65540:
-            return parseRegExpLiteral(parser, context, start, line, column);
+            return parseRegExpLiteral(parser, context);
         case 132:
         case 86094:
-            return parseClassExpression(parser, context, privateScope, inGroup, start, line, column);
+            return parseClassExpression(parser, context, privateScope, inGroup, start);
         case 86109:
-            return parseSuperExpression(parser, context, start, line, column);
+            return parseSuperExpression(parser, context);
         case 67174409:
-            return parseTemplateLiteral(parser, context, start, line, column);
+            return parseTemplateLiteral(parser, context, start);
         case 67174408:
             return parseTemplate(parser, context, privateScope);
         case 86107:
-            return parseNewExpression(parser, context, privateScope, inGroup, start, line, column);
+            return parseNewExpression(parser, context, privateScope, inGroup);
         case 134283388:
-            return parseBigIntLiteral(parser, context, start, line, column);
+            return parseBigIntLiteral(parser, context);
         case 130:
-            return parsePrivateIdentifier(parser, context, privateScope, 0, start, line, column);
+            return parsePrivateIdentifier(parser, context, privateScope, 0);
         case 86106:
-            return parseImportCallOrMetaExpression(parser, context, privateScope, inNew, inGroup, start, line, column);
+            return parseImportCallOrMetaExpression(parser, context, privateScope, inNew, inGroup, start);
         case 8456256:
             if (context & 8)
-                return parseJSXRootElementOrFragment(parser, context, privateScope, 0, start, line, column);
+                return parseJSXRootElementOrFragment(parser, context, privateScope, 0, parser.tokenStart);
         default:
             if (isValidIdentifier(context, parser.getToken()))
-                return parseIdentifierOrArrow(parser, context, privateScope, start, line, column);
+                return parseIdentifierOrArrow(parser, context, privateScope);
             report(parser, 30, KeywordDescTable[parser.getToken() & 255]);
     }
 }
-function parseImportCallOrMetaExpression(parser, context, privateScope, inNew, inGroup, start, line, column) {
+function parseImportCallOrMetaExpression(parser, context, privateScope, inNew, inGroup, start) {
     let expr = parseIdentifier(parser, context);
     if (parser.getToken() === 67108877) {
-        return parseImportMetaExpression(parser, context, expr, start, line, column);
+        return parseImportMetaExpression(parser, context, expr);
     }
     if (inNew)
         report(parser, 142);
-    expr = parseImportExpression(parser, context, privateScope, inGroup, start, line, column);
+    expr = parseImportExpression(parser, context, privateScope, inGroup, start);
     parser.assignable = 2;
-    return parseMemberOrUpdateExpression(parser, context, privateScope, expr, inGroup, 0, start, line, column);
+    return parseMemberOrUpdateExpression(parser, context, privateScope, expr, inGroup, 0, start);
 }
-function parseImportMetaExpression(parser, context, meta, start, line, column) {
+function parseImportMetaExpression(parser, context, meta) {
     if ((context & 512) === 0)
         report(parser, 169);
+    const { tokenStart } = parser;
     nextToken(parser, context);
     const token = parser.getToken();
     if (token !== 209030 && parser.tokenValue !== 'meta') {
@@ -6596,23 +6622,23 @@ function parseImportMetaExpression(parser, context, meta, start, line, column) {
         report(parser, 175);
     }
     parser.assignable = 2;
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'MetaProperty',
         meta,
         property: parseIdentifier(parser, context),
-    });
+    }, tokenStart);
 }
-function parseImportExpression(parser, context, privateScope, inGroup, start, line, column) {
+function parseImportExpression(parser, context, privateScope, inGroup, start) {
     consume(parser, context | 8192, 67174411);
     if (parser.getToken() === 14)
         report(parser, 143);
-    const source = parseExpression(parser, context, privateScope, 1, inGroup, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+    const source = parseExpression(parser, context, privateScope, 1, inGroup, parser.tokenStart);
     let options = null;
     if (parser.getToken() === 18) {
         consume(parser, context, 18);
         if (parser.getToken() !== 16) {
             const expContext = (context | 33554432) ^ 33554432;
-            options = parseExpression(parser, expContext, privateScope, 1, inGroup, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+            options = parseExpression(parser, expContext, privateScope, 1, inGroup, parser.tokenStart);
         }
         consumeOpt(parser, context, 18);
     }
@@ -6622,7 +6648,7 @@ function parseImportExpression(parser, context, privateScope, inGroup, start, li
         options,
     };
     consume(parser, context, 16);
-    return finishNode(parser, context, start, line, column, node);
+    return parser.finishNode(node, start);
 }
 function parseImportAttributes(parser, context, specifiers = null) {
     if (!consumeOpt(parser, context, 20579))
@@ -6631,9 +6657,7 @@ function parseImportAttributes(parser, context, specifiers = null) {
     const attributes = [];
     const keysContent = new Set();
     while (parser.getToken() !== 1074790415) {
-        const start = parser.tokenIndex;
-        const line = parser.tokenLine;
-        const column = parser.tokenColumn;
+        const start = parser.tokenStart;
         const key = parseIdentifierOrStringLiteral(parser, context);
         consume(parser, context, 21);
         const value = parseStringLiteral(parser, context);
@@ -6657,11 +6681,11 @@ function parseImportAttributes(parser, context, specifiers = null) {
             report(parser, 145, `${keyContent}`);
         }
         keysContent.add(keyContent);
-        attributes.push(finishNode(parser, context, start, line, column, {
+        attributes.push(parser.finishNode({
             type: 'ImportAttribute',
             key,
             value,
-        }));
+        }, start));
         if (parser.getToken() !== 1074790415) {
             consume(parser, context, 18);
         }
@@ -6711,8 +6735,8 @@ function parseModuleExportName(parser, context) {
         report(parser, 30, KeywordDescTable[parser.getToken() & 255]);
     }
 }
-function parseBigIntLiteral(parser, context, start, line, column) {
-    const { tokenRaw, tokenValue } = parser;
+function parseBigIntLiteral(parser, context) {
+    const { tokenRaw, tokenValue, tokenStart } = parser;
     nextToken(parser, context);
     parser.assignable = 2;
     const node = {
@@ -6723,61 +6747,57 @@ function parseBigIntLiteral(parser, context, start, line, column) {
     if (context & 128) {
         node.raw = tokenRaw;
     }
-    return finishNode(parser, context, start, line, column, node);
+    return parser.finishNode(node, tokenStart);
 }
-function parseTemplateLiteral(parser, context, start, line, column) {
+function parseTemplateLiteral(parser, context, start) {
     parser.assignable = 2;
-    const { tokenValue, tokenRaw, tokenIndex, tokenLine, tokenColumn } = parser;
+    const { tokenValue, tokenRaw, tokenStart } = parser;
     consume(parser, context, 67174409);
-    const quasis = [
-        parseTemplateElement(parser, context, tokenValue, tokenRaw, tokenIndex, tokenLine, tokenColumn, true),
-    ];
-    return finishNode(parser, context, start, line, column, {
+    const quasis = [parseTemplateElement(parser, context, tokenValue, tokenRaw, tokenStart, true)];
+    return parser.finishNode({
         type: 'TemplateLiteral',
         expressions: [],
         quasis,
-    });
+    }, start);
 }
 function parseTemplate(parser, context, privateScope) {
     context = (context | 33554432) ^ 33554432;
-    const { tokenValue, tokenRaw, tokenIndex, tokenLine, tokenColumn } = parser;
+    const { tokenValue, tokenRaw, tokenStart } = parser;
     consume(parser, (context & -16385) | 8192, 67174408);
-    const quasis = [
-        parseTemplateElement(parser, context, tokenValue, tokenRaw, tokenIndex, tokenLine, tokenColumn, false),
-    ];
+    const quasis = [parseTemplateElement(parser, context, tokenValue, tokenRaw, tokenStart, false)];
     const expressions = [
-        parseExpressions(parser, context & -16385, privateScope, 0, 1, parser.tokenIndex, parser.tokenLine, parser.tokenColumn),
+        parseExpressions(parser, context & -16385, privateScope, 0, 1, parser.tokenStart),
     ];
     if (parser.getToken() !== 1074790415)
         report(parser, 83);
     while (parser.setToken(scanTemplateTail(parser, context), true) !== 67174409) {
-        const { tokenValue, tokenRaw, tokenIndex, tokenLine, tokenColumn } = parser;
+        const { tokenValue, tokenRaw, tokenStart } = parser;
         consume(parser, (context & -16385) | 8192, 67174408);
-        quasis.push(parseTemplateElement(parser, context, tokenValue, tokenRaw, tokenIndex, tokenLine, tokenColumn, false));
-        expressions.push(parseExpressions(parser, context, privateScope, 0, 1, parser.tokenIndex, parser.tokenLine, parser.tokenColumn));
+        quasis.push(parseTemplateElement(parser, context, tokenValue, tokenRaw, tokenStart, false));
+        expressions.push(parseExpressions(parser, context, privateScope, 0, 1, parser.tokenStart));
         if (parser.getToken() !== 1074790415)
             report(parser, 83);
     }
     {
-        const { tokenValue, tokenRaw, tokenIndex, tokenLine, tokenColumn } = parser;
+        const { tokenValue, tokenRaw, tokenStart } = parser;
         consume(parser, context, 67174409);
-        quasis.push(parseTemplateElement(parser, context, tokenValue, tokenRaw, tokenIndex, tokenLine, tokenColumn, true));
+        quasis.push(parseTemplateElement(parser, context, tokenValue, tokenRaw, tokenStart, true));
     }
-    return finishNode(parser, context, tokenIndex, tokenLine, tokenColumn, {
+    return parser.finishNode({
         type: 'TemplateLiteral',
         expressions,
         quasis,
-    });
+    }, tokenStart);
 }
-function parseTemplateElement(parser, context, cooked, raw, start, line, col, tail) {
-    const node = finishNode(parser, context, start, line, col, {
+function parseTemplateElement(parser, context, cooked, raw, start, tail) {
+    const node = parser.finishNode({
         type: 'TemplateElement',
         value: {
             cooked,
             raw,
         },
         tail,
-    });
+    }, start);
     const tailSize = tail ? 1 : 2;
     if (context & 2) {
         node.start += 1;
@@ -6791,15 +6811,16 @@ function parseTemplateElement(parser, context, cooked, raw, start, line, col, ta
     }
     return node;
 }
-function parseSpreadElement(parser, context, privateScope, start, line, column) {
+function parseSpreadElement(parser, context, privateScope) {
+    const start = parser.tokenStart;
     context = (context | 33554432) ^ 33554432;
     consume(parser, context | 8192, 14);
-    const argument = parseExpression(parser, context, privateScope, 1, 0, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+    const argument = parseExpression(parser, context, privateScope, 1, 0, parser.tokenStart);
     parser.assignable = 1;
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'SpreadElement',
         argument,
-    });
+    }, start);
 }
 function parseArguments(parser, context, privateScope, inGroup) {
     nextToken(parser, context | 8192);
@@ -6810,10 +6831,10 @@ function parseArguments(parser, context, privateScope, inGroup) {
     }
     while (parser.getToken() !== 16) {
         if (parser.getToken() === 14) {
-            args.push(parseSpreadElement(parser, context, privateScope, parser.tokenIndex, parser.tokenLine, parser.tokenColumn));
+            args.push(parseSpreadElement(parser, context, privateScope));
         }
         else {
-            args.push(parseExpression(parser, context, privateScope, 1, inGroup, parser.tokenIndex, parser.tokenLine, parser.tokenColumn));
+            args.push(parseExpression(parser, context, privateScope, 1, inGroup, parser.tokenStart));
         }
         if (parser.getToken() !== 18)
             break;
@@ -6825,22 +6846,22 @@ function parseArguments(parser, context, privateScope, inGroup) {
     return args;
 }
 function parseIdentifier(parser, context) {
-    const { tokenValue, tokenIndex, tokenLine, tokenColumn } = parser;
+    const { tokenValue, tokenStart } = parser;
     const allowRegex = tokenValue === 'await' && (parser.getToken() & -2147483648) === 0;
     nextToken(parser, context | (allowRegex ? 8192 : 0));
-    return finishNode(parser, context, tokenIndex, tokenLine, tokenColumn, {
+    return parser.finishNode({
         type: 'Identifier',
         name: tokenValue,
-    });
+    }, tokenStart);
 }
 function parseLiteral(parser, context) {
-    const { tokenValue, tokenRaw, tokenIndex, tokenLine, tokenColumn } = parser;
+    const { tokenValue, tokenRaw, tokenStart } = parser;
     if (parser.getToken() === 134283388) {
-        return parseBigIntLiteral(parser, context, tokenIndex, tokenLine, tokenColumn);
+        return parseBigIntLiteral(parser, context);
     }
     nextToken(parser, context);
     parser.assignable = 2;
-    return finishNode(parser, context, tokenIndex, tokenLine, tokenColumn, context & 128
+    return parser.finishNode(context & 128
         ? {
             type: 'Literal',
             value: tokenValue,
@@ -6849,14 +6870,15 @@ function parseLiteral(parser, context) {
         : {
             type: 'Literal',
             value: tokenValue,
-        });
+        }, tokenStart);
 }
-function parseNullOrTrueOrFalseLiteral(parser, context, start, line, column) {
+function parseNullOrTrueOrFalseLiteral(parser, context) {
+    const start = parser.tokenStart;
     const raw = KeywordDescTable[parser.getToken() & 255];
     const value = parser.getToken() === 86023 ? null : raw === 'true';
     nextToken(parser, context);
     parser.assignable = 2;
-    return finishNode(parser, context, start, line, column, context & 128
+    return parser.finishNode(context & 128
         ? {
             type: 'Literal',
             value,
@@ -6865,17 +6887,17 @@ function parseNullOrTrueOrFalseLiteral(parser, context, start, line, column) {
         : {
             type: 'Literal',
             value,
-        });
+        }, start);
 }
 function parseThisExpression(parser, context) {
-    const { tokenIndex, tokenLine, tokenColumn } = parser;
+    const { tokenStart } = parser;
     nextToken(parser, context);
     parser.assignable = 2;
-    return finishNode(parser, context, tokenIndex, tokenLine, tokenColumn, {
+    return parser.finishNode({
         type: 'ThisExpression',
-    });
+    }, tokenStart);
 }
-function parseFunctionDeclaration(parser, context, scope, privateScope, origin, allowGen, flags, isAsync, start, line, column) {
+function parseFunctionDeclaration(parser, context, scope, privateScope, origin, allowGen, flags, isAsync, start) {
     nextToken(parser, context | 8192);
     const isGenerator = allowGen ? optionalBit(parser, context, 8391476) : 0;
     let id = null;
@@ -6931,16 +6953,16 @@ function parseFunctionDeclaration(parser, context, scope, privateScope, origin,
     const params = parseFormalParametersOrFormalList(parser, (context | 2097152) & -268435457, functionScope, privateScope, 0, 1);
     const modifierFlags = 2048 | 1024 | 32768 | 268435456;
     const body = parseFunctionBody(parser, ((context | modifierFlags) ^ modifierFlags) | 8388608 | 1048576, scope ? addChildScope(functionScope, 128) : functionScope, privateScope, 8, funcNameToken, functionScope?.scopeError);
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'FunctionDeclaration',
         id,
         params,
         body,
         async: isAsync === 1,
         generator: isGenerator === 1,
-    });
+    }, start);
 }
-function parseFunctionExpression(parser, context, privateScope, isAsync, inGroup, start, line, column) {
+function parseFunctionExpression(parser, context, privateScope, isAsync, inGroup, start) {
     nextToken(parser, context | 8192);
     const isGenerator = optionalBit(parser, context, 8391476);
     const generatorAndAsyncFlags = (isAsync ? 524288 : 0) | (isGenerator ? 262144 : 0);
@@ -6973,17 +6995,17 @@ function parseFunctionExpression(parser, context, privateScope, isAsync, inGroup
         8388608 |
         1048576, scope ? addChildScope(scope, 128) : scope, privateScope, 0, funcNameToken, scope?.scopeError);
     parser.assignable = 2;
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'FunctionExpression',
         id,
         params,
         body,
         async: isAsync === 1,
         generator: isGenerator === 1,
-    });
+    }, start);
 }
-function parseArrayLiteral(parser, context, privateScope, skipInitializer, inGroup, start, line, column) {
-    const expr = parseArrayExpressionOrPattern(parser, context, void 0, privateScope, skipInitializer, inGroup, 0, 2, 0, start, line, column);
+function parseArrayLiteral(parser, context, privateScope, skipInitializer, inGroup) {
+    const expr = parseArrayExpressionOrPattern(parser, context, void 0, privateScope, skipInitializer, inGroup, 0, 2, 0);
     if (parser.destructible & 64) {
         report(parser, 63);
     }
@@ -6992,7 +7014,8 @@ function parseArrayLiteral(parser, context, privateScope, skipInitializer, inGro
     }
     return expr;
 }
-function parseArrayExpressionOrPattern(parser, context, scope, privateScope, skipInitializer, inGroup, isPattern, kind, origin, start, line, column) {
+function parseArrayExpressionOrPattern(parser, context, scope, privateScope, skipInitializer, inGroup, isPattern, kind, origin) {
+    const { tokenStart: start } = parser;
     nextToken(parser, context | 8192);
     const elements = [];
     let destructible = 0;
@@ -7003,18 +7026,18 @@ function parseArrayExpressionOrPattern(parser, context, scope, privateScope, ski
         }
         else {
             let left;
-            const { tokenIndex, tokenLine, tokenColumn, tokenValue } = parser;
+            const { tokenStart, tokenValue } = parser;
             const token = parser.getToken();
             if (token & 143360) {
-                left = parsePrimaryExpression(parser, context, privateScope, kind, 0, 1, inGroup, 1, tokenIndex, tokenLine, tokenColumn);
+                left = parsePrimaryExpression(parser, context, privateScope, kind, 0, 1, inGroup, 1, tokenStart);
                 if (parser.getToken() === 1077936155) {
                     if (parser.assignable & 2)
                         report(parser, 26);
                     nextToken(parser, context | 8192);
                     if (scope)
                         addVarOrBlock(parser, context, scope, tokenValue, kind, origin);
-                    const right = parseExpression(parser, context, privateScope, 1, inGroup, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
-                    left = finishNode(parser, context, tokenIndex, tokenLine, tokenColumn, isPattern
+                    const right = parseExpression(parser, context, privateScope, 1, inGroup, parser.tokenStart);
+                    left = parser.finishNode(isPattern
                         ? {
                             type: 'AssignmentPattern',
                             left,
@@ -7025,7 +7048,7 @@ function parseArrayExpressionOrPattern(parser, context, scope, privateScope, ski
                             operator: '=',
                             left,
                             right,
-                        });
+                        }, tokenStart);
                     destructible |=
                         parser.destructible & 256
                             ? 256
@@ -7054,11 +7077,11 @@ function parseArrayExpressionOrPattern(parser, context, scope, privateScope, ski
                             : (kind & 2) === 0
                                 ? 16
                                 : 0;
-                    left = parseMemberOrUpdateExpression(parser, context, privateScope, left, inGroup, 0, tokenIndex, tokenLine, tokenColumn);
+                    left = parseMemberOrUpdateExpression(parser, context, privateScope, left, inGroup, 0, tokenStart);
                     if (parser.getToken() !== 18 && parser.getToken() !== 20) {
                         if (parser.getToken() !== 1077936155)
                             destructible |= 16;
-                        left = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenIndex, tokenLine, tokenColumn, left);
+                        left = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenStart, left);
                     }
                     else if (parser.getToken() !== 1077936155) {
                         destructible |=
@@ -7071,8 +7094,8 @@ function parseArrayExpressionOrPattern(parser, context, scope, privateScope, ski
             else if (token & 2097152) {
                 left =
                     parser.getToken() === 2162700
-                        ? parseObjectLiteralOrPattern(parser, context, scope, privateScope, 0, inGroup, isPattern, kind, origin, tokenIndex, tokenLine, tokenColumn)
-                        : parseArrayExpressionOrPattern(parser, context, scope, privateScope, 0, inGroup, isPattern, kind, origin, tokenIndex, tokenLine, tokenColumn);
+                        ? parseObjectLiteralOrPattern(parser, context, scope, privateScope, 0, inGroup, isPattern, kind, origin)
+                        : parseArrayExpressionOrPattern(parser, context, scope, privateScope, 0, inGroup, isPattern, kind, origin);
                 destructible |= parser.destructible;
                 parser.assignable =
                     parser.destructible & 16
@@ -7087,10 +7110,10 @@ function parseArrayExpressionOrPattern(parser, context, scope, privateScope, ski
                     report(parser, 71);
                 }
                 else {
-                    left = parseMemberOrUpdateExpression(parser, context, privateScope, left, inGroup, 0, tokenIndex, tokenLine, tokenColumn);
+                    left = parseMemberOrUpdateExpression(parser, context, privateScope, left, inGroup, 0, tokenStart);
                     destructible = parser.assignable & 2 ? 16 : 0;
                     if (parser.getToken() !== 18 && parser.getToken() !== 20) {
-                        left = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenIndex, tokenLine, tokenColumn, left);
+                        left = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenStart, left);
                     }
                     else if (parser.getToken() !== 1077936155) {
                         destructible |=
@@ -7101,15 +7124,15 @@ function parseArrayExpressionOrPattern(parser, context, scope, privateScope, ski
                 }
             }
             else if (token === 14) {
-                left = parseSpreadOrRestElement(parser, context, scope, privateScope, 20, kind, origin, 0, inGroup, isPattern, tokenIndex, tokenLine, tokenColumn);
+                left = parseSpreadOrRestElement(parser, context, scope, privateScope, 20, kind, origin, 0, inGroup, isPattern);
                 destructible |= parser.destructible;
                 if (parser.getToken() !== 18 && parser.getToken() !== 20)
                     report(parser, 30, KeywordDescTable[parser.getToken() & 255]);
             }
             else {
-                left = parseLeftHandSideExpression(parser, context, privateScope, 1, 0, 1, tokenIndex, tokenLine, tokenColumn);
+                left = parseLeftHandSideExpression(parser, context, privateScope, 1, 0, 1);
                 if (parser.getToken() !== 18 && parser.getToken() !== 20) {
-                    left = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenIndex, tokenLine, tokenColumn, left);
+                    left = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenStart, left);
                     if ((kind & (2 | 1)) === 0 && token === 67174411)
                         destructible |= 16;
                 }
@@ -7133,17 +7156,17 @@ function parseArrayExpressionOrPattern(parser, context, scope, privateScope, ski
         }
     }
     consume(parser, context, 20);
-    const node = finishNode(parser, context, start, line, column, {
+    const node = parser.finishNode({
         type: isPattern ? 'ArrayPattern' : 'ArrayExpression',
         elements,
-    });
+    }, start);
     if (!skipInitializer && parser.getToken() & 4194304) {
-        return parseArrayOrObjectAssignmentPattern(parser, context, privateScope, destructible, inGroup, isPattern, start, line, column, node);
+        return parseArrayOrObjectAssignmentPattern(parser, context, privateScope, destructible, inGroup, isPattern, start, node);
     }
     parser.destructible = destructible;
     return node;
 }
-function parseArrayOrObjectAssignmentPattern(parser, context, privateScope, destructible, inGroup, isPattern, start, line, column, node) {
+function parseArrayOrObjectAssignmentPattern(parser, context, privateScope, destructible, inGroup, isPattern, start, node) {
     if (parser.getToken() !== 1077936155)
         report(parser, 26);
     nextToken(parser, context | 8192);
@@ -7151,14 +7174,14 @@ function parseArrayOrObjectAssignmentPattern(parser, context, privateScope, dest
         report(parser, 26);
     if (!isPattern)
         reinterpretToPattern(parser, node);
-    const { tokenIndex, tokenLine, tokenColumn } = parser;
-    const right = parseExpression(parser, context, privateScope, 1, inGroup, tokenIndex, tokenLine, tokenColumn);
+    const { tokenStart } = parser;
+    const right = parseExpression(parser, context, privateScope, 1, inGroup, tokenStart);
     parser.destructible =
         ((destructible | 64 | 8) ^
             (8 | 64)) |
             (parser.destructible & 128 ? 128 : 0) |
             (parser.destructible & 256 ? 256 : 0);
-    return finishNode(parser, context, start, line, column, isPattern
+    return parser.finishNode(isPattern
         ? {
             type: 'AssignmentPattern',
             left: node,
@@ -7169,24 +7192,25 @@ function parseArrayOrObjectAssignmentPattern(parser, context, privateScope, dest
             left: node,
             operator: '=',
             right,
-        });
+        }, start);
 }
-function parseSpreadOrRestElement(parser, context, scope, privateScope, closingToken, kind, origin, isAsync, inGroup, isPattern, start, line, column) {
+function parseSpreadOrRestElement(parser, context, scope, privateScope, closingToken, kind, origin, isAsync, inGroup, isPattern) {
+    const { tokenStart: start } = parser;
     nextToken(parser, context | 8192);
     let argument = null;
     let destructible = 0;
-    const { tokenValue, tokenIndex, tokenLine, tokenColumn } = parser;
+    const { tokenValue, tokenStart } = parser;
     let token = parser.getToken();
     if (token & 143360) {
         parser.assignable = 1;
-        argument = parsePrimaryExpression(parser, context, privateScope, kind, 0, 1, inGroup, 1, tokenIndex, tokenLine, tokenColumn);
+        argument = parsePrimaryExpression(parser, context, privateScope, kind, 0, 1, inGroup, 1, tokenStart);
         token = parser.getToken();
-        argument = parseMemberOrUpdateExpression(parser, context, privateScope, argument, inGroup, 0, tokenIndex, tokenLine, tokenColumn);
+        argument = parseMemberOrUpdateExpression(parser, context, privateScope, argument, inGroup, 0, tokenStart);
         if (parser.getToken() !== 18 && parser.getToken() !== closingToken) {
             if (parser.assignable & 2 && parser.getToken() === 1077936155)
                 report(parser, 71);
             destructible |= 16;
-            argument = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenIndex, tokenLine, tokenColumn, argument);
+            argument = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenStart, argument);
         }
         if (parser.assignable & 2) {
             destructible |= 16;
@@ -7206,25 +7230,25 @@ function parseSpreadOrRestElement(parser, context, scope, privateScope, closingT
     else if (token & 2097152) {
         argument =
             parser.getToken() === 2162700
-                ? parseObjectLiteralOrPattern(parser, context, scope, privateScope, 1, inGroup, isPattern, kind, origin, tokenIndex, tokenLine, tokenColumn)
-                : parseArrayExpressionOrPattern(parser, context, scope, privateScope, 1, inGroup, isPattern, kind, origin, tokenIndex, tokenLine, tokenColumn);
+                ? parseObjectLiteralOrPattern(parser, context, scope, privateScope, 1, inGroup, isPattern, kind, origin)
+                : parseArrayExpressionOrPattern(parser, context, scope, privateScope, 1, inGroup, isPattern, kind, origin);
         token = parser.getToken();
         if (token !== 1077936155 && token !== closingToken && token !== 18) {
             if (parser.destructible & 8)
                 report(parser, 71);
-            argument = parseMemberOrUpdateExpression(parser, context, privateScope, argument, inGroup, 0, tokenIndex, tokenLine, tokenColumn);
+            argument = parseMemberOrUpdateExpression(parser, context, privateScope, argument, inGroup, 0, tokenStart);
             destructible |= parser.assignable & 2 ? 16 : 0;
             if ((parser.getToken() & 4194304) === 4194304) {
                 if (parser.getToken() !== 1077936155)
                     destructible |= 16;
-                argument = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenIndex, tokenLine, tokenColumn, argument);
+                argument = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenStart, argument);
             }
             else {
                 if ((parser.getToken() & 8388608) === 8388608) {
-                    argument = parseBinaryExpression(parser, context, privateScope, 1, tokenIndex, tokenLine, tokenColumn, 4, token, argument);
+                    argument = parseBinaryExpression(parser, context, privateScope, 1, tokenStart, 4, token, argument);
                 }
                 if (consumeOpt(parser, context | 8192, 22)) {
-                    argument = parseConditionalExpression(parser, context, privateScope, argument, tokenIndex, tokenLine, tokenColumn);
+                    argument = parseConditionalExpression(parser, context, privateScope, argument, tokenStart);
                 }
                 destructible |=
                     parser.assignable & 2
@@ -7241,13 +7265,13 @@ function parseSpreadOrRestElement(parser, context, scope, privateScope, closingT
     }
     else {
         destructible |= 32;
-        argument = parseLeftHandSideExpression(parser, context, privateScope, 1, inGroup, 1, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
-        const { tokenIndex, tokenLine, tokenColumn } = parser;
+        argument = parseLeftHandSideExpression(parser, context, privateScope, 1, inGroup, 1);
+        const { tokenStart } = parser;
         const token = parser.getToken();
         if (token === 1077936155) {
             if (parser.assignable & 2)
                 report(parser, 26);
-            argument = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenIndex, tokenLine, tokenColumn, argument);
+            argument = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenStart, argument);
             destructible |= 16;
         }
         else {
@@ -7255,7 +7279,7 @@ function parseSpreadOrRestElement(parser, context, scope, privateScope, closingT
                 destructible |= 16;
             }
             else if (token !== closingToken) {
-                argument = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenIndex, tokenLine, tokenColumn, argument);
+                argument = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenStart, argument);
             }
             destructible |=
                 parser.assignable & 1 ? 32 : 16;
@@ -7263,10 +7287,10 @@ function parseSpreadOrRestElement(parser, context, scope, privateScope, closingT
         parser.destructible = destructible;
         if (parser.getToken() !== closingToken && parser.getToken() !== 18)
             report(parser, 161);
-        return finishNode(parser, context, start, line, column, {
+        return parser.finishNode({
             type: isPattern ? 'RestElement' : 'SpreadElement',
             argument: argument,
-        });
+        }, start);
     }
     if (parser.getToken() !== closingToken) {
         if (kind & 1)
@@ -7275,8 +7299,8 @@ function parseSpreadOrRestElement(parser, context, scope, privateScope, closingT
             if (destructible & 16)
                 report(parser, 26);
             reinterpretToPattern(parser, argument);
-            const right = parseExpression(parser, context, privateScope, 1, inGroup, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
-            argument = finishNode(parser, context, tokenIndex, tokenLine, tokenColumn, isPattern
+            const right = parseExpression(parser, context, privateScope, 1, inGroup, parser.tokenStart);
+            argument = parser.finishNode(isPattern
                 ? {
                     type: 'AssignmentPattern',
                     left: argument,
@@ -7287,7 +7311,7 @@ function parseSpreadOrRestElement(parser, context, scope, privateScope, closingT
                     left: argument,
                     operator: '=',
                     right,
-                });
+                }, tokenStart);
             destructible = 16;
         }
         else {
@@ -7295,12 +7319,12 @@ function parseSpreadOrRestElement(parser, context, scope, privateScope, closingT
         }
     }
     parser.destructible = destructible;
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: isPattern ? 'RestElement' : 'SpreadElement',
         argument: argument,
-    });
+    }, start);
 }
-function parseMethodDefinition(parser, context, privateScope, kind, inGroup, start, line, column) {
+function parseMethodDefinition(parser, context, privateScope, kind, inGroup, start) {
     const modifierFlags = 262144 |
         524288 |
         2097152 |
@@ -7320,17 +7344,17 @@ function parseMethodDefinition(parser, context, privateScope, kind, inGroup, sta
     const body = parseFunctionBody(parser, (context & -301992961) |
         8388608 |
         1048576, scope, privateScope, 0, void 0, scope?.parent?.scopeError);
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'FunctionExpression',
         params,
         body,
         async: (kind & 16) > 0,
         generator: (kind & 8) > 0,
         id: null,
-    });
+    }, start);
 }
-function parseObjectLiteral(parser, context, privateScope, skipInitializer, inGroup, start, line, column) {
-    const expr = parseObjectLiteralOrPattern(parser, context, void 0, privateScope, skipInitializer, inGroup, 0, 2, 0, start, line, column);
+function parseObjectLiteral(parser, context, privateScope, skipInitializer, inGroup) {
+    const expr = parseObjectLiteralOrPattern(parser, context, void 0, privateScope, skipInitializer, inGroup, 0, 2, 0);
     if (parser.destructible & 64) {
         report(parser, 63);
     }
@@ -7339,17 +7363,18 @@ function parseObjectLiteral(parser, context, privateScope, skipInitializer, inGr
     }
     return expr;
 }
-function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipInitializer, inGroup, isPattern, kind, origin, start, line, column) {
+function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipInitializer, inGroup, isPattern, kind, origin) {
+    const { tokenStart: start } = parser;
     nextToken(parser, context);
     const properties = [];
     let destructible = 0;
     let prototypeCount = 0;
     context = (context | 33554432) ^ 33554432;
     while (parser.getToken() !== 1074790415) {
-        const { tokenValue, tokenLine, tokenColumn, tokenIndex } = parser;
+        const { tokenValue, tokenStart } = parser;
         const token = parser.getToken();
         if (token === 14) {
-            properties.push(parseSpreadOrRestElement(parser, context, scope, privateScope, 1074790415, kind, origin, 0, inGroup, isPattern, tokenIndex, tokenLine, tokenColumn));
+            properties.push(parseSpreadOrRestElement(parser, context, scope, privateScope, 1074790415, kind, origin, 0, inGroup, isPattern));
         }
         else {
             let state = 0;
@@ -7375,18 +7400,18 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                         addVarOrBlock(parser, context, scope, tokenValue, kind, origin);
                     if (consumeOpt(parser, context | 8192, 1077936155)) {
                         destructible |= 8;
-                        const right = parseExpression(parser, context, privateScope, 1, inGroup, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+                        const right = parseExpression(parser, context, privateScope, 1, inGroup, parser.tokenStart);
                         destructible |=
                             parser.destructible & 256
                                 ? 256
                                 : 0 | (parser.destructible & 128)
                                     ? 128
                                     : 0;
-                        value = finishNode(parser, context, tokenIndex, tokenLine, tokenColumn, {
+                        value = parser.finishNode({
                             type: 'AssignmentPattern',
                             left: context & 134217728 ? Object.assign({}, key) : key,
                             right,
-                        });
+                        }, tokenStart);
                     }
                     else {
                         destructible |=
@@ -7396,15 +7421,15 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                     }
                 }
                 else if (consumeOpt(parser, context | 8192, 21)) {
-                    const { tokenIndex, tokenLine, tokenColumn } = parser;
+                    const { tokenStart } = parser;
                     if (tokenValue === '__proto__')
                         prototypeCount++;
                     if (parser.getToken() & 143360) {
                         const tokenAfterColon = parser.getToken();
                         const valueAfterColon = parser.tokenValue;
-                        value = parsePrimaryExpression(parser, context, privateScope, kind, 0, 1, inGroup, 1, tokenIndex, tokenLine, tokenColumn);
+                        value = parsePrimaryExpression(parser, context, privateScope, kind, 0, 1, inGroup, 1, tokenStart);
                         const token = parser.getToken();
-                        value = parseMemberOrUpdateExpression(parser, context, privateScope, value, inGroup, 0, tokenIndex, tokenLine, tokenColumn);
+                        value = parseMemberOrUpdateExpression(parser, context, privateScope, value, inGroup, 0, tokenStart);
                         if (parser.getToken() === 18 || parser.getToken() === 1074790415) {
                             if (token === 1077936155 || token === 1074790415 || token === 18) {
                                 destructible |= parser.destructible & 128 ? 128 : 0;
@@ -7432,23 +7457,23 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                             else if (scope) {
                                 addVarOrBlock(parser, context, scope, valueAfterColon, kind, origin);
                             }
-                            value = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenIndex, tokenLine, tokenColumn, value);
+                            value = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenStart, value);
                         }
                         else {
                             destructible |= 16;
                             if ((parser.getToken() & 8388608) === 8388608) {
-                                value = parseBinaryExpression(parser, context, privateScope, 1, tokenIndex, tokenLine, tokenColumn, 4, token, value);
+                                value = parseBinaryExpression(parser, context, privateScope, 1, tokenStart, 4, token, value);
                             }
                             if (consumeOpt(parser, context | 8192, 22)) {
-                                value = parseConditionalExpression(parser, context, privateScope, value, tokenIndex, tokenLine, tokenColumn);
+                                value = parseConditionalExpression(parser, context, privateScope, value, tokenStart);
                             }
                         }
                     }
                     else if ((parser.getToken() & 2097152) === 2097152) {
                         value =
                             parser.getToken() === 69271571
-                                ? parseArrayExpressionOrPattern(parser, context, scope, privateScope, 0, inGroup, isPattern, kind, origin, tokenIndex, tokenLine, tokenColumn)
-                                : parseObjectLiteralOrPattern(parser, context, scope, privateScope, 0, inGroup, isPattern, kind, origin, tokenIndex, tokenLine, tokenColumn);
+                                ? parseArrayExpressionOrPattern(parser, context, scope, privateScope, 0, inGroup, isPattern, kind, origin)
+                                : parseObjectLiteralOrPattern(parser, context, scope, privateScope, 0, inGroup, isPattern, kind, origin);
                         destructible = parser.destructible;
                         parser.assignable =
                             destructible & 16 ? 2 : 1;
@@ -7460,17 +7485,17 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                             report(parser, 71);
                         }
                         else {
-                            value = parseMemberOrUpdateExpression(parser, context, privateScope, value, inGroup, 0, tokenIndex, tokenLine, tokenColumn);
+                            value = parseMemberOrUpdateExpression(parser, context, privateScope, value, inGroup, 0, tokenStart);
                             destructible = parser.assignable & 2 ? 16 : 0;
                             if ((parser.getToken() & 4194304) === 4194304) {
-                                value = parseAssignmentExpressionOrPattern(parser, context, privateScope, inGroup, isPattern, tokenIndex, tokenLine, tokenColumn, value);
+                                value = parseAssignmentExpressionOrPattern(parser, context, privateScope, inGroup, isPattern, tokenStart, value);
                             }
                             else {
                                 if ((parser.getToken() & 8388608) === 8388608) {
-                                    value = parseBinaryExpression(parser, context, privateScope, 1, tokenIndex, tokenLine, tokenColumn, 4, token, value);
+                                    value = parseBinaryExpression(parser, context, privateScope, 1, tokenStart, 4, token, value);
                                 }
                                 if (consumeOpt(parser, context | 8192, 22)) {
-                                    value = parseConditionalExpression(parser, context, privateScope, value, tokenIndex, tokenLine, tokenColumn);
+                                    value = parseConditionalExpression(parser, context, privateScope, value, tokenStart);
                                 }
                                 destructible |=
                                     parser.assignable & 2
@@ -7480,7 +7505,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                         }
                     }
                     else {
-                        value = parseLeftHandSideExpression(parser, context, privateScope, 1, inGroup, 1, tokenIndex, tokenLine, tokenColumn);
+                        value = parseLeftHandSideExpression(parser, context, privateScope, 1, inGroup, 1);
                         destructible |=
                             parser.assignable & 1
                                 ? 32
@@ -7490,12 +7515,12 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                                 destructible |= 16;
                         }
                         else {
-                            value = parseMemberOrUpdateExpression(parser, context, privateScope, value, inGroup, 0, tokenIndex, tokenLine, tokenColumn);
+                            value = parseMemberOrUpdateExpression(parser, context, privateScope, value, inGroup, 0, tokenStart);
                             destructible = parser.assignable & 2 ? 16 : 0;
                             if (parser.getToken() !== 18 && token !== 1074790415) {
                                 if (parser.getToken() !== 1077936155)
                                     destructible |= 16;
-                                value = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenIndex, tokenLine, tokenColumn, value);
+                                value = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenStart, value);
                             }
                         }
                     }
@@ -7512,7 +7537,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                                 : 1) | 2;
                     key = parseComputedPropertyName(parser, context, privateScope, inGroup);
                     destructible |= parser.assignable;
-                    value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+                    value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenStart);
                 }
                 else if (parser.getToken() & 143360) {
                     destructible |= 16;
@@ -7533,12 +7558,12 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                         report(parser, 0);
                     }
                     key = parseIdentifier(parser, context);
-                    value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+                    value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenStart);
                 }
                 else if (parser.getToken() === 67174411) {
                     destructible |= 16;
                     state |= 1;
-                    value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+                    value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenStart);
                 }
                 else if (parser.getToken() === 8391476) {
                     destructible |= 16;
@@ -7568,7 +7593,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                     else {
                         report(parser, 30, KeywordDescTable[parser.getToken() & 255]);
                     }
-                    value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+                    value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenStart);
                 }
                 else if ((parser.getToken() & 134217728) === 134217728) {
                     if (token === 209005)
@@ -7581,7 +7606,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                                 : 1;
                     destructible |= 16;
                     key = parseLiteral(parser, context);
-                    value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+                    value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenStart);
                 }
                 else {
                     report(parser, 133);
@@ -7591,14 +7616,14 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                 key = parseLiteral(parser, context);
                 if (parser.getToken() === 21) {
                     consume(parser, context | 8192, 21);
-                    const { tokenIndex, tokenLine, tokenColumn } = parser;
+                    const { tokenStart } = parser;
                     if (tokenValue === '__proto__')
                         prototypeCount++;
                     if (parser.getToken() & 143360) {
-                        value = parsePrimaryExpression(parser, context, privateScope, kind, 0, 1, inGroup, 1, tokenIndex, tokenLine, tokenColumn);
+                        value = parsePrimaryExpression(parser, context, privateScope, kind, 0, 1, inGroup, 1, tokenStart);
                         const { tokenValue: valueAfterColon } = parser;
                         const token = parser.getToken();
-                        value = parseMemberOrUpdateExpression(parser, context, privateScope, value, inGroup, 0, tokenIndex, tokenLine, tokenColumn);
+                        value = parseMemberOrUpdateExpression(parser, context, privateScope, value, inGroup, 0, tokenStart);
                         if (parser.getToken() === 18 || parser.getToken() === 1074790415) {
                             if (token === 1077936155 || token === 1074790415 || token === 18) {
                                 if (parser.assignable & 2) {
@@ -7618,18 +7643,18 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                         else if (parser.getToken() === 1077936155) {
                             if (parser.assignable & 2)
                                 destructible |= 16;
-                            value = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenIndex, tokenLine, tokenColumn, value);
+                            value = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenStart, value);
                         }
                         else {
                             destructible |= 16;
-                            value = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenIndex, tokenLine, tokenColumn, value);
+                            value = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenStart, value);
                         }
                     }
                     else if ((parser.getToken() & 2097152) === 2097152) {
                         value =
                             parser.getToken() === 69271571
-                                ? parseArrayExpressionOrPattern(parser, context, scope, privateScope, 0, inGroup, isPattern, kind, origin, tokenIndex, tokenLine, tokenColumn)
-                                : parseObjectLiteralOrPattern(parser, context, scope, privateScope, 0, inGroup, isPattern, kind, origin, tokenIndex, tokenLine, tokenColumn);
+                                ? parseArrayExpressionOrPattern(parser, context, scope, privateScope, 0, inGroup, isPattern, kind, origin)
+                                : parseObjectLiteralOrPattern(parser, context, scope, privateScope, 0, inGroup, isPattern, kind, origin);
                         destructible = parser.destructible;
                         parser.assignable =
                             destructible & 16 ? 2 : 1;
@@ -7639,17 +7664,17 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                             }
                         }
                         else if ((parser.destructible & 8) !== 8) {
-                            value = parseMemberOrUpdateExpression(parser, context, privateScope, value, inGroup, 0, tokenIndex, tokenLine, tokenColumn);
+                            value = parseMemberOrUpdateExpression(parser, context, privateScope, value, inGroup, 0, tokenStart);
                             destructible = parser.assignable & 2 ? 16 : 0;
                             if ((parser.getToken() & 4194304) === 4194304) {
-                                value = parseAssignmentExpressionOrPattern(parser, context, privateScope, inGroup, isPattern, tokenIndex, tokenLine, tokenColumn, value);
+                                value = parseAssignmentExpressionOrPattern(parser, context, privateScope, inGroup, isPattern, tokenStart, value);
                             }
                             else {
                                 if ((parser.getToken() & 8388608) === 8388608) {
-                                    value = parseBinaryExpression(parser, context, privateScope, 1, tokenIndex, tokenLine, tokenColumn, 4, token, value);
+                                    value = parseBinaryExpression(parser, context, privateScope, 1, tokenStart, 4, token, value);
                                 }
                                 if (consumeOpt(parser, context | 8192, 22)) {
-                                    value = parseConditionalExpression(parser, context, privateScope, value, tokenIndex, tokenLine, tokenColumn);
+                                    value = parseConditionalExpression(parser, context, privateScope, value, tokenStart);
                                 }
                                 destructible |=
                                     parser.assignable & 2
@@ -7659,7 +7684,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                         }
                     }
                     else {
-                        value = parseLeftHandSideExpression(parser, context, privateScope, 1, 0, 1, tokenIndex, tokenLine, tokenColumn);
+                        value = parseLeftHandSideExpression(parser, context, privateScope, 1, 0, 1);
                         destructible |=
                             parser.assignable & 1
                                 ? 32
@@ -7670,19 +7695,19 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                             }
                         }
                         else {
-                            value = parseMemberOrUpdateExpression(parser, context, privateScope, value, inGroup, 0, tokenIndex, tokenLine, tokenColumn);
+                            value = parseMemberOrUpdateExpression(parser, context, privateScope, value, inGroup, 0, tokenStart);
                             destructible = parser.assignable & 1 ? 0 : 16;
                             if (parser.getToken() !== 18 && parser.getToken() !== 1074790415) {
                                 if (parser.getToken() !== 1077936155)
                                     destructible |= 16;
-                                value = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenIndex, tokenLine, tokenColumn, value);
+                                value = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenStart, value);
                             }
                         }
                     }
                 }
                 else if (parser.getToken() === 67174411) {
                     state |= 1;
-                    value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+                    value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenStart);
                     destructible = parser.assignable | 16;
                 }
                 else {
@@ -7695,12 +7720,12 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                 state |= 2;
                 if (parser.getToken() === 21) {
                     nextToken(parser, context | 8192);
-                    const { tokenIndex, tokenLine, tokenColumn, tokenValue } = parser;
+                    const { tokenStart, tokenValue } = parser;
                     const tokenAfterColon = parser.getToken();
                     if (parser.getToken() & 143360) {
-                        value = parsePrimaryExpression(parser, context, privateScope, kind, 0, 1, inGroup, 1, tokenIndex, tokenLine, tokenColumn);
+                        value = parsePrimaryExpression(parser, context, privateScope, kind, 0, 1, inGroup, 1, tokenStart);
                         const token = parser.getToken();
-                        value = parseMemberOrUpdateExpression(parser, context, privateScope, value, inGroup, 0, tokenIndex, tokenLine, tokenColumn);
+                        value = parseMemberOrUpdateExpression(parser, context, privateScope, value, inGroup, 0, tokenStart);
                         if ((parser.getToken() & 4194304) === 4194304) {
                             destructible |=
                                 parser.assignable & 2
@@ -7708,7 +7733,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                                     : token === 1077936155
                                         ? 0
                                         : 32;
-                            value = parseAssignmentExpressionOrPattern(parser, context, privateScope, inGroup, isPattern, tokenIndex, tokenLine, tokenColumn, value);
+                            value = parseAssignmentExpressionOrPattern(parser, context, privateScope, inGroup, isPattern, tokenStart, value);
                         }
                         else if (parser.getToken() === 18 || parser.getToken() === 1074790415) {
                             if (token === 1077936155 || token === 1074790415 || token === 18) {
@@ -7728,14 +7753,14 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                         }
                         else {
                             destructible |= 16;
-                            value = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenIndex, tokenLine, tokenColumn, value);
+                            value = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenStart, value);
                         }
                     }
                     else if ((parser.getToken() & 2097152) === 2097152) {
                         value =
                             parser.getToken() === 69271571
-                                ? parseArrayExpressionOrPattern(parser, context, scope, privateScope, 0, inGroup, isPattern, kind, origin, tokenIndex, tokenLine, tokenColumn)
-                                : parseObjectLiteralOrPattern(parser, context, scope, privateScope, 0, inGroup, isPattern, kind, origin, tokenIndex, tokenLine, tokenColumn);
+                                ? parseArrayExpressionOrPattern(parser, context, scope, privateScope, 0, inGroup, isPattern, kind, origin)
+                                : parseObjectLiteralOrPattern(parser, context, scope, privateScope, 0, inGroup, isPattern, kind, origin);
                         destructible = parser.destructible;
                         parser.assignable =
                             destructible & 16 ? 2 : 1;
@@ -7747,20 +7772,20 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                             report(parser, 62);
                         }
                         else {
-                            value = parseMemberOrUpdateExpression(parser, context, privateScope, value, inGroup, 0, tokenIndex, tokenLine, tokenColumn);
+                            value = parseMemberOrUpdateExpression(parser, context, privateScope, value, inGroup, 0, tokenStart);
                             destructible =
                                 parser.assignable & 2 ? destructible | 16 : 0;
                             if ((parser.getToken() & 4194304) === 4194304) {
                                 if (parser.getToken() !== 1077936155)
                                     destructible |= 16;
-                                value = parseAssignmentExpressionOrPattern(parser, context, privateScope, inGroup, isPattern, tokenIndex, tokenLine, tokenColumn, value);
+                                value = parseAssignmentExpressionOrPattern(parser, context, privateScope, inGroup, isPattern, tokenStart, value);
                             }
                             else {
                                 if ((parser.getToken() & 8388608) === 8388608) {
-                                    value = parseBinaryExpression(parser, context, privateScope, 1, tokenIndex, tokenLine, tokenColumn, 4, token, value);
+                                    value = parseBinaryExpression(parser, context, privateScope, 1, tokenStart, 4, token, value);
                                 }
                                 if (consumeOpt(parser, context | 8192, 22)) {
-                                    value = parseConditionalExpression(parser, context, privateScope, value, tokenIndex, tokenLine, tokenColumn);
+                                    value = parseConditionalExpression(parser, context, privateScope, value, tokenStart);
                                 }
                                 destructible |=
                                     parser.assignable & 2
@@ -7770,7 +7795,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                         }
                     }
                     else {
-                        value = parseLeftHandSideExpression(parser, context, privateScope, 1, 0, 1, tokenIndex, tokenLine, tokenColumn);
+                        value = parseLeftHandSideExpression(parser, context, privateScope, 1, 0, 1);
                         destructible |=
                             parser.assignable & 1
                                 ? 32
@@ -7780,19 +7805,19 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                                 destructible |= 16;
                         }
                         else {
-                            value = parseMemberOrUpdateExpression(parser, context, privateScope, value, inGroup, 0, tokenIndex, tokenLine, tokenColumn);
+                            value = parseMemberOrUpdateExpression(parser, context, privateScope, value, inGroup, 0, tokenStart);
                             destructible = parser.assignable & 1 ? 0 : 16;
                             if (parser.getToken() !== 18 && parser.getToken() !== 1074790415) {
                                 if (parser.getToken() !== 1077936155)
                                     destructible |= 16;
-                                value = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenIndex, tokenLine, tokenColumn, value);
+                                value = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenStart, value);
                             }
                         }
                     }
                 }
                 else if (parser.getToken() === 67174411) {
                     state |= 1;
-                    value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenIndex, tokenLine, tokenColumn);
+                    value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenStart);
                     destructible = 16;
                 }
                 else {
@@ -7808,10 +7833,10 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                     state |= 1;
                     if (parser.getToken() === 67174411) {
                         destructible |= 16;
-                        value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+                        value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenStart);
                     }
                     else {
-                        reportMessageAt(parser.tokenIndex, parser.tokenLine, parser.tokenColumn, parser.index, parser.line, parser.column, token === 209005
+                        reportMessageAt(parser.tokenStart, parser.currentLocation, token === 209005
                             ? 46
                             : token === 209008 || parser.getToken() === 209009
                                 ? 45
@@ -7822,13 +7847,13 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                     destructible |= 16;
                     key = parseLiteral(parser, context);
                     state |= 1;
-                    value = parseMethodDefinition(parser, context, privateScope, state, inGroup, tokenIndex, tokenLine, tokenColumn);
+                    value = parseMethodDefinition(parser, context, privateScope, state, inGroup, tokenStart);
                 }
                 else if (parser.getToken() === 69271571) {
                     destructible |= 16;
                     state |= 2 | 1;
                     key = parseComputedPropertyName(parser, context, privateScope, inGroup);
-                    value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+                    value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenStart);
                 }
                 else {
                     report(parser, 126);
@@ -7839,7 +7864,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
             }
             destructible |= parser.destructible & 128 ? 128 : 0;
             parser.destructible = destructible;
-            properties.push(finishNode(parser, context, tokenIndex, tokenLine, tokenColumn, {
+            properties.push(parser.finishNode({
                 type: 'Property',
                 key: key,
                 value,
@@ -7847,7 +7872,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                 computed: (state & 2) > 0,
                 method: (state & 1) > 0,
                 shorthand: (state & 4) > 0,
-            }));
+            }, tokenStart));
         }
         destructible |= parser.destructible;
         if (parser.getToken() !== 18)
@@ -7857,12 +7882,12 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
     consume(parser, context, 1074790415);
     if (prototypeCount > 1)
         destructible |= 64;
-    const node = finishNode(parser, context, start, line, column, {
+    const node = parser.finishNode({
         type: isPattern ? 'ObjectPattern' : 'ObjectExpression',
         properties,
-    });
+    }, start);
     if (!skipInitializer && parser.getToken() & 4194304) {
-        return parseArrayOrObjectAssignmentPattern(parser, context, privateScope, destructible, inGroup, isPattern, start, line, column, node);
+        return parseArrayOrObjectAssignmentPattern(parser, context, privateScope, destructible, inGroup, isPattern, start, node);
     }
     parser.destructible = destructible;
     return node;
@@ -7889,7 +7914,7 @@ function parseMethodFormals(parser, context, scope, privateScope, kind, type, in
     let isNonSimpleParameterList = 0;
     while (parser.getToken() !== 18) {
         let left = null;
-        const { tokenIndex, tokenLine, tokenColumn } = parser;
+        const { tokenStart } = parser;
         if (parser.getToken() & 143360) {
             if ((context & 256) === 0) {
                 if ((parser.getToken() & 36864) === 36864) {
@@ -7899,17 +7924,17 @@ function parseMethodFormals(parser, context, scope, privateScope, kind, type, in
                     parser.flags |= 512;
                 }
             }
-            left = parseAndClassifyIdentifier(parser, context, scope, kind | 1, 0, tokenIndex, tokenLine, tokenColumn);
+            left = parseAndClassifyIdentifier(parser, context, scope, kind | 1, 0);
         }
         else {
             if (parser.getToken() === 2162700) {
-                left = parseObjectLiteralOrPattern(parser, context, scope, privateScope, 1, inGroup, 1, type, 0, tokenIndex, tokenLine, tokenColumn);
+                left = parseObjectLiteralOrPattern(parser, context, scope, privateScope, 1, inGroup, 1, type, 0);
             }
             else if (parser.getToken() === 69271571) {
-                left = parseArrayExpressionOrPattern(parser, context, scope, privateScope, 1, inGroup, 1, type, 0, tokenIndex, tokenLine, tokenColumn);
+                left = parseArrayExpressionOrPattern(parser, context, scope, privateScope, 1, inGroup, 1, type, 0);
             }
             else if (parser.getToken() === 14) {
-                left = parseSpreadOrRestElement(parser, context, scope, privateScope, 16, type, 0, 0, inGroup, 1, tokenIndex, tokenLine, tokenColumn);
+                left = parseSpreadOrRestElement(parser, context, scope, privateScope, 16, type, 0, 0, inGroup, 1);
             }
             isNonSimpleParameterList = 1;
             if (parser.destructible & (32 | 16))
@@ -7918,12 +7943,12 @@ function parseMethodFormals(parser, context, scope, privateScope, kind, type, in
         if (parser.getToken() === 1077936155) {
             nextToken(parser, context | 8192);
             isNonSimpleParameterList = 1;
-            const right = parseExpression(parser, context, privateScope, 1, 0, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
-            left = finishNode(parser, context, tokenIndex, tokenLine, tokenColumn, {
+            const right = parseExpression(parser, context, privateScope, 1, 0, parser.tokenStart);
+            left = parser.finishNode({
                 type: 'AssignmentPattern',
                 left: left,
                 right,
-            });
+            }, tokenStart);
         }
         setterArgs++;
         params.push(left);
@@ -7945,18 +7970,18 @@ function parseMethodFormals(parser, context, scope, privateScope, kind, type, in
 }
 function parseComputedPropertyName(parser, context, privateScope, inGroup) {
     nextToken(parser, context | 8192);
-    const key = parseExpression(parser, (context | 33554432) ^ 33554432, privateScope, 1, inGroup, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+    const key = parseExpression(parser, (context | 33554432) ^ 33554432, privateScope, 1, inGroup, parser.tokenStart);
     consume(parser, context, 20);
     return key;
 }
-function parseParenthesizedExpression(parser, context, privateScope, canAssign, kind, origin, start, line, column) {
+function parseParenthesizedExpression(parser, context, privateScope, canAssign, kind, origin, start) {
     parser.flags = (parser.flags | 128) ^ 128;
-    const { tokenIndex: piStart, tokenLine: plStart, tokenColumn: pcStart } = parser;
+    const parenthesesStart = parser.tokenStart;
     nextToken(parser, context | 8192 | 67108864);
     const scope = context & 16 ? addChildScope(createScope(), 1024) : void 0;
     context = (context | 33554432) ^ 33554432;
     if (consumeOpt(parser, context, 16)) {
-        return parseParenthesizedArrow(parser, context, scope, privateScope, [], canAssign, 0, start, line, column);
+        return parseParenthesizedArrow(parser, context, scope, privateScope, [], canAssign, 0, start);
     }
     let destructible = 0;
     parser.destructible &= -385;
@@ -7965,10 +7990,10 @@ function parseParenthesizedExpression(parser, context, privateScope, canAssign,
     let isSequence = 0;
     let isNonSimpleParameterList = 0;
     let hasStrictReserved = 0;
-    const { tokenIndex: iStart, tokenLine: lStart, tokenColumn: cStart } = parser;
+    const tokenAfterParenthesesStart = parser.tokenStart;
     parser.assignable = 1;
     while (parser.getToken() !== 16) {
-        const { tokenIndex, tokenLine, tokenColumn } = parser;
+        const { tokenStart } = parser;
         const token = parser.getToken();
         if (token & 143360) {
             if (scope)
@@ -7979,7 +8004,7 @@ function parseParenthesizedExpression(parser, context, privateScope, canAssign,
             else if ((token & 36864) === 36864) {
                 hasStrictReserved = 1;
             }
-            expr = parsePrimaryExpression(parser, context, privateScope, kind, 0, 1, 1, 1, tokenIndex, tokenLine, tokenColumn);
+            expr = parsePrimaryExpression(parser, context, privateScope, kind, 0, 1, 1, 1, tokenStart);
             if (parser.getToken() === 16 || parser.getToken() === 18) {
                 if (parser.assignable & 2) {
                     destructible |= 16;
@@ -7993,32 +8018,32 @@ function parseParenthesizedExpression(parser, context, privateScope, canAssign,
                 else {
                     destructible |= 16;
                 }
-                expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 1, 0, tokenIndex, tokenLine, tokenColumn);
+                expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 1, 0, tokenStart);
                 if (parser.getToken() !== 16 && parser.getToken() !== 18) {
-                    expr = parseAssignmentExpression(parser, context, privateScope, 1, 0, tokenIndex, tokenLine, tokenColumn, expr);
+                    expr = parseAssignmentExpression(parser, context, privateScope, 1, 0, tokenStart, expr);
                 }
             }
         }
         else if ((token & 2097152) === 2097152) {
             expr =
                 token === 2162700
-                    ? parseObjectLiteralOrPattern(parser, context | 67108864, scope, privateScope, 0, 1, 0, kind, origin, tokenIndex, tokenLine, tokenColumn)
-                    : parseArrayExpressionOrPattern(parser, context | 67108864, scope, privateScope, 0, 1, 0, kind, origin, tokenIndex, tokenLine, tokenColumn);
+                    ? parseObjectLiteralOrPattern(parser, context | 67108864, scope, privateScope, 0, 1, 0, kind, origin)
+                    : parseArrayExpressionOrPattern(parser, context | 67108864, scope, privateScope, 0, 1, 0, kind, origin);
             destructible |= parser.destructible;
             isNonSimpleParameterList = 1;
             parser.assignable = 2;
             if (parser.getToken() !== 16 && parser.getToken() !== 18) {
                 if (destructible & 8)
                     report(parser, 122);
-                expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 0, 0, tokenIndex, tokenLine, tokenColumn);
+                expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 0, 0, tokenStart);
                 destructible |= 16;
                 if (parser.getToken() !== 16 && parser.getToken() !== 18) {
-                    expr = parseAssignmentExpression(parser, context, privateScope, 0, 0, tokenIndex, tokenLine, tokenColumn, expr);
+                    expr = parseAssignmentExpression(parser, context, privateScope, 0, 0, tokenStart, expr);
                 }
             }
         }
         else if (token === 14) {
-            expr = parseSpreadOrRestElement(parser, context, scope, privateScope, 16, kind, origin, 0, 1, 0, tokenIndex, tokenLine, tokenColumn);
+            expr = parseSpreadOrRestElement(parser, context, scope, privateScope, 16, kind, origin, 0, 1, 0);
             if (parser.destructible & 16)
                 report(parser, 74);
             isNonSimpleParameterList = 1;
@@ -8030,7 +8055,7 @@ function parseParenthesizedExpression(parser, context, privateScope, canAssign,
         }
         else {
             destructible |= 16;
-            expr = parseExpression(parser, context, privateScope, 1, 1, tokenIndex, tokenLine, tokenColumn);
+            expr = parseExpression(parser, context, privateScope, 1, 1, tokenStart);
             if (isSequence && (parser.getToken() === 16 || parser.getToken() === 18)) {
                 expressions.push(expr);
             }
@@ -8042,21 +8067,21 @@ function parseParenthesizedExpression(parser, context, privateScope, canAssign,
             }
             if (isSequence) {
                 while (consumeOpt(parser, context | 8192, 18)) {
-                    expressions.push(parseExpression(parser, context, privateScope, 1, 1, parser.tokenIndex, parser.tokenLine, parser.tokenColumn));
+                    expressions.push(parseExpression(parser, context, privateScope, 1, 1, parser.tokenStart));
                 }
                 parser.assignable = 2;
-                expr = finishNode(parser, context, iStart, lStart, cStart, {
+                expr = parser.finishNode({
                     type: 'SequenceExpression',
                     expressions,
-                });
+                }, tokenAfterParenthesesStart);
             }
             consume(parser, context, 16);
             parser.destructible = destructible;
             return context & 32
-                ? finishNode(parser, context, piStart, plStart, pcStart, {
+                ? parser.finishNode({
                     type: 'ParenthesizedExpression',
                     expression: expr,
-                })
+                }, parenthesesStart)
                 : expr;
         }
         if (isSequence && (parser.getToken() === 16 || parser.getToken() === 18)) {
@@ -8075,10 +8100,10 @@ function parseParenthesizedExpression(parser, context, privateScope, canAssign,
     }
     if (isSequence) {
         parser.assignable = 2;
-        expr = finishNode(parser, context, iStart, lStart, cStart, {
+        expr = parser.finishNode({
             type: 'SequenceExpression',
             expressions,
-        });
+        }, tokenAfterParenthesesStart);
     }
     consume(parser, context, 16);
     if (destructible & 16 && destructible & 8)
@@ -8101,7 +8126,7 @@ function parseParenthesizedExpression(parser, context, privateScope, canAssign,
             parser.flags |= 128;
         if (hasStrictReserved)
             parser.flags |= 256;
-        return parseParenthesizedArrow(parser, context, scope, privateScope, isSequence ? expressions : [expr], canAssign, 0, start, line, column);
+        return parseParenthesizedArrow(parser, context, scope, privateScope, isSequence ? expressions : [expr], canAssign, 0, start);
     }
     if (destructible & 64) {
         report(parser, 63);
@@ -8111,13 +8136,14 @@ function parseParenthesizedExpression(parser, context, privateScope, canAssign,
     }
     parser.destructible = ((parser.destructible | 256) ^ 256) | destructible;
     return context & 32
-        ? finishNode(parser, context, piStart, plStart, pcStart, {
+        ? parser.finishNode({
             type: 'ParenthesizedExpression',
             expression: expr,
-        })
+        }, parenthesesStart)
         : expr;
 }
-function parseIdentifierOrArrow(parser, context, privateScope, start, line, column) {
+function parseIdentifierOrArrow(parser, context, privateScope) {
+    const { tokenStart: start } = parser;
     const { tokenValue } = parser;
     let isNonSimpleParameterList = 0;
     let hasStrictReserved = 0;
@@ -8137,27 +8163,27 @@ function parseIdentifierOrArrow(parser, context, privateScope, start, line, colu
             parser.flags |= 128;
         if (hasStrictReserved)
             parser.flags |= 256;
-        return parseArrowFunctionExpression(parser, context, scope, privateScope, [expr], 0, start, line, column);
+        return parseArrowFunctionExpression(parser, context, scope, privateScope, [expr], 0, start);
     }
     return expr;
 }
-function parseArrowFromIdentifier(parser, context, privateScope, value, expr, inNew, canAssign, isAsync, start, line, column) {
+function parseArrowFromIdentifier(parser, context, privateScope, value, expr, inNew, canAssign, isAsync, start) {
     if (!canAssign)
         report(parser, 57);
     if (inNew)
         report(parser, 51);
     parser.flags &= -129;
     const scope = context & 16 ? createArrowHeadParsingScope(parser, context, value) : void 0;
-    return parseArrowFunctionExpression(parser, context, scope, privateScope, [expr], isAsync, start, line, column);
+    return parseArrowFunctionExpression(parser, context, scope, privateScope, [expr], isAsync, start);
 }
-function parseParenthesizedArrow(parser, context, scope, privateScope, params, canAssign, isAsync, start, line, column) {
+function parseParenthesizedArrow(parser, context, scope, privateScope, params, canAssign, isAsync, start) {
     if (!canAssign)
         report(parser, 57);
     for (let i = 0; i < params.length; ++i)
         reinterpretToPattern(parser, params[i]);
-    return parseArrowFunctionExpression(parser, context, scope, privateScope, params, isAsync, start, line, column);
+    return parseArrowFunctionExpression(parser, context, scope, privateScope, params, isAsync, start);
 }
-function parseArrowFunctionExpression(parser, context, scope, privateScope, params, isAsync, start, line, column) {
+function parseArrowFunctionExpression(parser, context, scope, privateScope, params, isAsync, start) {
     if (parser.flags & 1)
         report(parser, 48);
     consume(parser, context | 8192, 10);
@@ -8171,7 +8197,7 @@ function parseArrowFunctionExpression(parser, context, scope, privateScope, para
         parser.flags =
             (parser.flags | 512 | 256 | 64 | 4096) ^
                 (512 | 256 | 64 | 4096);
-        body = parseExpression(parser, context, privateScope, 1, 0, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+        body = parseExpression(parser, context, privateScope, 1, 0, parser.tokenStart);
     }
     else {
         if (scope)
@@ -8201,14 +8227,14 @@ function parseArrowFunctionExpression(parser, context, scope, privateScope, para
             report(parser, 125);
     }
     parser.assignable = 2;
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'ArrowFunctionExpression',
         params,
         body,
         async: isAsync === 1,
         expression,
         generator: false,
-    });
+    }, start);
 }
 function parseFormalParametersOrFormalList(parser, context, scope, privateScope, inGroup, kind) {
     consume(parser, context, 67174411);
@@ -8220,7 +8246,7 @@ function parseFormalParametersOrFormalList(parser, context, scope, privateScope,
     let isNonSimpleParameterList = 0;
     while (parser.getToken() !== 18) {
         let left;
-        const { tokenIndex, tokenLine, tokenColumn } = parser;
+        const { tokenStart } = parser;
         const token = parser.getToken();
         if (token & 143360) {
             if ((context & 256) === 0) {
@@ -8231,17 +8257,17 @@ function parseFormalParametersOrFormalList(parser, context, scope, privateScope,
                     parser.flags |= 512;
                 }
             }
-            left = parseAndClassifyIdentifier(parser, context, scope, kind | 1, 0, tokenIndex, tokenLine, tokenColumn);
+            left = parseAndClassifyIdentifier(parser, context, scope, kind | 1, 0);
         }
         else {
             if (token === 2162700) {
-                left = parseObjectLiteralOrPattern(parser, context, scope, privateScope, 1, inGroup, 1, kind, 0, tokenIndex, tokenLine, tokenColumn);
+                left = parseObjectLiteralOrPattern(parser, context, scope, privateScope, 1, inGroup, 1, kind, 0);
             }
             else if (token === 69271571) {
-                left = parseArrayExpressionOrPattern(parser, context, scope, privateScope, 1, inGroup, 1, kind, 0, tokenIndex, tokenLine, tokenColumn);
+                left = parseArrayExpressionOrPattern(parser, context, scope, privateScope, 1, inGroup, 1, kind, 0);
             }
             else if (token === 14) {
-                left = parseSpreadOrRestElement(parser, context, scope, privateScope, 16, kind, 0, 0, inGroup, 1, tokenIndex, tokenLine, tokenColumn);
+                left = parseSpreadOrRestElement(parser, context, scope, privateScope, 16, kind, 0, 0, inGroup, 1);
             }
             else {
                 report(parser, 30, KeywordDescTable[token & 255]);
@@ -8254,12 +8280,12 @@ function parseFormalParametersOrFormalList(parser, context, scope, privateScope,
         if (parser.getToken() === 1077936155) {
             nextToken(parser, context | 8192);
             isNonSimpleParameterList = 1;
-            const right = parseExpression(parser, context, privateScope, 1, inGroup, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
-            left = finishNode(parser, context, tokenIndex, tokenLine, tokenColumn, {
+            const right = parseExpression(parser, context, privateScope, 1, inGroup, parser.tokenStart);
+            left = parser.finishNode({
                 type: 'AssignmentPattern',
                 left,
                 right,
-            });
+            }, tokenStart);
         }
         params.push(left);
         if (!consumeOpt(parser, context, 18))
@@ -8276,53 +8302,56 @@ function parseFormalParametersOrFormalList(parser, context, scope, privateScope,
     consume(parser, context, 16);
     return params;
 }
-function parseMemberExpressionNoCall(parser, context, privateScope, expr, inGroup, start, line, column) {
+function parseMemberExpressionNoCall(parser, context, privateScope, expr, inGroup, start) {
     const token = parser.getToken();
     if (token & 67108864) {
         if (token === 67108877) {
             nextToken(parser, context | 67108864);
             parser.assignable = 1;
             const property = parsePropertyOrPrivatePropertyName(parser, context, privateScope);
-            return parseMemberExpressionNoCall(parser, context, privateScope, finishNode(parser, context, start, line, column, {
+            return parseMemberExpressionNoCall(parser, context, privateScope, parser.finishNode({
                 type: 'MemberExpression',
                 object: expr,
                 computed: false,
                 property,
-            }), 0, start, line, column);
+                optional: false,
+            }, start), 0, start);
         }
         else if (token === 69271571) {
             nextToken(parser, context | 8192);
-            const { tokenIndex, tokenLine, tokenColumn } = parser;
-            const property = parseExpressions(parser, context, privateScope, inGroup, 1, tokenIndex, tokenLine, tokenColumn);
+            const { tokenStart } = parser;
+            const property = parseExpressions(parser, context, privateScope, inGroup, 1, tokenStart);
             consume(parser, context, 20);
             parser.assignable = 1;
-            return parseMemberExpressionNoCall(parser, context, privateScope, finishNode(parser, context, start, line, column, {
+            return parseMemberExpressionNoCall(parser, context, privateScope, parser.finishNode({
                 type: 'MemberExpression',
                 object: expr,
                 computed: true,
                 property,
-            }), 0, start, line, column);
+                optional: false,
+            }, start), 0, start);
         }
         else if (token === 67174408 || token === 67174409) {
             parser.assignable = 2;
-            return parseMemberExpressionNoCall(parser, context, privateScope, finishNode(parser, context, start, line, column, {
+            return parseMemberExpressionNoCall(parser, context, privateScope, parser.finishNode({
                 type: 'TaggedTemplateExpression',
                 tag: expr,
                 quasi: parser.getToken() === 67174408
                     ? parseTemplate(parser, context | 16384, privateScope)
-                    : parseTemplateLiteral(parser, context | 16384, parser.tokenIndex, parser.tokenLine, parser.tokenColumn),
-            }), 0, start, line, column);
+                    : parseTemplateLiteral(parser, context | 16384, parser.tokenStart),
+            }, start), 0, start);
         }
     }
     return expr;
 }
-function parseNewExpression(parser, context, privateScope, inGroup, start, line, column) {
+function parseNewExpression(parser, context, privateScope, inGroup) {
+    const { tokenStart: start } = parser;
     const id = parseIdentifier(parser, context | 8192);
-    const { tokenIndex, tokenLine, tokenColumn } = parser;
+    const { tokenStart } = parser;
     if (consumeOpt(parser, context, 67108877)) {
         if (context & 16777216 && parser.getToken() === 209029) {
             parser.assignable = 2;
-            return parseMetaProperty(parser, context, id, start, line, column);
+            return parseMetaProperty(parser, context, id, start);
         }
         report(parser, 94);
     }
@@ -8330,27 +8359,27 @@ function parseNewExpression(parser, context, privateScope, inGroup, start, line,
     if ((parser.getToken() & 16842752) === 16842752) {
         report(parser, 65, KeywordDescTable[parser.getToken() & 255]);
     }
-    const expr = parsePrimaryExpression(parser, context, privateScope, 2, 1, 0, inGroup, 1, tokenIndex, tokenLine, tokenColumn);
+    const expr = parsePrimaryExpression(parser, context, privateScope, 2, 1, 0, inGroup, 1, tokenStart);
     context = (context | 33554432) ^ 33554432;
     if (parser.getToken() === 67108990)
         report(parser, 168);
-    const callee = parseMemberExpressionNoCall(parser, context, privateScope, expr, inGroup, tokenIndex, tokenLine, tokenColumn);
+    const callee = parseMemberExpressionNoCall(parser, context, privateScope, expr, inGroup, tokenStart);
     parser.assignable = 2;
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'NewExpression',
         callee,
         arguments: parser.getToken() === 67174411 ? parseArguments(parser, context, privateScope, inGroup) : [],
-    });
+    }, start);
 }
-function parseMetaProperty(parser, context, meta, start, line, column) {
+function parseMetaProperty(parser, context, meta, start) {
     const property = parseIdentifier(parser, context);
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'MetaProperty',
         meta,
         property,
-    });
+    }, start);
 }
-function parseAsyncArrowAfterIdent(parser, context, privateScope, canAssign, start, line, column) {
+function parseAsyncArrowAfterIdent(parser, context, privateScope, canAssign, start) {
     if (parser.getToken() === 209006)
         report(parser, 31);
     if (context & (256 | 262144) && parser.getToken() === 241771) {
@@ -8360,9 +8389,9 @@ function parseAsyncArrowAfterIdent(parser, context, privateScope, canAssign, sta
     if ((parser.getToken() & 36864) === 36864) {
         parser.flags |= 256;
     }
-    return parseArrowFromIdentifier(parser, (context & -268435457) | 524288, privateScope, parser.tokenValue, parseIdentifier(parser, context), 0, canAssign, 1, start, line, column);
+    return parseArrowFromIdentifier(parser, (context & -268435457) | 524288, privateScope, parser.tokenValue, parseIdentifier(parser, context), 0, canAssign, 1, start);
 }
-function parseAsyncArrowOrCallExpression(parser, context, privateScope, callee, canAssign, kind, origin, flags, start, line, column) {
+function parseAsyncArrowOrCallExpression(parser, context, privateScope, callee, canAssign, kind, origin, flags, start) {
     nextToken(parser, context | 8192);
     const scope = context & 16 ? addChildScope(createScope(), 1024) : void 0;
     context = (context | 33554432) ^ 33554432;
@@ -8370,13 +8399,14 @@ function parseAsyncArrowOrCallExpression(parser, context, privateScope, callee,
         if (parser.getToken() === 10) {
             if (flags & 1)
                 report(parser, 48);
-            return parseParenthesizedArrow(parser, context, scope, privateScope, [], canAssign, 1, start, line, column);
+            return parseParenthesizedArrow(parser, context, scope, privateScope, [], canAssign, 1, start);
         }
-        return finishNode(parser, context, start, line, column, {
+        return parser.finishNode({
             type: 'CallExpression',
             callee,
             arguments: [],
-        });
+            optional: false,
+        }, start);
     }
     let destructible = 0;
     let expr = null;
@@ -8386,7 +8416,7 @@ function parseAsyncArrowOrCallExpression(parser, context, privateScope, callee,
             (256 | 128);
     const params = [];
     while (parser.getToken() !== 16) {
-        const { tokenIndex, tokenLine, tokenColumn } = parser;
+        const { tokenStart } = parser;
         const token = parser.getToken();
         if (token & 143360) {
             if (scope)
@@ -8397,7 +8427,7 @@ function parseAsyncArrowOrCallExpression(parser, context, privateScope, callee,
             else if ((token & 36864) === 36864) {
                 parser.flags |= 256;
             }
-            expr = parsePrimaryExpression(parser, context, privateScope, kind, 0, 1, 1, 1, tokenIndex, tokenLine, tokenColumn);
+            expr = parsePrimaryExpression(parser, context, privateScope, kind, 0, 1, 1, 1, tokenStart);
             if (parser.getToken() === 16 || parser.getToken() === 18) {
                 if (parser.assignable & 2) {
                     destructible |= 16;
@@ -8411,54 +8441,55 @@ function parseAsyncArrowOrCallExpression(parser, context, privateScope, callee,
                 else {
                     destructible |= 16;
                 }
-                expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 1, 0, tokenIndex, tokenLine, tokenColumn);
+                expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 1, 0, tokenStart);
                 if (parser.getToken() !== 16 && parser.getToken() !== 18) {
-                    expr = parseAssignmentExpression(parser, context, privateScope, 1, 0, tokenIndex, tokenLine, tokenColumn, expr);
+                    expr = parseAssignmentExpression(parser, context, privateScope, 1, 0, tokenStart, expr);
                 }
             }
         }
         else if (token & 2097152) {
             expr =
                 token === 2162700
-                    ? parseObjectLiteralOrPattern(parser, context, scope, privateScope, 0, 1, 0, kind, origin, tokenIndex, tokenLine, tokenColumn)
-                    : parseArrayExpressionOrPattern(parser, context, scope, privateScope, 0, 1, 0, kind, origin, tokenIndex, tokenLine, tokenColumn);
+                    ? parseObjectLiteralOrPattern(parser, context, scope, privateScope, 0, 1, 0, kind, origin)
+                    : parseArrayExpressionOrPattern(parser, context, scope, privateScope, 0, 1, 0, kind, origin);
             destructible |= parser.destructible;
             isNonSimpleParameterList = 1;
             if (parser.getToken() !== 16 && parser.getToken() !== 18) {
                 if (destructible & 8)
                     report(parser, 122);
-                expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 0, 0, tokenIndex, tokenLine, tokenColumn);
+                expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 0, 0, tokenStart);
                 destructible |= 16;
                 if ((parser.getToken() & 8388608) === 8388608) {
-                    expr = parseBinaryExpression(parser, context, privateScope, 1, start, line, column, 4, token, expr);
+                    expr = parseBinaryExpression(parser, context, privateScope, 1, start, 4, token, expr);
                 }
                 if (consumeOpt(parser, context | 8192, 22)) {
-                    expr = parseConditionalExpression(parser, context, privateScope, expr, start, line, column);
+                    expr = parseConditionalExpression(parser, context, privateScope, expr, start);
                 }
             }
         }
         else if (token === 14) {
-            expr = parseSpreadOrRestElement(parser, context, scope, privateScope, 16, kind, origin, 1, 1, 0, tokenIndex, tokenLine, tokenColumn);
+            expr = parseSpreadOrRestElement(parser, context, scope, privateScope, 16, kind, origin, 1, 1, 0);
             destructible |=
                 (parser.getToken() === 16 ? 0 : 16) | parser.destructible;
             isNonSimpleParameterList = 1;
         }
         else {
-            expr = parseExpression(parser, context, privateScope, 1, 0, tokenIndex, tokenLine, tokenColumn);
+            expr = parseExpression(parser, context, privateScope, 1, 0, tokenStart);
             destructible = parser.assignable;
             params.push(expr);
             while (consumeOpt(parser, context | 8192, 18)) {
-                params.push(parseExpression(parser, context, privateScope, 1, 0, tokenIndex, tokenLine, tokenColumn));
+                params.push(parseExpression(parser, context, privateScope, 1, 0, tokenStart));
             }
             destructible |= parser.assignable;
             consume(parser, context, 16);
             parser.destructible = destructible | 16;
             parser.assignable = 2;
-            return finishNode(parser, context, start, line, column, {
+            return parser.finishNode({
                 type: 'CallExpression',
                 callee,
                 arguments: params,
-            });
+                optional: false,
+            }, start);
         }
         params.push(expr);
         if (!consumeOpt(parser, context | 8192, 18))
@@ -8482,7 +8513,7 @@ function parseAsyncArrowOrCallExpression(parser, context, privateScope, callee,
             report(parser, 32);
         if (isNonSimpleParameterList)
             parser.flags |= 128;
-        return parseParenthesizedArrow(parser, context | 524288, scope, privateScope, params, canAssign, 1, start, line, column);
+        return parseParenthesizedArrow(parser, context | 524288, scope, privateScope, params, canAssign, 1, start);
     }
     if (destructible & 64) {
         report(parser, 63);
@@ -8491,40 +8522,41 @@ function parseAsyncArrowOrCallExpression(parser, context, privateScope, callee,
         report(parser, 62);
     }
     parser.assignable = 2;
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'CallExpression',
         callee,
         arguments: params,
-    });
+        optional: false,
+    }, start);
 }
-function parseRegExpLiteral(parser, context, start, line, column) {
-    const { tokenRaw, tokenRegExp, tokenValue } = parser;
+function parseRegExpLiteral(parser, context) {
+    const { tokenRaw, tokenRegExp, tokenValue, tokenStart } = parser;
     nextToken(parser, context);
     parser.assignable = 2;
-    return context & 128
-        ? finishNode(parser, context, start, line, column, {
-            type: 'Literal',
-            value: tokenValue,
-            regex: tokenRegExp,
-            raw: tokenRaw,
-        })
-        : finishNode(parser, context, start, line, column, {
-            type: 'Literal',
-            value: tokenValue,
-            regex: tokenRegExp,
-        });
+    const node = {
+        type: 'Literal',
+        value: tokenValue,
+        regex: tokenRegExp,
+    };
+    if (context & 128) {
+        node.raw = tokenRaw;
+    }
+    return parser.finishNode(node, tokenStart);
 }
-function parseClassDeclaration(parser, context, scope, privateScope, flags, start, line, column) {
-    let decorators = parseDecorators(parser, context, privateScope);
-    if (decorators.length) {
-        start = parser.tokenIndex;
-        line = parser.tokenLine;
-        column = parser.tokenColumn;
+function parseClassDeclaration(parser, context, scope, privateScope, flags) {
+    let start;
+    let decorators;
+    if (parser.leadingDecorators.decorators.length) {
+        if (parser.getToken() === 132) {
+            report(parser, 30, '@');
+        }
+        start = parser.leadingDecorators.start;
+        decorators = [...parser.leadingDecorators.decorators];
+        parser.leadingDecorators.decorators.length = 0;
     }
-    if (parser.leadingDecorators.length) {
-        parser.leadingDecorators.push(...decorators);
-        decorators = parser.leadingDecorators;
-        parser.leadingDecorators = [];
+    else {
+        start = parser.tokenStart;
+        decorators = parseDecorators(parser, context, privateScope);
     }
     context = (context | 4194304 | 256) ^ 4194304;
     nextToken(parser, context);
@@ -8554,30 +8586,25 @@ function parseClassDeclaration(parser, context, scope, privateScope, flags, star
     }
     let inheritedContext = context;
     if (consumeOpt(parser, context | 8192, 20565)) {
-        superClass = parseLeftHandSideExpression(parser, context, privateScope, 0, 0, 0, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+        superClass = parseLeftHandSideExpression(parser, context, privateScope, 0, 0, 0);
         inheritedContext |= 131072;
     }
     else {
         inheritedContext = (inheritedContext | 131072) ^ 131072;
     }
     const body = parseClassBody(parser, inheritedContext, context, scope, privateScope, 2, 8, 0);
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'ClassDeclaration',
         id,
         superClass,
         body,
         ...(context & 1 ? { decorators } : null),
-    });
+    }, start);
 }
-function parseClassExpression(parser, context, privateScope, inGroup, start, line, column) {
+function parseClassExpression(parser, context, privateScope, inGroup, start) {
     let id = null;
     let superClass = null;
     const decorators = parseDecorators(parser, context, privateScope);
-    if (decorators.length) {
-        start = parser.tokenIndex;
-        line = parser.tokenLine;
-        column = parser.tokenColumn;
-    }
     context = (context | 256 | 4194304) ^ 4194304;
     nextToken(parser, context);
     if (parser.getToken() & 4096 && parser.getToken() !== 20565) {
@@ -8590,7 +8617,7 @@ function parseClassExpression(parser, context, privateScope, inGroup, start, lin
     }
     let inheritedContext = context;
     if (consumeOpt(parser, context | 8192, 20565)) {
-        superClass = parseLeftHandSideExpression(parser, context, privateScope, 0, inGroup, 0, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+        superClass = parseLeftHandSideExpression(parser, context, privateScope, 0, inGroup, 0);
         inheritedContext |= 131072;
     }
     else {
@@ -8598,34 +8625,34 @@ function parseClassExpression(parser, context, privateScope, inGroup, start, lin
     }
     const body = parseClassBody(parser, inheritedContext, context, void 0, privateScope, 2, 0, inGroup);
     parser.assignable = 2;
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'ClassExpression',
         id,
         superClass,
         body,
         ...(context & 1 ? { decorators } : null),
-    });
+    }, start);
 }
 function parseDecorators(parser, context, privateScope) {
     const list = [];
     if (context & 1) {
         while (parser.getToken() === 132) {
-            list.push(parseDecoratorList(parser, context, privateScope, parser.tokenIndex, parser.tokenLine, parser.tokenColumn));
+            list.push(parseDecoratorList(parser, context, privateScope, parser.tokenStart));
         }
     }
     return list;
 }
-function parseDecoratorList(parser, context, privateScope, start, line, column) {
+function parseDecoratorList(parser, context, privateScope, start) {
     nextToken(parser, context | 8192);
-    let expression = parsePrimaryExpression(parser, context, privateScope, 2, 0, 1, 0, 1, start, line, column);
-    expression = parseMemberOrUpdateExpression(parser, context, privateScope, expression, 0, 0, start, line, column);
-    return finishNode(parser, context, start, line, column, {
+    let expression = parsePrimaryExpression(parser, context, privateScope, 2, 0, 1, 0, 1, start);
+    expression = parseMemberOrUpdateExpression(parser, context, privateScope, expression, 0, 0, parser.tokenStart);
+    return parser.finishNode({
         type: 'Decorator',
         expression,
-    });
+    }, start);
 }
 function parseClassBody(parser, context, inheritedContext, scope, parentScope, kind, origin, inGroup) {
-    const { tokenIndex, tokenLine, tokenColumn } = parser;
+    const { tokenStart } = parser;
     const privateScope = context & 16 ? addChildPrivateScope(parentScope) : undefined;
     consume(parser, context | 8192, 2162700);
     const modifierFlags = 33554432 | 268435456;
@@ -8634,6 +8661,7 @@ function parseClassBody(parser, context, inheritedContext, scope, parentScope, k
     parser.flags = (parser.flags | 32) ^ 32;
     const body = [];
     let decorators;
+    const decoratorStart = parser.tokenStart;
     while (parser.getToken() !== 1074790415) {
         let length = 0;
         decorators = parseDecorators(parser, context, privateScope);
@@ -8648,21 +8676,21 @@ function parseClassBody(parser, context, inheritedContext, scope, parentScope, k
                 report(parser, 120);
             continue;
         }
-        body.push(parseClassElementList(parser, context, scope, privateScope, inheritedContext, kind, decorators, 0, inGroup, parser.tokenIndex, parser.tokenLine, parser.tokenColumn));
+        body.push(parseClassElementList(parser, context, scope, privateScope, inheritedContext, kind, decorators, 0, inGroup, length > 0 ? decoratorStart : parser.tokenStart));
     }
     consume(parser, origin & 8 ? context | 8192 : context, 1074790415);
     if (privateScope)
         validatePrivateIdentifierRefs(privateScope);
     parser.flags = (parser.flags & -33) | hasConstr;
-    return finishNode(parser, context, tokenIndex, tokenLine, tokenColumn, {
+    return parser.finishNode({
         type: 'ClassBody',
         body,
-    });
+    }, tokenStart);
 }
-function parseClassElementList(parser, context, scope, privateScope, inheritedContext, type, decorators, isStatic, inGroup, start, line, column) {
+function parseClassElementList(parser, context, scope, privateScope, inheritedContext, type, decorators, isStatic, inGroup, start) {
     let kind = isStatic ? 32 : 0;
     let key = null;
-    const { tokenIndex, tokenLine, tokenColumn } = parser;
+    const { tokenStart } = parser;
     const token = parser.getToken();
     if (token & (143360 | 36864) || token === -2147483528) {
         key = parseIdentifier(parser, context);
@@ -8672,13 +8700,13 @@ function parseClassElementList(parser, context, scope, privateScope, inheritedCo
                     parser.getToken() !== 67174411 &&
                     (parser.getToken() & 1048576) !== 1048576 &&
                     parser.getToken() !== 1077936155) {
-                    return parseClassElementList(parser, context, scope, privateScope, inheritedContext, type, decorators, 1, inGroup, start, line, column);
+                    return parseClassElementList(parser, context, scope, privateScope, inheritedContext, type, decorators, 1, inGroup, start);
                 }
                 break;
             case 209005:
                 if (parser.getToken() !== 67174411 && (parser.flags & 1) === 0) {
                     if ((parser.getToken() & 1073741824) === 1073741824) {
-                        return parsePropertyDefinition(parser, context, privateScope, key, kind, decorators, tokenIndex, tokenLine, tokenColumn);
+                        return parsePropertyDefinition(parser, context, privateScope, key, kind, decorators, tokenStart);
                     }
                     kind |= 16 | (optionalBit(parser, context, 8391476) ? 8 : 0);
                 }
@@ -8686,7 +8714,7 @@ function parseClassElementList(parser, context, scope, privateScope, inheritedCo
             case 209008:
                 if (parser.getToken() !== 67174411) {
                     if ((parser.getToken() & 1073741824) === 1073741824) {
-                        return parsePropertyDefinition(parser, context, privateScope, key, kind, decorators, tokenIndex, tokenLine, tokenColumn);
+                        return parsePropertyDefinition(parser, context, privateScope, key, kind, decorators, tokenStart);
                     }
                     kind |= 256;
                 }
@@ -8694,7 +8722,7 @@ function parseClassElementList(parser, context, scope, privateScope, inheritedCo
             case 209009:
                 if (parser.getToken() !== 67174411) {
                     if ((parser.getToken() & 1073741824) === 1073741824) {
-                        return parsePropertyDefinition(parser, context, privateScope, key, kind, decorators, tokenIndex, tokenLine, tokenColumn);
+                        return parsePropertyDefinition(parser, context, privateScope, key, kind, decorators, tokenStart);
                     }
                     kind |= 512;
                 }
@@ -8702,7 +8730,7 @@ function parseClassElementList(parser, context, scope, privateScope, inheritedCo
             case 12402:
                 if (parser.getToken() !== 67174411 && (parser.flags & 1) === 0) {
                     if ((parser.getToken() & 1073741824) === 1073741824) {
-                        return parsePropertyDefinition(parser, context, privateScope, key, kind, decorators, tokenIndex, tokenLine, tokenColumn);
+                        return parsePropertyDefinition(parser, context, privateScope, key, kind, decorators, tokenStart);
                     }
                     if (context & 1)
                         kind |= 1024;
@@ -8723,13 +8751,13 @@ function parseClassElementList(parser, context, scope, privateScope, inheritedCo
     }
     else if (parser.getToken() === 130) {
         kind |= 8192;
-        key = parsePrivateIdentifier(parser, context | 4096, privateScope, 768, tokenIndex, tokenLine, tokenColumn);
+        key = parsePrivateIdentifier(parser, context | 4096, privateScope, 768);
     }
     else if ((parser.getToken() & 1073741824) === 1073741824) {
         kind |= 128;
     }
     else if (isStatic && token === 2162700) {
-        return parseStaticBlock(parser, context | 4096, scope, privateScope, start, line, column);
+        return parseStaticBlock(parser, context | 4096, scope, privateScope, start);
     }
     else if (token === -2147483527) {
         key = parseIdentifier(parser, context);
@@ -8754,7 +8782,7 @@ function parseClassElementList(parser, context, scope, privateScope, inheritedCo
         }
         else if (parser.getToken() === 130) {
             kind |= 8192;
-            key = parsePrivateIdentifier(parser, context, privateScope, kind, tokenIndex, tokenLine, tokenColumn);
+            key = parsePrivateIdentifier(parser, context, privateScope, kind);
         }
         else
             report(parser, 135);
@@ -8784,10 +8812,10 @@ function parseClassElementList(parser, context, scope, privateScope, inheritedCo
         }
     }
     if (kind & 1024 || (parser.getToken() !== 67174411 && (kind & 768) === 0)) {
-        return parsePropertyDefinition(parser, context, privateScope, key, kind, decorators, tokenIndex, tokenLine, tokenColumn);
+        return parsePropertyDefinition(parser, context, privateScope, key, kind, decorators, start);
     }
-    const value = parseMethodDefinition(parser, context | 4096, privateScope, kind, inGroup, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
-    return finishNode(parser, context, start, line, column, {
+    const value = parseMethodDefinition(parser, context | 4096, privateScope, kind, inGroup, parser.tokenStart);
+    return parser.finishNode({
         type: 'MethodDefinition',
         kind: (kind & 32) === 0 && kind & 64
             ? 'constructor'
@@ -8801,9 +8829,10 @@ function parseClassElementList(parser, context, scope, privateScope, inheritedCo
         key,
         value,
         ...(context & 1 ? { decorators } : null),
-    });
+    }, start);
 }
-function parsePrivateIdentifier(parser, context, privateScope, kind, start, line, column) {
+function parsePrivateIdentifier(parser, context, privateScope, kind) {
+    const { tokenStart } = parser;
     nextToken(parser, context);
     const { tokenValue } = parser;
     if (tokenValue === 'constructor')
@@ -8819,18 +8848,18 @@ function parsePrivateIdentifier(parser, context, privateScope, kind, start, line
         }
     }
     nextToken(parser, context);
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'PrivateIdentifier',
         name: tokenValue,
-    });
+    }, tokenStart);
 }
-function parsePropertyDefinition(parser, context, privateScope, key, state, decorators, start, line, column) {
+function parsePropertyDefinition(parser, context, privateScope, key, state, decorators, start) {
     let value = null;
     if (state & 8)
         report(parser, 0);
     if (parser.getToken() === 1077936155) {
         nextToken(parser, context | 8192);
-        const { tokenIndex, tokenLine, tokenColumn } = parser;
+        const { tokenStart } = parser;
         if (parser.getToken() === 537079927)
             report(parser, 119);
         const modifierFlags = 262144 |
@@ -8844,40 +8873,39 @@ function parsePropertyDefinition(parser, context, privateScope, key, state, deco
                 (state & 64 ? 4194304 : 0) |
                 65536 |
                 16777216;
-        value = parsePrimaryExpression(parser, context | 4096, privateScope, 2, 0, 1, 0, 1, tokenIndex, tokenLine, tokenColumn);
+        value = parsePrimaryExpression(parser, context | 4096, privateScope, 2, 0, 1, 0, 1, tokenStart);
         if ((parser.getToken() & 1073741824) !== 1073741824 ||
             (parser.getToken() & 4194304) === 4194304) {
-            value = parseMemberOrUpdateExpression(parser, context | 4096, privateScope, value, 0, 0, tokenIndex, tokenLine, tokenColumn);
-            value = parseAssignmentExpression(parser, context | 4096, privateScope, 0, 0, tokenIndex, tokenLine, tokenColumn, value);
+            value = parseMemberOrUpdateExpression(parser, context | 4096, privateScope, value, 0, 0, tokenStart);
+            value = parseAssignmentExpression(parser, context | 4096, privateScope, 0, 0, tokenStart, value);
         }
     }
     matchOrInsertSemicolon(parser, context);
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: state & 1024 ? 'AccessorProperty' : 'PropertyDefinition',
         key,
         value,
         static: (state & 32) > 0,
         computed: (state & 2) > 0,
         ...(context & 1 ? { decorators } : null),
-    });
+    }, start);
 }
-function parseBindingPattern(parser, context, scope, privateScope, type, origin, start, line, column) {
+function parseBindingPattern(parser, context, scope, privateScope, type, origin) {
     if (parser.getToken() & 143360 ||
         ((context & 256) === 0 && parser.getToken() === -2147483527))
-        return parseAndClassifyIdentifier(parser, context, scope, type, origin, start, line, column);
+        return parseAndClassifyIdentifier(parser, context, scope, type, origin);
     if ((parser.getToken() & 2097152) !== 2097152)
         report(parser, 30, KeywordDescTable[parser.getToken() & 255]);
     const left = parser.getToken() === 69271571
-        ? parseArrayExpressionOrPattern(parser, context, scope, privateScope, 1, 0, 1, type, origin, start, line, column)
-        : parseObjectLiteralOrPattern(parser, context, scope, privateScope, 1, 0, 1, type, origin, start, line, column);
+        ? parseArrayExpressionOrPattern(parser, context, scope, privateScope, 1, 0, 1, type, origin)
+        : parseObjectLiteralOrPattern(parser, context, scope, privateScope, 1, 0, 1, type, origin);
     if (parser.destructible & 16)
         report(parser, 50);
     if (parser.destructible & 32)
         report(parser, 50);
     return left;
 }
-function parseAndClassifyIdentifier(parser, context, scope, kind, origin, start, line, column) {
-    const { tokenValue } = parser;
+function parseAndClassifyIdentifier(parser, context, scope, kind, origin) {
     const token = parser.getToken();
     if (context & 256) {
         if ((token & 537079808) === 537079808) {
@@ -8906,54 +8934,55 @@ function parseAndClassifyIdentifier(parser, context, scope, kind, origin, start,
         if (context & 512)
             report(parser, 110);
     }
+    const { tokenValue, tokenStart: start } = parser;
     nextToken(parser, context);
     if (scope)
         addVarOrBlock(parser, context, scope, tokenValue, kind, origin);
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'Identifier',
         name: tokenValue,
-    });
+    }, start);
 }
-function parseJSXRootElementOrFragment(parser, context, privateScope, inJSXChild, start, line, column) {
+function parseJSXRootElementOrFragment(parser, context, privateScope, inJSXChild, start) {
     if (!inJSXChild)
         consume(parser, context, 8456256);
     if (parser.getToken() === 8390721) {
-        const openingFragment = parseOpeningFragment(parser, context, start, line, column);
+        const openingFragment = parseJSXOpeningFragment(parser, context, start);
         const [children, closingFragment] = parseJSXChildrenAndClosingFragment(parser, context, privateScope, inJSXChild);
-        return finishNode(parser, context, start, line, column, {
+        return parser.finishNode({
             type: 'JSXFragment',
             openingFragment,
             children,
             closingFragment,
-        });
+        }, start);
     }
     if (parser.getToken() === 8457014)
         report(parser, 30, KeywordDescTable[parser.getToken() & 255]);
     let closingElement = null;
     let children = [];
-    const openingElement = parseJSXOpeningElementOrSelfCloseElement(parser, context, privateScope, inJSXChild, start, line, column);
+    const openingElement = parseJSXOpeningElementOrSelfCloseElement(parser, context, privateScope, inJSXChild, start);
     if (!openingElement.selfClosing) {
         [children, closingElement] = parseJSXChildrenAndClosingElement(parser, context, privateScope, inJSXChild);
         const close = isEqualTagName(closingElement.name);
         if (isEqualTagName(openingElement.name) !== close)
             report(parser, 155, close);
     }
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'JSXElement',
         children,
         openingElement,
         closingElement,
-    });
+    }, start);
 }
-function parseOpeningFragment(parser, context, start, line, column) {
+function parseJSXOpeningFragment(parser, context, start) {
     nextJSXToken(parser, context);
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'JSXOpeningFragment',
-    });
+    }, start);
 }
-function parseJSXClosingElement(parser, context, inJSXChild, start, line, column) {
+function parseJSXClosingElement(parser, context, inJSXChild, start) {
     consume(parser, context, 8457014);
-    const name = parseJSXElementName(parser, context, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+    const name = parseJSXElementName(parser, context);
     if (parser.getToken() !== 8390721) {
         report(parser, 25, KeywordDescTable[8390721 & 255]);
     }
@@ -8963,12 +8992,12 @@ function parseJSXClosingElement(parser, context, inJSXChild, start, line, column
     else {
         nextToken(parser, context);
     }
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'JSXClosingElement',
         name,
-    });
+    }, start);
 }
-function parseJSXClosingFragment(parser, context, inJSXChild, start, line, column) {
+function parseJSXClosingFragment(parser, context, inJSXChild, start) {
     consume(parser, context, 8457014);
     if (parser.getToken() !== 8390721) {
         report(parser, 25, KeywordDescTable[8390721 & 255]);
@@ -8979,14 +9008,14 @@ function parseJSXClosingFragment(parser, context, inJSXChild, start, line, colum
     else {
         nextToken(parser, context);
     }
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'JSXClosingFragment',
-    });
+    }, start);
 }
 function parseJSXChildrenAndClosingElement(parser, context, privateScope, inJSXChild) {
     const children = [];
     while (true) {
-        const child = parseJSXChildOrClosingElement(parser, context, privateScope, inJSXChild, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+        const child = parseJSXChildOrClosingElement(parser, context, privateScope, inJSXChild);
         if (child.type === 'JSXClosingElement') {
             return [children, child];
         }
@@ -8996,40 +9025,43 @@ function parseJSXChildrenAndClosingElement(parser, context, privateScope, inJSXC
 function parseJSXChildrenAndClosingFragment(parser, context, privateScope, inJSXChild) {
     const children = [];
     while (true) {
-        const child = parseJSXChildOrClosingFragment(parser, context, privateScope, inJSXChild, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+        const child = parseJSXChildOrClosingFragment(parser, context, privateScope, inJSXChild);
         if (child.type === 'JSXClosingFragment') {
             return [children, child];
         }
         children.push(child);
     }
 }
-function parseJSXChildOrClosingElement(parser, context, privateScope, inJSXChild, start, line, column) {
+function parseJSXChildOrClosingElement(parser, context, privateScope, inJSXChild) {
     if (parser.getToken() === 137)
-        return parseJSXText(parser, context, start, line, column);
+        return parseJSXText(parser, context);
     if (parser.getToken() === 2162700)
-        return parseJSXExpressionContainer(parser, context, privateScope, 1, 0, start, line, column);
+        return parseJSXExpressionContainer(parser, context, privateScope, 1, 0);
     if (parser.getToken() === 8456256) {
+        const { tokenStart } = parser;
         nextToken(parser, context);
         if (parser.getToken() === 8457014)
-            return parseJSXClosingElement(parser, context, inJSXChild, start, line, column);
-        return parseJSXRootElementOrFragment(parser, context, privateScope, 1, start, line, column);
+            return parseJSXClosingElement(parser, context, inJSXChild, tokenStart);
+        return parseJSXRootElementOrFragment(parser, context, privateScope, 1, tokenStart);
     }
     report(parser, 0);
 }
-function parseJSXChildOrClosingFragment(parser, context, privateScope, inJSXChild, start, line, column) {
+function parseJSXChildOrClosingFragment(parser, context, privateScope, inJSXChild) {
     if (parser.getToken() === 137)
-        return parseJSXText(parser, context, start, line, column);
+        return parseJSXText(parser, context);
     if (parser.getToken() === 2162700)
-        return parseJSXExpressionContainer(parser, context, privateScope, 1, 0, start, line, column);
+        return parseJSXExpressionContainer(parser, context, privateScope, 1, 0);
     if (parser.getToken() === 8456256) {
+        const { tokenStart } = parser;
         nextToken(parser, context);
         if (parser.getToken() === 8457014)
-            return parseJSXClosingFragment(parser, context, inJSXChild, start, line, column);
-        return parseJSXRootElementOrFragment(parser, context, privateScope, 1, start, line, column);
+            return parseJSXClosingFragment(parser, context, inJSXChild, tokenStart);
+        return parseJSXRootElementOrFragment(parser, context, privateScope, 1, tokenStart);
     }
     report(parser, 0);
 }
-function parseJSXText(parser, context, start, line, column) {
+function parseJSXText(parser, context) {
+    const start = parser.tokenStart;
     nextToken(parser, context);
     const node = {
         type: 'JSXText',
@@ -9038,13 +9070,13 @@ function parseJSXText(parser, context, start, line, column) {
     if (context & 128) {
         node.raw = parser.tokenRaw;
     }
-    return finishNode(parser, context, start, line, column, node);
+    return parser.finishNode(node, start);
 }
-function parseJSXOpeningElementOrSelfCloseElement(parser, context, privateScope, inJSXChild, start, line, column) {
+function parseJSXOpeningElementOrSelfCloseElement(parser, context, privateScope, inJSXChild, start) {
     if ((parser.getToken() & 143360) !== 143360 &&
         (parser.getToken() & 4096) !== 4096)
         report(parser, 0);
-    const tagName = parseJSXElementName(parser, context, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+    const tagName = parseJSXElementName(parser, context);
     const attributes = parseJSXAttributes(parser, context, privateScope);
     const selfClosing = parser.getToken() === 8457014;
     if (selfClosing)
@@ -9058,105 +9090,112 @@ function parseJSXOpeningElementOrSelfCloseElement(parser, context, privateScope,
     else {
         nextToken(parser, context);
     }
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'JSXOpeningElement',
         name: tagName,
         attributes,
         selfClosing,
-    });
+    }, start);
 }
-function parseJSXElementName(parser, context, start, line, column) {
+function parseJSXElementName(parser, context) {
+    const { tokenStart } = parser;
     rescanJSXIdentifier(parser);
-    let key = parseJSXIdentifier(parser, context, start, line, column);
+    let key = parseJSXIdentifier(parser, context);
     if (parser.getToken() === 21)
-        return parseJSXNamespacedName(parser, context, key, start, line, column);
+        return parseJSXNamespacedName(parser, context, key, tokenStart);
     while (consumeOpt(parser, context, 67108877)) {
         rescanJSXIdentifier(parser);
-        key = parseJSXMemberExpression(parser, context, key, start, line, column);
+        key = parseJSXMemberExpression(parser, context, key, tokenStart);
     }
     return key;
 }
-function parseJSXMemberExpression(parser, context, object, start, line, column) {
-    const property = parseJSXIdentifier(parser, context, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
-    return finishNode(parser, context, start, line, column, {
+function parseJSXMemberExpression(parser, context, object, start) {
+    const property = parseJSXIdentifier(parser, context);
+    return parser.finishNode({
         type: 'JSXMemberExpression',
         object,
         property,
-    });
+    }, start);
 }
 function parseJSXAttributes(parser, context, privateScope) {
     const attributes = [];
     while (parser.getToken() !== 8457014 &&
         parser.getToken() !== 8390721 &&
         parser.getToken() !== 1048576) {
-        attributes.push(parseJsxAttribute(parser, context, privateScope, parser.tokenIndex, parser.tokenLine, parser.tokenColumn));
+        attributes.push(parseJsxAttribute(parser, context, privateScope));
     }
     return attributes;
 }
-function parseJSXSpreadAttribute(parser, context, privateScope, start, line, column) {
+function parseJSXSpreadAttribute(parser, context, privateScope) {
+    const start = parser.tokenStart;
     nextToken(parser, context);
     consume(parser, context, 14);
-    const expression = parseExpression(parser, context, privateScope, 1, 0, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+    const expression = parseExpression(parser, context, privateScope, 1, 0, parser.tokenStart);
     consume(parser, context, 1074790415);
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'JSXSpreadAttribute',
         argument: expression,
-    });
+    }, start);
 }
-function parseJsxAttribute(parser, context, privateScope, start, line, column) {
+function parseJsxAttribute(parser, context, privateScope) {
+    const { tokenStart } = parser;
     if (parser.getToken() === 2162700)
-        return parseJSXSpreadAttribute(parser, context, privateScope, start, line, column);
+        return parseJSXSpreadAttribute(parser, context, privateScope);
     rescanJSXIdentifier(parser);
     let value = null;
-    let name = parseJSXIdentifier(parser, context, start, line, column);
+    let name = parseJSXIdentifier(parser, context);
     if (parser.getToken() === 21) {
-        name = parseJSXNamespacedName(parser, context, name, start, line, column);
+        name = parseJSXNamespacedName(parser, context, name, tokenStart);
     }
     if (parser.getToken() === 1077936155) {
         const token = scanJSXAttributeValue(parser, context);
-        const { tokenIndex, tokenLine, tokenColumn } = parser;
         switch (token) {
             case 134283267:
                 value = parseLiteral(parser, context);
                 break;
             case 8456256:
-                value = parseJSXRootElementOrFragment(parser, context, privateScope, 0, tokenIndex, tokenLine, tokenColumn);
+                value = parseJSXRootElementOrFragment(parser, context, privateScope, 0, parser.tokenStart);
                 break;
             case 2162700:
-                value = parseJSXExpressionContainer(parser, context, privateScope, 0, 1, tokenIndex, tokenLine, tokenColumn);
+                value = parseJSXExpressionContainer(parser, context, privateScope, 0, 1);
                 break;
             default:
                 report(parser, 154);
         }
     }
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'JSXAttribute',
         value,
         name,
-    });
+    }, tokenStart);
 }
-function parseJSXNamespacedName(parser, context, namespace, start, line, column) {
+function parseJSXNamespacedName(parser, context, namespace, start) {
     consume(parser, context, 21);
-    const name = parseJSXIdentifier(parser, context, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
-    return finishNode(parser, context, start, line, column, {
+    const name = parseJSXIdentifier(parser, context);
+    return parser.finishNode({
         type: 'JSXNamespacedName',
         namespace,
         name,
-    });
+    }, start);
 }
-function parseJSXExpressionContainer(parser, context, privateScope, inJSXChild, isAttr, start, line, column) {
+function parseJSXExpressionContainer(parser, context, privateScope, inJSXChild, isAttr) {
+    const { tokenStart: start } = parser;
     nextToken(parser, context | 8192);
-    const { tokenIndex, tokenLine, tokenColumn } = parser;
+    const { tokenStart } = parser;
     if (parser.getToken() === 14)
-        return parseJSXSpreadChild(parser, context, privateScope, start, line, column);
+        return parseJSXSpreadChild(parser, context, privateScope, start);
     let expression = null;
     if (parser.getToken() === 1074790415) {
         if (isAttr)
             report(parser, 157);
-        expression = parseJSXEmptyExpression(parser, context, parser.startIndex, parser.startLine, parser.startColumn);
+        expression = parseJSXEmptyExpression(parser, {
+            index: parser.startIndex,
+            line: parser.startLine,
+            column: parser.startColumn,
+        });
     }
     else {
-        expression = parseExpression(parser, context, privateScope, 1, 0, tokenIndex, tokenLine, tokenColumn);
+        expression = parseExpression(parser, context, privateScope, 1, 0, tokenStart);
     }
     if (parser.getToken() !== 1074790415) {
         report(parser, 25, KeywordDescTable[1074790415 & 255]);
@@ -9167,41 +9206,39 @@ function parseJSXExpressionContainer(parser, context, privateScope, inJSXChild,
     else {
         nextToken(parser, context);
     }
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'JSXExpressionContainer',
         expression,
-    });
+    }, start);
 }
-function parseJSXSpreadChild(parser, context, privateScope, start, line, column) {
+function parseJSXSpreadChild(parser, context, privateScope, start) {
     consume(parser, context, 14);
-    const expression = parseExpression(parser, context, privateScope, 1, 0, parser.tokenIndex, parser.tokenLine, parser.tokenColumn);
+    const expression = parseExpression(parser, context, privateScope, 1, 0, parser.tokenStart);
     consume(parser, context, 1074790415);
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'JSXSpreadChild',
         expression,
-    });
+    }, start);
 }
-function parseJSXEmptyExpression(parser, context, start, line, column) {
-    parser.startIndex = parser.tokenIndex;
-    parser.startLine = parser.tokenLine;
-    parser.startColumn = parser.tokenColumn;
-    return finishNode(parser, context, start, line, column, {
+function parseJSXEmptyExpression(parser, start) {
+    return parser.finishNode({
         type: 'JSXEmptyExpression',
-    });
+    }, start, parser.tokenStart);
 }
-function parseJSXIdentifier(parser, context, start, line, column) {
+function parseJSXIdentifier(parser, context) {
+    const start = parser.tokenStart;
     if (!(parser.getToken() & 143360)) {
         report(parser, 30, KeywordDescTable[parser.getToken() & 255]);
     }
     const { tokenValue } = parser;
     nextToken(parser, context);
-    return finishNode(parser, context, start, line, column, {
+    return parser.finishNode({
         type: 'JSXIdentifier',
         name: tokenValue,
-    });
+    }, start);
 }
 
-var version$1 = "6.1.0";
+var version$1 = "6.1.1";
 
 const version = version$1;
 function parseScript(source, options) {