condenser 0.0.8 → 0.0.9

data/lib/condenser/processors/node_modules/@babel/parser/CHANGELOG.md

@@ -2,7 +2,7 @@
 
 > **Tags:**
 > - :boom:       [Breaking Change]
-> - :eyeglasses: [Spec Compliancy]
+> - :eyeglasses: [Spec Compliance]
 > - :rocket:     [New Feature]
 > - :bug:        [Bug Fix]
 > - :memo:       [Documentation]
@@ -56,7 +56,7 @@ See the [Babel Changelog](https://github.com/babel/babel/blob/master/CHANGELOG.m
 
 ## 7.0.0-beta.7 (2017-03-22)
 
-### Spec Compliancy
+### Spec Compliance
 * Remove babylon plugin for template revision since it's stage-4 (#426) (Henry Zhu)
 
 ### Bug Fix
@@ -200,7 +200,7 @@ declare module "C" {
 }
 ```
 
-### :eyeglasses: Spec Compliancy
+### :eyeglasses: Spec Compliance
 
 Forbid semicolons after decorators in classes ([#352](https://github.com/babel/babylon/pull/352)) (Kevin Gibbons)
 
@@ -305,7 +305,7 @@ AST spec: fix casing of `RegExpLiteral` ([#318](https://github.com/babel/babylon
 
 ## 6.15.0 (2017-01-10)
 
-### :eyeglasses: Spec Compliancy
+### :eyeglasses: Spec Compliance
 
 Add support for Flow shorthand import type ([#267](https://github.com/babel/babylon/pull/267)) (Jeff Morrison)
 
@@ -411,7 +411,7 @@ Will include all parser plugins instead of specifying each one individually. Use
 
 ## 6.14.0 (2016-11-16)
 
-### :eyeglasses: Spec Compliancy
+### :eyeglasses: Spec Compliance
 
 Throw error for reserved words `enum` and `await` ([#195](https://github.com/babel/babylon/pull/195)) (Kai Cataldo)
 
@@ -491,7 +491,7 @@ With that test case, there was a ~95ms savings by removing the need for node to
 
 ## v6.13.0 (2016-10-21)
 
-### :eyeglasses: Spec Compliancy
+### :eyeglasses: Spec Compliance
 
 Property variance type annotations for Flow plugin ([#161](https://github.com/babel/babylon/pull/161)) (Sam Goldman)
 
@@ -549,7 +549,7 @@ Fixes two tests that are failing after the merge of #172 ([#177](https://github.
 
 ## v6.12.0 (2016-10-14)
 
-### :eyeglasses: Spec Compliancy
+### :eyeglasses: Spec Compliance
 
 Implement import() syntax ([#163](https://github.com/babel/babylon/pull/163)) (Jordan Gensler)
 
@@ -643,7 +643,7 @@ export const { foo: [ ,, qux7 ] } = bar;
 
 ## v6.11.5 (2016-10-12)
 
-### :eyeglasses: Spec Compliancy
+### :eyeglasses: Spec Compliance
 
 Fix: Check for duplicate named exports in exported destructuring assignments ([#144](https://github.com/babel/babylon/pull/144)) (Kai Cataldo)
 
@@ -689,7 +689,7 @@ Temporary rollback for erroring on trailing comma with spread (#154) (Henry Zhu)
 
 ## v6.11.3 (2016-10-01)
 
-### :eyeglasses: Spec Compliancy
+### :eyeglasses: Spec Compliance
 
 Add static errors for object rest (#149) ([@danez](https://github.com/danez))
 
@@ -782,7 +782,7 @@ export toString from './toString';
 
 ## 6.11.0 (2016-09-22)
 
-### Spec Compliancy (will break CI)
+### Spec Compliance (will break CI)
 
 - Disallow duplicate named exports ([#107](https://github.com/babel/babylon/pull/107)) @kaicataldo
 
@@ -862,9 +862,9 @@ for (+i in {});
 
 ## 6.10.0 (2016-09-19)
 
-> We plan to include some spec compliancy bugs in patch versions. An example was the multiple default exports issue.
+> We plan to include some spec compliance bugs in patch versions. An example was the multiple default exports issue.
 
-### Spec Compliancy
+### Spec Compliance
 
 * Implement ES2016 check for simple parameter list in strict mode ([#106](https://github.com/babel/babylon/pull/106)) (Timothy Gu)
 
@@ -1023,7 +1023,7 @@ declare module "foo" {
 - The existential type `*` is not a valid type parameter.
 - The existential type `*` is a primary type
 
-### Spec Compliancy
+### Spec Compliance
 - The param list for type parameter declarations now consists of `TypeParameter` nodes
 - New `TypeParameter` AST Node (replaces using the `Identifier` node before)
 

data/lib/condenser/processors/node_modules/@babel/parser/lib/index.js

@@ -138,26 +138,30 @@ const types = {
   }),
   pipeline: createBinop("|>", 0),
   nullishCoalescing: createBinop("??", 1),
-  logicalOR: createBinop("||", 1),
-  logicalAND: createBinop("&&", 2),
-  bitwiseOR: createBinop("|", 3),
-  bitwiseXOR: createBinop("^", 4),
-  bitwiseAND: createBinop("&", 5),
-  equality: createBinop("==/!=/===/!==", 6),
-  relational: createBinop("</>/<=/>=", 7),
-  bitShift: createBinop("<</>>/>>>", 8),
+  logicalOR: createBinop("||", 2),
+  logicalAND: createBinop("&&", 3),
+  bitwiseOR: createBinop("|", 4),
+  bitwiseXOR: createBinop("^", 5),
+  bitwiseAND: createBinop("&", 6),
+  equality: createBinop("==/!=/===/!==", 7),
+  relational: createBinop("</>/<=/>=", 8),
+  bitShift: createBinop("<</>>/>>>", 9),
   plusMin: new TokenType("+/-", {
     beforeExpr,
-    binop: 9,
+    binop: 10,
     prefix,
     startsExpr
   }),
-  modulo: createBinop("%", 10),
-  star: createBinop("*", 10),
-  slash: createBinop("/", 10),
-  exponent: new TokenType("**", {
+  modulo: new TokenType("%", {
     beforeExpr,
     binop: 11,
+    startsExpr
+  }),
+  star: createBinop("*", 11),
+  slash: createBinop("/", 11),
+  exponent: new TokenType("**", {
+    beforeExpr,
+    binop: 12,
     rightAssociative: true
   }),
   _break: createKeyword("break"),
@@ -232,11 +236,11 @@ const types = {
   }),
   _in: createKeyword("in", {
     beforeExpr,
-    binop: 7
+    binop: 8
   }),
   _instanceof: createKeyword("instanceof", {
     beforeExpr,
-    binop: 7
+    binop: 8
   }),
   _typeof: createKeyword("typeof", {
     beforeExpr,
@@ -255,17 +259,18 @@ const types = {
   })
 };
 
-const SCOPE_OTHER = 0b000000000,
-      SCOPE_PROGRAM = 0b000000001,
-      SCOPE_FUNCTION = 0b000000010,
-      SCOPE_ASYNC = 0b000000100,
-      SCOPE_GENERATOR = 0b000001000,
-      SCOPE_ARROW = 0b000010000,
-      SCOPE_SIMPLE_CATCH = 0b000100000,
-      SCOPE_SUPER = 0b001000000,
-      SCOPE_DIRECT_SUPER = 0b010000000,
-      SCOPE_CLASS = 0b100000000,
-      SCOPE_VAR = SCOPE_PROGRAM | SCOPE_FUNCTION;
+const SCOPE_OTHER = 0b0000000000,
+      SCOPE_PROGRAM = 0b0000000001,
+      SCOPE_FUNCTION = 0b0000000010,
+      SCOPE_ASYNC = 0b0000000100,
+      SCOPE_GENERATOR = 0b0000001000,
+      SCOPE_ARROW = 0b0000010000,
+      SCOPE_SIMPLE_CATCH = 0b0000100000,
+      SCOPE_SUPER = 0b0001000000,
+      SCOPE_DIRECT_SUPER = 0b0010000000,
+      SCOPE_CLASS = 0b0100000000,
+      SCOPE_TS_MODULE = 0b1000000000,
+      SCOPE_VAR = SCOPE_PROGRAM | SCOPE_FUNCTION | SCOPE_TS_MODULE;
 function functionFlags(isAsync, isGenerator) {
   return SCOPE_FUNCTION | (isAsync ? SCOPE_ASYNC : 0) | (isGenerator ? SCOPE_GENERATOR : 0);
 }
@@ -286,11 +291,11 @@ const BIND_CLASS = BIND_KIND_VALUE | BIND_KIND_TYPE | BIND_SCOPE_LEXICAL | BIND_
       BIND_TS_INTERFACE = 0 | BIND_KIND_TYPE | 0 | BIND_FLAGS_CLASS,
       BIND_TS_TYPE = 0 | BIND_KIND_TYPE | 0 | 0,
       BIND_TS_ENUM = BIND_KIND_VALUE | BIND_KIND_TYPE | BIND_SCOPE_LEXICAL | BIND_FLAGS_TS_ENUM,
-      BIND_TS_FN_TYPE = 0 | 0 | 0 | BIND_FLAGS_TS_EXPORT_ONLY,
+      BIND_TS_AMBIENT = 0 | 0 | 0 | BIND_FLAGS_TS_EXPORT_ONLY,
       BIND_NONE = 0 | 0 | 0 | BIND_FLAGS_NONE,
       BIND_OUTSIDE = BIND_KIND_VALUE | 0 | 0 | BIND_FLAGS_NONE,
       BIND_TS_CONST_ENUM = BIND_TS_ENUM | BIND_FLAGS_TS_CONST_ENUM,
-      BIND_TS_NAMESPACE = BIND_TS_FN_TYPE;
+      BIND_TS_NAMESPACE = 0 | 0 | 0 | BIND_FLAGS_TS_EXPORT_ONLY;
 
 function isSimpleProperty(node) {
   return node != null && node.type === "Property" && node.kind === "init" && node.method === false;
@@ -315,6 +320,13 @@ var estree = (superClass => class extends superClass {
     return node;
   }
 
+  estreeParseBigIntLiteral(value) {
+    const bigInt = typeof BigInt !== "undefined" ? BigInt(value) : null;
+    const node = this.estreeParseLiteral(bigInt);
+    node.bigint = String(node.value || value);
+    return node;
+  }
+
   estreeParseLiteral(value) {
     return this.parseLiteral(value, "Literal");
   }
@@ -354,27 +366,25 @@ var estree = (superClass => class extends superClass {
       } else {
         this.raise(start, "setter must have exactly one formal parameter");
       }
-    }
-
-    if (prop.kind === "set" && prop.value.params[0].type === "RestElement") {
+    } else if (prop.kind === "set" && prop.value.params[0].type === "RestElement") {
       this.raise(start, "setter function argument must not be a rest parameter");
     }
   }
 
-  checkLVal(expr, bindingType = BIND_NONE, checkClashes, contextDescription) {
+  checkLVal(expr, bindingType = BIND_NONE, checkClashes, contextDescription, disallowLetBinding) {
     switch (expr.type) {
       case "ObjectPattern":
         expr.properties.forEach(prop => {
-          this.checkLVal(prop.type === "Property" ? prop.value : prop, bindingType, checkClashes, "object destructuring pattern");
+          this.checkLVal(prop.type === "Property" ? prop.value : prop, bindingType, checkClashes, "object destructuring pattern", disallowLetBinding);
         });
         break;
 
       default:
-        super.checkLVal(expr, bindingType, checkClashes, contextDescription);
+        super.checkLVal(expr, bindingType, checkClashes, contextDescription, disallowLetBinding);
     }
   }
 
-  checkPropClash(prop, propHash) {
+  checkDuplicatedProto(prop, protoRef) {
     if (prop.type === "SpreadElement" || prop.computed || prop.method || prop.shorthand) {
       return;
     }
@@ -383,11 +393,11 @@ var estree = (superClass => class extends superClass {
     const name = key.type === "Identifier" ? key.name : String(key.value);
 
     if (name === "__proto__" && prop.kind === "init") {
-      if (propHash.proto) {
-        this.raise(key.start, "Redefinition of __proto__ property");
+      if (protoRef.used && !protoRef.start) {
+        protoRef.start = key.start;
       }
 
-      propHash.proto = true;
+      protoRef.used = true;
     }
   }
 
@@ -440,13 +450,16 @@ var estree = (superClass => class extends superClass {
 
   parseExprAtom(refShorthandDefaultPos) {
     switch (this.state.type) {
-      case types.regexp:
-        return this.estreeParseRegExpLiteral(this.state.value);
-
       case types.num:
       case types.string:
         return this.estreeParseLiteral(this.state.value);
 
+      case types.regexp:
+        return this.estreeParseRegExpLiteral(this.state.value);
+
+      case types.bigint:
+        return this.estreeParseBigIntLiteral(this.state.value);
+
       case types._null:
         return this.estreeParseLiteral(null);
 
@@ -518,14 +531,35 @@ var estree = (superClass => class extends superClass {
 
   toAssignableObjectExpressionProp(prop, isBinding, isLast) {
     if (prop.kind === "get" || prop.kind === "set") {
-      this.raise(prop.key.start, "Object pattern can't contain getter or setter");
+      throw this.raise(prop.key.start, "Object pattern can't contain getter or setter");
     } else if (prop.method) {
-      this.raise(prop.key.start, "Object pattern can't contain methods");
+      throw this.raise(prop.key.start, "Object pattern can't contain methods");
     } else {
       super.toAssignableObjectExpressionProp(prop, isBinding, isLast);
     }
   }
 
+  finishCallExpression(node, optional) {
+    super.finishCallExpression(node, optional);
+
+    if (node.callee.type === "Import") {
+      node.type = "ImportExpression";
+      node.source = node.arguments[0];
+      delete node.arguments;
+      delete node.callee;
+    }
+
+    return node;
+  }
+
+  toReferencedListDeep(exprList, isParenthesizedExpr) {
+    if (!exprList) {
+      return;
+    }
+
+    super.toReferencedListDeep(exprList, isParenthesizedExpr);
+  }
+
 });
 
 const lineBreak = /\r\n?|[\n\u2028\u2029]/;
@@ -667,15 +701,18 @@ const reservedWords = {
   strictBind: ["eval", "arguments"]
 };
 const reservedWordsStrictSet = new Set(reservedWords.strict);
-const reservedWordsStrictBindSet = new Set(reservedWords.strict.concat(reservedWords.strictBind));
+const reservedWordsStrictBindSet = new Set(reservedWords.strictBind);
 const isReservedWord = (word, inModule) => {
   return inModule && word === "await" || word === "enum";
 };
 function isStrictReservedWord(word, inModule) {
   return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
 }
+function isStrictBindOnlyReservedWord(word) {
+  return reservedWordsStrictBindSet.has(word);
+}
 function isStrictBindReservedWord(word, inModule) {
-  return isReservedWord(word, inModule) || reservedWordsStrictBindSet.has(word);
+  return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);
 }
 function isKeyword(word) {
   return keywords.has(word);
@@ -732,7 +769,7 @@ function isIdentifierChar(code) {
   return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
 }
 
-const reservedTypes = ["any", "bool", "boolean", "empty", "false", "mixed", "null", "number", "static", "string", "true", "typeof", "void", "interface", "extends", "_"];
+const reservedTypes = new Set(["_", "any", "bool", "boolean", "empty", "extends", "false", "interface", "mixed", "null", "number", "static", "string", "true", "typeof", "void"]);
 
 function isEsModuleType(bodyElement) {
   return bodyElement.type === "DeclareExportAllDeclaration" || bodyElement.type === "DeclareExportDeclaration" && (!bodyElement.declaration || bodyElement.declaration.type !== "TypeAlias" && bodyElement.declaration.type !== "InterfaceDeclaration");
@@ -775,6 +812,10 @@ var flow = (superClass => class extends superClass {
     return this.getPluginOption("flow", "all") || this.flowPragma === "flow";
   }
 
+  shouldParseEnums() {
+    return !!this.getPluginOption("flow", "enums");
+  }
+
   finishToken(type, val) {
     if (type !== types.string && type !== types.semi && type !== types.interpreterDirective) {
       if (this.flowPragma === undefined) {
@@ -896,7 +937,7 @@ var flow = (superClass => class extends superClass {
         return this.flowParseDeclareModuleExports(node);
       } else {
         if (insideModule) {
-          this.unexpected(this.state.lastTokStart, "`declare module` cannot be used inside another `declare module`");
+          this.raise(this.state.lastTokStart, "`declare module` cannot be used inside another `declare module`");
         }
 
         return this.flowParseDeclareModule(node);
@@ -917,6 +958,7 @@ var flow = (superClass => class extends superClass {
   flowParseDeclareVariable(node) {
     this.next();
     node.id = this.flowParseTypeAnnotatableIdentifier(true);
+    this.scope.declareName(node.id.name, BIND_VAR, node.id.start);
     this.semicolon();
     return this.finishNode(node, "DeclareVariable");
   }
@@ -941,7 +983,7 @@ var flow = (superClass => class extends superClass {
         this.next();
 
         if (!this.isContextual("type") && !this.match(types._typeof)) {
-          this.unexpected(this.state.lastTokStart, "Imports within a `declare module` body must always be `import type` or `import typeof`");
+          this.raise(this.state.lastTokStart, "Imports within a `declare module` body must always be `import type` or `import typeof`");
         }
 
         this.parseImport(bodyNode);
@@ -962,16 +1004,16 @@ var flow = (superClass => class extends superClass {
     body.forEach(bodyElement => {
       if (isEsModuleType(bodyElement)) {
         if (kind === "CommonJS") {
-          this.unexpected(bodyElement.start, errorMessage);
+          this.raise(bodyElement.start, errorMessage);
         }
 
         kind = "ES";
       } else if (bodyElement.type === "DeclareModuleExports") {
         if (hasModuleExport) {
-          this.unexpected(bodyElement.start, "Duplicate `declare module.exports` statement");
+          this.raise(bodyElement.start, "Duplicate `declare module.exports` statement");
         }
 
-        if (kind === "ES") this.unexpected(bodyElement.start, errorMessage);
+        if (kind === "ES") this.raise(bodyElement.start, errorMessage);
         kind = "CommonJS";
         hasModuleExport = true;
       }
@@ -1050,7 +1092,8 @@ var flow = (superClass => class extends superClass {
   }
 
   flowParseInterfaceish(node, isClass = false) {
-    node.id = this.flowParseRestrictedIdentifier(!isClass);
+    node.id = this.flowParseRestrictedIdentifier(!isClass, true);
+    this.scope.declareName(node.id.name, isClass ? BIND_FUNCTION : BIND_LEXICAL, node.id.start);
 
     if (this.isRelational("<")) {
       node.typeParameters = this.flowParseTypeParameterDeclaration();
@@ -1113,23 +1156,28 @@ var flow = (superClass => class extends superClass {
 
   checkNotUnderscore(word) {
     if (word === "_") {
-      throw this.unexpected(null, "`_` is only allowed as a type argument to call or new");
+      this.raise(this.state.start, "`_` is only allowed as a type argument to call or new");
     }
   }
 
-  checkReservedType(word, startLoc) {
-    if (reservedTypes.indexOf(word) > -1) {
+  checkReservedType(word, startLoc, declaration) {
+    if (!reservedTypes.has(word)) return;
+
+    if (declaration) {
       this.raise(startLoc, `Cannot overwrite reserved type ${word}`);
+      return;
     }
+
+    this.raise(startLoc, `Unexpected reserved type ${word}`);
   }
 
-  flowParseRestrictedIdentifier(liberal) {
-    this.checkReservedType(this.state.value, this.state.start);
+  flowParseRestrictedIdentifier(liberal, declaration) {
+    this.checkReservedType(this.state.value, this.state.start, declaration);
     return this.parseIdentifier(liberal);
   }
 
   flowParseTypeAlias(node) {
-    node.id = this.flowParseRestrictedIdentifier();
+    node.id = this.flowParseRestrictedIdentifier(false, true);
     this.scope.declareName(node.id.name, BIND_LEXICAL, node.id.start);
 
     if (this.isRelational("<")) {
@@ -1145,7 +1193,7 @@ var flow = (superClass => class extends superClass {
 
   flowParseOpaqueType(node, declare) {
     this.expectContextual("type");
-    node.id = this.flowParseRestrictedIdentifier(true);
+    node.id = this.flowParseRestrictedIdentifier(true, true);
     this.scope.declareName(node.id.name, BIND_LEXICAL, node.id.start);
 
     if (this.isRelational("<")) {
@@ -1184,7 +1232,7 @@ var flow = (superClass => class extends superClass {
       node.default = this.flowParseType();
     } else {
       if (requireDefault) {
-        this.unexpected(nodeStart, "Type parameter declaration needs a default, since a preceding type parameter declaration has a default.");
+        this.raise(nodeStart, "Type parameter declaration needs a default, since a preceding type parameter declaration has a default.");
       }
     }
 
@@ -1399,6 +1447,7 @@ var flow = (superClass => class extends superClass {
     while (!this.match(endDelim)) {
       let isStatic = false;
       let protoStart = null;
+      let inexactStart = null;
       const node = this.startNode();
 
       if (allowProto && this.isContextual("proto")) {
@@ -1458,16 +1507,21 @@ var flow = (superClass => class extends superClass {
           }
         }
 
-        const propOrInexact = this.flowParseObjectTypeProperty(node, isStatic, protoStart, variance, kind, allowSpread, allowInexact);
+        const propOrInexact = this.flowParseObjectTypeProperty(node, isStatic, protoStart, variance, kind, allowSpread, allowInexact != null ? allowInexact : !exact);
 
         if (propOrInexact === null) {
           inexact = true;
+          inexactStart = this.state.lastTokStart;
         } else {
           nodeStart.properties.push(propOrInexact);
         }
       }
 
       this.flowObjectTypeSemicolon();
+
+      if (inexactStart && !this.match(types.braceR) && !this.match(types.braceBarR)) {
+        this.raise(inexactStart, "Explicit inexact syntax must appear at the end of an inexact object");
+      }
     }
 
     this.expect(endDelim);
@@ -1482,33 +1536,33 @@ var flow = (superClass => class extends superClass {
   }
 
   flowParseObjectTypeProperty(node, isStatic, protoStart, variance, kind, allowSpread, allowInexact) {
-    if (this.match(types.ellipsis)) {
-      if (!allowSpread) {
-        this.unexpected(null, "Spread operator cannot appear in class or interface definitions");
-      }
+    if (this.eat(types.ellipsis)) {
+      const isInexactToken = this.match(types.comma) || this.match(types.semi) || this.match(types.braceR) || this.match(types.braceBarR);
 
-      if (protoStart != null) {
-        this.unexpected(protoStart);
-      }
+      if (isInexactToken) {
+        if (!allowSpread) {
+          this.raise(this.state.lastTokStart, "Explicit inexact syntax cannot appear in class or interface definitions");
+        } else if (!allowInexact) {
+          this.raise(this.state.lastTokStart, "Explicit inexact syntax cannot appear inside an explicit exact object type");
+        }
 
-      if (variance) {
-        this.unexpected(variance.start, "Spread properties cannot have variance");
-      }
+        if (variance) {
+          this.raise(variance.start, "Explicit inexact syntax cannot have variance");
+        }
 
-      this.expect(types.ellipsis);
-      const isInexactToken = this.eat(types.comma) || this.eat(types.semi);
+        return null;
+      }
 
-      if (this.match(types.braceR)) {
-        if (allowInexact) return null;
-        this.unexpected(null, "Explicit inexact syntax is only allowed inside inexact objects");
+      if (!allowSpread) {
+        this.raise(this.state.lastTokStart, "Spread operator cannot appear in class or interface definitions");
       }
 
-      if (this.match(types.braceBarR)) {
-        this.unexpected(null, "Explicit inexact syntax cannot appear inside an explicit exact object type");
+      if (protoStart != null) {
+        this.unexpected(protoStart);
       }
 
-      if (isInexactToken) {
-        this.unexpected(null, "Explicit inexact syntax must appear at the end of an inexact object");
+      if (variance) {
+        this.raise(variance.start, "Spread properties cannot have variance");
       }
 
       node.argument = this.flowParseType();
@@ -1580,12 +1634,12 @@ var flow = (superClass => class extends superClass {
   flowParseQualifiedTypeIdentifier(startPos, startLoc, id) {
     startPos = startPos || this.state.start;
     startLoc = startLoc || this.state.startLoc;
-    let node = id || this.parseIdentifier();
+    let node = id || this.flowParseRestrictedIdentifier(true);
 
     while (this.eat(types.dot)) {
       const node2 = this.startNodeAt(startPos, startLoc);
       node2.qualification = node;
-      node2.id = this.parseIdentifier();
+      node2.id = this.flowParseRestrictedIdentifier(true);
       node = this.finishNode(node2, "QualifiedTypeIdentifier");
     }
 
@@ -1823,7 +1877,7 @@ var flow = (superClass => class extends superClass {
             return this.parseLiteral(-this.state.value, "BigIntLiteralTypeAnnotation", node.start, node.loc.start);
           }
 
-          this.unexpected(null, `Unexpected token, expected "number" or "bigint"`);
+          throw this.raise(this.state.start, `Unexpected token, expected "number" or "bigint"`);
         }
 
         this.unexpected();
@@ -2017,6 +2071,10 @@ var flow = (superClass => class extends superClass {
       const node = this.startNode();
       this.next();
       return this.flowParseInterface(node);
+    } else if (this.shouldParseEnums() && this.isContextual("enum")) {
+      const node = this.startNode();
+      this.next();
+      return this.flowParseEnumDeclaration(node);
     } else {
       const stmt = super.parseStatement(context, topLevel);
 
@@ -2049,34 +2107,40 @@ var flow = (superClass => class extends superClass {
   }
 
   shouldParseExportDeclaration() {
-    return this.isContextual("type") || this.isContextual("interface") || this.isContextual("opaque") || super.shouldParseExportDeclaration();
+    return this.isContextual("type") || this.isContextual("interface") || this.isContextual("opaque") || this.shouldParseEnums() && this.isContextual("enum") || super.shouldParseExportDeclaration();
   }
 
   isExportDefaultSpecifier() {
-    if (this.match(types.name) && (this.state.value === "type" || this.state.value === "interface" || this.state.value === "opaque")) {
+    if (this.match(types.name) && (this.state.value === "type" || this.state.value === "interface" || this.state.value === "opaque" || this.shouldParseEnums() && this.state.value === "enum")) {
       return false;
     }
 
     return super.isExportDefaultSpecifier();
   }
 
+  parseExportDefaultExpression() {
+    if (this.shouldParseEnums() && this.isContextual("enum")) {
+      const node = this.startNode();
+      this.next();
+      return this.flowParseEnumDeclaration(node);
+    }
+
+    return super.parseExportDefaultExpression();
+  }
+
   parseConditional(expr, noIn, startPos, startLoc, refNeedsArrowPos) {
     if (!this.match(types.question)) return expr;
 
     if (refNeedsArrowPos) {
-      const state = this.state.clone();
+      const result = this.tryParse(() => super.parseConditional(expr, noIn, startPos, startLoc));
 
-      try {
-        return super.parseConditional(expr, noIn, startPos, startLoc);
-      } catch (err) {
-        if (err instanceof SyntaxError) {
-          this.state = state;
-          refNeedsArrowPos.start = err.pos || this.state.start;
-          return expr;
-        } else {
-          throw err;
-        }
+      if (!result.node) {
+        refNeedsArrowPos.start = result.error.pos || this.state.start;
+        return expr;
       }
+
+      if (result.error) this.state = result.failState;
+      return result.node;
     }
 
     this.expect(types.question);
@@ -2119,10 +2183,9 @@ var flow = (superClass => class extends superClass {
           failed
         } = this.tryParseConditionalConsequent());
       }
-
-      this.getArrowLikeExpressions(consequent, true);
     }
 
+    this.getArrowLikeExpressions(consequent, true);
     this.state.noArrowAt = originalNoArrowAt;
     this.expect(types.colon);
     node.test = expr;
@@ -2151,10 +2214,7 @@ var flow = (superClass => class extends superClass {
 
       if (node.type === "ArrowFunctionExpression") {
         if (node.typeParameters || !node.returnType) {
-          this.toAssignableList(node.params, true, "arrow function parameters");
-          this.scope.enter(functionFlags(false, false) | SCOPE_ARROW);
-          super.checkParams(node, false, true);
-          this.scope.exit();
+          this.finishArrowValidation(node);
         } else {
           arrows.push(node);
         }
@@ -2167,21 +2227,20 @@ var flow = (superClass => class extends superClass {
     }
 
     if (disallowInvalid) {
-      for (let i = 0; i < arrows.length; i++) {
-        this.toAssignableList(node.params, true, "arrow function parameters");
-      }
-
+      arrows.forEach(node => this.finishArrowValidation(node));
       return [arrows, []];
     }
 
-    return partition(arrows, node => {
-      try {
-        this.toAssignableList(node.params, true, "arrow function parameters");
-        return true;
-      } catch (err) {
-        return false;
-      }
-    });
+    return partition(arrows, node => node.params.every(param => this.isAssignable(param, true)));
+  }
+
+  finishArrowValidation(node) {
+    var _node$extra;
+
+    this.toAssignableList(node.params, true, "arrow function parameters", (_node$extra = node.extra) == null ? void 0 : _node$extra.trailingComma);
+    this.scope.enter(functionFlags(false, false) | SCOPE_ARROW);
+    super.checkParams(node, false, true);
+    this.scope.exit();
   }
 
   forwardNoArrowParamsConversionAt(node, parse) {
@@ -2257,6 +2316,11 @@ var flow = (superClass => class extends superClass {
       const declarationNode = this.startNode();
       this.next();
       return this.flowParseInterface(declarationNode);
+    } else if (this.shouldParseEnums() && this.isContextual("enum")) {
+      node.exportKind = "value";
+      const declarationNode = this.startNode();
+      this.next();
+      return this.flowParseEnumDeclaration(declarationNode);
     } else {
       return super.parseExportDeclaration(node);
     }
@@ -2309,6 +2373,47 @@ var flow = (superClass => class extends superClass {
     }
   }
 
+  isAssignable(node, isBinding) {
+    switch (node.type) {
+      case "Identifier":
+      case "ObjectPattern":
+      case "ArrayPattern":
+      case "AssignmentPattern":
+        return true;
+
+      case "ObjectExpression":
+        {
+          const last = node.properties.length - 1;
+          return node.properties.every((prop, i) => {
+            return prop.type !== "ObjectMethod" && (i === last || prop.type === "SpreadElement") && this.isAssignable(prop);
+          });
+        }
+
+      case "ObjectProperty":
+        return this.isAssignable(node.value);
+
+      case "SpreadElement":
+        return this.isAssignable(node.argument);
+
+      case "ArrayExpression":
+        return node.elements.every(element => this.isAssignable(element));
+
+      case "AssignmentExpression":
+        return node.operator === "=";
+
+      case "ParenthesizedExpression":
+      case "TypeCastExpression":
+        return this.isAssignable(node.expression);
+
+      case "MemberExpression":
+      case "OptionalMemberExpression":
+        return !isBinding;
+
+      default:
+        return false;
+    }
+  }
+
   toAssignable(node, isBinding, contextDescription) {
     if (node.type === "TypeCastExpression") {
       return super.toAssignable(this.typeCastToParameter(node), isBinding, contextDescription);
@@ -2317,7 +2422,7 @@ var flow = (superClass => class extends superClass {
     }
   }
 
-  toAssignableList(exprList, isBinding, contextDescription) {
+  toAssignableList(exprList, isBinding, contextDescription, trailingCommaPos) {
     for (let i = 0; i < exprList.length; i++) {
       const expr = exprList[i];
 
@@ -2326,7 +2431,7 @@ var flow = (superClass => class extends superClass {
       }
     }
 
-    return super.toAssignableList(exprList, isBinding, contextDescription);
+    return super.toAssignableList(exprList, isBinding, contextDescription, trailingCommaPos);
   }
 
   toReferencedList(exprList, isParenthesizedExpr) {
@@ -2459,7 +2564,7 @@ var flow = (superClass => class extends superClass {
   parseAssignableListItemTypes(param) {
     if (this.eat(types.question)) {
       if (param.type !== "Identifier") {
-        throw this.raise(param.start, "A binding pattern parameter cannot be optional in an implementation signature.");
+        this.raise(param.start, "A binding pattern parameter cannot be optional in an implementation signature.");
       }
 
       param.optional = true;
@@ -2492,7 +2597,7 @@ var flow = (superClass => class extends superClass {
   }
 
   parseImportSpecifierLocal(node, specifier, type, contextDescription) {
-    specifier.local = hasTypeImportKind(node) ? this.flowParseRestrictedIdentifier(true) : this.parseIdentifier();
+    specifier.local = hasTypeImportKind(node) ? this.flowParseRestrictedIdentifier(true, true) : this.parseIdentifier();
     this.checkLVal(specifier.local, BIND_LEXICAL, undefined, contextDescription);
     node.specifiers.push(this.finishNode(specifier, type));
   }
@@ -2574,7 +2679,7 @@ var flow = (superClass => class extends superClass {
     }
 
     if (nodeIsTypeImport || specifierIsTypeImport) {
-      this.checkReservedType(specifier.local.name, specifier.local.start);
+      this.checkReservedType(specifier.local.name, specifier.local.start, true);
     }
 
     if (isBinding && !nodeIsTypeImport && !specifierIsTypeImport) {
@@ -2620,49 +2725,50 @@ var flow = (superClass => class extends superClass {
   }
 
   parseMaybeAssign(noIn, refShorthandDefaultPos, afterLeftParse, refNeedsArrowPos) {
-    let jsxError = null;
+    let state = null;
+    let jsx;
 
     if (this.hasPlugin("jsx") && (this.match(types.jsxTagStart) || this.isRelational("<"))) {
-      const state = this.state.clone();
-
-      try {
-        return super.parseMaybeAssign(noIn, refShorthandDefaultPos, afterLeftParse, refNeedsArrowPos);
-      } catch (err) {
-        if (err instanceof SyntaxError) {
-          this.state = state;
-          const cLength = this.state.context.length;
-
-          if (this.state.context[cLength - 1] === types$1.j_oTag) {
-            this.state.context.length -= 2;
-          }
+      state = this.state.clone();
+      jsx = this.tryParse(() => super.parseMaybeAssign(noIn, refShorthandDefaultPos, afterLeftParse, refNeedsArrowPos), state);
+      if (!jsx.error) return jsx.node;
+      const {
+        context
+      } = this.state;
 
-          jsxError = err;
-        } else {
-          throw err;
-        }
+      if (context[context.length - 1] === types$1.j_oTag) {
+        context.length -= 2;
+      } else if (context[context.length - 1] === types$1.j_expr) {
+        context.length -= 1;
       }
     }
 
-    if (jsxError != null || this.isRelational("<")) {
-      let arrowExpression;
+    if (jsx && jsx.error || this.isRelational("<")) {
+      state = state || this.state.clone();
       let typeParameters;
-
-      try {
+      const arrow = this.tryParse(() => {
         typeParameters = this.flowParseTypeParameterDeclaration();
-        arrowExpression = this.forwardNoArrowParamsConversionAt(typeParameters, () => super.parseMaybeAssign(noIn, refShorthandDefaultPos, afterLeftParse, refNeedsArrowPos));
+        const arrowExpression = this.forwardNoArrowParamsConversionAt(typeParameters, () => super.parseMaybeAssign(noIn, refShorthandDefaultPos, afterLeftParse, refNeedsArrowPos));
         arrowExpression.typeParameters = typeParameters;
         this.resetStartLocationFromNode(arrowExpression, typeParameters);
-      } catch (err) {
-        throw jsxError || err;
+        return arrowExpression;
+      }, state);
+      const arrowExpression = arrow.node && arrow.node.type === "ArrowFunctionExpression" ? arrow.node : null;
+      if (!arrow.error && arrowExpression) return arrowExpression;
+
+      if (jsx && jsx.node) {
+        this.state = jsx.failState;
+        return jsx.node;
       }
 
-      if (arrowExpression.type === "ArrowFunctionExpression") {
+      if (arrowExpression) {
+        this.state = arrow.failState;
         return arrowExpression;
-      } else if (jsxError != null) {
-        throw jsxError;
-      } else {
-        this.raise(typeParameters.start, "Expected an arrow function after this type parameter declaration");
       }
+
+      if (jsx && jsx.thrown) throw jsx.error;
+      if (arrow.thrown) throw arrow.error;
+      throw this.raise(typeParameters.start, "Expected an arrow function after this type parameter declaration");
     }
 
     return super.parseMaybeAssign(noIn, refShorthandDefaultPos, afterLeftParse, refNeedsArrowPos);
@@ -2670,9 +2776,7 @@ var flow = (superClass => class extends superClass {
 
   parseArrow(node) {
     if (this.match(types.colon)) {
-      const state = this.state.clone();
-
-      try {
+      const result = this.tryParse(() => {
         const oldNoAnonFunctionType = this.state.noAnonFunctionType;
         this.state.noAnonFunctionType = true;
         const typeNode = this.startNode();
@@ -2680,14 +2784,11 @@ var flow = (superClass => class extends superClass {
         this.state.noAnonFunctionType = oldNoAnonFunctionType;
         if (this.canInsertSemicolon()) this.unexpected();
         if (!this.match(types.arrow)) this.unexpected();
-        node.returnType = typeNode.typeAnnotation ? this.finishNode(typeNode, "TypeAnnotation") : null;
-      } catch (err) {
-        if (err instanceof SyntaxError) {
-          this.state = state;
-        } else {
-          throw err;
-        }
-      }
+        return typeNode;
+      });
+      if (result.thrown) return null;
+      if (result.error) this.state = result.failState;
+      node.returnType = result.node.typeAnnotation ? this.finishNode(result.node, "TypeAnnotation") : null;
     }
 
     return super.parseArrow(node);
@@ -2710,7 +2811,7 @@ var flow = (superClass => class extends superClass {
       return;
     }
 
-    return super.checkParams(node, allowDuplicates, isArrowFunction);
+    return super.checkParams(...arguments);
   }
 
   parseParenAndDistinguishExpression(canBeArrow) {
@@ -2726,28 +2827,28 @@ var flow = (superClass => class extends superClass {
       base = this.finishNode(node, "CallExpression");
     } else if (base.type === "Identifier" && base.name === "async" && this.isRelational("<")) {
       const state = this.state.clone();
-      let error;
+      const arrow = this.tryParse(abort => this.parseAsyncArrowWithTypeParameters(startPos, startLoc) || abort(), state);
+      if (!arrow.error && !arrow.aborted) return arrow.node;
+      const result = this.tryParse(() => super.parseSubscripts(base, startPos, startLoc, noCalls), state);
+      if (result.node && !result.error) return result.node;
 
-      try {
-        const node = this.parseAsyncArrowWithTypeParameters(startPos, startLoc);
-        if (node) return node;
-      } catch (e) {
-        error = e;
+      if (arrow.node) {
+        this.state = arrow.failState;
+        return arrow.node;
       }
 
-      this.state = state;
-
-      try {
-        return super.parseSubscripts(base, startPos, startLoc, noCalls);
-      } catch (e) {
-        throw error || e;
+      if (result.node) {
+        this.state = result.failState;
+        return result.node;
       }
+
+      throw arrow.error || result.error;
     }
 
     return super.parseSubscripts(base, startPos, startLoc, noCalls);
   }
 
-  parseSubscript(base, startPos, startLoc, noCalls, subscriptState, maybeAsyncArrow) {
+  parseSubscript(base, startPos, startLoc, noCalls, subscriptState) {
     if (this.match(types.questionDot) && this.isLookaheadRelational("<")) {
       this.expectPlugin("optionalChaining");
       subscriptState.optionalChainMember = true;
@@ -2764,50 +2865,32 @@ var flow = (superClass => class extends superClass {
       this.expect(types.parenL);
       node.arguments = this.parseCallExpressionArguments(types.parenR, false);
       node.optional = true;
-      return this.finishNode(node, "OptionalCallExpression");
+      return this.finishCallExpression(node, true);
     } else if (!noCalls && this.shouldParseTypes() && this.isRelational("<")) {
       const node = this.startNodeAt(startPos, startLoc);
       node.callee = base;
-      const state = this.state.clone();
-
-      try {
+      const result = this.tryParse(() => {
         node.typeArguments = this.flowParseTypeParameterInstantiationCallOrNew();
         this.expect(types.parenL);
         node.arguments = this.parseCallExpressionArguments(types.parenR, false);
+        if (subscriptState.optionalChainMember) node.optional = false;
+        return this.finishCallExpression(node, subscriptState.optionalChainMember);
+      });
 
-        if (subscriptState.optionalChainMember) {
-          node.optional = false;
-          return this.finishNode(node, "OptionalCallExpression");
-        }
-
-        return this.finishNode(node, "CallExpression");
-      } catch (e) {
-        if (e instanceof SyntaxError) {
-          this.state = state;
-        } else {
-          throw e;
-        }
+      if (result.node) {
+        if (result.error) this.state = result.failState;
+        return result.node;
       }
     }
 
-    return super.parseSubscript(base, startPos, startLoc, noCalls, subscriptState, maybeAsyncArrow);
+    return super.parseSubscript(base, startPos, startLoc, noCalls, subscriptState);
   }
 
   parseNewArguments(node) {
     let targs = null;
 
     if (this.shouldParseTypes() && this.isRelational("<")) {
-      const state = this.state.clone();
-
-      try {
-        targs = this.flowParseTypeParameterInstantiationCallOrNew();
-      } catch (e) {
-        if (e instanceof SyntaxError) {
-          this.state = state;
-        } else {
-          throw e;
-        }
-      }
+      targs = this.tryParse(() => this.flowParseTypeParameterInstantiationCallOrNew()).node;
     }
 
     node.typeArguments = targs;
@@ -2848,71 +2931,509 @@ var flow = (superClass => class extends superClass {
   parseTopLevel(file, program) {
     const fileNode = super.parseTopLevel(file, program);
 
-    if (this.state.hasFlowComment) {
-      this.unexpected(null, "Unterminated flow-comment");
-    }
+    if (this.state.hasFlowComment) {
+      this.raise(this.state.pos, "Unterminated flow-comment");
+    }
+
+    return fileNode;
+  }
+
+  skipBlockComment() {
+    if (this.hasPlugin("flowComments") && this.skipFlowComment()) {
+      if (this.state.hasFlowComment) {
+        this.unexpected(null, "Cannot have a flow comment inside another flow comment");
+      }
+
+      this.hasFlowCommentCompletion();
+      this.state.pos += this.skipFlowComment();
+      this.state.hasFlowComment = true;
+      return;
+    }
+
+    if (this.state.hasFlowComment) {
+      const end = this.input.indexOf("*-/", this.state.pos += 2);
+
+      if (end === -1) {
+        throw this.raise(this.state.pos - 2, "Unterminated comment");
+      }
+
+      this.state.pos = end + 3;
+      return;
+    }
+
+    super.skipBlockComment();
+  }
+
+  skipFlowComment() {
+    const {
+      pos
+    } = this.state;
+    let shiftToFirstNonWhiteSpace = 2;
+
+    while ([32, 9].includes(this.input.charCodeAt(pos + shiftToFirstNonWhiteSpace))) {
+      shiftToFirstNonWhiteSpace++;
+    }
+
+    const ch2 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos);
+    const ch3 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos + 1);
+
+    if (ch2 === 58 && ch3 === 58) {
+      return shiftToFirstNonWhiteSpace + 2;
+    }
+
+    if (this.input.slice(shiftToFirstNonWhiteSpace + pos, shiftToFirstNonWhiteSpace + pos + 12) === "flow-include") {
+      return shiftToFirstNonWhiteSpace + 12;
+    }
+
+    if (ch2 === 58 && ch3 !== 58) {
+      return shiftToFirstNonWhiteSpace;
+    }
+
+    return false;
+  }
+
+  hasFlowCommentCompletion() {
+    const end = this.input.indexOf("*/", this.state.pos);
+
+    if (end === -1) {
+      throw this.raise(this.state.pos, "Unterminated comment");
+    }
+  }
+
+  flowEnumErrorBooleanMemberNotInitialized(pos, {
+    enumName,
+    memberName
+  }) {
+    this.raise(pos, `Boolean enum members need to be initialized. Use either \`${memberName} = true,\` ` + `or \`${memberName} = false,\` in enum \`${enumName}\`.`);
+  }
+
+  flowEnumErrorInvalidMemberName(pos, {
+    enumName,
+    memberName
+  }) {
+    const suggestion = memberName[0].toUpperCase() + memberName.slice(1);
+    this.raise(pos, `Enum member names cannot start with lowercase 'a' through 'z'. Instead of using ` + `\`${memberName}\`, consider using \`${suggestion}\`, in enum \`${enumName}\`.`);
+  }
+
+  flowEnumErrorDuplicateMemberName(pos, {
+    enumName,
+    memberName
+  }) {
+    this.raise(pos, `Enum member names need to be unique, but the name \`${memberName}\` has already been used ` + `before in enum \`${enumName}\`.`);
+  }
+
+  flowEnumErrorInconsistentMemberValues(pos, {
+    enumName
+  }) {
+    this.raise(pos, `Enum \`${enumName}\` has inconsistent member initializers. Either use no initializers, or ` + `consistently use literals (either booleans, numbers, or strings) for all member initializers.`);
+  }
+
+  flowEnumErrorInvalidExplicitType(pos, {
+    enumName,
+    suppliedType
+  }) {
+    const suggestion = `Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in ` + `enum \`${enumName}\`.`;
+    const message = suppliedType === null ? `Supplied enum type is not valid. ${suggestion}` : `Enum type \`${suppliedType}\` is not valid. ${suggestion}`;
+    return this.raise(pos, message);
+  }
+
+  flowEnumErrorInvalidMemberInitializer(pos, {
+    enumName,
+    explicitType,
+    memberName
+  }) {
+    let message = null;
+
+    switch (explicitType) {
+      case "boolean":
+      case "number":
+      case "string":
+        message = `Enum \`${enumName}\` has type \`${explicitType}\`, so the initializer of ` + `\`${memberName}\` needs to be a ${explicitType} literal.`;
+        break;
+
+      case "symbol":
+        message = `Symbol enum members cannot be initialized. Use \`${memberName},\` in ` + `enum \`${enumName}\`.`;
+        break;
+
+      default:
+        message = `The enum member initializer for \`${memberName}\` needs to be a literal (either ` + `a boolean, number, or string) in enum \`${enumName}\`.`;
+    }
+
+    return this.raise(pos, message);
+  }
+
+  flowEnumErrorNumberMemberNotInitialized(pos, {
+    enumName,
+    memberName
+  }) {
+    this.raise(pos, `Number enum members need to be initialized, e.g. \`${memberName} = 1\` in enum \`${enumName}\`.`);
+  }
+
+  flowEnumErrorStringMemberInconsistentlyInitailized(pos, {
+    enumName
+  }) {
+    this.raise(pos, `String enum members need to consistently either all use initializers, or use no initializers, ` + `in enum \`${enumName}\`.`);
+  }
+
+  flowEnumMemberInit() {
+    const startPos = this.state.start;
+
+    const endOfInit = () => this.match(types.comma) || this.match(types.braceR);
+
+    switch (this.state.type) {
+      case types.num:
+        {
+          const literal = this.parseLiteral(this.state.value, "NumericLiteral");
+
+          if (endOfInit()) {
+            return {
+              type: "number",
+              pos: literal.start,
+              value: literal
+            };
+          }
+
+          return {
+            type: "invalid",
+            pos: startPos
+          };
+        }
+
+      case types.string:
+        {
+          const literal = this.parseLiteral(this.state.value, "StringLiteral");
+
+          if (endOfInit()) {
+            return {
+              type: "string",
+              pos: literal.start,
+              value: literal
+            };
+          }
+
+          return {
+            type: "invalid",
+            pos: startPos
+          };
+        }
+
+      case types._true:
+      case types._false:
+        {
+          const literal = this.parseBooleanLiteral();
+
+          if (endOfInit()) {
+            return {
+              type: "boolean",
+              pos: literal.start,
+              value: literal
+            };
+          }
+
+          return {
+            type: "invalid",
+            pos: startPos
+          };
+        }
+
+      default:
+        return {
+          type: "invalid",
+          pos: startPos
+        };
+    }
+  }
+
+  flowEnumMemberRaw() {
+    const pos = this.state.start;
+    const id = this.parseIdentifier(true);
+    const init = this.eat(types.eq) ? this.flowEnumMemberInit() : {
+      type: "none",
+      pos
+    };
+    return {
+      id,
+      init
+    };
+  }
+
+  flowEnumCheckExplicitTypeMismatch(pos, context, expectedType) {
+    const {
+      explicitType
+    } = context;
+
+    if (explicitType === null) {
+      return;
+    }
+
+    if (explicitType !== expectedType) {
+      this.flowEnumErrorInvalidMemberInitializer(pos, context);
+    }
+  }
+
+  flowEnumMembers({
+    enumName,
+    explicitType
+  }) {
+    const seenNames = new Set();
+    const members = {
+      booleanMembers: [],
+      numberMembers: [],
+      stringMembers: [],
+      defaultedMembers: []
+    };
+
+    while (!this.match(types.braceR)) {
+      const memberNode = this.startNode();
+      const {
+        id,
+        init
+      } = this.flowEnumMemberRaw();
+      const memberName = id.name;
+
+      if (memberName === "") {
+        continue;
+      }
+
+      if (/^[a-z]/.test(memberName)) {
+        this.flowEnumErrorInvalidMemberName(id.start, {
+          enumName,
+          memberName
+        });
+      }
+
+      if (seenNames.has(memberName)) {
+        this.flowEnumErrorDuplicateMemberName(id.start, {
+          enumName,
+          memberName
+        });
+      }
+
+      seenNames.add(memberName);
+      const context = {
+        enumName,
+        explicitType,
+        memberName
+      };
+      memberNode.id = id;
+
+      switch (init.type) {
+        case "boolean":
+          {
+            this.flowEnumCheckExplicitTypeMismatch(init.pos, context, "boolean");
+            memberNode.init = init.value;
+            members.booleanMembers.push(this.finishNode(memberNode, "EnumBooleanMember"));
+            break;
+          }
+
+        case "number":
+          {
+            this.flowEnumCheckExplicitTypeMismatch(init.pos, context, "number");
+            memberNode.init = init.value;
+            members.numberMembers.push(this.finishNode(memberNode, "EnumNumberMember"));
+            break;
+          }
+
+        case "string":
+          {
+            this.flowEnumCheckExplicitTypeMismatch(init.pos, context, "string");
+            memberNode.init = init.value;
+            members.stringMembers.push(this.finishNode(memberNode, "EnumStringMember"));
+            break;
+          }
+
+        case "invalid":
+          {
+            throw this.flowEnumErrorInvalidMemberInitializer(init.pos, context);
+          }
+
+        case "none":
+          {
+            switch (explicitType) {
+              case "boolean":
+                this.flowEnumErrorBooleanMemberNotInitialized(init.pos, context);
+                break;
+
+              case "number":
+                this.flowEnumErrorNumberMemberNotInitialized(init.pos, context);
+                break;
+
+              default:
+                members.defaultedMembers.push(this.finishNode(memberNode, "EnumDefaultedMember"));
+            }
+          }
+      }
+
+      if (!this.match(types.braceR)) {
+        this.expect(types.comma);
+      }
+    }
+
+    return members;
+  }
+
+  flowEnumStringMembers(initializedMembers, defaultedMembers, {
+    enumName
+  }) {
+    if (initializedMembers.length === 0) {
+      return defaultedMembers;
+    } else if (defaultedMembers.length === 0) {
+      return initializedMembers;
+    } else if (defaultedMembers.length > initializedMembers.length) {
+      for (let _i = 0; _i < initializedMembers.length; _i++) {
+        const member = initializedMembers[_i];
+        this.flowEnumErrorStringMemberInconsistentlyInitailized(member.start, {
+          enumName
+        });
+      }
+
+      return defaultedMembers;
+    } else {
+      for (let _i2 = 0; _i2 < defaultedMembers.length; _i2++) {
+        const member = defaultedMembers[_i2];
+        this.flowEnumErrorStringMemberInconsistentlyInitailized(member.start, {
+          enumName
+        });
+      }
 
-    return fileNode;
+      return initializedMembers;
+    }
   }
 
-  skipBlockComment() {
-    if (this.hasPlugin("flowComments") && this.skipFlowComment()) {
-      if (this.state.hasFlowComment) {
-        this.unexpected(null, "Cannot have a flow comment inside another flow comment");
+  flowEnumParseExplicitType({
+    enumName
+  }) {
+    if (this.eatContextual("of")) {
+      if (!this.match(types.name)) {
+        throw this.flowEnumErrorInvalidExplicitType(this.state.start, {
+          enumName,
+          suppliedType: null
+        });
       }
 
-      this.hasFlowCommentCompletion();
-      this.state.pos += this.skipFlowComment();
-      this.state.hasFlowComment = true;
-      return;
-    }
+      const {
+        value
+      } = this.state;
+      this.next();
 
-    if (this.state.hasFlowComment) {
-      const end = this.input.indexOf("*-/", this.state.pos += 2);
-      if (end === -1) this.raise(this.state.pos - 2, "Unterminated comment");
-      this.state.pos = end + 3;
-      return;
+      if (value !== "boolean" && value !== "number" && value !== "string" && value !== "symbol") {
+        this.flowEnumErrorInvalidExplicitType(this.state.start, {
+          enumName,
+          suppliedType: value
+        });
+      }
+
+      return value;
     }
 
-    super.skipBlockComment();
+    return null;
   }
 
-  skipFlowComment() {
-    const {
-      pos
-    } = this.state;
-    let shiftToFirstNonWhiteSpace = 2;
-
-    while ([32, 9].includes(this.input.charCodeAt(pos + shiftToFirstNonWhiteSpace))) {
-      shiftToFirstNonWhiteSpace++;
-    }
+  flowEnumBody(node, {
+    enumName,
+    nameLoc
+  }) {
+    const explicitType = this.flowEnumParseExplicitType({
+      enumName
+    });
+    this.expect(types.braceL);
+    const members = this.flowEnumMembers({
+      enumName,
+      explicitType
+    });
 
-    const ch2 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos);
-    const ch3 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos + 1);
+    switch (explicitType) {
+      case "boolean":
+        node.explicitType = true;
+        node.members = members.booleanMembers;
+        this.expect(types.braceR);
+        return this.finishNode(node, "EnumBooleanBody");
 
-    if (ch2 === 58 && ch3 === 58) {
-      return shiftToFirstNonWhiteSpace + 2;
-    }
+      case "number":
+        node.explicitType = true;
+        node.members = members.numberMembers;
+        this.expect(types.braceR);
+        return this.finishNode(node, "EnumNumberBody");
 
-    if (this.input.slice(shiftToFirstNonWhiteSpace + pos, shiftToFirstNonWhiteSpace + pos + 12) === "flow-include") {
-      return shiftToFirstNonWhiteSpace + 12;
-    }
+      case "string":
+        node.explicitType = true;
+        node.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, {
+          enumName
+        });
+        this.expect(types.braceR);
+        return this.finishNode(node, "EnumStringBody");
 
-    if (ch2 === 58 && ch3 !== 58) {
-      return shiftToFirstNonWhiteSpace;
-    }
+      case "symbol":
+        node.members = members.defaultedMembers;
+        this.expect(types.braceR);
+        return this.finishNode(node, "EnumSymbolBody");
 
-    return false;
-  }
+      default:
+        {
+          const empty = () => {
+            node.members = [];
+            this.expect(types.braceR);
+            return this.finishNode(node, "EnumStringBody");
+          };
+
+          node.explicitType = false;
+          const boolsLen = members.booleanMembers.length;
+          const numsLen = members.numberMembers.length;
+          const strsLen = members.stringMembers.length;
+          const defaultedLen = members.defaultedMembers.length;
+
+          if (!boolsLen && !numsLen && !strsLen && !defaultedLen) {
+            return empty();
+          } else if (!boolsLen && !numsLen) {
+            node.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, {
+              enumName
+            });
+            this.expect(types.braceR);
+            return this.finishNode(node, "EnumStringBody");
+          } else if (!numsLen && !strsLen && boolsLen >= defaultedLen) {
+            for (let _i3 = 0, _members$defaultedMem = members.defaultedMembers; _i3 < _members$defaultedMem.length; _i3++) {
+              const member = _members$defaultedMem[_i3];
+              this.flowEnumErrorBooleanMemberNotInitialized(member.start, {
+                enumName,
+                memberName: member.id.name
+              });
+            }
 
-  hasFlowCommentCompletion() {
-    const end = this.input.indexOf("*/", this.state.pos);
+            node.members = members.booleanMembers;
+            this.expect(types.braceR);
+            return this.finishNode(node, "EnumBooleanBody");
+          } else if (!boolsLen && !strsLen && numsLen >= defaultedLen) {
+            for (let _i4 = 0, _members$defaultedMem2 = members.defaultedMembers; _i4 < _members$defaultedMem2.length; _i4++) {
+              const member = _members$defaultedMem2[_i4];
+              this.flowEnumErrorNumberMemberNotInitialized(member.start, {
+                enumName,
+                memberName: member.id.name
+              });
+            }
 
-    if (end === -1) {
-      this.raise(this.state.pos, "Unterminated comment");
+            node.members = members.numberMembers;
+            this.expect(types.braceR);
+            return this.finishNode(node, "EnumNumberBody");
+          } else {
+            this.flowEnumErrorInconsistentMemberValues(nameLoc, {
+              enumName
+            });
+            return empty();
+          }
+        }
     }
   }
 
+  flowParseEnumDeclaration(node) {
+    const id = this.parseIdentifier();
+    node.id = id;
+    node.body = this.flowEnumBody(this.startNode(), {
+      enumName: id.name,
+      nameLoc: id.start
+    });
+    return this.finishNode(node, "EnumDeclaration");
+  }
+
 });
 
 const entities = {
@@ -3229,7 +3750,7 @@ var jsx = (superClass => class extends superClass {
 
     for (;;) {
       if (this.state.pos >= this.length) {
-        this.raise(this.state.start, "Unterminated JSX contents");
+        throw this.raise(this.state.start, "Unterminated JSX contents");
       }
 
       const ch = this.input.charCodeAt(this.state.pos);
@@ -3291,7 +3812,7 @@ var jsx = (superClass => class extends superClass {
 
     for (;;) {
       if (this.state.pos >= this.length) {
-        this.raise(this.state.start, "Unterminated string constant");
+        throw this.raise(this.state.start, "Unterminated string constant");
       }
 
       const ch = this.input.charCodeAt(this.state.pos);
@@ -3399,6 +3920,10 @@ var jsx = (superClass => class extends superClass {
     const startLoc = this.state.startLoc;
     let node = this.jsxParseNamespacedName();
 
+    if (node.type === "JSXNamespacedName") {
+      return node;
+    }
+
     while (this.eat(types.dot)) {
       const newNode = this.startNodeAt(startPos, startLoc);
       newNode.object = node;
@@ -3419,11 +3944,11 @@ var jsx = (superClass => class extends superClass {
         node = this.jsxParseExpressionContainer(node);
 
         if (node.expression.type === "JSXEmptyExpression") {
-          throw this.raise(node.start, "JSX attributes must only be assigned a non-empty expression");
-        } else {
-          return node;
+          this.raise(node.start, "JSX attributes must only be assigned a non-empty expression");
         }
 
+        return node;
+
       case types.jsxTagStart:
       case types.string:
         return this.parseExprAtom();
@@ -3575,8 +4100,8 @@ var jsx = (superClass => class extends superClass {
 
     node.children = children;
 
-    if (this.match(types.relational) && this.state.value === "<") {
-      this.raise(this.state.start, "Adjacent JSX elements must be wrapped in an enclosing tag. " + "Did you want a JSX fragment <>...</>?");
+    if (this.isRelational("<")) {
+      throw this.raise(this.state.start, "Adjacent JSX elements must be wrapped in an enclosing tag. " + "Did you want a JSX fragment <>...</>?");
     }
 
     return isFragment(openingElement) ? this.finishNode(node, "JSXFragment") : this.finishNode(node, "JSXElement");
@@ -3694,6 +4219,10 @@ class ScopeHandler {
     return (this.currentThisScope().flags & SCOPE_DIRECT_SUPER) > 0;
   }
 
+  get inClass() {
+    return (this.currentThisScope().flags & SCOPE_CLASS) > 0;
+  }
+
   get inNonArrowFunction() {
     return (this.currentThisScope().flags & SCOPE_FUNCTION) > 0;
   }
@@ -3961,6 +4490,24 @@ var typescript = (superClass => class extends superClass {
     return undefined;
   }
 
+  tsParseModifiers(allowedModifiers) {
+    const modifiers = Object.create(null);
+
+    while (true) {
+      const startPos = this.state.start;
+      const modifier = this.tsParseModifier(allowedModifiers);
+      if (!modifier) break;
+
+      if (Object.hasOwnProperty.call(modifiers, modifier)) {
+        this.raise(startPos, `Duplicate modifier: '${modifier}'`);
+      }
+
+      modifiers[modifier] = true;
+    }
+
+    return modifiers;
+  }
+
   tsIsListTerminator(kind) {
     switch (kind) {
       case "EnumMembers":
@@ -4054,7 +4601,7 @@ var typescript = (superClass => class extends superClass {
     this.expect(types.parenL);
 
     if (!this.match(types.string)) {
-      throw this.unexpected(null, "Argument in a type import must be a string literal");
+      this.raise(this.state.start, "Argument in a type import must be a string literal");
     }
 
     node.argument = this.parseExprAtom();
@@ -4172,9 +4719,9 @@ var typescript = (superClass => class extends superClass {
   }
 
   tsParseBindingListForSignature() {
-    return this.parseBindingList(types.parenR).map(pattern => {
+    return this.parseBindingList(types.parenR, 41).map(pattern => {
       if (pattern.type !== "Identifier" && pattern.type !== "RestElement" && pattern.type !== "ObjectPattern" && pattern.type !== "ArrayPattern") {
-        throw this.unexpected(pattern.start, `Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got ${pattern.type}`);
+        this.raise(pattern.start, "Name in a signature must be an Identifier, ObjectPattern or ArrayPattern," + `instead got ${pattern.type}`);
       }
 
       return pattern;
@@ -4359,7 +4906,11 @@ var typescript = (superClass => class extends superClass {
       const restNode = this.startNode();
       this.next();
       restNode.typeAnnotation = this.tsParseType();
-      this.checkCommaAfterRest();
+
+      if (this.match(types.comma) && this.lookaheadCharCode() !== 93) {
+        this.raiseRestNotLast(this.state.start);
+      }
+
       return this.finishNode(restNode, "TSRestType");
     }
 
@@ -4417,13 +4968,23 @@ var typescript = (superClass => class extends superClass {
     const templateNode = this.parseTemplate(false);
 
     if (templateNode.expressions.length > 0) {
-      throw this.raise(templateNode.expressions[0].start, "Template literal types cannot have any substitution");
+      this.raise(templateNode.expressions[0].start, "Template literal types cannot have any substitution");
     }
 
     node.literal = templateNode;
     return this.finishNode(node, "TSLiteralType");
   }
 
+  tsParseThisTypeOrThisTypePredicate() {
+    const thisKeyword = this.tsParseThisTypeNode();
+
+    if (this.isContextual("is") && !this.hasPrecedingLineBreak()) {
+      return this.tsParseThisTypePredicate(thisKeyword);
+    } else {
+      return thisKeyword;
+    }
+  }
+
   tsParseNonArrayType() {
     switch (this.state.type) {
       case types.name:
@@ -4432,7 +4993,7 @@ var typescript = (superClass => class extends superClass {
         {
           const type = this.match(types._void) ? "TSVoidKeyword" : this.match(types._null) ? "TSNullKeyword" : keywordTypeFromName(this.state.value);
 
-          if (type !== undefined && this.lookahead().type !== types.dot) {
+          if (type !== undefined && this.lookaheadCharCode() !== 46) {
             const node = this.startNode();
             this.next();
             return this.finishNode(node, type);
@@ -4462,15 +5023,7 @@ var typescript = (superClass => class extends superClass {
         break;
 
       case types._this:
-        {
-          const thisKeyword = this.tsParseThisTypeNode();
-
-          if (this.isContextual("is") && !this.hasPrecedingLineBreak()) {
-            return this.tsParseThisTypePredicate(thisKeyword);
-          } else {
-            return thisKeyword;
-          }
-        }
+        return this.tsParseThisTypeOrThisTypePredicate();
 
       case types._typeof:
         return this.tsParseTypeQuery();
@@ -4659,16 +5212,43 @@ var typescript = (superClass => class extends superClass {
     return this.tsInType(() => {
       const t = this.startNode();
       this.expect(returnToken);
+      const asserts = this.tsTryParse(this.tsParseTypePredicateAsserts.bind(this));
+
+      if (asserts && this.match(types._this)) {
+        let thisTypePredicate = this.tsParseThisTypeOrThisTypePredicate();
+
+        if (thisTypePredicate.type === "TSThisType") {
+          const node = this.startNodeAtNode(t);
+          node.parameterName = thisTypePredicate;
+          node.asserts = true;
+          thisTypePredicate = this.finishNode(node, "TSTypePredicate");
+        } else {
+          thisTypePredicate.asserts = true;
+        }
+
+        t.typeAnnotation = thisTypePredicate;
+        return this.finishNode(t, "TSTypeAnnotation");
+      }
+
       const typePredicateVariable = this.tsIsIdentifier() && this.tsTryParse(this.tsParseTypePredicatePrefix.bind(this));
 
       if (!typePredicateVariable) {
-        return this.tsParseTypeAnnotation(false, t);
+        if (!asserts) {
+          return this.tsParseTypeAnnotation(false, t);
+        }
+
+        const node = this.startNodeAtNode(t);
+        node.parameterName = this.parseIdentifier();
+        node.asserts = asserts;
+        t.typeAnnotation = this.finishNode(node, "TSTypePredicate");
+        return this.finishNode(t, "TSTypeAnnotation");
       }
 
       const type = this.tsParseTypeAnnotation(false);
-      const node = this.startNodeAtNode(typePredicateVariable);
+      const node = this.startNodeAtNode(t);
       node.parameterName = typePredicateVariable;
       node.typeAnnotation = type;
+      node.asserts = asserts;
       t.typeAnnotation = this.finishNode(node, "TSTypePredicate");
       return this.finishNode(t, "TSTypeAnnotation");
     });
@@ -4695,6 +5275,25 @@ var typescript = (superClass => class extends superClass {
     }
   }
 
+  tsParseTypePredicateAsserts() {
+    if (!this.match(types.name) || this.state.value !== "asserts" || this.hasPrecedingLineBreak()) {
+      return false;
+    }
+
+    const containsEsc = this.state.containsEsc;
+    this.next();
+
+    if (!this.match(types.name) && !this.match(types._this)) {
+      return false;
+    }
+
+    if (containsEsc) {
+      this.raise(this.state.lastTokStart, "Escape sequence in keyword asserts");
+    }
+
+    return true;
+  }
+
   tsParseTypeAnnotation(eatColon = true, t = this.startNode()) {
     this.tsInType(() => {
       if (eatColon) this.expect(types.colon);
@@ -4873,7 +5472,9 @@ var typescript = (superClass => class extends superClass {
       this.tsParseModuleOrNamespaceDeclaration(inner, true);
       node.body = inner;
     } else {
+      this.scope.enter(SCOPE_TS_MODULE);
       node.body = this.tsParseModuleBlock();
+      this.scope.exit();
     }
 
     return this.finishNode(node, "TSModuleDeclaration");
@@ -4890,7 +5491,9 @@ var typescript = (superClass => class extends superClass {
     }
 
     if (this.match(types.braceL)) {
+      this.scope.enter(SCOPE_TS_MODULE);
       node.body = this.tsParseModuleBlock();
+      this.scope.exit();
     } else {
       this.semicolon();
     }
@@ -4901,6 +5504,7 @@ var typescript = (superClass => class extends superClass {
   tsParseImportEqualsDeclaration(node, isExport) {
     node.isExport = isExport || false;
     node.id = this.parseIdentifier();
+    this.checkLVal(node.id, BIND_LEXICAL, undefined, "import equals declaration");
     this.expect(types.eq);
     node.moduleReference = this.tsParseModuleReference();
     this.semicolon();
@@ -4908,7 +5512,7 @@ var typescript = (superClass => class extends superClass {
   }
 
   tsIsExternalModuleReference() {
-    return this.isContextual("require") && this.lookahead().type === types.parenL;
+    return this.isContextual("require") && this.lookaheadCharCode() === 40;
   }
 
   tsParseModuleReference() {
@@ -4937,18 +5541,10 @@ var typescript = (superClass => class extends superClass {
   }
 
   tsTryParseAndCatch(f) {
-    const state = this.state.clone();
-
-    try {
-      return f();
-    } catch (e) {
-      if (e instanceof SyntaxError) {
-        this.state = state;
-        return undefined;
-      }
-
-      throw e;
-    }
+    const result = this.tryParse(abort => f() || abort());
+    if (result.aborted || !result.node) return undefined;
+    if (result.error) this.state = result.failState;
+    return result.node;
   }
 
   tsTryParse(f) {
@@ -4981,6 +5577,7 @@ var typescript = (superClass => class extends superClass {
         return this.parseFunctionStatement(nany, false, true);
 
       case types._class:
+        nany.declare = true;
         return this.parseClass(nany, true, false);
 
       case types._const:
@@ -5027,10 +5624,12 @@ var typescript = (superClass => class extends superClass {
 
       case "global":
         if (this.match(types.braceL)) {
+          this.scope.enter(SCOPE_TS_MODULE);
           const mod = node;
           mod.global = true;
           mod.id = expr;
           mod.body = this.tsParseModuleBlock();
+          this.scope.exit();
           return this.finishNode(mod, "TSModuleDeclaration");
         }
 
@@ -5190,7 +5789,7 @@ var typescript = (superClass => class extends superClass {
       if (readonly) pp.readonly = readonly;
 
       if (elt.type !== "Identifier" && elt.type !== "AssignmentPattern") {
-        throw this.raise(pp.start, "A parameter property may not be declared using a binding pattern.");
+        this.raise(pp.start, "A parameter property may not be declared using a binding pattern.");
       }
 
       pp.parameter = elt;
@@ -5219,15 +5818,15 @@ var typescript = (superClass => class extends superClass {
     super.parseFunctionBodyAndFinish(node, type, isMethod);
   }
 
-  checkFunctionStatementId(node) {
+  registerFunctionStatementId(node) {
     if (!node.body && node.id) {
-      this.checkLVal(node.id, BIND_TS_FN_TYPE, null, "function name");
+      this.checkLVal(node.id, BIND_TS_AMBIENT, null, "function name");
     } else {
-      super.checkFunctionStatementId(...arguments);
+      super.registerFunctionStatementId(...arguments);
     }
   }
 
-  parseSubscript(base, startPos, startLoc, noCalls, state, maybeAsyncArrow) {
+  parseSubscript(base, startPos, startLoc, noCalls, state) {
     if (!this.hasPrecedingLineBreak() && this.match(types.bang)) {
       this.state.exprAllowed = false;
       this.next();
@@ -5254,7 +5853,7 @@ var typescript = (superClass => class extends superClass {
           if (!noCalls && this.eat(types.parenL)) {
             node.arguments = this.parseCallExpressionArguments(types.parenR, false);
             node.typeParameters = typeArguments;
-            return this.finishCallExpression(node);
+            return this.finishCallExpression(node, state.optionalChainMember);
           } else if (this.match(types.backQuote)) {
             return this.parseTaggedTemplateExpression(startPos, startLoc, base, state, typeArguments);
           }
@@ -5265,7 +5864,7 @@ var typescript = (superClass => class extends superClass {
       if (result) return result;
     }
 
-    return super.parseSubscript(base, startPos, startLoc, noCalls, state, maybeAsyncArrow);
+    return super.parseSubscript(base, startPos, startLoc, noCalls, state);
   }
 
   parseNewArguments(node) {
@@ -5383,42 +5982,25 @@ var typescript = (superClass => class extends superClass {
   }
 
   parseClassMemberWithIsStatic(classBody, member, state, isStatic, constructorAllowsSuper) {
-    const methodOrProp = member;
-    const prop = member;
-    const propOrIdx = member;
-    let abstract = false,
-        readonly = false;
-    const mod = this.tsParseModifier(["abstract", "readonly"]);
-
-    switch (mod) {
-      case "readonly":
-        readonly = true;
-        abstract = !!this.tsParseModifier(["abstract"]);
-        break;
+    const modifiers = this.tsParseModifiers(["abstract", "readonly", "declare"]);
+    Object.assign(member, modifiers);
+    const idx = this.tsTryParseIndexSignature(member);
 
-      case "abstract":
-        abstract = true;
-        readonly = !!this.tsParseModifier(["readonly"]);
-        break;
-    }
+    if (idx) {
+      classBody.body.push(idx);
 
-    if (abstract) methodOrProp.abstract = true;
-    if (readonly) propOrIdx.readonly = true;
+      if (modifiers.abstract) {
+        this.raise(member.start, "Index signatures cannot have the 'abstract' modifier");
+      }
 
-    if (!abstract && !isStatic && !methodOrProp.accessibility) {
-      const idx = this.tsTryParseIndexSignature(member);
+      if (isStatic) {
+        this.raise(member.start, "Index signatures cannot have the 'static' modifier");
+      }
 
-      if (idx) {
-        classBody.body.push(idx);
-        return;
+      if (member.accessibility) {
+        this.raise(member.start, `Index signatures cannot have an accessibility modifier ('${member.accessibility}')`);
       }
-    }
 
-    if (readonly) {
-      methodOrProp.static = isStatic;
-      this.parseClassPropertyName(prop);
-      this.parsePostMemberNameModifiers(methodOrProp);
-      this.pushClassProperty(classBody, prop);
       return;
     }
 
@@ -5428,6 +6010,14 @@ var typescript = (superClass => class extends superClass {
   parsePostMemberNameModifiers(methodOrProp) {
     const optional = this.eat(types.question);
     if (optional) methodOrProp.optional = true;
+
+    if (methodOrProp.readonly && this.match(types.parenL)) {
+      this.raise(methodOrProp.start, "Class methods cannot have the 'readonly' modifier");
+    }
+
+    if (methodOrProp.declare && this.match(types.parenL)) {
+      this.raise(methodOrProp.start, "Class methods cannot have the 'declare' modifier");
+    }
   }
 
   parseExpressionStatement(node, expr) {
@@ -5445,19 +6035,15 @@ var typescript = (superClass => class extends superClass {
       return super.parseConditional(expr, noIn, startPos, startLoc, refNeedsArrowPos);
     }
 
-    const state = this.state.clone();
-
-    try {
-      return super.parseConditional(expr, noIn, startPos, startLoc);
-    } catch (err) {
-      if (!(err instanceof SyntaxError)) {
-        throw err;
-      }
+    const result = this.tryParse(() => super.parseConditional(expr, noIn, startPos, startLoc));
 
-      this.state = state;
-      refNeedsArrowPos.start = err.pos || this.state.start;
+    if (!result.node) {
+      refNeedsArrowPos.start = result.error.pos || this.state.start;
       return expr;
     }
+
+    if (result.error) this.state = result.failState;
+    return result.node;
   }
 
   parseParenItem(node, startPos, startLoc) {
@@ -5505,21 +6091,43 @@ var typescript = (superClass => class extends superClass {
       return;
     }
 
-    super.parseClassId(...arguments);
+    super.parseClassId(node, isStatement, optionalId, node.declare ? BIND_TS_AMBIENT : BIND_CLASS);
     const typeParameters = this.tsTryParseTypeParameters();
     if (typeParameters) node.typeParameters = typeParameters;
   }
 
-  parseClassProperty(node) {
+  parseClassPropertyAnnotation(node) {
     if (!node.optional && this.eat(types.bang)) {
       node.definite = true;
     }
 
     const type = this.tsTryParseTypeAnnotation();
     if (type) node.typeAnnotation = type;
+  }
+
+  parseClassProperty(node) {
+    this.parseClassPropertyAnnotation(node);
+
+    if (node.declare && this.match(types.equal)) {
+      this.raise(this.state.start, "'declare' class fields cannot have an initializer");
+    }
+
     return super.parseClassProperty(node);
   }
 
+  parseClassPrivateProperty(node) {
+    if (node.abstract) {
+      this.raise(node.start, "Private elements cannot have the 'abstract' modifier.");
+    }
+
+    if (node.accessibility) {
+      this.raise(node.start, `Private elements cannot have an accessibility modifier ('${node.accessibility}')`);
+    }
+
+    this.parseClassPropertyAnnotation(node);
+    return super.parseClassPrivateProperty(node);
+  }
+
   pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
     const typeParameters = this.tsTryParseTypeParameters();
     if (typeParameters) method.typeParameters = typeParameters;
@@ -5580,65 +6188,73 @@ var typescript = (superClass => class extends superClass {
   }
 
   parseMaybeAssign(...args) {
-    let jsxError;
+    let state;
+    let jsx;
+    let typeCast;
 
     if (this.match(types.jsxTagStart)) {
-      const context = this.curContext();
-      assert(context === types$1.j_oTag);
-      assert(this.state.context[this.state.context.length - 2] === types$1.j_expr);
-      const state = this.state.clone();
-
-      try {
-        return super.parseMaybeAssign(...args);
-      } catch (err) {
-        if (!(err instanceof SyntaxError)) {
-          throw err;
-        }
+      state = this.state.clone();
+      jsx = this.tryParse(() => super.parseMaybeAssign(...args), state);
+      if (!jsx.error) return jsx.node;
+      const {
+        context
+      } = this.state;
 
-        this.state = state;
-        assert(this.curContext() === types$1.j_oTag);
-        this.state.context.pop();
-        assert(this.curContext() === types$1.j_expr);
-        this.state.context.pop();
-        jsxError = err;
+      if (context[context.length - 1] === types$1.j_oTag) {
+        context.length -= 2;
+      } else if (context[context.length - 1] === types$1.j_expr) {
+        context.length -= 1;
       }
     }
 
-    if (jsxError === undefined && !this.isRelational("<")) {
+    if (!(jsx && jsx.error) && !this.isRelational("<")) {
       return super.parseMaybeAssign(...args);
     }
 
-    let arrowExpression;
     let typeParameters;
-    const state = this.state.clone();
-
-    try {
+    state = state || this.state.clone();
+    const arrow = this.tryParse(abort => {
       typeParameters = this.tsParseTypeParameters();
-      arrowExpression = super.parseMaybeAssign(...args);
+      const expr = super.parseMaybeAssign(...args);
 
-      if (arrowExpression.type !== "ArrowFunctionExpression" || arrowExpression.extra && arrowExpression.extra.parenthesized) {
-        this.unexpected();
-      }
-    } catch (err) {
-      if (!(err instanceof SyntaxError)) {
-        throw err;
+      if (expr.type !== "ArrowFunctionExpression" || expr.extra && expr.extra.parenthesized) {
+        abort();
       }
 
-      if (jsxError) {
-        throw jsxError;
+      if (typeParameters && typeParameters.params.length !== 0) {
+        this.resetStartLocationFromNode(expr, typeParameters);
       }
 
+      expr.typeParameters = typeParameters;
+      return expr;
+    }, state);
+    if (!arrow.error && !arrow.aborted) return arrow.node;
+
+    if (!jsx) {
       assert(!this.hasPlugin("jsx"));
-      this.state = state;
-      return super.parseMaybeAssign(...args);
+      typeCast = this.tryParse(() => super.parseMaybeAssign(...args), state);
+      if (!typeCast.error) return typeCast.node;
     }
 
-    if (typeParameters && typeParameters.params.length !== 0) {
-      this.resetStartLocationFromNode(arrowExpression, typeParameters);
+    if (jsx && jsx.node) {
+      this.state = jsx.failState;
+      return jsx.node;
     }
 
-    arrowExpression.typeParameters = typeParameters;
-    return arrowExpression;
+    if (arrow.node) {
+      this.state = arrow.failState;
+      return arrow.node;
+    }
+
+    if (typeCast && typeCast.node) {
+      this.state = typeCast.failState;
+      return typeCast.node;
+    }
+
+    if (jsx && jsx.thrown) throw jsx.error;
+    if (arrow.thrown) throw arrow.error;
+    if (typeCast && typeCast.thrown) throw typeCast.error;
+    throw jsx && jsx.error || arrow.error || typeCast && typeCast.error;
   }
 
   parseMaybeUnary(refShorthandDefaultPos) {
@@ -5651,23 +6267,16 @@ var typescript = (superClass => class extends superClass {
 
   parseArrow(node) {
     if (this.match(types.colon)) {
-      const state = this.state.clone();
-
-      try {
+      const result = this.tryParse(abort => {
         const returnType = this.tsParseTypeOrTypePredicateAnnotation(types.colon);
+        if (this.canInsertSemicolon() || !this.match(types.arrow)) abort();
+        return returnType;
+      });
+      if (result.aborted) return;
 
-        if (this.canInsertSemicolon() || !this.match(types.arrow)) {
-          this.state = state;
-          return undefined;
-        }
-
-        node.returnType = returnType;
-      } catch (err) {
-        if (err instanceof SyntaxError) {
-          this.state = state;
-        } else {
-          throw err;
-        }
+      if (!result.thrown) {
+        if (result.error) this.state = result.failState;
+        node.returnType = result.node;
       }
     }
 
@@ -5677,7 +6286,7 @@ var typescript = (superClass => class extends superClass {
   parseAssignableListItemTypes(param) {
     if (this.eat(types.question)) {
       if (param.type !== "Identifier") {
-        throw this.raise(param.start, "A binding pattern parameter cannot be optional in an implementation signature.");
+        this.raise(param.start, "A binding pattern parameter cannot be optional in an implementation signature.");
       }
 
       param.optional = true;
@@ -5781,7 +6390,7 @@ var typescript = (superClass => class extends superClass {
     }
   }
 
-  toAssignableList(exprList, isBinding, contextDescription) {
+  toAssignableList(exprList, isBinding) {
     for (let i = 0; i < exprList.length; i++) {
       const expr = exprList[i];
       if (!expr) continue;
@@ -5793,12 +6402,17 @@ var typescript = (superClass => class extends superClass {
 
         case "TSAsExpression":
         case "TSTypeAssertion":
-          this.raise(expr.start, "Unexpected type cast in parameter position.");
+          if (!isBinding) {
+            exprList[i] = this.typeCastToParameter(expr);
+          } else {
+            this.raise(expr.start, "Unexpected type cast in parameter position.");
+          }
+
           break;
       }
     }
 
-    return super.toAssignableList(exprList, isBinding, contextDescription);
+    return super.toAssignableList(...arguments);
   }
 
   typeCastToParameter(node) {
@@ -6036,6 +6650,33 @@ var placeholders = (superClass => class extends superClass {
 
 });
 
+var v8intrinsic = (superClass => class extends superClass {
+  parseV8Intrinsic() {
+    if (this.match(types.modulo)) {
+      const v8IntrinsicStart = this.state.start;
+      const node = this.startNode();
+      this.eat(types.modulo);
+
+      if (this.match(types.name)) {
+        const name = this.parseIdentifierName(this.state.start);
+        const identifier = this.createIdentifier(node, name);
+        identifier.type = "V8IntrinsicIdentifier";
+
+        if (this.match(types.parenL)) {
+          return identifier;
+        }
+      }
+
+      this.unexpected(v8IntrinsicStart);
+    }
+  }
+
+  parseExprAtom() {
+    return this.parseV8Intrinsic() || super.parseExprAtom(...arguments);
+  }
+
+});
+
 function hasPlugin(plugins, name) {
   return plugins.some(plugin => {
     if (Array.isArray(plugin)) {
@@ -6080,6 +6721,10 @@ function validatePlugins(plugins) {
     throw new Error("Cannot combine flow and typescript plugins.");
   }
 
+  if (hasPlugin(plugins, "placeholders") && hasPlugin(plugins, "v8intrinsic")) {
+    throw new Error("Cannot combine placeholders and v8intrinsic plugins.");
+  }
+
   if (hasPlugin(plugins, "pipelineOperator") && !PIPELINE_PROPOSALS.includes(getPluginOption(plugins, "pipelineOperator", "proposal"))) {
     throw new Error("'pipelineOperator' requires 'proposal' option whose value should be one of: " + PIPELINE_PROPOSALS.map(p => `'${p}'`).join(", "));
   }
@@ -6089,6 +6734,7 @@ const mixinPlugins = {
   jsx,
   flow,
   typescript,
+  v8intrinsic,
   placeholders
 };
 const mixinPluginNames = Object.keys(mixinPlugins);
@@ -6106,7 +6752,8 @@ const defaultOptions = {
   strictMode: null,
   ranges: false,
   tokens: false,
-  createParenthesizedExpressions: false
+  createParenthesizedExpressions: false,
+  errorRecovery: false
 };
 function getOptions(opts) {
   const options = {};
@@ -6150,27 +6797,81 @@ function getLineInfo(input, offset) {
 class BaseParser {
   constructor() {
     this.sawUnambiguousESM = false;
+    this.ambiguousScriptDifferentAst = false;
   }
 
   hasPlugin(name) {
     return this.plugins.has(name);
   }
 
-  getPluginOption(plugin, name) {
-    if (this.hasPlugin(plugin)) return this.plugins.get(plugin)[name];
-  }
+  getPluginOption(plugin, name) {
+    if (this.hasPlugin(plugin)) return this.plugins.get(plugin)[name];
+  }
+
+}
+
+function last(stack) {
+  return stack[stack.length - 1];
+}
+
+class CommentsParser extends BaseParser {
+  addComment(comment) {
+    if (this.filename) comment.loc.filename = this.filename;
+    this.state.trailingComments.push(comment);
+    this.state.leadingComments.push(comment);
+  }
+
+  adjustCommentsAfterTrailingComma(node, elements, takeAllComments) {
+    if (this.state.leadingComments.length === 0) {
+      return;
+    }
+
+    let lastElement = null;
+    let i = elements.length;
+
+    while (lastElement === null && i > 0) {
+      lastElement = elements[--i];
+    }
+
+    if (lastElement === null) {
+      return;
+    }
+
+    for (let j = 0; j < this.state.leadingComments.length; j++) {
+      if (this.state.leadingComments[j].end < this.state.commentPreviousNode.end) {
+        this.state.leadingComments.splice(j, 1);
+        j--;
+      }
+    }
+
+    const newTrailingComments = [];
+
+    for (let i = 0; i < this.state.leadingComments.length; i++) {
+      const leadingComment = this.state.leadingComments[i];
+
+      if (leadingComment.end < node.end) {
+        newTrailingComments.push(leadingComment);
+
+        if (!takeAllComments) {
+          this.state.leadingComments.splice(i, 1);
+          i--;
+        }
+      } else {
+        if (node.trailingComments === undefined) {
+          node.trailingComments = [];
+        }
 
-}
+        node.trailingComments.push(leadingComment);
+      }
+    }
 
-function last(stack) {
-  return stack[stack.length - 1];
-}
+    if (takeAllComments) this.state.leadingComments = [];
 
-class CommentsParser extends BaseParser {
-  addComment(comment) {
-    if (this.filename) comment.loc.filename = this.filename;
-    this.state.trailingComments.push(comment);
-    this.state.leadingComments.push(comment);
+    if (newTrailingComments.length > 0) {
+      lastElement.trailingComments = newTrailingComments;
+    } else if (lastElement.trailingComments !== undefined) {
+      lastElement.trailingComments = [];
+    }
   }
 
   processComment(node) {
@@ -6204,44 +6905,30 @@ class CommentsParser extends BaseParser {
 
     if (!lastChild && firstChild) lastChild = firstChild;
 
-    if (firstChild && this.state.leadingComments.length > 0) {
-      const lastComment = last(this.state.leadingComments);
+    if (firstChild) {
+      switch (node.type) {
+        case "ObjectExpression":
+          this.adjustCommentsAfterTrailingComma(node, node.properties);
+          break;
 
-      if (firstChild.type === "ObjectProperty") {
-        if (lastComment.start >= node.start) {
-          if (this.state.commentPreviousNode) {
-            for (j = 0; j < this.state.leadingComments.length; j++) {
-              if (this.state.leadingComments[j].end < this.state.commentPreviousNode.end) {
-                this.state.leadingComments.splice(j, 1);
-                j--;
-              }
-            }
+        case "ObjectPattern":
+          this.adjustCommentsAfterTrailingComma(node, node.properties, true);
+          break;
 
-            if (this.state.leadingComments.length > 0) {
-              firstChild.trailingComments = this.state.leadingComments;
-              this.state.leadingComments = [];
-            }
-          }
-        }
-      } else if (node.type === "CallExpression" && node.arguments && node.arguments.length) {
-        const lastArg = last(node.arguments);
+        case "CallExpression":
+          this.adjustCommentsAfterTrailingComma(node, node.arguments);
+          break;
 
-        if (lastArg && lastComment.start >= lastArg.start && lastComment.end <= node.end) {
-          if (this.state.commentPreviousNode) {
-            for (j = 0; j < this.state.leadingComments.length; j++) {
-              if (this.state.leadingComments[j].end < this.state.commentPreviousNode.end) {
-                this.state.leadingComments.splice(j, 1);
-                j--;
-              }
-            }
+        case "ArrayExpression":
+          this.adjustCommentsAfterTrailingComma(node, node.elements);
+          break;
 
-            if (this.state.leadingComments.length > 0) {
-              lastArg.trailingComments = this.state.leadingComments;
-              this.state.leadingComments = [];
-            }
-          }
-        }
+        case "ArrayPattern":
+          this.adjustCommentsAfterTrailingComma(node, node.elements, true);
+          break;
       }
+    } else if (this.state.commentPreviousNode && (this.state.commentPreviousNode.type === "ImportSpecifier" && node.type !== "ImportSpecifier" || this.state.commentPreviousNode.type === "ExportSpecifier" && node.type !== "ExportSpecifier")) {
+      this.adjustCommentsAfterTrailingComma(node, [this.state.commentPreviousNode], true);
     }
 
     if (lastChild) {
@@ -6334,17 +7021,22 @@ class LocationParser extends CommentsParser {
       err.code = code;
     }
 
-    throw err;
+    if (this.options.errorRecovery) {
+      if (!this.isLookahead) this.state.errors.push(err);
+      return err;
+    } else {
+      throw err;
+    }
   }
 
 }
 
 class State {
   constructor() {
+    this.errors = [];
     this.potentialArrowAt = -1;
     this.noArrowAt = [];
     this.noArrowParamsConversionAt = [];
-    this.commaAfterSpreadAt = -1;
     this.inParameters = false;
     this.maybeInArrowParameters = false;
     this.inPipeline = false;
@@ -6363,8 +7055,8 @@ class State {
     this.classLevel = 0;
     this.labels = [];
     this.decoratorStack = [[]];
-    this.yieldPos = 0;
-    this.awaitPos = 0;
+    this.yieldPos = -1;
+    this.awaitPos = -1;
     this.tokens = [];
     this.comments = [];
     this.trailingComments = [];
@@ -6454,8 +7146,12 @@ class Tokenizer extends LocationParser {
   }
 
   next() {
-    if (this.options.tokens && !this.isLookahead) {
-      this.state.tokens.push(new Token(this.state));
+    if (!this.isLookahead) {
+      this.checkKeywordEscapes();
+
+      if (this.options.tokens) {
+        this.state.tokens.push(new Token(this.state));
+      }
     }
 
     this.state.lastTokEnd = this.state.end;
@@ -6489,6 +7185,17 @@ class Tokenizer extends LocationParser {
     return curr;
   }
 
+  nextTokenStart() {
+    const thisTokEnd = this.state.pos;
+    skipWhiteSpace.lastIndex = thisTokEnd;
+    const skip = skipWhiteSpace.exec(this.input);
+    return thisTokEnd + skip[0].length;
+  }
+
+  lookaheadCharCode() {
+    return this.input.charCodeAt(this.nextTokenStart());
+  }
+
   setStrict(strict) {
     this.state.strict = strict;
     if (!this.match(types.num) && !this.match(types.string)) return;
@@ -6542,8 +7249,8 @@ class Tokenizer extends LocationParser {
   skipBlockComment() {
     const startLoc = this.state.curPosition();
     const start = this.state.pos;
-    const end = this.input.indexOf("*/", this.state.pos += 2);
-    if (end === -1) this.raise(this.state.pos - 2, "Unterminated comment");
+    const end = this.input.indexOf("*/", this.state.pos + 2);
+    if (end === -1) throw this.raise(start, "Unterminated comment");
     this.state.pos = end + 2;
     lineBreakG.lastIndex = start;
     let match;
@@ -6563,7 +7270,7 @@ class Tokenizer extends LocationParser {
     let ch = this.input.charCodeAt(this.state.pos += startSkip);
 
     if (this.state.pos < this.length) {
-      while (ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233 && ++this.state.pos < this.length) {
+      while (!isNewLine(ch) && ++this.state.pos < this.length) {
         ch = this.input.charCodeAt(this.state.pos);
       }
     }
@@ -6641,7 +7348,7 @@ class Tokenizer extends LocationParser {
     const next = this.input.charCodeAt(nextPos);
 
     if (next >= 48 && next <= 57) {
-      this.raise(this.state.pos, "Unexpected digit after hash token");
+      throw this.raise(this.state.pos, "Unexpected digit after hash token");
     }
 
     if ((this.hasPlugin("classPrivateProperties") || this.hasPlugin("classPrivateMethods")) && this.state.classLevel > 0) {
@@ -6651,7 +7358,7 @@ class Tokenizer extends LocationParser {
     } else if (this.getPluginOption("pipelineOperator", "proposal") === "smart") {
       this.finishOp(types.hash, 1);
     } else {
-      this.raise(this.state.pos, "Unexpected character '#'");
+      throw this.raise(this.state.pos, "Unexpected character '#'");
     }
   }
 
@@ -6663,9 +7370,7 @@ class Tokenizer extends LocationParser {
       return;
     }
 
-    const next2 = this.input.charCodeAt(this.state.pos + 2);
-
-    if (next === 46 && next2 === 46) {
+    if (next === 46 && this.input.charCodeAt(this.state.pos + 2) === 46) {
       this.state.pos += 3;
       this.finishToken(types.ellipsis);
     } else {
@@ -6697,7 +7402,7 @@ class Tokenizer extends LocationParser {
     let ch = this.input.charCodeAt(this.state.pos);
     if (ch !== 33) return false;
 
-    while (ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233 && ++this.state.pos < this.length) {
+    while (!isNewLine(ch) && ++this.state.pos < this.length) {
       ch = this.input.charCodeAt(this.state.pos);
     }
 
@@ -7012,7 +7717,7 @@ class Tokenizer extends LocationParser {
 
     }
 
-    this.raise(this.state.pos, `Unexpected character '${String.fromCodePoint(code)}'`);
+    throw this.raise(this.state.pos, `Unexpected character '${String.fromCodePoint(code)}'`);
   }
 
   finishOp(type, size) {
@@ -7027,13 +7732,13 @@ class Tokenizer extends LocationParser {
 
     for (;;) {
       if (this.state.pos >= this.length) {
-        this.raise(start, "Unterminated regular expression");
+        throw this.raise(start, "Unterminated regular expression");
       }
 
       const ch = this.input.charAt(this.state.pos);
 
       if (lineBreak.test(ch)) {
-        this.raise(start, "Unterminated regular expression");
+        throw this.raise(start, "Unterminated regular expression");
       }
 
       if (escaped) {
@@ -7065,14 +7770,14 @@ class Tokenizer extends LocationParser {
         if (mods.indexOf(char) > -1) {
           this.raise(this.state.pos + 1, "Duplicate regular expression flag");
         }
-
-        ++this.state.pos;
-        mods += char;
       } else if (isIdentifierChar(charCode) || charCode === 92) {
         this.raise(this.state.pos + 1, "Invalid regular expression flag");
       } else {
         break;
       }
+
+      ++this.state.pos;
+      mods += char;
     }
 
     this.finishToken(types.regexp, {
@@ -7081,10 +7786,11 @@ class Tokenizer extends LocationParser {
     });
   }
 
-  readInt(radix, len) {
+  readInt(radix, len, forceLen, allowNumSeparator = true) {
     const start = this.state.pos;
     const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;
     const allowedSiblings = radix === 16 ? allowedNumericSeparatorSiblings.hex : radix === 10 ? allowedNumericSeparatorSiblings.dec : radix === 8 ? allowedNumericSeparatorSiblings.oct : allowedNumericSeparatorSiblings.bin;
+    let invalid = false;
     let total = 0;
 
     for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
@@ -7092,16 +7798,18 @@ class Tokenizer extends LocationParser {
       let val;
 
       if (this.hasPlugin("numericSeparator")) {
-        const prev = this.input.charCodeAt(this.state.pos - 1);
-        const next = this.input.charCodeAt(this.state.pos + 1);
-
         if (code === 95) {
+          const prev = this.input.charCodeAt(this.state.pos - 1);
+          const next = this.input.charCodeAt(this.state.pos + 1);
+
           if (allowedSiblings.indexOf(next) === -1) {
-            this.raise(this.state.pos, "Invalid or unexpected token");
+            this.raise(this.state.pos, "A numeric separator is only allowed between two digits");
+          } else if (forbiddenSiblings.indexOf(prev) > -1 || forbiddenSiblings.indexOf(next) > -1 || Number.isNaN(next)) {
+            this.raise(this.state.pos, "A numeric separator is only allowed between two digits");
           }
 
-          if (forbiddenSiblings.indexOf(prev) > -1 || forbiddenSiblings.indexOf(next) > -1 || Number.isNaN(next)) {
-            this.raise(this.state.pos, "Invalid or unexpected token");
+          if (!allowNumSeparator) {
+            this.raise(this.state.pos, "Numeric separators are not allowed inside unicode escape sequences or hex escape sequences");
           }
 
           ++this.state.pos;
@@ -7119,12 +7827,23 @@ class Tokenizer extends LocationParser {
         val = Infinity;
       }
 
-      if (val >= radix) break;
+      if (val >= radix) {
+        if (this.options.errorRecovery && val <= 9) {
+          val = 0;
+          this.raise(this.state.start + i + 2, "Expected number in radix " + radix);
+        } else if (forceLen) {
+          val = 0;
+          invalid = true;
+        } else {
+          break;
+        }
+      }
+
       ++this.state.pos;
       total = total * radix + val;
     }
 
-    if (this.state.pos === start || len != null && this.state.pos - start !== len) {
+    if (this.state.pos === start || len != null && this.state.pos - start !== len || invalid) {
       return null;
     }
 
@@ -7149,7 +7868,7 @@ class Tokenizer extends LocationParser {
     }
 
     if (isIdentifierStart(this.input.codePointAt(this.state.pos))) {
-      this.raise(this.state.pos, "Identifier directly after number");
+      throw this.raise(this.state.pos, "Identifier directly after number");
     }
 
     if (isBigInt) {
@@ -7165,6 +7884,7 @@ class Tokenizer extends LocationParser {
     const start = this.state.pos;
     let isFloat = false;
     let isBigInt = false;
+    let isNonOctalDecimalInt = false;
 
     if (!startsWithDot && this.readInt(10) === null) {
       this.raise(start, "Invalid number");
@@ -7179,6 +7899,7 @@ class Tokenizer extends LocationParser {
 
       if (/[89]/.test(this.input.slice(start, this.state.pos))) {
         octal = false;
+        isNonOctalDecimalInt = true;
       }
     }
 
@@ -7203,16 +7924,27 @@ class Tokenizer extends LocationParser {
       next = this.input.charCodeAt(this.state.pos);
     }
 
+    if (this.hasPlugin("numericSeparator") && (octal || isNonOctalDecimalInt)) {
+      const underscorePos = this.input.slice(start, this.state.pos).indexOf("_");
+
+      if (underscorePos > 0) {
+        this.raise(underscorePos + start, "Numeric separator can not be used after leading 0");
+      }
+    }
+
     if (this.hasPlugin("bigInt")) {
       if (next === 110) {
-        if (isFloat || octal) this.raise(start, "Invalid BigIntLiteral");
+        if (isFloat || octal || isNonOctalDecimalInt) {
+          this.raise(start, "Invalid BigIntLiteral");
+        }
+
         ++this.state.pos;
         isBigInt = true;
       }
     }
 
     if (isIdentifierStart(this.input.codePointAt(this.state.pos))) {
-      this.raise(this.state.pos, "Identifier directly after number");
+      throw this.raise(this.state.pos, "Identifier directly after number");
     }
 
     const str = this.input.slice(start, this.state.pos).replace(/[_n]/g, "");
@@ -7232,7 +7964,7 @@ class Tokenizer extends LocationParser {
 
     if (ch === 123) {
       const codePos = ++this.state.pos;
-      code = this.readHexChar(this.input.indexOf("}", this.state.pos) - this.state.pos, throwOnInvalid);
+      code = this.readHexChar(this.input.indexOf("}", this.state.pos) - this.state.pos, true, throwOnInvalid);
       ++this.state.pos;
 
       if (code === null) {
@@ -7246,7 +7978,7 @@ class Tokenizer extends LocationParser {
         }
       }
     } else {
-      code = this.readHexChar(4, throwOnInvalid);
+      code = this.readHexChar(4, false, throwOnInvalid);
     }
 
     return code;
@@ -7258,7 +7990,7 @@ class Tokenizer extends LocationParser {
 
     for (;;) {
       if (this.state.pos >= this.length) {
-        this.raise(this.state.start, "Unterminated string constant");
+        throw this.raise(this.state.start, "Unterminated string constant");
       }
 
       const ch = this.input.charCodeAt(this.state.pos);
@@ -7272,7 +8004,7 @@ class Tokenizer extends LocationParser {
         ++this.state.pos;
         ++this.state.curLine;
       } else if (isNewLine(ch)) {
-        this.raise(this.state.start, "Unterminated string constant");
+        throw this.raise(this.state.start, "Unterminated string constant");
       } else {
         ++this.state.pos;
       }
@@ -7289,7 +8021,7 @@ class Tokenizer extends LocationParser {
 
     for (;;) {
       if (this.state.pos >= this.length) {
-        this.raise(this.state.start, "Unterminated template");
+        throw this.raise(this.state.start, "Unterminated template");
       }
 
       const ch = this.input.charCodeAt(this.state.pos);
@@ -7365,7 +8097,7 @@ class Tokenizer extends LocationParser {
 
       case 120:
         {
-          const code = this.readHexChar(2, throwOnInvalid);
+          const code = this.readHexChar(2, false, throwOnInvalid);
           return code === null ? null : String.fromCharCode(code);
         }
 
@@ -7400,6 +8132,14 @@ class Tokenizer extends LocationParser {
       case 8233:
         return "";
 
+      case 56:
+      case 57:
+        if (inTemplate) {
+          const codePos = this.state.pos - 1;
+          this.state.invalidTemplateEscapePosition = codePos;
+          return null;
+        }
+
       default:
         if (ch >= 48 && ch <= 55) {
           const codePos = this.state.pos - 1;
@@ -7433,9 +8173,9 @@ class Tokenizer extends LocationParser {
     }
   }
 
-  readHexChar(len, throwOnInvalid) {
+  readHexChar(len, forceLen, throwOnInvalid) {
     const codePos = this.state.pos;
-    const n = this.readInt(16, len);
+    const n = this.readInt(16, len, forceLen, false);
 
     if (n === null) {
       if (throwOnInvalid) {
@@ -7470,16 +8210,20 @@ class Tokenizer extends LocationParser {
 
         if (this.input.charCodeAt(++this.state.pos) !== 117) {
           this.raise(this.state.pos, "Expecting Unicode escape sequence \\uXXXX");
+          continue;
         }
 
         ++this.state.pos;
         const esc = this.readCodePoint(true);
 
-        if (!identifierCheck(esc, true)) {
-          this.raise(escStart, "Invalid Unicode escape");
+        if (esc !== null) {
+          if (!identifierCheck(esc)) {
+            this.raise(escStart, "Invalid Unicode escape");
+          }
+
+          word += String.fromCodePoint(esc);
         }
 
-        word += String.fromCodePoint(esc);
         chunkStart = this.state.pos;
       } else {
         break;
@@ -7497,10 +8241,6 @@ class Tokenizer extends LocationParser {
     const word = this.readWord1();
     const type = keywords.get(word) || types.name;
 
-    if (type.keyword && this.state.containsEsc) {
-      this.raise(this.state.pos, `Escape sequence in keyword ${word}`);
-    }
-
     if (this.state.isIterator && (!this.isIterator(word) || !this.state.inType)) {
       this.raise(this.state.pos, `Invalid identifier ${word}`);
     }
@@ -7508,6 +8248,14 @@ class Tokenizer extends LocationParser {
     this.finishToken(type, word);
   }
 
+  checkKeywordEscapes() {
+    const kw = this.state.type.keyword;
+
+    if (kw && this.state.containsEsc) {
+      this.raise(this.state.start, `Escape sequence in keyword ${kw}`);
+    }
+  }
+
   braceIsBlock(prevType) {
     const parent = this.curContext();
 
@@ -7570,8 +8318,18 @@ class UtilParser extends Tokenizer {
   }
 
   isLookaheadRelational(op) {
-    const l = this.lookahead();
-    return l.type === types.relational && l.value === op;
+    const next = this.nextTokenStart();
+
+    if (this.input.charAt(next) === op) {
+      if (next + 1 === this.input.length) {
+        return true;
+      }
+
+      const afterNext = this.input.charCodeAt(next + 1);
+      return afterNext !== op.charCodeAt(0) && afterNext !== 61;
+    }
+
+    return false;
   }
 
   expectRelational(op) {
@@ -7595,9 +8353,14 @@ class UtilParser extends Tokenizer {
     return this.match(types.name) && this.state.value === name && !this.state.containsEsc;
   }
 
+  isUnparsedContextual(nameStart, name) {
+    const nameEnd = nameStart + name.length;
+    return this.input.slice(nameStart, nameEnd) === name && (nameEnd === this.input.length || !isIdentifierChar(this.input.charCodeAt(nameEnd)));
+  }
+
   isLookaheadContextual(name) {
-    const l = this.lookahead();
-    return l.type === types.name && l.value === name;
+    const next = this.nextTokenStart();
+    return this.isUnparsedContextual(next, name);
   }
 
   eatContextual(name) {
@@ -7661,11 +8424,11 @@ class UtilParser extends Tokenizer {
   }
 
   checkYieldAwaitInDefaultParams() {
-    if (this.state.yieldPos && (!this.state.awaitPos || this.state.yieldPos < this.state.awaitPos)) {
+    if (this.state.yieldPos !== -1 && (this.state.awaitPos === -1 || this.state.yieldPos < this.state.awaitPos)) {
       this.raise(this.state.yieldPos, "Yield cannot be used as name inside a generator function");
     }
 
-    if (this.state.awaitPos) {
+    if (this.state.awaitPos !== -1) {
       this.raise(this.state.awaitPos, "Await cannot be used as name inside an async function");
     }
   }
@@ -7689,6 +8452,64 @@ class UtilParser extends Tokenizer {
     return false;
   }
 
+  tryParse(fn, oldState = this.state.clone()) {
+    const abortSignal = {
+      node: null
+    };
+
+    try {
+      const node = fn((node = null) => {
+        abortSignal.node = node;
+        throw abortSignal;
+      });
+
+      if (this.state.errors.length > oldState.errors.length) {
+        const failState = this.state;
+        this.state = oldState;
+        return {
+          node,
+          error: failState.errors[oldState.errors.length],
+          thrown: false,
+          aborted: false,
+          failState
+        };
+      }
+
+      return {
+        node,
+        error: null,
+        thrown: false,
+        aborted: false,
+        failState: null
+      };
+    } catch (error) {
+      const failState = this.state;
+      this.state = oldState;
+
+      if (error instanceof SyntaxError) {
+        return {
+          node: null,
+          error,
+          thrown: true,
+          aborted: false,
+          failState
+        };
+      }
+
+      if (error === abortSignal) {
+        return {
+          node: abortSignal.node,
+          error: null,
+          thrown: false,
+          aborted: true,
+          failState
+        };
+      }
+
+      throw error;
+    }
+  }
+
 }
 
 class Node {
@@ -7763,9 +8584,25 @@ class NodeUtils extends UtilParser {
 
 }
 
+const unwrapParenthesizedExpression = node => {
+  return node.type === "ParenthesizedExpression" ? unwrapParenthesizedExpression(node.expression) : node;
+};
+
 class LValParser extends NodeUtils {
   toAssignable(node, isBinding, contextDescription) {
+    var _node$extra3;
+
     if (node) {
+      var _node$extra;
+
+      if (this.options.createParenthesizedExpressions && node.type === "ParenthesizedExpression" || ((_node$extra = node.extra) == null ? void 0 : _node$extra.parenthesized)) {
+        const parenthesized = unwrapParenthesizedExpression(node);
+
+        if (parenthesized.type !== "Identifier" && parenthesized.type !== "MemberExpression") {
+          this.raise(node.start, "Invalid parenthesized assignment pattern");
+        }
+      }
+
       switch (node.type) {
         case "Identifier":
         case "ObjectPattern":
@@ -7777,9 +8614,15 @@ class LValParser extends NodeUtils {
           node.type = "ObjectPattern";
 
           for (let i = 0, length = node.properties.length, last = length - 1; i < length; i++) {
+            var _node$extra2;
+
             const prop = node.properties[i];
             const isLast = i === last;
             this.toAssignableObjectExpressionProp(prop, isBinding, isLast);
+
+            if (isLast && prop.type === "RestElement" && ((_node$extra2 = node.extra) == null ? void 0 : _node$extra2.trailingComma)) {
+              this.raiseRestNotLast(node.extra.trailingComma);
+            }
           }
 
           break;
@@ -7799,31 +8642,22 @@ class LValParser extends NodeUtils {
 
         case "ArrayExpression":
           node.type = "ArrayPattern";
-          this.toAssignableList(node.elements, isBinding, contextDescription);
+          this.toAssignableList(node.elements, isBinding, contextDescription, (_node$extra3 = node.extra) == null ? void 0 : _node$extra3.trailingComma);
           break;
 
         case "AssignmentExpression":
-          if (node.operator === "=") {
-            node.type = "AssignmentPattern";
-            delete node.operator;
-          } else {
+          if (node.operator !== "=") {
             this.raise(node.left.end, "Only '=' operator can be used for specifying default value.");
           }
 
+          node.type = "AssignmentPattern";
+          delete node.operator;
+          this.toAssignable(node.left, isBinding, contextDescription);
           break;
 
         case "ParenthesizedExpression":
           node.expression = this.toAssignable(node.expression, isBinding, contextDescription);
           break;
-
-        case "MemberExpression":
-          if (!isBinding) break;
-
-        default:
-          {
-            const message = "Invalid left-hand side" + (contextDescription ? " in " + contextDescription : "expression");
-            this.raise(node.start, message);
-          }
       }
     }
 
@@ -7841,7 +8675,7 @@ class LValParser extends NodeUtils {
     }
   }
 
-  toAssignableList(exprList, isBinding, contextDescription) {
+  toAssignableList(exprList, isBinding, contextDescription, trailingCommaPos) {
     let end = exprList.length;
 
     if (end) {
@@ -7858,6 +8692,10 @@ class LValParser extends NodeUtils {
           this.unexpected(arg.start);
         }
 
+        if (trailingCommaPos) {
+          this.raiseTrailingCommaAfterRest(trailingCommaPos);
+        }
+
         --end;
       }
     }
@@ -7891,19 +8729,12 @@ class LValParser extends NodeUtils {
         this.toReferencedListDeep(expr.elements);
       }
     }
-
-    return exprList;
   }
 
   parseSpread(refShorthandDefaultPos, refNeedsArrowPos) {
     const node = this.startNode();
     this.next();
     node.argument = this.parseMaybeAssign(false, refShorthandDefaultPos, undefined, refNeedsArrowPos);
-
-    if (this.state.commaAfterSpreadAt === -1 && this.match(types.comma)) {
-      this.state.commaAfterSpreadAt = this.state.start;
-    }
-
     return this.finishNode(node, "SpreadElement");
   }
 
@@ -7920,7 +8751,7 @@ class LValParser extends NodeUtils {
         {
           const node = this.startNode();
           this.next();
-          node.elements = this.parseBindingList(types.bracketR, true);
+          node.elements = this.parseBindingList(types.bracketR, 93, true);
           return this.finishNode(node, "ArrayPattern");
         }
 
@@ -7931,7 +8762,7 @@ class LValParser extends NodeUtils {
     return this.parseIdentifier();
   }
 
-  parseBindingList(close, allowEmpty, allowModifiers) {
+  parseBindingList(close, closeCharCode, allowEmpty, allowModifiers) {
     const elts = [];
     let first = true;
 
@@ -7948,7 +8779,7 @@ class LValParser extends NodeUtils {
         break;
       } else if (this.match(types.ellipsis)) {
         elts.push(this.parseAssignableListItemTypes(this.parseRestBinding()));
-        this.checkCommaAfterRest();
+        this.checkCommaAfterRest(closeCharCode);
         this.expect(close);
         break;
       } else {
@@ -7996,10 +8827,10 @@ class LValParser extends NodeUtils {
     return this.finishNode(node, "AssignmentPattern");
   }
 
-  checkLVal(expr, bindingType = BIND_NONE, checkClashes, contextDescription) {
+  checkLVal(expr, bindingType = BIND_NONE, checkClashes, contextDescription, disallowLetBinding, strictModeChanged = false) {
     switch (expr.type) {
       case "Identifier":
-        if (this.state.strict && isStrictBindReservedWord(expr.name, this.inModule)) {
+        if (this.state.strict && (strictModeChanged ? isStrictBindReservedWord(expr.name, this.inModule) : isStrictBindOnlyReservedWord(expr.name))) {
           this.raise(expr.start, `${bindingType === BIND_NONE ? "Assigning to" : "Binding"} '${expr.name}' in strict mode`);
         }
 
@@ -8013,7 +8844,7 @@ class LValParser extends NodeUtils {
           }
         }
 
-        if (bindingType === BIND_LEXICAL && expr.name === "let") {
+        if (disallowLetBinding && expr.name === "let") {
           this.raise(expr.start, "'let' is not allowed to be used as a name in 'let' or 'const' declarations.");
         }
 
@@ -8033,8 +8864,8 @@ class LValParser extends NodeUtils {
       case "ObjectPattern":
         for (let _i2 = 0, _expr$properties = expr.properties; _i2 < _expr$properties.length; _i2++) {
           let prop = _expr$properties[_i2];
-          if (prop.type === "ObjectProperty") prop = prop.value;
-          this.checkLVal(prop, bindingType, checkClashes, "object destructuring pattern");
+          if (prop.type === "ObjectProperty") prop = prop.value;else if (prop.type === "ObjectMethod") continue;
+          this.checkLVal(prop, bindingType, checkClashes, "object destructuring pattern", disallowLetBinding);
         }
 
         break;
@@ -8044,7 +8875,7 @@ class LValParser extends NodeUtils {
           const elem = _expr$elements[_i3];
 
           if (elem) {
-            this.checkLVal(elem, bindingType, checkClashes, "array destructuring pattern");
+            this.checkLVal(elem, bindingType, checkClashes, "array destructuring pattern", disallowLetBinding);
           }
         }
 
@@ -8076,30 +8907,28 @@ class LValParser extends NodeUtils {
     }
   }
 
-  checkCommaAfterRest() {
+  checkCommaAfterRest(close) {
     if (this.match(types.comma)) {
-      this.raiseRestNotLast(this.state.start);
+      if (this.lookaheadCharCode() === close) {
+        this.raiseTrailingCommaAfterRest(this.state.start);
+      } else {
+        this.raiseRestNotLast(this.state.start);
+      }
     }
   }
 
-  checkCommaAfterRestFromSpread() {
-    if (this.state.commaAfterSpreadAt > -1) {
-      this.raiseRestNotLast(this.state.commaAfterSpreadAt);
-    }
+  raiseRestNotLast(pos) {
+    throw this.raise(pos, `Rest element must be last element`);
   }
 
-  raiseRestNotLast(pos) {
-    this.raise(pos, `Rest element must be last element`);
+  raiseTrailingCommaAfterRest(pos) {
+    this.raise(pos, `Unexpected trailing comma after rest element`);
   }
 
 }
 
-const unwrapParenthesizedExpression = node => {
-  return node.type === "ParenthesizedExpression" ? unwrapParenthesizedExpression(node.expression) : node;
-};
-
 class ExpressionParser extends LValParser {
-  checkPropClash(prop, propHash) {
+  checkDuplicatedProto(prop, protoRef) {
     if (prop.type === "SpreadElement" || prop.computed || prop.kind || prop.shorthand) {
       return;
     }
@@ -8108,11 +8937,11 @@ class ExpressionParser extends LValParser {
     const name = key.type === "Identifier" ? key.name : String(key.value);
 
     if (name === "__proto__") {
-      if (propHash.proto) {
-        this.raise(key.start, "Redefinition of __proto__ property");
+      if (protoRef.used && !protoRef.start) {
+        protoRef.start = key.start;
       }
 
-      propHash.proto = true;
+      protoRef.used = true;
     }
   }
 
@@ -8126,6 +8955,7 @@ class ExpressionParser extends LValParser {
     }
 
     expr.comments = this.state.comments;
+    expr.errors = this.state.errors;
     return expr;
   }
 
@@ -8167,8 +8997,6 @@ class ExpressionParser extends LValParser {
       }
     }
 
-    const oldCommaAfterSpreadAt = this.state.commaAfterSpreadAt;
-    this.state.commaAfterSpreadAt = -1;
     let failOnShorthandAssign;
 
     if (refShorthandDefaultPos) {
@@ -8205,23 +9033,12 @@ class ExpressionParser extends LValParser {
       }
 
       node.left = this.match(types.eq) ? this.toAssignable(left, undefined, "assignment expression") : left;
-      refShorthandDefaultPos.start = 0;
-      this.checkLVal(left, undefined, undefined, "assignment expression");
-      const maybePattern = unwrapParenthesizedExpression(left);
-      let patternErrorMsg;
-
-      if (maybePattern.type === "ObjectPattern") {
-        patternErrorMsg = "`({a}) = 0` use `({a} = 0)`";
-      } else if (maybePattern.type === "ArrayPattern") {
-        patternErrorMsg = "`([a]) = 0` use `([a] = 0)`";
-      }
 
-      if (patternErrorMsg && (left.extra && left.extra.parenthesized || left.type === "ParenthesizedExpression")) {
-        this.raise(maybePattern.start, `You're trying to assign to a parenthesized expression, eg. instead of ${patternErrorMsg}`);
+      if (refShorthandDefaultPos.start >= node.left.start) {
+        refShorthandDefaultPos.start = 0;
       }
 
-      if (patternErrorMsg) this.checkCommaAfterRestFromSpread();
-      this.state.commaAfterSpreadAt = oldCommaAfterSpreadAt;
+      this.checkLVal(left, undefined, undefined, "assignment expression");
       this.next();
       node.right = this.parseMaybeAssign(noIn);
       return this.finishNode(node, "AssignmentExpression");
@@ -8229,7 +9046,6 @@ class ExpressionParser extends LValParser {
       this.unexpected(refShorthandDefaultPos.start);
     }
 
-    this.state.commaAfterSpreadAt = oldCommaAfterSpreadAt;
     return left;
   }
 
@@ -8315,6 +9131,15 @@ class ExpressionParser extends LValParser {
         }
 
         node.right = this.parseExprOpRightExpr(op, prec, noIn);
+
+        if (op === types.nullishCoalescing) {
+          if (left.type === "LogicalExpression" && left.operator !== "??" && !(left.extra && left.extra.parenthesized)) {
+            throw this.raise(left.start, `Nullish coalescing operator(??) requires parens when mixing with logical operators`);
+          } else if (node.right.type === "LogicalExpression" && node.right.operator !== "??" && !(node.right.extra && node.right.extra.parenthesized)) {
+            throw this.raise(node.right.start, `Nullish coalescing operator(??) requires parens when mixing with logical operators`);
+          }
+        }
+
         this.finishNode(node, op === types.logicalOR || op === types.logicalAND || op === types.nullishCoalescing ? "LogicalExpression" : "BinaryExpression");
         return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec, noIn);
       }
@@ -8353,7 +9178,7 @@ class ExpressionParser extends LValParser {
   }
 
   parseMaybeUnary(refShorthandDefaultPos) {
-    if (this.isContextual("await") && (this.scope.inAsync || !this.scope.inFunction && this.options.allowAwaitOutsideFunction)) {
+    if (this.isContextual("await") && this.isAwaitAllowed()) {
       return this.parseAwait();
     } else if (this.state.type.prefix) {
       const node = this.startNode();
@@ -8423,20 +9248,21 @@ class ExpressionParser extends LValParser {
   }
 
   parseSubscripts(base, startPos, startLoc, noCalls) {
-    const maybeAsyncArrow = this.atPossibleAsync(base);
     const state = {
       optionalChainMember: false,
+      maybeAsyncArrow: this.atPossibleAsync(base),
       stop: false
     };
 
     do {
-      base = this.parseSubscript(base, startPos, startLoc, noCalls, state, maybeAsyncArrow);
+      base = this.parseSubscript(base, startPos, startLoc, noCalls, state);
+      state.maybeAsyncArrow = false;
     } while (!state.stop);
 
     return base;
   }
 
-  parseSubscript(base, startPos, startLoc, noCalls, state, maybeAsyncArrow) {
+  parseSubscript(base, startPos, startLoc, noCalls, state) {
     if (!noCalls && this.eat(types.doubleColon)) {
       const node = this.startNodeAt(startPos, startLoc);
       node.object = base;
@@ -8447,7 +9273,7 @@ class ExpressionParser extends LValParser {
       this.expectPlugin("optionalChaining");
       state.optionalChainMember = true;
 
-      if (noCalls && this.lookahead().type === types.parenL) {
+      if (noCalls && this.lookaheadCharCode() === 40) {
         state.stop = true;
         return base;
       }
@@ -8466,7 +9292,7 @@ class ExpressionParser extends LValParser {
         node.callee = base;
         node.arguments = this.parseCallExpressionArguments(types.parenR, false);
         node.optional = true;
-        return this.finishNode(node, "OptionalCallExpression");
+        return this.finishCallExpression(node, true);
       } else {
         node.object = base;
         node.property = this.parseIdentifier(true);
@@ -8480,6 +9306,10 @@ class ExpressionParser extends LValParser {
       node.property = this.parseMaybePrivateName();
       node.computed = false;
 
+      if (node.property.type === "PrivateName" && node.object.type === "Super") {
+        this.raise(startPos, "Private fields can't be accessed on super");
+      }
+
       if (state.optionalChainMember) {
         node.optional = false;
         return this.finishNode(node, "OptionalMemberExpression");
@@ -8504,36 +9334,30 @@ class ExpressionParser extends LValParser {
       const oldYieldPos = this.state.yieldPos;
       const oldAwaitPos = this.state.awaitPos;
       this.state.maybeInArrowParameters = true;
-      this.state.yieldPos = 0;
-      this.state.awaitPos = 0;
+      this.state.yieldPos = -1;
+      this.state.awaitPos = -1;
       this.next();
       let node = this.startNodeAt(startPos, startLoc);
       node.callee = base;
-      const oldCommaAfterSpreadAt = this.state.commaAfterSpreadAt;
-      this.state.commaAfterSpreadAt = -1;
-      node.arguments = this.parseCallExpressionArguments(types.parenR, maybeAsyncArrow, base.type === "Import", base.type !== "Super");
-
-      if (!state.optionalChainMember) {
-        this.finishCallExpression(node);
-      } else {
-        this.finishOptionalCallExpression(node);
-      }
+      node.arguments = this.parseCallExpressionArguments(types.parenR, state.maybeAsyncArrow, base.type === "Import", base.type !== "Super", node);
+      this.finishCallExpression(node, state.optionalChainMember);
 
-      if (maybeAsyncArrow && this.shouldParseAsyncArrow()) {
+      if (state.maybeAsyncArrow && this.shouldParseAsyncArrow()) {
         state.stop = true;
-        this.checkCommaAfterRestFromSpread();
         node = this.parseAsyncArrowFromCallExpression(this.startNodeAt(startPos, startLoc), node);
         this.checkYieldAwaitInDefaultParams();
         this.state.yieldPos = oldYieldPos;
         this.state.awaitPos = oldAwaitPos;
       } else {
         this.toReferencedListDeep(node.arguments);
-        this.state.yieldPos = oldYieldPos || this.state.yieldPos;
-        this.state.awaitPos = oldAwaitPos || this.state.awaitPos;
+        if (oldYieldPos !== -1) this.state.yieldPos = oldYieldPos;
+
+        if (!this.isAwaitAllowed() && !oldMaybeInArrowParameters || oldAwaitPos !== -1) {
+          this.state.awaitPos = oldAwaitPos;
+        }
       }
 
       this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
-      this.state.commaAfterSpreadAt = oldCommaAfterSpreadAt;
       return node;
     } else if (this.match(types.backQuote)) {
       return this.parseTaggedTemplateExpression(startPos, startLoc, base, state);
@@ -8560,39 +9384,23 @@ class ExpressionParser extends LValParser {
     return base.type === "Identifier" && base.name === "async" && this.state.lastTokEnd === base.end && !this.canInsertSemicolon() && this.input.slice(base.start, base.end) === "async";
   }
 
-  finishCallExpression(node) {
-    if (node.callee.type === "Import") {
-      if (node.arguments.length !== 1) {
-        this.raise(node.start, "import() requires exactly one argument");
-      }
-
-      const importArg = node.arguments[0];
-
-      if (importArg && importArg.type === "SpreadElement") {
-        this.raise(importArg.start, "... is not allowed in import()");
-      }
-    }
-
-    return this.finishNode(node, "CallExpression");
-  }
-
-  finishOptionalCallExpression(node) {
+  finishCallExpression(node, optional) {
     if (node.callee.type === "Import") {
       if (node.arguments.length !== 1) {
         this.raise(node.start, "import() requires exactly one argument");
-      }
-
-      const importArg = node.arguments[0];
+      } else {
+        const importArg = node.arguments[0];
 
-      if (importArg && importArg.type === "SpreadElement") {
-        this.raise(importArg.start, "... is not allowed in import()");
+        if (importArg && importArg.type === "SpreadElement") {
+          this.raise(importArg.start, "... is not allowed in import()");
+        }
       }
     }
 
-    return this.finishNode(node, "OptionalCallExpression");
+    return this.finishNode(node, optional ? "OptionalCallExpression" : "CallExpression");
   }
 
-  parseCallExpressionArguments(close, possibleAsyncArrow, dynamicImport, allowPlaceholder) {
+  parseCallExpressionArguments(close, possibleAsyncArrow, dynamicImport, allowPlaceholder, nodeForExtra) {
     const elts = [];
     let innerParenStart;
     let first = true;
@@ -8605,11 +9413,16 @@ class ExpressionParser extends LValParser {
       } else {
         this.expect(types.comma);
 
-        if (this.eat(close)) {
+        if (this.match(close)) {
           if (dynamicImport) {
             this.raise(this.state.lastTokStart, "Trailing comma is disallowed inside import(...) arguments");
           }
 
+          if (nodeForExtra) {
+            this.addExtra(nodeForExtra, "trailingComma", this.state.lastTokStart);
+          }
+
+          this.next();
           break;
         }
       }
@@ -8638,8 +9451,10 @@ class ExpressionParser extends LValParser {
   }
 
   parseAsyncArrowFromCallExpression(node, call) {
+    var _call$extra;
+
     this.expect(types.arrow);
-    this.parseArrowExpression(node, call.arguments, true);
+    this.parseArrowExpression(node, call.arguments, true, (_call$extra = call.extra) == null ? void 0 : _call$extra.trailingComma);
     return node;
   }
 
@@ -8656,19 +9471,17 @@ class ExpressionParser extends LValParser {
 
     switch (this.state.type) {
       case types._super:
-        if (!this.scope.allowSuper && !this.options.allowSuperOutsideMethod) {
-          this.raise(this.state.start, "super is only allowed in object methods and classes");
-        }
-
         node = this.startNode();
         this.next();
 
         if (this.match(types.parenL) && !this.scope.allowDirectSuper && !this.options.allowSuperOutsideMethod) {
           this.raise(node.start, "super() is only valid inside a class constructor of a subclass. " + "Maybe a typo in the method name ('constructor') or not extending another class?");
+        } else if (!this.scope.allowSuper && !this.options.allowSuperOutsideMethod) {
+          this.raise(node.start, "super is only allowed in object methods and classes");
         }
 
         if (!this.match(types.parenL) && !this.match(types.bracketL) && !this.match(types.dot)) {
-          this.unexpected();
+          this.raise(node.start, "super can only be used with function calls (i.e. super()) or " + "in property accesses (i.e. super.prop or super[prop])");
         }
 
         return this.finishNode(node, "Super");
@@ -8701,6 +9514,13 @@ class ExpressionParser extends LValParser {
           const id = this.parseIdentifier();
 
           if (!containsEsc && id.name === "async" && this.match(types._function) && !this.canInsertSemicolon()) {
+            const last = this.state.context.length - 1;
+
+            if (this.state.context[last] !== types$1.functionStatement) {
+              throw new Error("Internal error");
+            }
+
+            this.state.context[last] = types$1.functionExpression;
             this.next();
             return this.parseFunction(node, undefined, true);
           } else if (canBeArrow && !containsEsc && id.name === "async" && this.match(types.name) && !this.canInsertSemicolon()) {
@@ -8767,7 +9587,7 @@ class ExpressionParser extends LValParser {
           this.state.inFSharpPipelineDirectBody = false;
           node = this.startNode();
           this.next();
-          node.elements = this.parseExprList(types.bracketR, true, refShorthandDefaultPos);
+          node.elements = this.parseExprList(types.bracketR, true, refShorthandDefaultPos, node);
 
           if (!this.state.maybeInArrowParameters) {
             this.toReferencedList(node.elements);
@@ -8828,12 +9648,12 @@ class ExpressionParser extends LValParser {
 
             this.next();
 
-            if (this.primaryTopicReferenceIsAllowedInCurrentTopicContext()) {
-              this.registerTopicReference();
-              return this.finishNode(node, "PipelinePrimaryTopicReference");
-            } else {
-              throw this.raise(node.start, `Topic reference was used in a lexical context without topic binding`);
+            if (!this.primaryTopicReferenceIsAllowedInCurrentTopicContext()) {
+              this.raise(node.start, `Topic reference was used in a lexical context without topic binding`);
             }
+
+            this.registerTopicReference();
+            return this.finishNode(node, "PipelinePrimaryTopicReference");
           }
         }
 
@@ -8904,17 +9724,18 @@ class ExpressionParser extends LValParser {
 
     if (this.isContextual("meta")) {
       this.expectPlugin("importMeta");
+
+      if (!this.inModule) {
+        this.raise(id.start, `import.meta may appear only with 'sourceType: "module"'`, {
+          code: "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED"
+        });
+      }
+
+      this.sawUnambiguousESM = true;
     } else if (!this.hasPlugin("importMeta")) {
       this.raise(id.start, `Dynamic imports require a parameter: import('a.js')`);
     }
 
-    if (!this.inModule) {
-      this.raise(id.start, `import.meta may appear only with 'sourceType: "module"'`, {
-        code: "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED"
-      });
-    }
-
-    this.sawUnambiguousESM = true;
     return this.parseMetaProperty(node, id, "meta");
   }
 
@@ -8939,8 +9760,8 @@ class ExpressionParser extends LValParser {
     const oldAwaitPos = this.state.awaitPos;
     const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
     this.state.maybeInArrowParameters = true;
-    this.state.yieldPos = 0;
-    this.state.awaitPos = 0;
+    this.state.yieldPos = -1;
+    this.state.awaitPos = -1;
     this.state.inFSharpPipelineDirectBody = false;
     const innerStartPos = this.state.start;
     const innerStartLoc = this.state.startLoc;
@@ -8972,7 +9793,7 @@ class ExpressionParser extends LValParser {
         const spreadNodeStartLoc = this.state.startLoc;
         spreadStart = this.state.start;
         exprList.push(this.parseParenItem(this.parseRestBinding(), spreadNodeStartPos, spreadNodeStartLoc));
-        this.checkCommaAfterRest();
+        this.checkCommaAfterRest(41);
         break;
       } else {
         exprList.push(this.parseMaybeAssign(false, refShorthandDefaultPos, this.parseParenItem, refNeedsArrowPos));
@@ -9003,8 +9824,8 @@ class ExpressionParser extends LValParser {
       return arrowNode;
     }
 
-    this.state.yieldPos = oldYieldPos || this.state.yieldPos;
-    this.state.awaitPos = oldAwaitPos || this.state.awaitPos;
+    if (oldYieldPos !== -1) this.state.yieldPos = oldYieldPos;
+    if (oldAwaitPos !== -1) this.state.awaitPos = oldAwaitPos;
 
     if (!exprList.length) {
       this.unexpected(this.state.lastTokStart);
@@ -9056,7 +9877,9 @@ class ExpressionParser extends LValParser {
 
   parseNew() {
     const node = this.startNode();
-    const meta = this.parseIdentifier(true);
+    let meta = this.startNode();
+    this.next();
+    meta = this.createIdentifier(meta, "new");
 
     if (this.eat(types.dot)) {
       const metaProp = this.parseMetaProperty(node, meta, "target");
@@ -9148,11 +9971,16 @@ class ExpressionParser extends LValParser {
         first = false;
       } else {
         this.expect(types.comma);
-        if (this.eat(types.braceR)) break;
+
+        if (this.match(types.braceR)) {
+          this.addExtra(node, "trailingComma", this.state.lastTokStart);
+          this.next();
+          break;
+        }
       }
 
       const prop = this.parseObjectMember(isPattern, refShorthandDefaultPos);
-      if (!isPattern) this.checkPropClash(prop, propHash);
+      if (!isPattern) this.checkDuplicatedProto(prop, propHash);
 
       if (prop.shorthand) {
         this.addExtra(prop, "shorthand", true);
@@ -9161,6 +9989,10 @@ class ExpressionParser extends LValParser {
       node.properties.push(prop);
     }
 
+    if (!this.match(types.eq) && propHash.start !== undefined) {
+      this.raise(propHash.start, "Redefinition of __proto__ property");
+    }
+
     return this.finishNode(node, isPattern ? "ObjectPattern" : "ObjectExpression");
   }
 
@@ -9174,10 +10006,10 @@ class ExpressionParser extends LValParser {
     if (this.match(types.at)) {
       if (this.hasPlugin("decorators")) {
         this.raise(this.state.start, "Stage 2 decorators disallow object literal property decorators");
-      } else {
-        while (this.match(types.at)) {
-          decorators.push(this.parseDecorator());
-        }
+      }
+
+      while (this.match(types.at)) {
+        decorators.push(this.parseDecorator());
       }
     }
 
@@ -9193,7 +10025,7 @@ class ExpressionParser extends LValParser {
       if (isPattern) {
         this.next();
         prop.argument = this.parseIdentifier();
-        this.checkCommaAfterRest();
+        this.checkCommaAfterRest(125);
         return this.finishNode(prop, "RestElement");
       }
 
@@ -9337,8 +10169,8 @@ class ExpressionParser extends LValParser {
   parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope = false) {
     const oldYieldPos = this.state.yieldPos;
     const oldAwaitPos = this.state.awaitPos;
-    this.state.yieldPos = 0;
-    this.state.awaitPos = 0;
+    this.state.yieldPos = -1;
+    this.state.awaitPos = -1;
     this.initFunction(node, isAsync);
     node.generator = !!isGenerator;
     const allowModifiers = isConstructor;
@@ -9352,16 +10184,16 @@ class ExpressionParser extends LValParser {
     return node;
   }
 
-  parseArrowExpression(node, params, isAsync) {
+  parseArrowExpression(node, params, isAsync, trailingCommaPos) {
     this.scope.enter(functionFlags(isAsync, false) | SCOPE_ARROW);
     this.initFunction(node, isAsync);
     const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
     const oldYieldPos = this.state.yieldPos;
     const oldAwaitPos = this.state.awaitPos;
     this.state.maybeInArrowParameters = false;
-    this.state.yieldPos = 0;
-    this.state.awaitPos = 0;
-    if (params) this.setArrowFunctionParameters(node, params);
+    this.state.yieldPos = -1;
+    this.state.awaitPos = -1;
+    if (params) this.setArrowFunctionParameters(node, params, trailingCommaPos);
     this.parseFunctionBody(node, true);
     this.scope.exit();
     this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
@@ -9370,8 +10202,8 @@ class ExpressionParser extends LValParser {
     return this.finishNode(node, "ArrowFunctionExpression");
   }
 
-  setArrowFunctionParameters(node, params) {
-    node.params = this.toAssignableList(params, true, "arrow function parameters");
+  setArrowFunctionParameters(node, params, trailingCommaPos) {
+    node.params = this.toAssignableList(params, true, "arrow function parameters", trailingCommaPos);
   }
 
   isStrictBody(node) {
@@ -9404,7 +10236,7 @@ class ExpressionParser extends LValParser {
 
     if (isExpression) {
       node.body = this.parseMaybeAssign();
-      this.checkParams(node, false, allowExpression);
+      this.checkParams(node, false, allowExpression, false);
     } else {
       const nonSimple = !this.isSimpleParamList(node.params);
 
@@ -9420,7 +10252,7 @@ class ExpressionParser extends LValParser {
       const oldLabels = this.state.labels;
       this.state.labels = [];
       if (useStrict) this.state.strict = true;
-      this.checkParams(node, !oldStrict && !useStrict && !allowExpression && !isMethod && !nonSimple, allowExpression);
+      this.checkParams(node, !oldStrict && !useStrict && !allowExpression && !isMethod && !nonSimple, allowExpression, !oldStrict && useStrict);
       node.body = this.parseBlock(true, false);
       this.state.labels = oldLabels;
     }
@@ -9428,7 +10260,7 @@ class ExpressionParser extends LValParser {
     this.state.inParameters = oldInParameters;
 
     if (this.state.strict && node.id) {
-      this.checkLVal(node.id, BIND_OUTSIDE, undefined, "function name");
+      this.checkLVal(node.id, BIND_OUTSIDE, undefined, "function name", undefined, !oldStrict && useStrict);
     }
 
     this.state.strict = oldStrict;
@@ -9442,15 +10274,15 @@ class ExpressionParser extends LValParser {
     return true;
   }
 
-  checkParams(node, allowDuplicates, isArrowFunction) {
+  checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged = true) {
     const nameHash = Object.create(null);
 
     for (let i = 0; i < node.params.length; i++) {
-      this.checkLVal(node.params[i], BIND_VAR, allowDuplicates ? null : nameHash, "function paramter list");
+      this.checkLVal(node.params[i], BIND_VAR, allowDuplicates ? null : nameHash, "function parameter list", undefined, strictModeChanged);
     }
   }
 
-  parseExprList(close, allowEmpty, refShorthandDefaultPos) {
+  parseExprList(close, allowEmpty, refShorthandDefaultPos, nodeForExtra) {
     const elts = [];
     let first = true;
 
@@ -9459,7 +10291,15 @@ class ExpressionParser extends LValParser {
         first = false;
       } else {
         this.expect(types.comma);
-        if (this.eat(close)) break;
+
+        if (this.match(close)) {
+          if (nodeForExtra) {
+            this.addExtra(nodeForExtra, "trailingComma", this.state.lastTokStart);
+          }
+
+          this.next();
+          break;
+        }
       }
 
       elts.push(this.parseExprListItem(allowEmpty, refShorthandDefaultPos));
@@ -9521,7 +10361,9 @@ class ExpressionParser extends LValParser {
       throw this.unexpected();
     }
 
-    if (!liberal) {
+    if (liberal) {
+      this.state.type = types.name;
+    } else {
       this.checkReservedWord(name, this.state.start, !!this.state.type.keyword, false);
     }
 
@@ -9532,18 +10374,28 @@ class ExpressionParser extends LValParser {
   checkReservedWord(word, startLoc, checkKeywords, isBinding) {
     if (this.scope.inGenerator && word === "yield") {
       this.raise(startLoc, "Can not use 'yield' as identifier inside a generator");
+      return;
     }
 
-    if (this.scope.inAsync && word === "await") {
-      this.raise(startLoc, "Can not use 'await' as identifier inside an async function");
+    if (word === "await") {
+      if (this.scope.inAsync) {
+        this.raise(startLoc, "Can not use 'await' as identifier inside an async function");
+        return;
+      }
+
+      if (this.state.awaitPos === -1 && (this.state.maybeInArrowParameters || this.isAwaitAllowed())) {
+        this.state.awaitPos = this.state.start;
+      }
     }
 
-    if (this.state.inClassProperty && word === "arguments") {
+    if (this.scope.inClass && !this.scope.inNonArrowFunction && word === "arguments") {
       this.raise(startLoc, "'arguments' is not allowed in class field initializer");
+      return;
     }
 
     if (checkKeywords && isKeyword(word)) {
       this.raise(startLoc, `Unexpected keyword '${word}'`);
+      return;
     }
 
     const reservedTest = !this.state.strict ? isReservedWord : isBinding ? isStrictBindReservedWord : isStrictReservedWord;
@@ -9551,28 +10403,41 @@ class ExpressionParser extends LValParser {
     if (reservedTest(word, this.inModule)) {
       if (!this.scope.inAsync && word === "await") {
         this.raise(startLoc, "Can not use keyword 'await' outside an async function");
+      } else {
+        this.raise(startLoc, `Unexpected reserved word '${word}'`);
       }
-
-      this.raise(startLoc, `Unexpected reserved word '${word}'`);
     }
   }
 
-  parseAwait() {
-    if (!this.state.awaitPos) {
-      this.state.awaitPos = this.state.start;
-    }
+  isAwaitAllowed() {
+    if (this.scope.inFunction) return this.scope.inAsync;
+    if (this.options.allowAwaitOutsideFunction) return true;
+    if (this.hasPlugin("topLevelAwait")) return this.inModule;
+    return false;
+  }
 
+  parseAwait() {
     const node = this.startNode();
     this.next();
 
     if (this.state.inParameters) {
       this.raise(node.start, "await is not allowed in async function parameters");
+    } else if (this.state.awaitPos === -1) {
+      this.state.awaitPos = node.start;
     }
 
-    if (this.match(types.star)) {
+    if (this.eat(types.star)) {
       this.raise(node.start, "await* has been removed from the async functions proposal. Use Promise.all() instead.");
     }
 
+    if (!this.scope.inFunction && !this.options.allowAwaitOutsideFunction) {
+      if (this.hasPrecedingLineBreak() || this.match(types.plusMin) || this.match(types.parenL) || this.match(types.bracketL) || this.match(types.backQuote) || this.match(types.regexp) || this.match(types.slash) || this.hasPlugin("v8intrinsic") && this.match(types.modulo)) {
+        this.ambiguousScriptDifferentAst = true;
+      } else {
+        this.sawUnambiguousESM = true;
+      }
+    }
+
     if (!this.state.soloAwait) {
       node.argument = this.parseMaybeUnary();
     }
@@ -9581,19 +10446,17 @@ class ExpressionParser extends LValParser {
   }
 
   parseYield(noIn) {
-    if (!this.state.yieldPos) {
-      this.state.yieldPos = this.state.start;
-    }
-
     const node = this.startNode();
 
     if (this.state.inParameters) {
       this.raise(node.start, "yield is not allowed in generator parameters");
+    } else if (this.state.yieldPos === -1) {
+      this.state.yieldPos = node.start;
     }
 
     this.next();
 
-    if (this.match(types.semi) || !this.match(types.star) && !this.state.type.startsExpr || this.canInsertSemicolon()) {
+    if (this.match(types.semi) || !this.match(types.star) && !this.state.type.startsExpr || this.hasPrecedingLineBreak()) {
       node.delegate = false;
       node.argument = null;
     } else {
@@ -9607,7 +10470,7 @@ class ExpressionParser extends LValParser {
   checkPipelineAtInfixOperator(left, leftStartPos) {
     if (this.getPluginOption("pipelineOperator", "proposal") === "smart") {
       if (left.type === "SequenceExpression") {
-        throw this.raise(leftStartPos, `Pipeline head should not be a comma-separated sequence expression`);
+        this.raise(leftStartPos, `Pipeline head should not be a comma-separated sequence expression`);
       }
     }
   }
@@ -9622,7 +10485,7 @@ class ExpressionParser extends LValParser {
     if (this.match(types.arrow)) {
       throw this.raise(this.state.start, `Unexpected arrow "=>" after pipeline body; arrow function in pipeline body must be parenthesized`);
     } else if (pipelineStyle === "PipelineTopicExpression" && childExpression.type === "SequenceExpression") {
-      throw this.raise(startPos, `Pipeline body may not be a comma-separated sequence expression`);
+      this.raise(startPos, `Pipeline body may not be a comma-separated sequence expression`);
     }
   }
 
@@ -9644,14 +10507,14 @@ class ExpressionParser extends LValParser {
 
       case "PipelineTopicExpression":
         if (!this.topicReferenceWasUsedInCurrentTopicContext()) {
-          throw this.raise(startPos, `Pipeline is in topic style but does not use topic reference`);
+          this.raise(startPos, `Pipeline is in topic style but does not use topic reference`);
         }
 
         bodyNode.expression = childExpression;
         break;
 
       default:
-        throw this.raise(startPos, `Unknown pipeline style ${pipelineStyle}`);
+        throw new Error(`Internal @babel/parser error: Unknown pipeline style (${pipelineStyle})`);
     }
 
     return this.finishNode(bodyNode, pipelineStyle);
@@ -9799,9 +10662,7 @@ class StatementParser extends ExpressionParser {
       return false;
     }
 
-    skipWhiteSpace.lastIndex = this.state.pos;
-    const skip = skipWhiteSpace.exec(this.input);
-    const next = this.state.pos + skip[0].length;
+    const next = this.nextTokenStart();
     const nextCh = this.input.charCodeAt(next);
     if (nextCh === 91) return true;
     if (context) return false;
@@ -9854,7 +10715,7 @@ class StatementParser extends ExpressionParser {
         return this.parseForStatement(node);
 
       case types._function:
-        if (this.lookahead().type === types.dot) break;
+        if (this.lookaheadCharCode() === 46) break;
 
         if (context) {
           if (this.state.strict) {
@@ -9890,7 +10751,7 @@ class StatementParser extends ExpressionParser {
         kind = kind || this.state.value;
 
         if (context && kind !== "var") {
-          this.unexpected(this.state.start, "Lexical declaration cannot appear in a single-statement context");
+          this.raise(this.state.start, "Lexical declaration cannot appear in a single-statement context");
         }
 
         return this.parseVarStatement(node, kind);
@@ -9910,9 +10771,9 @@ class StatementParser extends ExpressionParser {
       case types._export:
       case types._import:
         {
-          const nextToken = this.lookahead();
+          const nextTokenCharCode = this.lookaheadCharCode();
 
-          if (nextToken.type === types.parenL || nextToken.type === types.dot) {
+          if (nextTokenCharCode === 40 || nextTokenCharCode === 46) {
             break;
           }
 
@@ -9945,7 +10806,7 @@ class StatementParser extends ExpressionParser {
         {
           if (this.isAsyncFunction()) {
             if (context) {
-              this.unexpected(null, "Async functions can only be declared at the top level or inside a block");
+              this.raise(this.state.start, "Async functions can only be declared at the top level or inside a block");
             }
 
             this.next();
@@ -10003,7 +10864,7 @@ class StatementParser extends ExpressionParser {
         this.raise(this.state.start, "Using the export keyword between a decorator and a class is not allowed. " + "Please use `export @dec class` instead.");
       }
     } else if (!this.canHaveLeadingDecorator()) {
-      this.raise(this.state.start, "Leading decorators must be attached to a class declaration");
+      throw this.raise(this.state.start, "Leading decorators must be attached to a class declaration");
     }
   }
 
@@ -10116,7 +10977,7 @@ class StatementParser extends ExpressionParser {
     this.state.labels.push(loopLabel);
     let awaitAt = -1;
 
-    if ((this.scope.inAsync || !this.scope.inFunction && this.options.allowAwaitOutsideFunction) && this.eatContextual("await")) {
+    if (this.isAwaitAllowed() && this.eatContextual("await")) {
       awaitAt = this.state.lastTokStart;
     }
 
@@ -10499,7 +11360,7 @@ class StatementParser extends ExpressionParser {
 
   parseVarId(decl, kind) {
     decl.id = this.parseBindingAtom();
-    this.checkLVal(decl.id, kind === "var" ? BIND_VAR : BIND_LEXICAL, undefined, "variable declaration");
+    this.checkLVal(decl.id, kind === "var" ? BIND_VAR : BIND_LEXICAL, undefined, "variable declaration", kind !== "var");
   }
 
   parseFunction(node, statement = FUNC_NO_FLAGS, isAsync = false) {
@@ -10509,7 +11370,7 @@ class StatementParser extends ExpressionParser {
     this.initFunction(node, isAsync);
 
     if (this.match(types.star) && isHangingStatement) {
-      this.unexpected(this.state.start, "Generators can only be declared at the top level or inside a block");
+      this.raise(this.state.start, "Generators can only be declared at the top level or inside a block");
     }
 
     node.generator = this.eat(types.star);
@@ -10518,12 +11379,14 @@ class StatementParser extends ExpressionParser {
       node.id = this.parseFunctionId(requireId);
     }
 
+    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
     const oldInClassProperty = this.state.inClassProperty;
     const oldYieldPos = this.state.yieldPos;
     const oldAwaitPos = this.state.awaitPos;
+    this.state.maybeInArrowParameters = false;
     this.state.inClassProperty = false;
-    this.state.yieldPos = 0;
-    this.state.awaitPos = 0;
+    this.state.yieldPos = -1;
+    this.state.awaitPos = -1;
     this.scope.enter(functionFlags(node.async, node.generator));
 
     if (!isStatement) {
@@ -10537,9 +11400,10 @@ class StatementParser extends ExpressionParser {
     this.scope.exit();
 
     if (isStatement && !isHangingStatement) {
-      this.checkFunctionStatementId(node);
+      this.registerFunctionStatementId(node);
     }
 
+    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
     this.state.inClassProperty = oldInClassProperty;
     this.state.yieldPos = oldYieldPos;
     this.state.awaitPos = oldAwaitPos;
@@ -10554,14 +11418,14 @@ class StatementParser extends ExpressionParser {
     const oldInParameters = this.state.inParameters;
     this.state.inParameters = true;
     this.expect(types.parenL);
-    node.params = this.parseBindingList(types.parenR, false, allowModifiers);
+    node.params = this.parseBindingList(types.parenR, 41, false, allowModifiers);
     this.state.inParameters = oldInParameters;
     this.checkYieldAwaitInDefaultParams();
   }
 
-  checkFunctionStatementId(node) {
+  registerFunctionStatementId(node) {
     if (!node.id) return;
-    this.checkLVal(node.id, this.state.strict || node.generator || node.async ? this.scope.treatFunctionsAsVar ? BIND_VAR : BIND_LEXICAL : BIND_FUNCTION, null, "function name");
+    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);
   }
 
   parseClass(node, isStatement, optionalId) {
@@ -10601,7 +11465,7 @@ class StatementParser extends ExpressionParser {
       while (!this.eat(types.braceR)) {
         if (this.eat(types.semi)) {
           if (decorators.length > 0) {
-            this.raise(this.state.lastTokEnd, "Decorators must not be followed by a semicolon");
+            throw this.raise(this.state.lastTokEnd, "Decorators must not be followed by a semicolon");
           }
 
           continue;
@@ -10629,7 +11493,7 @@ class StatementParser extends ExpressionParser {
     });
 
     if (decorators.length) {
-      this.raise(this.state.start, "You have trailing decorators with no method");
+      throw this.raise(this.state.start, "You have trailing decorators with no method");
     }
 
     this.state.classLevel--;
@@ -10698,6 +11562,7 @@ class StatementParser extends ExpressionParser {
     const key = this.parseClassPropertyName(member);
     const isPrivate = key.type === "PrivateName";
     const isSimple = key.type === "Identifier";
+    const maybeQuestionTokenStart = this.state.start;
     this.parsePostMemberNameModifiers(publicMember);
 
     if (this.isClassMethod()) {
@@ -10714,10 +11579,6 @@ class StatementParser extends ExpressionParser {
       if (isConstructor) {
         publicMethod.kind = "constructor";
 
-        if (publicMethod.decorators) {
-          this.raise(publicMethod.start, "You can't attach decorators to a class constructor");
-        }
-
         if (state.hadConstructor && !this.hasPlugin("typescript")) {
           this.raise(key.start, "Duplicate constructor in the same class");
         }
@@ -10735,8 +11596,14 @@ class StatementParser extends ExpressionParser {
       }
     } else if (isSimple && key.name === "async" && !containsEsc && !this.isLineTerminator()) {
       const isGenerator = this.eat(types.star);
+
+      if (publicMember.optional) {
+        this.unexpected(maybeQuestionTokenStart);
+      }
+
       method.kind = "method";
       this.parseClassPropertyName(method);
+      this.parsePostMemberNameModifiers(publicMember);
 
       if (method.key.type === "PrivateName") {
         this.pushClassPrivateMethod(classBody, privateMethod, isGenerator, true);
@@ -10788,8 +11655,8 @@ class StatementParser extends ExpressionParser {
   }
 
   pushClassProperty(classBody, prop) {
-    if (this.isNonstaticConstructor(prop)) {
-      this.raise(prop.key.start, "Classes may not have a non-static field named 'constructor'");
+    if (!prop.computed && (prop.key.name === "constructor" || prop.key.value === "constructor")) {
+      this.raise(prop.key.start, "Classes may not have a field named 'constructor'");
     }
 
     classBody.body.push(this.parseClassProperty(prop));
@@ -10847,12 +11714,12 @@ class StatementParser extends ExpressionParser {
     return this.finishNode(node, "ClassProperty");
   }
 
-  parseClassId(node, isStatement, optionalId) {
+  parseClassId(node, isStatement, optionalId, bindingType = BIND_CLASS) {
     if (this.match(types.name)) {
       node.id = this.parseIdentifier();
 
       if (isStatement) {
-        this.checkLVal(node.id, BIND_CLASS, undefined, "class name");
+        this.checkLVal(node.id, bindingType, undefined, "class name");
       }
     } else {
       if (optionalId || !isStatement) {
@@ -10929,7 +11796,6 @@ class StatementParser extends ExpressionParser {
   maybeParseExportNamespaceSpecifier(node) {
     if (this.isContextual("as")) {
       if (!node.specifiers) node.specifiers = [];
-      this.expectPlugin("exportNamespaceFrom");
       const specifier = this.startNodeAt(this.state.lastTokStart, this.state.lastTokStartLoc);
       this.next();
       specifier.exported = this.parseIdentifier(true);
@@ -10955,10 +11821,10 @@ class StatementParser extends ExpressionParser {
   maybeParseExportDeclaration(node) {
     if (this.shouldParseExportDeclaration()) {
       if (this.isContextual("async")) {
-        const next = this.lookahead();
+        const next = this.nextTokenStart();
 
-        if (next.type !== types._function) {
-          this.unexpected(next.start, `Unexpected token, expected "function"`);
+        if (!this.isUnparsedContextual(next, "function")) {
+          this.unexpected(next, `Unexpected token, expected "function"`);
         }
       }
 
@@ -10973,14 +11839,8 @@ class StatementParser extends ExpressionParser {
 
   isAsyncFunction() {
     if (!this.isContextual("async")) return false;
-    const {
-      pos
-    } = this.state;
-    skipWhiteSpace.lastIndex = pos;
-    const skip = skipWhiteSpace.exec(this.input);
-    if (!skip || !skip.length) return false;
-    const next = pos + skip[0].length;
-    return !lineBreak.test(this.input.slice(pos, next)) && this.input.slice(next, next + 8) === "function" && (next + 8 === this.length || !isIdentifierChar(this.input.charCodeAt(next + 8)));
+    const next = this.nextTokenStart();
+    return !lineBreak.test(this.input.slice(this.state.pos, next)) && this.isUnparsedContextual(next, "function");
   }
 
   parseExportDefaultExpression() {
@@ -10999,13 +11859,13 @@ class StatementParser extends ExpressionParser {
       return this.parseClass(expr, true, true);
     } else if (this.match(types.at)) {
       if (this.hasPlugin("decorators") && this.getPluginOption("decorators", "decoratorsBeforeExport")) {
-        this.unexpected(this.state.start, "Decorators must be placed *before* the 'export' keyword." + " You can set the 'decoratorsBeforeExport' option to false to use" + " the 'export @decorator class {}' syntax");
+        this.raise(this.state.start, "Decorators must be placed *before* the 'export' keyword." + " You can set the 'decoratorsBeforeExport' option to false to use" + " the 'export @decorator class {}' syntax");
       }
 
       this.parseDecorators(false);
       return this.parseClass(expr, true, true);
     } else if (this.match(types._const) || this.match(types._var) || this.isLet()) {
-      return this.raise(this.state.start, "Only expressions, functions or classes are allowed as the `default` export.");
+      throw this.raise(this.state.start, "Only expressions, functions or classes are allowed as the `default` export.");
     } else {
       const res = this.parseMaybeAssign();
       this.semicolon();
@@ -11026,8 +11886,8 @@ class StatementParser extends ExpressionParser {
       return false;
     }
 
-    const lookahead = this.lookahead();
-    return lookahead.type === types.comma || lookahead.type === types.name && lookahead.value === "from";
+    const next = this.nextTokenStart();
+    return this.input.charCodeAt(next) === 44 || this.isUnparsedContextual(next, "from");
   }
 
   parseExportFrom(node, expect) {
@@ -11129,7 +11989,7 @@ class StatementParser extends ExpressionParser {
 
   checkDuplicateExports(node, name) {
     if (this.state.exportedIdentifiers.indexOf(name) > -1) {
-      throw this.raise(node.start, name === "default" ? "Only one default export allowed per module." : `\`${name}\` has already been exported. Exported identifiers must be unique.`);
+      this.raise(node.start, name === "default" ? "Only one default export allowed per module." : `\`${name}\` has already been exported. Exported identifiers must be unique.`);
     }
 
     this.state.exportedIdentifiers.push(name);
@@ -11218,7 +12078,7 @@ class StatementParser extends ExpressionParser {
         first = false;
       } else {
         if (this.eat(types.colon)) {
-          this.unexpected(null, "ES2015 named imports do not destructure. " + "Use another statement for destructuring after the import.");
+          throw this.raise(this.state.start, "ES2015 named imports do not destructure. " + "Use another statement for destructuring after the import.");
         }
 
         this.expect(types.comma);
@@ -11267,7 +12127,10 @@ class Parser extends StatementParser {
     const file = this.startNode();
     const program = this.startNode();
     this.nextToken();
-    return this.parseTopLevel(file, program);
+    file.errors = null;
+    this.parseTopLevel(file, program);
+    file.errors = this.state.errors;
+    return file;
   }
 
 }
@@ -11292,13 +12155,26 @@ function parse(input, options) {
       options.sourceType = "module";
       const parser = getParser(options, input);
       const ast = parser.parse();
-      if (!parser.sawUnambiguousESM) ast.program.sourceType = "script";
+
+      if (parser.sawUnambiguousESM) {
+        return ast;
+      }
+
+      if (parser.ambiguousScriptDifferentAst) {
+        try {
+          options.sourceType = "script";
+          return getParser(options, input).parse();
+        } catch (_unused) {}
+      } else {
+        ast.program.sourceType = "script";
+      }
+
       return ast;
     } catch (moduleError) {
       try {
         options.sourceType = "script";
         return getParser(options, input).parse();
-      } catch (scriptError) {}
+      } catch (_unused2) {}
 
       throw moduleError;
     }
@@ -11351,3 +12227,4 @@ function getParserClass(pluginsFromOptions) {
 exports.parse = parse;
 exports.parseExpression = parseExpression;
 exports.tokTypes = types;
+//# sourceMappingURL=index.js.map