meriyah 6.1.0 → 6.1.2

package/dist/meriyah.umd.js

@@ -184,31 +184,36 @@
       [177]: 'cannot use "await" in static blocks',
   };
   class ParseError extends SyntaxError {
-      constructor(start, startLine, startColumn, end, endLine, endColumn, type, ...params) {
+      start;
+      end;
+      range;
+      loc;
+      description;
+      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) => {
@@ -706,7 +711,13 @@
           : 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) {
@@ -742,7 +753,7 @@
           parser.tokenLine = parser.line;
           parser.tokenColumn = parser.column;
       }
-      if (parser.onComment) {
+      if (parser.options.onComment) {
           const loc = {
               start: {
                   line,
@@ -753,7 +764,7 @@
                   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;
   }
@@ -769,7 +780,7 @@
                   }
                   if (advanceChar(parser) === 47) {
                       advanceChar(parser);
-                      if (parser.onComment) {
+                      if (parser.options.onComment) {
                           const loc = {
                               start: {
                                   line: parser.tokenLine,
@@ -780,7 +791,7 @@
                                   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;
@@ -1339,7 +1350,7 @@
                       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;
@@ -1350,7 +1361,7 @@
                       --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;
@@ -1415,7 +1426,7 @@
               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);
@@ -1426,7 +1437,7 @@
           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);
   }
@@ -1628,6 +1639,7 @@
           report(parser, 5);
       }
       parser.currentChar = parser.source.charCodeAt((parser.index += 2));
+      parser.column += 2;
       return scanUnicodeEscape(parser);
   }
   function scanUnicodeEscape(parser) {
@@ -1638,10 +1650,10 @@
           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;
@@ -1659,6 +1671,7 @@
           report(parser, 7);
       codePoint = (toHex(char) << 12) | (toHex(char2) << 8) | (toHex(char3) << 4) | toHex(char4);
       parser.currentChar = parser.source.charCodeAt((parser.index += 4));
+      parser.column += 4;
       return codePoint;
   }
 
@@ -4386,7 +4399,7 @@
           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) {
@@ -4533,29 +4546,6 @@
       }
       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':
@@ -4572,16 +4562,11 @@
       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() {
@@ -4701,7 +4686,7 @@
       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);
           }
       }
   }
@@ -4718,39 +4703,6 @@
           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)
@@ -4771,72 +4723,136 @@
           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 {
+      source;
+      options;
+      lastOnToken = null;
+      token = 1048576;
+      flags = 0;
+      index = 0;
+      line = 1;
+      column = 0;
+      startIndex = 0;
+      end = 0;
+      tokenIndex = 0;
+      startColumn = 0;
+      tokenColumn = 0;
+      tokenLine = 1;
+      startLine = 1;
+      tokenValue = '';
+      tokenRaw = '';
+      tokenRegExp = void 0;
+      currentChar = 0;
+      exportedNames = {};
+      exportedBindings = {};
+      assignable = 1;
+      destructible = 0;
+      leadingDecorators = { decorators: [] };
+      constructor(source, options = {}) {
+          this.source = source;
+          this.options = options;
+          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;
@@ -4862,18 +4878,28 @@
               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 = [];
@@ -4891,43 +4917,29 @@
       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, {}));
@@ -4938,9 +4950,9 @@
       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));
@@ -4948,7 +4960,12 @@
       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:
@@ -4960,77 +4977,75 @@
           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, start);
                   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:
@@ -5044,11 +5059,11 @@
           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) {
@@ -5060,51 +5075,52 @@
                   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);
@@ -5112,37 +5128,37 @@
           (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) {
@@ -5150,89 +5166,92 @@
               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 = [];
@@ -5240,11 +5259,11 @@
       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);
@@ -5260,37 +5279,39 @@
                   $: 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) {
@@ -5300,12 +5321,13 @@
               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) {
@@ -5318,58 +5340,61 @@
           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)) {
@@ -5377,7 +5402,7 @@
               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);
           }
@@ -5388,14 +5413,14 @@
       }
       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;
@@ -5405,76 +5430,79 @@
               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;
@@ -5491,18 +5519,18 @@
       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');
               }
           }
       }
@@ -5510,13 +5538,14 @@
           (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);
@@ -5531,7 +5560,7 @@
           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) {
@@ -5542,11 +5571,11 @@
                           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;
               }
@@ -5556,14 +5585,14 @@
               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',
@@ -5573,7 +5602,7 @@
                       type: 'VariableDeclaration',
                       kind: 'const',
                       declarations: parseVariableDeclarationList(parser, context | 33554432, scope, privateScope, 16, 32),
-                  });
+                  }, tokenStart);
               parser.assignable = 1;
           }
       }
@@ -5582,20 +5611,21 @@
               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) {
@@ -5603,16 +5633,16 @@
                   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');
@@ -5620,15 +5650,15 @@
           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);
@@ -5636,25 +5666,25 @@
           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()))
@@ -5666,12 +5696,10 @@
       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);
@@ -5680,10 +5708,10 @@
           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()) {
@@ -5707,9 +5735,9 @@
                       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, start);
                   default:
                       report(parser, 30, KeywordDescTable[parser.getToken() & 255]);
               }
@@ -5724,19 +5752,19 @@
           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);
@@ -5747,7 +5775,7 @@
   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;
@@ -5771,41 +5799,39 @@
           }
           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, start) {
+      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), 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;
@@ -5814,47 +5840,47 @@
       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: {
@@ -5878,7 +5904,7 @@
                   attributes,
               };
               matchOrInsertSemicolon(parser, context | 8192);
-              return finishNode(parser, context, start, line, column, node);
+              return parser.finishNode(node, start);
           }
           case 2162700: {
               nextToken(parser, context);
@@ -5886,7 +5912,7 @@
               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;
@@ -5910,11 +5936,11 @@
                       }
                       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);
               }
@@ -5940,26 +5966,27 @@
               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;
               }
           }
@@ -5973,30 +6000,30 @@
           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)
@@ -6006,9 +6033,9 @@
               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,
@@ -6019,21 +6046,21 @@
                   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,
@@ -6044,24 +6071,24 @@
               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;
@@ -6075,23 +6102,24 @@
           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) {
@@ -6103,20 +6131,20 @@
           }
       }
       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)
@@ -6124,11 +6152,11 @@
               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);
@@ -6137,12 +6165,12 @@
           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) {
@@ -6158,83 +6186,83 @@
           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) {
@@ -6262,12 +6290,13 @@
       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:
@@ -6288,28 +6317,29 @@
           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;
@@ -6321,12 +6351,13 @@
                   }
                   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: {
@@ -6336,16 +6367,17 @@
                       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;
                   }
@@ -6363,11 +6395,12 @@
                   }
                   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;
                   }
@@ -6377,7 +6410,7 @@
                   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:
@@ -6385,26 +6418,26 @@
                       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) {
@@ -6415,38 +6448,38 @@
       }
       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;
@@ -6461,37 +6494,37 @@
           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();
@@ -6503,7 +6536,7 @@
               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) &&
@@ -6528,7 +6561,7 @@
       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:
@@ -6536,61 +6569,61 @@
           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, start);
       }
       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, start) {
       if ((context & 512) === 0)
           report(parser, 169);
       nextToken(parser, context);
@@ -6602,23 +6635,23 @@
           report(parser, 175);
       }
       parser.assignable = 2;
-      return finishNode(parser, context, start, line, column, {
+      return parser.finishNode({
           type: 'MetaProperty',
           meta,
           property: parseIdentifier(parser, context),
-      });
+      }, start);
   }
-  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);
       }
@@ -6628,7 +6661,7 @@
           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))
@@ -6637,9 +6670,7 @@
       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);
@@ -6663,11 +6694,11 @@
               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);
           }
@@ -6717,8 +6748,8 @@
           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 = {
@@ -6729,61 +6760,57 @@
       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;
@@ -6797,15 +6824,16 @@
       }
       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);
@@ -6816,10 +6844,10 @@
       }
       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;
@@ -6831,22 +6859,22 @@
       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,
@@ -6855,14 +6883,15 @@
           : {
               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,
@@ -6871,17 +6900,17 @@
           : {
               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;
@@ -6937,16 +6966,16 @@
       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);
@@ -6979,17 +7008,17 @@
           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);
       }
@@ -6998,7 +7027,8 @@
       }
       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;
@@ -7009,18 +7039,18 @@
           }
           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,
@@ -7031,7 +7061,7 @@
                               operator: '=',
                               left,
                               right,
-                          });
+                          }, tokenStart);
                       destructible |=
                           parser.destructible & 256
                               ? 256
@@ -7060,11 +7090,11 @@
                               : (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 |=
@@ -7077,8 +7107,8 @@
               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
@@ -7093,10 +7123,10 @@
                       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 |=
@@ -7107,15 +7137,15 @@
                   }
               }
               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;
                   }
@@ -7139,17 +7169,17 @@
           }
       }
       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);
@@ -7157,14 +7187,14 @@
           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,
@@ -7175,24 +7205,25 @@
               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;
@@ -7212,25 +7243,25 @@
       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
@@ -7247,13 +7278,13 @@
       }
       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 {
@@ -7261,7 +7292,7 @@
                   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;
@@ -7269,10 +7300,10 @@
           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)
@@ -7281,8 +7312,8 @@
               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,
@@ -7293,7 +7324,7 @@
                       left: argument,
                       operator: '=',
                       right,
-                  });
+                  }, tokenStart);
               destructible = 16;
           }
           else {
@@ -7301,12 +7332,12 @@
           }
       }
       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 |
@@ -7326,17 +7357,17 @@
       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);
       }
@@ -7345,17 +7376,18 @@
       }
       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;
@@ -7381,18 +7413,18 @@
                           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 |=
@@ -7402,15 +7434,15 @@
                       }
                   }
                   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;
@@ -7438,23 +7470,23 @@
                               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;
@@ -7466,17 +7498,17 @@
                               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
@@ -7486,7 +7518,7 @@
                           }
                       }
                       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
@@ -7496,12 +7528,12 @@
                                   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);
                               }
                           }
                       }
@@ -7518,7 +7550,7 @@
                                   : 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;
@@ -7539,12 +7571,12 @@
                           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;
@@ -7574,7 +7606,7 @@
                       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)
@@ -7587,7 +7619,7 @@
                                   : 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);
@@ -7597,14 +7629,14 @@
                   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) {
@@ -7624,18 +7656,18 @@
                           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;
@@ -7645,17 +7677,17 @@
                               }
                           }
                           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
@@ -7665,7 +7697,7 @@
                           }
                       }
                       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
@@ -7676,19 +7708,19 @@
                               }
                           }
                           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 {
@@ -7701,12 +7733,12 @@
                   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
@@ -7714,7 +7746,7 @@
                                       : 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) {
@@ -7734,14 +7766,14 @@
                           }
                           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;
@@ -7753,20 +7785,20 @@
                               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
@@ -7776,7 +7808,7 @@
                           }
                       }
                       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
@@ -7786,19 +7818,19 @@
                                   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 {
@@ -7814,10 +7846,10 @@
                       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
@@ -7828,13 +7860,13 @@
                       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);
@@ -7845,7 +7877,7 @@
               }
               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,
@@ -7853,7 +7885,7 @@
                   computed: (state & 2) > 0,
                   method: (state & 1) > 0,
                   shorthand: (state & 4) > 0,
-              }));
+              }, tokenStart));
           }
           destructible |= parser.destructible;
           if (parser.getToken() !== 18)
@@ -7863,12 +7895,12 @@
       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;
@@ -7895,7 +7927,7 @@
       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) {
@@ -7905,17 +7937,17 @@
                       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))
@@ -7924,12 +7956,12 @@
           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);
@@ -7951,18 +7983,18 @@
   }
   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;
@@ -7971,10 +8003,10 @@
       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)
@@ -7985,7 +8017,7 @@
               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;
@@ -7999,32 +8031,32 @@
                   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;
@@ -8036,7 +8068,7 @@
           }
           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);
               }
@@ -8048,21 +8080,21 @@
               }
               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)) {
@@ -8081,10 +8113,10 @@
       }
       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)
@@ -8107,7 +8139,7 @@
               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);
@@ -8117,13 +8149,14 @@
       }
       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;
@@ -8143,27 +8176,27 @@
               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);
@@ -8177,7 +8210,7 @@
           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)
@@ -8207,14 +8240,14 @@
               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);
@@ -8226,7 +8259,7 @@
       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) {
@@ -8237,17 +8270,17 @@
                       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]);
@@ -8260,12 +8293,12 @@
           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))
@@ -8282,53 +8315,56 @@
       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);
       }
@@ -8336,27 +8372,27 @@
       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) {
@@ -8366,9 +8402,9 @@
       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;
@@ -8376,13 +8412,14 @@
           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;
@@ -8392,7 +8429,7 @@
               (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)
@@ -8403,7 +8440,7 @@
               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;
@@ -8417,54 +8454,55 @@
                   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))
@@ -8488,7 +8526,7 @@
               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);
@@ -8497,40 +8535,41 @@
           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);
@@ -8560,30 +8599,25 @@
       }
       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) {
@@ -8596,7 +8630,7 @@
       }
       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 {
@@ -8604,34 +8638,34 @@
       }
       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;
@@ -8640,6 +8674,7 @@
       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);
@@ -8654,21 +8689,21 @@
                   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);
@@ -8678,13 +8713,13 @@
                       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);
                   }
@@ -8692,7 +8727,7 @@
               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;
                   }
@@ -8700,7 +8735,7 @@
               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;
                   }
@@ -8708,7 +8743,7 @@
               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;
@@ -8729,13 +8764,13 @@
       }
       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);
@@ -8760,7 +8795,7 @@
           }
           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);
@@ -8790,10 +8825,10 @@
           }
       }
       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'
@@ -8807,9 +8842,10 @@
           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')
@@ -8825,18 +8861,18 @@
           }
       }
       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 |
@@ -8850,40 +8886,39 @@
                   (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) {
@@ -8912,54 +8947,55 @@
           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]);
       }
@@ -8969,12 +9005,12 @@
       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]);
@@ -8985,14 +9021,14 @@
       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];
           }
@@ -9002,40 +9038,43 @@
   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',
@@ -9044,13 +9083,13 @@
       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)
@@ -9064,105 +9103,112 @@
       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]);
@@ -9173,41 +9219,39 @@
       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.2";
 
   const version = version$1;
   function parseScript(source, options) {