@next-core/brick-utils 2.32.4 → 2.33.1

package/dist/index.bundle.js

@@ -2211,7 +2211,19 @@
         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) {
@@ -3050,62 +3062,15 @@
   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);
     }
 
   }
@@ -3122,26 +3087,14 @@
 
   }
 
-  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 {
@@ -3563,13 +3516,7 @@
   }
 
   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,
@@ -3580,13 +3527,13 @@
         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
@@ -3596,7 +3543,7 @@
         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) {
@@ -3622,12 +3569,12 @@
       }, 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,
@@ -3716,9 +3663,9 @@
       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) {
@@ -3900,9 +3847,13 @@
 
     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];
@@ -4573,10 +4524,6 @@
     return tokenTypes[token];
   }
 
-  function isTokenType(obj) {
-    return typeof obj === "number";
-  }
-
   {
     tokenTypes[8].updateContext = context => {
       context.pop();
@@ -4745,7 +4692,6 @@
     constructor(raise, inModule) {
       this.scopeStack = [];
       this.undefinedExports = new Map();
-      this.undefinedPrivateNames = new Map();
       this.raise = raise;
       this.inModule = inModule;
     }
@@ -4811,11 +4757,11 @@
       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);
@@ -4829,7 +4775,7 @@
       } 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;
@@ -4847,9 +4793,11 @@
       }
     }
 
-    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);
       }
     }
 
@@ -4874,7 +4822,7 @@
       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);
       }
     }
 
@@ -4921,11 +4869,11 @@
       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;
@@ -4952,6 +4900,56 @@
 
   }
 
+  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;
@@ -4987,7 +4985,6 @@
       this.lastTokEndLoc = null;
       this.lastTokStartLoc = null;
       this.lastTokStart = 0;
-      this.lastTokEnd = 0;
       this.context = [types.brace];
       this.canStartJSXElement = true;
       this.containsEsc = false;
@@ -5005,11 +5002,11 @@
       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) {
@@ -5083,7 +5080,6 @@
         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;
@@ -5110,9 +5106,13 @@
         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
       };
     }
 
@@ -5158,7 +5158,15 @@
       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();
       }
     }
@@ -5185,7 +5193,13 @@
       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;
 
@@ -5343,12 +5357,12 @@
 
     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);
       }
     }
@@ -5367,14 +5381,18 @@
       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;
@@ -5478,7 +5496,9 @@
 
         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;
@@ -5488,7 +5508,9 @@
 
         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;
@@ -5645,7 +5667,9 @@
         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;
@@ -5665,7 +5689,9 @@
         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;
@@ -5798,7 +5824,9 @@
 
       }
 
-      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) {
@@ -5808,6 +5836,7 @@
     }
 
     readRegexp() {
+      var startLoc = this.state.startLoc;
       var start = this.state.start + 1;
       var escaped, inClass;
       var {
@@ -5816,13 +5845,17 @@
 
       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) {
@@ -5850,10 +5883,14 @@
 
         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;
         }
@@ -5886,13 +5923,19 @@
           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;
@@ -5912,7 +5955,9 @@
         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;
@@ -5933,13 +5978,15 @@
     }
 
     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);
@@ -5948,15 +5995,19 @@
         ++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;
       }
@@ -5966,6 +6017,7 @@
 
     readNumber(startsWithDot) {
       var start = this.state.pos;
+      var startLoc = this.state.curPosition();
       var isFloat = false;
       var isBigInt = false;
       var isDecimal = false;
@@ -5973,20 +6025,24 @@
       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)
+            });
           }
         }
 
@@ -6010,7 +6066,9 @@
         }
 
         if (this.readInt(10) === null) {
-          this.raise(start, ErrorMessages.InvalidOrMissingExponent);
+          this.raise(ErrorMessages.InvalidOrMissingExponent, {
+            at: startLoc
+          });
         }
 
         isFloat = true;
@@ -6020,7 +6078,9 @@
 
       if (next === 110) {
         if (isFloat || hasLeadingZero) {
-          this.raise(start, ErrorMessages.InvalidBigIntLiteral);
+          this.raise(ErrorMessages.InvalidBigIntLiteral, {
+            at: startLoc
+          });
         }
 
         ++this.state.pos;
@@ -6028,10 +6088,12 @@
       }
 
       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;
@@ -6039,7 +6101,9 @@
       }
 
       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, "");
@@ -6063,13 +6127,15 @@
       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;
           }
@@ -6087,7 +6153,9 @@
 
       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);
@@ -6102,7 +6170,9 @@
           ++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;
         }
@@ -6114,7 +6184,7 @@
 
     readTemplateContinuation() {
       if (!this.match(8)) {
-        this.unexpected(this.state.start, 8);
+        this.unexpected(null, 8);
       }
 
       this.state.pos--;
@@ -6129,7 +6199,9 @@
 
       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);
@@ -6187,11 +6259,18 @@
       }
     }
 
-    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
+        });
       }
     }
 
@@ -6250,12 +6329,12 @@
           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);
@@ -6272,7 +6351,7 @@
               if (inTemplate) {
                 return null;
               } else {
-                this.recordStrictModeErrors(codePos, ErrorMessages.StrictNumericEscape);
+                this.recordStrictModeErrors(ErrorMessages.StrictNumericEscape, codePos);
               }
             }
 
@@ -6284,14 +6363,16 @@
     }
 
     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;
         }
       }
 
@@ -6316,11 +6397,13 @@
         } 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;
           }
@@ -6330,7 +6413,9 @@
 
           if (esc !== null) {
             if (!identifierCheck(esc)) {
-              this.raise(escStart, ErrorMessages.EscapedCharNotAnIdentifier);
+              this.raise(ErrorMessages.EscapedCharNotAnIdentifier, {
+                at: escStart
+              });
             }
 
             word += String.fromCodePoint(esc);
@@ -6362,7 +6447,9 @@
       } = 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));
       }
     }
 
@@ -6398,18 +6485,20 @@
       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,
@@ -6433,14 +6522,16 @@
       }
 
       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) {
@@ -6448,9 +6539,11 @@
       }
 
       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);
       }
     }
 
@@ -6484,12 +6577,15 @@
       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) {
@@ -6512,7 +6608,7 @@
       this.stack.pop();
     }
 
-    recordParameterInitializerError(pos, template) {
+    recordParameterInitializerError(loc, template) {
       var {
         stack
       } = this;
@@ -6521,7 +6617,7 @@
 
       while (!scope.isCertainlyParameterDeclaration()) {
         if (scope.canBeArrowParameterDeclaration()) {
-          scope.recordDeclarationError(pos, template);
+          scope.recordDeclarationError(template, loc);
         } else {
           return;
         }
@@ -6529,25 +6625,29 @@
         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;
@@ -6556,7 +6656,7 @@
 
       while (scope.canBeArrowParameterDeclaration()) {
         if (scope.type === kMaybeAsyncArrowParameterDeclaration) {
-          scope.recordDeclarationError(pos, template);
+          scope.recordDeclarationError(template, loc);
         }
 
         scope = stack[--i];
@@ -6569,13 +6669,19 @@
       } = 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];
         }
       });
@@ -6645,10 +6751,19 @@
   }
 
   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) {
@@ -6681,7 +6796,15 @@
     }
 
     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() {
@@ -6689,7 +6812,7 @@
     }
 
     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() {
@@ -6704,41 +6827,37 @@
     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) {
@@ -6751,9 +6870,9 @@
       });
     }
 
-    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), "."));
       }
@@ -6761,9 +6880,9 @@
       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(", "), "."));
       }
@@ -6833,26 +6952,30 @@
     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);
       }
     }
 
@@ -6927,9 +7050,9 @@
 
   class ExpressionErrors {
     constructor() {
-      this.shorthandAssign = -1;
-      this.doubleProto = -1;
-      this.optionalParameters = -1;
+      this.shorthandAssignLoc = null;
+      this.doubleProtoLoc = null;
+      this.optionalParametersLoc = null;
     }
 
   }
@@ -7039,14 +7162,14 @@
     }
 
     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;
     }
@@ -7058,11 +7181,10 @@
     }
 
     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) {
@@ -7208,12 +7330,14 @@
 
     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)) {
@@ -7276,7 +7400,7 @@
       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");
     }
 
@@ -7292,7 +7416,9 @@
           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);
@@ -7313,7 +7439,7 @@
     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");
     }
@@ -7338,7 +7464,9 @@
           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);
@@ -7358,17 +7486,23 @@
       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";
@@ -7396,7 +7530,9 @@
         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)) {
@@ -7451,7 +7587,7 @@
     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();
@@ -7514,23 +7650,27 @@
 
     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();
@@ -7546,7 +7686,7 @@
     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();
@@ -7572,7 +7712,7 @@
 
     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();
@@ -7585,7 +7725,9 @@
         node.default = this.flowParseType();
       } else {
         if (requireDefault) {
-          this.raise(nodeStart, FlowErrors.MissingTypeParamDefault);
+          this.raise(FlowErrors.MissingTypeParamDefault, {
+            at: nodeStartLoc
+          });
         }
       }
 
@@ -7777,14 +7919,14 @@
       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();
@@ -7810,8 +7952,8 @@
 
       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)) {
@@ -7819,7 +7961,7 @@
 
           if (lookahead.type !== 14 && lookahead.type !== 17) {
             this.next();
-            protoStart = this.state.start;
+            protoStartLoc = this.state.startLoc;
             allowStatic = false;
           }
         }
@@ -7836,13 +7978,13 @@
         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));
@@ -7850,12 +7992,12 @@
             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));
@@ -7871,11 +8013,11 @@
             }
           }
 
-          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);
           }
@@ -7883,8 +8025,10 @@
 
         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
+          });
         }
       }
 
@@ -7899,34 +8043,44 @@
       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();
@@ -7934,19 +8088,19 @@
       } 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));
@@ -7956,7 +8110,9 @@
           }
 
           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();
@@ -7977,23 +8133,24 @@
 
     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
+        });
       }
     }
 
@@ -8062,7 +8219,9 @@
 
       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);
@@ -8071,7 +8230,9 @@
           optional = true;
 
           if (isThis) {
-            this.raise(node.start, FlowErrors.ThisParamMayNotBeOptional);
+            this.raise(FlowErrors.ThisParamMayNotBeOptional, {
+              node
+            });
           }
         }
 
@@ -8264,7 +8425,9 @@
               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();
@@ -8436,7 +8599,7 @@
 
     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;
     }
 
@@ -8601,7 +8764,9 @@
         }
 
         if (failed && valid.length > 1) {
-          this.raise(state.start, FlowErrors.AmbiguousConditionalArrow);
+          this.raise(FlowErrors.AmbiguousConditionalArrow, {
+            at: state.startLoc
+          });
         }
 
         if (failed && valid.length === 1) {
@@ -8667,7 +8832,7 @@
     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();
@@ -8776,11 +8941,13 @@
     }
 
     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;
@@ -8795,7 +8962,9 @@
     }
 
     parseClassMember(classBody, member, state) {
-      var pos = this.state.start;
+      var {
+        startLoc
+      } = this.state;
 
       if (this.isContextual(117)) {
         if (this.parseClassMemberFromModifier(classBody, member)) {
@@ -8809,9 +8978,13 @@
 
       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
+          });
         }
       }
     }
@@ -8825,7 +8998,9 @@
       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);
@@ -8870,7 +9045,7 @@
       }
     }
 
-    toAssignableList(exprList, trailingCommaPos, isLHS) {
+    toAssignableList(exprList, trailingCommaLoc, isLHS) {
       for (var i = 0; i < exprList.length; i++) {
         var expr = exprList[i];
 
@@ -8879,7 +9054,7 @@
         }
       }
 
-      return super.toAssignableList(exprList, trailingCommaPos, isLHS);
+      return super.toAssignableList(exprList, trailingCommaLoc, isLHS);
     }
 
     toReferencedList(exprList, isParenthesizedExpr) {
@@ -8889,7 +9064,9 @@
         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
+          });
         }
       }
 
@@ -8946,7 +9123,7 @@
 
     pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
       if (method.variance) {
-        this.unexpected(method.variance.start);
+        this.unexpected(method.variance.loc.start);
       }
 
       delete method.variance;
@@ -8961,20 +9138,24 @@
         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;
@@ -9021,9 +9202,13 @@
         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
+          });
         }
       }
     }
@@ -9034,7 +9219,7 @@
 
     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;
@@ -9055,11 +9240,15 @@
     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;
@@ -9068,11 +9257,15 @@
       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);
@@ -9083,7 +9276,9 @@
       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;
@@ -9120,7 +9315,7 @@
         } = lh;
 
         if (kind === "type" && type === 51) {
-          this.unexpected(lh.start);
+          this.unexpected(null, lh.type);
         }
 
         if (isMaybeDefaultImport(type) || type === 5 || type === 51) {
@@ -9164,7 +9359,9 @@
           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;
@@ -9182,15 +9379,17 @@
       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);
@@ -9287,7 +9486,9 @@
         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;
@@ -9308,7 +9509,9 @@
 
         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);
@@ -9353,7 +9556,9 @@
 
       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]
+          });
         }
       }
 
@@ -9478,7 +9683,9 @@
       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;
@@ -9487,7 +9694,9 @@
     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();
@@ -9497,13 +9706,15 @@
       }
 
       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;
       }
 
@@ -9542,93 +9753,64 @@
       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);
 
@@ -9640,14 +9822,14 @@
             if (endOfInit()) {
               return {
                 type: "number",
-                pos: literal.start,
+                loc: literal.loc.start,
                 value: literal
               };
             }
 
             return {
               type: "invalid",
-              pos: startPos
+              loc: startLoc
             };
           }
 
@@ -9658,14 +9840,14 @@
             if (endOfInit()) {
               return {
                 type: "string",
-                pos: _literal.start,
+                loc: _literal.loc.start,
                 value: _literal
               };
             }
 
             return {
               type: "invalid",
-              pos: startPos
+              loc: startLoc
             };
           }
 
@@ -9677,31 +9859,31 @@
             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,
@@ -9709,7 +9891,7 @@
       };
     }
 
-    flowEnumCheckExplicitTypeMismatch(pos, context, expectedType) {
+    flowEnumCheckExplicitTypeMismatch(loc, context, expectedType) {
       var {
         explicitType
       } = context;
@@ -9719,15 +9901,15 @@
       }
 
       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: [],
@@ -9755,17 +9937,15 @@
         }
 
         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);
@@ -9779,7 +9959,7 @@
         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;
@@ -9787,7 +9967,7 @@
 
           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;
@@ -9795,7 +9975,7 @@
 
           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;
@@ -9803,18 +9983,18 @@
 
           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:
@@ -9834,10 +10014,10 @@
       };
     }
 
-    flowEnumStringMembers(initializedMembers, defaultedMembers, _ref15) {
+    flowEnumStringMembers(initializedMembers, defaultedMembers, _ref14) {
       var {
         enumName
-      } = _ref15;
+      } = _ref14;
 
       if (initializedMembers.length === 0) {
         return defaultedMembers;
@@ -9845,7 +10025,7 @@
         return initializedMembers;
       } else if (defaultedMembers.length > initializedMembers.length) {
         for (var member of initializedMembers) {
-          this.flowEnumErrorStringMemberInconsistentlyInitailized(member.start, {
+          this.flowEnumErrorStringMemberInconsistentlyInitailized(member, {
             enumName
           });
         }
@@ -9853,7 +10033,7 @@
         return defaultedMembers;
       } else {
         for (var _member of defaultedMembers) {
-          this.flowEnumErrorStringMemberInconsistentlyInitailized(_member.start, {
+          this.flowEnumErrorStringMemberInconsistentlyInitailized(_member, {
             enumName
           });
         }
@@ -9862,14 +10042,14 @@
       }
     }
 
-    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
           });
@@ -9881,7 +10061,7 @@
         this.next();
 
         if (value !== "boolean" && value !== "number" && value !== "string" && value !== "symbol") {
-          this.flowEnumErrorInvalidExplicitType(this.state.start, {
+          this.flowEnumErrorInvalidExplicitType(this.state.startLoc, {
             enumName,
             suppliedType: value
           });
@@ -9893,11 +10073,9 @@
       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
       });
@@ -9961,7 +10139,7 @@
               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
                 });
@@ -9972,7 +10150,7 @@
               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
                 });
@@ -9982,9 +10160,9 @@
               this.expect(8);
               return this.finishNode(node, "EnumNumberBody");
             } else {
-              this.flowEnumErrorInconsistentMemberValues(nameLoc, {
-                enumName
-              });
+              this.raise(FlowErrors.EnumInconsistentMemberValues, {
+                at: nameLoc
+              }, enumName);
               return empty();
             }
           }
@@ -9994,10 +10172,7 @@
     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");
     }
 
@@ -10312,7 +10487,9 @@
 
       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);
@@ -10376,7 +10553,9 @@
 
       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);
@@ -10509,7 +10688,9 @@
           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;
@@ -10519,13 +10700,15 @@
           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) {
@@ -10652,13 +10835,19 @@
           }
         }
 
-        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));
           }
         }
       }
@@ -10674,7 +10863,9 @@
       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");
@@ -10787,7 +10978,7 @@
       return new TypeScriptScope(flags);
     }
 
-    declareName(name, bindingType, pos) {
+    declareName(name, bindingType, loc) {
       var scope = this.currentScope();
 
       if (bindingType & BIND_FLAGS_TS_EXPORT_ONLY) {
@@ -10800,7 +10991,7 @@
 
       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);
         }
 
@@ -11001,49 +11192,61 @@
     }
 
     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);
         }
       }
     }
@@ -11148,7 +11351,9 @@
       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();
@@ -11246,7 +11451,9 @@
       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) {
@@ -11267,21 +11474,25 @@
 
     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;
@@ -11334,47 +11545,67 @@
 
       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";
@@ -11516,7 +11747,9 @@
         } = 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";
@@ -11530,7 +11763,9 @@
         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");
@@ -11553,7 +11788,9 @@
         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;
         }
 
@@ -11749,7 +11986,9 @@
           return;
 
         default:
-          this.raise(node.start, TSErrors.UnexpectedReadonly);
+          this.raise(TSErrors.UnexpectedReadonly, {
+            node
+          });
       }
     }
 
@@ -11948,7 +12187,9 @@
       }
 
       if (containsEsc) {
-        this.raise(this.state.lastTokStart, ErrorMessages.InvalidEscapedReservedWord, "asserts");
+        this.raise(ErrorMessages.InvalidEscapedReservedWord, {
+          at: this.state.lastTokStartLoc
+        }, "asserts");
       }
 
       return true;
@@ -12002,7 +12243,9 @@
 
     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();
@@ -12016,11 +12259,13 @@
     }
 
     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;
@@ -12043,7 +12288,9 @@
         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();
@@ -12203,7 +12450,9 @@
       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;
@@ -12437,7 +12686,9 @@
       }));
 
       if (node.params.length === 0) {
-        this.raise(node.start, TSErrors.EmptyTypeArguments);
+        this.raise(TSErrors.EmptyTypeArguments, {
+          node
+        });
       }
 
       this.expect(46);
@@ -12468,7 +12719,9 @@
         readonly = modified.readonly;
 
         if (allowModifiers === false && (accessibility || readonly || override)) {
-          this.raise(startPos, TSErrors.UnexpectedParameterModifier);
+          this.raise(TSErrors.UnexpectedParameterModifier, {
+            at: startLoc
+          });
         }
       }
 
@@ -12488,7 +12741,9 @@
         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;
@@ -12517,7 +12772,9 @@
       }
 
       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);
@@ -12539,7 +12796,9 @@
     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
+          });
         }
       });
     }
@@ -12581,7 +12840,7 @@
       }
 
       if (this.match(45)) {
-        var missingParenErrorPos;
+        var missingParenErrorLoc;
         var result = this.tsTryParseAndCatch(() => {
           if (!noCalls && this.atPossibleAsyncArrow(base)) {
             var asyncArrowFn = this.tsTryParseGenericAsyncArrowFunction(startPos, startLoc);
@@ -12597,7 +12856,7 @@
 
           if (typeArguments) {
             if (isOptionalCall && !this.match(10)) {
-              missingParenErrorPos = this.state.pos;
+              missingParenErrorLoc = this.state.curPosition();
               this.unexpected();
             }
 
@@ -12622,8 +12881,8 @@
           this.unexpected();
         });
 
-        if (missingParenErrorPos) {
-          this.unexpected(missingParenErrorPos, 10);
+        if (missingParenErrorLoc) {
+          this.unexpected(missingParenErrorLoc, 10);
         }
 
         if (result) return result;
@@ -12693,7 +12952,9 @@
       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;
@@ -12800,7 +13061,9 @@
           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);
@@ -12823,31 +13086,43 @@
         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
+          });
         }
       }
 
@@ -12859,11 +13134,15 @@
       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
+        });
       }
     }
 
@@ -12920,7 +13199,9 @@
       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;
@@ -12968,14 +13249,18 @@
       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);
@@ -12983,11 +13268,15 @@
 
     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);
@@ -12998,11 +13287,15 @@
       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;
@@ -13053,7 +13346,7 @@
     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;
       }
 
@@ -13159,7 +13452,9 @@
       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
+        });
       }
     }
 
@@ -13192,7 +13487,9 @@
     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;
@@ -13273,7 +13570,9 @@
         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;
           }
 
@@ -13310,7 +13609,7 @@
           return call;
         }
 
-        this.unexpected(this.state.start, 10);
+        this.unexpected(null, 10);
       }
 
       return super.parseMaybeDecoratorArguments(expr);
@@ -13319,8 +13618,9 @@
     checkCommaAfterRest(close) {
       if (this.state.isAmbientContext && this.match(12) && this.lookaheadCharCode() === close) {
         this.next();
+        return false;
       } else {
-        super.checkCommaAfterRest(close);
+        return super.checkCommaAfterRest(close);
       }
     }
 
@@ -13336,7 +13636,9 @@
       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;
@@ -13385,7 +13687,9 @@
             if (!this.state.maybeInArrowParameters) {
               exprList[i] = this.typeCastToParameter(expr);
             } else {
-              this.raise(expr.start, TSErrors.UnexpectedTypeCastInParameter);
+              this.raise(TSErrors.UnexpectedTypeCastInParameter, {
+                node: expr
+              });
             }
 
             break;
@@ -13397,7 +13701,7 @@
 
     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;
     }
 
@@ -13479,7 +13783,9 @@
       } 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);
         }
@@ -13498,7 +13804,9 @@
           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), "]"));
         }
       }
 
@@ -13557,7 +13865,7 @@
       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();
@@ -13587,7 +13895,9 @@
       }
 
       if (hasTypeSpecifier && isInTypeOnlyImportExport) {
-        this.raise(pos, isImport ? TSErrors.TypeModifierIsUsedInTypeImports : TSErrors.TypeModifierIsUsedInTypeExports);
+        this.raise(isImport ? TSErrors.TypeModifierIsUsedInTypeImports : TSErrors.TypeModifierIsUsedInTypeExports, {
+          at: loc
+        });
       }
 
       node[leftOfAsKey] = leftOfAs;
@@ -13610,9 +13920,9 @@
 
   };
 
-  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) {
@@ -13735,7 +14045,9 @@
           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);
@@ -13835,7 +14147,7 @@
   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();
 
@@ -13849,7 +14161,7 @@
           }
         }
 
-        this.unexpected(v8IntrinsicStart);
+        this.unexpected(v8IntrinsicStartLoc);
       }
     }
 
@@ -14043,12 +14355,16 @@
 
         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
+          });
         }
       }
 
@@ -14070,8 +14386,10 @@
             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
+              });
             }
           }
 
@@ -14092,12 +14410,14 @@
 
         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";
@@ -14115,16 +14435,19 @@
 
     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) {
@@ -14142,8 +14465,10 @@
             this.unexpected(arg.start);
           }
 
-          if (trailingCommaPos) {
-            this.raiseTrailingCommaAfterRest(trailingCommaPos);
+          if (trailingCommaLoc) {
+            this.raise(ErrorMessages.RestTrailingComma, {
+              at: trailingCommaLoc
+            });
           }
 
           --end;
@@ -14157,7 +14482,9 @@
           this.toAssignable(elt, isLHS);
 
           if (elt.type === "RestElement") {
-            this.raiseRestNotLast(elt.start);
+            this.raise(ErrorMessages.RestTrailingComma, {
+              node: elt
+            });
           }
         }
       }
@@ -14268,14 +14595,18 @@
           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)) {
@@ -14358,23 +14689,29 @@
             } = 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;
@@ -14382,7 +14719,9 @@
 
         case "MemberExpression":
           if (bindingType !== BIND_NONE) {
-            this.raise(expr.start, ErrorMessages.InvalidPropertyBindingPattern);
+            this.raise(ErrorMessages.InvalidPropertyBindingPattern, {
+              node: expr
+            });
           }
 
           break;
@@ -14418,33 +14757,30 @@
 
         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;
     }
 
   }
@@ -14462,17 +14798,21 @@
 
       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
+            });
           }
         }
 
@@ -14541,9 +14881,9 @@
     }
 
     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) {
@@ -14593,12 +14933,12 @@
         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;
@@ -14661,15 +15001,14 @@
     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;
@@ -14685,7 +15024,7 @@
               return left;
             }
 
-            this.checkPipelineAtInfixOperator(left, leftStartPos);
+            this.checkPipelineAtInfixOperator(left, leftStartLoc);
           }
 
           var node = this.startNodeAt(leftStartPos, leftStartLoc);
@@ -14704,7 +15043,9 @@
             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
+              });
             }
           }
 
@@ -14713,7 +15054,9 @@
           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);
@@ -14738,7 +15081,9 @@
             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);
@@ -14765,16 +15110,20 @@
       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;
@@ -14782,7 +15131,9 @@
 
     checkExponentialAfterUnary(node) {
       if (this.match(53)) {
-        this.raise(node.argument.start, ErrorMessages.UnexpectedTokenUnaryExponentiation);
+        this.raise(ErrorMessages.UnexpectedTokenUnaryExponentiation, {
+          node: node.argument
+        });
       }
     }
 
@@ -14820,9 +15171,13 @@
           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
+            });
           }
         }
 
@@ -14842,7 +15197,7 @@
         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);
         }
       }
@@ -14950,10 +15305,12 @@
         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);
@@ -15029,14 +15386,16 @@
       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) {
@@ -15050,11 +15409,15 @@
         }
 
         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
+              });
             }
           }
         }
@@ -15077,11 +15440,13 @@
 
           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();
@@ -15105,7 +15470,7 @@
 
       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);
@@ -15143,7 +15508,9 @@
           }
 
           if (!this.match(10)) {
-            this.raise(this.state.lastTokStart, ErrorMessages.UnsupportedImport);
+            this.raise(ErrorMessages.UnsupportedImport, {
+              at: this.state.lastTokStartLoc
+            });
           }
 
           return this.finishNode(node, "Import");
@@ -15242,13 +15609,17 @@
             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();
           }
 
@@ -15340,7 +15711,7 @@
         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();
@@ -15349,38 +15720,32 @@
 
     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":
           {
@@ -15393,7 +15758,9 @@
           return tokenType === 27;
 
         default:
-          throw this.raise(start, ErrorMessages.PipeTopicRequiresHackPipes);
+          throw this.raise(ErrorMessages.PipeTopicRequiresHackPipes, {
+            at: startLoc
+          });
       }
     }
 
@@ -15403,7 +15770,9 @@
       this.prodParam.exit();
 
       if (this.hasPrecedingLineBreak()) {
-        this.raise(this.state.pos, ErrorMessages.LineTerminatorBeforeArrow);
+        this.raise(ErrorMessages.LineTerminatorBeforeArrow, {
+          at: this.state.curPosition()
+        });
       }
 
       this.expect(19);
@@ -15440,13 +15809,19 @@
       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");
@@ -15454,7 +15829,7 @@
 
     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);
@@ -15487,7 +15862,9 @@
       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");
@@ -15499,7 +15876,9 @@
 
       if (this.isContextual(96)) {
         if (!this.inModule) {
-          this.raise(id.start, SourceTypeModuleErrorMessages.ImportMetaOutsideModule);
+          this.raise(SourceTypeModuleErrorMessages.ImportMetaOutsideModule, {
+            node: id
+          });
         }
 
         this.sawUnambiguousESM = true;
@@ -15572,17 +15951,17 @@
       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;
           }
         }
@@ -15590,16 +15969,17 @@
         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;
@@ -15616,11 +15996,11 @@
       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);
 
@@ -15628,7 +16008,7 @@
         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];
       }
@@ -15636,7 +16016,7 @@
       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;
       }
 
@@ -15670,7 +16050,9 @@
         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;
@@ -15683,11 +16065,17 @@
       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);
@@ -15707,15 +16095,18 @@
     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)
+          });
         }
       }
 
@@ -15729,7 +16120,7 @@
       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;
     }
 
@@ -15772,7 +16163,7 @@
           this.expect(12);
 
           if (this.match(close)) {
-            this.addExtra(node, "trailingComma", this.state.lastTokStart);
+            this.addTrailingCommaExtraToNode(node);
             break;
           }
         }
@@ -15787,7 +16178,9 @@
         }
 
         if (isRecord && !this.isObjectProperty(prop) && prop.type !== "SpreadElement") {
-          this.raise(prop.start, ErrorMessages.InvalidRecordProperty);
+          this.raise(ErrorMessages.InvalidRecordProperty, {
+            node: prop
+          });
         }
 
         if (prop.shorthand) {
@@ -15810,6 +16203,11 @@
       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));
     }
@@ -15819,7 +16217,9 @@
 
       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)) {
@@ -15872,7 +16272,9 @@
 
           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();
           }
 
@@ -15897,18 +16299,17 @@
 
       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
+        });
       }
     }
 
@@ -15936,19 +16337,21 @@
       }
 
       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));
@@ -16001,8 +16404,9 @@
 
             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;
               }
@@ -16056,11 +16460,11 @@
       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;
       }
 
@@ -16070,7 +16474,7 @@
 
       if (params) {
         this.state.maybeInArrowParameters = true;
-        this.setArrowFunctionParameters(node, params, trailingCommaPos);
+        this.setArrowFunctionParameters(node, params, trailingCommaLoc);
       }
 
       this.state.maybeInArrowParameters = false;
@@ -16081,8 +16485,8 @@
       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) {
@@ -16108,8 +16512,12 @@
           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;
@@ -16155,7 +16563,7 @@
 
           if (this.match(close)) {
             if (nodeForExtra) {
-              this.addExtra(nodeForExtra, "trailingComma", this.state.lastTokStart);
+              this.addTrailingCommaExtraToNode(nodeForExtra);
             }
 
             this.next();
@@ -16174,7 +16582,9 @@
 
       if (this.match(12)) {
         if (!allowEmpty) {
-          this.raise(this.state.pos, ErrorMessages.UnexpectedToken, ",");
+          this.raise(ErrorMessages.UnexpectedToken, {
+            at: this.state.curPosition()
+          }, ",");
         }
 
         elt = null;
@@ -16186,7 +16596,9 @@
         this.expectPlugin("partialApplication");
 
         if (!allowPlaceholder) {
-          this.raise(this.state.start, ErrorMessages.UnexpectedArgumentPlaceholder);
+          this.raise(ErrorMessages.UnexpectedArgumentPlaceholder, {
+            at: this.state.startLoc
+          });
         }
 
         var node = this.startNode();
@@ -16214,7 +16626,7 @@
     parseIdentifierName(pos, liberal) {
       var name;
       var {
-        start,
+        startLoc,
         type
       } = this.state;
 
@@ -16231,7 +16643,7 @@
           this.replaceToken(124);
         }
       } else {
-        this.checkReservedWord(name, start, tokenIsKeyword, false);
+        this.checkReservedWord(name, startLoc, tokenIsKeyword, false);
       }
 
       this.next();
@@ -16249,35 +16661,49 @@
 
       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);
       }
     }
 
@@ -16293,10 +16719,12 @@
 
     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) {
@@ -16324,7 +16752,7 @@
 
     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;
@@ -16353,22 +16781,18 @@
       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);
 
@@ -16376,7 +16800,7 @@
         bodyNode.callee = childExpr;
         return this.finishNode(bodyNode, "PipelineBareFunction");
       } else {
-        this.checkSmartPipeTopicBodyEarlyErrors(startPos);
+        this.checkSmartPipeTopicBodyEarlyErrors(startLoc);
         bodyNode.expression = childExpr;
         return this.finishNode(bodyNode, "PipelineTopicExpression");
       }
@@ -16395,11 +16819,17 @@
       }
     }
 
-    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
+        });
       }
     }
 
@@ -16679,9 +17109,10 @@
       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);
         }
       }
 
@@ -16790,9 +17221,13 @@
 
           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
+              });
             }
           }
 
@@ -16822,7 +17257,9 @@
           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);
@@ -16851,7 +17288,9 @@
         case 78:
           {
             if (!this.options.allowImportExportEverywhere && !topLevel) {
-              this.raise(this.state.start, ErrorMessages.UnexpectedImportExport);
+              this.raise(ErrorMessages.UnexpectedImportExport, {
+                at: this.state.startLoc
+              });
             }
 
             this.next();
@@ -16879,7 +17318,9 @@
           {
             if (this.isAsyncFunction()) {
               if (context) {
-                this.raise(this.state.start, ErrorMessages.AsyncFunctionInSingleStatementContext);
+                this.raise(ErrorMessages.AsyncFunctionInSingleStatementContext, {
+                  at: this.state.startLoc
+                });
               }
 
               this.next();
@@ -16900,7 +17341,9 @@
 
     assertModuleNodeAllowed(node) {
       if (!this.options.allowImportExportEverywhere && !this.inModule) {
-        this.raise(node.start, SourceTypeModuleErrorMessages.ImportOutsideModule);
+        this.raise(SourceTypeModuleErrorMessages.ImportOutsideModule, {
+          node
+        });
       }
     }
 
@@ -16932,10 +17375,14 @@
         }
 
         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
+        });
       }
     }
 
@@ -17014,7 +17461,9 @@
       }
 
       if (i === this.state.labels.length) {
-        this.raise(node.start, ErrorMessages.IllegalBreakContinue, isBreak ? "break" : "continue");
+        this.raise(ErrorMessages.IllegalBreakContinue, {
+          node
+        }, isBreak ? "break" : "continue");
       }
     }
 
@@ -17045,17 +17494,17 @@
     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);
         }
 
@@ -17077,7 +17526,7 @@
           return this.parseForIn(node, _init, awaitAt);
         }
 
-        if (awaitAt > -1) {
+        if (awaitAt !== null) {
           this.unexpected(awaitAt);
         }
 
@@ -17091,9 +17540,15 @@
 
       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
+          });
         }
       }
 
@@ -17106,7 +17561,7 @@
         this.checkExpressionErrors(refExpressionErrors, true);
       }
 
-      if (awaitAt > -1) {
+      if (awaitAt !== null) {
         this.unexpected(awaitAt);
       }
 
@@ -17128,7 +17583,9 @@
 
     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();
@@ -17164,7 +17621,9 @@
             cur.test = this.parseExpression();
           } else {
             if (sawDefault) {
-              this.raise(this.state.lastTokStart, ErrorMessages.MultipleDefaultsInSwitch);
+              this.raise(ErrorMessages.MultipleDefaultsInSwitch, {
+                at: this.state.lastTokStartLoc
+              });
             }
 
             sawDefault = true;
@@ -17192,7 +17651,9 @@
       this.next();
 
       if (this.hasPrecedingLineBreak()) {
-        this.raise(this.state.lastTokEnd, ErrorMessages.NewlineAfterThrow);
+        this.raise(ErrorMessages.NewlineAfterThrow, {
+          at: this.state.lastTokEndLoc
+        });
       }
 
       node.argument = this.parseExpression();
@@ -17234,7 +17695,9 @@
       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");
@@ -17258,7 +17721,9 @@
 
     parseWithStatement(node) {
       if (this.state.strict) {
-        this.raise(this.state.start, ErrorMessages.StrictWith);
+        this.raise(ErrorMessages.StrictWith, {
+          at: this.state.startLoc
+        });
       }
 
       this.next();
@@ -17275,7 +17740,9 @@
     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);
         }
       }
 
@@ -17401,15 +17868,21 @@
       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;
@@ -17435,10 +17908,14 @@
         } 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;
@@ -17465,7 +17942,9 @@
       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);
@@ -17511,7 +17990,7 @@
 
     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) {
@@ -17551,7 +18030,9 @@
         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;
@@ -17573,7 +18054,9 @@
           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
+            });
           }
         }
       });
@@ -17581,7 +18064,9 @@
       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();
@@ -17650,7 +18135,9 @@
         }
 
         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);
@@ -17660,7 +18147,7 @@
       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()) {
@@ -17678,11 +18165,15 @@
           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;
@@ -17701,7 +18192,7 @@
         var isGenerator = this.eat(51);
 
         if (publicMember.optional) {
-          this.unexpected(maybeQuestionTokenStart);
+          this.unexpected(maybeQuestionTokenStartLoc);
         }
 
         method.kind = "method";
@@ -17715,7 +18206,9 @@
           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);
@@ -17732,7 +18225,9 @@
           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);
@@ -17753,17 +18248,20 @@
     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();
@@ -17789,13 +18287,17 @@
       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));
@@ -17804,7 +18306,7 @@
     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) {
@@ -17819,7 +18321,7 @@
     }
 
     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) {}
@@ -17859,7 +18361,9 @@
         if (optionalId || !isStatement) {
           node.id = null;
         } else {
-          this.unexpected(null, ErrorMessages.MissingClassName);
+          throw this.raise(ErrorMessages.MissingClassName, {
+            at: this.state.startLoc
+          });
         }
       }
     }
@@ -17992,22 +18496,32 @@
         }
 
         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) {
@@ -18079,10 +18593,12 @@
 
         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;
         }
       }
 
@@ -18100,7 +18616,9 @@
             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) {
@@ -18117,9 +18635,11 @@
               } = 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);
               }
             }
@@ -18140,7 +18660,9 @@
       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
+        });
       }
     }
 
@@ -18168,7 +18690,9 @@
 
     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);
@@ -18215,7 +18739,9 @@
         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;
@@ -18280,7 +18806,9 @@
         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);
@@ -18294,7 +18822,9 @@
         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);
@@ -18322,18 +18852,24 @@
         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);
@@ -18389,7 +18925,9 @@
           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);
@@ -18414,10 +18952,12 @@
         } = 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);
@@ -21237,7 +21777,7 @@
   }
 
   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__default["default"](_objectSpread__default["default"]({}, keep(node, fieldsToKeepInMenu)), {}, {
       items: keepItems(node.items, fieldsToKeepInMenuItem)