npm - @next-core/brick-utils - Versions diffs - 2.33.0 → 2.33.1 - Mend

@next-core/brick-utils 2.33.0 → 2.33.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/dist/index.esm.js CHANGED Viewed

@@ -3057,62 +3057,15 @@ var lib = {};
 Object.defineProperty(lib, '__esModule', {
   value: true
 });
-var lineBreak = /\r\n?|[\n\u2028\u2029]/;
-var lineBreakG = new RegExp(lineBreak.source, "g");
-function isNewLine(code) {
-  switch (code) {
-    case 10:
-    case 13:
-    case 8232:
-    case 8233:
-      return true;
-    default:
-      return false;
-  }
-}
-var skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
-var skipWhiteSpaceInLine = /(?:[^\S\n\r\u2028\u2029]|\/\/.*|\/\*.*?\*\/)*/y;
-var skipWhiteSpaceToLineBreak = new RegExp("(?=(" + skipWhiteSpaceInLine.source + "))\\1" + /(?=[\n\r\u2028\u2029]|\/\*(?!.*?\*\/)|$)/.source, "y");
-function isWhitespace(code) {
-  switch (code) {
-    case 0x0009:
-    case 0x000b:
-    case 0x000c:
-    case 32:
-    case 160:
-    case 5760:
-    case 0x2000:
-    case 0x2001:
-    case 0x2002:
-    case 0x2003:
-    case 0x2004:
-    case 0x2005:
-    case 0x2006:
-    case 0x2007:
-    case 0x2008:
-    case 0x2009:
-    case 0x200a:
-    case 0x202f:
-    case 0x205f:
-    case 0x3000:
-    case 0xfeff:
-      return true;
-    default:
-      return false;
-  }
-}
 class Position {
-  constructor(line, col) {
+  constructor(line, col, index) {
     this.line = void 0;
     this.column = void 0;
+    this.index = void 0;
     this.line = line;
     this.column = col;
+    indexes.set(this, index);
   }
 }
@@ -3129,26 +3082,14 @@ class SourceLocation {
 }
-function getLineInfo(input, offset) {
-  var line = 1;
-  var lineStart = 0;
-  var match;
-  lineBreakG.lastIndex = 0;
-  while ((match = lineBreakG.exec(input)) && match.index < offset) {
-    line++;
-    lineStart = lineBreakG.lastIndex;
-  }
-  return new Position(line, offset - lineStart);
-}
+var indexes = new WeakMap();
 function createPositionWithColumnOffset(position, columnOffset) {
   var {
     line,
     column
   } = position;
-  return new Position(line, column + columnOffset);
+  return new Position(line, column + columnOffset, indexes.get(position) + columnOffset);
 }
 class BaseParser {
@@ -3570,13 +3511,7 @@ function makeErrorTemplates(messages, code, syntaxPlugin) {
 }
 class ParserError extends CommentsParser {
-  getLocationForPosition(pos) {
-    var loc;
-    if (pos === this.state.start) loc = this.state.startLoc;else if (pos === this.state.lastTokStart) loc = this.state.lastTokStartLoc;else if (pos === this.state.end) loc = this.state.endLoc;else if (pos === this.state.lastTokEnd) loc = this.state.lastTokEndLoc;else loc = getLineInfo(this.input, pos);
-    return loc;
-  }
-  raise(pos, _ref) {
+  raise(_ref, origin) {
     var {
       code,
       reasonCode,
@@ -3587,13 +3522,13 @@ class ParserError extends CommentsParser {
       params[_key - 2] = arguments[_key];
     }
-    return this.raiseWithData(pos, {
+    return this.raiseWithData(origin.node ? origin.node.loc.start : origin.at, {
       code,
       reasonCode
     }, template, ...params);
   }
-  raiseOverwrite(pos, _ref2) {
+  raiseOverwrite(loc, _ref2) {
     var {
       code,
       template
@@ -3603,7 +3538,7 @@ class ParserError extends CommentsParser {
       params[_key2 - 2] = arguments[_key2];
     }
-    var loc = this.getLocationForPosition(pos);
+    var pos = indexes.get(loc);
     var message = template.replace(/%(\d+)/g, (_, i) => params[i]) + " (".concat(loc.line, ":").concat(loc.column, ")");
     if (this.options.errorRecovery) {
@@ -3629,12 +3564,12 @@ class ParserError extends CommentsParser {
     }, message);
   }
-  raiseWithData(pos, data, errorTemplate) {
+  raiseWithData(loc, data, errorTemplate) {
     for (var _len3 = arguments.length, params = new Array(_len3 > 3 ? _len3 - 3 : 0), _key3 = 3; _key3 < _len3; _key3++) {
       params[_key3 - 3] = arguments[_key3];
     }
-    var loc = this.getLocationForPosition(pos);
+    var pos = indexes.get(loc);
     var message = errorTemplate.replace(/%(\d+)/g, (_, i) => params[i]) + " (".concat(loc.line, ":").concat(loc.column, ")");
     return this._raise(Object.assign({
       loc,
@@ -3723,9 +3658,9 @@ var estree = superClass => class extends superClass {
     var expression = this.startNodeAt(directiveLiteral.start, directiveLiteral.loc.start);
     expression.value = directiveLiteral.extra.expressionValue;
     expression.raw = directiveLiteral.extra.raw;
-    stmt.expression = this.finishNodeAt(expression, "Literal", directiveLiteral.end, directiveLiteral.loc.end);
+    stmt.expression = this.finishNodeAt(expression, "Literal", directiveLiteral.loc.end);
     stmt.directive = directiveLiteral.extra.raw.slice(1, -1);
-    return this.finishNodeAt(stmt, "ExpressionStatement", directive.end, directive.loc.end);
+    return this.finishNodeAt(stmt, "ExpressionStatement", directive.loc.end);
   }
   initFunction(node, isAsync) {
@@ -3907,9 +3842,13 @@ var estree = superClass => class extends superClass {
   toAssignableObjectExpressionProp(prop) {
     if (prop.kind === "get" || prop.kind === "set") {
-      this.raise(prop.key.start, ErrorMessages.PatternHasAccessor);
+      this.raise(ErrorMessages.PatternHasAccessor, {
+        node: prop.key
+      });
     } else if (prop.method) {
-      this.raise(prop.key.start, ErrorMessages.PatternHasMethod);
+      this.raise(ErrorMessages.PatternHasMethod, {
+        node: prop.key
+      });
     } else {
       for (var _len5 = arguments.length, args = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {
         args[_key5 - 1] = arguments[_key5];
@@ -4580,10 +4519,6 @@ function getExportedToken(token) {
   return tokenTypes[token];
 }
-function isTokenType(obj) {
-  return typeof obj === "number";
-}
 {
   tokenTypes[8].updateContext = context => {
     context.pop();
@@ -4752,7 +4687,6 @@ class ScopeHandler {
   constructor(raise, inModule) {
     this.scopeStack = [];
     this.undefinedExports = new Map();
-    this.undefinedPrivateNames = new Map();
     this.raise = raise;
     this.inModule = inModule;
   }
@@ -4818,11 +4752,11 @@ class ScopeHandler {
     return !!(scope.flags & SCOPE_FUNCTION || !this.inModule && scope.flags & SCOPE_PROGRAM);
   }
-  declareName(name, bindingType, pos) {
+  declareName(name, bindingType, loc) {
     var scope = this.currentScope();
     if (bindingType & BIND_SCOPE_LEXICAL || bindingType & BIND_SCOPE_FUNCTION) {
-      this.checkRedeclarationInScope(scope, name, bindingType, pos);
+      this.checkRedeclarationInScope(scope, name, bindingType, loc);
       if (bindingType & BIND_SCOPE_FUNCTION) {
         scope.functions.add(name);
@@ -4836,7 +4770,7 @@ class ScopeHandler {
     } else if (bindingType & BIND_SCOPE_VAR) {
       for (var i = this.scopeStack.length - 1; i >= 0; --i) {
         scope = this.scopeStack[i];
-        this.checkRedeclarationInScope(scope, name, bindingType, pos);
+        this.checkRedeclarationInScope(scope, name, bindingType, loc);
         scope.var.add(name);
         this.maybeExportDefined(scope, name);
         if (scope.flags & SCOPE_VAR) break;
@@ -4854,9 +4788,11 @@ class ScopeHandler {
     }
   }
-  checkRedeclarationInScope(scope, name, bindingType, pos) {
+  checkRedeclarationInScope(scope, name, bindingType, loc) {
     if (this.isRedeclaredInScope(scope, name, bindingType)) {
-      this.raise(pos, ErrorMessages.VarRedeclaration, name);
+      this.raise(ErrorMessages.VarRedeclaration, {
+        at: loc
+      }, name);
     }
   }
@@ -4881,7 +4817,7 @@ class ScopeHandler {
     var topLevelScope = this.scopeStack[0];
     if (!topLevelScope.lexical.has(name) && !topLevelScope.var.has(name) && !topLevelScope.functions.has(name)) {
-      this.undefinedExports.set(name, id.start);
+      this.undefinedExports.set(name, id.loc.start);
     }
   }
@@ -4928,11 +4864,11 @@ class FlowScopeHandler extends ScopeHandler {
     return new FlowScope(flags);
   }
-  declareName(name, bindingType, pos) {
+  declareName(name, bindingType, loc) {
     var scope = this.currentScope();
     if (bindingType & BIND_FLAGS_FLOW_DECLARE_FN) {
-      this.checkRedeclarationInScope(scope, name, bindingType, pos);
+      this.checkRedeclarationInScope(scope, name, bindingType, loc);
       this.maybeExportDefined(scope, name);
       scope.declareFunctions.add(name);
       return;
@@ -4959,6 +4895,56 @@ class FlowScopeHandler extends ScopeHandler {
 }
+var lineBreak = /\r\n?|[\n\u2028\u2029]/;
+var lineBreakG = new RegExp(lineBreak.source, "g");
+function isNewLine(code) {
+  switch (code) {
+    case 10:
+    case 13:
+    case 8232:
+    case 8233:
+      return true;
+    default:
+      return false;
+  }
+}
+var skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
+var skipWhiteSpaceInLine = /(?:[^\S\n\r\u2028\u2029]|\/\/.*|\/\*.*?\*\/)*/y;
+var skipWhiteSpaceToLineBreak = new RegExp("(?=(" + skipWhiteSpaceInLine.source + "))\\1" + /(?=[\n\r\u2028\u2029]|\/\*(?!.*?\*\/)|$)/.source, "y");
+function isWhitespace(code) {
+  switch (code) {
+    case 0x0009:
+    case 0x000b:
+    case 0x000c:
+    case 32:
+    case 160:
+    case 5760:
+    case 0x2000:
+    case 0x2001:
+    case 0x2002:
+    case 0x2003:
+    case 0x2004:
+    case 0x2005:
+    case 0x2006:
+    case 0x2007:
+    case 0x2008:
+    case 0x2009:
+    case 0x200a:
+    case 0x202f:
+    case 0x205f:
+    case 0x3000:
+    case 0xfeff:
+      return true;
+    default:
+      return false;
+  }
+}
 class State {
   constructor() {
     this.strict = void 0;
@@ -4994,7 +4980,6 @@ class State {
     this.lastTokEndLoc = null;
     this.lastTokStartLoc = null;
     this.lastTokStart = 0;
-    this.lastTokEnd = 0;
     this.context = [types.brace];
     this.canStartJSXElement = true;
     this.containsEsc = false;
@@ -5012,11 +4997,11 @@ class State {
     this.strict = strictMode === false ? false : strictMode === true ? true : sourceType === "module";
     this.curLine = startLine;
     this.lineStart = -startColumn;
-    this.startLoc = this.endLoc = new Position(startLine, startColumn);
+    this.startLoc = this.endLoc = new Position(startLine, startColumn, 0);
   }
   curPosition() {
-    return new Position(this.curLine, this.pos - this.lineStart);
+    return new Position(this.curLine, this.pos - this.lineStart, this.pos);
   }
   clone(skipArrays) {
@@ -5090,7 +5075,6 @@ class Tokenizer extends ParserError {
       this.pushToken(new Token(this.state));
     }
-    this.state.lastTokEnd = this.state.end;
     this.state.lastTokStart = this.state.start;
     this.state.lastTokEndLoc = this.state.endLoc;
     this.state.lastTokStartLoc = this.state.startLoc;
@@ -5117,9 +5101,13 @@ class Tokenizer extends ParserError {
       type: state.type,
       start: state.start,
       end: state.end,
-      lastTokEnd: state.end,
       context: [this.curContext()],
-      inType: state.inType
+      inType: state.inType,
+      startLoc: state.startLoc,
+      lastTokEndLoc: state.lastTokEndLoc,
+      curLine: state.curLine,
+      lineStart: state.lineStart,
+      curPosition: state.curPosition
     };
   }
@@ -5165,7 +5153,15 @@ class Tokenizer extends ParserError {
     this.state.strict = strict;
     if (strict) {
-      this.state.strictErrors.forEach((message, pos) => this.raise(pos, message));
+      this.state.strictErrors.forEach(_ref5 => {
+        var {
+          message,
+          loc
+        } = _ref5;
+        return this.raise(message, {
+          at: loc
+        });
+      });
       this.state.strictErrors.clear();
     }
   }
@@ -5192,7 +5188,13 @@ class Tokenizer extends ParserError {
     if (!this.isLookahead) startLoc = this.state.curPosition();
     var start = this.state.pos;
     var end = this.input.indexOf("*/", start + 2);
-    if (end === -1) throw this.raise(start, ErrorMessages.UnterminatedComment);
+    if (end === -1) {
+      throw this.raise(ErrorMessages.UnterminatedComment, {
+        at: this.state.curPosition()
+      });
+    }
     this.state.pos = end + 2;
     lineBreakG.lastIndex = start + 2;
@@ -5350,12 +5352,12 @@ class Tokenizer extends ParserError {
   finishToken(type, val) {
     this.state.end = this.state.pos;
+    this.state.endLoc = this.state.curPosition();
     var prevType = this.state.type;
     this.state.type = type;
     this.state.value = val;
     if (!this.isLookahead) {
-      this.state.endLoc = this.state.curPosition();
       this.updateContext(prevType);
     }
   }
@@ -5374,14 +5376,18 @@ class Tokenizer extends ParserError {
     var next = this.codePointAtPos(nextPos);
     if (next >= 48 && next <= 57) {
-      throw this.raise(this.state.pos, ErrorMessages.UnexpectedDigitAfterHash);
+      throw this.raise(ErrorMessages.UnexpectedDigitAfterHash, {
+        at: this.state.curPosition()
+      });
     }
     if (next === 123 || next === 91 && this.hasPlugin("recordAndTuple")) {
       this.expectPlugin("recordAndTuple");
       if (this.getPluginOption("recordAndTuple", "syntaxType") !== "hash") {
-        throw this.raise(this.state.pos, next === 123 ? ErrorMessages.RecordExpressionHashIncorrectStartSyntaxType : ErrorMessages.TupleExpressionHashIncorrectStartSyntaxType);
+        throw this.raise(next === 123 ? ErrorMessages.RecordExpressionHashIncorrectStartSyntaxType : ErrorMessages.TupleExpressionHashIncorrectStartSyntaxType, {
+          at: this.state.curPosition()
+        });
       }
       this.state.pos += 2;
@@ -5485,7 +5491,9 @@ class Tokenizer extends ParserError {
       if (this.hasPlugin("recordAndTuple") && next === 125) {
         if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") {
-          throw this.raise(this.state.pos, ErrorMessages.RecordExpressionBarIncorrectEndSyntaxType);
+          throw this.raise(ErrorMessages.RecordExpressionBarIncorrectEndSyntaxType, {
+            at: this.state.curPosition()
+          });
         }
         this.state.pos += 2;
@@ -5495,7 +5503,9 @@ class Tokenizer extends ParserError {
       if (this.hasPlugin("recordAndTuple") && next === 93) {
         if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") {
-          throw this.raise(this.state.pos, ErrorMessages.TupleExpressionBarIncorrectEndSyntaxType);
+          throw this.raise(ErrorMessages.TupleExpressionBarIncorrectEndSyntaxType, {
+            at: this.state.curPosition()
+          });
         }
         this.state.pos += 2;
@@ -5652,7 +5662,9 @@ class Tokenizer extends ParserError {
       case 91:
         if (this.hasPlugin("recordAndTuple") && this.input.charCodeAt(this.state.pos + 1) === 124) {
           if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") {
-            throw this.raise(this.state.pos, ErrorMessages.TupleExpressionBarIncorrectStartSyntaxType);
+            throw this.raise(ErrorMessages.TupleExpressionBarIncorrectStartSyntaxType, {
+              at: this.state.curPosition()
+            });
           }
           this.state.pos += 2;
@@ -5672,7 +5684,9 @@ class Tokenizer extends ParserError {
       case 123:
         if (this.hasPlugin("recordAndTuple") && this.input.charCodeAt(this.state.pos + 1) === 124) {
           if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") {
-            throw this.raise(this.state.pos, ErrorMessages.RecordExpressionBarIncorrectStartSyntaxType);
+            throw this.raise(ErrorMessages.RecordExpressionBarIncorrectStartSyntaxType, {
+              at: this.state.curPosition()
+            });
           }
           this.state.pos += 2;
@@ -5805,7 +5819,9 @@ class Tokenizer extends ParserError {
     }
-    throw this.raise(this.state.pos, ErrorMessages.InvalidOrUnexpectedToken, String.fromCodePoint(code));
+    throw this.raise(ErrorMessages.InvalidOrUnexpectedToken, {
+      at: this.state.curPosition()
+    }, String.fromCodePoint(code));
   }
   finishOp(type, size) {
@@ -5815,6 +5831,7 @@ class Tokenizer extends ParserError {
   }
   readRegexp() {
+    var startLoc = this.state.startLoc;
     var start = this.state.start + 1;
     var escaped, inClass;
     var {
@@ -5823,13 +5840,17 @@ class Tokenizer extends ParserError {
     for (;; ++pos) {
       if (pos >= this.length) {
-        throw this.raise(start, ErrorMessages.UnterminatedRegExp);
+        throw this.raise(ErrorMessages.UnterminatedRegExp, {
+          at: createPositionWithColumnOffset(startLoc, 1)
+        });
       }
       var ch = this.input.charCodeAt(pos);
       if (isNewLine(ch)) {
-        throw this.raise(start, ErrorMessages.UnterminatedRegExp);
+        throw this.raise(ErrorMessages.UnterminatedRegExp, {
+          at: createPositionWithColumnOffset(startLoc, 1)
+        });
       }
       if (escaped) {
@@ -5857,10 +5878,14 @@ class Tokenizer extends ParserError {
       if (VALID_REGEX_FLAGS.has(cp)) {
         if (mods.includes(char)) {
-          this.raise(pos + 1, ErrorMessages.DuplicateRegExpFlags);
+          this.raise(ErrorMessages.DuplicateRegExpFlags, {
+            at: createPositionWithColumnOffset(startLoc, pos + 2 - start)
+          });
         }
       } else if (isIdentifierChar(cp) || cp === 92) {
-        this.raise(pos + 1, ErrorMessages.MalformedRegExpFlags);
+        this.raise(ErrorMessages.MalformedRegExpFlags, {
+          at: createPositionWithColumnOffset(startLoc, pos + 2 - start)
+        });
       } else {
         break;
       }
@@ -5893,13 +5918,19 @@ class Tokenizer extends ParserError {
         var next = this.input.charCodeAt(this.state.pos + 1);
         if (allowedSiblings.indexOf(next) === -1) {
-          this.raise(this.state.pos, ErrorMessages.UnexpectedNumericSeparator);
+          this.raise(ErrorMessages.UnexpectedNumericSeparator, {
+            at: this.state.curPosition()
+          });
         } else if (forbiddenSiblings.indexOf(prev) > -1 || forbiddenSiblings.indexOf(next) > -1 || Number.isNaN(next)) {
-          this.raise(this.state.pos, ErrorMessages.UnexpectedNumericSeparator);
+          this.raise(ErrorMessages.UnexpectedNumericSeparator, {
+            at: this.state.curPosition()
+          });
         }
         if (!allowNumSeparator) {
-          this.raise(this.state.pos, ErrorMessages.NumericSeparatorInEscapeSequence);
+          this.raise(ErrorMessages.NumericSeparatorInEscapeSequence, {
+            at: this.state.curPosition()
+          });
         }
         ++this.state.pos;
@@ -5919,7 +5950,9 @@ class Tokenizer extends ParserError {
       if (val >= radix) {
         if (this.options.errorRecovery && val <= 9) {
           val = 0;
-          this.raise(this.state.start + i + 2, ErrorMessages.InvalidDigit, radix);
+          this.raise(ErrorMessages.InvalidDigit, {
+            at: this.state.curPosition()
+          }, radix);
         } else if (forceLen) {
           val = 0;
           invalid = true;
@@ -5940,13 +5973,15 @@ class Tokenizer extends ParserError {
   }
   readRadixNumber(radix) {
-    var start = this.state.pos;
+    var startLoc = this.state.curPosition();
     var isBigInt = false;
     this.state.pos += 2;
     var val = this.readInt(radix);
     if (val == null) {
-      this.raise(this.state.start + 2, ErrorMessages.InvalidDigit, radix);
+      this.raise(ErrorMessages.InvalidDigit, {
+        at: createPositionWithColumnOffset(startLoc, 2)
+      }, radix);
     }
     var next = this.input.charCodeAt(this.state.pos);
@@ -5955,15 +5990,19 @@ class Tokenizer extends ParserError {
       ++this.state.pos;
       isBigInt = true;
     } else if (next === 109) {
-      throw this.raise(start, ErrorMessages.InvalidDecimal);
+      throw this.raise(ErrorMessages.InvalidDecimal, {
+        at: startLoc
+      });
     }
     if (isIdentifierStart(this.codePointAtPos(this.state.pos))) {
-      throw this.raise(this.state.pos, ErrorMessages.NumberIdentifier);
+      throw this.raise(ErrorMessages.NumberIdentifier, {
+        at: this.state.curPosition()
+      });
     }
     if (isBigInt) {
-      var str = this.input.slice(start, this.state.pos).replace(/[_n]/g, "");
+      var str = this.input.slice(indexes.get(startLoc), this.state.pos).replace(/[_n]/g, "");
       this.finishToken(127, str);
       return;
     }
@@ -5973,6 +6012,7 @@ class Tokenizer extends ParserError {
   readNumber(startsWithDot) {
     var start = this.state.pos;
+    var startLoc = this.state.curPosition();
     var isFloat = false;
     var isBigInt = false;
     var isDecimal = false;
@@ -5980,20 +6020,24 @@ class Tokenizer extends ParserError {
     var isOctal = false;
     if (!startsWithDot && this.readInt(10) === null) {
-      this.raise(start, ErrorMessages.InvalidNumber);
+      this.raise(ErrorMessages.InvalidNumber, {
+        at: this.state.curPosition()
+      });
     }
     var hasLeadingZero = this.state.pos - start >= 2 && this.input.charCodeAt(start) === 48;
     if (hasLeadingZero) {
       var integer = this.input.slice(start, this.state.pos);
-      this.recordStrictModeErrors(start, ErrorMessages.StrictOctalLiteral);
+      this.recordStrictModeErrors(ErrorMessages.StrictOctalLiteral, startLoc);
       if (!this.state.strict) {
         var underscorePos = integer.indexOf("_");
         if (underscorePos > 0) {
-          this.raise(underscorePos + start, ErrorMessages.ZeroDigitNumericSeparator);
+          this.raise(ErrorMessages.ZeroDigitNumericSeparator, {
+            at: createPositionWithColumnOffset(startLoc, underscorePos)
+          });
         }
       }
@@ -6017,7 +6061,9 @@ class Tokenizer extends ParserError {
       }
       if (this.readInt(10) === null) {
-        this.raise(start, ErrorMessages.InvalidOrMissingExponent);
+        this.raise(ErrorMessages.InvalidOrMissingExponent, {
+          at: startLoc
+        });
       }
       isFloat = true;
@@ -6027,7 +6073,9 @@ class Tokenizer extends ParserError {
     if (next === 110) {
       if (isFloat || hasLeadingZero) {
-        this.raise(start, ErrorMessages.InvalidBigIntLiteral);
+        this.raise(ErrorMessages.InvalidBigIntLiteral, {
+          at: startLoc
+        });
       }
       ++this.state.pos;
@@ -6035,10 +6083,12 @@ class Tokenizer extends ParserError {
     }
     if (next === 109) {
-      this.expectPlugin("decimal", this.state.pos);
+      this.expectPlugin("decimal", this.state.curPosition());
       if (hasExponent || hasLeadingZero) {
-        this.raise(start, ErrorMessages.InvalidDecimal);
+        this.raise(ErrorMessages.InvalidDecimal, {
+          at: startLoc
+        });
       }
       ++this.state.pos;
@@ -6046,7 +6096,9 @@ class Tokenizer extends ParserError {
     }
     if (isIdentifierStart(this.codePointAtPos(this.state.pos))) {
-      throw this.raise(this.state.pos, ErrorMessages.NumberIdentifier);
+      throw this.raise(ErrorMessages.NumberIdentifier, {
+        at: this.state.curPosition()
+      });
     }
     var str = this.input.slice(start, this.state.pos).replace(/[_mn]/g, "");
@@ -6070,13 +6122,15 @@ class Tokenizer extends ParserError {
     var code;
     if (ch === 123) {
-      var codePos = ++this.state.pos;
+      ++this.state.pos;
       code = this.readHexChar(this.input.indexOf("}", this.state.pos) - this.state.pos, true, throwOnInvalid);
       ++this.state.pos;
       if (code !== null && code > 0x10ffff) {
         if (throwOnInvalid) {
-          this.raise(codePos, ErrorMessages.InvalidCodePoint);
+          this.raise(ErrorMessages.InvalidCodePoint, {
+            at: this.state.curPosition()
+          });
         } else {
           return null;
         }
@@ -6094,7 +6148,9 @@ class Tokenizer extends ParserError {
     for (;;) {
       if (this.state.pos >= this.length) {
-        throw this.raise(this.state.start, ErrorMessages.UnterminatedString);
+        throw this.raise(ErrorMessages.UnterminatedString, {
+          at: this.state.startLoc
+        });
       }
       var ch = this.input.charCodeAt(this.state.pos);
@@ -6109,7 +6165,9 @@ class Tokenizer extends ParserError {
         ++this.state.curLine;
         this.state.lineStart = this.state.pos;
       } else if (isNewLine(ch)) {
-        throw this.raise(this.state.start, ErrorMessages.UnterminatedString);
+        throw this.raise(ErrorMessages.UnterminatedString, {
+          at: this.state.startLoc
+        });
       } else {
         ++this.state.pos;
       }
@@ -6121,7 +6179,7 @@ class Tokenizer extends ParserError {
   readTemplateContinuation() {
     if (!this.match(8)) {
-      this.unexpected(this.state.start, 8);
+      this.unexpected(null, 8);
     }
     this.state.pos--;
@@ -6136,7 +6194,9 @@ class Tokenizer extends ParserError {
     for (;;) {
       if (this.state.pos >= this.length) {
-        throw this.raise(this.state.start + 1, ErrorMessages.UnterminatedTemplate);
+        throw this.raise(ErrorMessages.UnterminatedTemplate, {
+          at: createPositionWithColumnOffset(this.state.startLoc, 1)
+        });
       }
       var ch = this.input.charCodeAt(this.state.pos);
@@ -6194,11 +6254,18 @@ class Tokenizer extends ParserError {
     }
   }
-  recordStrictModeErrors(pos, message) {
-    if (this.state.strict && !this.state.strictErrors.has(pos)) {
-      this.raise(pos, message);
+  recordStrictModeErrors(message, loc) {
+    var index = indexes.get(loc);
+    if (this.state.strict && !this.state.strictErrors.has(index)) {
+      this.raise(message, {
+        at: loc
+      });
     } else {
-      this.state.strictErrors.set(pos, message);
+      this.state.strictErrors.set(index, {
+        loc,
+        message
+      });
     }
   }
@@ -6257,12 +6324,12 @@ class Tokenizer extends ParserError {
         if (inTemplate) {
           return null;
         } else {
-          this.recordStrictModeErrors(this.state.pos - 1, ErrorMessages.StrictNumericEscape);
+          this.recordStrictModeErrors(ErrorMessages.StrictNumericEscape, createPositionWithColumnOffset(this.state.curPosition(), -1));
         }
       default:
         if (ch >= 48 && ch <= 55) {
-          var codePos = this.state.pos - 1;
+          var codePos = createPositionWithColumnOffset(this.state.curPosition(), -1);
           var match = this.input.substr(this.state.pos - 1, 3).match(/^[0-7]+/);
           var octalStr = match[0];
           var octal = parseInt(octalStr, 8);
@@ -6279,7 +6346,7 @@ class Tokenizer extends ParserError {
             if (inTemplate) {
               return null;
             } else {
-              this.recordStrictModeErrors(codePos, ErrorMessages.StrictNumericEscape);
+              this.recordStrictModeErrors(ErrorMessages.StrictNumericEscape, codePos);
             }
           }
@@ -6291,14 +6358,16 @@ class Tokenizer extends ParserError {
   }
   readHexChar(len, forceLen, throwOnInvalid) {
-    var codePos = this.state.pos;
+    var codeLoc = this.state.curPosition();
     var n = this.readInt(16, len, forceLen, false);
     if (n === null) {
       if (throwOnInvalid) {
-        this.raise(codePos, ErrorMessages.InvalidEscapeSequence);
+        this.raise(ErrorMessages.InvalidEscapeSequence, {
+          at: codeLoc
+        });
       } else {
-        this.state.pos = codePos - 1;
+        this.state.pos = indexes.get(codeLoc) - 1;
       }
     }
@@ -6323,11 +6392,13 @@ class Tokenizer extends ParserError {
       } else if (ch === 92) {
         this.state.containsEsc = true;
         word += this.input.slice(chunkStart, this.state.pos);
-        var escStart = this.state.pos;
+        var escStart = this.state.curPosition();
         var identifierCheck = this.state.pos === start ? isIdentifierStart : isIdentifierChar;
         if (this.input.charCodeAt(++this.state.pos) !== 117) {
-          this.raise(this.state.pos, ErrorMessages.MissingUnicodeEscape);
+          this.raise(ErrorMessages.MissingUnicodeEscape, {
+            at: this.state.curPosition()
+          });
           chunkStart = this.state.pos - 1;
           continue;
         }
@@ -6337,7 +6408,9 @@ class Tokenizer extends ParserError {
         if (esc !== null) {
           if (!identifierCheck(esc)) {
-            this.raise(escStart, ErrorMessages.EscapedCharNotAnIdentifier);
+            this.raise(ErrorMessages.EscapedCharNotAnIdentifier, {
+              at: escStart
+            });
           }
           word += String.fromCodePoint(esc);
@@ -6369,7 +6442,9 @@ class Tokenizer extends ParserError {
     } = this.state;
     if (tokenIsKeyword(type) && this.state.containsEsc) {
-      this.raise(this.state.start, ErrorMessages.InvalidEscapedReservedWord, tokenLabelName(type));
+      this.raise(ErrorMessages.InvalidEscapedReservedWord, {
+        at: this.state.startLoc
+      }, tokenLabelName(type));
     }
   }
@@ -6405,18 +6480,20 @@ class ClassScopeHandler {
     var oldClassScope = this.stack.pop();
     var current = this.current();
-    for (var [name, pos] of Array.from(oldClassScope.undefinedPrivateNames)) {
+    for (var [name, loc] of Array.from(oldClassScope.undefinedPrivateNames)) {
       if (current) {
         if (!current.undefinedPrivateNames.has(name)) {
-          current.undefinedPrivateNames.set(name, pos);
+          current.undefinedPrivateNames.set(name, loc);
         }
       } else {
-        this.raise(pos, ErrorMessages.InvalidPrivateFieldResolution, name);
+        this.raise(ErrorMessages.InvalidPrivateFieldResolution, {
+          at: loc
+        }, name);
       }
     }
   }
-  declarePrivateName(name, elementType, pos) {
+  declarePrivateName(name, elementType, loc) {
     var {
       privateNames,
       loneAccessors,
@@ -6440,14 +6517,16 @@ class ClassScopeHandler {
     }
     if (redefined) {
-      this.raise(pos, ErrorMessages.PrivateNameRedeclaration, name);
+      this.raise(ErrorMessages.PrivateNameRedeclaration, {
+        at: loc
+      }, name);
     }
     privateNames.add(name);
     undefinedPrivateNames.delete(name);
   }
-  usePrivateName(name, pos) {
+  usePrivateName(name, loc) {
     var classScope;
     for (classScope of this.stack) {
@@ -6455,9 +6534,11 @@ class ClassScopeHandler {
     }
     if (classScope) {
-      classScope.undefinedPrivateNames.set(name, pos);
+      classScope.undefinedPrivateNames.set(name, loc);
     } else {
-      this.raise(pos, ErrorMessages.InvalidPrivateFieldResolution, name);
+      this.raise(ErrorMessages.InvalidPrivateFieldResolution, {
+        at: loc
+      }, name);
     }
   }
@@ -6491,12 +6572,15 @@ class ArrowHeadParsingScope extends ExpressionScope {
     this.errors = new Map();
   }
-  recordDeclarationError(pos, template) {
-    this.errors.set(pos, template);
+  recordDeclarationError(message, loc) {
+    this.errors.set(indexes.get(loc), {
+      message,
+      loc
+    });
   }
-  clearDeclarationError(pos) {
-    this.errors.delete(pos);
+  clearDeclarationError(loc) {
+    this.errors.delete(indexes.get(loc));
   }
   iterateErrors(iterator) {
@@ -6519,7 +6603,7 @@ class ExpressionScopeHandler {
     this.stack.pop();
   }
-  recordParameterInitializerError(pos, template) {
+  recordParameterInitializerError(loc, template) {
     var {
       stack
     } = this;
@@ -6528,7 +6612,7 @@ class ExpressionScopeHandler {
     while (!scope.isCertainlyParameterDeclaration()) {
       if (scope.canBeArrowParameterDeclaration()) {
-        scope.recordDeclarationError(pos, template);
+        scope.recordDeclarationError(template, loc);
       } else {
         return;
       }
@@ -6536,25 +6620,29 @@ class ExpressionScopeHandler {
       scope = stack[--i];
     }
-    this.raise(pos, template);
+    this.raise(template, {
+      at: loc
+    });
   }
-  recordParenthesizedIdentifierError(pos, template) {
+  recordParenthesizedIdentifierError(template, loc) {
     var {
       stack
     } = this;
     var scope = stack[stack.length - 1];
     if (scope.isCertainlyParameterDeclaration()) {
-      this.raise(pos, template);
+      this.raise(template, {
+        at: loc
+      });
     } else if (scope.canBeArrowParameterDeclaration()) {
-      scope.recordDeclarationError(pos, template);
+      scope.recordDeclarationError(template, loc);
     } else {
       return;
     }
   }
-  recordAsyncArrowParametersError(pos, template) {
+  recordAsyncArrowParametersError(template, loc) {
     var {
       stack
     } = this;
@@ -6563,7 +6651,7 @@ class ExpressionScopeHandler {
     while (scope.canBeArrowParameterDeclaration()) {
       if (scope.type === kMaybeAsyncArrowParameterDeclaration) {
-        scope.recordDeclarationError(pos, template);
+        scope.recordDeclarationError(template, loc);
       }
       scope = stack[--i];
@@ -6576,13 +6664,19 @@ class ExpressionScopeHandler {
     } = this;
     var currentScope = stack[stack.length - 1];
     if (!currentScope.canBeArrowParameterDeclaration()) return;
-    currentScope.iterateErrors((template, pos) => {
-      this.raise(pos, template);
+    currentScope.iterateErrors(_ref6 => {
+      var {
+        message,
+        loc
+      } = _ref6;
+      this.raise(message, {
+        at: loc
+      });
       var i = stack.length - 2;
       var scope = stack[i];
       while (scope.canBeArrowParameterDeclaration()) {
-        scope.clearDeclarationError(pos);
+        scope.clearDeclarationError(loc);
         scope = stack[--i];
       }
     });
@@ -6652,10 +6746,19 @@ function functionFlags(isAsync, isGenerator) {
 }
 class UtilParser extends Tokenizer {
-  addExtra(node, key, val) {
+  addExtra(node, key, value) {
+    var enumerable = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
     if (!node) return;
     var extra = node.extra = node.extra || {};
-    extra[key] = val;
+    if (enumerable) {
+      extra[key] = value;
+    } else {
+      Object.defineProperty(extra, key, {
+        enumerable,
+        value
+      });
+    }
   }
   isContextual(token) {
@@ -6688,7 +6791,15 @@ class UtilParser extends Tokenizer {
   }
   expectContextual(token, template) {
-    if (!this.eatContextual(token)) this.unexpected(null, template);
+    if (!this.eatContextual(token)) {
+      if (template != null) {
+        throw this.raise(template, {
+          at: this.state.startLoc
+        });
+      }
+      throw this.unexpected(null, token);
+    }
   }
   canInsertSemicolon() {
@@ -6696,7 +6807,7 @@ class UtilParser extends Tokenizer {
   }
   hasPrecedingLineBreak() {
-    return lineBreak.test(this.input.slice(this.state.lastTokEnd, this.state.start));
+    return lineBreak.test(this.input.slice(indexes.get(this.state.lastTokEndLoc), this.state.start));
   }
   hasFollowingLineBreak() {
@@ -6711,41 +6822,37 @@ class UtilParser extends Tokenizer {
   semicolon() {
     var allowAsi = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
     if (allowAsi ? this.isLineTerminator() : this.eat(13)) return;
-    this.raise(this.state.lastTokEnd, ErrorMessages.MissingSemicolon);
+    this.raise(ErrorMessages.MissingSemicolon, {
+      at: this.state.lastTokEndLoc
+    });
   }
-  expect(type, pos) {
-    this.eat(type) || this.unexpected(pos, type);
+  expect(type, loc) {
+    this.eat(type) || this.unexpected(loc, type);
   }
   assertNoSpace() {
     var message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "Unexpected space.";
-    if (this.state.start > this.state.lastTokEnd) {
-      this.raise(this.state.lastTokEnd, {
+    if (this.state.start > indexes.get(this.state.lastTokEndLoc)) {
+      this.raise({
         code: ErrorCodes.SyntaxError,
         reasonCode: "UnexpectedSpace",
         template: message
+      }, {
+        at: this.state.lastTokEndLoc
       });
     }
   }
-  unexpected(pos) {
-    var messageOrType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+  unexpected(loc, type) {
+    throw this.raise({
       code: ErrorCodes.SyntaxError,
       reasonCode: "UnexpectedToken",
-      template: "Unexpected token"
-    };
-    if (isTokenType(messageOrType)) {
-      messageOrType = {
-        code: ErrorCodes.SyntaxError,
-        reasonCode: "UnexpectedToken",
-        template: "Unexpected token, expected \"".concat(tokenLabelName(messageOrType), "\"")
-      };
-    }
-    throw this.raise(pos != null ? pos : this.state.start, messageOrType);
+      template: type != null ? "Unexpected token, expected \"".concat(tokenLabelName(type), "\"") : "Unexpected token"
+    }, {
+      at: loc != null ? loc : this.state.startLoc
+    });
   }
   getPluginNamesFromConfigs(pluginConfigs) {
@@ -6758,9 +6865,9 @@ class UtilParser extends Tokenizer {
     });
   }
-  expectPlugin(pluginConfig, pos) {
+  expectPlugin(pluginConfig, loc) {
     if (!this.hasPlugin(pluginConfig)) {
-      throw this.raiseWithData(pos != null ? pos : this.state.start, {
+      throw this.raiseWithData(loc != null ? loc : this.state.startLoc, {
         missingPlugin: this.getPluginNamesFromConfigs([pluginConfig])
       }, "This experimental syntax requires enabling the parser plugin: ".concat(JSON.stringify(pluginConfig), "."));
     }
@@ -6768,9 +6875,9 @@ class UtilParser extends Tokenizer {
     return true;
   }
-  expectOnePlugin(pluginConfigs, pos) {
+  expectOnePlugin(pluginConfigs) {
     if (!pluginConfigs.some(c => this.hasPlugin(c))) {
-      throw this.raiseWithData(pos != null ? pos : this.state.start, {
+      throw this.raiseWithData(this.state.startLoc, {
         missingPlugin: this.getPluginNamesFromConfigs(pluginConfigs)
       }, "This experimental syntax requires enabling one of the following parser plugin(s): ".concat(pluginConfigs.map(c => JSON.stringify(c)).join(", "), "."));
     }
@@ -6840,26 +6947,30 @@ class UtilParser extends Tokenizer {
   checkExpressionErrors(refExpressionErrors, andThrow) {
     if (!refExpressionErrors) return false;
     var {
-      shorthandAssign,
-      doubleProto,
-      optionalParameters
+      shorthandAssignLoc,
+      doubleProtoLoc,
+      optionalParametersLoc
     } = refExpressionErrors;
-    var hasErrors = shorthandAssign + doubleProto + optionalParameters > -3;
+    var hasErrors = !!shorthandAssignLoc || !!doubleProtoLoc || !!optionalParametersLoc;
     if (!andThrow) {
       return hasErrors;
-    } else if (hasErrors) {
-      if (shorthandAssign >= 0) {
-        this.raise(shorthandAssign, ErrorMessages.InvalidCoverInitializedName);
-      }
+    }
-      if (doubleProto >= 0) {
-        this.raise(doubleProto, ErrorMessages.DuplicateProto);
-      }
+    if (shorthandAssignLoc != null) {
+      this.raise(ErrorMessages.InvalidCoverInitializedName, {
+        at: shorthandAssignLoc
+      });
+    }
-      if (optionalParameters >= 0) {
-        this.unexpected(optionalParameters);
-      }
+    if (doubleProtoLoc != null) {
+      this.raise(ErrorMessages.DuplicateProto, {
+        at: doubleProtoLoc
+      });
+    }
+    if (optionalParametersLoc != null) {
+      this.unexpected(optionalParametersLoc);
     }
   }
@@ -6934,9 +7045,9 @@ class UtilParser extends Tokenizer {
 class ExpressionErrors {
   constructor() {
-    this.shorthandAssign = -1;
-    this.doubleProto = -1;
-    this.optionalParameters = -1;
+    this.shorthandAssignLoc = null;
+    this.doubleProtoLoc = null;
+    this.optionalParametersLoc = null;
   }
 }
@@ -7046,14 +7157,14 @@ class NodeUtils extends UtilParser {
   }
   finishNode(node, type) {
-    return this.finishNodeAt(node, type, this.state.lastTokEnd, this.state.lastTokEndLoc);
+    return this.finishNodeAt(node, type, this.state.lastTokEndLoc);
   }
-  finishNodeAt(node, type, pos, loc) {
+  finishNodeAt(node, type, endLoc) {
     node.type = type;
-    node.end = pos;
-    node.loc.end = loc;
-    if (this.options.ranges) node.range[1] = pos;
+    node.end = indexes.get(endLoc);
+    node.loc.end = endLoc;
+    if (this.options.ranges) node.range[1] = node.end;
     if (this.options.attachComment) this.processComment(node);
     return node;
   }
@@ -7065,11 +7176,10 @@ class NodeUtils extends UtilParser {
   }
   resetEndLocation(node) {
-    var end = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state.lastTokEnd;
-    var endLoc = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.state.lastTokEndLoc;
-    node.end = end;
+    var endLoc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state.lastTokEndLoc;
+    node.end = indexes.get(endLoc);
     node.loc.end = endLoc;
-    if (this.options.ranges) node.range[1] = end;
+    if (this.options.ranges) node.range[1] = node.end;
   }
   resetStartLocationFromNode(node, locationNode) {
@@ -7215,12 +7325,14 @@ var flow = superClass => class extends superClass {
   flowParsePredicate() {
     var node = this.startNode();
-    var moduloPos = this.state.start;
+    var moduloLoc = this.state.startLoc;
     this.next();
     this.expectContextual(103);
-    if (this.state.lastTokStart > moduloPos + 1) {
-      this.raise(moduloPos, FlowErrors.UnexpectedSpaceBetweenModuloChecks);
+    if (this.state.lastTokStart > indexes.get(moduloLoc) + 1) {
+      this.raise(FlowErrors.UnexpectedSpaceBetweenModuloChecks, {
+        at: moduloLoc
+      });
     }
     if (this.eat(10)) {
@@ -7283,7 +7395,7 @@ var flow = superClass => class extends superClass {
     id.typeAnnotation = this.finishNode(typeContainer, "TypeAnnotation");
     this.resetEndLocation(id);
     this.semicolon();
-    this.scope.declareName(node.id.name, BIND_FLOW_DECLARE_FN, node.id.start);
+    this.scope.declareName(node.id.name, BIND_FLOW_DECLARE_FN, node.id.loc.start);
     return this.finishNode(node, "DeclareFunction");
   }
@@ -7299,7 +7411,9 @@ var flow = superClass => class extends superClass {
         return this.flowParseDeclareModuleExports(node);
       } else {
         if (insideModule) {
-          this.raise(this.state.lastTokStart, FlowErrors.NestedDeclareModule);
+          this.raise(FlowErrors.NestedDeclareModule, {
+            at: this.state.lastTokStartLoc
+          });
         }
         return this.flowParseDeclareModule(node);
@@ -7320,7 +7434,7 @@ var flow = superClass => class extends superClass {
   flowParseDeclareVariable(node) {
     this.next();
     node.id = this.flowParseTypeAnnotatableIdentifier(true);
-    this.scope.declareName(node.id.name, BIND_VAR, node.id.start);
+    this.scope.declareName(node.id.name, BIND_VAR, node.id.loc.start);
     this.semicolon();
     return this.finishNode(node, "DeclareVariable");
   }
@@ -7345,7 +7459,9 @@ var flow = superClass => class extends superClass {
         this.next();
         if (!this.isContextual(122) && !this.match(83)) {
-          this.raise(this.state.lastTokStart, FlowErrors.InvalidNonTypeImportInDeclareModule);
+          this.raise(FlowErrors.InvalidNonTypeImportInDeclareModule, {
+            at: this.state.lastTokStartLoc
+          });
         }
         this.parseImport(_bodyNode);
@@ -7365,17 +7481,23 @@ var flow = superClass => class extends superClass {
     body.forEach(bodyElement => {
       if (isEsModuleType(bodyElement)) {
         if (kind === "CommonJS") {
-          this.raise(bodyElement.start, FlowErrors.AmbiguousDeclareModuleKind);
+          this.raise(FlowErrors.AmbiguousDeclareModuleKind, {
+            node: bodyElement
+          });
         }
         kind = "ES";
       } else if (bodyElement.type === "DeclareModuleExports") {
         if (hasModuleExport) {
-          this.raise(bodyElement.start, FlowErrors.DuplicateDeclareModuleExports);
+          this.raise(FlowErrors.DuplicateDeclareModuleExports, {
+            node: bodyElement
+          });
         }
         if (kind === "ES") {
-          this.raise(bodyElement.start, FlowErrors.AmbiguousDeclareModuleKind);
+          this.raise(FlowErrors.AmbiguousDeclareModuleKind, {
+            node: bodyElement
+          });
         }
         kind = "CommonJS";
@@ -7403,7 +7525,9 @@ var flow = superClass => class extends superClass {
       if (this.match(71) || this.isLet() || (this.isContextual(122) || this.isContextual(121)) && !insideModule) {
         var label = this.state.value;
         var suggestion = exportSuggestions[label];
-        throw this.raise(this.state.start, FlowErrors.UnsupportedDeclareExportKind, label, suggestion);
+        throw this.raise(FlowErrors.UnsupportedDeclareExportKind, {
+          at: this.state.startLoc
+        }, label, suggestion);
       }
       if (this.match(70) || this.match(64) || this.match(76) || this.isContextual(123)) {
@@ -7458,7 +7582,7 @@ var flow = superClass => class extends superClass {
   flowParseInterfaceish(node) {
     var isClass = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     node.id = this.flowParseRestrictedIdentifier(!isClass, true);
-    this.scope.declareName(node.id.name, isClass ? BIND_FUNCTION : BIND_LEXICAL, node.id.start);
+    this.scope.declareName(node.id.name, isClass ? BIND_FUNCTION : BIND_LEXICAL, node.id.loc.start);
     if (this.match(45)) {
       node.typeParameters = this.flowParseTypeParameterDeclaration();
@@ -7521,23 +7645,27 @@ var flow = superClass => class extends superClass {
   checkNotUnderscore(word) {
     if (word === "_") {
-      this.raise(this.state.start, FlowErrors.UnexpectedReservedUnderscore);
+      this.raise(FlowErrors.UnexpectedReservedUnderscore, {
+        at: this.state.startLoc
+      });
     }
   }
   checkReservedType(word, startLoc, declaration) {
     if (!reservedTypes.has(word)) return;
-    this.raise(startLoc, declaration ? FlowErrors.AssignReservedType : FlowErrors.UnexpectedReservedType, word);
+    this.raise(declaration ? FlowErrors.AssignReservedType : FlowErrors.UnexpectedReservedType, {
+      at: startLoc
+    }, word);
   }
   flowParseRestrictedIdentifier(liberal, declaration) {
-    this.checkReservedType(this.state.value, this.state.start, declaration);
+    this.checkReservedType(this.state.value, this.state.startLoc, declaration);
     return this.parseIdentifier(liberal);
   }
   flowParseTypeAlias(node) {
     node.id = this.flowParseRestrictedIdentifier(false, true);
-    this.scope.declareName(node.id.name, BIND_LEXICAL, node.id.start);
+    this.scope.declareName(node.id.name, BIND_LEXICAL, node.id.loc.start);
     if (this.match(45)) {
       node.typeParameters = this.flowParseTypeParameterDeclaration();
@@ -7553,7 +7681,7 @@ var flow = superClass => class extends superClass {
   flowParseOpaqueType(node, declare) {
     this.expectContextual(122);
     node.id = this.flowParseRestrictedIdentifier(true, true);
-    this.scope.declareName(node.id.name, BIND_LEXICAL, node.id.start);
+    this.scope.declareName(node.id.name, BIND_LEXICAL, node.id.loc.start);
     if (this.match(45)) {
       node.typeParameters = this.flowParseTypeParameterDeclaration();
@@ -7579,7 +7707,7 @@ var flow = superClass => class extends superClass {
   flowParseTypeParameter() {
     var requireDefault = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-    var nodeStart = this.state.start;
+    var nodeStartLoc = this.state.startLoc;
     var node = this.startNode();
     var variance = this.flowParseVariance();
     var ident = this.flowParseTypeAnnotatableIdentifier();
@@ -7592,7 +7720,9 @@ var flow = superClass => class extends superClass {
       node.default = this.flowParseType();
     } else {
       if (requireDefault) {
-        this.raise(nodeStart, FlowErrors.MissingTypeParamDefault);
+        this.raise(FlowErrors.MissingTypeParamDefault, {
+          at: nodeStartLoc
+        });
       }
     }
@@ -7784,14 +7914,14 @@ var flow = superClass => class extends superClass {
     return this.finishNode(node, "ObjectTypeCallProperty");
   }
-  flowParseObjectType(_ref5) {
+  flowParseObjectType(_ref7) {
     var {
       allowStatic,
       allowExact,
       allowSpread,
       allowProto,
       allowInexact
-    } = _ref5;
+    } = _ref7;
     var oldInType = this.state.inType;
     this.state.inType = true;
     var nodeStart = this.startNode();
@@ -7817,8 +7947,8 @@ var flow = superClass => class extends superClass {
     while (!this.match(endDelim)) {
       var isStatic = false;
-      var protoStart = null;
-      var inexactStart = null;
+      var protoStartLoc = null;
+      var inexactStartLoc = null;
       var node = this.startNode();
       if (allowProto && this.isContextual(111)) {
@@ -7826,7 +7956,7 @@ var flow = superClass => class extends superClass {
         if (lookahead.type !== 14 && lookahead.type !== 17) {
           this.next();
-          protoStart = this.state.start;
+          protoStartLoc = this.state.startLoc;
           allowStatic = false;
         }
       }
@@ -7843,13 +7973,13 @@ var flow = superClass => class extends superClass {
       var variance = this.flowParseVariance();
       if (this.eat(0)) {
-        if (protoStart != null) {
-          this.unexpected(protoStart);
+        if (protoStartLoc != null) {
+          this.unexpected(protoStartLoc);
         }
         if (this.eat(0)) {
           if (variance) {
-            this.unexpected(variance.start);
+            this.unexpected(variance.loc.start);
           }
           nodeStart.internalSlots.push(this.flowParseObjectTypeInternalSlot(node, isStatic));
@@ -7857,12 +7987,12 @@ var flow = superClass => class extends superClass {
           nodeStart.indexers.push(this.flowParseObjectTypeIndexer(node, isStatic, variance));
         }
       } else if (this.match(10) || this.match(45)) {
-        if (protoStart != null) {
-          this.unexpected(protoStart);
+        if (protoStartLoc != null) {
+          this.unexpected(protoStartLoc);
         }
         if (variance) {
-          this.unexpected(variance.start);
+          this.unexpected(variance.loc.start);
         }
         nodeStart.callProperties.push(this.flowParseObjectTypeCallProperty(node, isStatic));
@@ -7878,11 +8008,11 @@ var flow = superClass => class extends superClass {
           }
         }
-        var propOrInexact = this.flowParseObjectTypeProperty(node, isStatic, protoStart, variance, kind, allowSpread, allowInexact != null ? allowInexact : !exact);
+        var propOrInexact = this.flowParseObjectTypeProperty(node, isStatic, protoStartLoc, variance, kind, allowSpread, allowInexact != null ? allowInexact : !exact);
         if (propOrInexact === null) {
           inexact = true;
-          inexactStart = this.state.lastTokStart;
+          inexactStartLoc = this.state.lastTokStartLoc;
         } else {
           nodeStart.properties.push(propOrInexact);
         }
@@ -7890,8 +8020,10 @@ var flow = superClass => class extends superClass {
       this.flowObjectTypeSemicolon();
-      if (inexactStart && !this.match(8) && !this.match(9)) {
-        this.raise(inexactStart, FlowErrors.UnexpectedExplicitInexactInObject);
+      if (inexactStartLoc && !this.match(8) && !this.match(9)) {
+        this.raise(FlowErrors.UnexpectedExplicitInexactInObject, {
+          at: inexactStartLoc
+        });
       }
     }
@@ -7906,34 +8038,44 @@ var flow = superClass => class extends superClass {
     return out;
   }
-  flowParseObjectTypeProperty(node, isStatic, protoStart, variance, kind, allowSpread, allowInexact) {
+  flowParseObjectTypeProperty(node, isStatic, protoStartLoc, variance, kind, allowSpread, allowInexact) {
     if (this.eat(21)) {
       var isInexactToken = this.match(12) || this.match(13) || this.match(8) || this.match(9);
       if (isInexactToken) {
         if (!allowSpread) {
-          this.raise(this.state.lastTokStart, FlowErrors.InexactInsideNonObject);
+          this.raise(FlowErrors.InexactInsideNonObject, {
+            at: this.state.lastTokStartLoc
+          });
         } else if (!allowInexact) {
-          this.raise(this.state.lastTokStart, FlowErrors.InexactInsideExact);
+          this.raise(FlowErrors.InexactInsideExact, {
+            at: this.state.lastTokStartLoc
+          });
         }
         if (variance) {
-          this.raise(variance.start, FlowErrors.InexactVariance);
+          this.raise(FlowErrors.InexactVariance, {
+            node: variance
+          });
         }
         return null;
       }
       if (!allowSpread) {
-        this.raise(this.state.lastTokStart, FlowErrors.UnexpectedSpreadType);
+        this.raise(FlowErrors.UnexpectedSpreadType, {
+          at: this.state.lastTokStartLoc
+        });
       }
-      if (protoStart != null) {
-        this.unexpected(protoStart);
+      if (protoStartLoc != null) {
+        this.unexpected(protoStartLoc);
       }
       if (variance) {
-        this.raise(variance.start, FlowErrors.SpreadVariance);
+        this.raise(FlowErrors.SpreadVariance, {
+          node: variance
+        });
       }
       node.argument = this.flowParseType();
@@ -7941,19 +8083,19 @@ var flow = superClass => class extends superClass {
     } else {
       node.key = this.flowParseObjectPropertyKey();
       node.static = isStatic;
-      node.proto = protoStart != null;
+      node.proto = protoStartLoc != null;
       node.kind = kind;
       var optional = false;
       if (this.match(45) || this.match(10)) {
         node.method = true;
-        if (protoStart != null) {
-          this.unexpected(protoStart);
+        if (protoStartLoc != null) {
+          this.unexpected(protoStartLoc);
         }
         if (variance) {
-          this.unexpected(variance.start);
+          this.unexpected(variance.loc.start);
         }
         node.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node.start, node.loc.start));
@@ -7963,7 +8105,9 @@ var flow = superClass => class extends superClass {
         }
         if (!allowSpread && node.key.name === "constructor" && node.value.this) {
-          this.raise(node.value.this.start, FlowErrors.ThisParamBannedInConstructor);
+          this.raise(FlowErrors.ThisParamBannedInConstructor, {
+            node: node.value.this
+          });
         }
       } else {
         if (kind !== "init") this.unexpected();
@@ -7984,23 +8128,24 @@ var flow = superClass => class extends superClass {
   flowCheckGetterSetterParams(property) {
     var paramCount = property.kind === "get" ? 0 : 1;
-    var start = property.start;
     var length = property.value.params.length + (property.value.rest ? 1 : 0);
     if (property.value.this) {
-      this.raise(property.value.this.start, property.kind === "get" ? FlowErrors.GetterMayNotHaveThisParam : FlowErrors.SetterMayNotHaveThisParam);
+      this.raise(property.kind === "get" ? FlowErrors.GetterMayNotHaveThisParam : FlowErrors.SetterMayNotHaveThisParam, {
+        node: property.value.this
+      });
     }
     if (length !== paramCount) {
-      if (property.kind === "get") {
-        this.raise(start, ErrorMessages.BadGetterArity);
-      } else {
-        this.raise(start, ErrorMessages.BadSetterArity);
-      }
+      this.raise(property.kind === "get" ? ErrorMessages.BadGetterArity : ErrorMessages.BadSetterArity, {
+        node: property
+      });
     }
     if (property.kind === "set" && property.value.rest) {
-      this.raise(start, ErrorMessages.BadSetterRestParameter);
+      this.raise(ErrorMessages.BadSetterRestParameter, {
+        node: property
+      });
     }
   }
@@ -8069,7 +8214,9 @@ var flow = superClass => class extends superClass {
     if (lh.type === 14 || lh.type === 17) {
       if (isThis && !first) {
-        this.raise(node.start, FlowErrors.ThisParamMustBeFirst);
+        this.raise(FlowErrors.ThisParamMustBeFirst, {
+          node
+        });
       }
       name = this.parseIdentifier(isThis);
@@ -8078,7 +8225,9 @@ var flow = superClass => class extends superClass {
         optional = true;
         if (isThis) {
-          this.raise(node.start, FlowErrors.ThisParamMayNotBeOptional);
+          this.raise(FlowErrors.ThisParamMayNotBeOptional, {
+            node
+          });
         }
       }
@@ -8271,7 +8420,9 @@ var flow = superClass => class extends superClass {
             return this.parseLiteralAtNode(-this.state.value, "BigIntLiteralTypeAnnotation", node);
           }
-          throw this.raise(this.state.start, FlowErrors.UnexpectedSubtractionOperand);
+          throw this.raise(FlowErrors.UnexpectedSubtractionOperand, {
+            at: this.state.startLoc
+          });
         }
         throw this.unexpected();
@@ -8443,7 +8594,7 @@ var flow = superClass => class extends superClass {
   typeCastToParameter(node) {
     node.expression.typeAnnotation = node.typeAnnotation;
-    this.resetEndLocation(node.expression, node.typeAnnotation.end, node.typeAnnotation.loc.end);
+    this.resetEndLocation(node.expression, node.typeAnnotation.loc.end);
     return node.expression;
   }
@@ -8608,7 +8759,9 @@ var flow = superClass => class extends superClass {
       }
       if (failed && valid.length > 1) {
-        this.raise(state.start, FlowErrors.AmbiguousConditionalArrow);
+        this.raise(FlowErrors.AmbiguousConditionalArrow, {
+          at: state.startLoc
+        });
       }
       if (failed && valid.length === 1) {
@@ -8674,7 +8827,7 @@ var flow = superClass => class extends superClass {
   finishArrowValidation(node) {
     var _node$extra;
-    this.toAssignableList(node.params, (_node$extra = node.extra) == null ? void 0 : _node$extra.trailingComma, false);
+    this.toAssignableList(node.params, (_node$extra = node.extra) == null ? void 0 : _node$extra.trailingCommaLoc, false);
     this.scope.enter(SCOPE_FUNCTION | SCOPE_ARROW);
     super.checkParams(node, false, true);
     this.scope.exit();
@@ -8783,11 +8936,13 @@ var flow = superClass => class extends superClass {
   }
   maybeParseExportNamespaceSpecifier(node) {
-    var pos = this.state.start;
+    var {
+      startLoc
+    } = this.state;
     var hasNamespace = super.maybeParseExportNamespaceSpecifier(node);
     if (hasNamespace && node.exportKind === "type") {
-      this.unexpected(pos);
+      this.unexpected(startLoc);
     }
     return hasNamespace;
@@ -8802,7 +8957,9 @@ var flow = superClass => class extends superClass {
   }
   parseClassMember(classBody, member, state) {
-    var pos = this.state.start;
+    var {
+      startLoc
+    } = this.state;
     if (this.isContextual(117)) {
       if (this.parseClassMemberFromModifier(classBody, member)) {
@@ -8816,9 +8973,13 @@ var flow = superClass => class extends superClass {
     if (member.declare) {
       if (member.type !== "ClassProperty" && member.type !== "ClassPrivateProperty" && member.type !== "PropertyDefinition") {
-        this.raise(pos, FlowErrors.DeclareClassElement);
+        this.raise(FlowErrors.DeclareClassElement, {
+          at: startLoc
+        });
       } else if (member.value) {
-        this.raise(member.value.start, FlowErrors.DeclareClassFieldInitializer);
+        this.raise(FlowErrors.DeclareClassFieldInitializer, {
+          node: member.value
+        });
       }
     }
   }
@@ -8832,7 +8993,9 @@ var flow = superClass => class extends superClass {
     var fullWord = "@@" + word;
     if (!this.isIterator(word) || !this.state.inType) {
-      this.raise(this.state.pos, ErrorMessages.InvalidIdentifier, fullWord);
+      this.raise(ErrorMessages.InvalidIdentifier, {
+        at: this.state.curPosition()
+      }, fullWord);
     }
     this.finishToken(124, fullWord);
@@ -8877,7 +9040,7 @@ var flow = superClass => class extends superClass {
     }
   }
-  toAssignableList(exprList, trailingCommaPos, isLHS) {
+  toAssignableList(exprList, trailingCommaLoc, isLHS) {
     for (var i = 0; i < exprList.length; i++) {
       var expr = exprList[i];
@@ -8886,7 +9049,7 @@ var flow = superClass => class extends superClass {
       }
     }
-    return super.toAssignableList(exprList, trailingCommaPos, isLHS);
+    return super.toAssignableList(exprList, trailingCommaLoc, isLHS);
   }
   toReferencedList(exprList, isParenthesizedExpr) {
@@ -8896,7 +9059,9 @@ var flow = superClass => class extends superClass {
       var expr = exprList[i];
       if (expr && expr.type === "TypeCastExpression" && !((_expr$extra = expr.extra) != null && _expr$extra.parenthesized) && (exprList.length > 1 || !isParenthesizedExpr)) {
-        this.raise(expr.typeAnnotation.start, FlowErrors.TypeCastInPattern);
+        this.raise(FlowErrors.TypeCastInPattern, {
+          node: expr.typeAnnotation
+        });
       }
     }
@@ -8953,7 +9118,7 @@ var flow = superClass => class extends superClass {
   pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
     if (method.variance) {
-      this.unexpected(method.variance.start);
+      this.unexpected(method.variance.loc.start);
     }
     delete method.variance;
@@ -8968,20 +9133,24 @@ var flow = superClass => class extends superClass {
       var params = method.params;
       if (params.length > 0 && this.isThisParam(params[0])) {
-        this.raise(method.start, FlowErrors.ThisParamBannedInConstructor);
+        this.raise(FlowErrors.ThisParamBannedInConstructor, {
+          node: method
+        });
       }
     } else if (method.type === "MethodDefinition" && isConstructor && method.value.params) {
       var _params2 = method.value.params;
       if (_params2.length > 0 && this.isThisParam(_params2[0])) {
-        this.raise(method.start, FlowErrors.ThisParamBannedInConstructor);
+        this.raise(FlowErrors.ThisParamBannedInConstructor, {
+          node: method
+        });
       }
     }
   }
   pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {
     if (method.variance) {
-      this.unexpected(method.variance.start);
+      this.unexpected(method.variance.loc.start);
     }
     delete method.variance;
@@ -9028,9 +9197,13 @@ var flow = superClass => class extends superClass {
       var param = params[0];
       if (this.isThisParam(param) && method.kind === "get") {
-        this.raise(param.start, FlowErrors.GetterMayNotHaveThisParam);
+        this.raise(FlowErrors.GetterMayNotHaveThisParam, {
+          node: param
+        });
       } else if (this.isThisParam(param)) {
-        this.raise(param.start, FlowErrors.SetterMayNotHaveThisParam);
+        this.raise(FlowErrors.SetterMayNotHaveThisParam, {
+          node: param
+        });
       }
     }
   }
@@ -9041,7 +9214,7 @@ var flow = superClass => class extends superClass {
   parseObjPropValue(prop, startPos, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {
     if (prop.variance) {
-      this.unexpected(prop.variance.start);
+      this.unexpected(prop.variance.loc.start);
     }
     delete prop.variance;
@@ -9062,11 +9235,15 @@ var flow = superClass => class extends superClass {
   parseAssignableListItemTypes(param) {
     if (this.eat(17)) {
       if (param.type !== "Identifier") {
-        this.raise(param.start, FlowErrors.PatternIsOptional);
+        this.raise(FlowErrors.PatternIsOptional, {
+          node: param
+        });
       }
       if (this.isThisParam(param)) {
-        this.raise(param.start, FlowErrors.ThisParamMayNotBeOptional);
+        this.raise(FlowErrors.ThisParamMayNotBeOptional, {
+          node: param
+        });
       }
       param.optional = true;
@@ -9075,11 +9252,15 @@ var flow = superClass => class extends superClass {
     if (this.match(14)) {
       param.typeAnnotation = this.flowParseTypeAnnotation();
     } else if (this.isThisParam(param)) {
-      this.raise(param.start, FlowErrors.ThisParamAnnotationRequired);
+      this.raise(FlowErrors.ThisParamAnnotationRequired, {
+        node: param
+      });
     }
     if (this.match(29) && this.isThisParam(param)) {
-      this.raise(param.start, FlowErrors.ThisParamNoDefault);
+      this.raise(FlowErrors.ThisParamNoDefault, {
+        node: param
+      });
     }
     this.resetEndLocation(param);
@@ -9090,7 +9271,9 @@ var flow = superClass => class extends superClass {
     var node = super.parseMaybeDefault(startPos, startLoc, left);
     if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) {
-      this.raise(node.typeAnnotation.start, FlowErrors.TypeBeforeInitializer);
+      this.raise(FlowErrors.TypeBeforeInitializer, {
+        node: node.typeAnnotation
+      });
     }
     return node;
@@ -9127,7 +9310,7 @@ var flow = superClass => class extends superClass {
       } = lh;
       if (kind === "type" && type === 51) {
-        this.unexpected(lh.start);
+        this.unexpected(null, lh.type);
       }
       if (isMaybeDefaultImport(type) || type === 5 || type === 51) {
@@ -9171,7 +9354,9 @@ var flow = superClass => class extends superClass {
         specifier.importKind = specifierTypeKind;
       } else {
         if (importedIsString) {
-          throw this.raise(specifier.start, ErrorMessages.ImportBindingIsString, firstIdent.value);
+          throw this.raise(ErrorMessages.ImportBindingIsString, {
+            node: specifier
+          }, firstIdent.value);
         }
         specifier.imported = firstIdent;
@@ -9189,15 +9374,17 @@ var flow = superClass => class extends superClass {
     var specifierIsTypeImport = hasTypeImportKind(specifier);
     if (isInTypeOnlyImport && specifierIsTypeImport) {
-      this.raise(specifier.start, FlowErrors.ImportTypeShorthandOnlyInPureImport);
+      this.raise(FlowErrors.ImportTypeShorthandOnlyInPureImport, {
+        node: specifier
+      });
     }
     if (isInTypeOnlyImport || specifierIsTypeImport) {
-      this.checkReservedType(specifier.local.name, specifier.local.start, true);
+      this.checkReservedType(specifier.local.name, specifier.local.loc.start, true);
     }
     if (isBinding && !isInTypeOnlyImport && !specifierIsTypeImport) {
-      this.checkReservedWord(specifier.local.name, specifier.start, true, true);
+      this.checkReservedWord(specifier.local.name, specifier.loc.start, true, true);
     }
     this.checkLVal(specifier.local, "import specifier", BIND_LEXICAL);
@@ -9294,7 +9481,9 @@ var flow = superClass => class extends superClass {
       if (arrow.node && this.maybeUnwrapTypeCastExpression(arrow.node).type === "ArrowFunctionExpression") {
         if (!arrow.error && !arrow.aborted) {
           if (arrow.node.async) {
-            this.raise(typeParameters.start, FlowErrors.UnexpectedTypeParameterBeforeAsyncArrowFunction);
+            this.raise(FlowErrors.UnexpectedTypeParameterBeforeAsyncArrowFunction, {
+              node: typeParameters
+            });
           }
           return arrow.node;
@@ -9315,7 +9504,9 @@ var flow = superClass => class extends superClass {
       if ((_jsx3 = jsx) != null && _jsx3.thrown) throw jsx.error;
       if (arrow.thrown) throw arrow.error;
-      throw this.raise(typeParameters.start, FlowErrors.UnexpectedTokenAfterTypeParameter);
+      throw this.raise(FlowErrors.UnexpectedTokenAfterTypeParameter, {
+        node: typeParameters
+      });
     }
     return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
@@ -9360,7 +9551,9 @@ var flow = superClass => class extends superClass {
     for (var i = 0; i < node.params.length; i++) {
       if (this.isThisParam(node.params[i]) && i > 0) {
-        this.raise(node.params[i].start, FlowErrors.ThisParamMustBeFirst);
+        this.raise(FlowErrors.ThisParamMustBeFirst, {
+          node: node.params[i]
+        });
       }
     }
@@ -9485,7 +9678,9 @@ var flow = superClass => class extends superClass {
     var fileNode = super.parseTopLevel(file, program);
     if (this.state.hasFlowComment) {
-      this.raise(this.state.pos, FlowErrors.UnterminatedFlowComment);
+      this.raise(FlowErrors.UnterminatedFlowComment, {
+        at: this.state.curPosition()
+      });
     }
     return fileNode;
@@ -9494,7 +9689,9 @@ var flow = superClass => class extends superClass {
   skipBlockComment() {
     if (this.hasPlugin("flowComments") && this.skipFlowComment()) {
       if (this.state.hasFlowComment) {
-        this.unexpected(null, FlowErrors.NestedFlowComment);
+        throw this.raise(FlowErrors.NestedFlowComment, {
+          at: this.state.startLoc
+        });
       }
       this.hasFlowCommentCompletion();
@@ -9504,13 +9701,15 @@ var flow = superClass => class extends superClass {
     }
     if (this.state.hasFlowComment) {
-      var end = this.input.indexOf("*-/", this.state.pos += 2);
+      var end = this.input.indexOf("*-/", this.state.pos + 2);
       if (end === -1) {
-        throw this.raise(this.state.pos - 2, ErrorMessages.UnterminatedComment);
+        throw this.raise(ErrorMessages.UnterminatedComment, {
+          at: this.state.curPosition()
+        });
       }
-      this.state.pos = end + 3;
+      this.state.pos = end + 2 + 3;
       return;
     }
@@ -9549,93 +9748,64 @@ var flow = superClass => class extends superClass {
     var end = this.input.indexOf("*/", this.state.pos);
     if (end === -1) {
-      throw this.raise(this.state.pos, ErrorMessages.UnterminatedComment);
+      throw this.raise(ErrorMessages.UnterminatedComment, {
+        at: this.state.curPosition()
+      });
     }
   }
-  flowEnumErrorBooleanMemberNotInitialized(pos, _ref6) {
-    var {
-      enumName,
-      memberName
-    } = _ref6;
-    this.raise(pos, FlowErrors.EnumBooleanMemberNotInitialized, memberName, enumName);
-  }
-  flowEnumErrorInvalidMemberName(pos, _ref7) {
-    var {
-      enumName,
-      memberName
-    } = _ref7;
-    var suggestion = memberName[0].toUpperCase() + memberName.slice(1);
-    this.raise(pos, FlowErrors.EnumInvalidMemberName, memberName, suggestion, enumName);
-  }
-  flowEnumErrorDuplicateMemberName(pos, _ref8) {
+  flowEnumErrorBooleanMemberNotInitialized(loc, _ref8) {
     var {
       enumName,
       memberName
     } = _ref8;
-    this.raise(pos, FlowErrors.EnumDuplicateMemberName, memberName, enumName);
-  }
-  flowEnumErrorInconsistentMemberValues(pos, _ref9) {
-    var {
-      enumName
-    } = _ref9;
-    this.raise(pos, FlowErrors.EnumInconsistentMemberValues, enumName);
+    this.raise(FlowErrors.EnumBooleanMemberNotInitialized, {
+      at: loc
+    }, memberName, enumName);
   }
-  flowEnumErrorInvalidExplicitType(pos, _ref10) {
+  flowEnumErrorInvalidExplicitType(loc, _ref9) {
     var {
       enumName,
       suppliedType
-    } = _ref10;
-    return this.raise(pos, suppliedType === null ? FlowErrors.EnumInvalidExplicitTypeUnknownSupplied : FlowErrors.EnumInvalidExplicitType, enumName, suppliedType);
+    } = _ref9;
+    return this.raise(suppliedType === null ? FlowErrors.EnumInvalidExplicitTypeUnknownSupplied : FlowErrors.EnumInvalidExplicitType, {
+      at: loc
+    }, enumName, suppliedType);
   }
-  flowEnumErrorInvalidMemberInitializer(pos, _ref11) {
+  flowEnumErrorInvalidMemberInitializer(loc, _ref10) {
     var {
       enumName,
       explicitType,
       memberName
-    } = _ref11;
-    var message = null;
-    switch (explicitType) {
-      case "boolean":
-      case "number":
-      case "string":
-        message = FlowErrors.EnumInvalidMemberInitializerPrimaryType;
-        break;
-      case "symbol":
-        message = FlowErrors.EnumInvalidMemberInitializerSymbolType;
-        break;
-      default:
-        message = FlowErrors.EnumInvalidMemberInitializerUnknownType;
-    }
-    return this.raise(pos, message, enumName, memberName, explicitType);
+    } = _ref10;
+    return this.raise(explicitType === "boolean" || explicitType === "number" || explicitType === "string" ? FlowErrors.EnumInvalidMemberInitializerPrimaryType : explicitType === "symbol" ? FlowErrors.EnumInvalidMemberInitializerSymbolType : FlowErrors.EnumInvalidMemberInitializerUnknownType, {
+      at: loc
+    }, enumName, memberName, explicitType);
   }
-  flowEnumErrorNumberMemberNotInitialized(pos, _ref12) {
+  flowEnumErrorNumberMemberNotInitialized(loc, _ref11) {
     var {
       enumName,
       memberName
-    } = _ref12;
-    this.raise(pos, FlowErrors.EnumNumberMemberNotInitialized, enumName, memberName);
+    } = _ref11;
+    this.raise(FlowErrors.EnumNumberMemberNotInitialized, {
+      at: loc
+    }, enumName, memberName);
   }
-  flowEnumErrorStringMemberInconsistentlyInitailized(pos, _ref13) {
+  flowEnumErrorStringMemberInconsistentlyInitailized(node, _ref12) {
     var {
       enumName
-    } = _ref13;
-    this.raise(pos, FlowErrors.EnumStringMemberInconsistentlyInitailized, enumName);
+    } = _ref12;
+    this.raise(FlowErrors.EnumStringMemberInconsistentlyInitailized, {
+      node
+    }, enumName);
   }
   flowEnumMemberInit() {
-    var startPos = this.state.start;
+    var startLoc = this.state.startLoc;
     var endOfInit = () => this.match(12) || this.match(8);
@@ -9647,14 +9817,14 @@ var flow = superClass => class extends superClass {
           if (endOfInit()) {
             return {
               type: "number",
-              pos: literal.start,
+              loc: literal.loc.start,
               value: literal
             };
           }
           return {
             type: "invalid",
-            pos: startPos
+            loc: startLoc
           };
         }
@@ -9665,14 +9835,14 @@ var flow = superClass => class extends superClass {
           if (endOfInit()) {
             return {
               type: "string",
-              pos: _literal.start,
+              loc: _literal.loc.start,
               value: _literal
             };
           }
           return {
             type: "invalid",
-            pos: startPos
+            loc: startLoc
           };
         }
@@ -9684,31 +9854,31 @@ var flow = superClass => class extends superClass {
           if (endOfInit()) {
             return {
               type: "boolean",
-              pos: _literal2.start,
+              loc: _literal2.loc.start,
               value: _literal2
             };
           }
           return {
             type: "invalid",
-            pos: startPos
+            loc: startLoc
           };
         }
       default:
         return {
           type: "invalid",
-          pos: startPos
+          loc: startLoc
         };
     }
   }
   flowEnumMemberRaw() {
-    var pos = this.state.start;
+    var loc = this.state.startLoc;
     var id = this.parseIdentifier(true);
     var init = this.eat(29) ? this.flowEnumMemberInit() : {
       type: "none",
-      pos
+      loc
     };
     return {
       id,
@@ -9716,7 +9886,7 @@ var flow = superClass => class extends superClass {
     };
   }
-  flowEnumCheckExplicitTypeMismatch(pos, context, expectedType) {
+  flowEnumCheckExplicitTypeMismatch(loc, context, expectedType) {
     var {
       explicitType
     } = context;
@@ -9726,15 +9896,15 @@ var flow = superClass => class extends superClass {
     }
     if (explicitType !== expectedType) {
-      this.flowEnumErrorInvalidMemberInitializer(pos, context);
+      this.flowEnumErrorInvalidMemberInitializer(loc, context);
     }
   }
-  flowEnumMembers(_ref14) {
+  flowEnumMembers(_ref13) {
     var {
       enumName,
       explicitType
-    } = _ref14;
+    } = _ref13;
     var seenNames = new Set();
     var members = {
       booleanMembers: [],
@@ -9762,17 +9932,15 @@ var flow = superClass => class extends superClass {
       }
       if (/^[a-z]/.test(memberName)) {
-        this.flowEnumErrorInvalidMemberName(id.start, {
-          enumName,
-          memberName
-        });
+        this.raise(FlowErrors.EnumInvalidMemberName, {
+          node: id
+        }, memberName, memberName[0].toUpperCase() + memberName.slice(1), enumName);
       }
       if (seenNames.has(memberName)) {
-        this.flowEnumErrorDuplicateMemberName(id.start, {
-          enumName,
-          memberName
-        });
+        this.raise(FlowErrors.EnumDuplicateMemberName, {
+          node: id
+        }, memberName, enumName);
       }
       seenNames.add(memberName);
@@ -9786,7 +9954,7 @@ var flow = superClass => class extends superClass {
       switch (init.type) {
         case "boolean":
           {
-            this.flowEnumCheckExplicitTypeMismatch(init.pos, context, "boolean");
+            this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "boolean");
             memberNode.init = init.value;
             members.booleanMembers.push(this.finishNode(memberNode, "EnumBooleanMember"));
             break;
@@ -9794,7 +9962,7 @@ var flow = superClass => class extends superClass {
         case "number":
           {
-            this.flowEnumCheckExplicitTypeMismatch(init.pos, context, "number");
+            this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "number");
             memberNode.init = init.value;
             members.numberMembers.push(this.finishNode(memberNode, "EnumNumberMember"));
             break;
@@ -9802,7 +9970,7 @@ var flow = superClass => class extends superClass {
         case "string":
           {
-            this.flowEnumCheckExplicitTypeMismatch(init.pos, context, "string");
+            this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "string");
             memberNode.init = init.value;
             members.stringMembers.push(this.finishNode(memberNode, "EnumStringMember"));
             break;
@@ -9810,18 +9978,18 @@ var flow = superClass => class extends superClass {
         case "invalid":
           {
-            throw this.flowEnumErrorInvalidMemberInitializer(init.pos, context);
+            throw this.flowEnumErrorInvalidMemberInitializer(init.loc, context);
           }
         case "none":
           {
             switch (explicitType) {
               case "boolean":
-                this.flowEnumErrorBooleanMemberNotInitialized(init.pos, context);
+                this.flowEnumErrorBooleanMemberNotInitialized(init.loc, context);
                 break;
               case "number":
-                this.flowEnumErrorNumberMemberNotInitialized(init.pos, context);
+                this.flowEnumErrorNumberMemberNotInitialized(init.loc, context);
                 break;
               default:
@@ -9841,10 +10009,10 @@ var flow = superClass => class extends superClass {
     };
   }
-  flowEnumStringMembers(initializedMembers, defaultedMembers, _ref15) {
+  flowEnumStringMembers(initializedMembers, defaultedMembers, _ref14) {
     var {
       enumName
-    } = _ref15;
+    } = _ref14;
     if (initializedMembers.length === 0) {
       return defaultedMembers;
@@ -9852,7 +10020,7 @@ var flow = superClass => class extends superClass {
       return initializedMembers;
     } else if (defaultedMembers.length > initializedMembers.length) {
       for (var member of initializedMembers) {
-        this.flowEnumErrorStringMemberInconsistentlyInitailized(member.start, {
+        this.flowEnumErrorStringMemberInconsistentlyInitailized(member, {
           enumName
         });
       }
@@ -9860,7 +10028,7 @@ var flow = superClass => class extends superClass {
       return defaultedMembers;
     } else {
       for (var _member of defaultedMembers) {
-        this.flowEnumErrorStringMemberInconsistentlyInitailized(_member.start, {
+        this.flowEnumErrorStringMemberInconsistentlyInitailized(_member, {
           enumName
         });
       }
@@ -9869,14 +10037,14 @@ var flow = superClass => class extends superClass {
     }
   }
-  flowEnumParseExplicitType(_ref16) {
+  flowEnumParseExplicitType(_ref15) {
     var {
       enumName
-    } = _ref16;
+    } = _ref15;
     if (this.eatContextual(97)) {
       if (!tokenIsIdentifier(this.state.type)) {
-        throw this.flowEnumErrorInvalidExplicitType(this.state.start, {
+        throw this.flowEnumErrorInvalidExplicitType(this.state.startLoc, {
           enumName,
           suppliedType: null
         });
@@ -9888,7 +10056,7 @@ var flow = superClass => class extends superClass {
       this.next();
       if (value !== "boolean" && value !== "number" && value !== "string" && value !== "symbol") {
-        this.flowEnumErrorInvalidExplicitType(this.state.start, {
+        this.flowEnumErrorInvalidExplicitType(this.state.startLoc, {
           enumName,
           suppliedType: value
         });
@@ -9900,11 +10068,9 @@ var flow = superClass => class extends superClass {
     return null;
   }
-  flowEnumBody(node, _ref17) {
-    var {
-      enumName,
-      nameLoc
-    } = _ref17;
+  flowEnumBody(node, id) {
+    var enumName = id.name;
+    var nameLoc = id.loc.start;
     var explicitType = this.flowEnumParseExplicitType({
       enumName
     });
@@ -9968,7 +10134,7 @@ var flow = superClass => class extends superClass {
             return this.finishNode(node, "EnumStringBody");
           } else if (!numsLen && !strsLen && boolsLen >= defaultedLen) {
             for (var member of members.defaultedMembers) {
-              this.flowEnumErrorBooleanMemberNotInitialized(member.start, {
+              this.flowEnumErrorBooleanMemberNotInitialized(member.loc.start, {
                 enumName,
                 memberName: member.id.name
               });
@@ -9979,7 +10145,7 @@ var flow = superClass => class extends superClass {
             return this.finishNode(node, "EnumBooleanBody");
           } else if (!boolsLen && !strsLen && numsLen >= defaultedLen) {
             for (var _member2 of members.defaultedMembers) {
-              this.flowEnumErrorNumberMemberNotInitialized(_member2.start, {
+              this.flowEnumErrorNumberMemberNotInitialized(_member2.loc.start, {
                 enumName,
                 memberName: _member2.id.name
               });
@@ -9989,9 +10155,9 @@ var flow = superClass => class extends superClass {
             this.expect(8);
             return this.finishNode(node, "EnumNumberBody");
           } else {
-            this.flowEnumErrorInconsistentMemberValues(nameLoc, {
-              enumName
-            });
+            this.raise(FlowErrors.EnumInconsistentMemberValues, {
+              at: nameLoc
+            }, enumName);
             return empty();
           }
         }
@@ -10001,10 +10167,7 @@ var flow = superClass => class extends superClass {
   flowParseEnumDeclaration(node) {
     var id = this.parseIdentifier();
     node.id = id;
-    node.body = this.flowEnumBody(this.startNode(), {
-      enumName: id.name,
-      nameLoc: id.start
-    });
+    node.body = this.flowEnumBody(this.startNode(), id);
     return this.finishNode(node, "EnumDeclaration");
   }
@@ -10319,7 +10482,9 @@ var jsx = superClass => class extends superClass {
     for (;;) {
       if (this.state.pos >= this.length) {
-        throw this.raise(this.state.start, JsxErrors.UnterminatedJsxContent);
+        throw this.raise(JsxErrors.UnterminatedJsxContent, {
+          at: this.state.startLoc
+        });
       }
       var ch = this.input.charCodeAt(this.state.pos);
@@ -10383,7 +10548,9 @@ var jsx = superClass => class extends superClass {
     for (;;) {
       if (this.state.pos >= this.length) {
-        throw this.raise(this.state.start, ErrorMessages.UnterminatedString);
+        throw this.raise(ErrorMessages.UnterminatedString, {
+          at: this.state.startLoc
+        });
       }
       var ch = this.input.charCodeAt(this.state.pos);
@@ -10516,7 +10683,9 @@ var jsx = superClass => class extends superClass {
         node = this.jsxParseExpressionContainer(node, types.j_oTag);
         if (node.expression.type === "JSXEmptyExpression") {
-          this.raise(node.start, JsxErrors.AttributeIsEmpty);
+          this.raise(JsxErrors.AttributeIsEmpty, {
+            node
+          });
         }
         return node;
@@ -10526,13 +10695,15 @@ var jsx = superClass => class extends superClass {
         return this.parseExprAtom();
       default:
-        throw this.raise(this.state.start, JsxErrors.UnsupportedJsxValue);
+        throw this.raise(JsxErrors.UnsupportedJsxValue, {
+          at: this.state.startLoc
+        });
     }
   }
   jsxParseEmptyExpression() {
-    var node = this.startNodeAt(this.state.lastTokEnd, this.state.lastTokEndLoc);
-    return this.finishNodeAt(node, "JSXEmptyExpression", this.state.start, this.state.startLoc);
+    var node = this.startNodeAt(indexes.get(this.state.lastTokEndLoc), this.state.lastTokEndLoc);
+    return this.finishNodeAt(node, "JSXEmptyExpression", this.state.startLoc);
   }
   jsxParseSpreadChild(node) {
@@ -10659,13 +10830,19 @@ var jsx = superClass => class extends superClass {
         }
       }
-      if (isFragment(openingElement) && !isFragment(closingElement)) {
-        this.raise(closingElement.start, JsxErrors.MissingClosingTagFragment);
+      if (isFragment(openingElement) && !isFragment(closingElement) && closingElement !== null) {
+        this.raise(JsxErrors.MissingClosingTagFragment, {
+          node: closingElement
+        });
       } else if (!isFragment(openingElement) && isFragment(closingElement)) {
-        this.raise(closingElement.start, JsxErrors.MissingClosingTagElement, getQualifiedJSXName(openingElement.name));
+        this.raise(JsxErrors.MissingClosingTagElement, {
+          node: closingElement
+        }, getQualifiedJSXName(openingElement.name));
       } else if (!isFragment(openingElement) && !isFragment(closingElement)) {
         if (getQualifiedJSXName(closingElement.name) !== getQualifiedJSXName(openingElement.name)) {
-          this.raise(closingElement.start, JsxErrors.MissingClosingTagElement, getQualifiedJSXName(openingElement.name));
+          this.raise(JsxErrors.MissingClosingTagElement, {
+            node: closingElement
+          }, getQualifiedJSXName(openingElement.name));
         }
       }
     }
@@ -10681,7 +10858,9 @@ var jsx = superClass => class extends superClass {
     node.children = children;
     if (this.match(45)) {
-      throw this.raise(this.state.start, JsxErrors.UnwrappedAdjacentJSXElements);
+      throw this.raise(JsxErrors.UnwrappedAdjacentJSXElements, {
+        at: this.state.startLoc
+      });
     }
     return isFragment(openingElement) ? this.finishNode(node, "JSXFragment") : this.finishNode(node, "JSXElement");
@@ -10794,7 +10973,7 @@ class TypeScriptScopeHandler extends ScopeHandler {
     return new TypeScriptScope(flags);
   }
-  declareName(name, bindingType, pos) {
+  declareName(name, bindingType, loc) {
     var scope = this.currentScope();
     if (bindingType & BIND_FLAGS_TS_EXPORT_ONLY) {
@@ -10807,7 +10986,7 @@ class TypeScriptScopeHandler extends ScopeHandler {
     if (bindingType & BIND_KIND_TYPE) {
       if (!(bindingType & BIND_KIND_VALUE)) {
-        this.checkRedeclarationInScope(scope, name, bindingType, pos);
+        this.checkRedeclarationInScope(scope, name, bindingType, loc);
         this.maybeExportDefined(scope, name);
       }
@@ -11008,49 +11187,61 @@ var typescript = superClass => class extends superClass {
   }
   tsParseModifiers(modified, allowedModifiers, disallowedModifiers, errorTemplate, stopOnStartOfClassStaticBlock) {
-    var enforceOrder = (pos, modifier, before, after) => {
+    var enforceOrder = (loc, modifier, before, after) => {
       if (modifier === before && modified[after]) {
-        this.raise(pos, TSErrors.InvalidModifiersOrder, before, after);
+        this.raise(TSErrors.InvalidModifiersOrder, {
+          at: loc
+        }, before, after);
       }
     };
-    var incompatible = (pos, modifier, mod1, mod2) => {
+    var incompatible = (loc, modifier, mod1, mod2) => {
       if (modified[mod1] && modifier === mod2 || modified[mod2] && modifier === mod1) {
-        this.raise(pos, TSErrors.IncompatibleModifiers, mod1, mod2);
+        this.raise(TSErrors.IncompatibleModifiers, {
+          at: loc
+        }, mod1, mod2);
       }
     };
     for (;;) {
-      var startPos = this.state.start;
+      var {
+        startLoc
+      } = this.state;
       var modifier = this.tsParseModifier(allowedModifiers.concat(disallowedModifiers != null ? disallowedModifiers : []), stopOnStartOfClassStaticBlock);
       if (!modifier) break;
       if (tsIsAccessModifier(modifier)) {
         if (modified.accessibility) {
-          this.raise(startPos, TSErrors.DuplicateAccessibilityModifier);
+          this.raise(TSErrors.DuplicateAccessibilityModifier, {
+            at: startLoc
+          });
         } else {
-          enforceOrder(startPos, modifier, modifier, "override");
-          enforceOrder(startPos, modifier, modifier, "static");
-          enforceOrder(startPos, modifier, modifier, "readonly");
+          enforceOrder(startLoc, modifier, modifier, "override");
+          enforceOrder(startLoc, modifier, modifier, "static");
+          enforceOrder(startLoc, modifier, modifier, "readonly");
           modified.accessibility = modifier;
         }
       } else {
         if (Object.hasOwnProperty.call(modified, modifier)) {
-          this.raise(startPos, TSErrors.DuplicateModifier, modifier);
+          this.raise(TSErrors.DuplicateModifier, {
+            at: startLoc
+          }, modifier);
         } else {
-          enforceOrder(startPos, modifier, "static", "readonly");
-          enforceOrder(startPos, modifier, "static", "override");
-          enforceOrder(startPos, modifier, "override", "readonly");
-          enforceOrder(startPos, modifier, "abstract", "override");
-          incompatible(startPos, modifier, "declare", "override");
-          incompatible(startPos, modifier, "static", "abstract");
+          enforceOrder(startLoc, modifier, "static", "readonly");
+          enforceOrder(startLoc, modifier, "static", "override");
+          enforceOrder(startLoc, modifier, "override", "readonly");
+          enforceOrder(startLoc, modifier, "abstract", "override");
+          incompatible(startLoc, modifier, "declare", "override");
+          incompatible(startLoc, modifier, "static", "abstract");
         }
         modified[modifier] = true;
       }
       if (disallowedModifiers != null && disallowedModifiers.includes(modifier)) {
-        this.raise(startPos, errorTemplate, modifier);
+        this.raise(errorTemplate, {
+          at: startLoc
+        }, modifier);
       }
     }
   }
@@ -11155,7 +11346,9 @@ var typescript = superClass => class extends superClass {
     this.expect(10);
     if (!this.match(125)) {
-      this.raise(this.state.start, TSErrors.UnsupportedImportTypeArgument);
+      this.raise(TSErrors.UnsupportedImportTypeArgument, {
+        at: this.state.startLoc
+      });
     }
     node.argument = this.parseExprAtom();
@@ -11253,7 +11446,9 @@ var typescript = superClass => class extends superClass {
     node.params = this.tsParseBracketedList("TypeParametersOrArguments", this.tsParseTypeParameter.bind(this), false, true, refTrailingCommaPos);
     if (node.params.length === 0) {
-      this.raise(node.start, TSErrors.EmptyTypeParameters);
+      this.raise(TSErrors.EmptyTypeParameters, {
+        node
+      });
     }
     if (refTrailingCommaPos.value !== -1) {
@@ -11274,21 +11469,25 @@ var typescript = superClass => class extends superClass {
   tsFillSignature(returnToken, signature) {
     var returnTokenRequired = returnToken === 19;
+    var paramsKey = "parameters";
+    var returnTypeKey = "typeAnnotation";
     signature.typeParameters = this.tsTryParseTypeParameters();
     this.expect(10);
-    signature.parameters = this.tsParseBindingListForSignature();
+    signature[paramsKey] = this.tsParseBindingListForSignature();
     if (returnTokenRequired) {
-      signature.typeAnnotation = this.tsParseTypeOrTypePredicateAnnotation(returnToken);
+      signature[returnTypeKey] = this.tsParseTypeOrTypePredicateAnnotation(returnToken);
     } else if (this.match(returnToken)) {
-      signature.typeAnnotation = this.tsParseTypeOrTypePredicateAnnotation(returnToken);
+      signature[returnTypeKey] = this.tsParseTypeOrTypePredicateAnnotation(returnToken);
     }
   }
   tsParseBindingListForSignature() {
     return this.parseBindingList(11, 41).map(pattern => {
       if (pattern.type !== "Identifier" && pattern.type !== "RestElement" && pattern.type !== "ObjectPattern" && pattern.type !== "ArrayPattern") {
-        this.raise(pattern.start, TSErrors.UnsupportedSignatureParameterKind, pattern.type);
+        this.raise(TSErrors.UnsupportedSignatureParameterKind, {
+          node: pattern
+        }, pattern.type);
       }
       return pattern;
@@ -11341,47 +11540,67 @@ var typescript = superClass => class extends superClass {
     if (this.match(10) || this.match(45)) {
       if (readonly) {
-        this.raise(node.start, TSErrors.ReadonlyForMethodSignature);
+        this.raise(TSErrors.ReadonlyForMethodSignature, {
+          node
+        });
       }
       var method = nodeAny;
       if (method.kind && this.match(45)) {
-        this.raise(this.state.pos, TSErrors.AccesorCannotHaveTypeParameters);
+        this.raise(TSErrors.AccesorCannotHaveTypeParameters, {
+          at: this.state.curPosition()
+        });
       }
       this.tsFillSignature(14, method);
       this.tsParseTypeMemberSemicolon();
+      var paramsKey = "parameters";
+      var returnTypeKey = "typeAnnotation";
       if (method.kind === "get") {
-        if (method.parameters.length > 0) {
-          this.raise(this.state.pos, ErrorMessages.BadGetterArity);
+        if (method[paramsKey].length > 0) {
+          this.raise(ErrorMessages.BadGetterArity, {
+            at: this.state.curPosition()
+          });
-          if (this.isThisParam(method.parameters[0])) {
-            this.raise(this.state.pos, TSErrors.AccesorCannotDeclareThisParameter);
+          if (this.isThisParam(method[paramsKey][0])) {
+            this.raise(TSErrors.AccesorCannotDeclareThisParameter, {
+              at: this.state.curPosition()
+            });
           }
         }
       } else if (method.kind === "set") {
-        if (method.parameters.length !== 1) {
-          this.raise(this.state.pos, ErrorMessages.BadSetterArity);
+        if (method[paramsKey].length !== 1) {
+          this.raise(ErrorMessages.BadSetterArity, {
+            at: this.state.curPosition()
+          });
         } else {
-          var firstParameter = method.parameters[0];
+          var firstParameter = method[paramsKey][0];
           if (this.isThisParam(firstParameter)) {
-            this.raise(this.state.pos, TSErrors.AccesorCannotDeclareThisParameter);
+            this.raise(TSErrors.AccesorCannotDeclareThisParameter, {
+              at: this.state.curPosition()
+            });
           }
           if (firstParameter.type === "Identifier" && firstParameter.optional) {
-            this.raise(this.state.pos, TSErrors.SetAccesorCannotHaveOptionalParameter);
+            this.raise(TSErrors.SetAccesorCannotHaveOptionalParameter, {
+              at: this.state.curPosition()
+            });
           }
           if (firstParameter.type === "RestElement") {
-            this.raise(this.state.pos, TSErrors.SetAccesorCannotHaveRestParameter);
+            this.raise(TSErrors.SetAccesorCannotHaveRestParameter, {
+              at: this.state.curPosition()
+            });
           }
         }
-        if (method.typeAnnotation) {
-          this.raise(method.typeAnnotation.start, TSErrors.SetAccesorCannotHaveReturnType);
+        if (method[returnTypeKey]) {
+          this.raise(TSErrors.SetAccesorCannotHaveReturnType, {
+            node: method[returnTypeKey]
+          });
         }
       } else {
         method.kind = "method";
@@ -11523,7 +11742,9 @@ var typescript = superClass => class extends superClass {
       } = elementNode;
       if (seenOptionalElement && type !== "TSRestType" && type !== "TSOptionalType" && !(type === "TSNamedTupleMember" && elementNode.optional)) {
-        this.raise(elementNode.start, TSErrors.OptionalTypeBeforeRequired);
+        this.raise(TSErrors.OptionalTypeBeforeRequired, {
+          node: elementNode
+        });
       }
       seenOptionalElement = seenOptionalElement || type === "TSNamedTupleMember" && elementNode.optional || type === "TSOptionalType";
@@ -11537,7 +11758,9 @@ var typescript = superClass => class extends superClass {
       labeledElements = (_labeledElements = labeledElements) != null ? _labeledElements : isLabeled;
       if (labeledElements !== isLabeled) {
-        this.raise(elementNode.start, TSErrors.MixedLabeledAndUnlabeledElements);
+        this.raise(TSErrors.MixedLabeledAndUnlabeledElements, {
+          node: elementNode
+        });
       }
     });
     return this.finishNode(node, "TSTupleType");
@@ -11560,7 +11783,9 @@ var typescript = superClass => class extends superClass {
       if (type.type === "TSTypeReference" && !type.typeParameters && type.typeName.type === "Identifier") {
         labeledNode.label = type.typeName;
       } else {
-        this.raise(type.start, TSErrors.InvalidTupleMemberLabel);
+        this.raise(TSErrors.InvalidTupleMemberLabel, {
+          node: type
+        });
         labeledNode.label = type;
       }
@@ -11756,7 +11981,9 @@ var typescript = superClass => class extends superClass {
         return;
       default:
-        this.raise(node.start, TSErrors.UnexpectedReadonly);
+        this.raise(TSErrors.UnexpectedReadonly, {
+          node
+        });
     }
   }
@@ -11955,7 +12182,9 @@ var typescript = superClass => class extends superClass {
     }
     if (containsEsc) {
-      this.raise(this.state.lastTokStart, ErrorMessages.InvalidEscapedReservedWord, "asserts");
+      this.raise(ErrorMessages.InvalidEscapedReservedWord, {
+        at: this.state.lastTokStartLoc
+      }, "asserts");
     }
     return true;
@@ -12009,7 +12238,9 @@ var typescript = superClass => class extends superClass {
   tsParseTypeAssertion() {
     if (this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) {
-      this.raise(this.state.start, TSErrors.ReservedTypeAssertion);
+      this.raise(TSErrors.ReservedTypeAssertion, {
+        at: this.state.startLoc
+      });
     }
     var node = this.startNode();
@@ -12023,11 +12254,13 @@ var typescript = superClass => class extends superClass {
   }
   tsParseHeritageClause(descriptor) {
-    var originalStart = this.state.start;
+    var originalStartLoc = this.state.startLoc;
     var delimitedList = this.tsParseDelimitedList("HeritageClauseElement", this.tsParseExpressionWithTypeArguments.bind(this));
     if (!delimitedList.length) {
-      this.raise(originalStart, TSErrors.EmptyHeritageClauseType, descriptor);
+      this.raise(TSErrors.EmptyHeritageClauseType, {
+        at: originalStartLoc
+      }, descriptor);
     }
     return delimitedList;
@@ -12050,7 +12283,9 @@ var typescript = superClass => class extends superClass {
       this.checkLVal(node.id, "typescript interface declaration", BIND_TS_INTERFACE);
     } else {
       node.id = null;
-      this.raise(this.state.start, TSErrors.MissingInterfaceName);
+      this.raise(TSErrors.MissingInterfaceName, {
+        at: this.state.startLoc
+      });
     }
     node.typeParameters = this.tsTryParseTypeParameters();
@@ -12210,7 +12445,9 @@ var typescript = superClass => class extends superClass {
     var moduleReference = this.tsParseModuleReference();
     if (node.importKind === "type" && moduleReference.type !== "TSExternalModuleReference") {
-      this.raise(moduleReference.start, TSErrors.ImportAliasHasImportType);
+      this.raise(TSErrors.ImportAliasHasImportType, {
+        node: moduleReference
+      });
     }
     node.moduleReference = moduleReference;
@@ -12444,7 +12681,9 @@ var typescript = superClass => class extends superClass {
     }));
     if (node.params.length === 0) {
-      this.raise(node.start, TSErrors.EmptyTypeArguments);
+      this.raise(TSErrors.EmptyTypeArguments, {
+        node
+      });
     }
     this.expect(46);
@@ -12475,7 +12714,9 @@ var typescript = superClass => class extends superClass {
       readonly = modified.readonly;
       if (allowModifiers === false && (accessibility || readonly || override)) {
-        this.raise(startPos, TSErrors.UnexpectedParameterModifier);
+        this.raise(TSErrors.UnexpectedParameterModifier, {
+          at: startLoc
+        });
       }
     }
@@ -12495,7 +12736,9 @@ var typescript = superClass => class extends superClass {
       if (override) pp.override = override;
       if (elt.type !== "Identifier" && elt.type !== "AssignmentPattern") {
-        this.raise(pp.start, TSErrors.UnsupportedParameterPropertyKind);
+        this.raise(TSErrors.UnsupportedParameterPropertyKind, {
+          node: pp
+        });
       }
       pp.parameter = elt;
@@ -12524,7 +12767,9 @@ var typescript = superClass => class extends superClass {
     }
     if (bodilessType === "TSDeclareFunction" && this.state.isAmbientContext) {
-      this.raise(node.start, TSErrors.DeclareFunctionHasImplementation);
+      this.raise(TSErrors.DeclareFunctionHasImplementation, {
+        node
+      });
       if (node.declare) {
         super.parseFunctionBodyAndFinish(node, bodilessType, isMethod);
@@ -12546,7 +12791,9 @@ var typescript = superClass => class extends superClass {
   tsCheckForInvalidTypeCasts(items) {
     items.forEach(node => {
       if ((node == null ? void 0 : node.type) === "TSTypeCastExpression") {
-        this.raise(node.typeAnnotation.start, TSErrors.UnexpectedTypeAnnotation);
+        this.raise(TSErrors.UnexpectedTypeAnnotation, {
+          node: node.typeAnnotation
+        });
       }
     });
   }
@@ -12588,7 +12835,7 @@ var typescript = superClass => class extends superClass {
     }
     if (this.match(45)) {
-      var missingParenErrorPos;
+      var missingParenErrorLoc;
       var result = this.tsTryParseAndCatch(() => {
         if (!noCalls && this.atPossibleAsyncArrow(base)) {
           var asyncArrowFn = this.tsTryParseGenericAsyncArrowFunction(startPos, startLoc);
@@ -12604,7 +12851,7 @@ var typescript = superClass => class extends superClass {
         if (typeArguments) {
           if (isOptionalCall && !this.match(10)) {
-            missingParenErrorPos = this.state.pos;
+            missingParenErrorLoc = this.state.curPosition();
             this.unexpected();
           }
@@ -12629,8 +12876,8 @@ var typescript = superClass => class extends superClass {
         this.unexpected();
       });
-      if (missingParenErrorPos) {
-        this.unexpected(missingParenErrorPos, 10);
+      if (missingParenErrorLoc) {
+        this.unexpected(missingParenErrorLoc, 10);
       }
       if (result) return result;
@@ -12700,7 +12947,9 @@ var typescript = superClass => class extends superClass {
     var importNode = super.parseImport(node);
     if (importNode.importKind === "type" && importNode.specifiers.length > 1 && importNode.specifiers[0].type === "ImportDefaultSpecifier") {
-      this.raise(importNode.start, TSErrors.TypeImportCannotSpecifyDefaultAndNamed);
+      this.raise(TSErrors.TypeImportCannotSpecifyDefaultAndNamed, {
+        node: importNode
+      });
     }
     return importNode;
@@ -12807,7 +13056,9 @@ var typescript = superClass => class extends superClass {
         this.next();
         if (this.tsHasSomeModifiers(member, modifiers)) {
-          this.raise(this.state.pos, TSErrors.StaticBlockCannotHaveModifier);
+          this.raise(TSErrors.StaticBlockCannotHaveModifier, {
+            at: this.state.curPosition()
+          });
         }
         this.parseClassStaticBlock(classBody, member);
@@ -12830,31 +13081,43 @@ var typescript = superClass => class extends superClass {
       classBody.body.push(idx);
       if (member.abstract) {
-        this.raise(member.start, TSErrors.IndexSignatureHasAbstract);
+        this.raise(TSErrors.IndexSignatureHasAbstract, {
+          node: member
+        });
       }
       if (member.accessibility) {
-        this.raise(member.start, TSErrors.IndexSignatureHasAccessibility, member.accessibility);
+        this.raise(TSErrors.IndexSignatureHasAccessibility, {
+          node: member
+        }, member.accessibility);
       }
       if (member.declare) {
-        this.raise(member.start, TSErrors.IndexSignatureHasDeclare);
+        this.raise(TSErrors.IndexSignatureHasDeclare, {
+          node: member
+        });
       }
       if (member.override) {
-        this.raise(member.start, TSErrors.IndexSignatureHasOverride);
+        this.raise(TSErrors.IndexSignatureHasOverride, {
+          node: member
+        });
       }
       return;
     }
     if (!this.state.inAbstractClass && member.abstract) {
-      this.raise(member.start, TSErrors.NonAbstractClassHasAbstractMethod);
+      this.raise(TSErrors.NonAbstractClassHasAbstractMethod, {
+        node: member
+      });
     }
     if (member.override) {
       if (!state.hadSuperClass) {
-        this.raise(member.start, TSErrors.OverrideNotInSubClass);
+        this.raise(TSErrors.OverrideNotInSubClass, {
+          node: member
+        });
       }
     }
@@ -12866,11 +13129,15 @@ var typescript = superClass => class extends superClass {
     if (optional) methodOrProp.optional = true;
     if (methodOrProp.readonly && this.match(10)) {
-      this.raise(methodOrProp.start, TSErrors.ClassMethodHasReadonly);
+      this.raise(TSErrors.ClassMethodHasReadonly, {
+        node: methodOrProp
+      });
     }
     if (methodOrProp.declare && this.match(10)) {
-      this.raise(methodOrProp.start, TSErrors.ClassMethodHasDeclare);
+      this.raise(TSErrors.ClassMethodHasDeclare, {
+        node: methodOrProp
+      });
     }
   }
@@ -12927,7 +13194,9 @@ var typescript = superClass => class extends superClass {
     var isDeclare = this.eatContextual(117);
     if (isDeclare && (this.isContextual(117) || !this.shouldParseExportDeclaration())) {
-      throw this.raise(this.state.start, TSErrors.ExpectedAmbientAfterExportDeclare);
+      throw this.raise(TSErrors.ExpectedAmbientAfterExportDeclare, {
+        at: this.state.startLoc
+      });
     }
     var declaration;
@@ -12975,14 +13244,18 @@ var typescript = superClass => class extends superClass {
     this.parseClassPropertyAnnotation(node);
     if (this.state.isAmbientContext && this.match(29)) {
-      this.raise(this.state.start, TSErrors.DeclareClassFieldHasInitializer);
+      this.raise(TSErrors.DeclareClassFieldHasInitializer, {
+        at: this.state.startLoc
+      });
     }
     if (node.abstract && this.match(29)) {
       var {
         key
       } = node;
-      this.raise(this.state.start, TSErrors.AbstractPropertyHasInitializer, key.type === "Identifier" && !node.computed ? key.name : "[".concat(this.input.slice(key.start, key.end), "]"));
+      this.raise(TSErrors.AbstractPropertyHasInitializer, {
+        at: this.state.startLoc
+      }, key.type === "Identifier" && !node.computed ? key.name : "[".concat(this.input.slice(key.start, key.end), "]"));
     }
     return super.parseClassProperty(node);
@@ -12990,11 +13263,15 @@ var typescript = superClass => class extends superClass {
   parseClassPrivateProperty(node) {
     if (node.abstract) {
-      this.raise(node.start, TSErrors.PrivateElementHasAbstract);
+      this.raise(TSErrors.PrivateElementHasAbstract, {
+        node
+      });
     }
     if (node.accessibility) {
-      this.raise(node.start, TSErrors.PrivateElementHasAccessibility, node.accessibility);
+      this.raise(TSErrors.PrivateElementHasAccessibility, {
+        node
+      }, node.accessibility);
     }
     this.parseClassPropertyAnnotation(node);
@@ -13005,11 +13282,15 @@ var typescript = superClass => class extends superClass {
     var typeParameters = this.tsTryParseTypeParameters();
     if (typeParameters && isConstructor) {
-      this.raise(typeParameters.start, TSErrors.ConstructorHasTypeParameters);
+      this.raise(TSErrors.ConstructorHasTypeParameters, {
+        node: typeParameters
+      });
     }
     if (method.declare && (method.kind === "get" || method.kind === "set")) {
-      this.raise(method.start, TSErrors.DeclareAccessor, method.kind);
+      this.raise(TSErrors.DeclareAccessor, {
+        node: method
+      }, method.kind);
     }
     if (typeParameters) method.typeParameters = typeParameters;
@@ -13060,7 +13341,7 @@ var typescript = superClass => class extends superClass {
   parseVarId(decl, kind) {
     super.parseVarId(decl, kind);
-    if (decl.id.type === "Identifier" && this.eat(35)) {
+    if (decl.id.type === "Identifier" && !this.hasPrecedingLineBreak() && this.eat(35)) {
       decl.definite = true;
     }
@@ -13166,7 +13447,9 @@ var typescript = superClass => class extends superClass {
     var _node$extra;
     if (node.params.length === 1 && !((_node$extra = node.extra) != null && _node$extra.trailingComma) && this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) {
-      this.raise(node.start, TSErrors.ReservedArrowTypeParam);
+      this.raise(TSErrors.ReservedArrowTypeParam, {
+        node
+      });
     }
   }
@@ -13199,7 +13482,9 @@ var typescript = superClass => class extends superClass {
   parseAssignableListItemTypes(param) {
     if (this.eat(17)) {
       if (param.type !== "Identifier" && !this.state.isAmbientContext && !this.state.inType) {
-        this.raise(param.start, TSErrors.PatternIsOptional);
+        this.raise(TSErrors.PatternIsOptional, {
+          node: param
+        });
       }
       param.optional = true;
@@ -13280,7 +13565,9 @@ var typescript = superClass => class extends superClass {
       case "TSAsExpression":
       case "TSTypeAssertion":
         if (!args[0] && contextDescription !== "parenthesized expression" && !((_expr$extra2 = expr.extra) != null && _expr$extra2.parenthesized)) {
-          this.raise(expr.start, ErrorMessages.InvalidLhs, contextDescription);
+          this.raise(ErrorMessages.InvalidLhs, {
+            node: expr
+          }, contextDescription);
           break;
         }
@@ -13317,7 +13604,7 @@ var typescript = superClass => class extends superClass {
         return call;
       }
-      this.unexpected(this.state.start, 10);
+      this.unexpected(null, 10);
     }
     return super.parseMaybeDecoratorArguments(expr);
@@ -13326,8 +13613,9 @@ var typescript = superClass => class extends superClass {
   checkCommaAfterRest(close) {
     if (this.state.isAmbientContext && this.match(12) && this.lookaheadCharCode() === close) {
       this.next();
+      return false;
     } else {
-      super.checkCommaAfterRest(close);
+      return super.checkCommaAfterRest(close);
     }
   }
@@ -13343,7 +13631,9 @@ var typescript = superClass => class extends superClass {
     var node = super.parseMaybeDefault(...arguments);
     if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) {
-      this.raise(node.typeAnnotation.start, TSErrors.TypeAnnotationAfterAssign);
+      this.raise(TSErrors.TypeAnnotationAfterAssign, {
+        node: node.typeAnnotation
+      });
     }
     return node;
@@ -13392,7 +13682,9 @@ var typescript = superClass => class extends superClass {
           if (!this.state.maybeInArrowParameters) {
             exprList[i] = this.typeCastToParameter(expr);
           } else {
-            this.raise(expr.start, TSErrors.UnexpectedTypeCastInParameter);
+            this.raise(TSErrors.UnexpectedTypeCastInParameter, {
+              node: expr
+            });
           }
           break;
@@ -13404,7 +13696,7 @@ var typescript = superClass => class extends superClass {
   typeCastToParameter(node) {
     node.expression.typeAnnotation = node.typeAnnotation;
-    this.resetEndLocation(node.expression, node.typeAnnotation.end, node.typeAnnotation.loc.end);
+    this.resetEndLocation(node.expression, node.typeAnnotation.loc.end);
     return node.expression;
   }
@@ -13486,7 +13778,9 @@ var typescript = superClass => class extends superClass {
     } else if (this.isContextual(121)) {
       if (!this.hasFollowingLineBreak()) {
         node.abstract = true;
-        this.raise(node.start, TSErrors.NonClassMethodPropertyHasAbstractModifer);
+        this.raise(TSErrors.NonClassMethodPropertyHasAbstractModifer, {
+          node
+        });
         this.next();
         return this.tsParseInterfaceDeclaration(node);
       }
@@ -13505,7 +13799,9 @@ var typescript = superClass => class extends superClass {
         var {
           key
         } = method;
-        this.raise(method.start, TSErrors.AbstractMethodHasImplementation, key.type === "Identifier" && !method.computed ? key.name : "[".concat(this.input.slice(key.start, key.end), "]"));
+        this.raise(TSErrors.AbstractMethodHasImplementation, {
+          node: method
+        }, key.type === "Identifier" && !method.computed ? key.name : "[".concat(this.input.slice(key.start, key.end), "]"));
       }
     }
@@ -13564,7 +13860,7 @@ var typescript = superClass => class extends superClass {
     var rightOfAs;
     var hasTypeSpecifier = false;
     var canParseAsKeyword = true;
-    var pos = leftOfAs.start;
+    var loc = leftOfAs.loc.start;
     if (this.isContextual(89)) {
       var firstAs = this.parseIdentifier();
@@ -13594,7 +13890,9 @@ var typescript = superClass => class extends superClass {
     }
     if (hasTypeSpecifier && isInTypeOnlyImportExport) {
-      this.raise(pos, isImport ? TSErrors.TypeModifierIsUsedInTypeImports : TSErrors.TypeModifierIsUsedInTypeExports);
+      this.raise(isImport ? TSErrors.TypeModifierIsUsedInTypeImports : TSErrors.TypeModifierIsUsedInTypeExports, {
+        at: loc
+      });
     }
     node[leftOfAsKey] = leftOfAs;
@@ -13617,9 +13915,9 @@ var typescript = superClass => class extends superClass {
 };
-var PlaceHolderErrors = makeErrorTemplates({
+var PlaceholderErrors = makeErrorTemplates({
   ClassNameIsRequired: "A class name is required."
-}, ErrorCodes.SyntaxError);
+}, ErrorCodes.SyntaxError, "placeholders");
 var placeholders = superClass => class extends superClass {
   parsePlaceholder(expectedNode) {
@@ -13742,7 +14040,9 @@ var placeholders = superClass => class extends superClass {
         node.body = this.finishPlaceholder(placeholder, "ClassBody");
         return this.finishNode(node, type);
       } else {
-        this.unexpected(null, PlaceHolderErrors.ClassNameIsRequired);
+        throw this.raise(PlaceholderErrors.ClassNameIsRequired, {
+          at: this.state.startLoc
+        });
       }
     } else {
       this.parseClassId(node, isStatement, optionalId);
@@ -13842,7 +14142,7 @@ var placeholders = superClass => class extends superClass {
 var v8intrinsic = superClass => class extends superClass {
   parseV8Intrinsic() {
     if (this.match(50)) {
-      var v8IntrinsicStart = this.state.start;
+      var v8IntrinsicStartLoc = this.state.startLoc;
       var node = this.startNode();
       this.next();
@@ -13856,7 +14156,7 @@ var v8intrinsic = superClass => class extends superClass {
         }
       }
-      this.unexpected(v8IntrinsicStart);
+      this.unexpected(v8IntrinsicStartLoc);
     }
   }
@@ -14050,12 +14350,16 @@ class LValParser extends NodeUtils {
       if (isLHS) {
         if (parenthesized.type === "Identifier") {
-          this.expressionScope.recordParenthesizedIdentifierError(node.start, ErrorMessages.InvalidParenthesizedAssignment);
+          this.expressionScope.recordParenthesizedIdentifierError(ErrorMessages.InvalidParenthesizedAssignment, node.loc.start);
         } else if (parenthesized.type !== "MemberExpression") {
-          this.raise(node.start, ErrorMessages.InvalidParenthesizedAssignment);
+          this.raise(ErrorMessages.InvalidParenthesizedAssignment, {
+            node
+          });
         }
       } else {
-        this.raise(node.start, ErrorMessages.InvalidParenthesizedAssignment);
+        this.raise(ErrorMessages.InvalidParenthesizedAssignment, {
+          node
+        });
       }
     }
@@ -14077,8 +14381,10 @@ class LValParser extends NodeUtils {
           var isLast = i === last;
           this.toAssignableObjectExpressionProp(prop, isLast, isLHS);
-          if (isLast && prop.type === "RestElement" && (_node$extra2 = node.extra) != null && _node$extra2.trailingComma) {
-            this.raiseRestNotLast(node.extra.trailingComma);
+          if (isLast && prop.type === "RestElement" && (_node$extra2 = node.extra) != null && _node$extra2.trailingCommaLoc) {
+            this.raise(ErrorMessages.RestTrailingComma, {
+              at: node.extra.trailingCommaLoc
+            });
           }
         }
@@ -14099,12 +14405,14 @@ class LValParser extends NodeUtils {
       case "ArrayExpression":
         node.type = "ArrayPattern";
-        this.toAssignableList(node.elements, (_node$extra3 = node.extra) == null ? void 0 : _node$extra3.trailingComma, isLHS);
+        this.toAssignableList(node.elements, (_node$extra3 = node.extra) == null ? void 0 : _node$extra3.trailingCommaLoc, isLHS);
         break;
       case "AssignmentExpression":
         if (node.operator !== "=") {
-          this.raise(node.left.end, ErrorMessages.MissingEqInAssignment);
+          this.raise(ErrorMessages.MissingEqInAssignment, {
+            at: node.left.loc.end
+          });
         }
         node.type = "AssignmentPattern";
@@ -14122,16 +14430,19 @@ class LValParser extends NodeUtils {
   toAssignableObjectExpressionProp(prop, isLast, isLHS) {
     if (prop.type === "ObjectMethod") {
-      var error = prop.kind === "get" || prop.kind === "set" ? ErrorMessages.PatternHasAccessor : ErrorMessages.PatternHasMethod;
-      this.raise(prop.key.start, error);
+      this.raise(prop.kind === "get" || prop.kind === "set" ? ErrorMessages.PatternHasAccessor : ErrorMessages.PatternHasMethod, {
+        node: prop.key
+      });
     } else if (prop.type === "SpreadElement" && !isLast) {
-      this.raiseRestNotLast(prop.start);
+      this.raise(ErrorMessages.RestTrailingComma, {
+        node: prop
+      });
     } else {
       this.toAssignable(prop, isLHS);
     }
   }
-  toAssignableList(exprList, trailingCommaPos, isLHS) {
+  toAssignableList(exprList, trailingCommaLoc, isLHS) {
     var end = exprList.length;
     if (end) {
@@ -14149,8 +14460,10 @@ class LValParser extends NodeUtils {
           this.unexpected(arg.start);
         }
-        if (trailingCommaPos) {
-          this.raiseTrailingCommaAfterRest(trailingCommaPos);
+        if (trailingCommaLoc) {
+          this.raise(ErrorMessages.RestTrailingComma, {
+            at: trailingCommaLoc
+          });
         }
         --end;
@@ -14164,7 +14477,9 @@ class LValParser extends NodeUtils {
         this.toAssignable(elt, isLHS);
         if (elt.type === "RestElement") {
-          this.raiseRestNotLast(elt.start);
+          this.raise(ErrorMessages.RestTrailingComma, {
+            node: elt
+          });
         }
       }
     }
@@ -14275,14 +14590,18 @@ class LValParser extends NodeUtils {
         break;
       } else if (this.match(21)) {
         elts.push(this.parseAssignableListItemTypes(this.parseRestBinding()));
-        this.checkCommaAfterRest(closeCharCode);
-        this.expect(close);
-        break;
+        if (!this.checkCommaAfterRest(closeCharCode)) {
+          this.expect(close);
+          break;
+        }
       } else {
         var decorators = [];
         if (this.match(26) && this.hasPlugin("decorators")) {
-          this.raise(this.state.start, ErrorMessages.UnsupportedParameterDecorator);
+          this.raise(ErrorMessages.UnsupportedParameterDecorator, {
+            at: this.state.startLoc
+          });
         }
         while (this.match(26)) {
@@ -14365,23 +14684,29 @@ class LValParser extends NodeUtils {
           } = expr;
           if (this.state.strict && (strictModeChanged ? isStrictBindReservedWord(name, this.inModule) : isStrictBindOnlyReservedWord(name))) {
-            this.raise(expr.start, bindingType === BIND_NONE ? ErrorMessages.StrictEvalArguments : ErrorMessages.StrictEvalArgumentsBinding, name);
+            this.raise(bindingType === BIND_NONE ? ErrorMessages.StrictEvalArguments : ErrorMessages.StrictEvalArgumentsBinding, {
+              node: expr
+            }, name);
           }
           if (checkClashes) {
             if (checkClashes.has(name)) {
-              this.raise(expr.start, ErrorMessages.ParamDupe);
+              this.raise(ErrorMessages.ParamDupe, {
+                node: expr
+              });
             } else {
               checkClashes.add(name);
             }
           }
           if (disallowLetBinding && name === "let") {
-            this.raise(expr.start, ErrorMessages.LetInLexicalBinding);
+            this.raise(ErrorMessages.LetInLexicalBinding, {
+              node: expr
+            });
           }
           if (!(bindingType & BIND_NONE)) {
-            this.scope.declareName(name, bindingType, expr.start);
+            this.scope.declareName(name, bindingType, expr.loc.start);
           }
           break;
@@ -14389,7 +14714,9 @@ class LValParser extends NodeUtils {
       case "MemberExpression":
         if (bindingType !== BIND_NONE) {
-          this.raise(expr.start, ErrorMessages.InvalidPropertyBindingPattern);
+          this.raise(ErrorMessages.InvalidPropertyBindingPattern, {
+            node: expr
+          });
         }
         break;
@@ -14425,33 +14752,30 @@ class LValParser extends NodeUtils {
       default:
         {
-          this.raise(expr.start, bindingType === BIND_NONE ? ErrorMessages.InvalidLhs : ErrorMessages.InvalidLhsBinding, contextDescription);
+          this.raise(bindingType === BIND_NONE ? ErrorMessages.InvalidLhs : ErrorMessages.InvalidLhsBinding, {
+            node: expr
+          }, contextDescription);
         }
     }
   }
   checkToRestConversion(node) {
     if (node.argument.type !== "Identifier" && node.argument.type !== "MemberExpression") {
-      this.raise(node.argument.start, ErrorMessages.InvalidRestAssignmentPattern);
+      this.raise(ErrorMessages.InvalidRestAssignmentPattern, {
+        node: node.argument
+      });
     }
   }
   checkCommaAfterRest(close) {
-    if (this.match(12)) {
-      if (this.lookaheadCharCode() === close) {
-        this.raiseTrailingCommaAfterRest(this.state.start);
-      } else {
-        this.raiseRestNotLast(this.state.start);
-      }
+    if (!this.match(12)) {
+      return false;
     }
-  }
-  raiseRestNotLast(pos) {
-    throw this.raise(pos, ErrorMessages.ElementAfterRest);
-  }
-  raiseTrailingCommaAfterRest(pos) {
-    this.raise(pos, ErrorMessages.RestTrailingComma);
+    this.raise(this.lookaheadCharCode() === close ? ErrorMessages.RestTrailingComma : ErrorMessages.ElementAfterRest, {
+      at: this.state.startLoc
+    });
+    return true;
   }
 }
@@ -14469,17 +14793,21 @@ class ExpressionParser extends LValParser {
     if (name === "__proto__") {
       if (isRecord) {
-        this.raise(key.start, ErrorMessages.RecordNoProto);
+        this.raise(ErrorMessages.RecordNoProto, {
+          node: key
+        });
         return;
       }
       if (protoRef.used) {
         if (refExpressionErrors) {
-          if (refExpressionErrors.doubleProto === -1) {
-            refExpressionErrors.doubleProto = key.start;
+          if (refExpressionErrors.doubleProtoLoc === null) {
+            refExpressionErrors.doubleProtoLoc = key.loc.start;
           }
         } else {
-          this.raise(key.start, ErrorMessages.DuplicateProto);
+          this.raise(ErrorMessages.DuplicateProto, {
+            node: key
+          });
         }
       }
@@ -14548,9 +14876,9 @@ class ExpressionParser extends LValParser {
   }
   setOptionalParametersError(refExpressionErrors, resultError) {
-    var _resultError$pos;
+    var _resultError$loc;
-    refExpressionErrors.optionalParameters = (_resultError$pos = resultError == null ? void 0 : resultError.pos) != null ? _resultError$pos : this.state.start;
+    refExpressionErrors.optionalParametersLoc = (_resultError$loc = resultError == null ? void 0 : resultError.loc) != null ? _resultError$loc : this.state.startLoc;
   }
   parseMaybeAssign(refExpressionErrors, afterLeftParse) {
@@ -14600,12 +14928,12 @@ class ExpressionParser extends LValParser {
       if (this.match(29)) {
         node.left = this.toAssignable(left, true);
-        if (refExpressionErrors.doubleProto >= startPos) {
-          refExpressionErrors.doubleProto = -1;
+        if (refExpressionErrors.doubleProtoLoc != null && indexes.get(refExpressionErrors.doubleProtoLoc) >= startPos) {
+          refExpressionErrors.doubleProtoLoc = null;
         }
-        if (refExpressionErrors.shorthandAssign >= startPos) {
-          refExpressionErrors.shorthandAssign = -1;
+        if (refExpressionErrors.shorthandAssignLoc != null && indexes.get(refExpressionErrors.shorthandAssignLoc) >= startPos) {
+          refExpressionErrors.shorthandAssignLoc = null;
         }
       } else {
         node.left = left;
@@ -14668,15 +14996,14 @@ class ExpressionParser extends LValParser {
   parseExprOp(left, leftStartPos, leftStartLoc, minPrec) {
     if (this.isPrivateName(left)) {
       var value = this.getPrivateNameSV(left);
-      var {
-        start
-      } = left;
       if (minPrec >= tokenOperatorPrecedence(54) || !this.prodParam.hasIn || !this.match(54)) {
-        this.raise(start, ErrorMessages.PrivateInExpectedIn, value);
+        this.raise(ErrorMessages.PrivateInExpectedIn, {
+          node: left
+        }, value);
       }
-      this.classScope.usePrivateName(value, start);
+      this.classScope.usePrivateName(value, left.loc.start);
     }
     var op = this.state.type;
@@ -14692,7 +15019,7 @@ class ExpressionParser extends LValParser {
             return left;
           }
-          this.checkPipelineAtInfixOperator(left, leftStartPos);
+          this.checkPipelineAtInfixOperator(left, leftStartLoc);
         }
         var node = this.startNodeAt(leftStartPos, leftStartLoc);
@@ -14711,7 +15038,9 @@ class ExpressionParser extends LValParser {
           proposal: "minimal"
         }])) {
           if (this.state.type === 92 && this.prodParam.hasAwait) {
-            throw this.raise(this.state.start, ErrorMessages.UnexpectedAwaitAfterPipelineBody);
+            throw this.raise(ErrorMessages.UnexpectedAwaitAfterPipelineBody, {
+              at: this.state.startLoc
+            });
           }
         }
@@ -14720,7 +15049,9 @@ class ExpressionParser extends LValParser {
         var nextOp = this.state.type;
         if (coalesce && (nextOp === 39 || nextOp === 40) || logical && nextOp === 38) {
-          throw this.raise(this.state.start, ErrorMessages.MixingCoalesceWithLogical);
+          throw this.raise(ErrorMessages.MixingCoalesceWithLogical, {
+            at: this.state.startLoc
+          });
         }
         return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec);
@@ -14745,7 +15076,9 @@ class ExpressionParser extends LValParser {
           case "smart":
             return this.withTopicBindingContext(() => {
               if (this.prodParam.hasYield && this.isContextual(101)) {
-                throw this.raise(this.state.start, ErrorMessages.PipeBodyIsTighter, this.state.value);
+                throw this.raise(ErrorMessages.PipeBodyIsTighter, {
+                  at: this.state.startLoc
+                }, this.state.value);
               }
               return this.parseSmartPipelineBodyInStyle(this.parseExprOpBaseRightExpr(op, prec), startPos, startLoc);
@@ -14772,16 +15105,20 @@ class ExpressionParser extends LValParser {
     var _body$extra;
     var {
-      start
+      startLoc
     } = this.state;
     var body = this.parseMaybeAssign();
     if (invalidHackPipeBodies.has(body.type) && !((_body$extra = body.extra) != null && _body$extra.parenthesized)) {
-      this.raise(start, ErrorMessages.PipeUnparenthesizedBody, invalidHackPipeBodies.get(body.type));
+      this.raise(ErrorMessages.PipeUnparenthesizedBody, {
+        at: startLoc
+      }, invalidHackPipeBodies.get(body.type));
     }
     if (!this.topicReferenceWasUsedInCurrentContext()) {
-      this.raise(start, ErrorMessages.PipeTopicUnused);
+      this.raise(ErrorMessages.PipeTopicUnused, {
+        at: startLoc
+      });
     }
     return body;
@@ -14789,7 +15126,9 @@ class ExpressionParser extends LValParser {
   checkExponentialAfterUnary(node) {
     if (this.match(53)) {
-      this.raise(node.argument.start, ErrorMessages.UnexpectedTokenUnaryExponentiation);
+      this.raise(ErrorMessages.UnexpectedTokenUnaryExponentiation, {
+        node: node.argument
+      });
     }
   }
@@ -14827,9 +15166,13 @@ class ExpressionParser extends LValParser {
         var arg = node.argument;
         if (arg.type === "Identifier") {
-          this.raise(node.start, ErrorMessages.StrictDelete);
+          this.raise(ErrorMessages.StrictDelete, {
+            node
+          });
         } else if (this.hasPropertyAsPrivateName(arg)) {
-          this.raise(node.start, ErrorMessages.DeletePrivateField);
+          this.raise(ErrorMessages.DeletePrivateField, {
+            node
+          });
         }
       }
@@ -14849,7 +15192,7 @@ class ExpressionParser extends LValParser {
       var _startsExpr = this.hasPlugin("v8intrinsic") ? tokenCanStartExpression(type) : tokenCanStartExpression(type) && !this.match(50);
       if (_startsExpr && !this.isAmbiguousAwait()) {
-        this.raiseOverwrite(startPos, ErrorMessages.AwaitNotInAsyncContext);
+        this.raiseOverwrite(startLoc, ErrorMessages.AwaitNotInAsyncContext);
         return this.parseAwait(startPos, startLoc);
       }
     }
@@ -14957,10 +15300,12 @@ class ExpressionParser extends LValParser {
       this.expect(3);
     } else if (this.match(130)) {
       if (base.type === "Super") {
-        this.raise(startPos, ErrorMessages.SuperPrivateField);
+        this.raise(ErrorMessages.SuperPrivateField, {
+          at: startLoc
+        });
       }
-      this.classScope.usePrivateName(this.state.value, this.state.start);
+      this.classScope.usePrivateName(this.state.value, this.state.startLoc);
       node.property = this.parsePrivateName();
     } else {
       node.property = this.parseIdentifier(true);
@@ -15036,14 +15381,16 @@ class ExpressionParser extends LValParser {
     node.quasi = this.parseTemplate(true);
     if (state.optionalChainMember) {
-      this.raise(startPos, ErrorMessages.OptionalChainingNoTemplate);
+      this.raise(ErrorMessages.OptionalChainingNoTemplate, {
+        at: startLoc
+      });
     }
     return this.finishNode(node, "TaggedTemplateExpression");
   }
   atPossibleAsyncArrow(base) {
-    return base.type === "Identifier" && base.name === "async" && this.state.lastTokEnd === base.end && !this.canInsertSemicolon() && base.end - base.start === 5 && base.start === this.state.potentialArrowAt;
+    return base.type === "Identifier" && base.name === "async" && indexes.get(this.state.lastTokEndLoc) === base.end && !this.canInsertSemicolon() && base.end - base.start === 5 && base.start === this.state.potentialArrowAt;
   }
   finishCallExpression(node, optional) {
@@ -15057,11 +15404,15 @@ class ExpressionParser extends LValParser {
       }
       if (node.arguments.length === 0 || node.arguments.length > 2) {
-        this.raise(node.start, ErrorMessages.ImportCallArity, this.hasPlugin("importAssertions") || this.hasPlugin("moduleAttributes") ? "one or two arguments" : "one argument");
+        this.raise(ErrorMessages.ImportCallArity, {
+          node
+        }, this.hasPlugin("importAssertions") || this.hasPlugin("moduleAttributes") ? "one or two arguments" : "one argument");
       } else {
         for (var arg of node.arguments) {
           if (arg.type === "SpreadElement") {
-            this.raise(arg.start, ErrorMessages.ImportCallSpreadArgument);
+            this.raise(ErrorMessages.ImportCallSpreadArgument, {
+              node: arg
+            });
           }
         }
       }
@@ -15084,11 +15435,13 @@ class ExpressionParser extends LValParser {
         if (this.match(close)) {
           if (dynamicImport && !this.hasPlugin("importAssertions") && !this.hasPlugin("moduleAttributes")) {
-            this.raise(this.state.lastTokStart, ErrorMessages.ImportCallArgumentTrailingComma);
+            this.raise(ErrorMessages.ImportCallArgumentTrailingComma, {
+              at: this.state.lastTokStartLoc
+            });
           }
           if (nodeForExtra) {
-            this.addExtra(nodeForExtra, "trailingComma", this.state.lastTokStart);
+            this.addTrailingCommaExtraToNode(nodeForExtra);
           }
           this.next();
@@ -15112,7 +15465,7 @@ class ExpressionParser extends LValParser {
     this.resetPreviousNodeTrailingComments(call);
     this.expect(19);
-    this.parseArrowExpression(node, call.arguments, true, (_call$extra = call.extra) == null ? void 0 : _call$extra.trailingComma);
+    this.parseArrowExpression(node, call.arguments, true, (_call$extra = call.extra) == null ? void 0 : _call$extra.trailingCommaLoc);
     if (call.innerComments) {
       setInnerComments(node, call.innerComments);
@@ -15150,7 +15503,9 @@ class ExpressionParser extends LValParser {
         }
         if (!this.match(10)) {
-          this.raise(this.state.lastTokStart, ErrorMessages.UnsupportedImport);
+          this.raise(ErrorMessages.UnsupportedImport, {
+            at: this.state.lastTokStartLoc
+          });
         }
         return this.finishNode(node, "Import");
@@ -15249,13 +15604,17 @@ class ExpressionParser extends LValParser {
           if (callee.type === "MemberExpression") {
             return this.finishNode(node, "BindExpression");
           } else {
-            throw this.raise(callee.start, ErrorMessages.UnsupportedBind);
+            throw this.raise(ErrorMessages.UnsupportedBind, {
+              node: callee
+            });
           }
         }
       case 130:
         {
-          this.raise(this.state.start, ErrorMessages.PrivateInExpectedIn, this.state.value);
+          this.raise(ErrorMessages.PrivateInExpectedIn, {
+            at: this.state.startLoc
+          }, this.state.value);
           return this.parsePrivateName();
         }
@@ -15347,7 +15706,7 @@ class ExpressionParser extends LValParser {
       this.state.value = topicTokenValue;
       this.state.pos--;
       this.state.end--;
-      this.state.endLoc.column--;
+      this.state.endLoc = createPositionWithColumnOffset(this.state.endLoc, -1);
       return this.parseTopicReference(pipeProposal);
     } else {
       throw this.unexpected();
@@ -15356,38 +15715,32 @@ class ExpressionParser extends LValParser {
   parseTopicReference(pipeProposal) {
     var node = this.startNode();
-    var start = this.state.start;
+    var startLoc = this.state.startLoc;
     var tokenType = this.state.type;
     this.next();
-    return this.finishTopicReference(node, start, pipeProposal, tokenType);
+    return this.finishTopicReference(node, startLoc, pipeProposal, tokenType);
   }
-  finishTopicReference(node, start, pipeProposal, tokenType) {
-    if (this.testTopicReferenceConfiguration(pipeProposal, start, tokenType)) {
-      var nodeType;
-      if (pipeProposal === "smart") {
-        nodeType = "PipelinePrimaryTopicReference";
-      } else {
-        nodeType = "TopicReference";
-      }
+  finishTopicReference(node, startLoc, pipeProposal, tokenType) {
+    if (this.testTopicReferenceConfiguration(pipeProposal, startLoc, tokenType)) {
+      var nodeType = pipeProposal === "smart" ? "PipelinePrimaryTopicReference" : "TopicReference";
       if (!this.topicReferenceIsAllowedInCurrentContext()) {
-        if (pipeProposal === "smart") {
-          this.raise(start, ErrorMessages.PrimaryTopicNotAllowed);
-        } else {
-          this.raise(start, ErrorMessages.PipeTopicUnbound);
-        }
+        this.raise(pipeProposal === "smart" ? ErrorMessages.PrimaryTopicNotAllowed : ErrorMessages.PipeTopicUnbound, {
+          at: startLoc
+        });
       }
       this.registerTopicReference();
       return this.finishNode(node, nodeType);
     } else {
-      throw this.raise(start, ErrorMessages.PipeTopicUnconfiguredToken, tokenLabelName(tokenType));
+      throw this.raise(ErrorMessages.PipeTopicUnconfiguredToken, {
+        at: startLoc
+      }, tokenLabelName(tokenType));
     }
   }
-  testTopicReferenceConfiguration(pipeProposal, start, tokenType) {
+  testTopicReferenceConfiguration(pipeProposal, startLoc, tokenType) {
     switch (pipeProposal) {
       case "hack":
         {
@@ -15400,7 +15753,9 @@ class ExpressionParser extends LValParser {
         return tokenType === 27;
       default:
-        throw this.raise(start, ErrorMessages.PipeTopicRequiresHackPipes);
+        throw this.raise(ErrorMessages.PipeTopicRequiresHackPipes, {
+          at: startLoc
+        });
     }
   }
@@ -15410,7 +15765,9 @@ class ExpressionParser extends LValParser {
     this.prodParam.exit();
     if (this.hasPrecedingLineBreak()) {
-      this.raise(this.state.pos, ErrorMessages.LineTerminatorBeforeArrow);
+      this.raise(ErrorMessages.LineTerminatorBeforeArrow, {
+        at: this.state.curPosition()
+      });
     }
     this.expect(19);
@@ -15447,13 +15804,19 @@ class ExpressionParser extends LValParser {
     this.next();
     if (this.match(10) && !this.scope.allowDirectSuper && !this.options.allowSuperOutsideMethod) {
-      this.raise(node.start, ErrorMessages.SuperNotAllowed);
+      this.raise(ErrorMessages.SuperNotAllowed, {
+        node
+      });
     } else if (!this.scope.allowSuper && !this.options.allowSuperOutsideMethod) {
-      this.raise(node.start, ErrorMessages.UnexpectedSuper);
+      this.raise(ErrorMessages.UnexpectedSuper, {
+        node
+      });
     }
     if (!this.match(10) && !this.match(0) && !this.match(16)) {
-      this.raise(node.start, ErrorMessages.UnsupportedSuper);
+      this.raise(ErrorMessages.UnsupportedSuper, {
+        node
+      });
     }
     return this.finishNode(node, "Super");
@@ -15461,7 +15824,7 @@ class ExpressionParser extends LValParser {
   parsePrivateName() {
     var node = this.startNode();
-    var id = this.startNodeAt(this.state.start + 1, new Position(this.state.curLine, this.state.start + 1 - this.state.lineStart));
+    var id = this.startNodeAt(this.state.start + 1, new Position(this.state.curLine, this.state.start + 1 - this.state.lineStart, this.state.start + 1));
     var name = this.state.value;
     this.next();
     node.id = this.createIdentifier(id, name);
@@ -15494,7 +15857,9 @@ class ExpressionParser extends LValParser {
     node.property = this.parseIdentifier(true);
     if (node.property.name !== propertyName || containsEsc) {
-      this.raise(node.property.start, ErrorMessages.UnsupportedMetaProperty, meta.name, propertyName);
+      this.raise(ErrorMessages.UnsupportedMetaProperty, {
+        node: node.property
+      }, meta.name, propertyName);
     }
     return this.finishNode(node, "MetaProperty");
@@ -15506,7 +15871,9 @@ class ExpressionParser extends LValParser {
     if (this.isContextual(96)) {
       if (!this.inModule) {
-        this.raise(id.start, SourceTypeModuleErrorMessages.ImportMetaOutsideModule);
+        this.raise(SourceTypeModuleErrorMessages.ImportMetaOutsideModule, {
+          node: id
+        });
       }
       this.sawUnambiguousESM = true;
@@ -15579,17 +15946,17 @@ class ExpressionParser extends LValParser {
     var exprList = [];
     var refExpressionErrors = new ExpressionErrors();
     var first = true;
-    var spreadStart;
-    var optionalCommaStart;
+    var spreadStartLoc;
+    var optionalCommaStartLoc;
     while (!this.match(11)) {
       if (first) {
         first = false;
       } else {
-        this.expect(12, refExpressionErrors.optionalParameters === -1 ? null : refExpressionErrors.optionalParameters);
+        this.expect(12, refExpressionErrors.optionalParametersLoc === null ? null : refExpressionErrors.optionalParametersLoc);
         if (this.match(11)) {
-          optionalCommaStart = this.state.start;
+          optionalCommaStartLoc = this.state.startLoc;
           break;
         }
       }
@@ -15597,16 +15964,17 @@ class ExpressionParser extends LValParser {
       if (this.match(21)) {
         var spreadNodeStartPos = this.state.start;
         var spreadNodeStartLoc = this.state.startLoc;
-        spreadStart = this.state.start;
+        spreadStartLoc = this.state.startLoc;
         exprList.push(this.parseParenItem(this.parseRestBinding(), spreadNodeStartPos, spreadNodeStartLoc));
-        this.checkCommaAfterRest(41);
-        break;
+        if (!this.checkCommaAfterRest(41)) {
+          break;
+        }
       } else {
         exprList.push(this.parseMaybeAssignAllowIn(refExpressionErrors, this.parseParenItem));
       }
     }
-    var innerEndPos = this.state.lastTokEnd;
     var innerEndLoc = this.state.lastTokEndLoc;
     this.expect(11);
     this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
@@ -15623,11 +15991,11 @@ class ExpressionParser extends LValParser {
     this.expressionScope.exit();
     if (!exprList.length) {
-      this.unexpected(this.state.lastTokStart);
+      this.unexpected(this.state.lastTokStartLoc);
     }
-    if (optionalCommaStart) this.unexpected(optionalCommaStart);
-    if (spreadStart) this.unexpected(spreadStart);
+    if (optionalCommaStartLoc) this.unexpected(optionalCommaStartLoc);
+    if (spreadStartLoc) this.unexpected(spreadStartLoc);
     this.checkExpressionErrors(refExpressionErrors, true);
     this.toReferencedListDeep(exprList, true);
@@ -15635,7 +16003,7 @@ class ExpressionParser extends LValParser {
       val = this.startNodeAt(innerStartPos, innerStartLoc);
       val.expressions = exprList;
       this.finishNode(val, "SequenceExpression");
-      this.resetEndLocation(val, innerEndPos, innerEndLoc);
+      this.resetEndLocation(val, innerEndLoc);
     } else {
       val = exprList[0];
     }
@@ -15643,7 +16011,7 @@ class ExpressionParser extends LValParser {
     if (!this.options.createParenthesizedExpressions) {
       this.addExtra(val, "parenthesized", true);
       this.addExtra(val, "parenStart", startPos);
-      this.takeSurroundingComments(val, startPos, this.state.lastTokEnd);
+      this.takeSurroundingComments(val, startPos, indexes.get(this.state.lastTokEndLoc));
       return val;
     }
@@ -15677,7 +16045,9 @@ class ExpressionParser extends LValParser {
       var metaProp = this.parseMetaProperty(node, meta, "target");
       if (!this.scope.inNonArrowFunction && !this.scope.inClass) {
-        this.raise(metaProp.start, ErrorMessages.UnexpectedNewTarget);
+        this.raise(ErrorMessages.UnexpectedNewTarget, {
+          node: metaProp
+        });
       }
       return metaProp;
@@ -15690,11 +16060,17 @@ class ExpressionParser extends LValParser {
     node.callee = this.parseNoCallExpr();
     if (node.callee.type === "Import") {
-      this.raise(node.callee.start, ErrorMessages.ImportCallNotNewExpression);
+      this.raise(ErrorMessages.ImportCallNotNewExpression, {
+        node: node.callee
+      });
     } else if (this.isOptionalChain(node.callee)) {
-      this.raise(this.state.lastTokEnd, ErrorMessages.OptionalChainingNoNew);
+      this.raise(ErrorMessages.OptionalChainingNoNew, {
+        at: this.state.lastTokEndLoc
+      });
     } else if (this.eat(18)) {
-      this.raise(this.state.start, ErrorMessages.OptionalChainingNoNew);
+      this.raise(ErrorMessages.OptionalChainingNoNew, {
+        at: this.state.startLoc
+      });
     }
     this.parseNewArguments(node);
@@ -15714,15 +16090,18 @@ class ExpressionParser extends LValParser {
   parseTemplateElement(isTagged) {
     var {
       start,
+      startLoc,
       end,
       value
     } = this.state;
     var elemStart = start + 1;
-    var elem = this.startNodeAt(elemStart, createPositionWithColumnOffset(this.state.startLoc, 1));
+    var elem = this.startNodeAt(elemStart, createPositionWithColumnOffset(startLoc, 1));
     if (value === null) {
       if (!isTagged) {
-        this.raise(start + 2, ErrorMessages.InvalidEscapeSequenceTemplate);
+        this.raise(ErrorMessages.InvalidEscapeSequenceTemplate, {
+          at: createPositionWithColumnOffset(startLoc, 2)
+        });
       }
     }
@@ -15736,7 +16115,7 @@ class ExpressionParser extends LValParser {
     elem.tail = isTail;
     this.next();
     this.finishNode(elem, "TemplateElement");
-    this.resetEndLocation(elem, elemEnd, createPositionWithColumnOffset(this.state.lastTokEndLoc, endOffset));
+    this.resetEndLocation(elem, createPositionWithColumnOffset(this.state.lastTokEndLoc, endOffset));
     return elem;
   }
@@ -15779,7 +16158,7 @@ class ExpressionParser extends LValParser {
         this.expect(12);
         if (this.match(close)) {
-          this.addExtra(node, "trailingComma", this.state.lastTokStart);
+          this.addTrailingCommaExtraToNode(node);
           break;
         }
       }
@@ -15794,7 +16173,9 @@ class ExpressionParser extends LValParser {
       }
       if (isRecord && !this.isObjectProperty(prop) && prop.type !== "SpreadElement") {
-        this.raise(prop.start, ErrorMessages.InvalidRecordProperty);
+        this.raise(ErrorMessages.InvalidRecordProperty, {
+          node: prop
+        });
       }
       if (prop.shorthand) {
@@ -15817,6 +16198,11 @@ class ExpressionParser extends LValParser {
     return this.finishNode(node, type);
   }
+  addTrailingCommaExtraToNode(node) {
+    this.addExtra(node, "trailingComma", this.state.lastTokStart);
+    this.addExtra(node, "trailingCommaLoc", this.state.lastTokStartLoc, false);
+  }
   maybeAsyncOrAccessorProp(prop) {
     return !prop.computed && prop.key.type === "Identifier" && (this.isLiteralPropertyName() || this.match(0) || this.match(51));
   }
@@ -15826,7 +16212,9 @@ class ExpressionParser extends LValParser {
     if (this.match(26)) {
       if (this.hasPlugin("decorators")) {
-        this.raise(this.state.start, ErrorMessages.UnsupportedPropertyDecorator);
+        this.raise(ErrorMessages.UnsupportedPropertyDecorator, {
+          at: this.state.startLoc
+        });
       }
       while (this.match(26)) {
@@ -15879,7 +16267,9 @@ class ExpressionParser extends LValParser {
         if (this.match(51)) {
           isGenerator = true;
-          this.raise(this.state.pos, ErrorMessages.AccessorIsGenerator, keyName);
+          this.raise(ErrorMessages.AccessorIsGenerator, {
+            at: this.state.curPosition()
+          }, keyName);
           this.next();
         }
@@ -15904,18 +16294,17 @@ class ExpressionParser extends LValParser {
     var paramCount = this.getGetterSetterExpectedParamCount(method);
     var params = this.getObjectOrClassMethodParams(method);
-    var start = method.start;
     if (params.length !== paramCount) {
-      if (method.kind === "get") {
-        this.raise(start, ErrorMessages.BadGetterArity);
-      } else {
-        this.raise(start, ErrorMessages.BadSetterArity);
-      }
+      this.raise(method.kind === "get" ? ErrorMessages.BadGetterArity : ErrorMessages.BadSetterArity, {
+        node: method
+      });
     }
     if (method.kind === "set" && ((_params = params[params.length - 1]) == null ? void 0 : _params.type) === "RestElement") {
-      this.raise(start, ErrorMessages.BadSetterRestParameter);
+      this.raise(ErrorMessages.BadSetterRestParameter, {
+        node: method
+      });
     }
   }
@@ -15943,19 +16332,21 @@ class ExpressionParser extends LValParser {
     }
     if (!prop.computed && prop.key.type === "Identifier") {
-      this.checkReservedWord(prop.key.name, prop.key.start, true, false);
+      this.checkReservedWord(prop.key.name, prop.key.loc.start, true, false);
       if (isPattern) {
         prop.value = this.parseMaybeDefault(startPos, startLoc, cloneIdentifier(prop.key));
       } else if (this.match(29)) {
-        var shorthandAssign = this.state.start;
+        var shorthandAssignLoc = this.state.startLoc;
         if (refExpressionErrors != null) {
-          if (refExpressionErrors.shorthandAssign === -1) {
-            refExpressionErrors.shorthandAssign = shorthandAssign;
+          if (refExpressionErrors.shorthandAssignLoc === null) {
+            refExpressionErrors.shorthandAssignLoc = shorthandAssignLoc;
           }
         } else {
-          this.raise(shorthandAssign, ErrorMessages.InvalidCoverInitializedName);
+          this.raise(ErrorMessages.InvalidCoverInitializedName, {
+            at: shorthandAssignLoc
+          });
         }
         prop.value = this.parseMaybeDefault(startPos, startLoc, cloneIdentifier(prop.key));
@@ -16008,8 +16399,9 @@ class ExpressionParser extends LValParser {
           case 130:
             {
-              var privateKeyPos = this.state.start + 1;
-              this.raise(privateKeyPos, ErrorMessages.UnexpectedPrivateField);
+              this.raise(ErrorMessages.UnexpectedPrivateField, {
+                at: createPositionWithColumnOffset(this.state.startLoc, 1)
+              });
               key = this.parsePrivateName();
               break;
             }
@@ -16063,11 +16455,11 @@ class ExpressionParser extends LValParser {
     return this.finishNode(node, isTuple ? "TupleExpression" : "ArrayExpression");
   }
-  parseArrowExpression(node, params, isAsync, trailingCommaPos) {
+  parseArrowExpression(node, params, isAsync, trailingCommaLoc) {
     this.scope.enter(SCOPE_FUNCTION | SCOPE_ARROW);
     var flags = functionFlags(isAsync, false);
-    if (!this.match(0) && this.prodParam.hasIn) {
+    if (!this.match(5) && this.prodParam.hasIn) {
       flags |= PARAM_IN;
     }
@@ -16077,7 +16469,7 @@ class ExpressionParser extends LValParser {
     if (params) {
       this.state.maybeInArrowParameters = true;
-      this.setArrowFunctionParameters(node, params, trailingCommaPos);
+      this.setArrowFunctionParameters(node, params, trailingCommaLoc);
     }
     this.state.maybeInArrowParameters = false;
@@ -16088,8 +16480,8 @@ class ExpressionParser extends LValParser {
     return this.finishNode(node, "ArrowFunctionExpression");
   }
-  setArrowFunctionParameters(node, params, trailingCommaPos) {
-    node.params = this.toAssignableList(params, trailingCommaPos, false);
+  setArrowFunctionParameters(node, params, trailingCommaLoc) {
+    node.params = this.toAssignableList(params, trailingCommaLoc, false);
   }
   parseFunctionBodyAndFinish(node, type) {
@@ -16115,8 +16507,12 @@ class ExpressionParser extends LValParser {
         var nonSimple = !this.isSimpleParamList(node.params);
         if (hasStrictModeDirective && nonSimple) {
-          var errorPos = (node.kind === "method" || node.kind === "constructor") && !!node.key ? node.key.end : node.start;
-          this.raise(errorPos, ErrorMessages.IllegalLanguageModeDirective);
+          var errorOrigin = (node.kind === "method" || node.kind === "constructor") && !!node.key ? {
+            at: node.key.loc.end
+          } : {
+            node
+          };
+          this.raise(ErrorMessages.IllegalLanguageModeDirective, errorOrigin);
         }
         var strictModeChanged = !oldStrict && this.state.strict;
@@ -16162,7 +16558,7 @@ class ExpressionParser extends LValParser {
         if (this.match(close)) {
           if (nodeForExtra) {
-            this.addExtra(nodeForExtra, "trailingComma", this.state.lastTokStart);
+            this.addTrailingCommaExtraToNode(nodeForExtra);
           }
           this.next();
@@ -16181,7 +16577,9 @@ class ExpressionParser extends LValParser {
     if (this.match(12)) {
       if (!allowEmpty) {
-        this.raise(this.state.pos, ErrorMessages.UnexpectedToken, ",");
+        this.raise(ErrorMessages.UnexpectedToken, {
+          at: this.state.curPosition()
+        }, ",");
       }
       elt = null;
@@ -16193,7 +16591,9 @@ class ExpressionParser extends LValParser {
       this.expectPlugin("partialApplication");
       if (!allowPlaceholder) {
-        this.raise(this.state.start, ErrorMessages.UnexpectedArgumentPlaceholder);
+        this.raise(ErrorMessages.UnexpectedArgumentPlaceholder, {
+          at: this.state.startLoc
+        });
       }
       var node = this.startNode();
@@ -16221,7 +16621,7 @@ class ExpressionParser extends LValParser {
   parseIdentifierName(pos, liberal) {
     var name;
     var {
-      start,
+      startLoc,
       type
     } = this.state;
@@ -16238,7 +16638,7 @@ class ExpressionParser extends LValParser {
         this.replaceToken(124);
       }
     } else {
-      this.checkReservedWord(name, start, tokenIsKeyword, false);
+      this.checkReservedWord(name, startLoc, tokenIsKeyword, false);
     }
     this.next();
@@ -16256,35 +16656,49 @@ class ExpressionParser extends LValParser {
     if (word === "yield") {
       if (this.prodParam.hasYield) {
-        this.raise(startLoc, ErrorMessages.YieldBindingIdentifier);
+        this.raise(ErrorMessages.YieldBindingIdentifier, {
+          at: startLoc
+        });
         return;
       }
     } else if (word === "await") {
       if (this.prodParam.hasAwait) {
-        this.raise(startLoc, ErrorMessages.AwaitBindingIdentifier);
+        this.raise(ErrorMessages.AwaitBindingIdentifier, {
+          at: startLoc
+        });
         return;
-      } else if (this.scope.inStaticBlock) {
-        this.raise(startLoc, ErrorMessages.AwaitBindingIdentifierInStaticBlock);
+      }
+      if (this.scope.inStaticBlock) {
+        this.raise(ErrorMessages.AwaitBindingIdentifierInStaticBlock, {
+          at: startLoc
+        });
         return;
-      } else {
-        this.expressionScope.recordAsyncArrowParametersError(startLoc, ErrorMessages.AwaitBindingIdentifier);
       }
+      this.expressionScope.recordAsyncArrowParametersError(ErrorMessages.AwaitBindingIdentifier, startLoc);
     } else if (word === "arguments") {
       if (this.scope.inClassAndNotInNonArrowFunction) {
-        this.raise(startLoc, ErrorMessages.ArgumentsInClass);
+        this.raise(ErrorMessages.ArgumentsInClass, {
+          at: startLoc
+        });
         return;
       }
     }
     if (checkKeywords && isKeyword(word)) {
-      this.raise(startLoc, ErrorMessages.UnexpectedKeyword, word);
+      this.raise(ErrorMessages.UnexpectedKeyword, {
+        at: startLoc
+      }, word);
       return;
     }
     var reservedTest = !this.state.strict ? isReservedWord : isBinding ? isStrictBindReservedWord : isStrictReservedWord;
     if (reservedTest(word, this.inModule)) {
-      this.raise(startLoc, ErrorMessages.UnexpectedReservedWord, word);
+      this.raise(ErrorMessages.UnexpectedReservedWord, {
+        at: startLoc
+      }, word);
     }
   }
@@ -16300,10 +16714,12 @@ class ExpressionParser extends LValParser {
   parseAwait(startPos, startLoc) {
     var node = this.startNodeAt(startPos, startLoc);
-    this.expressionScope.recordParameterInitializerError(node.start, ErrorMessages.AwaitExpressionFormalParameter);
+    this.expressionScope.recordParameterInitializerError(node.loc.start, ErrorMessages.AwaitExpressionFormalParameter);
     if (this.eat(51)) {
-      this.raise(node.start, ErrorMessages.ObsoleteAwaitStar);
+      this.raise(ErrorMessages.ObsoleteAwaitStar, {
+        node
+      });
     }
     if (!this.scope.inFunction && !this.options.allowAwaitOutsideFunction) {
@@ -16331,7 +16747,7 @@ class ExpressionParser extends LValParser {
   parseYield() {
     var node = this.startNode();
-    this.expressionScope.recordParameterInitializerError(node.start, ErrorMessages.YieldInParameter);
+    this.expressionScope.recordParameterInitializerError(node.loc.start, ErrorMessages.YieldInParameter);
     this.next();
     var delegating = false;
     var argument = null;
@@ -16360,22 +16776,18 @@ class ExpressionParser extends LValParser {
     return this.finishNode(node, "YieldExpression");
   }
-  checkPipelineAtInfixOperator(left, leftStartPos) {
+  checkPipelineAtInfixOperator(left, leftStartLoc) {
     if (this.hasPlugin(["pipelineOperator", {
       proposal: "smart"
     }])) {
       if (left.type === "SequenceExpression") {
-        this.raise(leftStartPos, ErrorMessages.PipelineHeadSequenceExpression);
+        this.raise(ErrorMessages.PipelineHeadSequenceExpression, {
+          at: leftStartLoc
+        });
       }
     }
   }
-  checkHackPipeBodyEarlyErrors(startPos) {
-    if (!this.topicReferenceWasUsedInCurrentContext()) {
-      this.raise(startPos, ErrorMessages.PipeTopicUnused);
-    }
-  }
   parseSmartPipelineBodyInStyle(childExpr, startPos, startLoc) {
     var bodyNode = this.startNodeAt(startPos, startLoc);
@@ -16383,7 +16795,7 @@ class ExpressionParser extends LValParser {
       bodyNode.callee = childExpr;
       return this.finishNode(bodyNode, "PipelineBareFunction");
     } else {
-      this.checkSmartPipeTopicBodyEarlyErrors(startPos);
+      this.checkSmartPipeTopicBodyEarlyErrors(startLoc);
       bodyNode.expression = childExpr;
       return this.finishNode(bodyNode, "PipelineTopicExpression");
     }
@@ -16402,11 +16814,17 @@ class ExpressionParser extends LValParser {
     }
   }
-  checkSmartPipeTopicBodyEarlyErrors(startPos) {
+  checkSmartPipeTopicBodyEarlyErrors(startLoc) {
     if (this.match(19)) {
-      throw this.raise(this.state.start, ErrorMessages.PipelineBodyNoArrow);
-    } else if (!this.topicReferenceWasUsedInCurrentContext()) {
-      this.raise(startPos, ErrorMessages.PipelineTopicUnused);
+      throw this.raise(ErrorMessages.PipelineBodyNoArrow, {
+        at: this.state.startLoc
+      });
+    }
+    if (!this.topicReferenceWasUsedInCurrentContext()) {
+      this.raise(ErrorMessages.PipelineTopicUnused, {
+        at: startLoc
+      });
     }
   }
@@ -16686,9 +17104,10 @@ class StatementParser extends ExpressionParser {
     this.parseBlockBody(program, true, true, end);
     if (this.inModule && !this.options.allowUndeclaredExports && this.scope.undefinedExports.size > 0) {
-      for (var [name] of Array.from(this.scope.undefinedExports)) {
-        var pos = this.scope.undefinedExports.get(name);
-        this.raise(pos, ErrorMessages.ModuleExportUndefined, name);
+      for (var [name, loc] of Array.from(this.scope.undefinedExports)) {
+        this.raise(ErrorMessages.ModuleExportUndefined, {
+          at: loc
+        }, name);
       }
     }
@@ -16797,9 +17216,13 @@ class StatementParser extends ExpressionParser {
         if (context) {
           if (this.state.strict) {
-            this.raise(this.state.start, ErrorMessages.StrictFunction);
+            this.raise(ErrorMessages.StrictFunction, {
+              at: this.state.startLoc
+            });
           } else if (context !== "if" && context !== "label") {
-            this.raise(this.state.start, ErrorMessages.SloppyFunction);
+            this.raise(ErrorMessages.SloppyFunction, {
+              at: this.state.startLoc
+            });
           }
         }
@@ -16829,7 +17252,9 @@ class StatementParser extends ExpressionParser {
         kind = kind || this.state.value;
         if (context && kind !== "var") {
-          this.raise(this.state.start, ErrorMessages.UnexpectedLexicalDeclaration);
+          this.raise(ErrorMessages.UnexpectedLexicalDeclaration, {
+            at: this.state.startLoc
+          });
         }
         return this.parseVarStatement(node, kind);
@@ -16858,7 +17283,9 @@ class StatementParser extends ExpressionParser {
       case 78:
         {
           if (!this.options.allowImportExportEverywhere && !topLevel) {
-            this.raise(this.state.start, ErrorMessages.UnexpectedImportExport);
+            this.raise(ErrorMessages.UnexpectedImportExport, {
+              at: this.state.startLoc
+            });
           }
           this.next();
@@ -16886,7 +17313,9 @@ class StatementParser extends ExpressionParser {
         {
           if (this.isAsyncFunction()) {
             if (context) {
-              this.raise(this.state.start, ErrorMessages.AsyncFunctionInSingleStatementContext);
+              this.raise(ErrorMessages.AsyncFunctionInSingleStatementContext, {
+                at: this.state.startLoc
+              });
             }
             this.next();
@@ -16907,7 +17336,9 @@ class StatementParser extends ExpressionParser {
   assertModuleNodeAllowed(node) {
     if (!this.options.allowImportExportEverywhere && !this.inModule) {
-      this.raise(node.start, SourceTypeModuleErrorMessages.ImportOutsideModule);
+      this.raise(SourceTypeModuleErrorMessages.ImportOutsideModule, {
+        node
+      });
     }
   }
@@ -16939,10 +17370,14 @@ class StatementParser extends ExpressionParser {
       }
       if (this.hasPlugin("decorators") && !this.getPluginOption("decorators", "decoratorsBeforeExport")) {
-        this.raise(this.state.start, ErrorMessages.DecoratorExportClass);
+        this.raise(ErrorMessages.DecoratorExportClass, {
+          at: this.state.startLoc
+        });
       }
     } else if (!this.canHaveLeadingDecorator()) {
-      throw this.raise(this.state.start, ErrorMessages.UnexpectedLeadingDecorator);
+      throw this.raise(ErrorMessages.UnexpectedLeadingDecorator, {
+        at: this.state.startLoc
+      });
     }
   }
@@ -17021,7 +17456,9 @@ class StatementParser extends ExpressionParser {
     }
     if (i === this.state.labels.length) {
-      this.raise(node.start, ErrorMessages.IllegalBreakContinue, isBreak ? "break" : "continue");
+      this.raise(ErrorMessages.IllegalBreakContinue, {
+        node
+      }, isBreak ? "break" : "continue");
     }
   }
@@ -17052,17 +17489,17 @@ class StatementParser extends ExpressionParser {
   parseForStatement(node) {
     this.next();
     this.state.labels.push(loopLabel);
-    var awaitAt = -1;
+    var awaitAt = null;
     if (this.isAwaitAllowed() && this.eatContextual(92)) {
-      awaitAt = this.state.lastTokStart;
+      awaitAt = this.state.lastTokStartLoc;
     }
     this.scope.enter(SCOPE_OTHER);
     this.expect(10);
     if (this.match(13)) {
-      if (awaitAt > -1) {
+      if (awaitAt !== null) {
         this.unexpected(awaitAt);
       }
@@ -17084,7 +17521,7 @@ class StatementParser extends ExpressionParser {
         return this.parseForIn(node, _init, awaitAt);
       }
-      if (awaitAt > -1) {
+      if (awaitAt !== null) {
         this.unexpected(awaitAt);
       }
@@ -17098,9 +17535,15 @@ class StatementParser extends ExpressionParser {
     if (isForOf) {
       if (startsWithLet) {
-        this.raise(init.start, ErrorMessages.ForOfLet);
-      } else if (awaitAt === -1 && startsWithAsync && init.type === "Identifier") {
-        this.raise(init.start, ErrorMessages.ForOfAsync);
+        this.raise(ErrorMessages.ForOfLet, {
+          node: init
+        });
+      }
+      if (awaitAt === null && startsWithAsync && init.type === "Identifier") {
+        this.raise(ErrorMessages.ForOfAsync, {
+          node: init
+        });
       }
     }
@@ -17113,7 +17556,7 @@ class StatementParser extends ExpressionParser {
       this.checkExpressionErrors(refExpressionErrors, true);
     }
-    if (awaitAt > -1) {
+    if (awaitAt !== null) {
       this.unexpected(awaitAt);
     }
@@ -17135,7 +17578,9 @@ class StatementParser extends ExpressionParser {
   parseReturnStatement(node) {
     if (!this.prodParam.hasReturn && !this.options.allowReturnOutsideFunction) {
-      this.raise(this.state.start, ErrorMessages.IllegalReturn);
+      this.raise(ErrorMessages.IllegalReturn, {
+        at: this.state.startLoc
+      });
     }
     this.next();
@@ -17171,7 +17616,9 @@ class StatementParser extends ExpressionParser {
           cur.test = this.parseExpression();
         } else {
           if (sawDefault) {
-            this.raise(this.state.lastTokStart, ErrorMessages.MultipleDefaultsInSwitch);
+            this.raise(ErrorMessages.MultipleDefaultsInSwitch, {
+              at: this.state.lastTokStartLoc
+            });
           }
           sawDefault = true;
@@ -17199,7 +17646,9 @@ class StatementParser extends ExpressionParser {
     this.next();
     if (this.hasPrecedingLineBreak()) {
-      this.raise(this.state.lastTokEnd, ErrorMessages.NewlineAfterThrow);
+      this.raise(ErrorMessages.NewlineAfterThrow, {
+        at: this.state.lastTokEndLoc
+      });
     }
     node.argument = this.parseExpression();
@@ -17241,7 +17690,9 @@ class StatementParser extends ExpressionParser {
     node.finalizer = this.eat(63) ? this.parseBlock() : null;
     if (!node.handler && !node.finalizer) {
-      this.raise(node.start, ErrorMessages.NoCatchOrFinally);
+      this.raise(ErrorMessages.NoCatchOrFinally, {
+        node
+      });
     }
     return this.finishNode(node, "TryStatement");
@@ -17265,7 +17716,9 @@ class StatementParser extends ExpressionParser {
   parseWithStatement(node) {
     if (this.state.strict) {
-      this.raise(this.state.start, ErrorMessages.StrictWith);
+      this.raise(ErrorMessages.StrictWith, {
+        at: this.state.startLoc
+      });
     }
     this.next();
@@ -17282,7 +17735,9 @@ class StatementParser extends ExpressionParser {
   parseLabeledStatement(node, maybeName, expr, context) {
     for (var label of this.state.labels) {
       if (label.name === maybeName) {
-        this.raise(expr.start, ErrorMessages.LabelRedeclaration, maybeName);
+        this.raise(ErrorMessages.LabelRedeclaration, {
+          node: expr
+        }, maybeName);
       }
     }
@@ -17408,15 +17863,21 @@ class StatementParser extends ExpressionParser {
     this.next();
     if (isForIn) {
-      if (awaitAt > -1) this.unexpected(awaitAt);
+      if (awaitAt !== null) this.unexpected(awaitAt);
     } else {
-      node.await = awaitAt > -1;
+      node.await = awaitAt !== null;
     }
     if (init.type === "VariableDeclaration" && init.declarations[0].init != null && (!isForIn || this.state.strict || init.kind !== "var" || init.declarations[0].id.type !== "Identifier")) {
-      this.raise(init.start, ErrorMessages.ForInOfLoopInitializer, isForIn ? "for-in" : "for-of");
-    } else if (init.type === "AssignmentPattern") {
-      this.raise(init.start, ErrorMessages.InvalidLhs, "for-loop");
+      this.raise(ErrorMessages.ForInOfLoopInitializer, {
+        node: init
+      }, isForIn ? "for-in" : "for-of");
+    }
+    if (init.type === "AssignmentPattern") {
+      this.raise(ErrorMessages.InvalidLhs, {
+        node: init
+      }, "for-loop");
     }
     node.left = init;
@@ -17442,10 +17903,14 @@ class StatementParser extends ExpressionParser {
       } else {
         if (kind === "const" && !(this.match(54) || this.isContextual(97))) {
           if (!isTypescript) {
-            this.raise(this.state.lastTokEnd, ErrorMessages.DeclarationMissingInitializer, "Const declarations");
+            this.raise(ErrorMessages.DeclarationMissingInitializer, {
+              at: this.state.lastTokEndLoc
+            }, "Const declarations");
           }
         } else if (decl.id.type !== "Identifier" && !(isFor && (this.match(54) || this.isContextual(97)))) {
-          this.raise(this.state.lastTokEnd, ErrorMessages.DeclarationMissingInitializer, "Complex binding patterns");
+          this.raise(ErrorMessages.DeclarationMissingInitializer, {
+            at: this.state.lastTokEndLoc
+          }, "Complex binding patterns");
         }
         decl.init = null;
@@ -17472,7 +17937,9 @@ class StatementParser extends ExpressionParser {
     this.initFunction(node, isAsync);
     if (this.match(51) && isHangingStatement) {
-      this.raise(this.state.start, ErrorMessages.GeneratorInSingleStatementContext);
+      this.raise(ErrorMessages.GeneratorInSingleStatementContext, {
+        at: this.state.startLoc
+      });
     }
     node.generator = this.eat(51);
@@ -17518,7 +17985,7 @@ class StatementParser extends ExpressionParser {
   registerFunctionStatementId(node) {
     if (!node.id) return;
-    this.scope.declareName(node.id.name, this.state.strict || node.generator || node.async ? this.scope.treatFunctionsAsVar ? BIND_VAR : BIND_LEXICAL : BIND_FUNCTION, node.id.start);
+    this.scope.declareName(node.id.name, this.state.strict || node.generator || node.async ? this.scope.treatFunctionsAsVar ? BIND_VAR : BIND_LEXICAL : BIND_FUNCTION, node.id.loc.start);
   }
   parseClass(node, isStatement, optionalId) {
@@ -17558,7 +18025,9 @@ class StatementParser extends ExpressionParser {
       while (!this.match(8)) {
         if (this.eat(13)) {
           if (decorators.length > 0) {
-            throw this.raise(this.state.lastTokEnd, ErrorMessages.DecoratorSemicolon);
+            throw this.raise(ErrorMessages.DecoratorSemicolon, {
+              at: this.state.lastTokEndLoc
+            });
           }
           continue;
@@ -17580,7 +18049,9 @@ class StatementParser extends ExpressionParser {
         this.parseClassMember(classBody, member, state);
         if (member.kind === "constructor" && member.decorators && member.decorators.length > 0) {
-          this.raise(member.start, ErrorMessages.DecoratorConstructor);
+          this.raise(ErrorMessages.DecoratorConstructor, {
+            node: member
+          });
         }
       }
     });
@@ -17588,7 +18059,9 @@ class StatementParser extends ExpressionParser {
     this.next();
     if (decorators.length) {
-      throw this.raise(this.state.start, ErrorMessages.TrailingDecorator);
+      throw this.raise(ErrorMessages.TrailingDecorator, {
+        at: this.state.startLoc
+      });
     }
     this.classScope.exit();
@@ -17657,7 +18130,9 @@ class StatementParser extends ExpressionParser {
       }
       if (this.isNonstaticConstructor(publicMethod)) {
-        this.raise(publicMethod.key.start, ErrorMessages.ConstructorIsGenerator);
+        this.raise(ErrorMessages.ConstructorIsGenerator, {
+          node: publicMethod.key
+        });
       }
       this.pushClassMethod(classBody, publicMethod, true, false, false, false);
@@ -17667,7 +18142,7 @@ class StatementParser extends ExpressionParser {
     var isContextual = tokenIsIdentifier(this.state.type) && !this.state.containsEsc;
     var isPrivate = this.match(130);
     var key = this.parseClassElementName(member);
-    var maybeQuestionTokenStart = this.state.start;
+    var maybeQuestionTokenStartLoc = this.state.startLoc;
     this.parsePostMemberNameModifiers(publicMember);
     if (this.isClassMethod()) {
@@ -17685,11 +18160,15 @@ class StatementParser extends ExpressionParser {
         publicMethod.kind = "constructor";
         if (state.hadConstructor && !this.hasPlugin("typescript")) {
-          this.raise(key.start, ErrorMessages.DuplicateConstructor);
+          this.raise(ErrorMessages.DuplicateConstructor, {
+            node: key
+          });
         }
         if (isConstructor && this.hasPlugin("typescript") && member.override) {
-          this.raise(key.start, ErrorMessages.OverrideOnConstructor);
+          this.raise(ErrorMessages.OverrideOnConstructor, {
+            node: key
+          });
         }
         state.hadConstructor = true;
@@ -17708,7 +18187,7 @@ class StatementParser extends ExpressionParser {
       var isGenerator = this.eat(51);
       if (publicMember.optional) {
-        this.unexpected(maybeQuestionTokenStart);
+        this.unexpected(maybeQuestionTokenStartLoc);
       }
       method.kind = "method";
@@ -17722,7 +18201,9 @@ class StatementParser extends ExpressionParser {
         this.pushClassPrivateMethod(classBody, privateMethod, isGenerator, true);
       } else {
         if (this.isNonstaticConstructor(publicMethod)) {
-          this.raise(publicMethod.key.start, ErrorMessages.ConstructorIsAsync);
+          this.raise(ErrorMessages.ConstructorIsAsync, {
+            node: publicMethod.key
+          });
         }
         this.pushClassMethod(classBody, publicMethod, isGenerator, true, false, false);
@@ -17739,7 +18220,9 @@ class StatementParser extends ExpressionParser {
         this.pushClassPrivateMethod(classBody, privateMethod, false, false);
       } else {
         if (this.isNonstaticConstructor(publicMethod)) {
-          this.raise(publicMethod.key.start, ErrorMessages.ConstructorIsAccessor);
+          this.raise(ErrorMessages.ConstructorIsAccessor, {
+            node: publicMethod.key
+          });
         }
         this.pushClassMethod(classBody, publicMethod, false, false, false, false);
@@ -17760,17 +18243,20 @@ class StatementParser extends ExpressionParser {
   parseClassElementName(member) {
     var {
       type,
-      value,
-      start
+      value
     } = this.state;
     if ((type === 124 || type === 125) && member.static && value === "prototype") {
-      this.raise(start, ErrorMessages.StaticPrototype);
+      this.raise(ErrorMessages.StaticPrototype, {
+        at: this.state.startLoc
+      });
     }
     if (type === 130) {
       if (value === "constructor") {
-        this.raise(start, ErrorMessages.ConstructorClassPrivateField);
+        this.raise(ErrorMessages.ConstructorClassPrivateField, {
+          at: this.state.startLoc
+        });
       }
       var key = this.parsePrivateName();
@@ -17796,13 +18282,17 @@ class StatementParser extends ExpressionParser {
     classBody.body.push(this.finishNode(member, "StaticBlock"));
     if ((_member$decorators = member.decorators) != null && _member$decorators.length) {
-      this.raise(member.start, ErrorMessages.DecoratorStaticBlock);
+      this.raise(ErrorMessages.DecoratorStaticBlock, {
+        node: member
+      });
     }
   }
   pushClassProperty(classBody, prop) {
     if (!prop.computed && (prop.key.name === "constructor" || prop.key.value === "constructor")) {
-      this.raise(prop.key.start, ErrorMessages.ConstructorClassField);
+      this.raise(ErrorMessages.ConstructorClassField, {
+        node: prop.key
+      });
     }
     classBody.body.push(this.parseClassProperty(prop));
@@ -17811,7 +18301,7 @@ class StatementParser extends ExpressionParser {
   pushClassPrivateProperty(classBody, prop) {
     var node = this.parseClassPrivateProperty(prop);
     classBody.body.push(node);
-    this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), CLASS_ELEMENT_OTHER, node.key.start);
+    this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), CLASS_ELEMENT_OTHER, node.key.loc.start);
   }
   pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
@@ -17826,7 +18316,7 @@ class StatementParser extends ExpressionParser {
   }
   declareClassPrivateMethodInScope(node, kind) {
-    this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), kind, node.key.start);
+    this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), kind, node.key.loc.start);
   }
   parsePostMemberNameModifiers(methodOrProp) {}
@@ -17866,7 +18356,9 @@ class StatementParser extends ExpressionParser {
       if (optionalId || !isStatement) {
         node.id = null;
       } else {
-        this.unexpected(null, ErrorMessages.MissingClassName);
+        throw this.raise(ErrorMessages.MissingClassName, {
+          at: this.state.startLoc
+        });
       }
     }
   }
@@ -17999,22 +18491,32 @@ class StatementParser extends ExpressionParser {
       }
       return this.parseFunction(expr, FUNC_STATEMENT | FUNC_NULLABLE_ID, isAsync);
-    } else if (this.match(76)) {
+    }
+    if (this.match(76)) {
       return this.parseClass(expr, true, true);
-    } else if (this.match(26)) {
+    }
+    if (this.match(26)) {
       if (this.hasPlugin("decorators") && this.getPluginOption("decorators", "decoratorsBeforeExport")) {
-        this.raise(this.state.start, ErrorMessages.DecoratorBeforeExport);
+        this.raise(ErrorMessages.DecoratorBeforeExport, {
+          at: this.state.startLoc
+        });
       }
       this.parseDecorators(false);
       return this.parseClass(expr, true, true);
-    } else if (this.match(71) || this.match(70) || this.isLet()) {
-      throw this.raise(this.state.start, ErrorMessages.UnsupportedDefaultExport);
-    } else {
-      var res = this.parseMaybeAssignAllowIn();
-      this.semicolon();
-      return res;
     }
+    if (this.match(71) || this.match(70) || this.isLet()) {
+      throw this.raise(ErrorMessages.UnsupportedDefaultExport, {
+        at: this.state.startLoc
+      });
+    }
+    var res = this.parseMaybeAssignAllowIn();
+    this.semicolon();
+    return res;
   }
   parseExportDeclaration(node) {
@@ -18086,10 +18588,12 @@ class StatementParser extends ExpressionParser {
       if (this.hasPlugin("decorators")) {
         if (this.getPluginOption("decorators", "decoratorsBeforeExport")) {
-          this.unexpected(this.state.start, ErrorMessages.DecoratorBeforeExport);
-        } else {
-          return true;
+          throw this.raise(ErrorMessages.DecoratorBeforeExport, {
+            at: this.state.startLoc
+          });
         }
+        return true;
       }
     }
@@ -18107,7 +18611,9 @@ class StatementParser extends ExpressionParser {
           var 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(declaration.start, ErrorMessages.ExportDefaultFromAsIdentifier);
+            this.raise(ErrorMessages.ExportDefaultFromAsIdentifier, {
+              node: declaration
+            });
           }
         }
       } else if (node.specifiers && node.specifiers.length) {
@@ -18124,9 +18630,11 @@ class StatementParser extends ExpressionParser {
             } = specifier;
             if (local.type !== "Identifier") {
-              this.raise(specifier.start, ErrorMessages.ExportBindingIsString, local.value, exportedName);
+              this.raise(ErrorMessages.ExportBindingIsString, {
+                node: specifier
+              }, local.value, exportedName);
             } else {
-              this.checkReservedWord(local.name, local.start, true, false);
+              this.checkReservedWord(local.name, local.loc.start, true, false);
               this.scope.checkLocalExport(local);
             }
           }
@@ -18147,7 +18655,9 @@ class StatementParser extends ExpressionParser {
     var currentContextDecorators = this.state.decoratorStack[this.state.decoratorStack.length - 1];
     if (currentContextDecorators.length) {
-      throw this.raise(node.start, ErrorMessages.UnsupportedDecoratorExport);
+      throw this.raise(ErrorMessages.UnsupportedDecoratorExport, {
+        node
+      });
     }
   }
@@ -18175,7 +18685,9 @@ class StatementParser extends ExpressionParser {
   checkDuplicateExports(node, name) {
     if (this.exportedIdentifiers.has(name)) {
-      this.raise(node.start, name === "default" ? ErrorMessages.DuplicateDefaultExport : ErrorMessages.DuplicateExport, name);
+      this.raise(name === "default" ? ErrorMessages.DuplicateDefaultExport : ErrorMessages.DuplicateExport, {
+        node
+      }, name);
     }
     this.exportedIdentifiers.add(name);
@@ -18222,7 +18734,9 @@ class StatementParser extends ExpressionParser {
       var surrogate = result.value.match(loneSurrogate);
       if (surrogate) {
-        this.raise(result.start, ErrorMessages.ModuleExportNameHasLoneSurrogate, surrogate[0].charCodeAt(0).toString(16));
+        this.raise(ErrorMessages.ModuleExportNameHasLoneSurrogate, {
+          node: result
+        }, surrogate[0].charCodeAt(0).toString(16));
       }
       return result;
@@ -18287,7 +18801,9 @@ class StatementParser extends ExpressionParser {
       var keyName = this.state.value;
       if (attrNames.has(keyName)) {
-        this.raise(this.state.start, ErrorMessages.ModuleAttributesWithDuplicateKeys, keyName);
+        this.raise(ErrorMessages.ModuleAttributesWithDuplicateKeys, {
+          at: this.state.startLoc
+        }, keyName);
       }
       attrNames.add(keyName);
@@ -18301,7 +18817,9 @@ class StatementParser extends ExpressionParser {
       this.expect(14);
       if (!this.match(125)) {
-        throw this.unexpected(this.state.start, ErrorMessages.ModuleAttributeInvalidValue);
+        throw this.raise(ErrorMessages.ModuleAttributeInvalidValue, {
+          at: this.state.startLoc
+        });
       }
       node.value = this.parseStringLiteral(this.state.value);
@@ -18329,18 +18847,24 @@ class StatementParser extends ExpressionParser {
       node.key = this.parseIdentifier(true);
       if (node.key.name !== "type") {
-        this.raise(node.key.start, ErrorMessages.ModuleAttributeDifferentFromType, node.key.name);
+        this.raise(ErrorMessages.ModuleAttributeDifferentFromType, {
+          node: node.key
+        }, node.key.name);
       }
       if (attributes.has(node.key.name)) {
-        this.raise(node.key.start, ErrorMessages.ModuleAttributesWithDuplicateKeys, node.key.name);
+        this.raise(ErrorMessages.ModuleAttributesWithDuplicateKeys, {
+          node: node.key
+        }, node.key.name);
       }
       attributes.add(node.key.name);
       this.expect(14);
       if (!this.match(125)) {
-        throw this.unexpected(this.state.start, ErrorMessages.ModuleAttributeInvalidValue);
+        throw this.raise(ErrorMessages.ModuleAttributeInvalidValue, {
+          at: this.state.startLoc
+        });
       }
       node.value = this.parseStringLiteral(this.state.value);
@@ -18396,7 +18920,9 @@ class StatementParser extends ExpressionParser {
         first = false;
       } else {
         if (this.eat(14)) {
-          throw this.raise(this.state.start, ErrorMessages.DestructureNamedImport);
+          throw this.raise(ErrorMessages.DestructureNamedImport, {
+            at: this.state.startLoc
+          });
         }
         this.expect(12);
@@ -18421,10 +18947,12 @@ class StatementParser extends ExpressionParser {
       } = specifier;
       if (importedIsString) {
-        throw this.raise(specifier.start, ErrorMessages.ImportBindingIsString, imported.value);
+        throw this.raise(ErrorMessages.ImportBindingIsString, {
+          node: specifier
+        }, imported.value);
       }
-      this.checkReservedWord(imported.name, specifier.start, true, true);
+      this.checkReservedWord(imported.name, specifier.loc.start, true, true);
       if (!specifier.local) {
         specifier.local = cloneIdentifier(imported);