@next-core/brick-utils 2.32.4 → 2.33.1

package/dist/index.esm.js

@@ -2206,7 +2206,19 @@ function cook(rootAst, codeSource) {
       getRunningContext().LexicalEnvironment = oldEnv;
 
       if (!LoopContinues(result)) {
-        return UpdateEmpty(result, V);
+        var status = UpdateEmpty(result, V);
+
+        if (!(iterationKind === "enumerate" || iteratorRecord.return === undefined)) {
+          // Perform *IteratorClose*
+          // https://tc39.es/ecma262/#sec-iteratorclose
+          var innerResult = iteratorRecord.return();
+
+          if (!innerResult || !["object", "function"].includes(typeof innerResult)) {
+            throw new TypeError("Iterator result is not an object");
+          }
+        }
+
+        return status;
       }
 
       if (result.Value !== Empty) {
@@ -3045,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);
   }
 
 }
@@ -3117,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 {
@@ -3558,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,
@@ -3575,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
@@ -3591,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) {
@@ -3617,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,
@@ -3711,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) {
@@ -3895,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];
@@ -4568,10 +4519,6 @@ function getExportedToken(token) {
   return tokenTypes[token];
 }
 
-function isTokenType(obj) {
-  return typeof obj === "number";
-}
-
 {
   tokenTypes[8].updateContext = context => {
     context.pop();
@@ -4740,7 +4687,6 @@ class ScopeHandler {
   constructor(raise, inModule) {
     this.scopeStack = [];
     this.undefinedExports = new Map();
-    this.undefinedPrivateNames = new Map();
     this.raise = raise;
     this.inModule = inModule;
   }
@@ -4806,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);
@@ -4824,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;
@@ -4842,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);
     }
   }
 
@@ -4869,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);
     }
   }
 
@@ -4916,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;
@@ -4947,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;
@@ -4982,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;
@@ -5000,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) {
@@ -5078,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;
@@ -5105,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
     };
   }
 
@@ -5153,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();
     }
   }
@@ -5180,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;
 
@@ -5338,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);
     }
   }
@@ -5362,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;
@@ -5473,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;
@@ -5483,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;
@@ -5640,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;
@@ -5660,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;
@@ -5793,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) {
@@ -5803,6 +5831,7 @@ class Tokenizer extends ParserError {
   }
 
   readRegexp() {
+    var startLoc = this.state.startLoc;
     var start = this.state.start + 1;
     var escaped, inClass;
     var {
@@ -5811,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) {
@@ -5845,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;
       }
@@ -5881,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;
@@ -5907,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;
@@ -5928,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);
@@ -5943,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;
     }
@@ -5961,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;
@@ -5968,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)
+          });
         }
       }
 
@@ -6005,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;
@@ -6015,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;
@@ -6023,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;
@@ -6034,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, "");
@@ -6058,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;
         }
@@ -6082,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);
@@ -6097,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;
       }
@@ -6109,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--;
@@ -6124,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);
@@ -6182,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
+      });
     }
   }
 
@@ -6245,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);
@@ -6267,7 +6346,7 @@ class Tokenizer extends ParserError {
             if (inTemplate) {
               return null;
             } else {
-              this.recordStrictModeErrors(codePos, ErrorMessages.StrictNumericEscape);
+              this.recordStrictModeErrors(ErrorMessages.StrictNumericEscape, codePos);
             }
           }
 
@@ -6279,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;
       }
     }
 
@@ -6311,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;
         }
@@ -6325,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);
@@ -6357,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));
     }
   }
 
@@ -6393,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,
@@ -6428,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) {
@@ -6443,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);
     }
   }
 
@@ -6479,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) {
@@ -6507,7 +6603,7 @@ class ExpressionScopeHandler {
     this.stack.pop();
   }
 
-  recordParameterInitializerError(pos, template) {
+  recordParameterInitializerError(loc, template) {
     var {
       stack
     } = this;
@@ -6516,7 +6612,7 @@ class ExpressionScopeHandler {
 
     while (!scope.isCertainlyParameterDeclaration()) {
       if (scope.canBeArrowParameterDeclaration()) {
-        scope.recordDeclarationError(pos, template);
+        scope.recordDeclarationError(template, loc);
       } else {
         return;
       }
@@ -6524,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;
@@ -6551,7 +6651,7 @@ class ExpressionScopeHandler {
 
     while (scope.canBeArrowParameterDeclaration()) {
       if (scope.type === kMaybeAsyncArrowParameterDeclaration) {
-        scope.recordDeclarationError(pos, template);
+        scope.recordDeclarationError(template, loc);
       }
 
       scope = stack[--i];
@@ -6564,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];
       }
     });
@@ -6640,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) {
@@ -6676,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() {
@@ -6684,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() {
@@ -6699,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) {
@@ -6746,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), "."));
     }
@@ -6756,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(", "), "."));
     }
@@ -6828,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);
     }
   }
 
@@ -6922,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;
   }
 
 }
@@ -7034,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;
   }
@@ -7053,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) {
@@ -7203,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)) {
@@ -7271,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");
   }
 
@@ -7287,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);
@@ -7308,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");
   }
@@ -7333,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);
@@ -7353,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";
@@ -7391,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)) {
@@ -7446,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();
@@ -7509,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();
@@ -7541,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();
@@ -7567,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();
@@ -7580,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
+        });
       }
     }
 
@@ -7772,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();
@@ -7805,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)) {
@@ -7814,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;
         }
       }
@@ -7831,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));
@@ -7845,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));
@@ -7866,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);
         }
@@ -7878,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
+        });
       }
     }
 
@@ -7894,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();
@@ -7929,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));
@@ -7951,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();
@@ -7972,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
+      });
     }
   }
 
@@ -8057,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);
@@ -8066,7 +8225,9 @@ var flow = superClass => class extends superClass {
         optional = true;
 
         if (isThis) {
-          this.raise(node.start, FlowErrors.ThisParamMayNotBeOptional);
+          this.raise(FlowErrors.ThisParamMayNotBeOptional, {
+            node
+          });
         }
       }
 
@@ -8259,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();
@@ -8431,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;
   }
 
@@ -8596,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) {
@@ -8662,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();
@@ -8771,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;
@@ -8790,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)) {
@@ -8804,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
+        });
       }
     }
   }
@@ -8820,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);
@@ -8865,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];
 
@@ -8874,7 +9049,7 @@ var flow = superClass => class extends superClass {
       }
     }
 
-    return super.toAssignableList(exprList, trailingCommaPos, isLHS);
+    return super.toAssignableList(exprList, trailingCommaLoc, isLHS);
   }
 
   toReferencedList(exprList, isParenthesizedExpr) {
@@ -8884,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
+        });
       }
     }
 
@@ -8941,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;
@@ -8956,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;
@@ -9016,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
+        });
       }
     }
   }
@@ -9029,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;
@@ -9050,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;
@@ -9063,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);
@@ -9078,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;
@@ -9115,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) {
@@ -9159,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;
@@ -9177,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);
@@ -9282,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;
@@ -9303,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);
@@ -9348,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]
+        });
       }
     }
 
@@ -9473,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;
@@ -9482,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();
@@ -9492,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;
     }
 
@@ -9537,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);
+    this.raise(FlowErrors.EnumBooleanMemberNotInitialized, {
+      at: loc
+    }, memberName, enumName);
   }
 
-  flowEnumErrorInconsistentMemberValues(pos, _ref9) {
-    var {
-      enumName
-    } = _ref9;
-    this.raise(pos, FlowErrors.EnumInconsistentMemberValues, 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);
 
@@ -9635,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
           };
         }
 
@@ -9653,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
           };
         }
 
@@ -9672,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,
@@ -9704,7 +9886,7 @@ var flow = superClass => class extends superClass {
     };
   }
 
-  flowEnumCheckExplicitTypeMismatch(pos, context, expectedType) {
+  flowEnumCheckExplicitTypeMismatch(loc, context, expectedType) {
     var {
       explicitType
     } = context;
@@ -9714,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: [],
@@ -9750,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);
@@ -9774,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;
@@ -9782,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;
@@ -9790,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;
@@ -9798,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:
@@ -9829,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;
@@ -9840,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
         });
       }
@@ -9848,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
         });
       }
@@ -9857,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
         });
@@ -9876,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
         });
@@ -9888,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
     });
@@ -9956,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
               });
@@ -9967,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
               });
@@ -9977,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();
           }
         }
@@ -9989,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");
   }
 
@@ -10307,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);
@@ -10371,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);
@@ -10504,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;
@@ -10514,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) {
@@ -10647,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));
         }
       }
     }
@@ -10669,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");
@@ -10782,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) {
@@ -10795,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);
       }
 
@@ -10996,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);
       }
     }
   }
@@ -11143,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();
@@ -11241,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) {
@@ -11262,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;
@@ -11329,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";
@@ -11511,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";
@@ -11525,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");
@@ -11548,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;
       }
 
@@ -11744,7 +11981,9 @@ var typescript = superClass => class extends superClass {
         return;
 
       default:
-        this.raise(node.start, TSErrors.UnexpectedReadonly);
+        this.raise(TSErrors.UnexpectedReadonly, {
+          node
+        });
     }
   }
 
@@ -11943,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;
@@ -11997,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();
@@ -12011,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;
@@ -12038,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();
@@ -12198,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;
@@ -12432,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);
@@ -12463,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
+        });
       }
     }
 
@@ -12483,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;
@@ -12512,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);
@@ -12534,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
+        });
       }
     });
   }
@@ -12576,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);
@@ -12592,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();
           }
 
@@ -12617,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;
@@ -12688,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;
@@ -12795,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);
@@ -12818,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
+        });
       }
     }
 
@@ -12854,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
+      });
     }
   }
 
@@ -12915,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;
@@ -12963,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);
@@ -12978,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);
@@ -12993,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;
@@ -13048,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;
     }
 
@@ -13154,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
+      });
     }
   }
 
@@ -13187,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;
@@ -13268,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;
         }
 
@@ -13305,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);
@@ -13314,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);
     }
   }
 
@@ -13331,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;
@@ -13380,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;
@@ -13392,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;
   }
 
@@ -13474,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);
       }
@@ -13493,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), "]"));
       }
     }
 
@@ -13552,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();
@@ -13582,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;
@@ -13605,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) {
@@ -13730,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);
@@ -13830,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();
 
@@ -13844,7 +14156,7 @@ var v8intrinsic = superClass => class extends superClass {
         }
       }
 
-      this.unexpected(v8IntrinsicStart);
+      this.unexpected(v8IntrinsicStartLoc);
     }
   }
 
@@ -14038,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
+        });
       }
     }
 
@@ -14065,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
+            });
           }
         }
 
@@ -14087,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";
@@ -14110,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) {
@@ -14137,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;
@@ -14152,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
+          });
         }
       }
     }
@@ -14263,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)) {
@@ -14353,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;
@@ -14377,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;
@@ -14413,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;
   }
 
 }
@@ -14457,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
+          });
         }
       }
 
@@ -14536,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) {
@@ -14588,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;
@@ -14656,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;
@@ -14680,7 +15019,7 @@ class ExpressionParser extends LValParser {
             return left;
           }
 
-          this.checkPipelineAtInfixOperator(left, leftStartPos);
+          this.checkPipelineAtInfixOperator(left, leftStartLoc);
         }
 
         var node = this.startNodeAt(leftStartPos, leftStartLoc);
@@ -14699,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
+            });
           }
         }
 
@@ -14708,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);
@@ -14733,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);
@@ -14760,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;
@@ -14777,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
+      });
     }
   }
 
@@ -14815,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
+          });
         }
       }
 
@@ -14837,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);
       }
     }
@@ -14945,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);
@@ -15024,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) {
@@ -15045,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
+            });
           }
         }
       }
@@ -15072,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();
@@ -15100,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);
@@ -15138,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");
@@ -15237,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();
         }
 
@@ -15335,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();
@@ -15344,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":
         {
@@ -15388,7 +15753,9 @@ class ExpressionParser extends LValParser {
         return tokenType === 27;
 
       default:
-        throw this.raise(start, ErrorMessages.PipeTopicRequiresHackPipes);
+        throw this.raise(ErrorMessages.PipeTopicRequiresHackPipes, {
+          at: startLoc
+        });
     }
   }
 
@@ -15398,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);
@@ -15435,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");
@@ -15449,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);
@@ -15482,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");
@@ -15494,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;
@@ -15567,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;
         }
       }
@@ -15585,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;
@@ -15611,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);
 
@@ -15623,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];
     }
@@ -15631,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;
     }
 
@@ -15665,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;
@@ -15678,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);
@@ -15702,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)
+        });
       }
     }
 
@@ -15724,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;
   }
 
@@ -15767,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;
         }
       }
@@ -15782,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) {
@@ -15805,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));
   }
@@ -15814,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)) {
@@ -15867,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();
         }
 
@@ -15892,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
+      });
     }
   }
 
@@ -15931,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));
@@ -15996,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;
             }
@@ -16051,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;
     }
 
@@ -16065,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;
@@ -16076,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) {
@@ -16103,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;
@@ -16150,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();
@@ -16169,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;
@@ -16181,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();
@@ -16209,7 +16621,7 @@ class ExpressionParser extends LValParser {
   parseIdentifierName(pos, liberal) {
     var name;
     var {
-      start,
+      startLoc,
       type
     } = this.state;
 
@@ -16226,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();
@@ -16244,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);
     }
   }
 
@@ -16288,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) {
@@ -16319,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;
@@ -16348,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);
 
@@ -16371,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");
     }
@@ -16390,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
+      });
     }
   }
 
@@ -16674,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);
       }
     }
 
@@ -16785,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
+            });
           }
         }
 
@@ -16817,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);
@@ -16846,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();
@@ -16874,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();
@@ -16895,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
+      });
     }
   }
 
@@ -16927,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
+      });
     }
   }
 
@@ -17009,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");
     }
   }
 
@@ -17040,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);
       }
 
@@ -17072,7 +17521,7 @@ class StatementParser extends ExpressionParser {
         return this.parseForIn(node, _init, awaitAt);
       }
 
-      if (awaitAt > -1) {
+      if (awaitAt !== null) {
         this.unexpected(awaitAt);
       }
 
@@ -17086,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
+        });
       }
     }
 
@@ -17101,7 +17556,7 @@ class StatementParser extends ExpressionParser {
       this.checkExpressionErrors(refExpressionErrors, true);
     }
 
-    if (awaitAt > -1) {
+    if (awaitAt !== null) {
       this.unexpected(awaitAt);
     }
 
@@ -17123,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();
@@ -17159,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;
@@ -17187,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();
@@ -17229,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");
@@ -17253,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();
@@ -17270,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);
       }
     }
 
@@ -17396,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;
@@ -17430,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;
@@ -17460,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);
@@ -17506,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) {
@@ -17546,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;
@@ -17568,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
+          });
         }
       }
     });
@@ -17576,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();
@@ -17645,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);
@@ -17655,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()) {
@@ -17673,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;
@@ -17696,7 +18187,7 @@ class StatementParser extends ExpressionParser {
       var isGenerator = this.eat(51);
 
       if (publicMember.optional) {
-        this.unexpected(maybeQuestionTokenStart);
+        this.unexpected(maybeQuestionTokenStartLoc);
       }
 
       method.kind = "method";
@@ -17710,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);
@@ -17727,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);
@@ -17748,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();
@@ -17784,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));
@@ -17799,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) {
@@ -17814,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) {}
@@ -17854,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
+        });
       }
     }
   }
@@ -17987,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) {
@@ -18074,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;
       }
     }
 
@@ -18095,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) {
@@ -18112,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);
             }
           }
@@ -18135,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
+      });
     }
   }
 
@@ -18163,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);
@@ -18210,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;
@@ -18275,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);
@@ -18289,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);
@@ -18317,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);
@@ -18384,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);
@@ -18409,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);
@@ -21232,7 +21772,7 @@ function safeYamlParse(value) {
 }
 
 var fieldsToKeepInMenu = ["menuId", "title", "icon", "titleDataSource", "defaultCollapsed", "defaultCollapsedBreakpoint", "link", "type", "injectMenuGroupId", "dynamicItems", "itemsResolve"];
-var fieldsToKeepInMenuItem = ["text", "to", "target", "icon", "exact", "key", "activeIncludes", "activeExcludes", "activeMatchSearch", "type", "sort", "defaultExpanded", "if", "groupId"];
+var fieldsToKeepInMenuItem = ["text", "to", "href", "target", "icon", "exact", "key", "activeIncludes", "activeExcludes", "activeMatchSearch", "type", "sort", "defaultExpanded", "if", "groupId"];
 function normalizeMenu(node) {
   return _objectSpread(_objectSpread({}, keep(node, fieldsToKeepInMenu)), {}, {
     items: keepItems(node.items, fieldsToKeepInMenuItem)