@sanity/pkg-utils 4.0.0 → 4.1.1

package/dist/index.js

@@ -3,6 +3,7 @@ import path$1, { relative, resolve, dirname } from 'path';
 import pkgUp from 'pkg-up';
 import findConfig from 'find-config';
 import fs$1, { statSync } from 'fs';
+import config from '@sanity/browserslist-config';
 import fs, { writeFile, readFile, readdir, lstat } from 'fs/promises';
 import { z, ZodError } from 'zod';
 import chalk from 'chalk';
@@ -101,12 +102,7 @@ function resolveConfigProperty(prop, initialValue) {
   return prop;
 }
 
-const DEFAULT_BROWSERSLIST_QUERY = [
-  "> 0.2% and supports es6-module and supports es6-module-dynamic-import",
-  "not dead",
-  "not IE 11",
-  "maintained node versions"
-];
+const DEFAULT_BROWSERSLIST_QUERY = config;
 
 function isRecord(value) {
   return Boolean(value) && !Array.isArray(value) && typeof value === "object";
@@ -156,7 +152,7 @@ const pkgSchema = z.object({
       ])
     )
   ),
-  browserslist: z.optional(z.array(z.string()))
+  browserslist: z.optional(z.union([z.string(), z.array(z.string())]))
 });
 function validatePkg(input) {
   return pkgSchema.parse(input);
@@ -517,6 +513,99 @@ function createLogger() {
   };
 }
 
+// convert the browserslist field in package.json to
+// esbuild compatible array of browsers
+function browserslistToEsbuild(browserslistConfig, options = {}) {
+  if (!browserslistConfig) {
+    // the path from where the script is run
+    const path = process.cwd();
+
+    // read config if none is passed
+    browserslistConfig = browserslist.loadConfig({ path, ...options });
+  }
+
+  const SUPPORTED_ESBUILD_TARGETS = [
+    'es',
+    'chrome',
+    'edge',
+    'firefox',
+    'ios',
+    'node',
+    'safari',
+    'opera',
+    'ie',
+  ];
+
+  // https://github.com/eBay/browserslist-config/issues/16#issuecomment-863870093
+  const UNSUPPORTED = ['android 4'];
+
+  const replaces = {
+    ios_saf: 'ios',
+    android: 'chrome',
+  };
+
+  const separator = ' ';
+
+  return (
+    browserslist(browserslistConfig, options)
+      // filter out the unsupported ones
+      .filter((b) => !UNSUPPORTED.some((u) => b.startsWith(u)))
+      // replaces safari TP with latest safari version
+      .map((b) => {
+        if (b === 'safari TP') {
+          return browserslist('last 1 safari version')[0]
+        }
+
+        return b
+      })
+      // transform into ['chrome', '88']
+      .map((b) => b.split(separator))
+      // replace the similar browser
+      .map((b) => {
+        if (replaces[b[0]]) {
+          b[0] = replaces[b[0]];
+        }
+
+        return b
+      })
+      // 11.0-12.0 --> 11.0
+      .map((b) => {
+        if (b[1].includes('-')) {
+          b[1] = b[1].slice(0, b[1].indexOf('-'));
+        }
+
+        return b
+      })
+      // 11.0 --> 11
+      .map((b) => {
+        if (b[1].endsWith('.0')) {
+          b[1] = b[1].slice(0, -2);
+        }
+
+        return b
+      })
+      // removes invalid versions that will break esbuild
+      // https://github.com/evanw/esbuild/blob/35c0d65b9d4f29a26176404d2890d1b499634e9f/compat-table/src/caniuse.ts#L119-L122
+      .filter((b) => /^\d+(\.\d+)*$/.test(b[1]))
+      // only get the targets supported by esbuild
+      .filter((b) => SUPPORTED_ESBUILD_TARGETS.includes(b[0]))
+      // only get the oldest version, assuming that the older version
+      // is last in the array
+      .reduce((acc, b) => {
+        const existingIndex = acc.findIndex((br) => br[0] === b[0]);
+
+        if (existingIndex !== -1) {
+          acc[existingIndex][1] = b[1];
+        } else {
+          acc.push(b);
+        }
+        return acc
+      }, [])
+      // remove separator
+      .map((b) => b.join(''))
+  )
+}
+
 function pathContains(containerPath, itemPath) {
   return !path$1.relative(containerPath, itemPath).startsWith("..");
 }
@@ -544,65 +633,10 @@ function findCommonDirPath(filePaths) {
   return ret;
 }
 
-function sortAsNumber(a, b) {
-  const aVersion = Number(a);
-  const bVersion = Number(b);
-  return aVersion - bVersion;
-}
-function resolveBrowserslistVersions(query) {
-  const result = browserslist(query);
-  const entries = result.map((key) => {
-    const [name, version] = key.split(" ");
-    return { name, version: version.split("-")[0].split(".")[0] };
-  });
-  const andChr = entries.filter((b) => b.name === "and_chr");
-  const andFf = entries.filter((b) => b.name === "and_ff");
-  const chrome = entries.filter((b) => b.name === "chrome");
-  const edge = entries.filter((b) => b.name === "edge");
-  const ff = entries.filter((b) => b.name === "firefox");
-  const iosSaf = entries.filter((b) => b.name === "ios_saf");
-  const saf = entries.filter((b) => b.name === "safari");
-  const opera = entries.filter((b) => b.name === "opera");
-  const node = entries.filter((b) => b.name === "node");
-  const versions = {
-    chrome: andChr.concat(chrome).map((b) => b.version),
-    ff: andFf.concat(ff).map((b) => b.version),
-    edge: edge.map((b) => b.version),
-    iosSaf: iosSaf.map((b) => b.version),
-    saf: saf.map((b) => b.version),
-    opera: opera.map((b) => b.version),
-    node: node.map((b) => b.version)
-  };
-  versions.chrome.sort(sortAsNumber);
-  versions.ff.sort(sortAsNumber);
-  versions.edge.sort(sortAsNumber);
-  versions.iosSaf.sort(sortAsNumber);
-  versions.saf.sort(sortAsNumber);
-  versions.opera.sort(sortAsNumber);
-  versions.node.sort(sortAsNumber);
-  return versions;
-}
-
 function resolveBrowserTarget(versions) {
-  const target = [];
-  if (versions.chrome.length) {
-    target.push(`chrome${versions.chrome[0]}`);
-  }
-  if (versions.ff.length) {
-    target.push(`firefox${versions.ff[0]}`);
-  }
-  if (versions.edge.length) {
-    target.push(`edge${versions.edge[0]}`);
-  }
-  if (versions.iosSaf.length) {
-    target.push(`ios${versions.iosSaf[0]}`);
-  }
-  if (versions.saf.length) {
-    target.push(`safari${versions.saf[0]}`);
-  }
-  if (versions.opera.length) {
-    target.push(`opera${versions.opera[0]}`);
-  }
+  const target = versions.filter(
+    (version) => version.startsWith("chrome") || version.startsWith("edge") || version.startsWith("firefox") || version.startsWith("ios") || version.startsWith("safari") || version.startsWith("opera")
+  );
   if (target.length === 0) {
     return void 0;
   }
@@ -610,10 +644,7 @@ function resolveBrowserTarget(versions) {
 }
 
 function resolveNodeTarget(versions) {
-  const target = [];
-  if (versions.node.length) {
-    target.push(`node${versions.node[0]}`);
-  }
+  const target = versions.filter((version) => version.startsWith("node"));
   if (target.length === 0) {
     return void 0;
   }
@@ -632,7 +663,14 @@ async function resolveBuildContext(options) {
     tsconfig: tsconfigPath
   } = options;
   const tsconfig = await loadTSConfig({ cwd, tsconfigPath });
-  const targetVersions = resolveBrowserslistVersions(pkg.browserslist || DEFAULT_BROWSERSLIST_QUERY);
+  let browserslist = pkg.browserslist;
+  if (!browserslist) {
+    logger.warn(
+      'Could not detect a `browserslist` property in `package.json`, using default configuration. Add `"browserslist": "extends @sanity/browserslist-config"` to silence this warning.'
+    );
+    browserslist = DEFAULT_BROWSERSLIST_QUERY;
+  }
+  const targetVersions = browserslistToEsbuild(browserslist);
   const nodeTarget = resolveNodeTarget(targetVersions);
   const webTarget = resolveBrowserTarget(targetVersions);
   if (!nodeTarget) {
@@ -22008,8 +22046,8 @@ function requireLib () {
 	  PrimaryTopicNotAllowed: "Topic reference was used in a lexical context without topic binding.",
 	  PrimaryTopicRequiresSmartPipeline: 'Topic reference is used, but the pipelineOperator plugin was not passed a "proposal": "hack" or "smart" option.'
 	};
-	const _excluded$1 = ["toMessage"],
-	  _excluded2$1 = ["message"];
+	const _excluded = ["toMessage"],
+	  _excluded2 = ["message"];
 	function defineHidden(obj, key, value) {
 	  Object.defineProperty(obj, key, {
 	    enumerable: false,
@@ -22021,11 +22059,8 @@ function requireLib () {
 	  let {
 	      toMessage
 	    } = _ref,
-	    properties = _objectWithoutPropertiesLoose(_ref, _excluded$1);
-	  return function constructor({
-	    loc,
-	    details
-	  }) {
+	    properties = _objectWithoutPropertiesLoose(_ref, _excluded);
+	  return function constructor(loc, details) {
 	    const error = new SyntaxError();
 	    Object.assign(error, properties, {
 	      loc,
@@ -22043,10 +22078,7 @@ function requireLib () {
 	        column,
 	        index
 	      } = (_overrides$loc = overrides.loc) != null ? _overrides$loc : loc;
-	      return constructor({
-	        loc: new Position(line, column, index),
-	        details: Object.assign({}, details, overrides.details)
-	      });
+	      return constructor(new Position(line, column, index), Object.assign({}, details, overrides.details));
 	    });
 	    defineHidden(error, "details", details);
 	    Object.defineProperty(error, "message", {
@@ -22081,7 +22113,7 @@ function requireLib () {
 	      {
 	        message
 	      } = _ref2,
-	      rest = _objectWithoutPropertiesLoose(_ref2, _excluded2$1);
+	      rest = _objectWithoutPropertiesLoose(_ref2, _excluded2);
 	    const toMessage = typeof message === "string" ? () => message : message;
 	    ParseErrorConstructors[reasonCode] = toParseErrorConstructor(Object.assign({
 	      code: "BABEL_PARSER_SYNTAX_ERROR",
@@ -22326,13 +22358,9 @@ function requireLib () {
 	  }
 	  toAssignableObjectExpressionProp(prop, isLast, isLHS) {
 	    if (prop.kind === "get" || prop.kind === "set") {
-	      this.raise(Errors.PatternHasAccessor, {
-	        at: prop.key
-	      });
+	      this.raise(Errors.PatternHasAccessor, prop.key);
 	    } else if (prop.method) {
-	      this.raise(Errors.PatternHasMethod, {
-	        at: prop.key
-	      });
+	      this.raise(Errors.PatternHasMethod, prop.key);
 	    } else {
 	      super.toAssignableObjectExpressionProp(prop, isLast, isLHS);
 	    }
@@ -23068,9 +23096,9 @@ function requireLib () {
 	}
 	class Scope {
 	  constructor(flags) {
-	    this.var = new Set();
-	    this.lexical = new Set();
-	    this.functions = new Set();
+	    this.flags = 0;
+	    this.names = new Map();
+	    this.firstLexicalName = "";
 	    this.flags = flags;
 	  }
 	}
@@ -23138,11 +23166,16 @@ function requireLib () {
 	    let scope = this.currentScope();
 	    if (bindingType & 8 || bindingType & 16) {
 	      this.checkRedeclarationInScope(scope, name, bindingType, loc);
+	      let type = scope.names.get(name) || 0;
 	      if (bindingType & 16) {
-	        scope.functions.add(name);
+	        type = type | 4;
 	      } else {
-	        scope.lexical.add(name);
+	        if (!scope.firstLexicalName) {
+	          scope.firstLexicalName = name;
+	        }
+	        type = type | 2;
 	      }
+	      scope.names.set(name, type);
 	      if (bindingType & 8) {
 	        this.maybeExportDefined(scope, name);
 	      }
@@ -23150,7 +23183,7 @@ function requireLib () {
 	      for (let i = this.scopeStack.length - 1; i >= 0; --i) {
 	        scope = this.scopeStack[i];
 	        this.checkRedeclarationInScope(scope, name, bindingType, loc);
-	        scope.var.add(name);
+	        scope.names.set(name, (scope.names.get(name) || 0) | 1);
 	        this.maybeExportDefined(scope, name);
 	        if (scope.flags & 387) break;
 	      }
@@ -23166,8 +23199,7 @@ function requireLib () {
 	  }
 	  checkRedeclarationInScope(scope, name, bindingType, loc) {
 	    if (this.isRedeclaredInScope(scope, name, bindingType)) {
-	      this.parser.raise(Errors.VarRedeclaration, {
-	        at: loc,
+	      this.parser.raise(Errors.VarRedeclaration, loc, {
 	        identifierName: name
 	      });
 	    }
@@ -23175,19 +23207,20 @@ function requireLib () {
 	  isRedeclaredInScope(scope, name, bindingType) {
 	    if (!(bindingType & 1)) return false;
 	    if (bindingType & 8) {
-	      return scope.lexical.has(name) || scope.functions.has(name) || scope.var.has(name);
+	      return scope.names.has(name);
 	    }
+	    const type = scope.names.get(name);
 	    if (bindingType & 16) {
-	      return scope.lexical.has(name) || !this.treatFunctionsAsVarInScope(scope) && scope.var.has(name);
+	      return (type & 2) > 0 || !this.treatFunctionsAsVarInScope(scope) && (type & 1) > 0;
 	    }
-	    return scope.lexical.has(name) && !(scope.flags & 8 && scope.lexical.values().next().value === name) || !this.treatFunctionsAsVarInScope(scope) && scope.functions.has(name);
+	    return (type & 2) > 0 && !(scope.flags & 8 && scope.firstLexicalName === name) || !this.treatFunctionsAsVarInScope(scope) && (type & 4) > 0;
 	  }
 	  checkLocalExport(id) {
 	    const {
 	      name
 	    } = id;
 	    const topLevelScope = this.scopeStack[0];
-	    if (!topLevelScope.lexical.has(name) && !topLevelScope.var.has(name) && !topLevelScope.functions.has(name)) {
+	    if (!topLevelScope.names.has(name)) {
 	      this.undefinedExports.set(name, id.loc.start);
 	    }
 	  }
@@ -23237,8 +23270,9 @@ function requireLib () {
 	  }
 	  isRedeclaredInScope(scope, name, bindingType) {
 	    if (super.isRedeclaredInScope(scope, name, bindingType)) return true;
-	    if (bindingType & 2048) {
-	      return !scope.declareFunctions.has(name) && (scope.lexical.has(name) || scope.functions.has(name));
+	    if (bindingType & 2048 && !scope.declareFunctions.has(name)) {
+	      const type = scope.names.get(name);
+	      return (type & 4) > 0 || (type & 2) > 0;
 	    }
 	    return false;
 	  }
@@ -23311,7 +23345,12 @@ function requireLib () {
 	class CommentsParser extends BaseParser {
 	  addComment(comment) {
 	    if (this.filename) comment.loc.filename = this.filename;
-	    this.state.comments.push(comment);
+	    const {
+	      commentsLen
+	    } = this.state;
+	    if (this.comments.length != commentsLen) this.comments.length = commentsLen;
+	    this.comments.push(comment);
+	    this.state.commentsLen++;
 	  }
 	  processComment(node) {
 	    const {
@@ -23500,7 +23539,7 @@ function requireLib () {
 	}
 	class State {
 	  constructor() {
-	    this.strict = void 0;
+	    this.flags = 1024;
 	    this.curLine = void 0;
 	    this.lineStart = void 0;
 	    this.startLoc = void 0;
@@ -23509,21 +23548,12 @@ function requireLib () {
 	    this.potentialArrowAt = -1;
 	    this.noArrowAt = [];
 	    this.noArrowParamsConversionAt = [];
-	    this.maybeInArrowParameters = false;
-	    this.inType = false;
-	    this.noAnonFunctionType = false;
-	    this.hasFlowComment = false;
-	    this.isAmbientContext = false;
-	    this.inAbstractClass = false;
-	    this.inDisallowConditionalTypesContext = false;
 	    this.topicContext = {
 	      maxNumOfResolvableTopics: 0,
 	      maxTopicIndex: null
 	    };
-	    this.soloAwait = false;
-	    this.inFSharpPipelineDirectBody = false;
 	    this.labels = [];
-	    this.comments = [];
+	    this.commentsLen = 0;
 	    this.commentStack = [];
 	    this.pos = 0;
 	    this.type = 139;
@@ -23532,14 +23562,21 @@ function requireLib () {
 	    this.end = 0;
 	    this.lastTokEndLoc = null;
 	    this.lastTokStartLoc = null;
-	    this.lastTokStart = 0;
 	    this.context = [types.brace];
-	    this.canStartJSXElement = true;
-	    this.containsEsc = false;
 	    this.firstInvalidTemplateEscapePos = null;
 	    this.strictErrors = new Map();
 	    this.tokensLength = 0;
 	  }
+	  get strict() {
+	    return (this.flags & 1) > 0;
+	  }
+	  set strict(value) {
+	    if (value) {
+	      this.flags |= 1;
+	    } else {
+	      this.flags &= ~1;
+	    }
+	  }
 	  init({
 	    strictMode,
 	    sourceType,
@@ -23551,20 +23588,145 @@ function requireLib () {
 	    this.lineStart = -startColumn;
 	    this.startLoc = this.endLoc = new Position(startLine, startColumn, 0);
 	  }
+	  get maybeInArrowParameters() {
+	    return (this.flags & 2) > 0;
+	  }
+	  set maybeInArrowParameters(value) {
+	    if (value) {
+	      this.flags |= 2;
+	    } else {
+	      this.flags &= ~2;
+	    }
+	  }
+	  get inType() {
+	    return (this.flags & 4) > 0;
+	  }
+	  set inType(value) {
+	    if (value) {
+	      this.flags |= 4;
+	    } else {
+	      this.flags &= ~4;
+	    }
+	  }
+	  get noAnonFunctionType() {
+	    return (this.flags & 8) > 0;
+	  }
+	  set noAnonFunctionType(value) {
+	    if (value) {
+	      this.flags |= 8;
+	    } else {
+	      this.flags &= ~8;
+	    }
+	  }
+	  get hasFlowComment() {
+	    return (this.flags & 16) > 0;
+	  }
+	  set hasFlowComment(value) {
+	    if (value) {
+	      this.flags |= 16;
+	    } else {
+	      this.flags &= ~16;
+	    }
+	  }
+	  get isAmbientContext() {
+	    return (this.flags & 32) > 0;
+	  }
+	  set isAmbientContext(value) {
+	    if (value) {
+	      this.flags |= 32;
+	    } else {
+	      this.flags &= ~32;
+	    }
+	  }
+	  get inAbstractClass() {
+	    return (this.flags & 64) > 0;
+	  }
+	  set inAbstractClass(value) {
+	    if (value) {
+	      this.flags |= 64;
+	    } else {
+	      this.flags &= ~64;
+	    }
+	  }
+	  get inDisallowConditionalTypesContext() {
+	    return (this.flags & 128) > 0;
+	  }
+	  set inDisallowConditionalTypesContext(value) {
+	    if (value) {
+	      this.flags |= 128;
+	    } else {
+	      this.flags &= ~128;
+	    }
+	  }
+	  get soloAwait() {
+	    return (this.flags & 256) > 0;
+	  }
+	  set soloAwait(value) {
+	    if (value) {
+	      this.flags |= 256;
+	    } else {
+	      this.flags &= ~256;
+	    }
+	  }
+	  get inFSharpPipelineDirectBody() {
+	    return (this.flags & 512) > 0;
+	  }
+	  set inFSharpPipelineDirectBody(value) {
+	    if (value) {
+	      this.flags |= 512;
+	    } else {
+	      this.flags &= ~512;
+	    }
+	  }
+	  get canStartJSXElement() {
+	    return (this.flags & 1024) > 0;
+	  }
+	  set canStartJSXElement(value) {
+	    if (value) {
+	      this.flags |= 1024;
+	    } else {
+	      this.flags &= ~1024;
+	    }
+	  }
+	  get containsEsc() {
+	    return (this.flags & 2048) > 0;
+	  }
+	  set containsEsc(value) {
+	    if (value) {
+	      this.flags |= 2048;
+	    } else {
+	      this.flags &= ~2048;
+	    }
+	  }
 	  curPosition() {
 	    return new Position(this.curLine, this.pos - this.lineStart, this.pos);
 	  }
-	  clone(skipArrays) {
+	  clone() {
 	    const state = new State();
-	    const keys = Object.keys(this);
-	    for (let i = 0, length = keys.length; i < length; i++) {
-	      const key = keys[i];
-	      let val = this[key];
-	      if (!skipArrays && Array.isArray(val)) {
-	        val = val.slice();
-	      }
-	      state[key] = val;
-	    }
+	    state.flags = this.flags;
+	    state.curLine = this.curLine;
+	    state.lineStart = this.lineStart;
+	    state.startLoc = this.startLoc;
+	    state.endLoc = this.endLoc;
+	    state.errors = this.errors.slice();
+	    state.potentialArrowAt = this.potentialArrowAt;
+	    state.noArrowAt = this.noArrowAt.slice();
+	    state.noArrowParamsConversionAt = this.noArrowParamsConversionAt.slice();
+	    state.topicContext = this.topicContext;
+	    state.labels = this.labels.slice();
+	    state.commentsLen = this.commentsLen;
+	    state.commentStack = this.commentStack.slice();
+	    state.pos = this.pos;
+	    state.type = this.type;
+	    state.value = this.value;
+	    state.start = this.start;
+	    state.end = this.end;
+	    state.lastTokEndLoc = this.lastTokEndLoc;
+	    state.lastTokStartLoc = this.lastTokStartLoc;
+	    state.context = this.context.slice();
+	    state.firstInvalidTemplateEscapePos = this.firstInvalidTemplateEscapePos;
+	    state.strictErrors = this.strictErrors;
+	    state.tokensLength = this.tokensLength;
 	    return state;
 	  }
 	}
@@ -23853,8 +24015,6 @@ function requireLib () {
 	    pos
 	  };
 	}
-	const _excluded = ["at"],
-	  _excluded2 = ["at"];
 	function buildPosition(pos, lineStart, curLine) {
 	  return new Position(curLine, pos - lineStart, pos);
 	}
@@ -23876,8 +24036,7 @@ function requireLib () {
 	    this.errorHandlers_readInt = {
 	      invalidDigit: (pos, lineStart, curLine, radix) => {
 	        if (!this.options.errorRecovery) return false;
-	        this.raise(Errors.InvalidDigit, {
-	          at: buildPosition(pos, lineStart, curLine),
+	        this.raise(Errors.InvalidDigit, buildPosition(pos, lineStart, curLine), {
 	          radix
 	        });
 	        return true;
@@ -23891,28 +24050,23 @@ function requireLib () {
 	    });
 	    this.errorHandlers_readStringContents_string = Object.assign({}, this.errorHandlers_readCodePoint, {
 	      strictNumericEscape: (pos, lineStart, curLine) => {
-	        this.recordStrictModeErrors(Errors.StrictNumericEscape, {
-	          at: buildPosition(pos, lineStart, curLine)
-	        });
+	        this.recordStrictModeErrors(Errors.StrictNumericEscape, buildPosition(pos, lineStart, curLine));
 	      },
 	      unterminated: (pos, lineStart, curLine) => {
-	        throw this.raise(Errors.UnterminatedString, {
-	          at: buildPosition(pos - 1, lineStart, curLine)
-	        });
+	        throw this.raise(Errors.UnterminatedString, buildPosition(pos - 1, lineStart, curLine));
 	      }
 	    });
 	    this.errorHandlers_readStringContents_template = Object.assign({}, this.errorHandlers_readCodePoint, {
 	      strictNumericEscape: this.errorBuilder(Errors.StrictNumericEscape),
 	      unterminated: (pos, lineStart, curLine) => {
-	        throw this.raise(Errors.UnterminatedTemplate, {
-	          at: buildPosition(pos, lineStart, curLine)
-	        });
+	        throw this.raise(Errors.UnterminatedTemplate, buildPosition(pos, lineStart, curLine));
 	      }
 	    });
 	    this.state = new State();
 	    this.state.init(options);
 	    this.input = input;
 	    this.length = input.length;
+	    this.comments = [];
 	    this.isLookahead = false;
 	  }
 	  pushToken(token) {
@@ -23925,7 +24079,6 @@ function requireLib () {
 	    if (this.options.tokens) {
 	      this.pushToken(new Token(this.state));
 	    }
-	    this.state.lastTokStart = this.state.start;
 	    this.state.lastTokEndLoc = this.state.endLoc;
 	    this.state.lastTokStartLoc = this.state.startLoc;
 	    this.nextToken();
@@ -24000,9 +24153,7 @@ function requireLib () {
 	  setStrict(strict) {
 	    this.state.strict = strict;
 	    if (strict) {
-	      this.state.strictErrors.forEach(([toParseError, at]) => this.raise(toParseError, {
-	        at
-	      }));
+	      this.state.strictErrors.forEach(([toParseError, at]) => this.raise(toParseError, at));
 	      this.state.strictErrors.clear();
 	    }
 	  }
@@ -24025,9 +24176,7 @@ function requireLib () {
 	    const start = this.state.pos;
 	    const end = this.input.indexOf(commentEnd, start + 2);
 	    if (end === -1) {
-	      throw this.raise(Errors.UnterminatedComment, {
-	        at: this.state.curPosition()
-	      });
+	      throw this.raise(Errors.UnterminatedComment, this.state.curPosition());
 	    }
 	    this.state.pos = end + commentEnd.length;
 	    lineBreakG.lastIndex = start + 2;
@@ -24179,16 +24328,12 @@ function requireLib () {
 	    const nextPos = this.state.pos + 1;
 	    const next = this.codePointAtPos(nextPos);
 	    if (next >= 48 && next <= 57) {
-	      throw this.raise(Errors.UnexpectedDigitAfterHash, {
-	        at: this.state.curPosition()
-	      });
+	      throw this.raise(Errors.UnexpectedDigitAfterHash, this.state.curPosition());
 	    }
 	    if (next === 123 || next === 91 && this.hasPlugin("recordAndTuple")) {
 	      this.expectPlugin("recordAndTuple");
 	      if (this.getPluginOption("recordAndTuple", "syntaxType") === "bar") {
-	        throw this.raise(next === 123 ? Errors.RecordExpressionHashIncorrectStartSyntaxType : Errors.TupleExpressionHashIncorrectStartSyntaxType, {
-	          at: this.state.curPosition()
-	        });
+	        throw this.raise(next === 123 ? Errors.RecordExpressionHashIncorrectStartSyntaxType : Errors.TupleExpressionHashIncorrectStartSyntaxType, this.state.curPosition());
 	      }
 	      this.state.pos += 2;
 	      if (next === 123) {
@@ -24273,9 +24418,7 @@ function requireLib () {
 	      }
 	      if (this.hasPlugin("recordAndTuple") && next === 125) {
 	        if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") {
-	          throw this.raise(Errors.RecordExpressionBarIncorrectEndSyntaxType, {
-	            at: this.state.curPosition()
-	          });
+	          throw this.raise(Errors.RecordExpressionBarIncorrectEndSyntaxType, this.state.curPosition());
 	        }
 	        this.state.pos += 2;
 	        this.finishToken(9);
@@ -24283,9 +24426,7 @@ function requireLib () {
 	      }
 	      if (this.hasPlugin("recordAndTuple") && next === 93) {
 	        if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") {
-	          throw this.raise(Errors.TupleExpressionBarIncorrectEndSyntaxType, {
-	            at: this.state.curPosition()
-	          });
+	          throw this.raise(Errors.TupleExpressionBarIncorrectEndSyntaxType, this.state.curPosition());
 	        }
 	        this.state.pos += 2;
 	        this.finishToken(4);
@@ -24431,9 +24572,7 @@ function requireLib () {
 	      case 91:
 	        if (this.hasPlugin("recordAndTuple") && this.input.charCodeAt(this.state.pos + 1) === 124) {
 	          if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") {
-	            throw this.raise(Errors.TupleExpressionBarIncorrectStartSyntaxType, {
-	              at: this.state.curPosition()
-	            });
+	            throw this.raise(Errors.TupleExpressionBarIncorrectStartSyntaxType, this.state.curPosition());
 	          }
 	          this.state.pos += 2;
 	          this.finishToken(2);
@@ -24449,9 +24588,7 @@ function requireLib () {
 	      case 123:
 	        if (this.hasPlugin("recordAndTuple") && this.input.charCodeAt(this.state.pos + 1) === 124) {
 	          if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") {
-	            throw this.raise(Errors.RecordExpressionBarIncorrectStartSyntaxType, {
-	              at: this.state.curPosition()
-	            });
+	            throw this.raise(Errors.RecordExpressionBarIncorrectStartSyntaxType, this.state.curPosition());
 	          }
 	          this.state.pos += 2;
 	          this.finishToken(6);
@@ -24555,8 +24692,7 @@ function requireLib () {
 	          return;
 	        }
 	    }
-	    throw this.raise(Errors.InvalidOrUnexpectedToken, {
-	      at: this.state.curPosition(),
+	    throw this.raise(Errors.InvalidOrUnexpectedToken, this.state.curPosition(), {
 	      unexpected: String.fromCodePoint(code)
 	    });
 	  }
@@ -24574,15 +24710,11 @@ function requireLib () {
 	    } = this.state;
 	    for (;; ++pos) {
 	      if (pos >= this.length) {
-	        throw this.raise(Errors.UnterminatedRegExp, {
-	          at: createPositionWithColumnOffset(startLoc, 1)
-	        });
+	        throw this.raise(Errors.UnterminatedRegExp, createPositionWithColumnOffset(startLoc, 1));
 	      }
 	      const ch = this.input.charCodeAt(pos);
 	      if (isNewLine(ch)) {
-	        throw this.raise(Errors.UnterminatedRegExp, {
-	          at: createPositionWithColumnOffset(startLoc, 1)
-	        });
+	        throw this.raise(Errors.UnterminatedRegExp, createPositionWithColumnOffset(startLoc, 1));
 	      }
 	      if (escaped) {
 	        escaped = false;
@@ -24607,26 +24739,18 @@ function requireLib () {
 	      if (VALID_REGEX_FLAGS.has(cp)) {
 	        if (cp === 118) {
 	          if (mods.includes("u")) {
-	            this.raise(Errors.IncompatibleRegExpUVFlags, {
-	              at: nextPos()
-	            });
+	            this.raise(Errors.IncompatibleRegExpUVFlags, nextPos());
 	          }
 	        } else if (cp === 117) {
 	          if (mods.includes("v")) {
-	            this.raise(Errors.IncompatibleRegExpUVFlags, {
-	              at: nextPos()
-	            });
+	            this.raise(Errors.IncompatibleRegExpUVFlags, nextPos());
 	          }
 	        }
 	        if (mods.includes(char)) {
-	          this.raise(Errors.DuplicateRegExpFlags, {
-	            at: nextPos()
-	          });
+	          this.raise(Errors.DuplicateRegExpFlags, nextPos());
 	        }
 	      } else if (isIdentifierChar(cp) || cp === 92) {
-	        this.raise(Errors.MalformedRegExpFlags, {
-	          at: nextPos()
-	        });
+	        this.raise(Errors.MalformedRegExpFlags, nextPos());
 	      } else {
 	        break;
 	      }
@@ -24653,8 +24777,7 @@ function requireLib () {
 	    this.state.pos += 2;
 	    const val = this.readInt(radix);
 	    if (val == null) {
-	      this.raise(Errors.InvalidDigit, {
-	        at: createPositionWithColumnOffset(startLoc, 2),
+	      this.raise(Errors.InvalidDigit, createPositionWithColumnOffset(startLoc, 2), {
 	        radix
 	      });
 	    }
@@ -24663,14 +24786,10 @@ function requireLib () {
 	      ++this.state.pos;
 	      isBigInt = true;
 	    } else if (next === 109) {
-	      throw this.raise(Errors.InvalidDecimal, {
-	        at: startLoc
-	      });
+	      throw this.raise(Errors.InvalidDecimal, startLoc);
 	    }
 	    if (isIdentifierStart(this.codePointAtPos(this.state.pos))) {
-	      throw this.raise(Errors.NumberIdentifier, {
-	        at: this.state.curPosition()
-	      });
+	      throw this.raise(Errors.NumberIdentifier, this.state.curPosition());
 	    }
 	    if (isBigInt) {
 	      const str = this.input.slice(startLoc.index, this.state.pos).replace(/[_n]/g, "");
@@ -24688,22 +24807,16 @@ function requireLib () {
 	    let hasExponent = false;
 	    let isOctal = false;
 	    if (!startsWithDot && this.readInt(10) === null) {
-	      this.raise(Errors.InvalidNumber, {
-	        at: this.state.curPosition()
-	      });
+	      this.raise(Errors.InvalidNumber, this.state.curPosition());
 	    }
 	    const hasLeadingZero = this.state.pos - start >= 2 && this.input.charCodeAt(start) === 48;
 	    if (hasLeadingZero) {
 	      const integer = this.input.slice(start, this.state.pos);
-	      this.recordStrictModeErrors(Errors.StrictOctalLiteral, {
-	        at: startLoc
-	      });
+	      this.recordStrictModeErrors(Errors.StrictOctalLiteral, startLoc);
 	      if (!this.state.strict) {
 	        const underscorePos = integer.indexOf("_");
 	        if (underscorePos > 0) {
-	          this.raise(Errors.ZeroDigitNumericSeparator, {
-	            at: createPositionWithColumnOffset(startLoc, underscorePos)
-	          });
+	          this.raise(Errors.ZeroDigitNumericSeparator, createPositionWithColumnOffset(startLoc, underscorePos));
 	        }
 	      }
 	      isOctal = hasLeadingZero && !/[89]/.test(integer);
@@ -24721,9 +24834,7 @@ function requireLib () {
 	        ++this.state.pos;
 	      }
 	      if (this.readInt(10) === null) {
-	        this.raise(Errors.InvalidOrMissingExponent, {
-	          at: startLoc
-	        });
+	        this.raise(Errors.InvalidOrMissingExponent, startLoc);
 	      }
 	      isFloat = true;
 	      hasExponent = true;
@@ -24731,9 +24842,7 @@ function requireLib () {
 	    }
 	    if (next === 110) {
 	      if (isFloat || hasLeadingZero) {
-	        this.raise(Errors.InvalidBigIntLiteral, {
-	          at: startLoc
-	        });
+	        this.raise(Errors.InvalidBigIntLiteral, startLoc);
 	      }
 	      ++this.state.pos;
 	      isBigInt = true;
@@ -24741,17 +24850,13 @@ function requireLib () {
 	    if (next === 109) {
 	      this.expectPlugin("decimal", this.state.curPosition());
 	      if (hasExponent || hasLeadingZero) {
-	        this.raise(Errors.InvalidDecimal, {
-	          at: startLoc
-	        });
+	        this.raise(Errors.InvalidDecimal, startLoc);
 	      }
 	      ++this.state.pos;
 	      isDecimal = true;
 	    }
 	    if (isIdentifierStart(this.codePointAtPos(this.state.pos))) {
-	      throw this.raise(Errors.NumberIdentifier, {
-	        at: this.state.curPosition()
-	      });
+	      throw this.raise(Errors.NumberIdentifier, this.state.curPosition());
 	    }
 	    const str = this.input.slice(start, this.state.pos).replace(/[_mn]/g, "");
 	    if (isBigInt) {
@@ -24814,14 +24919,10 @@ function requireLib () {
 	      this.finishToken(25, firstInvalidLoc ? null : opening + str + "${");
 	    }
 	  }
-	  recordStrictModeErrors(toParseError, {
-	    at
-	  }) {
+	  recordStrictModeErrors(toParseError, at) {
 	    const index = at.index;
 	    if (this.state.strict && !this.state.strictErrors.has(index)) {
-	      this.raise(toParseError, {
-	        at
-	      });
+	      this.raise(toParseError, at);
 	    } else {
 	      this.state.strictErrors.set(index, [toParseError, at]);
 	    }
@@ -24844,9 +24945,7 @@ function requireLib () {
 	        const escStart = this.state.curPosition();
 	        const identifierCheck = this.state.pos === start ? isIdentifierStart : isIdentifierChar;
 	        if (this.input.charCodeAt(++this.state.pos) !== 117) {
-	          this.raise(Errors.MissingUnicodeEscape, {
-	            at: this.state.curPosition()
-	          });
+	          this.raise(Errors.MissingUnicodeEscape, this.state.curPosition());
 	          chunkStart = this.state.pos - 1;
 	          continue;
 	        }
@@ -24854,9 +24953,7 @@ function requireLib () {
 	        const esc = this.readCodePoint(true);
 	        if (esc !== null) {
 	          if (!identifierCheck(esc)) {
-	            this.raise(Errors.EscapedCharNotAnIdentifier, {
-	              at: escStart
-	            });
+	            this.raise(Errors.EscapedCharNotAnIdentifier, escStart);
 	          }
 	          word += String.fromCodePoint(esc);
 	        }
@@ -24881,75 +24978,55 @@ function requireLib () {
 	      type
 	    } = this.state;
 	    if (tokenIsKeyword(type) && this.state.containsEsc) {
-	      this.raise(Errors.InvalidEscapedReservedWord, {
-	        at: this.state.startLoc,
+	      this.raise(Errors.InvalidEscapedReservedWord, this.state.startLoc, {
 	        reservedWord: tokenLabelName(type)
 	      });
 	    }
 	  }
-	  raise(toParseError, raiseProperties) {
-	    const {
-	        at
-	      } = raiseProperties,
-	      details = _objectWithoutPropertiesLoose(raiseProperties, _excluded);
+	  raise(toParseError, at, details = {}) {
 	    const loc = at instanceof Position ? at : at.loc.start;
-	    const error = toParseError({
-	      loc,
-	      details
-	    });
+	    const error = toParseError(loc, details);
 	    if (!this.options.errorRecovery) throw error;
 	    if (!this.isLookahead) this.state.errors.push(error);
 	    return error;
 	  }
-	  raiseOverwrite(toParseError, raiseProperties) {
-	    const {
-	        at
-	      } = raiseProperties,
-	      details = _objectWithoutPropertiesLoose(raiseProperties, _excluded2);
+	  raiseOverwrite(toParseError, at, details = {}) {
 	    const loc = at instanceof Position ? at : at.loc.start;
 	    const pos = loc.index;
 	    const errors = this.state.errors;
 	    for (let i = errors.length - 1; i >= 0; i--) {
 	      const error = errors[i];
 	      if (error.loc.index === pos) {
-	        return errors[i] = toParseError({
-	          loc,
-	          details
-	        });
+	        return errors[i] = toParseError(loc, details);
 	      }
 	      if (error.loc.index < pos) break;
 	    }
-	    return this.raise(toParseError, raiseProperties);
+	    return this.raise(toParseError, at, details);
 	  }
 	  updateContext(prevType) {}
 	  unexpected(loc, type) {
-	    throw this.raise(Errors.UnexpectedToken, {
-	      expected: type ? tokenLabelName(type) : null,
-	      at: loc != null ? loc : this.state.startLoc
+	    throw this.raise(Errors.UnexpectedToken, loc != null ? loc : this.state.startLoc, {
+	      expected: type ? tokenLabelName(type) : null
 	    });
 	  }
 	  expectPlugin(pluginName, loc) {
 	    if (this.hasPlugin(pluginName)) {
 	      return true;
 	    }
-	    throw this.raise(Errors.MissingPlugin, {
-	      at: loc != null ? loc : this.state.startLoc,
+	    throw this.raise(Errors.MissingPlugin, loc != null ? loc : this.state.startLoc, {
 	      missingPlugin: [pluginName]
 	    });
 	  }
 	  expectOnePlugin(pluginNames) {
 	    if (!pluginNames.some(name => this.hasPlugin(name))) {
-	      throw this.raise(Errors.MissingOneOfPlugins, {
-	        at: this.state.startLoc,
+	      throw this.raise(Errors.MissingOneOfPlugins, this.state.startLoc, {
 	        missingPlugin: pluginNames
 	      });
 	    }
 	  }
 	  errorBuilder(error) {
 	    return (pos, lineStart, curLine) => {
-	      this.raise(error, {
-	        at: buildPosition(pos, lineStart, curLine)
-	      });
+	      this.raise(error, buildPosition(pos, lineStart, curLine));
 	    };
 	  }
 	}
@@ -24982,8 +25059,7 @@ function requireLib () {
 	          current.undefinedPrivateNames.set(name, loc);
 	        }
 	      } else {
-	        this.parser.raise(Errors.InvalidPrivateFieldResolution, {
-	          at: loc,
+	        this.parser.raise(Errors.InvalidPrivateFieldResolution, loc, {
 	          identifierName: name
 	        });
 	      }
@@ -25010,8 +25086,7 @@ function requireLib () {
 	      }
 	    }
 	    if (redefined) {
-	      this.parser.raise(Errors.PrivateNameRedeclaration, {
-	        at: loc,
+	      this.parser.raise(Errors.PrivateNameRedeclaration, loc, {
 	        identifierName: name
 	      });
 	    }
@@ -25026,8 +25101,7 @@ function requireLib () {
 	    if (classScope) {
 	      classScope.undefinedPrivateNames.set(name, loc);
 	    } else {
-	      this.parser.raise(Errors.InvalidPrivateFieldResolution, {
-	        at: loc,
+	      this.parser.raise(Errors.InvalidPrivateFieldResolution, loc, {
 	        identifierName: name
 	      });
 	    }
@@ -25049,9 +25123,7 @@ function requireLib () {
 	    super(type);
 	    this.declarationErrors = new Map();
 	  }
-	  recordDeclarationError(ParsingErrorClass, {
-	    at
-	  }) {
+	  recordDeclarationError(ParsingErrorClass, at) {
 	    const index = at.index;
 	    this.declarationErrors.set(index, [ParsingErrorClass, at]);
 	  }
@@ -25074,12 +25146,8 @@ function requireLib () {
 	  exit() {
 	    this.stack.pop();
 	  }
-	  recordParameterInitializerError(toParseError, {
-	    at: node
-	  }) {
-	    const origin = {
-	      at: node.loc.start
-	    };
+	  recordParameterInitializerError(toParseError, node) {
+	    const origin = node.loc.start;
 	    const {
 	      stack
 	    } = this;
@@ -25095,16 +25163,12 @@ function requireLib () {
 	    }
 	    this.parser.raise(toParseError, origin);
 	  }
-	  recordArrowParameterBindingError(error, {
-	    at: node
-	  }) {
+	  recordArrowParameterBindingError(error, node) {
 	    const {
 	      stack
 	    } = this;
 	    const scope = stack[stack.length - 1];
-	    const origin = {
-	      at: node.loc.start
-	    };
+	    const origin = node.loc.start;
 	    if (scope.isCertainlyParameterDeclaration()) {
 	      this.parser.raise(error, origin);
 	    } else if (scope.canBeArrowParameterDeclaration()) {
@@ -25113,9 +25177,7 @@ function requireLib () {
 	      return;
 	    }
 	  }
-	  recordAsyncArrowParametersError({
-	    at
-	  }) {
+	  recordAsyncArrowParametersError(at) {
 	    const {
 	      stack
 	    } = this;
@@ -25123,9 +25185,7 @@ function requireLib () {
 	    let scope = stack[i];
 	    while (scope.canBeArrowParameterDeclaration()) {
 	      if (scope.type === 2) {
-	        scope.recordDeclarationError(Errors.AwaitBindingIdentifier, {
-	          at
-	        });
+	        scope.recordDeclarationError(Errors.AwaitBindingIdentifier, at);
 	      }
 	      scope = stack[--i];
 	    }
@@ -25137,9 +25197,7 @@ function requireLib () {
 	    const currentScope = stack[stack.length - 1];
 	    if (!currentScope.canBeArrowParameterDeclaration()) return;
 	    currentScope.iterateErrors(([toParseError, loc]) => {
-	      this.parser.raise(toParseError, {
-	        at: loc
-	      });
+	      this.parser.raise(toParseError, loc);
 	      let i = stack.length - 2;
 	      let scope = stack[i];
 	      while (scope.canBeArrowParameterDeclaration()) {
@@ -25228,9 +25286,7 @@ function requireLib () {
 	  expectContextual(token, toParseError) {
 	    if (!this.eatContextual(token)) {
 	      if (toParseError != null) {
-	        throw this.raise(toParseError, {
-	          at: this.state.startLoc
-	        });
+	        throw this.raise(toParseError, this.state.startLoc);
 	      }
 	      this.unexpected(null, token);
 	    }
@@ -25250,9 +25306,7 @@ function requireLib () {
 	  }
 	  semicolon(allowAsi = true) {
 	    if (allowAsi ? this.isLineTerminator() : this.eat(13)) return;
-	    this.raise(Errors.MissingSemicolon, {
-	      at: this.state.lastTokEndLoc
-	    });
+	    this.raise(Errors.MissingSemicolon, this.state.lastTokEndLoc);
 	  }
 	  expect(type, loc) {
 	    this.eat(type) || this.unexpected(loc, type);
@@ -25322,19 +25376,13 @@ function requireLib () {
 	      return hasErrors;
 	    }
 	    if (shorthandAssignLoc != null) {
-	      this.raise(Errors.InvalidCoverInitializedName, {
-	        at: shorthandAssignLoc
-	      });
+	      this.raise(Errors.InvalidCoverInitializedName, shorthandAssignLoc);
 	    }
 	    if (doubleProtoLoc != null) {
-	      this.raise(Errors.DuplicateProto, {
-	        at: doubleProtoLoc
-	      });
+	      this.raise(Errors.DuplicateProto, doubleProtoLoc);
 	    }
 	    if (privateKeyLoc != null) {
-	      this.raise(Errors.UnexpectedPrivateField, {
-	        at: privateKeyLoc
-	      });
+	      this.raise(Errors.UnexpectedPrivateField, privateKeyLoc);
 	    }
 	    if (optionalParametersLoc != null) {
 	      this.unexpected(optionalParametersLoc);
@@ -25487,7 +25535,8 @@ function requireLib () {
 	}
 	class NodeUtils extends UtilParser {
 	  startNode() {
-	    return new Node(this, this.state.start, this.state.startLoc);
+	    const loc = this.state.startLoc;
+	    return new Node(this, loc.index, loc);
 	  }
 	  startNodeAt(loc) {
 	    return new Node(this, loc.index, loc);
@@ -25683,10 +25732,8 @@ function requireLib () {
 	    const moduloLoc = this.state.startLoc;
 	    this.next();
 	    this.expectContextual(110);
-	    if (this.state.lastTokStart > moduloLoc.index + 1) {
-	      this.raise(FlowErrors.UnexpectedSpaceBetweenModuloChecks, {
-	        at: moduloLoc
-	      });
+	    if (this.state.lastTokStartLoc.index > moduloLoc.index + 1) {
+	      this.raise(FlowErrors.UnexpectedSpaceBetweenModuloChecks, moduloLoc);
 	    }
 	    if (this.eat(10)) {
 	      node.value = super.parseExpression();
@@ -25755,9 +25802,7 @@ function requireLib () {
 	        return this.flowParseDeclareModuleExports(node);
 	      } else {
 	        if (insideModule) {
-	          this.raise(FlowErrors.NestedDeclareModule, {
-	            at: this.state.lastTokStartLoc
-	          });
+	          this.raise(FlowErrors.NestedDeclareModule, this.state.lastTokStartLoc);
 	        }
 	        return this.flowParseDeclareModule(node);
 	      }
@@ -25795,9 +25840,7 @@ function requireLib () {
 	      if (this.match(83)) {
 	        this.next();
 	        if (!this.isContextual(130) && !this.match(87)) {
-	          this.raise(FlowErrors.InvalidNonTypeImportInDeclareModule, {
-	            at: this.state.lastTokStartLoc
-	          });
+	          this.raise(FlowErrors.InvalidNonTypeImportInDeclareModule, this.state.lastTokStartLoc);
 	        }
 	        super.parseImport(bodyNode);
 	      } else {
@@ -25814,21 +25857,15 @@ function requireLib () {
 	    body.forEach(bodyElement => {
 	      if (isEsModuleType(bodyElement)) {
 	        if (kind === "CommonJS") {
-	          this.raise(FlowErrors.AmbiguousDeclareModuleKind, {
-	            at: bodyElement
-	          });
+	          this.raise(FlowErrors.AmbiguousDeclareModuleKind, bodyElement);
 	        }
 	        kind = "ES";
 	      } else if (bodyElement.type === "DeclareModuleExports") {
 	        if (hasModuleExport) {
-	          this.raise(FlowErrors.DuplicateDeclareModuleExports, {
-	            at: bodyElement
-	          });
+	          this.raise(FlowErrors.DuplicateDeclareModuleExports, bodyElement);
 	        }
 	        if (kind === "ES") {
-	          this.raise(FlowErrors.AmbiguousDeclareModuleKind, {
-	            at: bodyElement
-	          });
+	          this.raise(FlowErrors.AmbiguousDeclareModuleKind, bodyElement);
 	        }
 	        kind = "CommonJS";
 	        hasModuleExport = true;
@@ -25851,8 +25888,7 @@ function requireLib () {
 	    } else {
 	      if (this.match(75) || this.isLet() || (this.isContextual(130) || this.isContextual(129)) && !insideModule) {
 	        const label = this.state.value;
-	        throw this.raise(FlowErrors.UnsupportedDeclareExportKind, {
-	          at: this.state.startLoc,
+	        throw this.raise(FlowErrors.UnsupportedDeclareExportKind, this.state.startLoc, {
 	          unsupportedExportKind: label,
 	          suggestion: exportSuggestions[label]
 	        });
@@ -25950,15 +25986,12 @@ function requireLib () {
 	  }
 	  checkNotUnderscore(word) {
 	    if (word === "_") {
-	      this.raise(FlowErrors.UnexpectedReservedUnderscore, {
-	        at: this.state.startLoc
-	      });
+	      this.raise(FlowErrors.UnexpectedReservedUnderscore, this.state.startLoc);
 	    }
 	  }
 	  checkReservedType(word, startLoc, declaration) {
 	    if (!reservedTypes.has(word)) return;
-	    this.raise(declaration ? FlowErrors.AssignReservedType : FlowErrors.UnexpectedReservedType, {
-	      at: startLoc,
+	    this.raise(declaration ? FlowErrors.AssignReservedType : FlowErrors.UnexpectedReservedType, startLoc, {
 	      reservedType: word
 	    });
 	  }
@@ -26011,9 +26044,7 @@ function requireLib () {
 	      node.default = this.flowParseType();
 	    } else {
 	      if (requireDefault) {
-	        this.raise(FlowErrors.MissingTypeParamDefault, {
-	          at: nodeStartLoc
-	        });
+	        this.raise(FlowErrors.MissingTypeParamDefault, nodeStartLoc);
 	      }
 	    }
 	    return this.finishNode(node, "TypeParameter");
@@ -26253,9 +26284,7 @@ function requireLib () {
 	      }
 	      this.flowObjectTypeSemicolon();
 	      if (inexactStartLoc && !this.match(8) && !this.match(9)) {
-	        this.raise(FlowErrors.UnexpectedExplicitInexactInObject, {
-	          at: inexactStartLoc
-	        });
+	        this.raise(FlowErrors.UnexpectedExplicitInexactInObject, inexactStartLoc);
 	      }
 	    }
 	    this.expect(endDelim);
@@ -26271,33 +26300,23 @@ function requireLib () {
 	      const isInexactToken = this.match(12) || this.match(13) || this.match(8) || this.match(9);
 	      if (isInexactToken) {
 	        if (!allowSpread) {
-	          this.raise(FlowErrors.InexactInsideNonObject, {
-	            at: this.state.lastTokStartLoc
-	          });
+	          this.raise(FlowErrors.InexactInsideNonObject, this.state.lastTokStartLoc);
 	        } else if (!allowInexact) {
-	          this.raise(FlowErrors.InexactInsideExact, {
-	            at: this.state.lastTokStartLoc
-	          });
+	          this.raise(FlowErrors.InexactInsideExact, this.state.lastTokStartLoc);
 	        }
 	        if (variance) {
-	          this.raise(FlowErrors.InexactVariance, {
-	            at: variance
-	          });
+	          this.raise(FlowErrors.InexactVariance, variance);
 	        }
 	        return null;
 	      }
 	      if (!allowSpread) {
-	        this.raise(FlowErrors.UnexpectedSpreadType, {
-	          at: this.state.lastTokStartLoc
-	        });
+	        this.raise(FlowErrors.UnexpectedSpreadType, this.state.lastTokStartLoc);
 	      }
 	      if (protoStartLoc != null) {
 	        this.unexpected(protoStartLoc);
 	      }
 	      if (variance) {
-	        this.raise(FlowErrors.SpreadVariance, {
-	          at: variance
-	        });
+	        this.raise(FlowErrors.SpreadVariance, variance);
 	      }
 	      node.argument = this.flowParseType();
 	      return this.finishNode(node, "ObjectTypeSpreadProperty");
@@ -26320,9 +26339,7 @@ function requireLib () {
 	          this.flowCheckGetterSetterParams(node);
 	        }
 	        if (!allowSpread && node.key.name === "constructor" && node.value.this) {
-	          this.raise(FlowErrors.ThisParamBannedInConstructor, {
-	            at: node.value.this
-	          });
+	          this.raise(FlowErrors.ThisParamBannedInConstructor, node.value.this);
 	        }
 	      } else {
 	        if (kind !== "init") this.unexpected();
@@ -26341,19 +26358,13 @@ function requireLib () {
 	    const paramCount = property.kind === "get" ? 0 : 1;
 	    const length = property.value.params.length + (property.value.rest ? 1 : 0);
 	    if (property.value.this) {
-	      this.raise(property.kind === "get" ? FlowErrors.GetterMayNotHaveThisParam : FlowErrors.SetterMayNotHaveThisParam, {
-	        at: property.value.this
-	      });
+	      this.raise(property.kind === "get" ? FlowErrors.GetterMayNotHaveThisParam : FlowErrors.SetterMayNotHaveThisParam, property.value.this);
 	    }
 	    if (length !== paramCount) {
-	      this.raise(property.kind === "get" ? Errors.BadGetterArity : Errors.BadSetterArity, {
-	        at: property
-	      });
+	      this.raise(property.kind === "get" ? Errors.BadGetterArity : Errors.BadSetterArity, property);
 	    }
 	    if (property.kind === "set" && property.value.rest) {
-	      this.raise(Errors.BadSetterRestParameter, {
-	        at: property
-	      });
+	      this.raise(Errors.BadSetterRestParameter, property);
 	    }
 	  }
 	  flowObjectTypeSemicolon() {
@@ -26409,17 +26420,13 @@ function requireLib () {
 	    const isThis = this.state.type === 78;
 	    if (lh.type === 14 || lh.type === 17) {
 	      if (isThis && !first) {
-	        this.raise(FlowErrors.ThisParamMustBeFirst, {
-	          at: node
-	        });
+	        this.raise(FlowErrors.ThisParamMustBeFirst, node);
 	      }
 	      name = this.parseIdentifier(isThis);
 	      if (this.eat(17)) {
 	        optional = true;
 	        if (isThis) {
-	          this.raise(FlowErrors.ThisParamMayNotBeOptional, {
-	            at: node
-	          });
+	          this.raise(FlowErrors.ThisParamMayNotBeOptional, node);
 	        }
 	      }
 	      typeAnnotation = this.flowParseTypeInitialiser();
@@ -26575,9 +26582,7 @@ function requireLib () {
 	          if (this.match(135)) {
 	            return this.parseLiteralAtNode(-this.state.value, "BigIntLiteralTypeAnnotation", node);
 	          }
-	          throw this.raise(FlowErrors.UnexpectedSubtractionOperand, {
-	            at: this.state.startLoc
-	          });
+	          throw this.raise(FlowErrors.UnexpectedSubtractionOperand, this.state.startLoc);
 	        }
 	        this.unexpected();
 	        return;
@@ -26841,9 +26846,7 @@ function requireLib () {
 	        [valid, invalid] = this.getArrowLikeExpressions(consequent);
 	      }
 	      if (failed && valid.length > 1) {
-	        this.raise(FlowErrors.AmbiguousConditionalArrow, {
-	          at: state.startLoc
-	        });
+	        this.raise(FlowErrors.AmbiguousConditionalArrow, state.startLoc);
 	      }
 	      if (failed && valid.length === 1) {
 	        this.state = state;
@@ -27004,13 +27007,9 @@ function requireLib () {
 	    super.parseClassMember(classBody, member, state);
 	    if (member.declare) {
 	      if (member.type !== "ClassProperty" && member.type !== "ClassPrivateProperty" && member.type !== "PropertyDefinition") {
-	        this.raise(FlowErrors.DeclareClassElement, {
-	          at: startLoc
-	        });
+	        this.raise(FlowErrors.DeclareClassElement, startLoc);
 	      } else if (member.value) {
-	        this.raise(FlowErrors.DeclareClassFieldInitializer, {
-	          at: member.value
-	        });
+	        this.raise(FlowErrors.DeclareClassFieldInitializer, member.value);
 	      }
 	    }
 	  }
@@ -27021,8 +27020,7 @@ function requireLib () {
 	    const word = super.readWord1();
 	    const fullWord = "@@" + word;
 	    if (!this.isIterator(word) || !this.state.inType) {
-	      this.raise(Errors.InvalidIdentifier, {
-	        at: this.state.curPosition(),
+	      this.raise(Errors.InvalidIdentifier, this.state.curPosition(), {
 	        identifierName: fullWord
 	      });
 	    }
@@ -27074,9 +27072,7 @@ function requireLib () {
 	      var _expr$extra;
 	      const expr = exprList[i];
 	      if (expr && expr.type === "TypeCastExpression" && !((_expr$extra = expr.extra) != null && _expr$extra.parenthesized) && (exprList.length > 1 || !isParenthesizedExpr)) {
-	        this.raise(FlowErrors.TypeCastInPattern, {
-	          at: expr.typeAnnotation
-	        });
+	        this.raise(FlowErrors.TypeCastInPattern, expr.typeAnnotation);
 	      }
 	    }
 	    return exprList;
@@ -27124,16 +27120,12 @@ function requireLib () {
 	    if (method.params && isConstructor) {
 	      const params = method.params;
 	      if (params.length > 0 && this.isThisParam(params[0])) {
-	        this.raise(FlowErrors.ThisParamBannedInConstructor, {
-	          at: method
-	        });
+	        this.raise(FlowErrors.ThisParamBannedInConstructor, method);
 	      }
 	    } else if (method.type === "MethodDefinition" && isConstructor && method.value.params) {
 	      const params = method.value.params;
 	      if (params.length > 0 && this.isThisParam(params[0])) {
-	        this.raise(FlowErrors.ThisParamBannedInConstructor, {
-	          at: method
-	        });
+	        this.raise(FlowErrors.ThisParamBannedInConstructor, method);
 	      }
 	    }
 	  }
@@ -27173,13 +27165,9 @@ function requireLib () {
 	    if (params.length > 0) {
 	      const param = params[0];
 	      if (this.isThisParam(param) && method.kind === "get") {
-	        this.raise(FlowErrors.GetterMayNotHaveThisParam, {
-	          at: param
-	        });
+	        this.raise(FlowErrors.GetterMayNotHaveThisParam, param);
 	      } else if (this.isThisParam(param)) {
-	        this.raise(FlowErrors.SetterMayNotHaveThisParam, {
-	          at: param
-	        });
+	        this.raise(FlowErrors.SetterMayNotHaveThisParam, param);
 	      }
 	    }
 	  }
@@ -27205,28 +27193,20 @@ function requireLib () {
 	  parseAssignableListItemTypes(param) {
 	    if (this.eat(17)) {
 	      if (param.type !== "Identifier") {
-	        this.raise(FlowErrors.PatternIsOptional, {
-	          at: param
-	        });
+	        this.raise(FlowErrors.PatternIsOptional, param);
 	      }
 	      if (this.isThisParam(param)) {
-	        this.raise(FlowErrors.ThisParamMayNotBeOptional, {
-	          at: param
-	        });
+	        this.raise(FlowErrors.ThisParamMayNotBeOptional, param);
 	      }
 	      param.optional = true;
 	    }
 	    if (this.match(14)) {
 	      param.typeAnnotation = this.flowParseTypeAnnotation();
 	    } else if (this.isThisParam(param)) {
-	      this.raise(FlowErrors.ThisParamAnnotationRequired, {
-	        at: param
-	      });
+	      this.raise(FlowErrors.ThisParamAnnotationRequired, param);
 	    }
 	    if (this.match(29) && this.isThisParam(param)) {
-	      this.raise(FlowErrors.ThisParamNoDefault, {
-	        at: param
-	      });
+	      this.raise(FlowErrors.ThisParamNoDefault, param);
 	    }
 	    this.resetEndLocation(param);
 	    return param;
@@ -27234,18 +27214,14 @@ function requireLib () {
 	  parseMaybeDefault(startLoc, left) {
 	    const node = super.parseMaybeDefault(startLoc, left);
 	    if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) {
-	      this.raise(FlowErrors.TypeBeforeInitializer, {
-	        at: node.typeAnnotation
-	      });
+	      this.raise(FlowErrors.TypeBeforeInitializer, node.typeAnnotation);
 	    }
 	    return node;
 	  }
 	  checkImportReflection(node) {
 	    super.checkImportReflection(node);
 	    if (node.module && node.importKind !== "value") {
-	      this.raise(FlowErrors.ImportReflectionHasImportType, {
-	        at: node.specifiers[0].loc.start
-	      });
+	      this.raise(FlowErrors.ImportReflectionHasImportType, node.specifiers[0].loc.start);
 	    }
 	  }
 	  parseImportSpecifierLocal(node, specifier, type) {
@@ -27301,8 +27277,7 @@ function requireLib () {
 	        specifier.importKind = specifierTypeKind;
 	      } else {
 	        if (importedIsString) {
-	          throw this.raise(Errors.ImportBindingIsString, {
-	            at: specifier,
+	          throw this.raise(Errors.ImportBindingIsString, specifier, {
 	            importName: firstIdent.value
 	          });
 	        }
@@ -27318,9 +27293,7 @@ function requireLib () {
 	    }
 	    const specifierIsTypeImport = hasTypeImportKind(specifier);
 	    if (isInTypeOnlyImport && specifierIsTypeImport) {
-	      this.raise(FlowErrors.ImportTypeShorthandOnlyInPureImport, {
-	        at: specifier
-	      });
+	      this.raise(FlowErrors.ImportTypeShorthandOnlyInPureImport, specifier);
 	    }
 	    if (isInTypeOnlyImport || specifierIsTypeImport) {
 	      this.checkReservedType(specifier.local.name, specifier.local.loc.start, true);
@@ -27403,9 +27376,7 @@ function requireLib () {
 	      if (arrow.node && this.maybeUnwrapTypeCastExpression(arrow.node).type === "ArrowFunctionExpression") {
 	        if (!arrow.error && !arrow.aborted) {
 	          if (arrow.node.async) {
-	            this.raise(FlowErrors.UnexpectedTypeParameterBeforeAsyncArrowFunction, {
-	              at: typeParameters
-	            });
+	            this.raise(FlowErrors.UnexpectedTypeParameterBeforeAsyncArrowFunction, typeParameters);
 	          }
 	          return arrow.node;
 	        }
@@ -27421,9 +27392,7 @@ function requireLib () {
 	      }
 	      if ((_jsx3 = jsx) != null && _jsx3.thrown) throw jsx.error;
 	      if (arrow.thrown) throw arrow.error;
-	      throw this.raise(FlowErrors.UnexpectedTokenAfterTypeParameter, {
-	        at: typeParameters
-	      });
+	      throw this.raise(FlowErrors.UnexpectedTokenAfterTypeParameter, typeParameters);
 	    }
 	    return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
 	  }
@@ -27461,9 +27430,7 @@ function requireLib () {
 	    }
 	    for (let i = 0; i < node.params.length; i++) {
 	      if (this.isThisParam(node.params[i]) && i > 0) {
-	        this.raise(FlowErrors.ThisParamMustBeFirst, {
-	          at: node.params[i]
-	        });
+	        this.raise(FlowErrors.ThisParamMustBeFirst, node.params[i]);
 	      }
 	    }
 	    super.checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged);
@@ -27565,18 +27532,14 @@ function requireLib () {
 	  parseTopLevel(file, program) {
 	    const fileNode = super.parseTopLevel(file, program);
 	    if (this.state.hasFlowComment) {
-	      this.raise(FlowErrors.UnterminatedFlowComment, {
-	        at: this.state.curPosition()
-	      });
+	      this.raise(FlowErrors.UnterminatedFlowComment, this.state.curPosition());
 	    }
 	    return fileNode;
 	  }
 	  skipBlockComment() {
 	    if (this.hasPlugin("flowComments") && this.skipFlowComment()) {
 	      if (this.state.hasFlowComment) {
-	        throw this.raise(FlowErrors.NestedFlowComment, {
-	          at: this.state.startLoc
-	        });
+	        throw this.raise(FlowErrors.NestedFlowComment, this.state.startLoc);
 	      }
 	      this.hasFlowCommentCompletion();
 	      const commentSkip = this.skipFlowComment();
@@ -27612,43 +27575,26 @@ function requireLib () {
 	  hasFlowCommentCompletion() {
 	    const end = this.input.indexOf("*/", this.state.pos);
 	    if (end === -1) {
-	      throw this.raise(Errors.UnterminatedComment, {
-	        at: this.state.curPosition()
-	      });
+	      throw this.raise(Errors.UnterminatedComment, this.state.curPosition());
 	    }
 	  }
 	  flowEnumErrorBooleanMemberNotInitialized(loc, {
 	    enumName,
 	    memberName
 	  }) {
-	    this.raise(FlowErrors.EnumBooleanMemberNotInitialized, {
-	      at: loc,
+	    this.raise(FlowErrors.EnumBooleanMemberNotInitialized, loc, {
 	      memberName,
 	      enumName
 	    });
 	  }
 	  flowEnumErrorInvalidMemberInitializer(loc, enumContext) {
-	    return this.raise(!enumContext.explicitType ? FlowErrors.EnumInvalidMemberInitializerUnknownType : enumContext.explicitType === "symbol" ? FlowErrors.EnumInvalidMemberInitializerSymbolType : FlowErrors.EnumInvalidMemberInitializerPrimaryType, Object.assign({
-	      at: loc
-	    }, enumContext));
+	    return this.raise(!enumContext.explicitType ? FlowErrors.EnumInvalidMemberInitializerUnknownType : enumContext.explicitType === "symbol" ? FlowErrors.EnumInvalidMemberInitializerSymbolType : FlowErrors.EnumInvalidMemberInitializerPrimaryType, loc, enumContext);
 	  }
-	  flowEnumErrorNumberMemberNotInitialized(loc, {
-	    enumName,
-	    memberName
-	  }) {
-	    this.raise(FlowErrors.EnumNumberMemberNotInitialized, {
-	      at: loc,
-	      enumName,
-	      memberName
-	    });
+	  flowEnumErrorNumberMemberNotInitialized(loc, details) {
+	    this.raise(FlowErrors.EnumNumberMemberNotInitialized, loc, details);
 	  }
-	  flowEnumErrorStringMemberInconsistentlyInitialized(node, {
-	    enumName
-	  }) {
-	    this.raise(FlowErrors.EnumStringMemberInconsistentlyInitialized, {
-	      at: node,
-	      enumName
-	    });
+	  flowEnumErrorStringMemberInconsistentlyInitialized(node, details) {
+	    this.raise(FlowErrors.EnumStringMemberInconsistentlyInitialized, node, details);
 	  }
 	  flowEnumMemberInit() {
 	    const startLoc = this.state.startLoc;
@@ -27757,16 +27703,14 @@ function requireLib () {
 	        continue;
 	      }
 	      if (/^[a-z]/.test(memberName)) {
-	        this.raise(FlowErrors.EnumInvalidMemberName, {
-	          at: id,
+	        this.raise(FlowErrors.EnumInvalidMemberName, id, {
 	          memberName,
 	          suggestion: memberName[0].toUpperCase() + memberName.slice(1),
 	          enumName
 	        });
 	      }
 	      if (seenNames.has(memberName)) {
-	        this.raise(FlowErrors.EnumDuplicateMemberName, {
-	          at: id,
+	        this.raise(FlowErrors.EnumDuplicateMemberName, id, {
 	          memberName,
 	          enumName
 	        });
@@ -27855,8 +27799,7 @@ function requireLib () {
 	  }) {
 	    if (!this.eatContextual(102)) return null;
 	    if (!tokenIsIdentifier(this.state.type)) {
-	      throw this.raise(FlowErrors.EnumInvalidExplicitTypeUnknownSupplied, {
-	        at: this.state.startLoc,
+	      throw this.raise(FlowErrors.EnumInvalidExplicitTypeUnknownSupplied, this.state.startLoc, {
 	        enumName
 	      });
 	    }
@@ -27865,8 +27808,7 @@ function requireLib () {
 	    } = this.state;
 	    this.next();
 	    if (value !== "boolean" && value !== "number" && value !== "string" && value !== "symbol") {
-	      this.raise(FlowErrors.EnumInvalidExplicitType, {
-	        at: this.state.startLoc,
+	      this.raise(FlowErrors.EnumInvalidExplicitType, this.state.startLoc, {
 	        enumName,
 	        invalidEnumType: value
 	      });
@@ -27951,8 +27893,7 @@ function requireLib () {
 	            this.expect(8);
 	            return this.finishNode(node, "EnumNumberBody");
 	          } else {
-	            this.raise(FlowErrors.EnumInconsistentMemberValues, {
-	              at: nameLoc,
+	            this.raise(FlowErrors.EnumInconsistentMemberValues, nameLoc, {
 	              enumName
 	            });
 	            return empty();
@@ -28270,9 +28211,7 @@ function requireLib () {
 	    let chunkStart = this.state.pos;
 	    for (;;) {
 	      if (this.state.pos >= this.length) {
-	        throw this.raise(JsxErrors.UnterminatedJsxContent, {
-	          at: this.state.startLoc
-	        });
+	        throw this.raise(JsxErrors.UnterminatedJsxContent, this.state.startLoc);
 	      }
 	      const ch = this.input.charCodeAt(this.state.pos);
 	      switch (ch) {
@@ -28327,9 +28266,7 @@ function requireLib () {
 	    let chunkStart = ++this.state.pos;
 	    for (;;) {
 	      if (this.state.pos >= this.length) {
-	        throw this.raise(Errors.UnterminatedString, {
-	          at: this.state.startLoc
-	        });
+	        throw this.raise(Errors.UnterminatedString, this.state.startLoc);
 	      }
 	      const ch = this.input.charCodeAt(this.state.pos);
 	      if (ch === quote) break;
@@ -28432,18 +28369,14 @@ function requireLib () {
 	        this.next();
 	        node = this.jsxParseExpressionContainer(node, types.j_oTag);
 	        if (node.expression.type === "JSXEmptyExpression") {
-	          this.raise(JsxErrors.AttributeIsEmpty, {
-	            at: node
-	          });
+	          this.raise(JsxErrors.AttributeIsEmpty, node);
 	        }
 	        return node;
 	      case 142:
 	      case 133:
 	        return this.parseExprAtom();
 	      default:
-	        throw this.raise(JsxErrors.UnsupportedJsxValue, {
-	          at: this.state.startLoc
-	        });
+	        throw this.raise(JsxErrors.UnsupportedJsxValue, this.state.startLoc);
 	    }
 	  }
 	  jsxParseEmptyExpression() {
@@ -28550,18 +28483,14 @@ function requireLib () {
 	        }
 	      }
 	      if (isFragment(openingElement) && !isFragment(closingElement) && closingElement !== null) {
-	        this.raise(JsxErrors.MissingClosingTagFragment, {
-	          at: closingElement
-	        });
+	        this.raise(JsxErrors.MissingClosingTagFragment, closingElement);
 	      } else if (!isFragment(openingElement) && isFragment(closingElement)) {
-	        this.raise(JsxErrors.MissingClosingTagElement, {
-	          at: closingElement,
+	        this.raise(JsxErrors.MissingClosingTagElement, closingElement, {
 	          openingTagName: getQualifiedJSXName(openingElement.name)
 	        });
 	      } else if (!isFragment(openingElement) && !isFragment(closingElement)) {
 	        if (getQualifiedJSXName(closingElement.name) !== getQualifiedJSXName(openingElement.name)) {
-	          this.raise(JsxErrors.MissingClosingTagElement, {
-	            at: closingElement,
+	          this.raise(JsxErrors.MissingClosingTagElement, closingElement, {
 	            openingTagName: getQualifiedJSXName(openingElement.name)
 	          });
 	        }
@@ -28576,9 +28505,7 @@ function requireLib () {
 	    }
 	    node.children = children;
 	    if (this.match(47)) {
-	      throw this.raise(JsxErrors.UnwrappedAdjacentJSXElements, {
-	        at: this.state.startLoc
-	      });
+	      throw this.raise(JsxErrors.UnwrappedAdjacentJSXElements, this.state.startLoc);
 	    }
 	    return isFragment(openingElement) ? this.finishNode(node, "JSXFragment") : this.finishNode(node, "JSXElement");
 	  }
@@ -28664,11 +28591,7 @@ function requireLib () {
 	class TypeScriptScope extends Scope {
 	  constructor(...args) {
 	    super(...args);
-	    this.types = new Set();
-	    this.enums = new Set();
-	    this.constEnums = new Set();
-	    this.classes = new Set();
-	    this.exportOnlyBindings = new Set();
+	    this.tsNames = new Map();
 	  }
 	}
 	class TypeScriptScopeHandler extends ScopeHandler {
@@ -28708,8 +28631,7 @@ function requireLib () {
 	  declareName(name, bindingType, loc) {
 	    if (bindingType & 4096) {
 	      if (this.hasImport(name, true)) {
-	        this.parser.raise(Errors.VarRedeclaration, {
-	          at: loc,
+	        this.parser.raise(Errors.VarRedeclaration, loc, {
 	          identifierName: name
 	        });
 	      }
@@ -28717,9 +28639,10 @@ function requireLib () {
 	      return;
 	    }
 	    const scope = this.currentScope();
+	    let type = scope.tsNames.get(name) || 0;
 	    if (bindingType & 1024) {
 	      this.maybeExportDefined(scope, name);
-	      scope.exportOnlyBindings.add(name);
+	      scope.tsNames.set(name, type | 16);
 	      return;
 	    }
 	    super.declareName(name, bindingType, loc);
@@ -28728,31 +28651,37 @@ function requireLib () {
 	        this.checkRedeclarationInScope(scope, name, bindingType, loc);
 	        this.maybeExportDefined(scope, name);
 	      }
-	      scope.types.add(name);
+	      type = type | 1;
+	    }
+	    if (bindingType & 256) {
+	      type = type | 2;
 	    }
-	    if (bindingType & 256) scope.enums.add(name);
 	    if (bindingType & 512) {
-	      scope.constEnums.add(name);
+	      type = type | 4;
+	    }
+	    if (bindingType & 128) {
+	      type = type | 8;
 	    }
-	    if (bindingType & 128) scope.classes.add(name);
+	    if (type) scope.tsNames.set(name, type);
 	  }
 	  isRedeclaredInScope(scope, name, bindingType) {
-	    if (scope.enums.has(name)) {
+	    const type = scope.tsNames.get(name);
+	    if ((type & 2) > 0) {
 	      if (bindingType & 256) {
 	        const isConst = !!(bindingType & 512);
-	        const wasConst = scope.constEnums.has(name);
+	        const wasConst = (type & 4) > 0;
 	        return isConst !== wasConst;
 	      }
 	      return true;
 	    }
-	    if (bindingType & 128 && scope.classes.has(name)) {
-	      if (scope.lexical.has(name)) {
+	    if (bindingType & 128 && (type & 8) > 0) {
+	      if (scope.names.get(name) & 2) {
 	        return !!(bindingType & 1);
 	      } else {
 	        return false;
 	      }
 	    }
-	    if (bindingType & 2 && scope.types.has(name)) {
+	    if (bindingType & 2 && (type & 1) > 0) {
 	      return true;
 	    }
 	    return super.isRedeclaredInScope(scope, name, bindingType);
@@ -28765,7 +28694,10 @@ function requireLib () {
 	    const len = this.scopeStack.length;
 	    for (let i = len - 1; i >= 0; i--) {
 	      const scope = this.scopeStack[i];
-	      if (scope.types.has(name) || scope.exportOnlyBindings.has(name)) return;
+	      const type = scope.tsNames.get(name);
+	      if ((type & 1) > 0 || (type & 16) > 0) {
+	        return;
+	      }
 	    }
 	    super.checkLocalExport(id);
 	  }
@@ -28782,18 +28714,12 @@ function requireLib () {
 	      parenthesized = unwrapParenthesizedExpression(node);
 	      if (isLHS) {
 	        if (parenthesized.type === "Identifier") {
-	          this.expressionScope.recordArrowParameterBindingError(Errors.InvalidParenthesizedAssignment, {
-	            at: node
-	          });
+	          this.expressionScope.recordArrowParameterBindingError(Errors.InvalidParenthesizedAssignment, node);
 	        } else if (parenthesized.type !== "MemberExpression" && !this.isOptionalMemberExpression(parenthesized)) {
-	          this.raise(Errors.InvalidParenthesizedAssignment, {
-	            at: node
-	          });
+	          this.raise(Errors.InvalidParenthesizedAssignment, node);
 	        }
 	      } else {
-	        this.raise(Errors.InvalidParenthesizedAssignment, {
-	          at: node
-	        });
+	        this.raise(Errors.InvalidParenthesizedAssignment, node);
 	      }
 	    }
 	    switch (node.type) {
@@ -28811,9 +28737,7 @@ function requireLib () {
 	          const isLast = i === last;
 	          this.toAssignableObjectExpressionProp(prop, isLast, isLHS);
 	          if (isLast && prop.type === "RestElement" && (_node$extra2 = node.extra) != null && _node$extra2.trailingCommaLoc) {
-	            this.raise(Errors.RestTrailingComma, {
-	              at: node.extra.trailingCommaLoc
-	            });
+	            this.raise(Errors.RestTrailingComma, node.extra.trailingCommaLoc);
 	          }
 	        }
 	        break;
@@ -28839,9 +28763,7 @@ function requireLib () {
 	        break;
 	      case "AssignmentExpression":
 	        if (node.operator !== "=") {
-	          this.raise(Errors.MissingEqInAssignment, {
-	            at: node.left.loc.end
-	          });
+	          this.raise(Errors.MissingEqInAssignment, node.left.loc.end);
 	        }
 	        node.type = "AssignmentPattern";
 	        delete node.operator;
@@ -28854,18 +28776,14 @@ function requireLib () {
 	  }
 	  toAssignableObjectExpressionProp(prop, isLast, isLHS) {
 	    if (prop.type === "ObjectMethod") {
-	      this.raise(prop.kind === "get" || prop.kind === "set" ? Errors.PatternHasAccessor : Errors.PatternHasMethod, {
-	        at: prop.key
-	      });
+	      this.raise(prop.kind === "get" || prop.kind === "set" ? Errors.PatternHasAccessor : Errors.PatternHasMethod, prop.key);
 	    } else if (prop.type === "SpreadElement") {
 	      prop.type = "RestElement";
 	      const arg = prop.argument;
 	      this.checkToRestConversion(arg, false);
 	      this.toAssignable(arg, isLHS);
 	      if (!isLast) {
-	        this.raise(Errors.RestTrailingComma, {
-	          at: prop
-	        });
+	        this.raise(Errors.RestTrailingComma, prop);
 	      }
 	    } else {
 	      this.toAssignable(prop, isLHS);
@@ -28886,13 +28804,9 @@ function requireLib () {
 	      }
 	      if (elt.type === "RestElement") {
 	        if (i < end) {
-	          this.raise(Errors.RestTrailingComma, {
-	            at: elt
-	          });
+	          this.raise(Errors.RestTrailingComma, elt);
 	        } else if (trailingCommaLoc) {
-	          this.raise(Errors.RestTrailingComma, {
-	            at: trailingCommaLoc
-	          });
+	          this.raise(Errors.RestTrailingComma, trailingCommaLoc);
 	        }
 	      }
 	    }
@@ -28989,9 +28903,7 @@ function requireLib () {
 	      } else {
 	        const decorators = [];
 	        if (this.match(26) && this.hasPlugin("decorators")) {
-	          this.raise(Errors.UnsupportedParameterDecorator, {
-	            at: this.state.startLoc
-	          });
+	          this.raise(Errors.UnsupportedParameterDecorator, this.state.startLoc);
 	        }
 	        while (this.match(26)) {
 	          decorators.push(this.parseDecorator());
@@ -29075,16 +28987,13 @@ function requireLib () {
 	      if (isOptionalMemberExpression) {
 	        this.expectPlugin("optionalChainingAssign", expression.loc.start);
 	        if (ancestor.type !== "AssignmentExpression") {
-	          this.raise(Errors.InvalidLhsOptionalChaining, {
-	            at: expression,
+	          this.raise(Errors.InvalidLhsOptionalChaining, expression, {
 	            ancestor
 	          });
 	        }
 	      }
 	      if (binding !== 64) {
-	        this.raise(Errors.InvalidPropertyBindingPattern, {
-	          at: expression
-	        });
+	        this.raise(Errors.InvalidPropertyBindingPattern, expression);
 	      }
 	      return;
 	    }
@@ -29095,9 +29004,7 @@ function requireLib () {
 	      } = expression;
 	      if (checkClashes) {
 	        if (checkClashes.has(name)) {
-	          this.raise(Errors.ParamDupe, {
-	            at: expression
-	          });
+	          this.raise(Errors.ParamDupe, expression);
 	        } else {
 	          checkClashes.add(name);
 	        }
@@ -29108,8 +29015,7 @@ function requireLib () {
 	    if (validity === true) return;
 	    if (validity === false) {
 	      const ParseErrorClass = binding === 64 ? Errors.InvalidLhs : Errors.InvalidLhsBinding;
-	      this.raise(ParseErrorClass, {
-	        at: expression,
+	      this.raise(ParseErrorClass, expression, {
 	        ancestor
 	      });
 	      return;
@@ -29133,21 +29039,17 @@ function requireLib () {
 	  checkIdentifier(at, bindingType, strictModeChanged = false) {
 	    if (this.state.strict && (strictModeChanged ? isStrictBindReservedWord(at.name, this.inModule) : isStrictBindOnlyReservedWord(at.name))) {
 	      if (bindingType === 64) {
-	        this.raise(Errors.StrictEvalArguments, {
-	          at,
+	        this.raise(Errors.StrictEvalArguments, at, {
 	          referenceName: at.name
 	        });
 	      } else {
-	        this.raise(Errors.StrictEvalArgumentsBinding, {
-	          at,
+	        this.raise(Errors.StrictEvalArgumentsBinding, at, {
 	          bindingName: at.name
 	        });
 	      }
 	    }
 	    if (bindingType & 8192 && at.name === "let") {
-	      this.raise(Errors.LetInLexicalBinding, {
-	        at
-	      });
+	      this.raise(Errors.LetInLexicalBinding, at);
 	    }
 	    if (!(bindingType & 64)) {
 	      this.declareNameFromIdentifier(at, bindingType);
@@ -29168,18 +29070,14 @@ function requireLib () {
 	      case "ObjectExpression":
 	        if (allowPattern) break;
 	      default:
-	        this.raise(Errors.InvalidRestAssignmentPattern, {
-	          at: node
-	        });
+	        this.raise(Errors.InvalidRestAssignmentPattern, node);
 	    }
 	  }
 	  checkCommaAfterRest(close) {
 	    if (!this.match(12)) {
 	      return false;
 	    }
-	    this.raise(this.lookaheadCharCode() === close ? Errors.RestTrailingComma : Errors.ElementAfterRest, {
-	      at: this.state.startLoc
-	    });
+	    this.raise(this.lookaheadCharCode() === close ? Errors.RestTrailingComma : Errors.ElementAfterRest, this.state.startLoc);
 	    return true;
 	  }
 	}
@@ -29375,16 +29273,14 @@ function requireLib () {
 	  }, modified) {
 	    const enforceOrder = (loc, modifier, before, after) => {
 	      if (modifier === before && modified[after]) {
-	        this.raise(TSErrors.InvalidModifiersOrder, {
-	          at: loc,
+	        this.raise(TSErrors.InvalidModifiersOrder, loc, {
 	          orderedModifiers: [before, after]
 	        });
 	      }
 	    };
 	    const incompatible = (loc, modifier, mod1, mod2) => {
 	      if (modified[mod1] && modifier === mod2 || modified[mod2] && modifier === mod1) {
-	        this.raise(TSErrors.IncompatibleModifiers, {
-	          at: loc,
+	        this.raise(TSErrors.IncompatibleModifiers, loc, {
 	          modifiers: [mod1, mod2]
 	        });
 	      }
@@ -29397,8 +29293,7 @@ function requireLib () {
 	      if (!modifier) break;
 	      if (tsIsAccessModifier(modifier)) {
 	        if (modified.accessibility) {
-	          this.raise(TSErrors.DuplicateAccessibilityModifier, {
-	            at: startLoc,
+	          this.raise(TSErrors.DuplicateAccessibilityModifier, startLoc, {
 	            modifier
 	          });
 	        } else {
@@ -29409,8 +29304,7 @@ function requireLib () {
 	        }
 	      } else if (tsIsVarianceAnnotations(modifier)) {
 	        if (modified[modifier]) {
-	          this.raise(TSErrors.DuplicateModifier, {
-	            at: startLoc,
+	          this.raise(TSErrors.DuplicateModifier, startLoc, {
 	            modifier
 	          });
 	        }
@@ -29418,8 +29312,7 @@ function requireLib () {
 	        enforceOrder(startLoc, modifier, "in", "out");
 	      } else {
 	        if (Object.hasOwnProperty.call(modified, modifier)) {
-	          this.raise(TSErrors.DuplicateModifier, {
-	            at: startLoc,
+	          this.raise(TSErrors.DuplicateModifier, startLoc, {
 	            modifier
 	          });
 	        } else {
@@ -29433,8 +29326,7 @@ function requireLib () {
 	        modified[modifier] = true;
 	      }
 	      if (disallowedModifiers != null && disallowedModifiers.includes(modifier)) {
-	        this.raise(errorTemplate, {
-	          at: startLoc,
+	        this.raise(errorTemplate, startLoc, {
 	          modifier
 	        });
 	      }
@@ -29477,7 +29369,7 @@ function requireLib () {
 	      }
 	      result.push(element);
 	      if (this.eat(12)) {
-	        trailingCommaPos = this.state.lastTokStart;
+	        trailingCommaPos = this.state.lastTokStartLoc.index;
 	        continue;
 	      }
 	      if (this.tsIsListTerminator(kind)) {
@@ -29514,9 +29406,7 @@ function requireLib () {
 	    this.expect(83);
 	    this.expect(10);
 	    if (!this.match(133)) {
-	      this.raise(TSErrors.UnsupportedImportTypeArgument, {
-	        at: this.state.startLoc
-	      });
+	      this.raise(TSErrors.UnsupportedImportTypeArgument, this.state.startLoc);
 	    }
 	    node.argument = super.parseExprAtom();
 	    this.expect(11);
@@ -29597,9 +29487,7 @@ function requireLib () {
 	    };
 	    node.params = this.tsParseBracketedList("TypeParametersOrArguments", this.tsParseTypeParameter.bind(this, parseModifiers), false, true, refTrailingCommaPos);
 	    if (node.params.length === 0) {
-	      this.raise(TSErrors.EmptyTypeParameters, {
-	        at: node
-	      });
+	      this.raise(TSErrors.EmptyTypeParameters, node);
 	    }
 	    if (refTrailingCommaPos.value !== -1) {
 	      this.addExtra(node, "trailingComma", refTrailingCommaPos.value);
@@ -29626,8 +29514,7 @@ function requireLib () {
 	        type
 	      } = pattern;
 	      if (type === "AssignmentPattern" || type === "TSParameterProperty") {
-	        this.raise(TSErrors.UnsupportedSignatureParameterKind, {
-	          at: pattern,
+	        this.raise(TSErrors.UnsupportedSignatureParameterKind, pattern, {
 	          type
 	        });
 	      }
@@ -29672,15 +29559,11 @@ function requireLib () {
 	    const nodeAny = node;
 	    if (this.match(10) || this.match(47)) {
 	      if (readonly) {
-	        this.raise(TSErrors.ReadonlyForMethodSignature, {
-	          at: node
-	        });
+	        this.raise(TSErrors.ReadonlyForMethodSignature, node);
 	      }
 	      const method = nodeAny;
 	      if (method.kind && this.match(47)) {
-	        this.raise(TSErrors.AccesorCannotHaveTypeParameters, {
-	          at: this.state.curPosition()
-	        });
+	        this.raise(TSErrors.AccesorCannotHaveTypeParameters, this.state.curPosition());
 	      }
 	      this.tsFillSignature(14, method);
 	      this.tsParseTypeMemberSemicolon();
@@ -29688,42 +29571,28 @@ function requireLib () {
 	      const returnTypeKey = "typeAnnotation";
 	      if (method.kind === "get") {
 	        if (method[paramsKey].length > 0) {
-	          this.raise(Errors.BadGetterArity, {
-	            at: this.state.curPosition()
-	          });
+	          this.raise(Errors.BadGetterArity, this.state.curPosition());
 	          if (this.isThisParam(method[paramsKey][0])) {
-	            this.raise(TSErrors.AccesorCannotDeclareThisParameter, {
-	              at: this.state.curPosition()
-	            });
+	            this.raise(TSErrors.AccesorCannotDeclareThisParameter, this.state.curPosition());
 	          }
 	        }
 	      } else if (method.kind === "set") {
 	        if (method[paramsKey].length !== 1) {
-	          this.raise(Errors.BadSetterArity, {
-	            at: this.state.curPosition()
-	          });
+	          this.raise(Errors.BadSetterArity, this.state.curPosition());
 	        } else {
 	          const firstParameter = method[paramsKey][0];
 	          if (this.isThisParam(firstParameter)) {
-	            this.raise(TSErrors.AccesorCannotDeclareThisParameter, {
-	              at: this.state.curPosition()
-	            });
+	            this.raise(TSErrors.AccesorCannotDeclareThisParameter, this.state.curPosition());
 	          }
 	          if (firstParameter.type === "Identifier" && firstParameter.optional) {
-	            this.raise(TSErrors.SetAccesorCannotHaveOptionalParameter, {
-	              at: this.state.curPosition()
-	            });
+	            this.raise(TSErrors.SetAccesorCannotHaveOptionalParameter, this.state.curPosition());
 	          }
 	          if (firstParameter.type === "RestElement") {
-	            this.raise(TSErrors.SetAccesorCannotHaveRestParameter, {
-	              at: this.state.curPosition()
-	            });
+	            this.raise(TSErrors.SetAccesorCannotHaveRestParameter, this.state.curPosition());
 	          }
 	        }
 	        if (method[returnTypeKey]) {
-	          this.raise(TSErrors.SetAccesorCannotHaveReturnType, {
-	            at: method[returnTypeKey]
-	          });
+	          this.raise(TSErrors.SetAccesorCannotHaveReturnType, method[returnTypeKey]);
 	        }
 	      } else {
 	        method.kind = "method";
@@ -29838,9 +29707,7 @@ function requireLib () {
 	        type
 	      } = elementNode;
 	      if (seenOptionalElement && type !== "TSRestType" && type !== "TSOptionalType" && !(type === "TSNamedTupleMember" && elementNode.optional)) {
-	        this.raise(TSErrors.OptionalTypeBeforeRequired, {
-	          at: elementNode
-	        });
+	        this.raise(TSErrors.OptionalTypeBeforeRequired, elementNode);
 	      }
 	      seenOptionalElement || (seenOptionalElement = type === "TSNamedTupleMember" && elementNode.optional || type === "TSOptionalType");
 	    });
@@ -29893,16 +29760,12 @@ function requireLib () {
 	        labeledNode.elementType = type;
 	        if (this.eat(17)) {
 	          labeledNode.optional = true;
-	          this.raise(TSErrors.TupleOptionalAfterType, {
-	            at: this.state.lastTokStartLoc
-	          });
+	          this.raise(TSErrors.TupleOptionalAfterType, this.state.lastTokStartLoc);
 	        }
 	      } else {
 	        labeledNode = this.startNodeAtNode(type);
 	        labeledNode.optional = optional;
-	        this.raise(TSErrors.InvalidTupleMemberLabel, {
-	          at: type
-	        });
+	        this.raise(TSErrors.InvalidTupleMemberLabel, type);
 	        labeledNode.label = type;
 	        labeledNode.elementType = this.tsParseType();
 	      }
@@ -30055,9 +29918,7 @@ function requireLib () {
 	      case "TSArrayType":
 	        return;
 	      default:
-	        this.raise(TSErrors.UnexpectedReadonly, {
-	          at: node
-	        });
+	        this.raise(TSErrors.UnexpectedReadonly, node);
 	    }
 	  }
 	  tsParseInferType() {
@@ -30225,8 +30086,7 @@ function requireLib () {
 	      return false;
 	    }
 	    if (containsEsc) {
-	      this.raise(Errors.InvalidEscapedReservedWord, {
-	        at: this.state.lastTokStartLoc,
+	      this.raise(Errors.InvalidEscapedReservedWord, this.state.lastTokStartLoc, {
 	        reservedWord: "asserts"
 	      });
 	    }
@@ -30270,9 +30130,7 @@ function requireLib () {
 	  }
 	  tsParseTypeAssertion() {
 	    if (this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) {
-	      this.raise(TSErrors.ReservedTypeAssertion, {
-	        at: this.state.startLoc
-	      });
+	      this.raise(TSErrors.ReservedTypeAssertion, this.state.startLoc);
 	    }
 	    const node = this.startNode();
 	    node.typeAnnotation = this.tsInType(() => {
@@ -30294,8 +30152,7 @@ function requireLib () {
 	      return this.finishNode(node, "TSExpressionWithTypeArguments");
 	    });
 	    if (!delimitedList.length) {
-	      this.raise(TSErrors.EmptyHeritageClauseType, {
-	        at: originalStartLoc,
+	      this.raise(TSErrors.EmptyHeritageClauseType, originalStartLoc, {
 	        token
 	      });
 	    }
@@ -30310,9 +30167,7 @@ function requireLib () {
 	      this.checkIdentifier(node.id, 130);
 	    } else {
 	      node.id = null;
-	      this.raise(TSErrors.MissingInterfaceName, {
-	        at: this.state.startLoc
-	      });
+	      this.raise(TSErrors.MissingInterfaceName, this.state.startLoc);
 	    }
 	    node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutConstModifiers);
 	    if (this.eat(81)) {
@@ -30464,9 +30319,7 @@ function requireLib () {
 	    this.expect(29);
 	    const moduleReference = this.tsParseModuleReference();
 	    if (node.importKind === "type" && moduleReference.type !== "TSExternalModuleReference") {
-	      this.raise(TSErrors.ImportAliasHasImportType, {
-	        at: moduleReference
-	      });
+	      this.raise(TSErrors.ImportAliasHasImportType, moduleReference);
 	    }
 	    node.moduleReference = moduleReference;
 	    this.semicolon();
@@ -30652,9 +30505,7 @@ function requireLib () {
 	      return this.tsParseDelimitedList("TypeParametersOrArguments", this.tsParseType.bind(this));
 	    }));
 	    if (node.params.length === 0) {
-	      this.raise(TSErrors.EmptyTypeArguments, {
-	        at: node
-	      });
+	      this.raise(TSErrors.EmptyTypeArguments, node);
 	    } else if (!this.state.inType && this.curContext() === types.brace) {
 	      this.reScan_lt_gt();
 	    }
@@ -30678,9 +30529,7 @@ function requireLib () {
 	    const override = modified.override;
 	    const readonly = modified.readonly;
 	    if (!(flags & 4) && (accessibility || readonly || override)) {
-	      this.raise(TSErrors.UnexpectedParameterModifier, {
-	        at: startLoc
-	      });
+	      this.raise(TSErrors.UnexpectedParameterModifier, startLoc);
 	    }
 	    const left = this.parseMaybeDefault();
 	    this.parseAssignableListItemTypes(left, flags);
@@ -30694,9 +30543,7 @@ function requireLib () {
 	      if (readonly) pp.readonly = readonly;
 	      if (override) pp.override = override;
 	      if (elt.type !== "Identifier" && elt.type !== "AssignmentPattern") {
-	        this.raise(TSErrors.UnsupportedParameterPropertyKind, {
-	          at: pp
-	        });
+	        this.raise(TSErrors.UnsupportedParameterPropertyKind, pp);
 	      }
 	      pp.parameter = elt;
 	      return this.finishNode(pp, "TSParameterProperty");
@@ -30712,9 +30559,7 @@ function requireLib () {
 	  tsDisallowOptionalPattern(node) {
 	    for (const param of node.params) {
 	      if (param.type !== "Identifier" && param.optional && !this.state.isAmbientContext) {
-	        this.raise(TSErrors.PatternIsOptional, {
-	          at: param
-	        });
+	        this.raise(TSErrors.PatternIsOptional, param);
 	      }
 	    }
 	  }
@@ -30731,9 +30576,7 @@ function requireLib () {
 	      return this.finishNode(node, bodilessType);
 	    }
 	    if (bodilessType === "TSDeclareFunction" && this.state.isAmbientContext) {
-	      this.raise(TSErrors.DeclareFunctionHasImplementation, {
-	        at: node
-	      });
+	      this.raise(TSErrors.DeclareFunctionHasImplementation, node);
 	      if (node.declare) {
 	        return super.parseFunctionBodyAndFinish(node, bodilessType, isMethod);
 	      }
@@ -30751,9 +30594,7 @@ function requireLib () {
 	  tsCheckForInvalidTypeCasts(items) {
 	    items.forEach(node => {
 	      if ((node == null ? void 0 : node.type) === "TSTypeCastExpression") {
-	        this.raise(TSErrors.UnexpectedTypeAnnotation, {
-	          at: node.typeAnnotation
-	        });
+	        this.raise(TSErrors.UnexpectedTypeAnnotation, node.typeAnnotation);
 	      }
 	    });
 	  }
@@ -30830,9 +30671,7 @@ function requireLib () {
 	      }
 	      if (result) {
 	        if (result.type === "TSInstantiationExpression" && (this.match(16) || this.match(18) && this.lookaheadCharCode() !== 40)) {
-	          this.raise(TSErrors.InvalidPropertyAccessAfterInstantiationExpression, {
-	            at: this.state.startLoc
-	          });
+	          this.raise(TSErrors.InvalidPropertyAccessAfterInstantiationExpression, this.state.startLoc);
 	        }
 	        return result;
 	      }
@@ -30859,8 +30698,7 @@ function requireLib () {
 	        this.next();
 	        if (this.match(75)) {
 	          if (isSatisfies) {
-	            this.raise(Errors.UnexpectedKeyword, {
-	              at: this.state.startLoc,
+	            this.raise(Errors.UnexpectedKeyword, this.state.startLoc, {
 	              keyword: "const"
 	            });
 	          }
@@ -30882,9 +30720,7 @@ function requireLib () {
 	  checkImportReflection(node) {
 	    super.checkImportReflection(node);
 	    if (node.module && node.importKind !== "value") {
-	      this.raise(TSErrors.ImportReflectionHasImportType, {
-	        at: node.specifiers[0].loc.start
-	      });
+	      this.raise(TSErrors.ImportReflectionHasImportType, node.specifiers[0].loc.start);
 	    }
 	  }
 	  checkDuplicateExports() {}
@@ -30924,9 +30760,7 @@ function requireLib () {
 	      importNode = super.parseImport(node);
 	    }
 	    if (importNode.importKind === "type" && importNode.specifiers.length > 1 && importNode.specifiers[0].type === "ImportDefaultSpecifier") {
-	      this.raise(TSErrors.TypeImportCannotSpecifyDefaultAndNamed, {
-	        at: importNode
-	      });
+	      this.raise(TSErrors.TypeImportCannotSpecifyDefaultAndNamed, importNode);
 	    }
 	    return importNode;
 	  }
@@ -30984,13 +30818,9 @@ function requireLib () {
 	    } of declaration.declarations) {
 	      if (!init) continue;
 	      if (kind !== "const" || !!id.typeAnnotation) {
-	        this.raise(TSErrors.InitializerNotAllowedInAmbientContext, {
-	          at: init
-	        });
+	        this.raise(TSErrors.InitializerNotAllowedInAmbientContext, init);
 	      } else if (!isValidAmbientConstInitializer(init, this.hasPlugin("estree"))) {
-	        this.raise(TSErrors.ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference, {
-	          at: init
-	        });
+	        this.raise(TSErrors.ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference, init);
 	      }
 	    }
 	    return declaration;
@@ -31039,9 +30869,7 @@ function requireLib () {
 	        this.next();
 	        this.next();
 	        if (this.tsHasSomeModifiers(member, modifiers)) {
-	          this.raise(TSErrors.StaticBlockCannotHaveModifier, {
-	            at: this.state.curPosition()
-	          });
+	          this.raise(TSErrors.StaticBlockCannotHaveModifier, this.state.curPosition());
 	        }
 	        super.parseClassStaticBlock(classBody, member);
 	      } else {
@@ -31059,38 +30887,27 @@ function requireLib () {
 	    if (idx) {
 	      classBody.body.push(idx);
 	      if (member.abstract) {
-	        this.raise(TSErrors.IndexSignatureHasAbstract, {
-	          at: member
-	        });
+	        this.raise(TSErrors.IndexSignatureHasAbstract, member);
 	      }
 	      if (member.accessibility) {
-	        this.raise(TSErrors.IndexSignatureHasAccessibility, {
-	          at: member,
+	        this.raise(TSErrors.IndexSignatureHasAccessibility, member, {
 	          modifier: member.accessibility
 	        });
 	      }
 	      if (member.declare) {
-	        this.raise(TSErrors.IndexSignatureHasDeclare, {
-	          at: member
-	        });
+	        this.raise(TSErrors.IndexSignatureHasDeclare, member);
 	      }
 	      if (member.override) {
-	        this.raise(TSErrors.IndexSignatureHasOverride, {
-	          at: member
-	        });
+	        this.raise(TSErrors.IndexSignatureHasOverride, member);
 	      }
 	      return;
 	    }
 	    if (!this.state.inAbstractClass && member.abstract) {
-	      this.raise(TSErrors.NonAbstractClassHasAbstractMethod, {
-	        at: member
-	      });
+	      this.raise(TSErrors.NonAbstractClassHasAbstractMethod, member);
 	    }
 	    if (member.override) {
 	      if (!state.hadSuperClass) {
-	        this.raise(TSErrors.OverrideNotInSubClass, {
-	          at: member
-	        });
+	        this.raise(TSErrors.OverrideNotInSubClass, member);
 	      }
 	    }
 	    super.parseClassMemberWithIsStatic(classBody, member, state, isStatic);
@@ -31099,14 +30916,10 @@ function requireLib () {
 	    const optional = this.eat(17);
 	    if (optional) methodOrProp.optional = true;
 	    if (methodOrProp.readonly && this.match(10)) {
-	      this.raise(TSErrors.ClassMethodHasReadonly, {
-	        at: methodOrProp
-	      });
+	      this.raise(TSErrors.ClassMethodHasReadonly, methodOrProp);
 	    }
 	    if (methodOrProp.declare && this.match(10)) {
-	      this.raise(TSErrors.ClassMethodHasDeclare, {
-	        at: methodOrProp
-	      });
+	      this.raise(TSErrors.ClassMethodHasDeclare, methodOrProp);
 	    }
 	  }
 	  parseExpressionStatement(node, expr, decorators) {
@@ -31152,9 +30965,7 @@ function requireLib () {
 	    const startLoc = this.state.startLoc;
 	    const isDeclare = this.eatContextual(125);
 	    if (isDeclare && (this.isContextual(125) || !this.shouldParseExportDeclaration())) {
-	      throw this.raise(TSErrors.ExpectedAmbientAfterExportDeclare, {
-	        at: this.state.startLoc
-	      });
+	      throw this.raise(TSErrors.ExpectedAmbientAfterExportDeclare, this.state.startLoc);
 	    }
 	    const isIdentifier = tokenIsIdentifier(this.state.type);
 	    const declaration = isIdentifier && this.tsTryParseExportDeclaration() || super.parseExportDeclaration(node);
@@ -31190,16 +31001,13 @@ function requireLib () {
 	  parseClassProperty(node) {
 	    this.parseClassPropertyAnnotation(node);
 	    if (this.state.isAmbientContext && !(node.readonly && !node.typeAnnotation) && this.match(29)) {
-	      this.raise(TSErrors.DeclareClassFieldHasInitializer, {
-	        at: this.state.startLoc
-	      });
+	      this.raise(TSErrors.DeclareClassFieldHasInitializer, this.state.startLoc);
 	    }
 	    if (node.abstract && this.match(29)) {
 	      const {
 	        key
 	      } = node;
-	      this.raise(TSErrors.AbstractPropertyHasInitializer, {
-	        at: this.state.startLoc,
+	      this.raise(TSErrors.AbstractPropertyHasInitializer, this.state.startLoc, {
 	        propertyName: key.type === "Identifier" && !node.computed ? key.name : `[${this.input.slice(key.start, key.end)}]`
 	      });
 	    }
@@ -31207,13 +31015,10 @@ function requireLib () {
 	  }
 	  parseClassPrivateProperty(node) {
 	    if (node.abstract) {
-	      this.raise(TSErrors.PrivateElementHasAbstract, {
-	        at: node
-	      });
+	      this.raise(TSErrors.PrivateElementHasAbstract, node);
 	    }
 	    if (node.accessibility) {
-	      this.raise(TSErrors.PrivateElementHasAccessibility, {
-	        at: node,
+	      this.raise(TSErrors.PrivateElementHasAccessibility, node, {
 	        modifier: node.accessibility
 	      });
 	    }
@@ -31223,26 +31028,21 @@ function requireLib () {
 	  parseClassAccessorProperty(node) {
 	    this.parseClassPropertyAnnotation(node);
 	    if (node.optional) {
-	      this.raise(TSErrors.AccessorCannotBeOptional, {
-	        at: node
-	      });
+	      this.raise(TSErrors.AccessorCannotBeOptional, node);
 	    }
 	    return super.parseClassAccessorProperty(node);
 	  }
 	  pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
 	    const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
 	    if (typeParameters && isConstructor) {
-	      this.raise(TSErrors.ConstructorHasTypeParameters, {
-	        at: typeParameters
-	      });
+	      this.raise(TSErrors.ConstructorHasTypeParameters, typeParameters);
 	    }
 	    const {
 	      declare = false,
 	      kind
 	    } = method;
 	    if (declare && (kind === "get" || kind === "set")) {
-	      this.raise(TSErrors.DeclareAccessor, {
-	        at: method,
+	      this.raise(TSErrors.DeclareAccessor, method, {
 	        kind
 	      });
 	    }
@@ -31357,9 +31157,7 @@ function requireLib () {
 	  reportReservedArrowTypeParam(node) {
 	    var _node$extra;
 	    if (node.params.length === 1 && !node.params[0].constraint && !((_node$extra = node.extra) != null && _node$extra.trailingComma) && this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) {
-	      this.raise(TSErrors.ReservedArrowTypeParam, {
-	        at: node
-	      });
+	      this.raise(TSErrors.ReservedArrowTypeParam, node);
 	    }
 	  }
 	  parseMaybeUnary(refExpressionErrors, sawUnary) {
@@ -31413,13 +31211,9 @@ function requireLib () {
 	      case "TSNonNullExpression":
 	      case "TSTypeAssertion":
 	        if (isLHS) {
-	          this.expressionScope.recordArrowParameterBindingError(TSErrors.UnexpectedTypeCastInParameter, {
-	            at: node
-	          });
+	          this.expressionScope.recordArrowParameterBindingError(TSErrors.UnexpectedTypeCastInParameter, node);
 	        } else {
-	          this.raise(TSErrors.UnexpectedTypeCastInParameter, {
-	            at: node
-	          });
+	          this.raise(TSErrors.UnexpectedTypeCastInParameter, node);
 	        }
 	        this.toAssignable(node.expression, isLHS);
 	        break;
@@ -31500,9 +31294,7 @@ function requireLib () {
 	  parseMaybeDefault(startLoc, left) {
 	    const node = super.parseMaybeDefault(startLoc, left);
 	    if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) {
-	      this.raise(TSErrors.TypeAnnotationAfterAssign, {
-	        at: node.typeAnnotation
-	      });
+	      this.raise(TSErrors.TypeAnnotationAfterAssign, node.typeAnnotation);
 	    }
 	    return node;
 	  }
@@ -31616,9 +31408,7 @@ function requireLib () {
 	    } else if (this.isContextual(129)) {
 	      if (!this.hasFollowingLineBreak()) {
 	        node.abstract = true;
-	        this.raise(TSErrors.NonClassMethodPropertyHasAbstractModifer, {
-	          at: node
-	        });
+	        this.raise(TSErrors.NonClassMethodPropertyHasAbstractModifer, node);
 	        return this.tsParseInterfaceDeclaration(node);
 	      }
 	    } else {
@@ -31633,8 +31423,7 @@ function requireLib () {
 	        const {
 	          key
 	        } = method;
-	        this.raise(TSErrors.AbstractMethodHasImplementation, {
-	          at: method,
+	        this.raise(TSErrors.AbstractMethodHasImplementation, method, {
 	          methodName: key.type === "Identifier" && !method.computed ? key.name : `[${this.input.slice(key.start, key.end)}]`
 	        });
 	      }
@@ -31716,9 +31505,7 @@ function requireLib () {
 	      }
 	    }
 	    if (hasTypeSpecifier && isInTypeOnlyImportExport) {
-	      this.raise(isImport ? TSErrors.TypeModifierIsUsedInTypeImports : TSErrors.TypeModifierIsUsedInTypeExports, {
-	        at: loc
-	      });
+	      this.raise(isImport ? TSErrors.TypeModifierIsUsedInTypeImports : TSErrors.TypeModifierIsUsedInTypeExports, loc);
 	    }
 	    node[leftOfAsKey] = leftOfAs;
 	    node[rightOfAsKey] = rightOfAs;
@@ -31905,9 +31692,7 @@ function requireLib () {
 	        node.body = this.finishPlaceholder(placeholder, "ClassBody");
 	        return this.finishNode(node, type);
 	      } else {
-	        throw this.raise(PlaceholderErrors.ClassNameIsRequired, {
-	          at: this.state.startLoc
-	        });
+	        throw this.raise(PlaceholderErrors.ClassNameIsRequired, this.state.startLoc);
 	      }
 	    } else {
 	      this.parseClassId(node, isStatement, optionalId);
@@ -31985,9 +31770,7 @@ function requireLib () {
 	  }
 	  assertNoSpace() {
 	    if (this.state.start > this.state.lastTokEndLoc.index) {
-	      this.raise(PlaceholderErrors.UnexpectedSpace, {
-	        at: this.state.lastTokEndLoc
-	      });
+	      this.raise(PlaceholderErrors.UnexpectedSpace, this.state.lastTokEndLoc);
 	    }
 	  }
 	};
@@ -32176,9 +31959,7 @@ function requireLib () {
 	    const name = key.type === "Identifier" ? key.name : key.value;
 	    if (name === "__proto__") {
 	      if (isRecord) {
-	        this.raise(Errors.RecordNoProto, {
-	          at: key
-	        });
+	        this.raise(Errors.RecordNoProto, key);
 	        return;
 	      }
 	      if (protoRef.used) {
@@ -32187,9 +31968,7 @@ function requireLib () {
 	            refExpressionErrors.doubleProtoLoc = key.loc.start;
 	          }
 	        } else {
-	          this.raise(Errors.DuplicateProto, {
-	            at: key
-	          });
+	          this.raise(Errors.DuplicateProto, key);
 	        }
 	      }
 	      protoRef.used = true;
@@ -32206,7 +31985,7 @@ function requireLib () {
 	      this.unexpected();
 	    }
 	    this.finalizeRemainingComments();
-	    expr.comments = this.state.comments;
+	    expr.comments = this.comments;
 	    expr.errors = this.state.errors;
 	    if (this.options.tokens) {
 	      expr.tokens = this.tokens;
@@ -32339,8 +32118,7 @@ function requireLib () {
 	    if (this.isPrivateName(left)) {
 	      const value = this.getPrivateNameSV(left);
 	      if (minPrec >= tokenOperatorPrecedence(58) || !this.prodParam.hasIn || !this.match(58)) {
-	        this.raise(Errors.PrivateInExpectedIn, {
-	          at: left,
+	        this.raise(Errors.PrivateInExpectedIn, left, {
 	          identifierName: value
 	        });
 	      }
@@ -32370,18 +32148,14 @@ function requireLib () {
 	          proposal: "minimal"
 	        }])) {
 	          if (this.state.type === 96 && this.prodParam.hasAwait) {
-	            throw this.raise(Errors.UnexpectedAwaitAfterPipelineBody, {
-	              at: this.state.startLoc
-	            });
+	            throw this.raise(Errors.UnexpectedAwaitAfterPipelineBody, this.state.startLoc);
 	          }
 	        }
 	        node.right = this.parseExprOpRightExpr(op, prec);
 	        const finishedNode = this.finishNode(node, logical || coalesce ? "LogicalExpression" : "BinaryExpression");
 	        const nextOp = this.state.type;
 	        if (coalesce && (nextOp === 41 || nextOp === 42) || logical && nextOp === 40) {
-	          throw this.raise(Errors.MixingCoalesceWithLogical, {
-	            at: this.state.startLoc
-	          });
+	          throw this.raise(Errors.MixingCoalesceWithLogical, this.state.startLoc);
 	        }
 	        return this.parseExprOp(finishedNode, leftStartLoc, minPrec);
 	      }
@@ -32400,9 +32174,7 @@ function requireLib () {
 	          case "smart":
 	            return this.withTopicBindingContext(() => {
 	              if (this.prodParam.hasYield && this.isContextual(108)) {
-	                throw this.raise(Errors.PipeBodyIsTighter, {
-	                  at: this.state.startLoc
-	                });
+	                throw this.raise(Errors.PipeBodyIsTighter, this.state.startLoc);
 	              }
 	              return this.parseSmartPipelineBodyInStyle(this.parseExprOpBaseRightExpr(op, prec), startLoc);
 	            });
@@ -32427,23 +32199,18 @@ function requireLib () {
 	    const body = this.parseMaybeAssign();
 	    const requiredParentheses = UnparenthesizedPipeBodyDescriptions.has(body.type);
 	    if (requiredParentheses && !((_body$extra = body.extra) != null && _body$extra.parenthesized)) {
-	      this.raise(Errors.PipeUnparenthesizedBody, {
-	        at: startLoc,
+	      this.raise(Errors.PipeUnparenthesizedBody, startLoc, {
 	        type: body.type
 	      });
 	    }
 	    if (!this.topicReferenceWasUsedInCurrentContext()) {
-	      this.raise(Errors.PipeTopicUnused, {
-	        at: startLoc
-	      });
+	      this.raise(Errors.PipeTopicUnused, startLoc);
 	    }
 	    return body;
 	  }
 	  checkExponentialAfterUnary(node) {
 	    if (this.match(57)) {
-	      this.raise(Errors.UnexpectedTokenUnaryExponentiation, {
-	        at: node.argument
-	      });
+	      this.raise(Errors.UnexpectedTokenUnaryExponentiation, node.argument);
 	    }
 	  }
 	  parseMaybeUnary(refExpressionErrors, sawUnary) {
@@ -32470,13 +32237,9 @@ function requireLib () {
 	      if (this.state.strict && isDelete) {
 	        const arg = node.argument;
 	        if (arg.type === "Identifier") {
-	          this.raise(Errors.StrictDelete, {
-	            at: node
-	          });
+	          this.raise(Errors.StrictDelete, node);
 	        } else if (this.hasPropertyAsPrivateName(arg)) {
-	          this.raise(Errors.DeletePrivateField, {
-	            at: node
-	          });
+	          this.raise(Errors.DeletePrivateField, node);
 	        }
 	      }
 	      if (!update) {
@@ -32493,9 +32256,7 @@ function requireLib () {
 	      } = this.state;
 	      const startsExpr = this.hasPlugin("v8intrinsic") ? tokenCanStartExpression(type) : tokenCanStartExpression(type) && !this.match(54);
 	      if (startsExpr && !this.isAmbiguousAwait()) {
-	        this.raiseOverwrite(Errors.AwaitNotInAsyncContext, {
-	          at: startLoc
-	        });
+	        this.raiseOverwrite(Errors.AwaitNotInAsyncContext, startLoc);
 	        return this.parseAwait(startLoc);
 	      }
 	    }
@@ -32557,9 +32318,7 @@ function requireLib () {
 	    let optional = false;
 	    if (type === 18) {
 	      if (noCalls) {
-	        this.raise(Errors.OptionalChainingNoNew, {
-	          at: this.state.startLoc
-	        });
+	        this.raise(Errors.OptionalChainingNoNew, this.state.startLoc);
 	        if (this.lookaheadCharCode() === 40) {
 	          state.stop = true;
 	          return base;
@@ -32589,9 +32348,7 @@ function requireLib () {
 	      this.expect(3);
 	    } else if (this.match(138)) {
 	      if (base.type === "Super") {
-	        this.raise(Errors.SuperPrivateField, {
-	          at: startLoc
-	        });
+	        this.raise(Errors.SuperPrivateField, startLoc);
 	      }
 	      this.classScope.usePrivateName(this.state.value, this.state.startLoc);
 	      node.property = this.parsePrivateName();
@@ -32661,9 +32418,7 @@ function requireLib () {
 	    node.tag = base;
 	    node.quasi = this.parseTemplate(true);
 	    if (state.optionalChainMember) {
-	      this.raise(Errors.OptionalChainingNoTemplate, {
-	        at: startLoc
-	      });
+	      this.raise(Errors.OptionalChainingNoTemplate, startLoc);
 	    }
 	    return this.finishNode(node, "TaggedTemplateExpression");
 	  }
@@ -32685,16 +32440,13 @@ function requireLib () {
 	        }
 	      }
 	      if (node.arguments.length === 0 || node.arguments.length > 2) {
-	        this.raise(Errors.ImportCallArity, {
-	          at: node,
+	        this.raise(Errors.ImportCallArity, node, {
 	          maxArgumentCount: this.hasPlugin("importAttributes") || this.hasPlugin("importAssertions") || this.hasPlugin("moduleAttributes") ? 2 : 1
 	        });
 	      } else {
 	        for (const arg of node.arguments) {
 	          if (arg.type === "SpreadElement") {
-	            this.raise(Errors.ImportCallSpreadArgument, {
-	              at: arg
-	            });
+	            this.raise(Errors.ImportCallSpreadArgument, arg);
 	          }
 	        }
 	      }
@@ -32713,9 +32465,7 @@ function requireLib () {
 	        this.expect(12);
 	        if (this.match(close)) {
 	          if (dynamicImport && !this.hasPlugin("importAttributes") && !this.hasPlugin("importAssertions") && !this.hasPlugin("moduleAttributes")) {
-	            this.raise(Errors.ImportCallArgumentTrailingComma, {
-	              at: this.state.lastTokStartLoc
-	            });
+	            this.raise(Errors.ImportCallArgumentTrailingComma, this.state.lastTokStartLoc);
 	          }
 	          if (nodeForExtra) {
 	            this.addTrailingCommaExtraToNode(nodeForExtra);
@@ -32771,9 +32521,7 @@ function requireLib () {
 	            return this.finishNode(node, "Import");
 	          }
 	        } else {
-	          this.raise(Errors.UnsupportedImport, {
-	            at: this.state.lastTokStartLoc
-	          });
+	          this.raise(Errors.UnsupportedImport, this.state.lastTokStartLoc);
 	          return this.finishNode(node, "Import");
 	        }
 	      case 78:
@@ -32847,15 +32595,12 @@ function requireLib () {
 	          if (callee.type === "MemberExpression") {
 	            return this.finishNode(node, "BindExpression");
 	          } else {
-	            throw this.raise(Errors.UnsupportedBind, {
-	              at: callee
-	            });
+	            throw this.raise(Errors.UnsupportedBind, callee);
 	          }
 	        }
 	      case 138:
 	        {
-	          this.raise(Errors.PrivateInExpectedIn, {
-	            at: this.state.startLoc,
+	          this.raise(Errors.PrivateInExpectedIn, this.state.startLoc, {
 	            identifierName: this.state.value
 	          });
 	          return this.parsePrivateName();
@@ -32955,15 +32700,12 @@ function requireLib () {
 	    if (this.testTopicReferenceConfiguration(pipeProposal, startLoc, tokenType)) {
 	      const nodeType = pipeProposal === "smart" ? "PipelinePrimaryTopicReference" : "TopicReference";
 	      if (!this.topicReferenceIsAllowedInCurrentContext()) {
-	        this.raise(pipeProposal === "smart" ? Errors.PrimaryTopicNotAllowed : Errors.PipeTopicUnbound, {
-	          at: startLoc
-	        });
+	        this.raise(pipeProposal === "smart" ? Errors.PrimaryTopicNotAllowed : Errors.PipeTopicUnbound, startLoc);
 	      }
 	      this.registerTopicReference();
 	      return this.finishNode(node, nodeType);
 	    } else {
-	      throw this.raise(Errors.PipeTopicUnconfiguredToken, {
-	        at: startLoc,
+	      throw this.raise(Errors.PipeTopicUnconfiguredToken, startLoc, {
 	        token: tokenLabelName(tokenType)
 	      });
 	    }
@@ -32979,9 +32721,7 @@ function requireLib () {
 	      case "smart":
 	        return tokenType === 27;
 	      default:
-	        throw this.raise(Errors.PipeTopicRequiresHackPipes, {
-	          at: startLoc
-	        });
+	        throw this.raise(Errors.PipeTopicRequiresHackPipes, startLoc);
 	    }
 	  }
 	  parseAsyncArrowUnaryFunction(node) {
@@ -32989,9 +32729,7 @@ function requireLib () {
 	    const params = [this.parseIdentifier()];
 	    this.prodParam.exit();
 	    if (this.hasPrecedingLineBreak()) {
-	      this.raise(Errors.LineTerminatorBeforeArrow, {
-	        at: this.state.curPosition()
-	      });
+	      this.raise(Errors.LineTerminatorBeforeArrow, this.state.curPosition());
 	    }
 	    this.expect(19);
 	    return this.parseArrowExpression(node, params, true);
@@ -33019,18 +32757,12 @@ function requireLib () {
 	    const node = this.startNode();
 	    this.next();
 	    if (this.match(10) && !this.scope.allowDirectSuper && !this.options.allowSuperOutsideMethod) {
-	      this.raise(Errors.SuperNotAllowed, {
-	        at: node
-	      });
+	      this.raise(Errors.SuperNotAllowed, node);
 	    } else if (!this.scope.allowSuper && !this.options.allowSuperOutsideMethod) {
-	      this.raise(Errors.UnexpectedSuper, {
-	        at: node
-	      });
+	      this.raise(Errors.UnexpectedSuper, node);
 	    }
 	    if (!this.match(10) && !this.match(0) && !this.match(16)) {
-	      this.raise(Errors.UnsupportedSuper, {
-	        at: node
-	      });
+	      this.raise(Errors.UnsupportedSuper, node);
 	    }
 	    return this.finishNode(node, "Super");
 	  }
@@ -33062,8 +32794,7 @@ function requireLib () {
 	    const containsEsc = this.state.containsEsc;
 	    node.property = this.parseIdentifier(true);
 	    if (node.property.name !== propertyName || containsEsc) {
-	      this.raise(Errors.UnsupportedMetaProperty, {
-	        at: node.property,
+	      this.raise(Errors.UnsupportedMetaProperty, node.property, {
 	        target: meta.name,
 	        onlyValidPropertyName: propertyName
 	      });
@@ -33075,9 +32806,7 @@ function requireLib () {
 	    this.next();
 	    if (this.isContextual(101)) {
 	      if (!this.inModule) {
-	        this.raise(Errors.ImportMetaOutsideModule, {
-	          at: id
-	        });
+	        this.raise(Errors.ImportMetaOutsideModule, id);
 	      }
 	      this.sawUnambiguousESM = true;
 	    } else if (this.isContextual(105) || this.isContextual(97)) {
@@ -33085,8 +32814,7 @@ function requireLib () {
 	      if (!isSource) this.unexpected();
 	      this.expectPlugin(isSource ? "sourcePhaseImports" : "deferredImportEvaluation");
 	      if (!this.options.createImportExpressions) {
-	        throw this.raise(Errors.DynamicImportPhaseRequiresImportExpressions, {
-	          at: this.state.startLoc,
+	        throw this.raise(Errors.DynamicImportPhaseRequiresImportExpressions, this.state.startLoc, {
 	          phase: this.state.value
 	        });
 	      }
@@ -33232,9 +32960,7 @@ function requireLib () {
 	      this.next();
 	      const metaProp = this.parseMetaProperty(node, meta, "target");
 	      if (!this.scope.inNonArrowFunction && !this.scope.inClass && !this.options.allowNewTargetOutsideFunction) {
-	        this.raise(Errors.UnexpectedNewTarget, {
-	          at: metaProp
-	        });
+	        this.raise(Errors.UnexpectedNewTarget, metaProp);
 	      }
 	      return metaProp;
 	    }
@@ -33256,9 +32982,7 @@ function requireLib () {
 	    const callee = this.parseNoCallExpr();
 	    node.callee = callee;
 	    if (isImport && (callee.type === "Import" || callee.type === "ImportExpression")) {
-	      this.raise(Errors.ImportCallNotNewExpression, {
-	        at: callee
-	      });
+	      this.raise(Errors.ImportCallNotNewExpression, callee);
 	    }
 	  }
 	  parseTemplateElement(isTagged) {
@@ -33272,9 +32996,7 @@ function requireLib () {
 	    const elem = this.startNodeAt(createPositionWithColumnOffset(startLoc, 1));
 	    if (value === null) {
 	      if (!isTagged) {
-	        this.raise(Errors.InvalidEscapeSequenceTemplate, {
-	          at: createPositionWithColumnOffset(this.state.firstInvalidTemplateEscapePos, 1)
-	        });
+	        this.raise(Errors.InvalidEscapeSequenceTemplate, createPositionWithColumnOffset(this.state.firstInvalidTemplateEscapePos, 1));
 	      }
 	    }
 	    const isTail = this.match(24);
@@ -33334,9 +33056,7 @@ function requireLib () {
 	        this.checkProto(prop, isRecord, propHash, refExpressionErrors);
 	      }
 	      if (isRecord && !this.isObjectProperty(prop) && prop.type !== "SpreadElement") {
-	        this.raise(Errors.InvalidRecordProperty, {
-	          at: prop
-	        });
+	        this.raise(Errors.InvalidRecordProperty, prop);
 	      }
 	      if (prop.shorthand) {
 	        this.addExtra(prop, "shorthand", true);
@@ -33354,7 +33074,7 @@ function requireLib () {
 	    return this.finishNode(node, type);
 	  }
 	  addTrailingCommaExtraToNode(node) {
-	    this.addExtra(node, "trailingComma", this.state.lastTokStart);
+	    this.addExtra(node, "trailingComma", this.state.lastTokStartLoc.index);
 	    this.addExtra(node, "trailingCommaLoc", this.state.lastTokStartLoc, false);
 	  }
 	  maybeAsyncOrAccessorProp(prop) {
@@ -33364,9 +33084,7 @@ function requireLib () {
 	    let decorators = [];
 	    if (this.match(26)) {
 	      if (this.hasPlugin("decorators")) {
-	        this.raise(Errors.UnsupportedPropertyDecorator, {
-	          at: this.state.startLoc
-	        });
+	        this.raise(Errors.UnsupportedPropertyDecorator, this.state.startLoc);
 	      }
 	      while (this.match(26)) {
 	        decorators.push(this.parseDecorator());
@@ -33406,8 +33124,7 @@ function requireLib () {
 	        prop.kind = keyName;
 	        if (this.match(55)) {
 	          isGenerator = true;
-	          this.raise(Errors.AccessorIsGenerator, {
-	            at: this.state.curPosition(),
+	          this.raise(Errors.AccessorIsGenerator, this.state.curPosition(), {
 	            kind: keyName
 	          });
 	          this.next();
@@ -33428,14 +33145,10 @@ function requireLib () {
 	    const paramCount = this.getGetterSetterExpectedParamCount(method);
 	    const params = this.getObjectOrClassMethodParams(method);
 	    if (params.length !== paramCount) {
-	      this.raise(method.kind === "get" ? Errors.BadGetterArity : Errors.BadSetterArity, {
-	        at: method
-	      });
+	      this.raise(method.kind === "get" ? Errors.BadGetterArity : Errors.BadSetterArity, method);
 	    }
 	    if (method.kind === "set" && ((_params = params[params.length - 1]) == null ? void 0 : _params.type) === "RestElement") {
-	      this.raise(Errors.BadSetterRestParameter, {
-	        at: method
-	      });
+	      this.raise(Errors.BadSetterRestParameter, method);
 	    }
 	  }
 	  parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) {
@@ -33468,9 +33181,7 @@ function requireLib () {
 	            refExpressionErrors.shorthandAssignLoc = shorthandAssignLoc;
 	          }
 	        } else {
-	          this.raise(Errors.InvalidCoverInitializedName, {
-	            at: shorthandAssignLoc
-	          });
+	          this.raise(Errors.InvalidCoverInitializedName, shorthandAssignLoc);
 	        }
 	        prop.value = this.parseMaybeDefault(startLoc, cloneIdentifier(prop.key));
 	      } else {
@@ -33520,9 +33231,7 @@ function requireLib () {
 	                  refExpressionErrors.privateKeyLoc = privateKeyLoc;
 	                }
 	              } else {
-	                this.raise(Errors.UnexpectedPrivateField, {
-	                  at: privateKeyLoc
-	                });
+	                this.raise(Errors.UnexpectedPrivateField, privateKeyLoc);
 	              }
 	              key = this.parsePrivateName();
 	              break;
@@ -33608,9 +33317,7 @@ function requireLib () {
 	      node.body = this.parseBlock(true, false, hasStrictModeDirective => {
 	        const nonSimple = !this.isSimpleParamList(node.params);
 	        if (hasStrictModeDirective && nonSimple) {
-	          this.raise(Errors.IllegalLanguageModeDirective, {
-	            at: (node.kind === "method" || node.kind === "constructor") && !!node.key ? node.key.loc.end : node
-	          });
+	          this.raise(Errors.IllegalLanguageModeDirective, (node.kind === "method" || node.kind === "constructor") && !!node.key ? node.key.loc.end : node);
 	        }
 	        const strictModeChanged = !oldStrict && this.state.strict;
 	        this.checkParams(node, !this.state.strict && !allowExpression && !isMethod && !nonSimple, allowExpression, strictModeChanged);
@@ -33670,8 +33377,7 @@ function requireLib () {
 	    let elt;
 	    if (this.match(12)) {
 	      if (!allowEmpty) {
-	        this.raise(Errors.UnexpectedToken, {
-	          at: this.state.curPosition(),
+	        this.raise(Errors.UnexpectedToken, this.state.curPosition(), {
 	          unexpected: ","
 	        });
 	      }
@@ -33682,9 +33388,7 @@ function requireLib () {
 	    } else if (this.match(17)) {
 	      this.expectPlugin("partialApplication");
 	      if (!allowPlaceholder) {
-	        this.raise(Errors.UnexpectedArgumentPlaceholder, {
-	          at: this.state.startLoc
-	        });
+	        this.raise(Errors.UnexpectedArgumentPlaceholder, this.state.startLoc);
 	      }
 	      const node = this.startNode();
 	      this.next();
@@ -33734,47 +33438,35 @@ function requireLib () {
 	      return;
 	    }
 	    if (checkKeywords && isKeyword(word)) {
-	      this.raise(Errors.UnexpectedKeyword, {
-	        at: startLoc,
+	      this.raise(Errors.UnexpectedKeyword, startLoc, {
 	        keyword: word
 	      });
 	      return;
 	    }
 	    const reservedTest = !this.state.strict ? isReservedWord : isBinding ? isStrictBindReservedWord : isStrictReservedWord;
 	    if (reservedTest(word, this.inModule)) {
-	      this.raise(Errors.UnexpectedReservedWord, {
-	        at: startLoc,
+	      this.raise(Errors.UnexpectedReservedWord, startLoc, {
 	        reservedWord: word
 	      });
 	      return;
 	    } else if (word === "yield") {
 	      if (this.prodParam.hasYield) {
-	        this.raise(Errors.YieldBindingIdentifier, {
-	          at: startLoc
-	        });
+	        this.raise(Errors.YieldBindingIdentifier, startLoc);
 	        return;
 	      }
 	    } else if (word === "await") {
 	      if (this.prodParam.hasAwait) {
-	        this.raise(Errors.AwaitBindingIdentifier, {
-	          at: startLoc
-	        });
+	        this.raise(Errors.AwaitBindingIdentifier, startLoc);
 	        return;
 	      }
 	      if (this.scope.inStaticBlock) {
-	        this.raise(Errors.AwaitBindingIdentifierInStaticBlock, {
-	          at: startLoc
-	        });
+	        this.raise(Errors.AwaitBindingIdentifierInStaticBlock, startLoc);
 	        return;
 	      }
-	      this.expressionScope.recordAsyncArrowParametersError({
-	        at: startLoc
-	      });
+	      this.expressionScope.recordAsyncArrowParametersError(startLoc);
 	    } else if (word === "arguments") {
 	      if (this.scope.inClassAndNotInNonArrowFunction) {
-	        this.raise(Errors.ArgumentsInClass, {
-	          at: startLoc
-	        });
+	        this.raise(Errors.ArgumentsInClass, startLoc);
 	        return;
 	      }
 	    }
@@ -33788,13 +33480,9 @@ function requireLib () {
 	  }
 	  parseAwait(startLoc) {
 	    const node = this.startNodeAt(startLoc);
-	    this.expressionScope.recordParameterInitializerError(Errors.AwaitExpressionFormalParameter, {
-	      at: node
-	    });
+	    this.expressionScope.recordParameterInitializerError(Errors.AwaitExpressionFormalParameter, node);
 	    if (this.eat(55)) {
-	      this.raise(Errors.ObsoleteAwaitStar, {
-	        at: node
-	      });
+	      this.raise(Errors.ObsoleteAwaitStar, node);
 	    }
 	    if (!this.scope.inFunction && !this.options.allowAwaitOutsideFunction) {
 	      if (this.isAmbiguousAwait()) {
@@ -33817,9 +33505,7 @@ function requireLib () {
 	  }
 	  parseYield() {
 	    const node = this.startNode();
-	    this.expressionScope.recordParameterInitializerError(Errors.YieldInParameter, {
-	      at: node
-	    });
+	    this.expressionScope.recordParameterInitializerError(Errors.YieldInParameter, node);
 	    this.next();
 	    let delegating = false;
 	    let argument = null;
@@ -33864,9 +33550,7 @@ function requireLib () {
 	      proposal: "smart"
 	    }])) {
 	      if (left.type === "SequenceExpression") {
-	        this.raise(Errors.PipelineHeadSequenceExpression, {
-	          at: leftStartLoc
-	        });
+	        this.raise(Errors.PipelineHeadSequenceExpression, leftStartLoc);
 	      }
 	    }
 	  }
@@ -33894,14 +33578,10 @@ function requireLib () {
 	  }
 	  checkSmartPipeTopicBodyEarlyErrors(startLoc) {
 	    if (this.match(19)) {
-	      throw this.raise(Errors.PipelineBodyNoArrow, {
-	        at: this.state.startLoc
-	      });
+	      throw this.raise(Errors.PipelineBodyNoArrow, this.state.startLoc);
 	    }
 	    if (!this.topicReferenceWasUsedInCurrentContext()) {
-	      this.raise(Errors.PipelineTopicUnused, {
-	        at: startLoc
-	      });
+	      this.raise(Errors.PipelineTopicUnused, startLoc);
 	    }
 	  }
 	  withTopicBindingContext(callback) {
@@ -34008,10 +33688,10 @@ function requireLib () {
 	  parsePropertyNamePrefixOperator(prop) {}
 	}
 	const loopLabel = {
-	    kind: "loop"
+	    kind: 1
 	  },
 	  switchLabel = {
-	    kind: "switch"
+	    kind: 2
 	  };
 	const loneSurrogate = /[\uD800-\uDFFF]/u;
 	const keywordRelationalOperator = /in(?:stanceof)?/y;
@@ -34125,7 +33805,7 @@ function requireLib () {
 	class StatementParser extends ExpressionParser {
 	  parseTopLevel(file, program) {
 	    file.program = this.parseProgram(program);
-	    file.comments = this.state.comments;
+	    file.comments = this.comments;
 	    if (this.options.tokens) {
 	      file.tokens = babel7CompatTokens(this.tokens, this.input);
 	    }
@@ -34137,8 +33817,7 @@ function requireLib () {
 	    this.parseBlockBody(program, true, true, end);
 	    if (this.inModule && !this.options.allowUndeclaredExports && this.scope.undefinedExports.size > 0) {
 	      for (const [localName, at] of Array.from(this.scope.undefinedExports)) {
-	        this.raise(Errors.ModuleExportUndefined, {
-	          at,
+	        this.raise(Errors.ModuleExportUndefined, at, {
 	          localName
 	        });
 	      }
@@ -34280,9 +33959,7 @@ function requireLib () {
 	      case 68:
 	        if (this.lookaheadCharCode() === 46) break;
 	        if (!allowFunctionDeclaration) {
-	          this.raise(this.state.strict ? Errors.StrictFunction : this.options.annexB ? Errors.SloppyFunctionAnnexB : Errors.SloppyFunction, {
-	            at: this.state.startLoc
-	          });
+	          this.raise(this.state.strict ? Errors.StrictFunction : this.options.annexB ? Errors.SloppyFunctionAnnexB : Errors.SloppyFunction, this.state.startLoc);
 	        }
 	        return this.parseFunctionStatement(node, false, !allowDeclaration && allowFunctionDeclaration);
 	      case 80:
@@ -34301,13 +33978,9 @@ function requireLib () {
 	      case 96:
 	        if (!this.state.containsEsc && this.startsAwaitUsing()) {
 	          if (!this.isAwaitAllowed()) {
-	            this.raise(Errors.AwaitUsingNotInAsyncContext, {
-	              at: node
-	            });
+	            this.raise(Errors.AwaitUsingNotInAsyncContext, node);
 	          } else if (!allowDeclaration) {
-	            this.raise(Errors.UnexpectedLexicalDeclaration, {
-	              at: node
-	            });
+	            this.raise(Errors.UnexpectedLexicalDeclaration, node);
 	          }
 	          this.next();
 	          return this.parseVarStatement(node, "await using");
@@ -34319,13 +33992,9 @@ function requireLib () {
 	        }
 	        this.expectPlugin("explicitResourceManagement");
 	        if (!this.scope.inModule && this.scope.inTopLevel) {
-	          this.raise(Errors.UnexpectedUsingDeclaration, {
-	            at: this.state.startLoc
-	          });
+	          this.raise(Errors.UnexpectedUsingDeclaration, this.state.startLoc);
 	        } else if (!allowDeclaration) {
-	          this.raise(Errors.UnexpectedLexicalDeclaration, {
-	            at: this.state.startLoc
-	          });
+	          this.raise(Errors.UnexpectedLexicalDeclaration, this.state.startLoc);
 	        }
 	        return this.parseVarStatement(node, "using");
 	      case 100:
@@ -34345,9 +34014,7 @@ function requireLib () {
 	      case 75:
 	        {
 	          if (!allowDeclaration) {
-	            this.raise(Errors.UnexpectedLexicalDeclaration, {
-	              at: this.state.startLoc
-	            });
+	            this.raise(Errors.UnexpectedLexicalDeclaration, this.state.startLoc);
 	          }
 	        }
 	      case 74:
@@ -34373,9 +34040,7 @@ function requireLib () {
 	      case 82:
 	        {
 	          if (!this.options.allowImportExportEverywhere && !topLevel) {
-	            this.raise(Errors.UnexpectedImportExport, {
-	              at: this.state.startLoc
-	            });
+	            this.raise(Errors.UnexpectedImportExport, this.state.startLoc);
 	          }
 	          this.next();
 	          let result;
@@ -34397,9 +34062,7 @@ function requireLib () {
 	        {
 	          if (this.isAsyncFunction()) {
 	            if (!allowDeclaration) {
-	              this.raise(Errors.AsyncFunctionInSingleStatementContext, {
-	                at: this.state.startLoc
-	              });
+	              this.raise(Errors.AsyncFunctionInSingleStatementContext, this.state.startLoc);
 	            }
 	            this.next();
 	            return this.parseFunctionStatement(node, true, !allowDeclaration && allowFunctionDeclaration);
@@ -34416,9 +34079,7 @@ function requireLib () {
 	  }
 	  assertModuleNodeAllowed(node) {
 	    if (!this.options.allowImportExportEverywhere && !this.inModule) {
-	      this.raise(Errors.ImportOutsideModule, {
-	        at: node
-	      });
+	      this.raise(Errors.ImportOutsideModule, node);
 	    }
 	  }
 	  decoratorsEnabledBeforeExport() {
@@ -34429,9 +34090,7 @@ function requireLib () {
 	    if (maybeDecorators) {
 	      if (classNode.decorators && classNode.decorators.length > 0) {
 	        if (typeof this.getPluginOption("decorators", "decoratorsBeforeExport") !== "boolean") {
-	          this.raise(Errors.DecoratorsBeforeAfterExport, {
-	            at: classNode.decorators[0]
-	          });
+	          this.raise(Errors.DecoratorsBeforeAfterExport, classNode.decorators[0]);
 	        }
 	        classNode.decorators.unshift(...maybeDecorators);
 	      } else {
@@ -34455,14 +34114,10 @@ function requireLib () {
 	        this.unexpected();
 	      }
 	      if (!this.decoratorsEnabledBeforeExport()) {
-	        this.raise(Errors.DecoratorExportClass, {
-	          at: this.state.startLoc
-	        });
+	        this.raise(Errors.DecoratorExportClass, this.state.startLoc);
 	      }
 	    } else if (!this.canHaveLeadingDecorator()) {
-	      throw this.raise(Errors.UnexpectedLeadingDecorator, {
-	        at: this.state.startLoc
-	      });
+	      throw this.raise(Errors.UnexpectedLeadingDecorator, this.state.startLoc);
 	    }
 	    return decorators;
 	  }
@@ -34482,9 +34137,7 @@ function requireLib () {
 	        const paramsStartLoc = this.state.startLoc;
 	        node.expression = this.parseMaybeDecoratorArguments(expr);
 	        if (this.getPluginOption("decorators", "allowCallParenthesized") === false && node.expression !== expr) {
-	          this.raise(Errors.DecoratorArgumentsOutsideParentheses, {
-	            at: paramsStartLoc
-	          });
+	          this.raise(Errors.DecoratorArgumentsOutsideParentheses, paramsStartLoc);
 	        }
 	      } else {
 	        expr = this.parseIdentifier(false);
@@ -34533,14 +34186,15 @@ function requireLib () {
 	    for (i = 0; i < this.state.labels.length; ++i) {
 	      const lab = this.state.labels[i];
 	      if (node.label == null || lab.name === node.label.name) {
-	        if (lab.kind != null && (isBreak || lab.kind === "loop")) break;
+	        if (lab.kind != null && (isBreak || lab.kind === 1)) {
+	          break;
+	        }
 	        if (node.label && isBreak) break;
 	      }
 	    }
 	    if (i === this.state.labels.length) {
 	      const type = isBreak ? "BreakStatement" : "ContinueStatement";
-	      this.raise(Errors.IllegalBreakContinue, {
-	        at: node,
+	      this.raise(Errors.IllegalBreakContinue, node, {
 	        type
 	      });
 	    }
@@ -34592,9 +34246,7 @@ function requireLib () {
 	        if (startsWithAwaitUsing) {
 	          kind = "await using";
 	          if (!this.isAwaitAllowed()) {
-	            this.raise(Errors.AwaitUsingNotInAsyncContext, {
-	              at: this.state.startLoc
-	            });
+	            this.raise(Errors.AwaitUsingNotInAsyncContext, this.state.startLoc);
 	          }
 	          this.next();
 	        } else {
@@ -34605,9 +34257,7 @@ function requireLib () {
 	        const init = this.finishNode(initNode, "VariableDeclaration");
 	        const isForIn = this.match(58);
 	        if (isForIn && starsWithUsingDeclaration) {
-	          this.raise(Errors.ForInUsing, {
-	            at: init
-	          });
+	          this.raise(Errors.ForInUsing, init);
 	        }
 	        if ((isForIn || this.isContextual(102)) && init.declarations.length === 1) {
 	          return this.parseForIn(node, init, awaitAt);
@@ -34624,14 +34274,10 @@ function requireLib () {
 	    const isForOf = this.isContextual(102);
 	    if (isForOf) {
 	      if (startsWithLet) {
-	        this.raise(Errors.ForOfLet, {
-	          at: init
-	        });
+	        this.raise(Errors.ForOfLet, init);
 	      }
 	      if (awaitAt === null && startsWithAsync && init.type === "Identifier") {
-	        this.raise(Errors.ForOfAsync, {
-	          at: init
-	        });
+	        this.raise(Errors.ForOfAsync, init);
 	      }
 	    }
 	    if (isForOf || this.match(58)) {
@@ -34665,9 +34311,7 @@ function requireLib () {
 	  }
 	  parseReturnStatement(node) {
 	    if (!this.prodParam.hasReturn && !this.options.allowReturnOutsideFunction) {
-	      this.raise(Errors.IllegalReturn, {
-	        at: this.state.startLoc
-	      });
+	      this.raise(Errors.IllegalReturn, this.state.startLoc);
 	    }
 	    this.next();
 	    if (this.isLineTerminator()) {
@@ -34697,9 +34341,7 @@ function requireLib () {
 	          cur.test = this.parseExpression();
 	        } else {
 	          if (sawDefault) {
-	            this.raise(Errors.MultipleDefaultsInSwitch, {
-	              at: this.state.lastTokStartLoc
-	            });
+	            this.raise(Errors.MultipleDefaultsInSwitch, this.state.lastTokStartLoc);
 	          }
 	          sawDefault = true;
 	          cur.test = null;
@@ -34722,9 +34364,7 @@ function requireLib () {
 	  parseThrowStatement(node) {
 	    this.next();
 	    if (this.hasPrecedingLineBreak()) {
-	      this.raise(Errors.NewlineAfterThrow, {
-	        at: this.state.lastTokEndLoc
-	      });
+	      this.raise(Errors.NewlineAfterThrow, this.state.lastTokEndLoc);
 	    }
 	    node.argument = this.parseExpression();
 	    this.semicolon();
@@ -34762,9 +34402,7 @@ function requireLib () {
 	    }
 	    node.finalizer = this.eat(67) ? this.parseBlock() : null;
 	    if (!node.handler && !node.finalizer) {
-	      this.raise(Errors.NoCatchOrFinally, {
-	        at: node
-	      });
+	      this.raise(Errors.NoCatchOrFinally, node);
 	    }
 	    return this.finishNode(node, "TryStatement");
 	  }
@@ -34784,9 +34422,7 @@ function requireLib () {
 	  }
 	  parseWithStatement(node) {
 	    if (this.state.strict) {
-	      this.raise(Errors.StrictWith, {
-	        at: this.state.startLoc
-	      });
+	      this.raise(Errors.StrictWith, this.state.startLoc);
 	    }
 	    this.next();
 	    node.object = this.parseHeaderExpression();
@@ -34800,13 +34436,12 @@ function requireLib () {
 	  parseLabeledStatement(node, maybeName, expr, flags) {
 	    for (const label of this.state.labels) {
 	      if (label.name === maybeName) {
-	        this.raise(Errors.LabelRedeclaration, {
-	          at: expr,
+	        this.raise(Errors.LabelRedeclaration, expr, {
 	          labelName: maybeName
 	        });
 	      }
 	    }
-	    const kind = tokenIsLoop(this.state.type) ? "loop" : this.match(71) ? "switch" : null;
+	    const kind = tokenIsLoop(this.state.type) ? 1 : this.match(71) ? 2 : null;
 	    for (let i = this.state.labels.length - 1; i >= 0; i--) {
 	      const label = this.state.labels[i];
 	      if (label.statementStart === node.start) {
@@ -34902,14 +34537,12 @@ function requireLib () {
 	      node.await = awaitAt !== null;
 	    }
 	    if (init.type === "VariableDeclaration" && init.declarations[0].init != null && (!isForIn || !this.options.annexB || this.state.strict || init.kind !== "var" || init.declarations[0].id.type !== "Identifier")) {
-	      this.raise(Errors.ForInOfLoopInitializer, {
-	        at: init,
+	      this.raise(Errors.ForInOfLoopInitializer, init, {
 	        type: isForIn ? "ForInStatement" : "ForOfStatement"
 	      });
 	    }
 	    if (init.type === "AssignmentPattern") {
-	      this.raise(Errors.InvalidLhs, {
-	        at: init,
+	      this.raise(Errors.InvalidLhs, init, {
 	        ancestor: {
 	          type: "ForStatement"
 	        }
@@ -34932,13 +34565,11 @@ function requireLib () {
 	      decl.init = !this.eat(29) ? null : isFor ? this.parseMaybeAssignDisallowIn() : this.parseMaybeAssignAllowIn();
 	      if (decl.init === null && !allowMissingInitializer) {
 	        if (decl.id.type !== "Identifier" && !(isFor && (this.match(58) || this.isContextual(102)))) {
-	          this.raise(Errors.DeclarationMissingInitializer, {
-	            at: this.state.lastTokEndLoc,
+	          this.raise(Errors.DeclarationMissingInitializer, this.state.lastTokEndLoc, {
 	            kind: "destructuring"
 	          });
 	        } else if (kind === "const" && !(this.match(58) || this.isContextual(102))) {
-	          this.raise(Errors.DeclarationMissingInitializer, {
-	            at: this.state.lastTokEndLoc,
+	          this.raise(Errors.DeclarationMissingInitializer, this.state.lastTokEndLoc, {
 	            kind: "const"
 	          });
 	        }
@@ -34969,9 +34600,7 @@ function requireLib () {
 	    this.initFunction(node, isAsync);
 	    if (this.match(55)) {
 	      if (hangingDeclaration) {
-	        this.raise(Errors.GeneratorInSingleStatementContext, {
-	          at: this.state.startLoc
-	        });
+	        this.raise(Errors.GeneratorInSingleStatementContext, this.state.startLoc);
 	      }
 	      this.next();
 	      node.generator = true;
@@ -35043,9 +34672,7 @@ function requireLib () {
 	      while (!this.match(8)) {
 	        if (this.eat(13)) {
 	          if (decorators.length > 0) {
-	            throw this.raise(Errors.DecoratorSemicolon, {
-	              at: this.state.lastTokEndLoc
-	            });
+	            throw this.raise(Errors.DecoratorSemicolon, this.state.lastTokEndLoc);
 	          }
 	          continue;
 	        }
@@ -35061,18 +34688,14 @@ function requireLib () {
 	        }
 	        this.parseClassMember(classBody, member, state);
 	        if (member.kind === "constructor" && member.decorators && member.decorators.length > 0) {
-	          this.raise(Errors.DecoratorConstructor, {
-	            at: member
-	          });
+	          this.raise(Errors.DecoratorConstructor, member);
 	        }
 	      }
 	    });
 	    this.state.strict = oldStrict;
 	    this.next();
 	    if (decorators.length) {
-	      throw this.raise(Errors.TrailingDecorator, {
-	        at: this.state.startLoc
-	      });
+	      throw this.raise(Errors.TrailingDecorator, this.state.startLoc);
 	    }
 	    this.classScope.exit();
 	    return this.finishNode(classBody, "ClassBody");
@@ -35130,9 +34753,7 @@ function requireLib () {
 	        return;
 	      }
 	      if (this.isNonstaticConstructor(publicMethod)) {
-	        this.raise(Errors.ConstructorIsGenerator, {
-	          at: publicMethod.key
-	        });
+	        this.raise(Errors.ConstructorIsGenerator, publicMethod.key);
 	      }
 	      this.pushClassMethod(classBody, publicMethod, true, false, false, false);
 	      return;
@@ -35153,14 +34774,10 @@ function requireLib () {
 	      if (isConstructor) {
 	        publicMethod.kind = "constructor";
 	        if (state.hadConstructor && !this.hasPlugin("typescript")) {
-	          this.raise(Errors.DuplicateConstructor, {
-	            at: key
-	          });
+	          this.raise(Errors.DuplicateConstructor, key);
 	        }
 	        if (isConstructor && this.hasPlugin("typescript") && member.override) {
-	          this.raise(Errors.OverrideOnConstructor, {
-	            at: key
-	          });
+	          this.raise(Errors.OverrideOnConstructor, key);
 	        }
 	        state.hadConstructor = true;
 	        allowsDirectSuper = state.hadSuperClass;
@@ -35186,9 +34803,7 @@ function requireLib () {
 	        this.pushClassPrivateMethod(classBody, privateMethod, isGenerator, true);
 	      } else {
 	        if (this.isNonstaticConstructor(publicMethod)) {
-	          this.raise(Errors.ConstructorIsAsync, {
-	            at: publicMethod.key
-	          });
+	          this.raise(Errors.ConstructorIsAsync, publicMethod.key);
 	        }
 	        this.pushClassMethod(classBody, publicMethod, isGenerator, true, false, false);
 	      }
@@ -35201,9 +34816,7 @@ function requireLib () {
 	        this.pushClassPrivateMethod(classBody, privateMethod, false, false);
 	      } else {
 	        if (this.isNonstaticConstructor(publicMethod)) {
-	          this.raise(Errors.ConstructorIsAccessor, {
-	            at: publicMethod.key
-	          });
+	          this.raise(Errors.ConstructorIsAccessor, publicMethod.key);
 	        }
 	        this.pushClassMethod(classBody, publicMethod, false, false, false, false);
 	      }
@@ -35230,15 +34843,11 @@ function requireLib () {
 	      value
 	    } = this.state;
 	    if ((type === 132 || type === 133) && member.static && value === "prototype") {
-	      this.raise(Errors.StaticPrototype, {
-	        at: this.state.startLoc
-	      });
+	      this.raise(Errors.StaticPrototype, this.state.startLoc);
 	    }
 	    if (type === 138) {
 	      if (value === "constructor") {
-	        this.raise(Errors.ConstructorClassPrivateField, {
-	          at: this.state.startLoc
-	        });
+	        this.raise(Errors.ConstructorClassPrivateField, this.state.startLoc);
 	      }
 	      const key = this.parsePrivateName();
 	      member.key = key;
@@ -35259,16 +34868,12 @@ function requireLib () {
 	    this.state.labels = oldLabels;
 	    classBody.body.push(this.finishNode(member, "StaticBlock"));
 	    if ((_member$decorators = member.decorators) != null && _member$decorators.length) {
-	      this.raise(Errors.DecoratorStaticBlock, {
-	        at: member
-	      });
+	      this.raise(Errors.DecoratorStaticBlock, member);
 	    }
 	  }
 	  pushClassProperty(classBody, prop) {
 	    if (!prop.computed && (prop.key.name === "constructor" || prop.key.value === "constructor")) {
-	      this.raise(Errors.ConstructorClassField, {
-	        at: prop.key
-	      });
+	      this.raise(Errors.ConstructorClassField, prop.key);
 	    }
 	    classBody.body.push(this.parseClassProperty(prop));
 	  }
@@ -35281,9 +34886,7 @@ function requireLib () {
 	    if (!isPrivate && !prop.computed) {
 	      const key = prop.key;
 	      if (key.name === "constructor" || key.value === "constructor") {
-	        this.raise(Errors.ConstructorClassField, {
-	          at: key
-	        });
+	        this.raise(Errors.ConstructorClassField, key);
 	      }
 	    }
 	    const node = this.parseClassAccessorProperty(prop);
@@ -35339,9 +34942,7 @@ function requireLib () {
 	      if (optionalId || !isStatement) {
 	        node.id = null;
 	      } else {
-	        throw this.raise(Errors.MissingClassName, {
-	          at: this.state.startLoc
-	        });
+	        throw this.raise(Errors.MissingClassName, this.state.startLoc);
 	      }
 	    }
 	  }
@@ -35359,9 +34960,7 @@ function requireLib () {
 	    if (hasStar && !hasNamespace) {
 	      if (hasDefault) this.unexpected();
 	      if (decorators) {
-	        throw this.raise(Errors.UnsupportedDecoratorExport, {
-	          at: node
-	        });
+	        throw this.raise(Errors.UnsupportedDecoratorExport, node);
 	      }
 	      this.parseExportFrom(node, true);
 	      return this.finishNode(node, "ExportAllDeclaration");
@@ -35377,9 +34976,7 @@ function requireLib () {
 	    if (isFromRequired || hasSpecifiers) {
 	      hasDeclaration = false;
 	      if (decorators) {
-	        throw this.raise(Errors.UnsupportedDecoratorExport, {
-	          at: node
-	        });
+	        throw this.raise(Errors.UnsupportedDecoratorExport, node);
 	      }
 	      this.parseExportFrom(node, isFromRequired);
 	    } else {
@@ -35392,9 +34989,7 @@ function requireLib () {
 	      if (((_node2$declaration = node2.declaration) == null ? void 0 : _node2$declaration.type) === "ClassDeclaration") {
 	        this.maybeTakeDecorators(decorators, node2.declaration, node2);
 	      } else if (decorators) {
-	        throw this.raise(Errors.UnsupportedDecoratorExport, {
-	          at: node
-	        });
+	        throw this.raise(Errors.UnsupportedDecoratorExport, node);
 	      }
 	      return this.finishNode(node2, "ExportNamedDeclaration");
 	    }
@@ -35405,9 +35000,7 @@ function requireLib () {
 	      if (decl.type === "ClassDeclaration") {
 	        this.maybeTakeDecorators(decorators, decl, node2);
 	      } else if (decorators) {
-	        throw this.raise(Errors.UnsupportedDecoratorExport, {
-	          at: node
-	        });
+	        throw this.raise(Errors.UnsupportedDecoratorExport, node);
 	      }
 	      this.checkExport(node2, true, true);
 	      return this.finishNode(node2, "ExportDefaultDeclaration");
@@ -35485,16 +35078,12 @@ function requireLib () {
 	    }
 	    if (this.match(26)) {
 	      if (this.hasPlugin("decorators") && this.getPluginOption("decorators", "decoratorsBeforeExport") === true) {
-	        this.raise(Errors.DecoratorBeforeExport, {
-	          at: this.state.startLoc
-	        });
+	        this.raise(Errors.DecoratorBeforeExport, this.state.startLoc);
 	      }
 	      return this.parseClass(this.maybeTakeDecorators(this.parseDecorators(false), this.startNode()), true, true);
 	    }
 	    if (this.match(75) || this.match(74) || this.isLet()) {
-	      throw this.raise(Errors.UnsupportedDefaultExport, {
-	        at: this.state.startLoc
-	      });
+	      throw this.raise(Errors.UnsupportedDefaultExport, this.state.startLoc);
 	    }
 	    const res = this.parseMaybeAssignAllowIn();
 	    this.semicolon();
@@ -35557,9 +35146,7 @@ function requireLib () {
 	      this.expectOnePlugin(["decorators", "decorators-legacy"]);
 	      if (this.hasPlugin("decorators")) {
 	        if (this.getPluginOption("decorators", "decoratorsBeforeExport") === true) {
-	          this.raise(Errors.DecoratorBeforeExport, {
-	            at: this.state.startLoc
-	          });
+	          this.raise(Errors.DecoratorBeforeExport, this.state.startLoc);
 	        }
 	        return true;
 	      }
@@ -35575,9 +35162,7 @@ function requireLib () {
 	          var _declaration$extra;
 	          const declaration = node.declaration;
 	          if (declaration.type === "Identifier" && declaration.name === "from" && declaration.end - declaration.start === 4 && !((_declaration$extra = declaration.extra) != null && _declaration$extra.parenthesized)) {
-	            this.raise(Errors.ExportDefaultFromAsIdentifier, {
-	              at: declaration
-	            });
+	            this.raise(Errors.ExportDefaultFromAsIdentifier, declaration);
 	          }
 	        }
 	      } else if ((_node$specifiers = node.specifiers) != null && _node$specifiers.length) {
@@ -35592,8 +35177,7 @@ function requireLib () {
 	              local
 	            } = specifier;
 	            if (local.type !== "Identifier") {
-	              this.raise(Errors.ExportBindingIsString, {
-	                at: specifier,
+	              this.raise(Errors.ExportBindingIsString, specifier, {
 	                localName: local.value,
 	                exportName
 	              });
@@ -35640,12 +35224,9 @@ function requireLib () {
 	  checkDuplicateExports(node, exportName) {
 	    if (this.exportedIdentifiers.has(exportName)) {
 	      if (exportName === "default") {
-	        this.raise(Errors.DuplicateDefaultExport, {
-	          at: node
-	        });
+	        this.raise(Errors.DuplicateDefaultExport, node);
 	      } else {
-	        this.raise(Errors.DuplicateExport, {
-	          at: node,
+	        this.raise(Errors.DuplicateExport, node, {
 	          exportName
 	        });
 	      }
@@ -35686,8 +35267,7 @@ function requireLib () {
 	      const result = this.parseStringLiteral(this.state.value);
 	      const surrogate = result.value.match(loneSurrogate);
 	      if (surrogate) {
-	        this.raise(Errors.ModuleExportNameHasLoneSurrogate, {
-	          at: result,
+	        this.raise(Errors.ModuleExportNameHasLoneSurrogate, result, {
 	          surrogateCharCode: surrogate[0].charCodeAt(0)
 	        });
 	      }
@@ -35713,27 +35293,19 @@ function requireLib () {
 	    const singleBindingType = specifiers.length === 1 ? specifiers[0].type : null;
 	    if (node.phase === "source") {
 	      if (singleBindingType !== "ImportDefaultSpecifier") {
-	        this.raise(Errors.SourcePhaseImportRequiresDefault, {
-	          at: specifiers[0].loc.start
-	        });
+	        this.raise(Errors.SourcePhaseImportRequiresDefault, specifiers[0].loc.start);
 	      }
 	    } else if (node.phase === "defer") {
 	      if (singleBindingType !== "ImportNamespaceSpecifier") {
-	        this.raise(Errors.DeferImportRequiresNamespace, {
-	          at: specifiers[0].loc.start
-	        });
+	        this.raise(Errors.DeferImportRequiresNamespace, specifiers[0].loc.start);
 	      }
 	    } else if (node.module) {
 	      var _node$assertions;
 	      if (singleBindingType !== "ImportDefaultSpecifier") {
-	        this.raise(Errors.ImportReflectionNotBinding, {
-	          at: specifiers[0].loc.start
-	        });
+	        this.raise(Errors.ImportReflectionNotBinding, specifiers[0].loc.start);
 	      }
 	      if (((_node$assertions = node.assertions) == null ? void 0 : _node$assertions.length) > 0) {
-	        this.raise(Errors.ImportReflectionHasAssertion, {
-	          at: node.specifiers[0].loc.start
-	        });
+	        this.raise(Errors.ImportReflectionHasAssertion, specifiers[0].loc.start);
 	      }
 	    }
 	  }
@@ -35755,9 +35327,7 @@ function requireLib () {
 	          }
 	        });
 	        if (nonDefaultNamedSpecifier !== undefined) {
-	          this.raise(Errors.ImportJSONBindingNotDefault, {
-	            at: nonDefaultNamedSpecifier.loc.start
-	          });
+	          this.raise(Errors.ImportJSONBindingNotDefault, nonDefaultNamedSpecifier.loc.start);
 	        }
 	      }
 	    }
@@ -35864,8 +35434,7 @@ function requireLib () {
 	      const node = this.startNode();
 	      const keyName = this.state.value;
 	      if (attrNames.has(keyName)) {
-	        this.raise(Errors.ModuleAttributesWithDuplicateKeys, {
-	          at: this.state.startLoc,
+	        this.raise(Errors.ModuleAttributesWithDuplicateKeys, this.state.startLoc, {
 	          key: keyName
 	        });
 	      }
@@ -35877,9 +35446,7 @@ function requireLib () {
 	      }
 	      this.expect(14);
 	      if (!this.match(133)) {
-	        throw this.raise(Errors.ModuleAttributeInvalidValue, {
-	          at: this.state.startLoc
-	        });
+	        throw this.raise(Errors.ModuleAttributeInvalidValue, this.state.startLoc);
 	      }
 	      node.value = this.parseStringLiteral(this.state.value);
 	      attrs.push(this.finishNode(node, "ImportAttribute"));
@@ -35894,22 +35461,17 @@ function requireLib () {
 	      const node = this.startNode();
 	      node.key = this.parseIdentifier(true);
 	      if (node.key.name !== "type") {
-	        this.raise(Errors.ModuleAttributeDifferentFromType, {
-	          at: node.key
-	        });
+	        this.raise(Errors.ModuleAttributeDifferentFromType, node.key);
 	      }
 	      if (attributes.has(node.key.name)) {
-	        this.raise(Errors.ModuleAttributesWithDuplicateKeys, {
-	          at: node.key,
+	        this.raise(Errors.ModuleAttributesWithDuplicateKeys, node.key, {
 	          key: node.key.name
 	        });
 	      }
 	      attributes.add(node.key.name);
 	      this.expect(14);
 	      if (!this.match(133)) {
-	        throw this.raise(Errors.ModuleAttributeInvalidValue, {
-	          at: this.state.startLoc
-	        });
+	        throw this.raise(Errors.ModuleAttributeInvalidValue, this.state.startLoc);
 	      }
 	      node.value = this.parseStringLiteral(this.state.value);
 	      attrs.push(this.finishNode(node, "ImportAttribute"));
@@ -35936,9 +35498,7 @@ function requireLib () {
 	    } else if (this.isContextual(94) && !this.hasPrecedingLineBreak()) {
 	      if (this.hasPlugin("importAttributes")) {
 	        if (this.getPluginOption("importAttributes", "deprecatedAssertSyntax") !== true) {
-	          this.raise(Errors.ImportAttributesUseAssert, {
-	            at: this.state.startLoc
-	          });
+	          this.raise(Errors.ImportAttributesUseAssert, this.state.startLoc);
 	        }
 	        this.addExtra(node, "deprecatedAssertSyntax", true);
 	      } else {
@@ -35989,9 +35549,7 @@ function requireLib () {
 	        first = false;
 	      } else {
 	        if (this.eat(14)) {
-	          throw this.raise(Errors.DestructureNamedImport, {
-	            at: this.state.startLoc
-	          });
+	          throw this.raise(Errors.DestructureNamedImport, this.state.startLoc);
 	        }
 	        this.expect(12);
 	        if (this.eat(8)) break;
@@ -36012,8 +35570,7 @@ function requireLib () {
 	        imported
 	      } = specifier;
 	      if (importedIsString) {
-	        throw this.raise(Errors.ImportBindingIsString, {
-	          at: specifier,
+	        throw this.raise(Errors.ImportBindingIsString, specifier, {
 	          importName: imported.value
 	        });
 	      }
@@ -36048,6 +35605,7 @@ function requireLib () {
 	    file.errors = null;
 	    this.parseTopLevel(file, program);
 	    file.errors = this.state.errors;
+	    file.comments.length = this.state.commentsLen;
 	    return file;
 	  }
 	}