@vue/compiler-sfc 3.4.15 → 3.4.16

package/dist/compiler-sfc.esm-browser.js

@@ -1,5 +1,5 @@
 /**
-* @vue/compiler-sfc v3.4.15
+* @vue/compiler-sfc v3.4.16
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -2266,8 +2266,10 @@ const ErrorCodes = {
   "50": "X_SCOPE_ID_NOT_SUPPORTED",
   "X_VNODE_HOOKS": 51,
   "51": "X_VNODE_HOOKS",
-  "__EXTEND_POINT__": 52,
-  "52": "__EXTEND_POINT__"
+  "X_V_BIND_INVALID_SAME_NAME_ARGUMENT": 52,
+  "52": "X_V_BIND_INVALID_SAME_NAME_ARGUMENT",
+  "__EXTEND_POINT__": 53,
+  "53": "__EXTEND_POINT__"
 };
 const errorMessages$1 = {
   // parse errors
@@ -2308,6 +2310,7 @@ const errorMessages$1 = {
   [32]: `v-for has invalid expression.`,
   [33]: `<template v-for> key should be placed on the <template> tag.`,
   [34]: `v-bind is missing expression.`,
+  [52]: `v-bind with same-name shorthand only allows static argument.`,
   [35]: `v-on is missing expression.`,
   [36]: `Unexpected custom directive on <slot> outlet.`,
   [37]: `Mixed v-slot usage on both the component and nested <template>. When there are multiple named slots, all slots should use <template> syntax to avoid scope ambiguity.`,
@@ -2328,7 +2331,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
   [49]: `"cacheHandlers" option is only supported when the "prefixIdentifiers" option is enabled.`,
   [50]: `"scopeId" option is only supported in module mode.`,
   // just to fulfill types
-  [52]: ``
+  [53]: ``
 };
 
 function getDefaultExportFromCjs (x) {
@@ -2697,8 +2700,8 @@ var PipelineOperatorErrors = {
   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,
@@ -2710,11 +2713,8 @@ function toParseErrorConstructor(_ref) {
   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,
@@ -2732,10 +2732,7 @@ function toParseErrorConstructor(_ref) {
         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", {
@@ -2770,7 +2767,7 @@ function ParseErrorEnum(argument, syntaxPlugin) {
       {
         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",
@@ -3015,13 +3012,9 @@ var estree = superClass => class ESTreeParserMixin extends superClass {
   }
   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);
     }
@@ -3757,9 +3750,9 @@ function canBeReservedWord(word) {
 }
 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;
   }
 }
@@ -3827,11 +3820,16 @@ class ScopeHandler {
     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);
       }
@@ -3839,7 +3837,7 @@ class ScopeHandler {
       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;
       }
@@ -3855,8 +3853,7 @@ class ScopeHandler {
   }
   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
       });
     }
@@ -3864,19 +3861,20 @@ class ScopeHandler {
   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);
     }
   }
@@ -3926,8 +3924,9 @@ class FlowScopeHandler extends ScopeHandler {
   }
   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;
   }
@@ -4000,7 +3999,12 @@ function adjustInnerComments(node, elements, commentWS) {
 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 {
@@ -4189,7 +4193,7 @@ function isWhitespace(code) {
 }
 class State {
   constructor() {
-    this.strict = void 0;
+    this.flags = 1024;
     this.curLine = void 0;
     this.lineStart = void 0;
     this.startLoc = void 0;
@@ -4198,21 +4202,12 @@ class State {
     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;
@@ -4221,14 +4216,21 @@ class State {
     this.end = 0;
     this.lastTokEndLoc = null;
     this.lastTokStartLoc = null;
-    this.lastTokStart = 0;
     this.context = [types$1.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,
@@ -4240,20 +4242,145 @@ class State {
     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;
   }
 }
@@ -4542,8 +4669,6 @@ function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {
     pos
   };
 }
-const _excluded = ["at"],
-  _excluded2 = ["at"];
 function buildPosition(pos, lineStart, curLine) {
   return new Position(curLine, pos - lineStart, pos);
 }
@@ -4565,8 +4690,7 @@ class Tokenizer extends CommentsParser {
     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;
@@ -4580,28 +4704,23 @@ class Tokenizer extends CommentsParser {
     });
     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) {
@@ -4614,7 +4733,6 @@ class Tokenizer extends CommentsParser {
     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();
@@ -4689,9 +4807,7 @@ class Tokenizer extends CommentsParser {
   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();
     }
   }
@@ -4714,9 +4830,7 @@ class Tokenizer extends CommentsParser {
     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;
@@ -4868,16 +4982,12 @@ class Tokenizer extends CommentsParser {
     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) {
@@ -4962,9 +5072,7 @@ class Tokenizer extends CommentsParser {
       }
       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);
@@ -4972,9 +5080,7 @@ class Tokenizer extends CommentsParser {
       }
       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);
@@ -5120,9 +5226,7 @@ class Tokenizer extends CommentsParser {
       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);
@@ -5138,9 +5242,7 @@ class Tokenizer extends CommentsParser {
       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);
@@ -5244,8 +5346,7 @@ class Tokenizer extends CommentsParser {
           return;
         }
     }
-    throw this.raise(Errors.InvalidOrUnexpectedToken, {
-      at: this.state.curPosition(),
+    throw this.raise(Errors.InvalidOrUnexpectedToken, this.state.curPosition(), {
       unexpected: String.fromCodePoint(code)
     });
   }
@@ -5263,15 +5364,11 @@ class Tokenizer extends CommentsParser {
     } = 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;
@@ -5296,26 +5393,18 @@ class Tokenizer extends CommentsParser {
       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;
       }
@@ -5342,8 +5431,7 @@ class Tokenizer extends CommentsParser {
     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
       });
     }
@@ -5352,14 +5440,10 @@ class Tokenizer extends CommentsParser {
       ++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, "");
@@ -5377,22 +5461,16 @@ class Tokenizer extends CommentsParser {
     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);
@@ -5410,9 +5488,7 @@ class Tokenizer extends CommentsParser {
         ++this.state.pos;
       }
       if (this.readInt(10) === null) {
-        this.raise(Errors.InvalidOrMissingExponent, {
-          at: startLoc
-        });
+        this.raise(Errors.InvalidOrMissingExponent, startLoc);
       }
       isFloat = true;
       hasExponent = true;
@@ -5420,9 +5496,7 @@ class Tokenizer extends CommentsParser {
     }
     if (next === 110) {
       if (isFloat || hasLeadingZero) {
-        this.raise(Errors.InvalidBigIntLiteral, {
-          at: startLoc
-        });
+        this.raise(Errors.InvalidBigIntLiteral, startLoc);
       }
       ++this.state.pos;
       isBigInt = true;
@@ -5430,17 +5504,13 @@ class Tokenizer extends CommentsParser {
     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) {
@@ -5503,14 +5573,10 @@ class Tokenizer extends CommentsParser {
       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]);
     }
@@ -5533,9 +5599,7 @@ class Tokenizer extends CommentsParser {
         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;
         }
@@ -5543,9 +5607,7 @@ class Tokenizer extends CommentsParser {
         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);
         }
@@ -5570,75 +5632,55 @@ class Tokenizer extends CommentsParser {
       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));
     };
   }
 }
@@ -5671,8 +5713,7 @@ class ClassScopeHandler {
           current.undefinedPrivateNames.set(name, loc);
         }
       } else {
-        this.parser.raise(Errors.InvalidPrivateFieldResolution, {
-          at: loc,
+        this.parser.raise(Errors.InvalidPrivateFieldResolution, loc, {
           identifierName: name
         });
       }
@@ -5699,8 +5740,7 @@ class ClassScopeHandler {
       }
     }
     if (redefined) {
-      this.parser.raise(Errors.PrivateNameRedeclaration, {
-        at: loc,
+      this.parser.raise(Errors.PrivateNameRedeclaration, loc, {
         identifierName: name
       });
     }
@@ -5715,8 +5755,7 @@ class ClassScopeHandler {
     if (classScope) {
       classScope.undefinedPrivateNames.set(name, loc);
     } else {
-      this.parser.raise(Errors.InvalidPrivateFieldResolution, {
-        at: loc,
+      this.parser.raise(Errors.InvalidPrivateFieldResolution, loc, {
         identifierName: name
       });
     }
@@ -5738,9 +5777,7 @@ class ArrowHeadParsingScope extends ExpressionScope {
     super(type);
     this.declarationErrors = new Map();
   }
-  recordDeclarationError(ParsingErrorClass, {
-    at
-  }) {
+  recordDeclarationError(ParsingErrorClass, at) {
     const index = at.index;
     this.declarationErrors.set(index, [ParsingErrorClass, at]);
   }
@@ -5763,12 +5800,8 @@ class ExpressionScopeHandler {
   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;
@@ -5784,16 +5817,12 @@ class ExpressionScopeHandler {
     }
     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()) {
@@ -5802,9 +5831,7 @@ class ExpressionScopeHandler {
       return;
     }
   }
-  recordAsyncArrowParametersError({
-    at
-  }) {
+  recordAsyncArrowParametersError(at) {
     const {
       stack
     } = this;
@@ -5812,9 +5839,7 @@ class ExpressionScopeHandler {
     let scope = stack[i];
     while (scope.canBeArrowParameterDeclaration()) {
       if (scope.type === 2) {
-        scope.recordDeclarationError(Errors.AwaitBindingIdentifier, {
-          at
-        });
+        scope.recordDeclarationError(Errors.AwaitBindingIdentifier, at);
       }
       scope = stack[--i];
     }
@@ -5826,9 +5851,7 @@ class ExpressionScopeHandler {
     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()) {
@@ -5917,9 +5940,7 @@ class UtilParser extends Tokenizer {
   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);
     }
@@ -5939,9 +5960,7 @@ class UtilParser extends Tokenizer {
   }
   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);
@@ -6011,19 +6030,13 @@ class UtilParser extends Tokenizer {
       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);
@@ -6176,7 +6189,8 @@ function cloneStringLiteral(node) {
 }
 class NodeUtils extends UtilParser {
   startNode() {
-    return new Node$5(this, this.state.start, this.state.startLoc);
+    const loc = this.state.startLoc;
+    return new Node$5(this, loc.index, loc);
   }
   startNodeAt(loc) {
     return new Node$5(this, loc.index, loc);
@@ -6372,10 +6386,8 @@ var flow = superClass => class FlowParserMixin extends superClass {
     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();
@@ -6444,9 +6456,7 @@ var flow = superClass => class FlowParserMixin extends superClass {
         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);
       }
@@ -6484,9 +6494,7 @@ var flow = superClass => class FlowParserMixin extends superClass {
       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 {
@@ -6503,21 +6511,15 @@ var flow = superClass => class FlowParserMixin extends superClass {
     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;
@@ -6540,8 +6542,7 @@ var flow = superClass => class FlowParserMixin extends superClass {
     } 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]
         });
@@ -6639,15 +6640,12 @@ var flow = superClass => class FlowParserMixin extends superClass {
   }
   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
     });
   }
@@ -6700,9 +6698,7 @@ var flow = superClass => class FlowParserMixin extends superClass {
       node.default = this.flowParseType();
     } else {
       if (requireDefault) {
-        this.raise(FlowErrors.MissingTypeParamDefault, {
-          at: nodeStartLoc
-        });
+        this.raise(FlowErrors.MissingTypeParamDefault, nodeStartLoc);
       }
     }
     return this.finishNode(node, "TypeParameter");
@@ -6942,9 +6938,7 @@ var flow = superClass => class FlowParserMixin extends superClass {
       }
       this.flowObjectTypeSemicolon();
       if (inexactStartLoc && !this.match(8) && !this.match(9)) {
-        this.raise(FlowErrors.UnexpectedExplicitInexactInObject, {
-          at: inexactStartLoc
-        });
+        this.raise(FlowErrors.UnexpectedExplicitInexactInObject, inexactStartLoc);
       }
     }
     this.expect(endDelim);
@@ -6960,33 +6954,23 @@ var flow = superClass => class FlowParserMixin extends superClass {
       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");
@@ -7009,9 +6993,7 @@ var flow = superClass => class FlowParserMixin extends superClass {
           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();
@@ -7030,19 +7012,13 @@ var flow = superClass => class FlowParserMixin extends superClass {
     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() {
@@ -7098,17 +7074,13 @@ var flow = superClass => class FlowParserMixin extends superClass {
     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();
@@ -7264,9 +7236,7 @@ var flow = superClass => class FlowParserMixin extends superClass {
           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;
@@ -7530,9 +7500,7 @@ var flow = superClass => class FlowParserMixin extends superClass {
         [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;
@@ -7693,13 +7661,9 @@ var flow = superClass => class FlowParserMixin extends superClass {
     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);
       }
     }
   }
@@ -7710,8 +7674,7 @@ var flow = superClass => class FlowParserMixin extends superClass {
     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
       });
     }
@@ -7763,9 +7726,7 @@ var flow = superClass => class FlowParserMixin extends superClass {
       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;
@@ -7813,16 +7774,12 @@ var flow = superClass => class FlowParserMixin extends superClass {
     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);
       }
     }
   }
@@ -7862,13 +7819,9 @@ var flow = superClass => class FlowParserMixin extends superClass {
     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);
       }
     }
   }
@@ -7894,28 +7847,20 @@ var flow = superClass => class FlowParserMixin extends superClass {
   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;
@@ -7923,18 +7868,14 @@ var flow = superClass => class FlowParserMixin extends superClass {
   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) {
@@ -7990,8 +7931,7 @@ var flow = superClass => class FlowParserMixin extends superClass {
         specifier.importKind = specifierTypeKind;
       } else {
         if (importedIsString) {
-          throw this.raise(Errors.ImportBindingIsString, {
-            at: specifier,
+          throw this.raise(Errors.ImportBindingIsString, specifier, {
             importName: firstIdent.value
           });
         }
@@ -8007,9 +7947,7 @@ var flow = superClass => class FlowParserMixin extends superClass {
     }
     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);
@@ -8092,9 +8030,7 @@ var flow = superClass => class FlowParserMixin extends superClass {
       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;
         }
@@ -8110,9 +8046,7 @@ var flow = superClass => class FlowParserMixin extends superClass {
       }
       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);
   }
@@ -8150,9 +8084,7 @@ var flow = superClass => class FlowParserMixin extends superClass {
     }
     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);
@@ -8254,18 +8186,14 @@ var flow = superClass => class FlowParserMixin extends superClass {
   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();
@@ -8301,43 +8229,26 @@ var flow = superClass => class FlowParserMixin extends superClass {
   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;
@@ -8446,16 +8357,14 @@ var flow = superClass => class FlowParserMixin extends superClass {
         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
         });
@@ -8544,8 +8453,7 @@ var flow = superClass => class FlowParserMixin extends superClass {
   }) {
     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
       });
     }
@@ -8554,8 +8462,7 @@ var flow = superClass => class FlowParserMixin extends superClass {
     } = 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
       });
@@ -8640,8 +8547,7 @@ var flow = superClass => class FlowParserMixin extends superClass {
             this.expect(8);
             return this.finishNode(node, "EnumNumberBody");
           } else {
-            this.raise(FlowErrors.EnumInconsistentMemberValues, {
-              at: nameLoc,
+            this.raise(FlowErrors.EnumInconsistentMemberValues, nameLoc, {
               enumName
             });
             return empty();
@@ -8959,9 +8865,7 @@ var jsx = superClass => class JSXParserMixin extends superClass {
     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) {
@@ -9016,9 +8920,7 @@ var jsx = superClass => class JSXParserMixin extends superClass {
     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;
@@ -9121,18 +9023,14 @@ var jsx = superClass => class JSXParserMixin extends superClass {
         this.next();
         node = this.jsxParseExpressionContainer(node, types$1.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() {
@@ -9239,18 +9137,14 @@ var jsx = superClass => class JSXParserMixin extends superClass {
         }
       }
       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)
           });
         }
@@ -9265,9 +9159,7 @@ var jsx = superClass => class JSXParserMixin extends superClass {
     }
     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");
   }
@@ -9353,11 +9245,7 @@ var jsx = superClass => class JSXParserMixin extends superClass {
 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 {
@@ -9397,8 +9285,7 @@ class TypeScriptScopeHandler extends ScopeHandler {
   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
         });
       }
@@ -9406,9 +9293,10 @@ class TypeScriptScopeHandler extends ScopeHandler {
       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);
@@ -9417,31 +9305,37 @@ class TypeScriptScopeHandler extends ScopeHandler {
         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) scope.classes.add(name);
+    if (bindingType & 128) {
+      type = type | 8;
+    }
+    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);
@@ -9454,7 +9348,10 @@ class TypeScriptScopeHandler extends ScopeHandler {
     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);
   }
@@ -9471,18 +9368,12 @@ class LValParser extends NodeUtils {
       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) {
@@ -9500,9 +9391,7 @@ class LValParser extends NodeUtils {
           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;
@@ -9528,9 +9417,7 @@ class LValParser extends NodeUtils {
         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;
@@ -9543,18 +9430,14 @@ class LValParser extends NodeUtils {
   }
   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);
@@ -9575,13 +9458,9 @@ class LValParser extends NodeUtils {
       }
       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);
         }
       }
     }
@@ -9678,9 +9557,7 @@ class LValParser extends NodeUtils {
       } 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());
@@ -9764,16 +9641,13 @@ class LValParser extends NodeUtils {
       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;
     }
@@ -9784,9 +9658,7 @@ class LValParser extends NodeUtils {
       } = expression;
       if (checkClashes) {
         if (checkClashes.has(name)) {
-          this.raise(Errors.ParamDupe, {
-            at: expression
-          });
+          this.raise(Errors.ParamDupe, expression);
         } else {
           checkClashes.add(name);
         }
@@ -9797,8 +9669,7 @@ class LValParser extends NodeUtils {
     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;
@@ -9822,21 +9693,17 @@ class LValParser extends NodeUtils {
   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);
@@ -9857,18 +9724,14 @@ class LValParser extends NodeUtils {
       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;
   }
 }
@@ -10064,16 +9927,14 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
   }, 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]
         });
       }
@@ -10086,8 +9947,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
       if (!modifier) break;
       if (tsIsAccessModifier(modifier)) {
         if (modified.accessibility) {
-          this.raise(TSErrors.DuplicateAccessibilityModifier, {
-            at: startLoc,
+          this.raise(TSErrors.DuplicateAccessibilityModifier, startLoc, {
             modifier
           });
         } else {
@@ -10098,8 +9958,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
         }
       } else if (tsIsVarianceAnnotations(modifier)) {
         if (modified[modifier]) {
-          this.raise(TSErrors.DuplicateModifier, {
-            at: startLoc,
+          this.raise(TSErrors.DuplicateModifier, startLoc, {
             modifier
           });
         }
@@ -10107,8 +9966,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
         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 {
@@ -10122,8 +9980,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
         modified[modifier] = true;
       }
       if (disallowedModifiers != null && disallowedModifiers.includes(modifier)) {
-        this.raise(errorTemplate, {
-          at: startLoc,
+        this.raise(errorTemplate, startLoc, {
           modifier
         });
       }
@@ -10166,7 +10023,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
       }
       result.push(element);
       if (this.eat(12)) {
-        trailingCommaPos = this.state.lastTokStart;
+        trailingCommaPos = this.state.lastTokStartLoc.index;
         continue;
       }
       if (this.tsIsListTerminator(kind)) {
@@ -10203,9 +10060,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     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);
@@ -10286,9 +10141,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     };
     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);
@@ -10315,8 +10168,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
         type
       } = pattern;
       if (type === "AssignmentPattern" || type === "TSParameterProperty") {
-        this.raise(TSErrors.UnsupportedSignatureParameterKind, {
-          at: pattern,
+        this.raise(TSErrors.UnsupportedSignatureParameterKind, pattern, {
           type
         });
       }
@@ -10361,15 +10213,11 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     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();
@@ -10377,42 +10225,28 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
       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";
@@ -10527,9 +10361,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
         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");
     });
@@ -10582,16 +10414,12 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
         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();
       }
@@ -10744,9 +10572,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
       case "TSArrayType":
         return;
       default:
-        this.raise(TSErrors.UnexpectedReadonly, {
-          at: node
-        });
+        this.raise(TSErrors.UnexpectedReadonly, node);
     }
   }
   tsParseInferType() {
@@ -10914,8 +10740,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
       return false;
     }
     if (containsEsc) {
-      this.raise(Errors.InvalidEscapedReservedWord, {
-        at: this.state.lastTokStartLoc,
+      this.raise(Errors.InvalidEscapedReservedWord, this.state.lastTokStartLoc, {
         reservedWord: "asserts"
       });
     }
@@ -10959,9 +10784,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
   }
   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(() => {
@@ -10983,8 +10806,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
       return this.finishNode(node, "TSExpressionWithTypeArguments");
     });
     if (!delimitedList.length) {
-      this.raise(TSErrors.EmptyHeritageClauseType, {
-        at: originalStartLoc,
+      this.raise(TSErrors.EmptyHeritageClauseType, originalStartLoc, {
         token
       });
     }
@@ -10999,9 +10821,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
       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)) {
@@ -11153,9 +10973,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     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();
@@ -11341,9 +11159,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
       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$1.brace) {
       this.reScan_lt_gt();
     }
@@ -11367,9 +11183,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     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);
@@ -11383,9 +11197,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
       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");
@@ -11401,9 +11213,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
   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);
       }
     }
   }
@@ -11420,9 +11230,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
       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);
       }
@@ -11440,9 +11248,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
   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);
       }
     });
   }
@@ -11519,9 +11325,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
       }
       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;
       }
@@ -11548,8 +11352,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
         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"
             });
           }
@@ -11571,9 +11374,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
   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() {}
@@ -11613,9 +11414,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
       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;
   }
@@ -11673,13 +11472,9 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     } 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;
@@ -11728,9 +11523,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
         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 {
@@ -11748,38 +11541,27 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     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);
@@ -11788,14 +11570,10 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     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) {
@@ -11841,9 +11619,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     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);
@@ -11879,16 +11655,13 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
   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)}]`
       });
     }
@@ -11896,13 +11669,10 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
   }
   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
       });
     }
@@ -11912,26 +11682,21 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
   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
       });
     }
@@ -12046,9 +11811,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
   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) {
@@ -12102,13 +11865,9 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
       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;
@@ -12189,9 +11948,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
   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;
   }
@@ -12305,9 +12062,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     } 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 {
@@ -12322,8 +12077,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
         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)}]`
         });
       }
@@ -12405,9 +12159,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
       }
     }
     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;
@@ -12594,9 +12346,7 @@ var placeholders = superClass => class PlaceholdersParserMixin extends superClas
         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);
@@ -12674,9 +12424,7 @@ var placeholders = superClass => class PlaceholdersParserMixin extends superClas
   }
   assertNoSpace() {
     if (this.state.start > this.state.lastTokEndLoc.index) {
-      this.raise(PlaceholderErrors.UnexpectedSpace, {
-        at: this.state.lastTokEndLoc
-      });
+      this.raise(PlaceholderErrors.UnexpectedSpace, this.state.lastTokEndLoc);
     }
   }
 };
@@ -12865,9 +12613,7 @@ class ExpressionParser extends LValParser {
     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) {
@@ -12876,9 +12622,7 @@ class ExpressionParser extends LValParser {
             refExpressionErrors.doubleProtoLoc = key.loc.start;
           }
         } else {
-          this.raise(Errors.DuplicateProto, {
-            at: key
-          });
+          this.raise(Errors.DuplicateProto, key);
         }
       }
       protoRef.used = true;
@@ -12895,7 +12639,7 @@ class ExpressionParser extends LValParser {
       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;
@@ -13028,8 +12772,7 @@ class ExpressionParser extends LValParser {
     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
         });
       }
@@ -13059,18 +12802,14 @@ class ExpressionParser extends LValParser {
           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);
       }
@@ -13089,9 +12828,7 @@ class ExpressionParser extends LValParser {
           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);
             });
@@ -13116,23 +12853,18 @@ class ExpressionParser extends LValParser {
     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) {
@@ -13159,13 +12891,9 @@ class ExpressionParser extends LValParser {
       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) {
@@ -13182,9 +12910,7 @@ class ExpressionParser extends LValParser {
       } = 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);
       }
     }
@@ -13246,9 +12972,7 @@ class ExpressionParser extends LValParser {
     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;
@@ -13278,9 +13002,7 @@ class ExpressionParser extends LValParser {
       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();
@@ -13350,9 +13072,7 @@ class ExpressionParser extends LValParser {
     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");
   }
@@ -13374,16 +13094,13 @@ class ExpressionParser extends LValParser {
         }
       }
       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);
           }
         }
       }
@@ -13402,9 +13119,7 @@ class ExpressionParser extends LValParser {
         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);
@@ -13460,9 +13175,7 @@ class ExpressionParser extends LValParser {
             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:
@@ -13536,15 +13249,12 @@ class ExpressionParser extends LValParser {
           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();
@@ -13644,15 +13354,12 @@ class ExpressionParser extends LValParser {
     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)
       });
     }
@@ -13668,9 +13375,7 @@ class ExpressionParser extends LValParser {
       case "smart":
         return tokenType === 27;
       default:
-        throw this.raise(Errors.PipeTopicRequiresHackPipes, {
-          at: startLoc
-        });
+        throw this.raise(Errors.PipeTopicRequiresHackPipes, startLoc);
     }
   }
   parseAsyncArrowUnaryFunction(node) {
@@ -13678,9 +13383,7 @@ class ExpressionParser extends LValParser {
     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);
@@ -13708,18 +13411,12 @@ class ExpressionParser extends LValParser {
     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");
   }
@@ -13751,8 +13448,7 @@ class ExpressionParser extends LValParser {
     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
       });
@@ -13764,9 +13460,7 @@ class ExpressionParser extends LValParser {
     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)) {
@@ -13774,8 +13468,7 @@ class ExpressionParser extends LValParser {
       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
         });
       }
@@ -13921,9 +13614,7 @@ class ExpressionParser extends LValParser {
       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;
     }
@@ -13945,9 +13636,7 @@ class ExpressionParser extends LValParser {
     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) {
@@ -13961,9 +13650,7 @@ class ExpressionParser extends LValParser {
     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);
@@ -14023,9 +13710,7 @@ class ExpressionParser extends LValParser {
         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);
@@ -14043,7 +13728,7 @@ class ExpressionParser extends LValParser {
     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) {
@@ -14053,9 +13738,7 @@ class ExpressionParser extends LValParser {
     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());
@@ -14095,8 +13778,7 @@ class ExpressionParser extends LValParser {
         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();
@@ -14117,14 +13799,10 @@ class ExpressionParser extends LValParser {
     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) {
@@ -14157,9 +13835,7 @@ class ExpressionParser extends LValParser {
             refExpressionErrors.shorthandAssignLoc = shorthandAssignLoc;
           }
         } else {
-          this.raise(Errors.InvalidCoverInitializedName, {
-            at: shorthandAssignLoc
-          });
+          this.raise(Errors.InvalidCoverInitializedName, shorthandAssignLoc);
         }
         prop.value = this.parseMaybeDefault(startLoc, cloneIdentifier(prop.key));
       } else {
@@ -14209,9 +13885,7 @@ class ExpressionParser extends LValParser {
                   refExpressionErrors.privateKeyLoc = privateKeyLoc;
                 }
               } else {
-                this.raise(Errors.UnexpectedPrivateField, {
-                  at: privateKeyLoc
-                });
+                this.raise(Errors.UnexpectedPrivateField, privateKeyLoc);
               }
               key = this.parsePrivateName();
               break;
@@ -14297,9 +13971,7 @@ class ExpressionParser extends LValParser {
       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);
@@ -14359,8 +14031,7 @@ class ExpressionParser extends LValParser {
     let elt;
     if (this.match(12)) {
       if (!allowEmpty) {
-        this.raise(Errors.UnexpectedToken, {
-          at: this.state.curPosition(),
+        this.raise(Errors.UnexpectedToken, this.state.curPosition(), {
           unexpected: ","
         });
       }
@@ -14371,9 +14042,7 @@ class ExpressionParser extends LValParser {
     } 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();
@@ -14423,47 +14092,35 @@ class ExpressionParser extends LValParser {
       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;
       }
     }
@@ -14477,13 +14134,9 @@ class ExpressionParser extends LValParser {
   }
   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()) {
@@ -14506,9 +14159,7 @@ class ExpressionParser extends LValParser {
   }
   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;
@@ -14553,9 +14204,7 @@ class ExpressionParser extends LValParser {
       proposal: "smart"
     }])) {
       if (left.type === "SequenceExpression") {
-        this.raise(Errors.PipelineHeadSequenceExpression, {
-          at: leftStartLoc
-        });
+        this.raise(Errors.PipelineHeadSequenceExpression, leftStartLoc);
       }
     }
   }
@@ -14583,14 +14232,10 @@ class ExpressionParser extends LValParser {
   }
   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) {
@@ -14697,10 +14342,10 @@ class ExpressionParser extends LValParser {
   parsePropertyNamePrefixOperator(prop) {}
 }
 const loopLabel = {
-    kind: "loop"
+    kind: 1
   },
   switchLabel = {
-    kind: "switch"
+    kind: 2
   };
 const loneSurrogate = /[\uD800-\uDFFF]/u;
 const keywordRelationalOperator = /in(?:stanceof)?/y;
@@ -14814,7 +14459,7 @@ function babel7CompatTokens(tokens, input) {
 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);
     }
@@ -14826,8 +14471,7 @@ class StatementParser extends ExpressionParser {
     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
         });
       }
@@ -14969,9 +14613,7 @@ class StatementParser extends ExpressionParser {
       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:
@@ -14990,13 +14632,9 @@ class StatementParser extends ExpressionParser {
       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");
@@ -15008,13 +14646,9 @@ class StatementParser extends ExpressionParser {
         }
         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:
@@ -15034,9 +14668,7 @@ class StatementParser extends ExpressionParser {
       case 75:
         {
           if (!allowDeclaration) {
-            this.raise(Errors.UnexpectedLexicalDeclaration, {
-              at: this.state.startLoc
-            });
+            this.raise(Errors.UnexpectedLexicalDeclaration, this.state.startLoc);
           }
         }
       case 74:
@@ -15062,9 +14694,7 @@ class StatementParser extends ExpressionParser {
       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;
@@ -15086,9 +14716,7 @@ class StatementParser extends ExpressionParser {
         {
           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);
@@ -15105,9 +14733,7 @@ class StatementParser extends ExpressionParser {
   }
   assertModuleNodeAllowed(node) {
     if (!this.options.allowImportExportEverywhere && !this.inModule) {
-      this.raise(Errors.ImportOutsideModule, {
-        at: node
-      });
+      this.raise(Errors.ImportOutsideModule, node);
     }
   }
   decoratorsEnabledBeforeExport() {
@@ -15118,9 +14744,7 @@ class StatementParser extends ExpressionParser {
     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 {
@@ -15144,14 +14768,10 @@ class StatementParser extends ExpressionParser {
         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;
   }
@@ -15171,9 +14791,7 @@ class StatementParser extends ExpressionParser {
         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);
@@ -15222,14 +14840,15 @@ class StatementParser extends ExpressionParser {
     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
       });
     }
@@ -15281,9 +14900,7 @@ class StatementParser extends ExpressionParser {
         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 {
@@ -15294,9 +14911,7 @@ class StatementParser extends ExpressionParser {
         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);
@@ -15313,14 +14928,10 @@ class StatementParser extends ExpressionParser {
     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)) {
@@ -15354,9 +14965,7 @@ class StatementParser extends ExpressionParser {
   }
   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()) {
@@ -15386,9 +14995,7 @@ class StatementParser extends ExpressionParser {
           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;
@@ -15411,9 +15018,7 @@ class StatementParser extends ExpressionParser {
   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();
@@ -15451,9 +15056,7 @@ class StatementParser extends ExpressionParser {
     }
     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");
   }
@@ -15473,9 +15076,7 @@ class StatementParser extends ExpressionParser {
   }
   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();
@@ -15489,13 +15090,12 @@ class StatementParser extends ExpressionParser {
   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) {
@@ -15591,14 +15191,12 @@ class StatementParser extends ExpressionParser {
       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"
         }
@@ -15621,13 +15219,11 @@ class StatementParser extends ExpressionParser {
       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"
           });
         }
@@ -15658,9 +15254,7 @@ class StatementParser extends ExpressionParser {
     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;
@@ -15732,9 +15326,7 @@ class StatementParser extends ExpressionParser {
       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;
         }
@@ -15750,18 +15342,14 @@ class StatementParser extends ExpressionParser {
         }
         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");
@@ -15819,9 +15407,7 @@ class StatementParser extends ExpressionParser {
         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;
@@ -15842,14 +15428,10 @@ class StatementParser extends ExpressionParser {
       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;
@@ -15875,9 +15457,7 @@ class StatementParser extends ExpressionParser {
         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);
       }
@@ -15890,9 +15470,7 @@ class StatementParser extends ExpressionParser {
         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);
       }
@@ -15919,15 +15497,11 @@ class StatementParser extends ExpressionParser {
       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;
@@ -15948,16 +15522,12 @@ class StatementParser extends ExpressionParser {
     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));
   }
@@ -15970,9 +15540,7 @@ class StatementParser extends ExpressionParser {
     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);
@@ -16028,9 +15596,7 @@ class StatementParser extends ExpressionParser {
       if (optionalId || !isStatement) {
         node.id = null;
       } else {
-        throw this.raise(Errors.MissingClassName, {
-          at: this.state.startLoc
-        });
+        throw this.raise(Errors.MissingClassName, this.state.startLoc);
       }
     }
   }
@@ -16048,9 +15614,7 @@ class StatementParser extends ExpressionParser {
     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");
@@ -16066,9 +15630,7 @@ class StatementParser extends ExpressionParser {
     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 {
@@ -16081,9 +15643,7 @@ class StatementParser extends ExpressionParser {
       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");
     }
@@ -16094,9 +15654,7 @@ class StatementParser extends ExpressionParser {
       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");
@@ -16174,16 +15732,12 @@ class StatementParser extends ExpressionParser {
     }
     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();
@@ -16246,9 +15800,7 @@ class StatementParser extends ExpressionParser {
       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;
       }
@@ -16264,9 +15816,7 @@ class StatementParser extends ExpressionParser {
           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) {
@@ -16281,8 +15831,7 @@ class StatementParser extends ExpressionParser {
               local
             } = specifier;
             if (local.type !== "Identifier") {
-              this.raise(Errors.ExportBindingIsString, {
-                at: specifier,
+              this.raise(Errors.ExportBindingIsString, specifier, {
                 localName: local.value,
                 exportName
               });
@@ -16329,12 +15878,9 @@ class StatementParser extends ExpressionParser {
   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
         });
       }
@@ -16375,8 +15921,7 @@ class StatementParser extends ExpressionParser {
       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)
         });
       }
@@ -16402,27 +15947,19 @@ class StatementParser extends ExpressionParser {
     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);
       }
     }
   }
@@ -16444,9 +15981,7 @@ class StatementParser extends ExpressionParser {
           }
         });
         if (nonDefaultNamedSpecifier !== undefined) {
-          this.raise(Errors.ImportJSONBindingNotDefault, {
-            at: nonDefaultNamedSpecifier.loc.start
-          });
+          this.raise(Errors.ImportJSONBindingNotDefault, nonDefaultNamedSpecifier.loc.start);
         }
       }
     }
@@ -16553,8 +16088,7 @@ class StatementParser extends ExpressionParser {
       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
         });
       }
@@ -16566,9 +16100,7 @@ class StatementParser extends ExpressionParser {
       }
       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"));
@@ -16583,22 +16115,17 @@ class StatementParser extends ExpressionParser {
       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"));
@@ -16625,9 +16152,7 @@ class StatementParser extends ExpressionParser {
     } 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 {
@@ -16678,9 +16203,7 @@ class StatementParser extends ExpressionParser {
         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;
@@ -16701,8 +16224,7 @@ class StatementParser extends ExpressionParser {
         imported
       } = specifier;
       if (importedIsString) {
-        throw this.raise(Errors.ImportBindingIsString, {
-          at: specifier,
+        throw this.raise(Errors.ImportBindingIsString, specifier, {
           importName: imported.value
         });
       }
@@ -16737,6 +16259,7 @@ let Parser$2 = class Parser extends StatementParser {
     file.errors = null;
     this.parseTopLevel(file, program);
     file.errors = this.state.errors;
+    file.comments.length = this.state.commentsLen;
     return file;
   }
 };
@@ -24532,8 +24055,15 @@ function processSlotOutlet(node, context) {
       }
     } else {
       if (p.name === "bind" && isStaticArgOf(p.arg, "name")) {
-        if (p.exp)
+        if (p.exp) {
           slotName = p.exp;
+        } else if (p.arg && p.arg.type === 4) {
+          const name = camelize(p.arg.content);
+          slotName = p.exp = createSimpleExpression(name, false, p.arg.loc);
+          {
+            slotName = p.exp = processExpression(p.exp, context);
+          }
+        }
       } else {
         if (p.name === "bind" && p.arg && isStaticExp(p.arg)) {
           p.arg.content = camelize(p.arg.content);
@@ -24673,7 +24203,32 @@ const transformBind = (dir, _node, context) => {
   const { modifiers, loc } = dir;
   const arg = dir.arg;
   let { exp } = dir;
-  if (!exp && arg.type === 4) {
+  if (exp && exp.type === 4 && !exp.content.trim()) {
+    {
+      context.onError(
+        createCompilerError(34, loc)
+      );
+      return {
+        props: [
+          createObjectProperty(arg, createSimpleExpression("", true, loc))
+        ]
+      };
+    }
+  }
+  if (!exp) {
+    if (arg.type !== 4 || !arg.isStatic) {
+      context.onError(
+        createCompilerError(
+          52,
+          arg.loc
+        )
+      );
+      return {
+        props: [
+          createObjectProperty(arg, createSimpleExpression("", true, loc))
+        ]
+      };
+    }
     const propName = camelize(arg.content);
     exp = dir.exp = createSimpleExpression(propName, false, arg.loc);
     {
@@ -24706,12 +24261,6 @@ const transformBind = (dir, _node, context) => {
       injectPrefix(arg, "^");
     }
   }
-  if (!exp || exp.type === 4 && !exp.content.trim()) {
-    context.onError(createCompilerError(34, loc));
-    return {
-      props: [createObjectProperty(arg, createSimpleExpression("", true, loc))]
-    };
-  }
   return {
     props: [createObjectProperty(arg, exp)]
   };
@@ -27470,6 +27019,8 @@ var isArray$2 = Array.isArray || function (arr) {
  * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
  * @license  MIT
  */
+/* eslint-disable no-proto */
+
 
 var INSPECT_MAX_BYTES = 50;
 
@@ -37172,7 +36723,6 @@ const trimPlugin = () => {
   };
 };
 trimPlugin.postcss = true;
-var trimPlugin$1 = trimPlugin;
 
 var dist = {exports: {}};
 
@@ -40744,7 +40294,6 @@ function isSpaceCombinator(node) {
   return node.type === "combinator" && /^\s+$/.test(node.value);
 }
 scopedPlugin.postcss = true;
-var scopedPlugin$1 = scopedPlugin;
 
 var sourceMap$1 = {};
 
@@ -44141,10 +43690,10 @@ function doCompileStyle(options) {
   const plugins = (postcssPlugins || []).slice();
   plugins.unshift(cssVarsPlugin({ id: shortId, isProd }));
   if (trim) {
-    plugins.push(trimPlugin$1());
+    plugins.push(trimPlugin());
   }
   if (scoped) {
-    plugins.push(scopedPlugin$1(longId));
+    plugins.push(scopedPlugin(longId));
   }
   let cssModules;
   if (modules) {
@@ -44575,8 +44124,8 @@ class Chunk {
 }
 
 function getBtoa() {
-	if (typeof window !== 'undefined' && typeof window.btoa === 'function') {
-		return (str) => window.btoa(unescape(encodeURIComponent(str)));
+	if (typeof globalThis !== 'undefined' && typeof globalThis.btoa === 'function') {
+		return (str) => globalThis.btoa(unescape(encodeURIComponent(str)));
 	} else if (typeof Buffer === 'function') {
 		return (str) => Buffer.from(str, 'utf-8').toString('base64');
 	} else {
@@ -48649,7 +48198,7 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
-const version = "3.4.15";
+const version = "3.4.16";
 const parseCache = parseCache$1;
 const errorMessages = __spreadValues(__spreadValues({}, errorMessages$1), DOMErrorMessages);
 const walk = walk$2;