stacks 0.58.29 → 0.58.30

package/core/docs/dist/index.js

@@ -1033,11 +1033,8 @@ var require_lib = __commonJS((exports) => {
   var toParseErrorConstructor = function(_ref) {
     let {
       toMessage
-    } = _ref, properties = _objectWithoutPropertiesLoose(_ref, _excluded$1);
-    return function constructor({
-      loc,
-      details
-    }) {
+    } = _ref, properties = _objectWithoutPropertiesLoose(_ref, _excluded);
+    return function constructor(loc, details) {
       const error = new SyntaxError;
       Object.assign(error, properties, {
         loc,
@@ -1055,10 +1052,7 @@ var require_lib = __commonJS((exports) => {
           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", {
@@ -1091,7 +1085,7 @@ var require_lib = __commonJS((exports) => {
         message: template
       } : template, {
         message
-      } = _ref2, rest = _objectWithoutPropertiesLoose(_ref2, _excluded2$1);
+      } = _ref2, rest = _objectWithoutPropertiesLoose(_ref2, _excluded2);
       const toMessage = typeof message === "string" ? () => message : message;
       ParseErrorConstructors[reasonCode] = toParseErrorConstructor(Object.assign({
         code: "BABEL_PARSER_SYNTAX_ERROR",
@@ -2448,8 +2442,8 @@ var require_lib = __commonJS((exports) => {
     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.'
   };
-  var _excluded$1 = ["toMessage"];
-  var _excluded2$1 = ["message"];
+  var _excluded = ["toMessage"];
+  var _excluded2 = ["message"];
   var Errors = Object.assign({}, ParseErrorEnum(ModuleErrors), ParseErrorEnum(StandardErrors), ParseErrorEnum(StrictModeErrors), ParseErrorEnum`pipelineOperator`(PipelineOperatorErrors));
   var {
     defineProperty
@@ -2679,13 +2673,9 @@ var require_lib = __commonJS((exports) => {
     }
     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);
       }
@@ -3276,9 +3266,9 @@ var require_lib = __commonJS((exports) => {
 
   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;
     }
   }
@@ -3347,11 +3337,16 @@ var require_lib = __commonJS((exports) => {
       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);
         }
@@ -3359,7 +3354,7 @@ var require_lib = __commonJS((exports) => {
         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;
@@ -3376,8 +3371,7 @@ var require_lib = __commonJS((exports) => {
     }
     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
         });
       }
@@ -3386,19 +3380,20 @@ var require_lib = __commonJS((exports) => {
       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);
       }
     }
@@ -3451,8 +3446,9 @@ var require_lib = __commonJS((exports) => {
     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;
     }
@@ -3495,7 +3491,13 @@ var require_lib = __commonJS((exports) => {
     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 {
@@ -3649,7 +3651,7 @@ var require_lib = __commonJS((exports) => {
 
   class State {
     constructor() {
-      this.strict = undefined;
+      this.flags = 1024;
       this.curLine = undefined;
       this.lineStart = undefined;
       this.startLoc = undefined;
@@ -3658,21 +3660,12 @@ var require_lib = __commonJS((exports) => {
       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;
@@ -3681,14 +3674,21 @@ var require_lib = __commonJS((exports) => {
       this.end = 0;
       this.lastTokEndLoc = null;
       this.lastTokStartLoc = null;
-      this.lastTokStart = 0;
       this.context = [types.brace];
-      this.canStartJSXElement = true;
-      this.containsEsc = false;
       this.firstInvalidTemplateEscapePos = null;
       this.strictErrors = new Map;
       this.tokensLength = 0;
     }
+    get strict() {
+      return (this.flags & 1) > 0;
+    }
+    set strict(value) {
+      if (value) {
+        this.flags |= 1;
+      } else {
+        this.flags &= ~1;
+      }
+    }
     init({
       strictMode,
       sourceType,
@@ -3700,20 +3700,145 @@ var require_lib = __commonJS((exports) => {
       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;
     }
   }
@@ -3730,8 +3855,6 @@ var require_lib = __commonJS((exports) => {
     dec: (ch) => ch >= 48 && ch <= 57,
     hex: (ch) => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
   };
-  var _excluded = ["at"];
-  var _excluded2 = ["at"];
   var VALID_REGEX_FLAGS = new Set([103, 109, 115, 105, 121, 117, 100, 118]);
 
   class Token {
@@ -3753,8 +3876,7 @@ var require_lib = __commonJS((exports) => {
         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;
@@ -3768,28 +3890,23 @@ var require_lib = __commonJS((exports) => {
       });
       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) {
@@ -3802,7 +3919,6 @@ var require_lib = __commonJS((exports) => {
       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();
@@ -3877,9 +3993,7 @@ var require_lib = __commonJS((exports) => {
     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();
       }
     }
@@ -3904,9 +4018,7 @@ var require_lib = __commonJS((exports) => {
       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;
@@ -4066,16 +4178,12 @@ var require_lib = __commonJS((exports) => {
       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) {
@@ -4162,9 +4270,7 @@ var require_lib = __commonJS((exports) => {
         }
         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);
@@ -4172,9 +4278,7 @@ var require_lib = __commonJS((exports) => {
         }
         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);
@@ -4320,9 +4424,7 @@ var require_lib = __commonJS((exports) => {
         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);
@@ -4338,9 +4440,7 @@ var require_lib = __commonJS((exports) => {
         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);
@@ -4443,8 +4543,7 @@ var require_lib = __commonJS((exports) => {
             return;
           }
       }
-      throw this.raise(Errors.InvalidOrUnexpectedToken, {
-        at: this.state.curPosition(),
+      throw this.raise(Errors.InvalidOrUnexpectedToken, this.state.curPosition(), {
         unexpected: String.fromCodePoint(code2)
       });
     }
@@ -4462,15 +4561,11 @@ var require_lib = __commonJS((exports) => {
       } = 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;
@@ -4495,26 +4590,18 @@ var require_lib = __commonJS((exports) => {
         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;
         }
@@ -4541,8 +4628,7 @@ var require_lib = __commonJS((exports) => {
       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
         });
       }
@@ -4551,14 +4637,10 @@ var require_lib = __commonJS((exports) => {
         ++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, "");
@@ -4576,22 +4658,16 @@ var require_lib = __commonJS((exports) => {
       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);
@@ -4609,9 +4685,7 @@ var require_lib = __commonJS((exports) => {
           ++this.state.pos;
         }
         if (this.readInt(10) === null) {
-          this.raise(Errors.InvalidOrMissingExponent, {
-            at: startLoc
-          });
+          this.raise(Errors.InvalidOrMissingExponent, startLoc);
         }
         isFloat = true;
         hasExponent = true;
@@ -4619,9 +4693,7 @@ var require_lib = __commonJS((exports) => {
       }
       if (next === 110) {
         if (isFloat || hasLeadingZero) {
-          this.raise(Errors.InvalidBigIntLiteral, {
-            at: startLoc
-          });
+          this.raise(Errors.InvalidBigIntLiteral, startLoc);
         }
         ++this.state.pos;
         isBigInt = true;
@@ -4629,17 +4701,13 @@ var require_lib = __commonJS((exports) => {
       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) {
@@ -4702,14 +4770,10 @@ var require_lib = __commonJS((exports) => {
         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]);
       }
@@ -4732,9 +4796,7 @@ var require_lib = __commonJS((exports) => {
           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;
           }
@@ -4742,9 +4804,7 @@ var require_lib = __commonJS((exports) => {
           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);
           }
@@ -4769,77 +4829,59 @@ var require_lib = __commonJS((exports) => {
         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));
       };
     }
   }
@@ -4874,8 +4916,7 @@ var require_lib = __commonJS((exports) => {
             current.undefinedPrivateNames.set(name, loc);
           }
         } else {
-          this.parser.raise(Errors.InvalidPrivateFieldResolution, {
-            at: loc,
+          this.parser.raise(Errors.InvalidPrivateFieldResolution, loc, {
             identifierName: name
           });
         }
@@ -4903,8 +4944,7 @@ var require_lib = __commonJS((exports) => {
         }
       }
       if (redefined) {
-        this.parser.raise(Errors.PrivateNameRedeclaration, {
-          at: loc,
+        this.parser.raise(Errors.PrivateNameRedeclaration, loc, {
           identifierName: name
         });
       }
@@ -4920,8 +4960,7 @@ var require_lib = __commonJS((exports) => {
       if (classScope) {
         classScope.undefinedPrivateNames.set(name, loc);
       } else {
-        this.parser.raise(Errors.InvalidPrivateFieldResolution, {
-          at: loc,
+        this.parser.raise(Errors.InvalidPrivateFieldResolution, loc, {
           identifierName: name
         });
       }
@@ -4945,9 +4984,7 @@ var require_lib = __commonJS((exports) => {
       super(type);
       this.declarationErrors = new Map;
     }
-    recordDeclarationError(ParsingErrorClass, {
-      at
-    }) {
+    recordDeclarationError(ParsingErrorClass, at) {
       const index = at.index;
       this.declarationErrors.set(index, [ParsingErrorClass, at]);
     }
@@ -4971,12 +5008,8 @@ var require_lib = __commonJS((exports) => {
     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;
@@ -4992,16 +5025,12 @@ var require_lib = __commonJS((exports) => {
       }
       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()) {
@@ -5010,9 +5039,7 @@ var require_lib = __commonJS((exports) => {
         return;
       }
     }
-    recordAsyncArrowParametersError({
-      at
-    }) {
+    recordAsyncArrowParametersError(at) {
       const {
         stack
       } = this;
@@ -5020,9 +5047,7 @@ var require_lib = __commonJS((exports) => {
       let scope = stack[i];
       while (scope.canBeArrowParameterDeclaration()) {
         if (scope.type === 2) {
-          scope.recordDeclarationError(Errors.AwaitBindingIdentifier, {
-            at
-          });
+          scope.recordDeclarationError(Errors.AwaitBindingIdentifier, at);
         }
         scope = stack[--i];
       }
@@ -5035,9 +5060,7 @@ var require_lib = __commonJS((exports) => {
       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()) {
@@ -5114,9 +5137,7 @@ var require_lib = __commonJS((exports) => {
     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);
       }
@@ -5137,9 +5158,7 @@ var require_lib = __commonJS((exports) => {
     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);
@@ -5210,19 +5229,13 @@ var require_lib = __commonJS((exports) => {
         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);
@@ -5328,7 +5341,8 @@ var require_lib = __commonJS((exports) => {
 
   class NodeUtils extends UtilParser {
     startNode() {
-      return new Node(this, this.state.start, this.state.startLoc);
+      const loc = this.state.startLoc;
+      return new Node(this, loc.index, loc);
     }
     startNodeAt(loc) {
       return new Node(this, loc.index, loc);
@@ -5516,10 +5530,8 @@ var require_lib = __commonJS((exports) => {
       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();
@@ -5588,9 +5600,7 @@ var require_lib = __commonJS((exports) => {
           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);
         }
@@ -5628,9 +5638,7 @@ var require_lib = __commonJS((exports) => {
         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(bodyNode2);
         } else {
@@ -5647,21 +5655,15 @@ var require_lib = __commonJS((exports) => {
       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;
@@ -5684,8 +5686,7 @@ var require_lib = __commonJS((exports) => {
       } 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]
           });
@@ -5783,16 +5784,13 @@ var require_lib = __commonJS((exports) => {
     }
     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
       });
     }
@@ -5845,9 +5843,7 @@ var require_lib = __commonJS((exports) => {
         node.default = this.flowParseType();
       } else {
         if (requireDefault) {
-          this.raise(FlowErrors.MissingTypeParamDefault, {
-            at: nodeStartLoc
-          });
+          this.raise(FlowErrors.MissingTypeParamDefault, nodeStartLoc);
         }
       }
       return this.finishNode(node, "TypeParameter");
@@ -6087,9 +6083,7 @@ var require_lib = __commonJS((exports) => {
         }
         this.flowObjectTypeSemicolon();
         if (inexactStartLoc && !this.match(8) && !this.match(9)) {
-          this.raise(FlowErrors.UnexpectedExplicitInexactInObject, {
-            at: inexactStartLoc
-          });
+          this.raise(FlowErrors.UnexpectedExplicitInexactInObject, inexactStartLoc);
         }
       }
       this.expect(endDelim);
@@ -6105,33 +6099,23 @@ var require_lib = __commonJS((exports) => {
         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");
@@ -6154,9 +6138,7 @@ var require_lib = __commonJS((exports) => {
             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")
@@ -6176,19 +6158,13 @@ var require_lib = __commonJS((exports) => {
       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() {
@@ -6245,17 +6221,13 @@ var require_lib = __commonJS((exports) => {
       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();
@@ -6411,9 +6383,7 @@ var require_lib = __commonJS((exports) => {
             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;
@@ -6678,9 +6648,7 @@ var require_lib = __commonJS((exports) => {
           [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;
@@ -6842,13 +6810,9 @@ var require_lib = __commonJS((exports) => {
       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);
         }
       }
     }
@@ -6859,8 +6823,7 @@ var require_lib = __commonJS((exports) => {
       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
         });
       }
@@ -6912,9 +6875,7 @@ var require_lib = __commonJS((exports) => {
         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;
@@ -6962,16 +6923,12 @@ var require_lib = __commonJS((exports) => {
       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);
         }
       }
     }
@@ -7011,13 +6968,9 @@ var require_lib = __commonJS((exports) => {
       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);
         }
       }
     }
@@ -7044,28 +6997,20 @@ var require_lib = __commonJS((exports) => {
     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;
@@ -7073,18 +7018,14 @@ var require_lib = __commonJS((exports) => {
     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) {
@@ -7143,8 +7084,7 @@ var require_lib = __commonJS((exports) => {
           specifier.importKind = specifierTypeKind;
         } else {
           if (importedIsString) {
-            throw this.raise(Errors.ImportBindingIsString, {
-              at: specifier,
+            throw this.raise(Errors.ImportBindingIsString, specifier, {
               importName: firstIdent.value
             });
           }
@@ -7160,9 +7100,7 @@ var require_lib = __commonJS((exports) => {
       }
       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);
@@ -7248,9 +7186,7 @@ var require_lib = __commonJS((exports) => {
         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;
           }
@@ -7268,9 +7204,7 @@ var require_lib = __commonJS((exports) => {
           throw jsx2.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);
     }
@@ -7312,9 +7246,7 @@ var require_lib = __commonJS((exports) => {
       }
       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);
@@ -7420,18 +7352,14 @@ var require_lib = __commonJS((exports) => {
     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();
@@ -7467,43 +7395,26 @@ var require_lib = __commonJS((exports) => {
     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;
@@ -7609,16 +7520,14 @@ var require_lib = __commonJS((exports) => {
           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
           });
@@ -7703,8 +7612,7 @@ var require_lib = __commonJS((exports) => {
       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
         });
       }
@@ -7713,8 +7621,7 @@ var require_lib = __commonJS((exports) => {
       } = 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
         });
@@ -7798,8 +7705,7 @@ var require_lib = __commonJS((exports) => {
             this.expect(8);
             return this.finishNode(node, "EnumNumberBody");
           } else {
-            this.raise(FlowErrors.EnumInconsistentMemberValues, {
-              at: nameLoc,
+            this.raise(FlowErrors.EnumInconsistentMemberValues, nameLoc, {
               enumName
             });
             return empty();
@@ -8102,9 +8008,7 @@ var require_lib = __commonJS((exports) => {
       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) {
@@ -8159,9 +8063,7 @@ var require_lib = __commonJS((exports) => {
       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)
@@ -8266,18 +8168,14 @@ var require_lib = __commonJS((exports) => {
           this.next();
           node = this.jsxParseExpressionContainer(node, types.j_oTag);
           if (node.expression.type === "JSXEmptyExpression") {
-            this.raise(JsxErrors.AttributeIsEmpty, {
-              at: node
-            });
+            this.raise(JsxErrors.AttributeIsEmpty, node);
           }
           return node;
         case 142:
         case 133:
           return this.parseExprAtom();
         default:
-          throw this.raise(JsxErrors.UnsupportedJsxValue, {
-            at: this.state.startLoc
-          });
+          throw this.raise(JsxErrors.UnsupportedJsxValue, this.state.startLoc);
       }
     }
     jsxParseEmptyExpression() {
@@ -8384,18 +8282,14 @@ var require_lib = __commonJS((exports) => {
             }
           }
         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)
             });
           }
@@ -8410,9 +8304,7 @@ var require_lib = __commonJS((exports) => {
       }
       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");
     }
@@ -8500,11 +8392,7 @@ var require_lib = __commonJS((exports) => {
   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;
     }
   }
 
@@ -8546,8 +8434,7 @@ var require_lib = __commonJS((exports) => {
     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
           });
         }
@@ -8555,9 +8442,10 @@ var require_lib = __commonJS((exports) => {
         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);
@@ -8566,33 +8454,38 @@ var require_lib = __commonJS((exports) => {
           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);
@@ -8606,8 +8499,10 @@ var require_lib = __commonJS((exports) => {
       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))
+        const type = scope.tsNames.get(name);
+        if ((type & 1) > 0 || (type & 16) > 0) {
           return;
+        }
       }
       super.checkLocalExport(id);
     }
@@ -8625,18 +8520,12 @@ var require_lib = __commonJS((exports) => {
         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) {
@@ -8654,9 +8543,7 @@ var require_lib = __commonJS((exports) => {
             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;
@@ -8680,9 +8567,7 @@ var require_lib = __commonJS((exports) => {
           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;
@@ -8695,18 +8580,14 @@ var require_lib = __commonJS((exports) => {
     }
     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);
@@ -8728,13 +8609,9 @@ var require_lib = __commonJS((exports) => {
         }
         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);
           }
         }
       }
@@ -8829,9 +8706,7 @@ var require_lib = __commonJS((exports) => {
         } 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());
@@ -8917,16 +8792,13 @@ var require_lib = __commonJS((exports) => {
         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;
       }
@@ -8937,9 +8809,7 @@ var require_lib = __commonJS((exports) => {
         } = expression;
         if (checkClashes) {
           if (checkClashes.has(name)) {
-            this.raise(Errors.ParamDupe, {
-              at: expression
-            });
+            this.raise(Errors.ParamDupe, expression);
           } else {
             checkClashes.add(name);
           }
@@ -8951,8 +8821,7 @@ var require_lib = __commonJS((exports) => {
         return;
       if (validity === false) {
         const ParseErrorClass = binding === 64 ? Errors.InvalidLhs : Errors.InvalidLhsBinding;
-        this.raise(ParseErrorClass, {
-          at: expression,
+        this.raise(ParseErrorClass, expression, {
           ancestor
         });
         return;
@@ -8976,21 +8845,17 @@ var require_lib = __commonJS((exports) => {
     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);
@@ -9012,18 +8877,14 @@ var require_lib = __commonJS((exports) => {
           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;
     }
   }
@@ -9176,16 +9037,14 @@ var require_lib = __commonJS((exports) => {
     }, 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]
           });
         }
@@ -9199,8 +9058,7 @@ var require_lib = __commonJS((exports) => {
           break;
         if (tsIsAccessModifier(modifier)) {
           if (modified.accessibility) {
-            this.raise(TSErrors.DuplicateAccessibilityModifier, {
-              at: startLoc,
+            this.raise(TSErrors.DuplicateAccessibilityModifier, startLoc, {
               modifier
             });
           } else {
@@ -9211,8 +9069,7 @@ var require_lib = __commonJS((exports) => {
           }
         } else if (tsIsVarianceAnnotations(modifier)) {
           if (modified[modifier]) {
-            this.raise(TSErrors.DuplicateModifier, {
-              at: startLoc,
+            this.raise(TSErrors.DuplicateModifier, startLoc, {
               modifier
             });
           }
@@ -9220,8 +9077,7 @@ var require_lib = __commonJS((exports) => {
           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 {
@@ -9235,8 +9091,7 @@ var require_lib = __commonJS((exports) => {
           modified[modifier] = true;
         }
         if (disallowedModifiers != null && disallowedModifiers.includes(modifier)) {
-          this.raise(errorTemplate, {
-            at: startLoc,
+          this.raise(errorTemplate, startLoc, {
             modifier
           });
         }
@@ -9279,7 +9134,7 @@ var require_lib = __commonJS((exports) => {
         }
         result.push(element);
         if (this.eat(12)) {
-          trailingCommaPos = this.state.lastTokStart;
+          trailingCommaPos = this.state.lastTokStartLoc.index;
           continue;
         }
         if (this.tsIsListTerminator(kind)) {
@@ -9316,9 +9171,7 @@ var require_lib = __commonJS((exports) => {
       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);
@@ -9399,9 +9252,7 @@ var require_lib = __commonJS((exports) => {
       };
       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);
@@ -9428,8 +9279,7 @@ var require_lib = __commonJS((exports) => {
           type
         } = pattern;
         if (type === "AssignmentPattern" || type === "TSParameterProperty") {
-          this.raise(TSErrors.UnsupportedSignatureParameterKind, {
-            at: pattern,
+          this.raise(TSErrors.UnsupportedSignatureParameterKind, pattern, {
             type
           });
         }
@@ -9476,15 +9326,11 @@ var require_lib = __commonJS((exports) => {
       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();
@@ -9492,42 +9338,28 @@ var require_lib = __commonJS((exports) => {
         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";
@@ -9644,9 +9476,7 @@ var require_lib = __commonJS((exports) => {
           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");
       });
@@ -9699,16 +9529,12 @@ var require_lib = __commonJS((exports) => {
           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();
         }
@@ -9862,9 +9688,7 @@ var require_lib = __commonJS((exports) => {
         case "TSArrayType":
           return;
         default:
-          this.raise(TSErrors.UnexpectedReadonly, {
-            at: node
-          });
+          this.raise(TSErrors.UnexpectedReadonly, node);
       }
     }
     tsParseInferType() {
@@ -10032,8 +9856,7 @@ var require_lib = __commonJS((exports) => {
         return false;
       }
       if (containsEsc) {
-        this.raise(Errors.InvalidEscapedReservedWord, {
-          at: this.state.lastTokStartLoc,
+        this.raise(Errors.InvalidEscapedReservedWord, this.state.lastTokStartLoc, {
           reservedWord: "asserts"
         });
       }
@@ -10078,9 +9901,7 @@ var require_lib = __commonJS((exports) => {
     }
     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(() => {
@@ -10102,8 +9923,7 @@ var require_lib = __commonJS((exports) => {
         return this.finishNode(node, "TSExpressionWithTypeArguments");
       });
       if (!delimitedList.length) {
-        this.raise(TSErrors.EmptyHeritageClauseType, {
-          at: originalStartLoc,
+        this.raise(TSErrors.EmptyHeritageClauseType, originalStartLoc, {
           token
         });
       }
@@ -10120,9 +9940,7 @@ var require_lib = __commonJS((exports) => {
         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)) {
@@ -10276,9 +10094,7 @@ var require_lib = __commonJS((exports) => {
       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();
@@ -10469,9 +10285,7 @@ var require_lib = __commonJS((exports) => {
         return this.tsParseDelimitedList("TypeParametersOrArguments", this.tsParseType.bind(this));
       }));
       if (node.params.length === 0) {
-        this.raise(TSErrors.EmptyTypeArguments, {
-          at: node
-        });
+        this.raise(TSErrors.EmptyTypeArguments, node);
       } else if (!this.state.inType && this.curContext() === types.brace) {
         this.reScan_lt_gt();
       }
@@ -10496,9 +10310,7 @@ var require_lib = __commonJS((exports) => {
       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);
@@ -10515,9 +10327,7 @@ var require_lib = __commonJS((exports) => {
         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");
@@ -10533,9 +10343,7 @@ var require_lib = __commonJS((exports) => {
     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);
         }
       }
     }
@@ -10552,9 +10360,7 @@ var require_lib = __commonJS((exports) => {
         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);
         }
@@ -10572,9 +10378,7 @@ var require_lib = __commonJS((exports) => {
     tsCheckForInvalidTypeCasts(items) {
       items.forEach((node) => {
         if ((node == null ? undefined : node.type) === "TSTypeCastExpression") {
-          this.raise(TSErrors.UnexpectedTypeAnnotation, {
-            at: node.typeAnnotation
-          });
+          this.raise(TSErrors.UnexpectedTypeAnnotation, node.typeAnnotation);
         }
       });
     }
@@ -10652,9 +10456,7 @@ var require_lib = __commonJS((exports) => {
         }
         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;
         }
@@ -10681,8 +10483,7 @@ var require_lib = __commonJS((exports) => {
           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"
               });
             }
@@ -10704,9 +10505,7 @@ var require_lib = __commonJS((exports) => {
     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() {
@@ -10748,9 +10547,7 @@ var require_lib = __commonJS((exports) => {
         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;
     }
@@ -10811,13 +10608,9 @@ var require_lib = __commonJS((exports) => {
         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;
@@ -10867,9 +10660,7 @@ var require_lib = __commonJS((exports) => {
           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 {
@@ -10887,38 +10678,27 @@ var require_lib = __commonJS((exports) => {
       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);
@@ -10928,14 +10708,10 @@ var require_lib = __commonJS((exports) => {
       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) {
@@ -10983,9 +10759,7 @@ var require_lib = __commonJS((exports) => {
       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);
@@ -11024,16 +10798,13 @@ var require_lib = __commonJS((exports) => {
     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)}]`
         });
       }
@@ -11041,13 +10812,10 @@ var require_lib = __commonJS((exports) => {
     }
     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
         });
       }
@@ -11057,26 +10825,21 @@ var require_lib = __commonJS((exports) => {
     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
         });
       }
@@ -11202,9 +10965,7 @@ var require_lib = __commonJS((exports) => {
     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) {
@@ -11263,13 +11024,9 @@ var require_lib = __commonJS((exports) => {
         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;
@@ -11350,9 +11107,7 @@ var require_lib = __commonJS((exports) => {
     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;
     }
@@ -11467,9 +11222,7 @@ var require_lib = __commonJS((exports) => {
       } 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 {
@@ -11484,8 +11237,7 @@ var require_lib = __commonJS((exports) => {
           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)}]`
           });
         }
@@ -11567,9 +11319,7 @@ var require_lib = __commonJS((exports) => {
         }
       }
       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;
@@ -11688,9 +11438,7 @@ var require_lib = __commonJS((exports) => {
           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);
@@ -11771,9 +11519,7 @@ var require_lib = __commonJS((exports) => {
     }
     assertNoSpace() {
       if (this.state.start > this.state.lastTokEndLoc.index) {
-        this.raise(PlaceholderErrors.UnexpectedSpace, {
-          at: this.state.lastTokEndLoc
-        });
+        this.raise(PlaceholderErrors.UnexpectedSpace, this.state.lastTokEndLoc);
       }
     }
   };
@@ -11841,9 +11587,7 @@ var require_lib = __commonJS((exports) => {
       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) {
@@ -11852,9 +11596,7 @@ var require_lib = __commonJS((exports) => {
               refExpressionErrors.doubleProtoLoc = key.loc.start;
             }
           } else {
-            this.raise(Errors.DuplicateProto, {
-              at: key
-            });
+            this.raise(Errors.DuplicateProto, key);
           }
         }
         protoRef.used = true;
@@ -11871,7 +11613,7 @@ var require_lib = __commonJS((exports) => {
         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;
@@ -12004,8 +11746,7 @@ var require_lib = __commonJS((exports) => {
       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
           });
         }
@@ -12035,18 +11776,14 @@ var require_lib = __commonJS((exports) => {
             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);
         }
@@ -12065,9 +11802,7 @@ var require_lib = __commonJS((exports) => {
             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);
               });
@@ -12092,23 +11827,18 @@ var require_lib = __commonJS((exports) => {
       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) {
@@ -12136,13 +11866,9 @@ var require_lib = __commonJS((exports) => {
         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) {
@@ -12159,9 +11885,7 @@ var require_lib = __commonJS((exports) => {
         } = this.state;
         const startsExpr2 = this.hasPlugin("v8intrinsic") ? tokenCanStartExpression(type) : tokenCanStartExpression(type) && !this.match(54);
         if (startsExpr2 && !this.isAmbiguousAwait()) {
-          this.raiseOverwrite(Errors.AwaitNotInAsyncContext, {
-            at: startLoc
-          });
+          this.raiseOverwrite(Errors.AwaitNotInAsyncContext, startLoc);
           return this.parseAwait(startLoc);
         }
       }
@@ -12224,9 +11948,7 @@ var require_lib = __commonJS((exports) => {
       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;
@@ -12256,9 +11978,7 @@ var require_lib = __commonJS((exports) => {
         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();
@@ -12328,9 +12048,7 @@ var require_lib = __commonJS((exports) => {
       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");
     }
@@ -12352,16 +12070,13 @@ var require_lib = __commonJS((exports) => {
           }
         }
         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);
             }
           }
         }
@@ -12380,9 +12095,7 @@ var require_lib = __commonJS((exports) => {
           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);
@@ -12438,9 +12151,7 @@ var require_lib = __commonJS((exports) => {
               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:
@@ -12506,14 +12217,11 @@ var require_lib = __commonJS((exports) => {
           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();
@@ -12608,15 +12316,12 @@ var require_lib = __commonJS((exports) => {
       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)
         });
       }
@@ -12631,9 +12336,7 @@ var require_lib = __commonJS((exports) => {
         case "smart":
           return tokenType === 27;
         default:
-          throw this.raise(Errors.PipeTopicRequiresHackPipes, {
-            at: startLoc
-          });
+          throw this.raise(Errors.PipeTopicRequiresHackPipes, startLoc);
       }
     }
     parseAsyncArrowUnaryFunction(node) {
@@ -12641,9 +12344,7 @@ var require_lib = __commonJS((exports) => {
       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);
@@ -12671,18 +12372,12 @@ var require_lib = __commonJS((exports) => {
       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");
     }
@@ -12714,8 +12409,7 @@ var require_lib = __commonJS((exports) => {
       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: meta2.name,
           onlyValidPropertyName: propertyName
         });
@@ -12727,9 +12421,7 @@ var require_lib = __commonJS((exports) => {
       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)) {
@@ -12738,8 +12430,7 @@ var require_lib = __commonJS((exports) => {
           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
           });
         }
@@ -12887,9 +12578,7 @@ var require_lib = __commonJS((exports) => {
         this.next();
         const metaProp = this.parseMetaProperty(node, meta2, "target");
         if (!this.scope.inNonArrowFunction && !this.scope.inClass && !this.options.allowNewTargetOutsideFunction) {
-          this.raise(Errors.UnexpectedNewTarget, {
-            at: metaProp
-          });
+          this.raise(Errors.UnexpectedNewTarget, metaProp);
         }
         return metaProp;
       }
@@ -12911,9 +12600,7 @@ var require_lib = __commonJS((exports) => {
       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) {
@@ -12927,9 +12614,7 @@ var require_lib = __commonJS((exports) => {
       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);
@@ -12989,9 +12674,7 @@ var require_lib = __commonJS((exports) => {
           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);
@@ -13009,7 +12692,7 @@ var require_lib = __commonJS((exports) => {
       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) {
@@ -13019,9 +12702,7 @@ var require_lib = __commonJS((exports) => {
       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());
@@ -13062,8 +12743,7 @@ var require_lib = __commonJS((exports) => {
           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();
@@ -13084,14 +12764,10 @@ var require_lib = __commonJS((exports) => {
       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 ? undefined : _params.type) === "RestElement") {
-        this.raise(Errors.BadSetterRestParameter, {
-          at: method
-        });
+        this.raise(Errors.BadSetterRestParameter, method);
       }
     }
     parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) {
@@ -13125,9 +12801,7 @@ var require_lib = __commonJS((exports) => {
               refExpressionErrors.shorthandAssignLoc = shorthandAssignLoc;
             }
           } else {
-            this.raise(Errors.InvalidCoverInitializedName, {
-              at: shorthandAssignLoc
-            });
+            this.raise(Errors.InvalidCoverInitializedName, shorthandAssignLoc);
           }
           prop.value = this.parseMaybeDefault(startLoc, cloneIdentifier(prop.key));
         } else {
@@ -13177,9 +12851,7 @@ var require_lib = __commonJS((exports) => {
                   refExpressionErrors.privateKeyLoc = privateKeyLoc;
                 }
               } else {
-                this.raise(Errors.UnexpectedPrivateField, {
-                  at: privateKeyLoc
-                });
+                this.raise(Errors.UnexpectedPrivateField, privateKeyLoc);
               }
               key = this.parsePrivateName();
               break;
@@ -13265,9 +12937,7 @@ var require_lib = __commonJS((exports) => {
         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);
@@ -13328,8 +12998,7 @@ var require_lib = __commonJS((exports) => {
       let elt;
       if (this.match(12)) {
         if (!allowEmpty) {
-          this.raise(Errors.UnexpectedToken, {
-            at: this.state.curPosition(),
+          this.raise(Errors.UnexpectedToken, this.state.curPosition(), {
             unexpected: ","
           });
         }
@@ -13340,9 +13009,7 @@ var require_lib = __commonJS((exports) => {
       } 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();
@@ -13392,47 +13059,35 @@ var require_lib = __commonJS((exports) => {
         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;
         }
       }
@@ -13447,13 +13102,9 @@ var require_lib = __commonJS((exports) => {
     }
     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()) {
@@ -13477,9 +13128,7 @@ var require_lib = __commonJS((exports) => {
     }
     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;
@@ -13525,9 +13174,7 @@ var require_lib = __commonJS((exports) => {
         proposal: "smart"
       }])) {
         if (left.type === "SequenceExpression") {
-          this.raise(Errors.PipelineHeadSequenceExpression, {
-            at: leftStartLoc
-          });
+          this.raise(Errors.PipelineHeadSequenceExpression, leftStartLoc);
         }
       }
     }
@@ -13555,14 +13202,10 @@ var require_lib = __commonJS((exports) => {
     }
     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) {
@@ -13670,10 +13313,10 @@ var require_lib = __commonJS((exports) => {
     }
   }
   var loopLabel = {
-    kind: "loop"
+    kind: 1
   };
   var switchLabel = {
-    kind: "switch"
+    kind: 2
   };
   var loneSurrogate = /[\uD800-\uDFFF]/u;
   var keywordRelationalOperator = /in(?:stanceof)?/y;
@@ -13681,7 +13324,7 @@ var require_lib = __commonJS((exports) => {
   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);
       }
@@ -13693,8 +13336,7 @@ var require_lib = __commonJS((exports) => {
       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
           });
         }
@@ -13837,9 +13479,7 @@ var require_lib = __commonJS((exports) => {
           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:
@@ -13859,13 +13499,9 @@ var require_lib = __commonJS((exports) => {
         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");
@@ -13877,13 +13513,9 @@ var require_lib = __commonJS((exports) => {
           }
           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: {
@@ -13902,9 +13534,7 @@ var require_lib = __commonJS((exports) => {
         }
         case 75: {
           if (!allowDeclaration) {
-            this.raise(Errors.UnexpectedLexicalDeclaration, {
-              at: this.state.startLoc
-            });
+            this.raise(Errors.UnexpectedLexicalDeclaration, this.state.startLoc);
           }
         }
         case 74: {
@@ -13927,9 +13557,7 @@ var require_lib = __commonJS((exports) => {
         }
         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;
@@ -13950,9 +13578,7 @@ var require_lib = __commonJS((exports) => {
         default: {
           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);
@@ -13969,9 +13595,7 @@ var require_lib = __commonJS((exports) => {
     }
     assertModuleNodeAllowed(node) {
       if (!this.options.allowImportExportEverywhere && !this.inModule) {
-        this.raise(Errors.ImportOutsideModule, {
-          at: node
-        });
+        this.raise(Errors.ImportOutsideModule, node);
       }
     }
     decoratorsEnabledBeforeExport() {
@@ -13983,9 +13607,7 @@ var require_lib = __commonJS((exports) => {
       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 {
@@ -14010,14 +13632,10 @@ var require_lib = __commonJS((exports) => {
           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;
     }
@@ -14037,9 +13655,7 @@ var require_lib = __commonJS((exports) => {
           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);
@@ -14088,16 +13704,16 @@ var require_lib = __commonJS((exports) => {
       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"))
+          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
         });
       }
@@ -14149,9 +13765,7 @@ var require_lib = __commonJS((exports) => {
           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 {
@@ -14162,9 +13776,7 @@ var require_lib = __commonJS((exports) => {
           const init2 = this.finishNode(initNode, "VariableDeclaration");
           const isForIn = this.match(58);
           if (isForIn && starsWithUsingDeclaration) {
-            this.raise(Errors.ForInUsing, {
-              at: init2
-            });
+            this.raise(Errors.ForInUsing, init2);
           }
           if ((isForIn || this.isContextual(102)) && init2.declarations.length === 1) {
             return this.parseForIn(node, init2, awaitAt);
@@ -14181,14 +13793,10 @@ var require_lib = __commonJS((exports) => {
       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)) {
@@ -14222,9 +13830,7 @@ var require_lib = __commonJS((exports) => {
     }
     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()) {
@@ -14255,9 +13861,7 @@ var require_lib = __commonJS((exports) => {
             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;
@@ -14281,9 +13885,7 @@ var require_lib = __commonJS((exports) => {
     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();
@@ -14321,9 +13923,7 @@ var require_lib = __commonJS((exports) => {
       }
       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");
     }
@@ -14343,9 +13943,7 @@ var require_lib = __commonJS((exports) => {
     }
     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();
@@ -14359,13 +13957,12 @@ var require_lib = __commonJS((exports) => {
     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) {
@@ -14462,14 +14059,12 @@ var require_lib = __commonJS((exports) => {
         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"
           }
@@ -14492,13 +14087,11 @@ var require_lib = __commonJS((exports) => {
         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"
             });
           }
@@ -14530,9 +14123,7 @@ var require_lib = __commonJS((exports) => {
       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;
@@ -14605,9 +14196,7 @@ var require_lib = __commonJS((exports) => {
         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;
           }
@@ -14623,18 +14212,14 @@ var require_lib = __commonJS((exports) => {
           }
           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");
@@ -14692,9 +14277,7 @@ var require_lib = __commonJS((exports) => {
           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;
@@ -14715,14 +14298,10 @@ var require_lib = __commonJS((exports) => {
         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;
@@ -14748,9 +14327,7 @@ var require_lib = __commonJS((exports) => {
           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);
         }
@@ -14763,9 +14340,7 @@ var require_lib = __commonJS((exports) => {
           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);
         }
@@ -14792,15 +14367,11 @@ var require_lib = __commonJS((exports) => {
         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;
@@ -14821,16 +14392,12 @@ var require_lib = __commonJS((exports) => {
       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));
     }
@@ -14843,9 +14410,7 @@ var require_lib = __commonJS((exports) => {
       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);
@@ -14902,9 +14467,7 @@ var require_lib = __commonJS((exports) => {
         if (optionalId || !isStatement) {
           node.id = null;
         } else {
-          throw this.raise(Errors.MissingClassName, {
-            at: this.state.startLoc
-          });
+          throw this.raise(Errors.MissingClassName, this.state.startLoc);
         }
       }
     }
@@ -14923,9 +14486,7 @@ var require_lib = __commonJS((exports) => {
         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");
@@ -14941,9 +14502,7 @@ var require_lib = __commonJS((exports) => {
       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 {
@@ -14956,9 +14515,7 @@ var require_lib = __commonJS((exports) => {
         if (((_node2$declaration = node2.declaration) == null ? undefined : _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");
       }
@@ -14969,9 +14526,7 @@ var require_lib = __commonJS((exports) => {
         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");
@@ -15052,16 +14607,12 @@ var require_lib = __commonJS((exports) => {
       }
       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();
@@ -15124,9 +14675,7 @@ var require_lib = __commonJS((exports) => {
         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;
         }
@@ -15142,9 +14691,7 @@ var require_lib = __commonJS((exports) => {
             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) {
@@ -15159,8 +14706,7 @@ var require_lib = __commonJS((exports) => {
                 local
               } = specifier;
               if (local.type !== "Identifier") {
-                this.raise(Errors.ExportBindingIsString, {
-                  at: specifier,
+                this.raise(Errors.ExportBindingIsString, specifier, {
                   localName: local.value,
                   exportName
                 });
@@ -15208,12 +14754,9 @@ var require_lib = __commonJS((exports) => {
     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
           });
         }
@@ -15255,8 +14798,7 @@ var require_lib = __commonJS((exports) => {
         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)
           });
         }
@@ -15282,27 +14824,19 @@ var require_lib = __commonJS((exports) => {
       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 ? undefined : _node$assertions.length) > 0) {
-          this.raise(Errors.ImportReflectionHasAssertion, {
-            at: node.specifiers[0].loc.start
-          });
+          this.raise(Errors.ImportReflectionHasAssertion, specifiers[0].loc.start);
         }
       }
     }
@@ -15324,9 +14858,7 @@ var require_lib = __commonJS((exports) => {
             }
           });
           if (nonDefaultNamedSpecifier !== undefined) {
-            this.raise(Errors.ImportJSONBindingNotDefault, {
-              at: nonDefaultNamedSpecifier.loc.start
-            });
+            this.raise(Errors.ImportJSONBindingNotDefault, nonDefaultNamedSpecifier.loc.start);
           }
         }
       }
@@ -15436,8 +14968,7 @@ var require_lib = __commonJS((exports) => {
         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
           });
         }
@@ -15449,9 +14980,7 @@ var require_lib = __commonJS((exports) => {
         }
         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"));
@@ -15466,22 +14995,17 @@ var require_lib = __commonJS((exports) => {
         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"));
@@ -15508,9 +15032,7 @@ var require_lib = __commonJS((exports) => {
       } 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 {
@@ -15562,9 +15084,7 @@ var require_lib = __commonJS((exports) => {
           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))
@@ -15586,8 +15106,7 @@ var require_lib = __commonJS((exports) => {
           imported
         } = specifier;
         if (importedIsString) {
-          throw this.raise(Errors.ImportBindingIsString, {
-            at: specifier,
+          throw this.raise(Errors.ImportBindingIsString, specifier, {
             importName: imported.value
           });
         }
@@ -15623,6 +15142,7 @@ var require_lib = __commonJS((exports) => {
       file.errors = null;
       this.parseTopLevel(file, program);
       file.errors = this.state.errors;
+      file.comments.length = this.state.commentsLen;
       return file;
     }
   }
@@ -216787,6 +216307,7 @@ async function detectOverflow(state, options) {
     y: 1
   };
   const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements,
     rect,
     offsetParent,
     strategy
@@ -216918,7 +216439,6 @@ var computePosition = async (reference, floating, config2) => {
         } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
       }
       i = -1;
-      continue;
     }
   }
   return {
@@ -216976,7 +216496,7 @@ var arrow = (options) => ({
     const max2 = clientSize - arrowDimensions[length] - maxPadding;
     const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
     const offset = clamp(min$1, center, max2);
-    const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center != offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
+    const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
     const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max2 : 0;
     return {
       [axis]: coords[axis] + alignmentOffset,
@@ -219377,7 +218897,7 @@ var TwoslashFloatingVue = {
   }
 };
 
-// /home/runner/work/stacks/stacks/node_modules/shikiji-twoslash/node_modules/shikiji-core/dist/textmate.mjs
+// /home/runner/work/stacks/stacks/node_modules/shikiji-core/dist/textmate.mjs
 var toOptionalTokenType = function(standardType) {
   return standardType;
 };
@@ -222094,7 +221614,7 @@ var Registry$1 = class Registry {
 };
 var INITIAL = StateStackImpl.NULL;
 
-// /home/runner/work/stacks/stacks/node_modules/shikiji-twoslash/node_modules/shikiji-core/dist/index.mjs
+// /home/runner/work/stacks/stacks/node_modules/shikiji-core/dist/index.mjs
 var addClassToHast = function(node, className) {
   if (!className)
     return;
@@ -226510,22 +226030,19 @@ function markdownLineEndingOrSpace(code) {
 function markdownSpace(code) {
   return code === -2 || code === -1 || code === 32;
 }
-function unicodePunctuation(code) {
-  return asciiPunctuation(code) || unicodePunctuationInternal(code);
-}
 var regexCheck = function(regex) {
   return check;
   function check(code) {
     return code !== null && code > -1 && regex.test(String.fromCharCode(code));
   }
 };
-var unicodePunctuationInternal = regexCheck(/\p{P}/u);
 var asciiAlpha = regexCheck(/[A-Za-z]/);
 var asciiAlphanumeric = regexCheck(/[\dA-Za-z]/);
 var asciiAtext = regexCheck(/[#-'*+\--9=?A-Z^-~]/);
 var asciiDigit = regexCheck(/\d/);
 var asciiHexDigit = regexCheck(/[\dA-Fa-f]/);
 var asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);
+var unicodePunctuation = regexCheck(/\p{P}|\p{S}/u);
 var unicodeWhitespace = regexCheck(/\s/);
 
 // /home/runner/work/stacks/stacks/node_modules/mdast-util-find-and-replace/node_modules/escape-string-regexp/index.js