@tinacms/app 1.1.0 → 1.1.1

package/appFiles/node_modules/@babel/parser/lib/index.js

@@ -128,9 +128,10 @@ var StandardErrors = {
     kind
   }) => `Missing initializer in ${kind} declaration.`,
   DecoratorArgumentsOutsideParentheses: "Decorator arguments must be moved inside parentheses: use '@(decorator(args))' instead of '@(decorator)(args)'.",
-  DecoratorBeforeExport: "Decorators must be placed *before* the 'export' keyword. You can set the 'decoratorsBeforeExport' option to false to use the 'export @decorator class {}' syntax.",
+  DecoratorBeforeExport: "Decorators must be placed *before* the 'export' keyword. Remove the 'decoratorsBeforeExport: true' option to use the 'export @decorator class {}' syntax.",
+  DecoratorsBeforeAfterExport: "Decorators can be placed *either* before or after the 'export' keyword, but not in both locations at the same time.",
   DecoratorConstructor: "Decorators can't be used with a constructor. Did you mean '@dec class { ... }'?",
-  DecoratorExportClass: "Using the export keyword between a decorator and a class is not allowed. Please use `export @dec class` instead.",
+  DecoratorExportClass: "Decorators must be placed *after* the 'export' keyword. Remove the 'decoratorsBeforeExport: false' option to use the '@decorator export class {}' syntax.",
   DecoratorSemicolon: "Decorators must not be followed by a semicolon.",
   DecoratorStaticBlock: "Decorators can't be used with a static block.",
   DeletePrivateField: "Deleting a private field is not allowed.",
@@ -258,7 +259,8 @@ var StandardErrors = {
   RecordExpressionHashIncorrectStartSyntaxType: "Record expressions starting with '#{' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'hash'.",
   RecordNoProto: "'__proto__' is not allowed in Record expressions.",
   RestTrailingComma: "Unexpected trailing comma after rest element.",
-  SloppyFunction: "In non-strict mode code, functions can only be declared at top level, inside a block, or as the body of an if statement.",
+  SloppyFunction: "In non-strict mode code, functions can only be declared at top level or inside a block.",
+  SloppyFunctionAnnexB: "In non-strict mode code, functions can only be declared at top level, inside a block, or as the body of an if statement.",
   StaticPrototype: "Classes may not have static property named prototype.",
   SuperNotAllowed: "`super()` is only valid inside a class constructor of a subclass. Maybe a typo in the method name ('constructor') or not extending another class?",
   SuperPrivateField: "Private fields can't be accessed on super.",
@@ -735,9 +737,6 @@ var estree = (superClass => class ESTreeParserMixin extends superClass {
     }
     return super.hasPropertyAsPrivateName(node);
   }
-  isOptionalChain(node) {
-    return node.type === "ChainExpression";
-  }
   isObjectProperty(node) {
     return node.type === "Property" && node.kind === "init" && !node.method;
   }
@@ -2475,7 +2474,7 @@ class Tokenizer extends CommentsParser {
         default:
           if (isWhitespace(ch)) {
             ++this.state.pos;
-          } else if (ch === 45 && !this.inModule) {
+          } else if (ch === 45 && !this.inModule && this.options.annexB) {
             const pos = this.state.pos;
             if (this.input.charCodeAt(pos + 1) === 45 && this.input.charCodeAt(pos + 2) === 62 && (spaceStart === 0 || this.state.lineStart > spaceStart)) {
               const comment = this.skipLineComment(3);
@@ -2486,7 +2485,7 @@ class Tokenizer extends CommentsParser {
             } else {
               break loop;
             }
-          } else if (ch === 60 && !this.inModule) {
+          } else if (ch === 60 && !this.inModule && this.options.annexB) {
             const pos = this.state.pos;
             if (this.input.charCodeAt(pos + 1) === 33 && this.input.charCodeAt(pos + 2) === 45 && this.input.charCodeAt(pos + 3) === 45) {
               const comment = this.skipLineComment(4);
@@ -3724,9 +3723,6 @@ class UtilParser extends Tokenizer {
   hasPropertyAsPrivateName(node) {
     return (node.type === "MemberExpression" || node.type === "OptionalMemberExpression") && this.isPrivateName(node.property);
   }
-  isOptionalChain(node) {
-    return node.type === "OptionalMemberExpression" || node.type === "OptionalCallExpression";
-  }
   isObjectProperty(node) {
     return node.type === "ObjectProperty";
   }
@@ -5730,12 +5726,12 @@ var flow = (superClass => class FlowParserMixin extends superClass {
         return super.parseBindingAtom();
     }
   }
-  parseFunctionParams(node, allowModifiers) {
+  parseFunctionParams(node, isConstructor) {
     const kind = node.kind;
     if (kind !== "get" && kind !== "set" && this.match(47)) {
       node.typeParameters = this.flowParseTypeParameterDeclaration();
     }
-    super.parseFunctionParams(node, allowModifiers);
+    super.parseFunctionParams(node, isConstructor);
   }
   parseVarId(decl, kind) {
     super.parseVarId(decl, kind);
@@ -5932,7 +5928,7 @@ var flow = (superClass => class FlowParserMixin extends superClass {
   }
   parseAsyncArrowWithTypeParameters(startLoc) {
     const node = this.startNodeAt(startLoc);
-    this.parseFunctionParams(node);
+    this.parseFunctionParams(node, false);
     if (!this.parseArrow(node)) return;
     return super.parseArrowExpression(node, undefined, true);
   }
@@ -7157,491 +7153,898 @@ class TypeScriptScopeHandler extends ScopeHandler {
 }
 
 const getOwn$1 = (object, key) => Object.hasOwnProperty.call(object, key) && object[key];
-function nonNull(x) {
-  if (x == null) {
-    throw new Error(`Unexpected ${x} value.`);
-  }
-  return x;
-}
-function assert(x) {
-  if (!x) {
-    throw new Error("Assert fail");
-  }
-}
-const TSErrors = ParseErrorEnum`typescript`({
-  AbstractMethodHasImplementation: ({
-    methodName
-  }) => `Method '${methodName}' cannot have an implementation because it is marked abstract.`,
-  AbstractPropertyHasInitializer: ({
-    propertyName
-  }) => `Property '${propertyName}' cannot have an initializer because it is marked abstract.`,
-  AccesorCannotDeclareThisParameter: "'get' and 'set' accessors cannot declare 'this' parameters.",
-  AccesorCannotHaveTypeParameters: "An accessor cannot have type parameters.",
-  AccessorCannotBeOptional: "An 'accessor' property cannot be declared optional.",
-  ClassMethodHasDeclare: "Class methods cannot have the 'declare' modifier.",
-  ClassMethodHasReadonly: "Class methods cannot have the 'readonly' modifier.",
-  ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference: "A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference.",
-  ConstructorHasTypeParameters: "Type parameters cannot appear on a constructor declaration.",
-  DeclareAccessor: ({
-    kind
-  }) => `'declare' is not allowed in ${kind}ters.`,
-  DeclareClassFieldHasInitializer: "Initializers are not allowed in ambient contexts.",
-  DeclareFunctionHasImplementation: "An implementation cannot be declared in ambient contexts.",
-  DuplicateAccessibilityModifier: ({
-    modifier
-  }) => `Accessibility modifier already seen.`,
-  DuplicateModifier: ({
-    modifier
-  }) => `Duplicate modifier: '${modifier}'.`,
-  EmptyHeritageClauseType: ({
-    token
-  }) => `'${token}' list cannot be empty.`,
-  EmptyTypeArguments: "Type argument list cannot be empty.",
-  EmptyTypeParameters: "Type parameter list cannot be empty.",
-  ExpectedAmbientAfterExportDeclare: "'export declare' must be followed by an ambient declaration.",
-  ImportAliasHasImportType: "An import alias can not use 'import type'.",
-  ImportReflectionHasImportType: "An `import module` declaration can not use `type` modifier",
-  IncompatibleModifiers: ({
-    modifiers
-  }) => `'${modifiers[0]}' modifier cannot be used with '${modifiers[1]}' modifier.`,
-  IndexSignatureHasAbstract: "Index signatures cannot have the 'abstract' modifier.",
-  IndexSignatureHasAccessibility: ({
-    modifier
-  }) => `Index signatures cannot have an accessibility modifier ('${modifier}').`,
-  IndexSignatureHasDeclare: "Index signatures cannot have the 'declare' modifier.",
-  IndexSignatureHasOverride: "'override' modifier cannot appear on an index signature.",
-  IndexSignatureHasStatic: "Index signatures cannot have the 'static' modifier.",
-  InitializerNotAllowedInAmbientContext: "Initializers are not allowed in ambient contexts.",
-  InvalidModifierOnTypeMember: ({
-    modifier
-  }) => `'${modifier}' modifier cannot appear on a type member.`,
-  InvalidModifierOnTypeParameter: ({
-    modifier
-  }) => `'${modifier}' modifier cannot appear on a type parameter.`,
-  InvalidModifierOnTypeParameterPositions: ({
-    modifier
-  }) => `'${modifier}' modifier can only appear on a type parameter of a class, interface or type alias.`,
-  InvalidModifiersOrder: ({
-    orderedModifiers
-  }) => `'${orderedModifiers[0]}' modifier must precede '${orderedModifiers[1]}' modifier.`,
-  InvalidPropertyAccessAfterInstantiationExpression: "Invalid property access after an instantiation expression. " + "You can either wrap the instantiation expression in parentheses, or delete the type arguments.",
-  InvalidTupleMemberLabel: "Tuple members must be labeled with a simple identifier.",
-  MissingInterfaceName: "'interface' declarations must be followed by an identifier.",
-  MixedLabeledAndUnlabeledElements: "Tuple members must all have names or all not have names.",
-  NonAbstractClassHasAbstractMethod: "Abstract methods can only appear within an abstract class.",
-  NonClassMethodPropertyHasAbstractModifer: "'abstract' modifier can only appear on a class, method, or property declaration.",
-  OptionalTypeBeforeRequired: "A required element cannot follow an optional element.",
-  OverrideNotInSubClass: "This member cannot have an 'override' modifier because its containing class does not extend another class.",
-  PatternIsOptional: "A binding pattern parameter cannot be optional in an implementation signature.",
-  PrivateElementHasAbstract: "Private elements cannot have the 'abstract' modifier.",
-  PrivateElementHasAccessibility: ({
-    modifier
-  }) => `Private elements cannot have an accessibility modifier ('${modifier}').`,
-  ReadonlyForMethodSignature: "'readonly' modifier can only appear on a property declaration or index signature.",
-  ReservedArrowTypeParam: "This syntax is reserved in files with the .mts or .cts extension. Add a trailing comma, as in `<T,>() => ...`.",
-  ReservedTypeAssertion: "This syntax is reserved in files with the .mts or .cts extension. Use an `as` expression instead.",
-  SetAccesorCannotHaveOptionalParameter: "A 'set' accessor cannot have an optional parameter.",
-  SetAccesorCannotHaveRestParameter: "A 'set' accessor cannot have rest parameter.",
-  SetAccesorCannotHaveReturnType: "A 'set' accessor cannot have a return type annotation.",
-  SingleTypeParameterWithoutTrailingComma: ({
-    typeParameterName
-  }) => `Single type parameter ${typeParameterName} should have a trailing comma. Example usage: <${typeParameterName},>.`,
-  StaticBlockCannotHaveModifier: "Static class blocks cannot have any modifier.",
-  TypeAnnotationAfterAssign: "Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.",
-  TypeImportCannotSpecifyDefaultAndNamed: "A type-only import can specify a default import or named bindings, but not both.",
-  TypeModifierIsUsedInTypeExports: "The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement.",
-  TypeModifierIsUsedInTypeImports: "The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement.",
-  UnexpectedParameterModifier: "A parameter property is only allowed in a constructor implementation.",
-  UnexpectedReadonly: "'readonly' type modifier is only permitted on array and tuple literal types.",
-  UnexpectedTypeAnnotation: "Did not expect a type annotation here.",
-  UnexpectedTypeCastInParameter: "Unexpected type cast in parameter position.",
-  UnsupportedImportTypeArgument: "Argument in a type import must be a string literal.",
-  UnsupportedParameterPropertyKind: "A parameter property may not be declared using a binding pattern.",
-  UnsupportedSignatureParameterKind: ({
-    type
-  }) => `Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got ${type}.`
-});
-function keywordTypeFromName(value) {
-  switch (value) {
-    case "any":
-      return "TSAnyKeyword";
-    case "boolean":
-      return "TSBooleanKeyword";
-    case "bigint":
-      return "TSBigIntKeyword";
-    case "never":
-      return "TSNeverKeyword";
-    case "number":
-      return "TSNumberKeyword";
-    case "object":
-      return "TSObjectKeyword";
-    case "string":
-      return "TSStringKeyword";
-    case "symbol":
-      return "TSSymbolKeyword";
-    case "undefined":
-      return "TSUndefinedKeyword";
-    case "unknown":
-      return "TSUnknownKeyword";
-    default:
-      return undefined;
-  }
-}
-function tsIsAccessModifier(modifier) {
-  return modifier === "private" || modifier === "public" || modifier === "protected";
-}
-function tsIsVarianceAnnotations(modifier) {
-  return modifier === "in" || modifier === "out";
-}
-var typescript = (superClass => class TypeScriptParserMixin extends superClass {
-  getScopeHandler() {
-    return TypeScriptScopeHandler;
-  }
-  tsIsIdentifier() {
-    return tokenIsIdentifier(this.state.type);
-  }
-  tsTokenCanFollowModifier() {
-    return (this.match(0) || this.match(5) || this.match(55) || this.match(21) || this.match(136) || this.isLiteralPropertyName()) && !this.hasPrecedingLineBreak();
-  }
-  tsNextTokenCanFollowModifier() {
-    this.next();
-    return this.tsTokenCanFollowModifier();
-  }
-  tsParseModifier(allowedModifiers, stopOnStartOfClassStaticBlock) {
-    if (!tokenIsIdentifier(this.state.type) && this.state.type !== 58) {
-      return undefined;
-    }
-    const modifier = this.state.value;
-    if (allowedModifiers.indexOf(modifier) !== -1) {
-      if (stopOnStartOfClassStaticBlock && this.tsIsStartOfStaticBlocks()) {
-        return undefined;
-      }
-      if (this.tsTryParse(this.tsNextTokenCanFollowModifier.bind(this))) {
-        return modifier;
-      }
-    }
-    return undefined;
-  }
-  tsParseModifiers({
-    modified,
-    allowedModifiers,
-    disallowedModifiers,
-    stopOnStartOfClassStaticBlock,
-    errorTemplate = TSErrors.InvalidModifierOnTypeMember
-  }) {
-    const enforceOrder = (loc, modifier, before, after) => {
-      if (modifier === before && modified[after]) {
-        this.raise(TSErrors.InvalidModifiersOrder, {
-          at: loc,
-          orderedModifiers: [before, after]
-        });
-      }
-    };
-    const incompatible = (loc, modifier, mod1, mod2) => {
-      if (modified[mod1] && modifier === mod2 || modified[mod2] && modifier === mod1) {
-        this.raise(TSErrors.IncompatibleModifiers, {
-          at: loc,
-          modifiers: [mod1, mod2]
-        });
-      }
-    };
-    for (;;) {
-      const {
-        startLoc
-      } = this.state;
-      const modifier = this.tsParseModifier(allowedModifiers.concat(disallowedModifiers != null ? disallowedModifiers : []), stopOnStartOfClassStaticBlock);
-      if (!modifier) break;
-      if (tsIsAccessModifier(modifier)) {
-        if (modified.accessibility) {
-          this.raise(TSErrors.DuplicateAccessibilityModifier, {
-            at: startLoc,
-            modifier
+const unwrapParenthesizedExpression = node => {
+  return node.type === "ParenthesizedExpression" ? unwrapParenthesizedExpression(node.expression) : node;
+};
+var ParseBindingListFlags = {
+  ALLOW_EMPTY: 1,
+  IS_FUNCTION_PARAMS: 2,
+  IS_CONSTRUCTOR_PARAMS: 4
+};
+class LValParser extends NodeUtils {
+  toAssignable(node, isLHS = false) {
+    var _node$extra, _node$extra3;
+    let parenthesized = undefined;
+    if (node.type === "ParenthesizedExpression" || (_node$extra = node.extra) != null && _node$extra.parenthesized) {
+      parenthesized = unwrapParenthesizedExpression(node);
+      if (isLHS) {
+        if (parenthesized.type === "Identifier") {
+          this.expressionScope.recordArrowParameterBindingError(Errors.InvalidParenthesizedAssignment, {
+            at: node
           });
-        } else {
-          enforceOrder(startLoc, modifier, modifier, "override");
-          enforceOrder(startLoc, modifier, modifier, "static");
-          enforceOrder(startLoc, modifier, modifier, "readonly");
-          modified.accessibility = modifier;
-        }
-      } else if (tsIsVarianceAnnotations(modifier)) {
-        if (modified[modifier]) {
-          this.raise(TSErrors.DuplicateModifier, {
-            at: startLoc,
-            modifier
+        } else if (parenthesized.type !== "MemberExpression") {
+          this.raise(Errors.InvalidParenthesizedAssignment, {
+            at: node
           });
         }
-        modified[modifier] = true;
-        enforceOrder(startLoc, modifier, "in", "out");
       } else {
-        if (Object.hasOwnProperty.call(modified, modifier)) {
-          this.raise(TSErrors.DuplicateModifier, {
-            at: startLoc,
-            modifier
-          });
-        } else {
-          enforceOrder(startLoc, modifier, "static", "readonly");
-          enforceOrder(startLoc, modifier, "static", "override");
-          enforceOrder(startLoc, modifier, "override", "readonly");
-          enforceOrder(startLoc, modifier, "abstract", "override");
-          incompatible(startLoc, modifier, "declare", "override");
-          incompatible(startLoc, modifier, "static", "abstract");
-        }
-        modified[modifier] = true;
-      }
-      if (disallowedModifiers != null && disallowedModifiers.includes(modifier)) {
-        this.raise(errorTemplate, {
-          at: startLoc,
-          modifier
+        this.raise(Errors.InvalidParenthesizedAssignment, {
+          at: node
         });
       }
     }
-  }
-  tsIsListTerminator(kind) {
-    switch (kind) {
-      case "EnumMembers":
-      case "TypeMembers":
-        return this.match(8);
-      case "HeritageClauseElement":
-        return this.match(5);
-      case "TupleElementTypes":
-        return this.match(3);
-      case "TypeParametersOrArguments":
-        return this.match(48);
-    }
-    throw new Error("Unreachable");
-  }
-  tsParseList(kind, parseElement) {
-    const result = [];
-    while (!this.tsIsListTerminator(kind)) {
-      result.push(parseElement());
-    }
-    return result;
-  }
-  tsParseDelimitedList(kind, parseElement, refTrailingCommaPos) {
-    return nonNull(this.tsParseDelimitedListWorker(kind, parseElement, true, refTrailingCommaPos));
-  }
-  tsParseDelimitedListWorker(kind, parseElement, expectSuccess, refTrailingCommaPos) {
-    const result = [];
-    let trailingCommaPos = -1;
-    for (;;) {
-      if (this.tsIsListTerminator(kind)) {
+    switch (node.type) {
+      case "Identifier":
+      case "ObjectPattern":
+      case "ArrayPattern":
+      case "AssignmentPattern":
+      case "RestElement":
         break;
-      }
-      trailingCommaPos = -1;
-      const element = parseElement();
-      if (element == null) {
-        return undefined;
-      }
-      result.push(element);
-      if (this.eat(12)) {
-        trailingCommaPos = this.state.lastTokStart;
-        continue;
-      }
-      if (this.tsIsListTerminator(kind)) {
+      case "ObjectExpression":
+        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, isLast, isLHS);
+          if (isLast && prop.type === "RestElement" && (_node$extra2 = node.extra) != null && _node$extra2.trailingCommaLoc) {
+            this.raise(Errors.RestTrailingComma, {
+              at: node.extra.trailingCommaLoc
+            });
+          }
+        }
+        break;
+      case "ObjectProperty":
+        {
+          const {
+            key,
+            value
+          } = node;
+          if (this.isPrivateName(key)) {
+            this.classScope.usePrivateName(this.getPrivateNameSV(key), key.loc.start);
+          }
+          this.toAssignable(value, isLHS);
+          break;
+        }
+      case "SpreadElement":
+        {
+          throw new Error("Internal @babel/parser error (this is a bug, please report it)." + " SpreadElement should be converted by .toAssignable's caller.");
+        }
+      case "ArrayExpression":
+        node.type = "ArrayPattern";
+        this.toAssignableList(node.elements, (_node$extra3 = node.extra) == null ? void 0 : _node$extra3.trailingCommaLoc, isLHS);
+        break;
+      case "AssignmentExpression":
+        if (node.operator !== "=") {
+          this.raise(Errors.MissingEqInAssignment, {
+            at: node.left.loc.end
+          });
+        }
+        node.type = "AssignmentPattern";
+        delete node.operator;
+        this.toAssignable(node.left, isLHS);
+        break;
+      case "ParenthesizedExpression":
+        this.toAssignable(parenthesized, isLHS);
         break;
-      }
-      if (expectSuccess) {
-        this.expect(12);
-      }
-      return undefined;
-    }
-    if (refTrailingCommaPos) {
-      refTrailingCommaPos.value = trailingCommaPos;
     }
-    return result;
   }
-  tsParseBracketedList(kind, parseElement, bracket, skipFirstToken, refTrailingCommaPos) {
-    if (!skipFirstToken) {
-      if (bracket) {
-        this.expect(0);
-      } else {
-        this.expect(47);
+  toAssignableObjectExpressionProp(prop, isLast, isLHS) {
+    if (prop.type === "ObjectMethod") {
+      this.raise(prop.kind === "get" || prop.kind === "set" ? Errors.PatternHasAccessor : Errors.PatternHasMethod, {
+        at: prop.key
+      });
+    } else if (prop.type === "SpreadElement") {
+      prop.type = "RestElement";
+      const arg = prop.argument;
+      this.checkToRestConversion(arg, false);
+      this.toAssignable(arg, isLHS);
+      if (!isLast) {
+        this.raise(Errors.RestTrailingComma, {
+          at: prop
+        });
       }
-    }
-    const result = this.tsParseDelimitedList(kind, parseElement, refTrailingCommaPos);
-    if (bracket) {
-      this.expect(3);
     } else {
-      this.expect(48);
+      this.toAssignable(prop, isLHS);
     }
-    return result;
   }
-  tsParseImportType() {
-    const node = this.startNode();
-    this.expect(83);
-    this.expect(10);
-    if (!this.match(131)) {
-      this.raise(TSErrors.UnsupportedImportTypeArgument, {
-        at: this.state.startLoc
-      });
-    }
-    node.argument = super.parseExprAtom();
-    this.expect(11);
-    if (this.eat(16)) {
-      node.qualifier = this.tsParseEntityName();
-    }
-    if (this.match(47)) {
-      node.typeParameters = this.tsParseTypeArguments();
+  toAssignableList(exprList, trailingCommaLoc, isLHS) {
+    const end = exprList.length - 1;
+    for (let i = 0; i <= end; i++) {
+      const elt = exprList[i];
+      if (!elt) continue;
+      if (elt.type === "SpreadElement") {
+        elt.type = "RestElement";
+        const arg = elt.argument;
+        this.checkToRestConversion(arg, true);
+        this.toAssignable(arg, isLHS);
+      } else {
+        this.toAssignable(elt, isLHS);
+      }
+      if (elt.type === "RestElement") {
+        if (i < end) {
+          this.raise(Errors.RestTrailingComma, {
+            at: elt
+          });
+        } else if (trailingCommaLoc) {
+          this.raise(Errors.RestTrailingComma, {
+            at: trailingCommaLoc
+          });
+        }
+      }
     }
-    return this.finishNode(node, "TSImportType");
   }
-  tsParseEntityName(allowReservedWords = true) {
-    let entity = this.parseIdentifier(allowReservedWords);
-    while (this.eat(16)) {
-      const node = this.startNodeAtNode(entity);
-      node.left = entity;
-      node.right = this.parseIdentifier(allowReservedWords);
-      entity = this.finishNode(node, "TSQualifiedName");
+  isAssignable(node, isBinding) {
+    switch (node.type) {
+      case "Identifier":
+      case "ObjectPattern":
+      case "ArrayPattern":
+      case "AssignmentPattern":
+      case "RestElement":
+        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 => element === null || this.isAssignable(element));
+      case "AssignmentExpression":
+        return node.operator === "=";
+      case "ParenthesizedExpression":
+        return this.isAssignable(node.expression);
+      case "MemberExpression":
+      case "OptionalMemberExpression":
+        return !isBinding;
+      default:
+        return false;
     }
-    return entity;
   }
-  tsParseTypeReference() {
-    const node = this.startNode();
-    node.typeName = this.tsParseEntityName();
-    if (!this.hasPrecedingLineBreak() && this.match(47)) {
-      node.typeParameters = this.tsParseTypeArguments();
+  toReferencedList(exprList, isParenthesizedExpr) {
+    return exprList;
+  }
+  toReferencedListDeep(exprList, isParenthesizedExpr) {
+    this.toReferencedList(exprList, isParenthesizedExpr);
+    for (const expr of exprList) {
+      if ((expr == null ? void 0 : expr.type) === "ArrayExpression") {
+        this.toReferencedListDeep(expr.elements);
+      }
     }
-    return this.finishNode(node, "TSTypeReference");
   }
-  tsParseThisTypePredicate(lhs) {
+  parseSpread(refExpressionErrors) {
+    const node = this.startNode();
     this.next();
-    const node = this.startNodeAtNode(lhs);
-    node.parameterName = lhs;
-    node.typeAnnotation = this.tsParseTypeAnnotation(false);
-    node.asserts = false;
-    return this.finishNode(node, "TSTypePredicate");
+    node.argument = this.parseMaybeAssignAllowIn(refExpressionErrors, undefined);
+    return this.finishNode(node, "SpreadElement");
   }
-  tsParseThisTypeNode() {
+  parseRestBinding() {
     const node = this.startNode();
     this.next();
-    return this.finishNode(node, "TSThisType");
+    node.argument = this.parseBindingAtom();
+    return this.finishNode(node, "RestElement");
   }
-  tsParseTypeQuery() {
-    const node = this.startNode();
-    this.expect(87);
-    if (this.match(83)) {
-      node.exprName = this.tsParseImportType();
-    } else {
-      node.exprName = this.tsParseEntityName();
-    }
-    if (!this.hasPrecedingLineBreak() && this.match(47)) {
-      node.typeParameters = this.tsParseTypeArguments();
+  parseBindingAtom() {
+    switch (this.state.type) {
+      case 0:
+        {
+          const node = this.startNode();
+          this.next();
+          node.elements = this.parseBindingList(3, 93, ParseBindingListFlags.ALLOW_EMPTY);
+          return this.finishNode(node, "ArrayPattern");
+        }
+      case 5:
+        return this.parseObjectLike(8, true);
     }
-    return this.finishNode(node, "TSTypeQuery");
+    return this.parseIdentifier();
   }
-  tsParseInOutModifiers(node) {
-    this.tsParseModifiers({
-      modified: node,
-      allowedModifiers: ["in", "out"],
-      disallowedModifiers: ["public", "private", "protected", "readonly", "declare", "abstract", "override"],
-      errorTemplate: TSErrors.InvalidModifierOnTypeParameter
-    });
+  parseBindingList(close, closeCharCode, flags) {
+    const allowEmpty = flags & ParseBindingListFlags.ALLOW_EMPTY;
+    const elts = [];
+    let first = true;
+    while (!this.eat(close)) {
+      if (first) {
+        first = false;
+      } else {
+        this.expect(12);
+      }
+      if (allowEmpty && this.match(12)) {
+        elts.push(null);
+      } else if (this.eat(close)) {
+        break;
+      } else if (this.match(21)) {
+        elts.push(this.parseAssignableListItemTypes(this.parseRestBinding(), flags));
+        if (!this.checkCommaAfterRest(closeCharCode)) {
+          this.expect(close);
+          break;
+        }
+      } else {
+        const decorators = [];
+        if (this.match(26) && this.hasPlugin("decorators")) {
+          this.raise(Errors.UnsupportedParameterDecorator, {
+            at: this.state.startLoc
+          });
+        }
+        while (this.match(26)) {
+          decorators.push(this.parseDecorator());
+        }
+        elts.push(this.parseAssignableListItem(flags, decorators));
+      }
+    }
+    return elts;
   }
-  tsParseNoneModifiers(node) {
-    this.tsParseModifiers({
-      modified: node,
-      allowedModifiers: [],
-      disallowedModifiers: ["in", "out"],
-      errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions
-    });
+  parseBindingRestProperty(prop) {
+    this.next();
+    prop.argument = this.parseIdentifier();
+    this.checkCommaAfterRest(125);
+    return this.finishNode(prop, "RestElement");
   }
-  tsParseTypeParameter(parseModifiers = this.tsParseNoneModifiers.bind(this)) {
-    const node = this.startNode();
-    parseModifiers(node);
-    node.name = this.tsParseTypeParameterName();
-    node.constraint = this.tsEatThenParseType(81);
-    node.default = this.tsEatThenParseType(29);
-    return this.finishNode(node, "TSTypeParameter");
+  parseBindingProperty() {
+    const prop = this.startNode();
+    const {
+      type,
+      startLoc
+    } = this.state;
+    if (type === 21) {
+      return this.parseBindingRestProperty(prop);
+    } else if (type === 136) {
+      this.expectPlugin("destructuringPrivate", startLoc);
+      this.classScope.usePrivateName(this.state.value, startLoc);
+      prop.key = this.parsePrivateName();
+    } else {
+      this.parsePropertyName(prop);
+    }
+    prop.method = false;
+    return this.parseObjPropValue(prop, startLoc, false, false, true, false);
   }
-  tsTryParseTypeParameters(parseModifiers) {
-    if (this.match(47)) {
-      return this.tsParseTypeParameters(parseModifiers);
+  parseAssignableListItem(flags, decorators) {
+    const left = this.parseMaybeDefault();
+    this.parseAssignableListItemTypes(left, flags);
+    const elt = this.parseMaybeDefault(left.loc.start, left);
+    if (decorators.length) {
+      left.decorators = decorators;
     }
+    return elt;
   }
-  tsParseTypeParameters(parseModifiers) {
-    const node = this.startNode();
-    if (this.match(47) || this.match(140)) {
-      this.next();
-    } else {
-      this.unexpected();
+  parseAssignableListItemTypes(param, flags) {
+    return param;
+  }
+  parseMaybeDefault(startLoc, left) {
+    var _startLoc, _left;
+    (_startLoc = startLoc) != null ? _startLoc : startLoc = this.state.startLoc;
+    left = (_left = left) != null ? _left : this.parseBindingAtom();
+    if (!this.eat(29)) return left;
+    const node = this.startNodeAt(startLoc);
+    node.left = left;
+    node.right = this.parseMaybeAssignAllowIn();
+    return this.finishNode(node, "AssignmentPattern");
+  }
+  isValidLVal(type, isUnparenthesizedInAssign, binding) {
+    return getOwn$1({
+      AssignmentPattern: "left",
+      RestElement: "argument",
+      ObjectProperty: "value",
+      ParenthesizedExpression: "expression",
+      ArrayPattern: "elements",
+      ObjectPattern: "properties"
+    }, type);
+  }
+  checkLVal(expression, {
+    in: ancestor,
+    binding = BIND_NONE,
+    checkClashes = false,
+    strictModeChanged = false,
+    hasParenthesizedAncestor = false
+  }) {
+    var _expression$extra;
+    const type = expression.type;
+    if (this.isObjectMethod(expression)) return;
+    if (type === "MemberExpression") {
+      if (binding !== BIND_NONE) {
+        this.raise(Errors.InvalidPropertyBindingPattern, {
+          at: expression
+        });
+      }
+      return;
     }
-    const refTrailingCommaPos = {
-      value: -1
-    };
-    node.params = this.tsParseBracketedList("TypeParametersOrArguments", this.tsParseTypeParameter.bind(this, parseModifiers), false, true, refTrailingCommaPos);
-    if (node.params.length === 0) {
-      this.raise(TSErrors.EmptyTypeParameters, {
-        at: node
-      });
+    if (type === "Identifier") {
+      this.checkIdentifier(expression, binding, strictModeChanged);
+      const {
+        name
+      } = expression;
+      if (checkClashes) {
+        if (checkClashes.has(name)) {
+          this.raise(Errors.ParamDupe, {
+            at: expression
+          });
+        } else {
+          checkClashes.add(name);
+        }
+      }
+      return;
     }
-    if (refTrailingCommaPos.value !== -1) {
-      this.addExtra(node, "trailingComma", refTrailingCommaPos.value);
+    const validity = this.isValidLVal(type, !(hasParenthesizedAncestor || (_expression$extra = expression.extra) != null && _expression$extra.parenthesized) && ancestor.type === "AssignmentExpression", binding);
+    if (validity === true) return;
+    if (validity === false) {
+      const ParseErrorClass = binding === BIND_NONE ? Errors.InvalidLhs : Errors.InvalidLhsBinding;
+      this.raise(ParseErrorClass, {
+        at: expression,
+        ancestor
+      });
+      return;
     }
-    return this.finishNode(node, "TSTypeParameterDeclaration");
-  }
-  tsFillSignature(returnToken, signature) {
-    const returnTokenRequired = returnToken === 19;
-    const paramsKey = "parameters";
-    const returnTypeKey = "typeAnnotation";
-    signature.typeParameters = this.tsTryParseTypeParameters();
-    this.expect(10);
-    signature[paramsKey] = this.tsParseBindingListForSignature();
-    if (returnTokenRequired) {
-      signature[returnTypeKey] = this.tsParseTypeOrTypePredicateAnnotation(returnToken);
-    } else if (this.match(returnToken)) {
-      signature[returnTypeKey] = this.tsParseTypeOrTypePredicateAnnotation(returnToken);
+    const [key, isParenthesizedExpression] = Array.isArray(validity) ? validity : [validity, type === "ParenthesizedExpression"];
+    const nextAncestor = type === "ArrayPattern" || type === "ObjectPattern" || type === "ParenthesizedExpression" ? {
+      type
+    } : ancestor;
+    for (const child of [].concat(expression[key])) {
+      if (child) {
+        this.checkLVal(child, {
+          in: nextAncestor,
+          binding,
+          checkClashes,
+          strictModeChanged,
+          hasParenthesizedAncestor: isParenthesizedExpression
+        });
+      }
     }
   }
-  tsParseBindingListForSignature() {
-    return super.parseBindingList(11, 41).map(pattern => {
-      if (pattern.type !== "Identifier" && pattern.type !== "RestElement" && pattern.type !== "ObjectPattern" && pattern.type !== "ArrayPattern") {
-        this.raise(TSErrors.UnsupportedSignatureParameterKind, {
-          at: pattern,
-          type: pattern.type
+  checkIdentifier(at, bindingType, strictModeChanged = false) {
+    if (this.state.strict && (strictModeChanged ? isStrictBindReservedWord(at.name, this.inModule) : isStrictBindOnlyReservedWord(at.name))) {
+      if (bindingType === BIND_NONE) {
+        this.raise(Errors.StrictEvalArguments, {
+          at,
+          referenceName: at.name
+        });
+      } else {
+        this.raise(Errors.StrictEvalArgumentsBinding, {
+          at,
+          bindingName: at.name
         });
       }
-      return pattern;
-    });
-  }
-  tsParseTypeMemberSemicolon() {
-    if (!this.eat(12) && !this.isLineTerminator()) {
-      this.expect(13);
     }
-  }
-  tsParseSignatureMember(kind, node) {
-    this.tsFillSignature(14, node);
-    this.tsParseTypeMemberSemicolon();
-    return this.finishNode(node, kind);
-  }
-  tsIsUnambiguouslyIndexSignature() {
-    this.next();
-    if (tokenIsIdentifier(this.state.type)) {
-      this.next();
-      return this.match(14);
+    if (bindingType & BIND_FLAGS_NO_LET_IN_LEXICAL && at.name === "let") {
+      this.raise(Errors.LetInLexicalBinding, {
+        at
+      });
     }
-    return false;
-  }
-  tsTryParseIndexSignature(node) {
-    if (!(this.match(0) && this.tsLookAhead(this.tsIsUnambiguouslyIndexSignature.bind(this)))) {
-      return undefined;
+    if (!(bindingType & BIND_NONE)) {
+      this.declareNameFromIdentifier(at, bindingType);
     }
-    this.expect(0);
-    const id = this.parseIdentifier();
-    id.typeAnnotation = this.tsParseTypeAnnotation();
-    this.resetEndLocation(id);
-    this.expect(3);
-    node.parameters = [id];
-    const type = this.tsTryParseTypeAnnotation();
-    if (type) node.typeAnnotation = type;
-    this.tsParseTypeMemberSemicolon();
-    return this.finishNode(node, "TSIndexSignature");
   }
-  tsParsePropertyOrMethodSignature(node, readonly) {
-    if (this.eat(17)) node.optional = true;
-    const nodeAny = node;
-    if (this.match(10) || this.match(47)) {
-      if (readonly) {
-        this.raise(TSErrors.ReadonlyForMethodSignature, {
+  declareNameFromIdentifier(identifier, binding) {
+    this.scope.declareName(identifier.name, binding, identifier.loc.start);
+  }
+  checkToRestConversion(node, allowPattern) {
+    switch (node.type) {
+      case "ParenthesizedExpression":
+        this.checkToRestConversion(node.expression, allowPattern);
+        break;
+      case "Identifier":
+      case "MemberExpression":
+        break;
+      case "ArrayExpression":
+      case "ObjectExpression":
+        if (allowPattern) break;
+      default:
+        this.raise(Errors.InvalidRestAssignmentPattern, {
+          at: node
+        });
+    }
+  }
+  checkCommaAfterRest(close) {
+    if (!this.match(12)) {
+      return false;
+    }
+    this.raise(this.lookaheadCharCode() === close ? Errors.RestTrailingComma : Errors.ElementAfterRest, {
+      at: this.state.startLoc
+    });
+    return true;
+  }
+}
+
+const getOwn = (object, key) => Object.hasOwnProperty.call(object, key) && object[key];
+function nonNull(x) {
+  if (x == null) {
+    throw new Error(`Unexpected ${x} value.`);
+  }
+  return x;
+}
+function assert(x) {
+  if (!x) {
+    throw new Error("Assert fail");
+  }
+}
+const TSErrors = ParseErrorEnum`typescript`({
+  AbstractMethodHasImplementation: ({
+    methodName
+  }) => `Method '${methodName}' cannot have an implementation because it is marked abstract.`,
+  AbstractPropertyHasInitializer: ({
+    propertyName
+  }) => `Property '${propertyName}' cannot have an initializer because it is marked abstract.`,
+  AccesorCannotDeclareThisParameter: "'get' and 'set' accessors cannot declare 'this' parameters.",
+  AccesorCannotHaveTypeParameters: "An accessor cannot have type parameters.",
+  AccessorCannotBeOptional: "An 'accessor' property cannot be declared optional.",
+  ClassMethodHasDeclare: "Class methods cannot have the 'declare' modifier.",
+  ClassMethodHasReadonly: "Class methods cannot have the 'readonly' modifier.",
+  ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference: "A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference.",
+  ConstructorHasTypeParameters: "Type parameters cannot appear on a constructor declaration.",
+  DeclareAccessor: ({
+    kind
+  }) => `'declare' is not allowed in ${kind}ters.`,
+  DeclareClassFieldHasInitializer: "Initializers are not allowed in ambient contexts.",
+  DeclareFunctionHasImplementation: "An implementation cannot be declared in ambient contexts.",
+  DuplicateAccessibilityModifier: ({
+    modifier
+  }) => `Accessibility modifier already seen.`,
+  DuplicateModifier: ({
+    modifier
+  }) => `Duplicate modifier: '${modifier}'.`,
+  EmptyHeritageClauseType: ({
+    token
+  }) => `'${token}' list cannot be empty.`,
+  EmptyTypeArguments: "Type argument list cannot be empty.",
+  EmptyTypeParameters: "Type parameter list cannot be empty.",
+  ExpectedAmbientAfterExportDeclare: "'export declare' must be followed by an ambient declaration.",
+  ImportAliasHasImportType: "An import alias can not use 'import type'.",
+  ImportReflectionHasImportType: "An `import module` declaration can not use `type` modifier",
+  IncompatibleModifiers: ({
+    modifiers
+  }) => `'${modifiers[0]}' modifier cannot be used with '${modifiers[1]}' modifier.`,
+  IndexSignatureHasAbstract: "Index signatures cannot have the 'abstract' modifier.",
+  IndexSignatureHasAccessibility: ({
+    modifier
+  }) => `Index signatures cannot have an accessibility modifier ('${modifier}').`,
+  IndexSignatureHasDeclare: "Index signatures cannot have the 'declare' modifier.",
+  IndexSignatureHasOverride: "'override' modifier cannot appear on an index signature.",
+  IndexSignatureHasStatic: "Index signatures cannot have the 'static' modifier.",
+  InitializerNotAllowedInAmbientContext: "Initializers are not allowed in ambient contexts.",
+  InvalidModifierOnTypeMember: ({
+    modifier
+  }) => `'${modifier}' modifier cannot appear on a type member.`,
+  InvalidModifierOnTypeParameter: ({
+    modifier
+  }) => `'${modifier}' modifier cannot appear on a type parameter.`,
+  InvalidModifierOnTypeParameterPositions: ({
+    modifier
+  }) => `'${modifier}' modifier can only appear on a type parameter of a class, interface or type alias.`,
+  InvalidModifiersOrder: ({
+    orderedModifiers
+  }) => `'${orderedModifiers[0]}' modifier must precede '${orderedModifiers[1]}' modifier.`,
+  InvalidPropertyAccessAfterInstantiationExpression: "Invalid property access after an instantiation expression. " + "You can either wrap the instantiation expression in parentheses, or delete the type arguments.",
+  InvalidTupleMemberLabel: "Tuple members must be labeled with a simple identifier.",
+  MissingInterfaceName: "'interface' declarations must be followed by an identifier.",
+  MixedLabeledAndUnlabeledElements: "Tuple members must all have names or all not have names.",
+  NonAbstractClassHasAbstractMethod: "Abstract methods can only appear within an abstract class.",
+  NonClassMethodPropertyHasAbstractModifer: "'abstract' modifier can only appear on a class, method, or property declaration.",
+  OptionalTypeBeforeRequired: "A required element cannot follow an optional element.",
+  OverrideNotInSubClass: "This member cannot have an 'override' modifier because its containing class does not extend another class.",
+  PatternIsOptional: "A binding pattern parameter cannot be optional in an implementation signature.",
+  PrivateElementHasAbstract: "Private elements cannot have the 'abstract' modifier.",
+  PrivateElementHasAccessibility: ({
+    modifier
+  }) => `Private elements cannot have an accessibility modifier ('${modifier}').`,
+  ReadonlyForMethodSignature: "'readonly' modifier can only appear on a property declaration or index signature.",
+  ReservedArrowTypeParam: "This syntax is reserved in files with the .mts or .cts extension. Add a trailing comma, as in `<T,>() => ...`.",
+  ReservedTypeAssertion: "This syntax is reserved in files with the .mts or .cts extension. Use an `as` expression instead.",
+  SetAccesorCannotHaveOptionalParameter: "A 'set' accessor cannot have an optional parameter.",
+  SetAccesorCannotHaveRestParameter: "A 'set' accessor cannot have rest parameter.",
+  SetAccesorCannotHaveReturnType: "A 'set' accessor cannot have a return type annotation.",
+  SingleTypeParameterWithoutTrailingComma: ({
+    typeParameterName
+  }) => `Single type parameter ${typeParameterName} should have a trailing comma. Example usage: <${typeParameterName},>.`,
+  StaticBlockCannotHaveModifier: "Static class blocks cannot have any modifier.",
+  TypeAnnotationAfterAssign: "Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.",
+  TypeImportCannotSpecifyDefaultAndNamed: "A type-only import can specify a default import or named bindings, but not both.",
+  TypeModifierIsUsedInTypeExports: "The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement.",
+  TypeModifierIsUsedInTypeImports: "The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement.",
+  UnexpectedParameterModifier: "A parameter property is only allowed in a constructor implementation.",
+  UnexpectedReadonly: "'readonly' type modifier is only permitted on array and tuple literal types.",
+  UnexpectedTypeAnnotation: "Did not expect a type annotation here.",
+  UnexpectedTypeCastInParameter: "Unexpected type cast in parameter position.",
+  UnsupportedImportTypeArgument: "Argument in a type import must be a string literal.",
+  UnsupportedParameterPropertyKind: "A parameter property may not be declared using a binding pattern.",
+  UnsupportedSignatureParameterKind: ({
+    type
+  }) => `Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got ${type}.`
+});
+function keywordTypeFromName(value) {
+  switch (value) {
+    case "any":
+      return "TSAnyKeyword";
+    case "boolean":
+      return "TSBooleanKeyword";
+    case "bigint":
+      return "TSBigIntKeyword";
+    case "never":
+      return "TSNeverKeyword";
+    case "number":
+      return "TSNumberKeyword";
+    case "object":
+      return "TSObjectKeyword";
+    case "string":
+      return "TSStringKeyword";
+    case "symbol":
+      return "TSSymbolKeyword";
+    case "undefined":
+      return "TSUndefinedKeyword";
+    case "unknown":
+      return "TSUnknownKeyword";
+    default:
+      return undefined;
+  }
+}
+function tsIsAccessModifier(modifier) {
+  return modifier === "private" || modifier === "public" || modifier === "protected";
+}
+function tsIsVarianceAnnotations(modifier) {
+  return modifier === "in" || modifier === "out";
+}
+var typescript = (superClass => class TypeScriptParserMixin extends superClass {
+  constructor(...args) {
+    super(...args);
+    this.tsParseInOutModifiers = this.tsParseModifiers.bind(this, {
+      allowedModifiers: ["in", "out"],
+      disallowedModifiers: ["const", "public", "private", "protected", "readonly", "declare", "abstract", "override"],
+      errorTemplate: TSErrors.InvalidModifierOnTypeParameter
+    });
+    this.tsParseConstModifier = this.tsParseModifiers.bind(this, {
+      allowedModifiers: ["const"],
+      disallowedModifiers: ["in", "out"],
+      errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions
+    });
+    this.tsParseInOutConstModifiers = this.tsParseModifiers.bind(this, {
+      allowedModifiers: ["in", "out", "const"],
+      disallowedModifiers: ["public", "private", "protected", "readonly", "declare", "abstract", "override"],
+      errorTemplate: TSErrors.InvalidModifierOnTypeParameter
+    });
+  }
+  getScopeHandler() {
+    return TypeScriptScopeHandler;
+  }
+  tsIsIdentifier() {
+    return tokenIsIdentifier(this.state.type);
+  }
+  tsTokenCanFollowModifier() {
+    return (this.match(0) || this.match(5) || this.match(55) || this.match(21) || this.match(136) || this.isLiteralPropertyName()) && !this.hasPrecedingLineBreak();
+  }
+  tsNextTokenCanFollowModifier() {
+    this.next();
+    return this.tsTokenCanFollowModifier();
+  }
+  tsParseModifier(allowedModifiers, stopOnStartOfClassStaticBlock) {
+    if (!tokenIsIdentifier(this.state.type) && this.state.type !== 58 && this.state.type !== 75) {
+      return undefined;
+    }
+    const modifier = this.state.value;
+    if (allowedModifiers.indexOf(modifier) !== -1) {
+      if (stopOnStartOfClassStaticBlock && this.tsIsStartOfStaticBlocks()) {
+        return undefined;
+      }
+      if (this.tsTryParse(this.tsNextTokenCanFollowModifier.bind(this))) {
+        return modifier;
+      }
+    }
+    return undefined;
+  }
+  tsParseModifiers({
+    allowedModifiers,
+    disallowedModifiers,
+    stopOnStartOfClassStaticBlock,
+    errorTemplate = TSErrors.InvalidModifierOnTypeMember
+  }, modified) {
+    const enforceOrder = (loc, modifier, before, after) => {
+      if (modifier === before && modified[after]) {
+        this.raise(TSErrors.InvalidModifiersOrder, {
+          at: loc,
+          orderedModifiers: [before, after]
+        });
+      }
+    };
+    const incompatible = (loc, modifier, mod1, mod2) => {
+      if (modified[mod1] && modifier === mod2 || modified[mod2] && modifier === mod1) {
+        this.raise(TSErrors.IncompatibleModifiers, {
+          at: loc,
+          modifiers: [mod1, mod2]
+        });
+      }
+    };
+    for (;;) {
+      const {
+        startLoc
+      } = this.state;
+      const modifier = this.tsParseModifier(allowedModifiers.concat(disallowedModifiers != null ? disallowedModifiers : []), stopOnStartOfClassStaticBlock);
+      if (!modifier) break;
+      if (tsIsAccessModifier(modifier)) {
+        if (modified.accessibility) {
+          this.raise(TSErrors.DuplicateAccessibilityModifier, {
+            at: startLoc,
+            modifier
+          });
+        } else {
+          enforceOrder(startLoc, modifier, modifier, "override");
+          enforceOrder(startLoc, modifier, modifier, "static");
+          enforceOrder(startLoc, modifier, modifier, "readonly");
+          modified.accessibility = modifier;
+        }
+      } else if (tsIsVarianceAnnotations(modifier)) {
+        if (modified[modifier]) {
+          this.raise(TSErrors.DuplicateModifier, {
+            at: startLoc,
+            modifier
+          });
+        }
+        modified[modifier] = true;
+        enforceOrder(startLoc, modifier, "in", "out");
+      } else {
+        if (Object.hasOwnProperty.call(modified, modifier)) {
+          this.raise(TSErrors.DuplicateModifier, {
+            at: startLoc,
+            modifier
+          });
+        } else {
+          enforceOrder(startLoc, modifier, "static", "readonly");
+          enforceOrder(startLoc, modifier, "static", "override");
+          enforceOrder(startLoc, modifier, "override", "readonly");
+          enforceOrder(startLoc, modifier, "abstract", "override");
+          incompatible(startLoc, modifier, "declare", "override");
+          incompatible(startLoc, modifier, "static", "abstract");
+        }
+        modified[modifier] = true;
+      }
+      if (disallowedModifiers != null && disallowedModifiers.includes(modifier)) {
+        this.raise(errorTemplate, {
+          at: startLoc,
+          modifier
+        });
+      }
+    }
+  }
+  tsIsListTerminator(kind) {
+    switch (kind) {
+      case "EnumMembers":
+      case "TypeMembers":
+        return this.match(8);
+      case "HeritageClauseElement":
+        return this.match(5);
+      case "TupleElementTypes":
+        return this.match(3);
+      case "TypeParametersOrArguments":
+        return this.match(48);
+    }
+    throw new Error("Unreachable");
+  }
+  tsParseList(kind, parseElement) {
+    const result = [];
+    while (!this.tsIsListTerminator(kind)) {
+      result.push(parseElement());
+    }
+    return result;
+  }
+  tsParseDelimitedList(kind, parseElement, refTrailingCommaPos) {
+    return nonNull(this.tsParseDelimitedListWorker(kind, parseElement, true, refTrailingCommaPos));
+  }
+  tsParseDelimitedListWorker(kind, parseElement, expectSuccess, refTrailingCommaPos) {
+    const result = [];
+    let trailingCommaPos = -1;
+    for (;;) {
+      if (this.tsIsListTerminator(kind)) {
+        break;
+      }
+      trailingCommaPos = -1;
+      const element = parseElement();
+      if (element == null) {
+        return undefined;
+      }
+      result.push(element);
+      if (this.eat(12)) {
+        trailingCommaPos = this.state.lastTokStart;
+        continue;
+      }
+      if (this.tsIsListTerminator(kind)) {
+        break;
+      }
+      if (expectSuccess) {
+        this.expect(12);
+      }
+      return undefined;
+    }
+    if (refTrailingCommaPos) {
+      refTrailingCommaPos.value = trailingCommaPos;
+    }
+    return result;
+  }
+  tsParseBracketedList(kind, parseElement, bracket, skipFirstToken, refTrailingCommaPos) {
+    if (!skipFirstToken) {
+      if (bracket) {
+        this.expect(0);
+      } else {
+        this.expect(47);
+      }
+    }
+    const result = this.tsParseDelimitedList(kind, parseElement, refTrailingCommaPos);
+    if (bracket) {
+      this.expect(3);
+    } else {
+      this.expect(48);
+    }
+    return result;
+  }
+  tsParseImportType() {
+    const node = this.startNode();
+    this.expect(83);
+    this.expect(10);
+    if (!this.match(131)) {
+      this.raise(TSErrors.UnsupportedImportTypeArgument, {
+        at: this.state.startLoc
+      });
+    }
+    node.argument = super.parseExprAtom();
+    this.expect(11);
+    if (this.eat(16)) {
+      node.qualifier = this.tsParseEntityName();
+    }
+    if (this.match(47)) {
+      node.typeParameters = this.tsParseTypeArguments();
+    }
+    return this.finishNode(node, "TSImportType");
+  }
+  tsParseEntityName(allowReservedWords = true) {
+    let entity = this.parseIdentifier(allowReservedWords);
+    while (this.eat(16)) {
+      const node = this.startNodeAtNode(entity);
+      node.left = entity;
+      node.right = this.parseIdentifier(allowReservedWords);
+      entity = this.finishNode(node, "TSQualifiedName");
+    }
+    return entity;
+  }
+  tsParseTypeReference() {
+    const node = this.startNode();
+    node.typeName = this.tsParseEntityName();
+    if (!this.hasPrecedingLineBreak() && this.match(47)) {
+      node.typeParameters = this.tsParseTypeArguments();
+    }
+    return this.finishNode(node, "TSTypeReference");
+  }
+  tsParseThisTypePredicate(lhs) {
+    this.next();
+    const node = this.startNodeAtNode(lhs);
+    node.parameterName = lhs;
+    node.typeAnnotation = this.tsParseTypeAnnotation(false);
+    node.asserts = false;
+    return this.finishNode(node, "TSTypePredicate");
+  }
+  tsParseThisTypeNode() {
+    const node = this.startNode();
+    this.next();
+    return this.finishNode(node, "TSThisType");
+  }
+  tsParseTypeQuery() {
+    const node = this.startNode();
+    this.expect(87);
+    if (this.match(83)) {
+      node.exprName = this.tsParseImportType();
+    } else {
+      node.exprName = this.tsParseEntityName();
+    }
+    if (!this.hasPrecedingLineBreak() && this.match(47)) {
+      node.typeParameters = this.tsParseTypeArguments();
+    }
+    return this.finishNode(node, "TSTypeQuery");
+  }
+  tsParseTypeParameter(parseModifiers) {
+    const node = this.startNode();
+    parseModifiers(node);
+    node.name = this.tsParseTypeParameterName();
+    node.constraint = this.tsEatThenParseType(81);
+    node.default = this.tsEatThenParseType(29);
+    return this.finishNode(node, "TSTypeParameter");
+  }
+  tsTryParseTypeParameters(parseModifiers) {
+    if (this.match(47)) {
+      return this.tsParseTypeParameters(parseModifiers);
+    }
+  }
+  tsParseTypeParameters(parseModifiers) {
+    const node = this.startNode();
+    if (this.match(47) || this.match(140)) {
+      this.next();
+    } else {
+      this.unexpected();
+    }
+    const refTrailingCommaPos = {
+      value: -1
+    };
+    node.params = this.tsParseBracketedList("TypeParametersOrArguments", this.tsParseTypeParameter.bind(this, parseModifiers), false, true, refTrailingCommaPos);
+    if (node.params.length === 0) {
+      this.raise(TSErrors.EmptyTypeParameters, {
+        at: node
+      });
+    }
+    if (refTrailingCommaPos.value !== -1) {
+      this.addExtra(node, "trailingComma", refTrailingCommaPos.value);
+    }
+    return this.finishNode(node, "TSTypeParameterDeclaration");
+  }
+  tsFillSignature(returnToken, signature) {
+    const returnTokenRequired = returnToken === 19;
+    const paramsKey = "parameters";
+    const returnTypeKey = "typeAnnotation";
+    signature.typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
+    this.expect(10);
+    signature[paramsKey] = this.tsParseBindingListForSignature();
+    if (returnTokenRequired) {
+      signature[returnTypeKey] = this.tsParseTypeOrTypePredicateAnnotation(returnToken);
+    } else if (this.match(returnToken)) {
+      signature[returnTypeKey] = this.tsParseTypeOrTypePredicateAnnotation(returnToken);
+    }
+  }
+  tsParseBindingListForSignature() {
+    return super.parseBindingList(11, 41, ParseBindingListFlags.IS_FUNCTION_PARAMS).map(pattern => {
+      if (pattern.type !== "Identifier" && pattern.type !== "RestElement" && pattern.type !== "ObjectPattern" && pattern.type !== "ArrayPattern") {
+        this.raise(TSErrors.UnsupportedSignatureParameterKind, {
+          at: pattern,
+          type: pattern.type
+        });
+      }
+      return pattern;
+    });
+  }
+  tsParseTypeMemberSemicolon() {
+    if (!this.eat(12) && !this.isLineTerminator()) {
+      this.expect(13);
+    }
+  }
+  tsParseSignatureMember(kind, node) {
+    this.tsFillSignature(14, node);
+    this.tsParseTypeMemberSemicolon();
+    return this.finishNode(node, kind);
+  }
+  tsIsUnambiguouslyIndexSignature() {
+    this.next();
+    if (tokenIsIdentifier(this.state.type)) {
+      this.next();
+      return this.match(14);
+    }
+    return false;
+  }
+  tsTryParseIndexSignature(node) {
+    if (!(this.match(0) && this.tsLookAhead(this.tsIsUnambiguouslyIndexSignature.bind(this)))) {
+      return undefined;
+    }
+    this.expect(0);
+    const id = this.parseIdentifier();
+    id.typeAnnotation = this.tsParseTypeAnnotation();
+    this.resetEndLocation(id);
+    this.expect(3);
+    node.parameters = [id];
+    const type = this.tsTryParseTypeAnnotation();
+    if (type) node.typeAnnotation = type;
+    this.tsParseTypeMemberSemicolon();
+    return this.finishNode(node, "TSIndexSignature");
+  }
+  tsParsePropertyOrMethodSignature(node, readonly) {
+    if (this.eat(17)) node.optional = true;
+    const nodeAny = node;
+    if (this.match(10) || this.match(47)) {
+      if (readonly) {
+        this.raise(TSErrors.ReadonlyForMethodSignature, {
           at: node
         });
       }
@@ -7723,10 +8126,9 @@ var typescript = (superClass => class TypeScriptParserMixin extends superClass {
       }
     }
     this.tsParseModifiers({
-      modified: node,
       allowedModifiers: ["readonly"],
       disallowedModifiers: ["declare", "abstract", "private", "protected", "public", "static", "override"]
-    });
+    }, node);
     const idx = this.tsTryParseIndexSignature(node);
     if (idx) {
       return idx;
@@ -8075,7 +8477,7 @@ var typescript = (superClass => class TypeScriptParserMixin extends superClass {
       } = this.state;
       const previousErrorCount = errors.length;
       try {
-        super.parseBindingList(3, 93, true);
+        super.parseBindingList(3, 93, ParseBindingListFlags.ALLOW_EMPTY);
         return errors.length === previousErrorCount;
       } catch (_unused2) {
         return false;
@@ -8255,7 +8657,7 @@ var typescript = (superClass => class TypeScriptParserMixin extends superClass {
         at: this.state.startLoc
       });
     }
-    node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers.bind(this));
+    node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutConstModifiers);
     if (this.eat(81)) {
       node.extends = this.tsParseHeritageClause("extends");
     }
@@ -8268,7 +8670,7 @@ var typescript = (superClass => class TypeScriptParserMixin extends superClass {
     node.id = this.parseIdentifier();
     this.checkIdentifier(node.id, BIND_TS_TYPE);
     node.typeAnnotation = this.tsInType(() => {
-      node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers.bind(this));
+      node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers);
       this.expect(29);
       if (this.isContextual(112) && this.lookahead().type !== 16) {
         const node = this.startNode();
@@ -8574,7 +8976,7 @@ var typescript = (superClass => class TypeScriptParserMixin extends superClass {
     this.state.maybeInArrowParameters = true;
     const res = this.tsTryParseAndCatch(() => {
       const node = this.startNodeAt(startLoc);
-      node.typeParameters = this.tsParseTypeParameters();
+      node.typeParameters = this.tsParseTypeParameters(this.tsParseConstModifier);
       super.parseFunctionParams(node);
       node.returnType = this.tsTryParseTypeOrTypePredicateAnnotation();
       this.expect(19);
@@ -8613,28 +9015,22 @@ var typescript = (superClass => class TypeScriptParserMixin extends superClass {
     if (this.tsIsDeclarationStart()) return false;
     return super.isExportDefaultSpecifier();
   }
-  parseAssignableListItem(allowModifiers, decorators) {
+  parseAssignableListItem(flags, decorators) {
     const startLoc = this.state.startLoc;
-    let accessibility;
-    let readonly = false;
-    let override = false;
-    if (allowModifiers !== undefined) {
-      const modified = {};
-      this.tsParseModifiers({
-        modified,
-        allowedModifiers: ["public", "private", "protected", "override", "readonly"]
+    const modified = {};
+    this.tsParseModifiers({
+      allowedModifiers: ["public", "private", "protected", "override", "readonly"]
+    }, modified);
+    const accessibility = modified.accessibility;
+    const override = modified.override;
+    const readonly = modified.readonly;
+    if (!(flags & ParseBindingListFlags.IS_CONSTRUCTOR_PARAMS) && (accessibility || readonly || override)) {
+      this.raise(TSErrors.UnexpectedParameterModifier, {
+        at: startLoc
       });
-      accessibility = modified.accessibility;
-      override = modified.override;
-      readonly = modified.readonly;
-      if (allowModifiers === false && (accessibility || readonly || override)) {
-        this.raise(TSErrors.UnexpectedParameterModifier, {
-          at: startLoc
-        });
-      }
     }
     const left = this.parseMaybeDefault();
-    this.parseAssignableListItemTypes(left);
+    this.parseAssignableListItemTypes(left, flags);
     const elt = this.parseMaybeDefault(left.loc.start, left);
     if (accessibility || readonly || override) {
       const pp = this.startNodeAt(startLoc);
@@ -8655,10 +9051,23 @@ var typescript = (superClass => class TypeScriptParserMixin extends superClass {
     if (decorators.length) {
       left.decorators = decorators;
     }
-    return elt;
+    return elt;
+  }
+  isSimpleParameter(node) {
+    return node.type === "TSParameterProperty" && super.isSimpleParameter(node.parameter) || super.isSimpleParameter(node);
+  }
+  tsDisallowOptionalPattern(node) {
+    for (const param of node.params) {
+      if (param.type !== "Identifier" && param.optional && !this.state.isAmbientContext) {
+        this.raise(TSErrors.PatternIsOptional, {
+          at: param
+        });
+      }
+    }
   }
-  isSimpleParameter(node) {
-    return node.type === "TSParameterProperty" && super.isSimpleParameter(node.parameter) || super.isSimpleParameter(node);
+  setArrowFunctionParameters(node, params, trailingCommaLoc) {
+    super.setArrowFunctionParameters(node, params, trailingCommaLoc);
+    this.tsDisallowOptionalPattern(node);
   }
   parseFunctionBodyAndFinish(node, type, isMethod = false) {
     if (this.match(14)) {
@@ -8676,6 +9085,7 @@ var typescript = (superClass => class TypeScriptParserMixin extends superClass {
         return super.parseFunctionBodyAndFinish(node, bodilessType, isMethod);
       }
     }
+    this.tsDisallowOptionalPattern(node);
     return super.parseFunctionBodyAndFinish(node, type, isMethod);
   }
   registerFunctionStatementId(node) {
@@ -8868,11 +9278,13 @@ var typescript = (superClass => class TypeScriptParserMixin extends superClass {
       this.semicolon();
       return this.finishNode(decl, "TSNamespaceExportDeclaration");
     } else {
-      if (this.isContextual(128) && this.lookahead().type === 5) {
-        this.next();
-        node.exportKind = "type";
-      } else {
-        node.exportKind = "value";
+      node.exportKind = "value";
+      if (this.isContextual(128)) {
+        const ch = this.lookaheadCharCode();
+        if (ch === 123 || ch === 42) {
+          this.next();
+          node.exportKind = "type";
+        }
       }
       return super.parseExport(node, decorators);
     }
@@ -8950,1538 +9362,1138 @@ var typescript = (superClass => class TypeScriptParserMixin extends superClass {
   parseClassMember(classBody, member, state) {
     const modifiers = ["declare", "private", "public", "protected", "override", "abstract", "readonly", "static"];
     this.tsParseModifiers({
-      modified: member,
       allowedModifiers: modifiers,
       disallowedModifiers: ["in", "out"],
       stopOnStartOfClassStaticBlock: true,
       errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions
-    });
+    }, member);
     const callParseClassMemberWithIsStatic = () => {
       if (this.tsIsStartOfStaticBlocks()) {
         this.next();
         this.next();
         if (this.tsHasSomeModifiers(member, modifiers)) {
           this.raise(TSErrors.StaticBlockCannotHaveModifier, {
-            at: this.state.curPosition()
-          });
-        }
-        super.parseClassStaticBlock(classBody, member);
-      } else {
-        this.parseClassMemberWithIsStatic(classBody, member, state, !!member.static);
-      }
-    };
-    if (member.declare) {
-      this.tsInAmbientContext(callParseClassMemberWithIsStatic);
-    } else {
-      callParseClassMemberWithIsStatic();
-    }
-  }
-  parseClassMemberWithIsStatic(classBody, member, state, isStatic) {
-    const idx = this.tsTryParseIndexSignature(member);
-    if (idx) {
-      classBody.body.push(idx);
-      if (member.abstract) {
-        this.raise(TSErrors.IndexSignatureHasAbstract, {
-          at: member
-        });
-      }
-      if (member.accessibility) {
-        this.raise(TSErrors.IndexSignatureHasAccessibility, {
-          at: member,
-          modifier: member.accessibility
-        });
-      }
-      if (member.declare) {
-        this.raise(TSErrors.IndexSignatureHasDeclare, {
-          at: member
-        });
-      }
-      if (member.override) {
-        this.raise(TSErrors.IndexSignatureHasOverride, {
-          at: member
-        });
-      }
-      return;
-    }
-    if (!this.state.inAbstractClass && member.abstract) {
-      this.raise(TSErrors.NonAbstractClassHasAbstractMethod, {
-        at: member
-      });
-    }
-    if (member.override) {
-      if (!state.hadSuperClass) {
-        this.raise(TSErrors.OverrideNotInSubClass, {
-          at: member
-        });
-      }
-    }
-    super.parseClassMemberWithIsStatic(classBody, member, state, isStatic);
-  }
-  parsePostMemberNameModifiers(methodOrProp) {
-    const optional = this.eat(17);
-    if (optional) methodOrProp.optional = true;
-    if (methodOrProp.readonly && this.match(10)) {
-      this.raise(TSErrors.ClassMethodHasReadonly, {
-        at: methodOrProp
-      });
-    }
-    if (methodOrProp.declare && this.match(10)) {
-      this.raise(TSErrors.ClassMethodHasDeclare, {
-        at: methodOrProp
-      });
-    }
-  }
-  parseExpressionStatement(node, expr, decorators) {
-    const decl = expr.type === "Identifier" ? this.tsParseExpressionStatement(node, expr, decorators) : undefined;
-    return decl || super.parseExpressionStatement(node, expr, decorators);
-  }
-  shouldParseExportDeclaration() {
-    if (this.tsIsDeclarationStart()) return true;
-    return super.shouldParseExportDeclaration();
-  }
-  parseConditional(expr, startLoc, refExpressionErrors) {
-    if (!this.state.maybeInArrowParameters || !this.match(17)) {
-      return super.parseConditional(expr, startLoc, refExpressionErrors);
-    }
-    const result = this.tryParse(() => super.parseConditional(expr, startLoc));
-    if (!result.node) {
-      if (result.error) {
-        super.setOptionalParametersError(refExpressionErrors, result.error);
-      }
-      return expr;
-    }
-    if (result.error) this.state = result.failState;
-    return result.node;
-  }
-  parseParenItem(node, startLoc) {
-    node = super.parseParenItem(node, startLoc);
-    if (this.eat(17)) {
-      node.optional = true;
-      this.resetEndLocation(node);
-    }
-    if (this.match(14)) {
-      const typeCastNode = this.startNodeAt(startLoc);
-      typeCastNode.expression = node;
-      typeCastNode.typeAnnotation = this.tsParseTypeAnnotation();
-      return this.finishNode(typeCastNode, "TSTypeCastExpression");
-    }
-    return node;
-  }
-  parseExportDeclaration(node) {
-    if (!this.state.isAmbientContext && this.isContextual(123)) {
-      return this.tsInAmbientContext(() => this.parseExportDeclaration(node));
-    }
-    const startLoc = this.state.startLoc;
-    const isDeclare = this.eatContextual(123);
-    if (isDeclare && (this.isContextual(123) || !this.shouldParseExportDeclaration())) {
-      throw this.raise(TSErrors.ExpectedAmbientAfterExportDeclare, {
-        at: this.state.startLoc
-      });
-    }
-    const isIdentifier = tokenIsIdentifier(this.state.type);
-    const declaration = isIdentifier && this.tsTryParseExportDeclaration() || super.parseExportDeclaration(node);
-    if (!declaration) return null;
-    if (declaration.type === "TSInterfaceDeclaration" || declaration.type === "TSTypeAliasDeclaration" || isDeclare) {
-      node.exportKind = "type";
-    }
-    if (isDeclare) {
-      this.resetStartLocation(declaration, startLoc);
-      declaration.declare = true;
-    }
-    return declaration;
-  }
-  parseClassId(node, isStatement, optionalId, bindingType) {
-    if ((!isStatement || optionalId) && this.isContextual(111)) {
-      return;
-    }
-    super.parseClassId(node, isStatement, optionalId, node.declare ? BIND_TS_AMBIENT : BIND_CLASS);
-    const typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers.bind(this));
-    if (typeParameters) node.typeParameters = typeParameters;
-  }
-  parseClassPropertyAnnotation(node) {
-    if (!node.optional) {
-      if (this.eat(35)) {
-        node.definite = true;
-      } else if (this.eat(17)) {
-        node.optional = true;
-      }
-    }
-    const type = this.tsTryParseTypeAnnotation();
-    if (type) node.typeAnnotation = type;
-  }
-  parseClassProperty(node) {
-    this.parseClassPropertyAnnotation(node);
-    if (this.state.isAmbientContext && !(node.readonly && !node.typeAnnotation) && this.match(29)) {
-      this.raise(TSErrors.DeclareClassFieldHasInitializer, {
-        at: this.state.startLoc
-      });
-    }
-    if (node.abstract && this.match(29)) {
-      const {
-        key
-      } = node;
-      this.raise(TSErrors.AbstractPropertyHasInitializer, {
-        at: this.state.startLoc,
-        propertyName: key.type === "Identifier" && !node.computed ? key.name : `[${this.input.slice(key.start, key.end)}]`
-      });
-    }
-    return super.parseClassProperty(node);
-  }
-  parseClassPrivateProperty(node) {
-    if (node.abstract) {
-      this.raise(TSErrors.PrivateElementHasAbstract, {
-        at: node
-      });
-    }
-    if (node.accessibility) {
-      this.raise(TSErrors.PrivateElementHasAccessibility, {
-        at: node,
-        modifier: node.accessibility
-      });
-    }
-    this.parseClassPropertyAnnotation(node);
-    return super.parseClassPrivateProperty(node);
-  }
-  parseClassAccessorProperty(node) {
-    this.parseClassPropertyAnnotation(node);
-    if (node.optional) {
-      this.raise(TSErrors.AccessorCannotBeOptional, {
-        at: node
-      });
-    }
-    return super.parseClassAccessorProperty(node);
-  }
-  pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
-    const typeParameters = this.tsTryParseTypeParameters();
-    if (typeParameters && isConstructor) {
-      this.raise(TSErrors.ConstructorHasTypeParameters, {
-        at: typeParameters
-      });
-    }
-    const {
-      declare = false,
-      kind
-    } = method;
-    if (declare && (kind === "get" || kind === "set")) {
-      this.raise(TSErrors.DeclareAccessor, {
-        at: method,
-        kind
-      });
-    }
-    if (typeParameters) method.typeParameters = typeParameters;
-    super.pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper);
-  }
-  pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {
-    const typeParameters = this.tsTryParseTypeParameters();
-    if (typeParameters) method.typeParameters = typeParameters;
-    super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync);
-  }
-  declareClassPrivateMethodInScope(node, kind) {
-    if (node.type === "TSDeclareMethod") return;
-    if (node.type === "MethodDefinition" && !node.value.body) return;
-    super.declareClassPrivateMethodInScope(node, kind);
-  }
-  parseClassSuper(node) {
-    super.parseClassSuper(node);
-    if (node.superClass && (this.match(47) || this.match(51))) {
-      node.superTypeParameters = this.tsParseTypeArgumentsInExpression();
-    }
-    if (this.eatContextual(111)) {
-      node.implements = this.tsParseHeritageClause("implements");
-    }
-  }
-  parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {
-    const typeParameters = this.tsTryParseTypeParameters();
-    if (typeParameters) prop.typeParameters = typeParameters;
-    return super.parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors);
-  }
-  parseFunctionParams(node, allowModifiers) {
-    const typeParameters = this.tsTryParseTypeParameters();
-    if (typeParameters) node.typeParameters = typeParameters;
-    super.parseFunctionParams(node, allowModifiers);
-  }
-  parseVarId(decl, kind) {
-    super.parseVarId(decl, kind);
-    if (decl.id.type === "Identifier" && !this.hasPrecedingLineBreak() && this.eat(35)) {
-      decl.definite = true;
-    }
-    const type = this.tsTryParseTypeAnnotation();
-    if (type) {
-      decl.id.typeAnnotation = type;
-      this.resetEndLocation(decl.id);
-    }
-  }
-  parseAsyncArrowFromCallExpression(node, call) {
-    if (this.match(14)) {
-      node.returnType = this.tsParseTypeAnnotation();
+            at: this.state.curPosition()
+          });
+        }
+        super.parseClassStaticBlock(classBody, member);
+      } else {
+        this.parseClassMemberWithIsStatic(classBody, member, state, !!member.static);
+      }
+    };
+    if (member.declare) {
+      this.tsInAmbientContext(callParseClassMemberWithIsStatic);
+    } else {
+      callParseClassMemberWithIsStatic();
     }
-    return super.parseAsyncArrowFromCallExpression(node, call);
   }
-  parseMaybeAssign(refExpressionErrors, afterLeftParse) {
-    var _jsx, _jsx2, _typeCast, _jsx3, _typeCast2, _jsx4, _typeCast3;
-    let state;
-    let jsx;
-    let typeCast;
-    if (this.hasPlugin("jsx") && (this.match(140) || this.match(47))) {
-      state = this.state.clone();
-      jsx = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state);
-      if (!jsx.error) return jsx.node;
-      const {
-        context
-      } = this.state;
-      const currentContext = context[context.length - 1];
-      if (currentContext === types.j_oTag || currentContext === types.j_expr) {
-        context.pop();
+  parseClassMemberWithIsStatic(classBody, member, state, isStatic) {
+    const idx = this.tsTryParseIndexSignature(member);
+    if (idx) {
+      classBody.body.push(idx);
+      if (member.abstract) {
+        this.raise(TSErrors.IndexSignatureHasAbstract, {
+          at: member
+        });
       }
-    }
-    if (!((_jsx = jsx) != null && _jsx.error) && !this.match(47)) {
-      return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
-    }
-    if (!state || state === this.state) state = this.state.clone();
-    let typeParameters;
-    const arrow = this.tryParse(abort => {
-      var _expr$extra, _typeParameters;
-      typeParameters = this.tsParseTypeParameters();
-      const expr = super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
-      if (expr.type !== "ArrowFunctionExpression" || (_expr$extra = expr.extra) != null && _expr$extra.parenthesized) {
-        abort();
+      if (member.accessibility) {
+        this.raise(TSErrors.IndexSignatureHasAccessibility, {
+          at: member,
+          modifier: member.accessibility
+        });
       }
-      if (((_typeParameters = typeParameters) == null ? void 0 : _typeParameters.params.length) !== 0) {
-        this.resetStartLocationFromNode(expr, typeParameters);
+      if (member.declare) {
+        this.raise(TSErrors.IndexSignatureHasDeclare, {
+          at: member
+        });
       }
-      expr.typeParameters = typeParameters;
-      return expr;
-    }, state);
-    if (!arrow.error && !arrow.aborted) {
-      if (typeParameters) this.reportReservedArrowTypeParam(typeParameters);
-      return arrow.node;
-    }
-    if (!jsx) {
-      assert(!this.hasPlugin("jsx"));
-      typeCast = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state);
-      if (!typeCast.error) return typeCast.node;
-    }
-    if ((_jsx2 = jsx) != null && _jsx2.node) {
-      this.state = jsx.failState;
-      return jsx.node;
+      if (member.override) {
+        this.raise(TSErrors.IndexSignatureHasOverride, {
+          at: member
+        });
+      }
+      return;
     }
-    if (arrow.node) {
-      this.state = arrow.failState;
-      if (typeParameters) this.reportReservedArrowTypeParam(typeParameters);
-      return arrow.node;
+    if (!this.state.inAbstractClass && member.abstract) {
+      this.raise(TSErrors.NonAbstractClassHasAbstractMethod, {
+        at: member
+      });
     }
-    if ((_typeCast = typeCast) != null && _typeCast.node) {
-      this.state = typeCast.failState;
-      return typeCast.node;
+    if (member.override) {
+      if (!state.hadSuperClass) {
+        this.raise(TSErrors.OverrideNotInSubClass, {
+          at: member
+        });
+      }
     }
-    if ((_jsx3 = jsx) != null && _jsx3.thrown) throw jsx.error;
-    if (arrow.thrown) throw arrow.error;
-    if ((_typeCast2 = typeCast) != null && _typeCast2.thrown) throw typeCast.error;
-    throw ((_jsx4 = jsx) == null ? void 0 : _jsx4.error) || arrow.error || ((_typeCast3 = typeCast) == null ? void 0 : _typeCast3.error);
+    super.parseClassMemberWithIsStatic(classBody, member, state, isStatic);
   }
-  reportReservedArrowTypeParam(node) {
-    var _node$extra;
-    if (node.params.length === 1 && !((_node$extra = node.extra) != null && _node$extra.trailingComma) && this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) {
-      this.raise(TSErrors.ReservedArrowTypeParam, {
-        at: node
+  parsePostMemberNameModifiers(methodOrProp) {
+    const optional = this.eat(17);
+    if (optional) methodOrProp.optional = true;
+    if (methodOrProp.readonly && this.match(10)) {
+      this.raise(TSErrors.ClassMethodHasReadonly, {
+        at: methodOrProp
       });
     }
-  }
-  parseMaybeUnary(refExpressionErrors, sawUnary) {
-    if (!this.hasPlugin("jsx") && this.match(47)) {
-      return this.tsParseTypeAssertion();
-    } else {
-      return super.parseMaybeUnary(refExpressionErrors, sawUnary);
+    if (methodOrProp.declare && this.match(10)) {
+      this.raise(TSErrors.ClassMethodHasDeclare, {
+        at: methodOrProp
+      });
     }
   }
-  parseArrow(node) {
-    if (this.match(14)) {
-      const result = this.tryParse(abort => {
-        const returnType = this.tsParseTypeOrTypePredicateAnnotation(14);
-        if (this.canInsertSemicolon() || !this.match(19)) abort();
-        return returnType;
-      });
-      if (result.aborted) return;
-      if (!result.thrown) {
-        if (result.error) this.state = result.failState;
-        node.returnType = result.node;
+  parseExpressionStatement(node, expr, decorators) {
+    const decl = expr.type === "Identifier" ? this.tsParseExpressionStatement(node, expr, decorators) : undefined;
+    return decl || super.parseExpressionStatement(node, expr, decorators);
+  }
+  shouldParseExportDeclaration() {
+    if (this.tsIsDeclarationStart()) return true;
+    return super.shouldParseExportDeclaration();
+  }
+  parseConditional(expr, startLoc, refExpressionErrors) {
+    if (!this.state.maybeInArrowParameters || !this.match(17)) {
+      return super.parseConditional(expr, startLoc, refExpressionErrors);
+    }
+    const result = this.tryParse(() => super.parseConditional(expr, startLoc));
+    if (!result.node) {
+      if (result.error) {
+        super.setOptionalParametersError(refExpressionErrors, result.error);
       }
+      return expr;
     }
-    return super.parseArrow(node);
+    if (result.error) this.state = result.failState;
+    return result.node;
   }
-  parseAssignableListItemTypes(param) {
+  parseParenItem(node, startLoc) {
+    node = super.parseParenItem(node, startLoc);
     if (this.eat(17)) {
-      if (param.type !== "Identifier" && !this.state.isAmbientContext && !this.state.inType) {
-        this.raise(TSErrors.PatternIsOptional, {
-          at: param
-        });
-      }
-      param.optional = true;
+      node.optional = true;
+      this.resetEndLocation(node);
     }
-    const type = this.tsTryParseTypeAnnotation();
-    if (type) param.typeAnnotation = type;
-    this.resetEndLocation(param);
-    return param;
-  }
-  isAssignable(node, isBinding) {
-    switch (node.type) {
-      case "TSTypeCastExpression":
-        return this.isAssignable(node.expression, isBinding);
-      case "TSParameterProperty":
-        return true;
-      default:
-        return super.isAssignable(node, isBinding);
+    if (this.match(14)) {
+      const typeCastNode = this.startNodeAt(startLoc);
+      typeCastNode.expression = node;
+      typeCastNode.typeAnnotation = this.tsParseTypeAnnotation();
+      return this.finishNode(typeCastNode, "TSTypeCastExpression");
     }
+    return node;
   }
-  toAssignable(node, isLHS = false) {
-    switch (node.type) {
-      case "ParenthesizedExpression":
-        this.toAssignableParenthesizedExpression(node, isLHS);
-        break;
-      case "TSAsExpression":
-      case "TSSatisfiesExpression":
-      case "TSNonNullExpression":
-      case "TSTypeAssertion":
-        if (isLHS) {
-          this.expressionScope.recordArrowParameterBindingError(TSErrors.UnexpectedTypeCastInParameter, {
-            at: node
-          });
-        } else {
-          this.raise(TSErrors.UnexpectedTypeCastInParameter, {
-            at: node
-          });
-        }
-        this.toAssignable(node.expression, isLHS);
-        break;
-      case "AssignmentExpression":
-        if (!isLHS && node.left.type === "TSTypeCastExpression") {
-          node.left = this.typeCastToParameter(node.left);
-        }
-      default:
-        super.toAssignable(node, isLHS);
+  parseExportDeclaration(node) {
+    if (!this.state.isAmbientContext && this.isContextual(123)) {
+      return this.tsInAmbientContext(() => this.parseExportDeclaration(node));
     }
-  }
-  toAssignableParenthesizedExpression(node, isLHS) {
-    switch (node.expression.type) {
-      case "TSAsExpression":
-      case "TSSatisfiesExpression":
-      case "TSNonNullExpression":
-      case "TSTypeAssertion":
-      case "ParenthesizedExpression":
-        this.toAssignable(node.expression, isLHS);
-        break;
-      default:
-        super.toAssignable(node, isLHS);
+    const startLoc = this.state.startLoc;
+    const isDeclare = this.eatContextual(123);
+    if (isDeclare && (this.isContextual(123) || !this.shouldParseExportDeclaration())) {
+      throw this.raise(TSErrors.ExpectedAmbientAfterExportDeclare, {
+        at: this.state.startLoc
+      });
     }
-  }
-  checkToRestConversion(node, allowPattern) {
-    switch (node.type) {
-      case "TSAsExpression":
-      case "TSSatisfiesExpression":
-      case "TSTypeAssertion":
-      case "TSNonNullExpression":
-        this.checkToRestConversion(node.expression, false);
-        break;
-      default:
-        super.checkToRestConversion(node, allowPattern);
+    const isIdentifier = tokenIsIdentifier(this.state.type);
+    const declaration = isIdentifier && this.tsTryParseExportDeclaration() || super.parseExportDeclaration(node);
+    if (!declaration) return null;
+    if (declaration.type === "TSInterfaceDeclaration" || declaration.type === "TSTypeAliasDeclaration" || isDeclare) {
+      node.exportKind = "type";
     }
+    if (isDeclare) {
+      this.resetStartLocation(declaration, startLoc);
+      declaration.declare = true;
+    }
+    return declaration;
   }
-  isValidLVal(type, isUnparenthesizedInAssign, binding) {
-    return getOwn$1({
-      TSTypeCastExpression: true,
-      TSParameterProperty: "parameter",
-      TSNonNullExpression: "expression",
-      TSAsExpression: (binding !== BIND_NONE || !isUnparenthesizedInAssign) && ["expression", true],
-      TSSatisfiesExpression: (binding !== BIND_NONE || !isUnparenthesizedInAssign) && ["expression", true],
-      TSTypeAssertion: (binding !== BIND_NONE || !isUnparenthesizedInAssign) && ["expression", true]
-    }, type) || super.isValidLVal(type, isUnparenthesizedInAssign, binding);
-  }
-  parseBindingAtom() {
-    switch (this.state.type) {
-      case 78:
-        return this.parseIdentifier(true);
-      default:
-        return super.parseBindingAtom();
+  parseClassId(node, isStatement, optionalId, bindingType) {
+    if ((!isStatement || optionalId) && this.isContextual(111)) {
+      return;
     }
+    super.parseClassId(node, isStatement, optionalId, node.declare ? BIND_TS_AMBIENT : BIND_CLASS);
+    const typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutConstModifiers);
+    if (typeParameters) node.typeParameters = typeParameters;
   }
-  parseMaybeDecoratorArguments(expr) {
-    if (this.match(47) || this.match(51)) {
-      const typeArguments = this.tsParseTypeArgumentsInExpression();
-      if (this.match(10)) {
-        const call = super.parseMaybeDecoratorArguments(expr);
-        call.typeParameters = typeArguments;
-        return call;
+  parseClassPropertyAnnotation(node) {
+    if (!node.optional) {
+      if (this.eat(35)) {
+        node.definite = true;
+      } else if (this.eat(17)) {
+        node.optional = true;
       }
-      this.unexpected(null, 10);
     }
-    return super.parseMaybeDecoratorArguments(expr);
+    const type = this.tsTryParseTypeAnnotation();
+    if (type) node.typeAnnotation = type;
   }
-  checkCommaAfterRest(close) {
-    if (this.state.isAmbientContext && this.match(12) && this.lookaheadCharCode() === close) {
-      this.next();
-      return false;
-    } else {
-      return super.checkCommaAfterRest(close);
+  parseClassProperty(node) {
+    this.parseClassPropertyAnnotation(node);
+    if (this.state.isAmbientContext && !(node.readonly && !node.typeAnnotation) && this.match(29)) {
+      this.raise(TSErrors.DeclareClassFieldHasInitializer, {
+        at: this.state.startLoc
+      });
     }
-  }
-  isClassMethod() {
-    return this.match(47) || super.isClassMethod();
-  }
-  isClassProperty() {
-    return this.match(35) || this.match(14) || super.isClassProperty();
-  }
-  parseMaybeDefault(startLoc, left) {
-    const node = super.parseMaybeDefault(startLoc, left);
-    if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) {
-      this.raise(TSErrors.TypeAnnotationAfterAssign, {
-        at: node.typeAnnotation
+    if (node.abstract && this.match(29)) {
+      const {
+        key
+      } = node;
+      this.raise(TSErrors.AbstractPropertyHasInitializer, {
+        at: this.state.startLoc,
+        propertyName: key.type === "Identifier" && !node.computed ? key.name : `[${this.input.slice(key.start, key.end)}]`
       });
     }
-    return node;
+    return super.parseClassProperty(node);
   }
-  getTokenFromCode(code) {
-    if (this.state.inType) {
-      if (code === 62) {
-        return this.finishOp(48, 1);
-      }
-      if (code === 60) {
-        return this.finishOp(47, 1);
-      }
+  parseClassPrivateProperty(node) {
+    if (node.abstract) {
+      this.raise(TSErrors.PrivateElementHasAbstract, {
+        at: node
+      });
     }
-    return super.getTokenFromCode(code);
+    if (node.accessibility) {
+      this.raise(TSErrors.PrivateElementHasAccessibility, {
+        at: node,
+        modifier: node.accessibility
+      });
+    }
+    this.parseClassPropertyAnnotation(node);
+    return super.parseClassPrivateProperty(node);
   }
-  reScan_lt_gt() {
-    const {
-      type
-    } = this.state;
-    if (type === 47) {
-      this.state.pos -= 1;
-      this.readToken_lt();
-    } else if (type === 48) {
-      this.state.pos -= 1;
-      this.readToken_gt();
+  parseClassAccessorProperty(node) {
+    this.parseClassPropertyAnnotation(node);
+    if (node.optional) {
+      this.raise(TSErrors.AccessorCannotBeOptional, {
+        at: node
+      });
     }
+    return super.parseClassAccessorProperty(node);
   }
-  reScan_lt() {
+  pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
+    const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
+    if (typeParameters && isConstructor) {
+      this.raise(TSErrors.ConstructorHasTypeParameters, {
+        at: typeParameters
+      });
+    }
     const {
-      type
-    } = this.state;
-    if (type === 51) {
-      this.state.pos -= 2;
-      this.finishOp(47, 1);
-      return 47;
+      declare = false,
+      kind
+    } = method;
+    if (declare && (kind === "get" || kind === "set")) {
+      this.raise(TSErrors.DeclareAccessor, {
+        at: method,
+        kind
+      });
     }
-    return type;
+    if (typeParameters) method.typeParameters = typeParameters;
+    super.pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper);
   }
-  toAssignableList(exprList, trailingCommaLoc, isLHS) {
-    for (let i = 0; i < exprList.length; i++) {
-      const expr = exprList[i];
-      if ((expr == null ? void 0 : expr.type) === "TSTypeCastExpression") {
-        exprList[i] = this.typeCastToParameter(expr);
-      }
-    }
-    super.toAssignableList(exprList, trailingCommaLoc, isLHS);
+  pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {
+    const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
+    if (typeParameters) method.typeParameters = typeParameters;
+    super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync);
   }
-  typeCastToParameter(node) {
-    node.expression.typeAnnotation = node.typeAnnotation;
-    this.resetEndLocation(node.expression, node.typeAnnotation.loc.end);
-    return node.expression;
+  declareClassPrivateMethodInScope(node, kind) {
+    if (node.type === "TSDeclareMethod") return;
+    if (node.type === "MethodDefinition" && !node.value.body) return;
+    super.declareClassPrivateMethodInScope(node, kind);
   }
-  shouldParseArrow(params) {
-    if (this.match(14)) {
-      return params.every(expr => this.isAssignable(expr, true));
+  parseClassSuper(node) {
+    super.parseClassSuper(node);
+    if (node.superClass && (this.match(47) || this.match(51))) {
+      node.superTypeParameters = this.tsParseTypeArgumentsInExpression();
+    }
+    if (this.eatContextual(111)) {
+      node.implements = this.tsParseHeritageClause("implements");
     }
-    return super.shouldParseArrow(params);
   }
-  shouldParseAsyncArrow() {
-    return this.match(14) || super.shouldParseAsyncArrow();
+  parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {
+    const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
+    if (typeParameters) prop.typeParameters = typeParameters;
+    return super.parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors);
   }
-  canHaveLeadingDecorator() {
-    return super.canHaveLeadingDecorator() || this.isAbstractClass();
+  parseFunctionParams(node, isConstructor) {
+    const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
+    if (typeParameters) node.typeParameters = typeParameters;
+    super.parseFunctionParams(node, isConstructor);
   }
-  jsxParseOpeningElementAfterName(node) {
-    if (this.match(47) || this.match(51)) {
-      const typeArguments = this.tsTryParseAndCatch(() => this.tsParseTypeArgumentsInExpression());
-      if (typeArguments) node.typeParameters = typeArguments;
+  parseVarId(decl, kind) {
+    super.parseVarId(decl, kind);
+    if (decl.id.type === "Identifier" && !this.hasPrecedingLineBreak() && this.eat(35)) {
+      decl.definite = true;
     }
-    return super.jsxParseOpeningElementAfterName(node);
-  }
-  getGetterSetterExpectedParamCount(method) {
-    const baseCount = super.getGetterSetterExpectedParamCount(method);
-    const params = this.getObjectOrClassMethodParams(method);
-    const firstParam = params[0];
-    const hasContextParam = firstParam && this.isThisParam(firstParam);
-    return hasContextParam ? baseCount + 1 : baseCount;
-  }
-  parseCatchClauseParam() {
-    const param = super.parseCatchClauseParam();
     const type = this.tsTryParseTypeAnnotation();
     if (type) {
-      param.typeAnnotation = type;
-      this.resetEndLocation(param);
+      decl.id.typeAnnotation = type;
+      this.resetEndLocation(decl.id);
     }
-    return param;
   }
-  tsInAmbientContext(cb) {
-    const oldIsAmbientContext = this.state.isAmbientContext;
-    this.state.isAmbientContext = true;
-    try {
-      return cb();
-    } finally {
-      this.state.isAmbientContext = oldIsAmbientContext;
+  parseAsyncArrowFromCallExpression(node, call) {
+    if (this.match(14)) {
+      node.returnType = this.tsParseTypeAnnotation();
     }
+    return super.parseAsyncArrowFromCallExpression(node, call);
   }
-  parseClass(node, isStatement, optionalId) {
-    const oldInAbstractClass = this.state.inAbstractClass;
-    this.state.inAbstractClass = !!node.abstract;
-    try {
-      return super.parseClass(node, isStatement, optionalId);
-    } finally {
-      this.state.inAbstractClass = oldInAbstractClass;
+  parseMaybeAssign(refExpressionErrors, afterLeftParse) {
+    var _jsx, _jsx2, _typeCast, _jsx3, _typeCast2, _jsx4, _typeCast3;
+    let state;
+    let jsx;
+    let typeCast;
+    if (this.hasPlugin("jsx") && (this.match(140) || this.match(47))) {
+      state = this.state.clone();
+      jsx = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state);
+      if (!jsx.error) return jsx.node;
+      const {
+        context
+      } = this.state;
+      const currentContext = context[context.length - 1];
+      if (currentContext === types.j_oTag || currentContext === types.j_expr) {
+        context.pop();
+      }
+    }
+    if (!((_jsx = jsx) != null && _jsx.error) && !this.match(47)) {
+      return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
+    }
+    if (!state || state === this.state) state = this.state.clone();
+    let typeParameters;
+    const arrow = this.tryParse(abort => {
+      var _expr$extra, _typeParameters;
+      typeParameters = this.tsParseTypeParameters(this.tsParseConstModifier);
+      const expr = super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
+      if (expr.type !== "ArrowFunctionExpression" || (_expr$extra = expr.extra) != null && _expr$extra.parenthesized) {
+        abort();
+      }
+      if (((_typeParameters = typeParameters) == null ? void 0 : _typeParameters.params.length) !== 0) {
+        this.resetStartLocationFromNode(expr, typeParameters);
+      }
+      expr.typeParameters = typeParameters;
+      return expr;
+    }, state);
+    if (!arrow.error && !arrow.aborted) {
+      if (typeParameters) this.reportReservedArrowTypeParam(typeParameters);
+      return arrow.node;
+    }
+    if (!jsx) {
+      assert(!this.hasPlugin("jsx"));
+      typeCast = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state);
+      if (!typeCast.error) return typeCast.node;
+    }
+    if ((_jsx2 = jsx) != null && _jsx2.node) {
+      this.state = jsx.failState;
+      return jsx.node;
+    }
+    if (arrow.node) {
+      this.state = arrow.failState;
+      if (typeParameters) this.reportReservedArrowTypeParam(typeParameters);
+      return arrow.node;
     }
-  }
-  tsParseAbstractDeclaration(node, decorators) {
-    if (this.match(80)) {
-      node.abstract = true;
-      return this.maybeTakeDecorators(decorators, this.parseClass(node, true, false));
-    } else if (this.isContextual(127)) {
-      if (!this.hasFollowingLineBreak()) {
-        node.abstract = true;
-        this.raise(TSErrors.NonClassMethodPropertyHasAbstractModifer, {
-          at: node
-        });
-        return this.tsParseInterfaceDeclaration(node);
-      }
-    } else {
-      this.unexpected(null, 80);
+    if ((_typeCast = typeCast) != null && _typeCast.node) {
+      this.state = typeCast.failState;
+      return typeCast.node;
     }
+    if ((_jsx3 = jsx) != null && _jsx3.thrown) throw jsx.error;
+    if (arrow.thrown) throw arrow.error;
+    if ((_typeCast2 = typeCast) != null && _typeCast2.thrown) throw typeCast.error;
+    throw ((_jsx4 = jsx) == null ? void 0 : _jsx4.error) || arrow.error || ((_typeCast3 = typeCast) == null ? void 0 : _typeCast3.error);
   }
-  parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope) {
-    const method = super.parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope);
-    if (method.abstract) {
-      const hasBody = this.hasPlugin("estree") ? !!method.value.body : !!method.body;
-      if (hasBody) {
-        const {
-          key
-        } = method;
-        this.raise(TSErrors.AbstractMethodHasImplementation, {
-          at: method,
-          methodName: key.type === "Identifier" && !method.computed ? key.name : `[${this.input.slice(key.start, key.end)}]`
-        });
-      }
+  reportReservedArrowTypeParam(node) {
+    var _node$extra;
+    if (node.params.length === 1 && !node.params[0].constraint && !((_node$extra = node.extra) != null && _node$extra.trailingComma) && this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) {
+      this.raise(TSErrors.ReservedArrowTypeParam, {
+        at: node
+      });
     }
-    return method;
-  }
-  tsParseTypeParameterName() {
-    const typeName = this.parseIdentifier();
-    return typeName.name;
-  }
-  shouldParseAsAmbientContext() {
-    return !!this.getPluginOption("typescript", "dts");
   }
-  parse() {
-    if (this.shouldParseAsAmbientContext()) {
-      this.state.isAmbientContext = true;
+  parseMaybeUnary(refExpressionErrors, sawUnary) {
+    if (!this.hasPlugin("jsx") && this.match(47)) {
+      return this.tsParseTypeAssertion();
+    } else {
+      return super.parseMaybeUnary(refExpressionErrors, sawUnary);
     }
-    return super.parse();
   }
-  getExpression() {
-    if (this.shouldParseAsAmbientContext()) {
-      this.state.isAmbientContext = true;
+  parseArrow(node) {
+    if (this.match(14)) {
+      const result = this.tryParse(abort => {
+        const returnType = this.tsParseTypeOrTypePredicateAnnotation(14);
+        if (this.canInsertSemicolon() || !this.match(19)) abort();
+        return returnType;
+      });
+      if (result.aborted) return;
+      if (!result.thrown) {
+        if (result.error) this.state = result.failState;
+        node.returnType = result.node;
+      }
     }
-    return super.getExpression();
+    return super.parseArrow(node);
   }
-  parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly) {
-    if (!isString && isMaybeTypeOnly) {
-      this.parseTypeOnlyImportExportSpecifier(node, false, isInTypeExport);
-      return this.finishNode(node, "ExportSpecifier");
+  parseAssignableListItemTypes(param, flags) {
+    if (!(flags & ParseBindingListFlags.IS_FUNCTION_PARAMS)) return param;
+    if (this.eat(17)) {
+      param.optional = true;
     }
-    node.exportKind = "value";
-    return super.parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly);
+    const type = this.tsTryParseTypeAnnotation();
+    if (type) param.typeAnnotation = type;
+    this.resetEndLocation(param);
+    return param;
   }
-  parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {
-    if (!importedIsString && isMaybeTypeOnly) {
-      this.parseTypeOnlyImportExportSpecifier(specifier, true, isInTypeOnlyImport);
-      return this.finishNode(specifier, "ImportSpecifier");
+  isAssignable(node, isBinding) {
+    switch (node.type) {
+      case "TSTypeCastExpression":
+        return this.isAssignable(node.expression, isBinding);
+      case "TSParameterProperty":
+        return true;
+      default:
+        return super.isAssignable(node, isBinding);
     }
-    specifier.importKind = "value";
-    return super.parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, isInTypeOnlyImport ? BIND_TS_TYPE_IMPORT : BIND_FLAGS_TS_IMPORT);
   }
-  parseTypeOnlyImportExportSpecifier(node, isImport, isInTypeOnlyImportExport) {
-    const leftOfAsKey = isImport ? "imported" : "local";
-    const rightOfAsKey = isImport ? "local" : "exported";
-    let leftOfAs = node[leftOfAsKey];
-    let rightOfAs;
-    let hasTypeSpecifier = false;
-    let canParseAsKeyword = true;
-    const loc = leftOfAs.loc.start;
-    if (this.isContextual(93)) {
-      const firstAs = this.parseIdentifier();
-      if (this.isContextual(93)) {
-        const secondAs = this.parseIdentifier();
-        if (tokenIsKeywordOrIdentifier(this.state.type)) {
-          hasTypeSpecifier = true;
-          leftOfAs = firstAs;
-          rightOfAs = isImport ? this.parseIdentifier() : this.parseModuleExportName();
-          canParseAsKeyword = false;
+  toAssignable(node, isLHS = false) {
+    switch (node.type) {
+      case "ParenthesizedExpression":
+        this.toAssignableParenthesizedExpression(node, isLHS);
+        break;
+      case "TSAsExpression":
+      case "TSSatisfiesExpression":
+      case "TSNonNullExpression":
+      case "TSTypeAssertion":
+        if (isLHS) {
+          this.expressionScope.recordArrowParameterBindingError(TSErrors.UnexpectedTypeCastInParameter, {
+            at: node
+          });
         } else {
-          rightOfAs = secondAs;
-          canParseAsKeyword = false;
+          this.raise(TSErrors.UnexpectedTypeCastInParameter, {
+            at: node
+          });
         }
-      } else if (tokenIsKeywordOrIdentifier(this.state.type)) {
-        canParseAsKeyword = false;
-        rightOfAs = isImport ? this.parseIdentifier() : this.parseModuleExportName();
-      } else {
-        hasTypeSpecifier = true;
-        leftOfAs = firstAs;
-      }
-    } else if (tokenIsKeywordOrIdentifier(this.state.type)) {
-      hasTypeSpecifier = true;
-      if (isImport) {
-        leftOfAs = this.parseIdentifier(true);
-        if (!this.isContextual(93)) {
-          this.checkReservedWord(leftOfAs.name, leftOfAs.loc.start, true, true);
+        this.toAssignable(node.expression, isLHS);
+        break;
+      case "AssignmentExpression":
+        if (!isLHS && node.left.type === "TSTypeCastExpression") {
+          node.left = this.typeCastToParameter(node.left);
         }
-      } else {
-        leftOfAs = this.parseModuleExportName();
-      }
-    }
-    if (hasTypeSpecifier && isInTypeOnlyImportExport) {
-      this.raise(isImport ? TSErrors.TypeModifierIsUsedInTypeImports : TSErrors.TypeModifierIsUsedInTypeExports, {
-        at: loc
-      });
-    }
-    node[leftOfAsKey] = leftOfAs;
-    node[rightOfAsKey] = rightOfAs;
-    const kindKey = isImport ? "importKind" : "exportKind";
-    node[kindKey] = hasTypeSpecifier ? "type" : "value";
-    if (canParseAsKeyword && this.eatContextual(93)) {
-      node[rightOfAsKey] = isImport ? this.parseIdentifier() : this.parseModuleExportName();
-    }
-    if (!node[rightOfAsKey]) {
-      node[rightOfAsKey] = cloneIdentifier(node[leftOfAsKey]);
-    }
-    if (isImport) {
-      this.checkIdentifier(node[rightOfAsKey], hasTypeSpecifier ? BIND_TS_TYPE_IMPORT : BIND_FLAGS_TS_IMPORT);
+      default:
+        super.toAssignable(node, isLHS);
     }
   }
-});
-function isPossiblyLiteralEnum(expression) {
-  if (expression.type !== "MemberExpression") return false;
-  const {
-    computed,
-    property
-  } = expression;
-  if (computed && property.type !== "StringLiteral" && (property.type !== "TemplateLiteral" || property.expressions.length > 0)) {
-    return false;
-  }
-  return isUncomputedMemberExpressionChain(expression.object);
-}
-function isValidAmbientConstInitializer(expression, estree) {
-  var _expression$extra;
-  const {
-    type
-  } = expression;
-  if ((_expression$extra = expression.extra) != null && _expression$extra.parenthesized) {
-    return false;
-  }
-  if (estree) {
-    if (type === "Literal") {
-      const {
-        value
-      } = expression;
-      if (typeof value === "string" || typeof value === "boolean") {
-        return true;
-      }
-    }
-  } else {
-    if (type === "StringLiteral" || type === "BooleanLiteral") {
-      return true;
+  toAssignableParenthesizedExpression(node, isLHS) {
+    switch (node.expression.type) {
+      case "TSAsExpression":
+      case "TSSatisfiesExpression":
+      case "TSNonNullExpression":
+      case "TSTypeAssertion":
+      case "ParenthesizedExpression":
+        this.toAssignable(node.expression, isLHS);
+        break;
+      default:
+        super.toAssignable(node, isLHS);
     }
   }
-  if (isNumber(expression, estree) || isNegativeNumber(expression, estree)) {
-    return true;
-  }
-  if (type === "TemplateLiteral" && expression.expressions.length === 0) {
-    return true;
+  checkToRestConversion(node, allowPattern) {
+    switch (node.type) {
+      case "TSAsExpression":
+      case "TSSatisfiesExpression":
+      case "TSTypeAssertion":
+      case "TSNonNullExpression":
+        this.checkToRestConversion(node.expression, false);
+        break;
+      default:
+        super.checkToRestConversion(node, allowPattern);
+    }
   }
-  if (isPossiblyLiteralEnum(expression)) {
-    return true;
+  isValidLVal(type, isUnparenthesizedInAssign, binding) {
+    return getOwn({
+      TSTypeCastExpression: true,
+      TSParameterProperty: "parameter",
+      TSNonNullExpression: "expression",
+      TSAsExpression: (binding !== BIND_NONE || !isUnparenthesizedInAssign) && ["expression", true],
+      TSSatisfiesExpression: (binding !== BIND_NONE || !isUnparenthesizedInAssign) && ["expression", true],
+      TSTypeAssertion: (binding !== BIND_NONE || !isUnparenthesizedInAssign) && ["expression", true]
+    }, type) || super.isValidLVal(type, isUnparenthesizedInAssign, binding);
   }
-  return false;
-}
-function isNumber(expression, estree) {
-  if (estree) {
-    return expression.type === "Literal" && (typeof expression.value === "number" || "bigint" in expression);
-  } else {
-    return expression.type === "NumericLiteral" || expression.type === "BigIntLiteral";
+  parseBindingAtom() {
+    switch (this.state.type) {
+      case 78:
+        return this.parseIdentifier(true);
+      default:
+        return super.parseBindingAtom();
+    }
   }
-}
-function isNegativeNumber(expression, estree) {
-  if (expression.type === "UnaryExpression") {
-    const {
-      operator,
-      argument
-    } = expression;
-    if (operator === "-" && isNumber(argument, estree)) {
-      return true;
+  parseMaybeDecoratorArguments(expr) {
+    if (this.match(47) || this.match(51)) {
+      const typeArguments = this.tsParseTypeArgumentsInExpression();
+      if (this.match(10)) {
+        const call = super.parseMaybeDecoratorArguments(expr);
+        call.typeParameters = typeArguments;
+        return call;
+      }
+      this.unexpected(null, 10);
     }
+    return super.parseMaybeDecoratorArguments(expr);
   }
-  return false;
-}
-function isUncomputedMemberExpressionChain(expression) {
-  if (expression.type === "Identifier") return true;
-  if (expression.type !== "MemberExpression") return false;
-  if (expression.computed) return false;
-  return isUncomputedMemberExpressionChain(expression.object);
-}
-
-const PlaceholderErrors = ParseErrorEnum`placeholders`({
-  ClassNameIsRequired: "A class name is required.",
-  UnexpectedSpace: "Unexpected space in placeholder."
-});
-var placeholders = (superClass => class PlaceholdersParserMixin extends superClass {
-  parsePlaceholder(expectedNode) {
-    if (this.match(142)) {
-      const node = this.startNode();
+  checkCommaAfterRest(close) {
+    if (this.state.isAmbientContext && this.match(12) && this.lookaheadCharCode() === close) {
       this.next();
-      this.assertNoSpace();
-      node.name = super.parseIdentifier(true);
-      this.assertNoSpace();
-      this.expect(142);
-      return this.finishPlaceholder(node, expectedNode);
+      return false;
+    } else {
+      return super.checkCommaAfterRest(close);
     }
   }
-  finishPlaceholder(node, expectedNode) {
-    const isFinished = !!(node.expectedNode && node.type === "Placeholder");
-    node.expectedNode = expectedNode;
-    return isFinished ? node : this.finishNode(node, "Placeholder");
+  isClassMethod() {
+    return this.match(47) || super.isClassMethod();
+  }
+  isClassProperty() {
+    return this.match(35) || this.match(14) || super.isClassProperty();
+  }
+  parseMaybeDefault(startLoc, left) {
+    const node = super.parseMaybeDefault(startLoc, left);
+    if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) {
+      this.raise(TSErrors.TypeAnnotationAfterAssign, {
+        at: node.typeAnnotation
+      });
+    }
+    return node;
   }
   getTokenFromCode(code) {
-    if (code === 37 && this.input.charCodeAt(this.state.pos + 1) === 37) {
-      return this.finishOp(142, 2);
+    if (this.state.inType) {
+      if (code === 62) {
+        return this.finishOp(48, 1);
+      }
+      if (code === 60) {
+        return this.finishOp(47, 1);
+      }
     }
     return super.getTokenFromCode(code);
   }
-  parseExprAtom(refExpressionErrors) {
-    return this.parsePlaceholder("Expression") || super.parseExprAtom(refExpressionErrors);
-  }
-  parseIdentifier(liberal) {
-    return this.parsePlaceholder("Identifier") || super.parseIdentifier(liberal);
+  reScan_lt_gt() {
+    const {
+      type
+    } = this.state;
+    if (type === 47) {
+      this.state.pos -= 1;
+      this.readToken_lt();
+    } else if (type === 48) {
+      this.state.pos -= 1;
+      this.readToken_gt();
+    }
   }
-  checkReservedWord(word, startLoc, checkKeywords, isBinding) {
-    if (word !== undefined) {
-      super.checkReservedWord(word, startLoc, checkKeywords, isBinding);
+  reScan_lt() {
+    const {
+      type
+    } = this.state;
+    if (type === 51) {
+      this.state.pos -= 2;
+      this.finishOp(47, 1);
+      return 47;
     }
+    return type;
   }
-  parseBindingAtom() {
-    return this.parsePlaceholder("Pattern") || super.parseBindingAtom();
+  toAssignableList(exprList, trailingCommaLoc, isLHS) {
+    for (let i = 0; i < exprList.length; i++) {
+      const expr = exprList[i];
+      if ((expr == null ? void 0 : expr.type) === "TSTypeCastExpression") {
+        exprList[i] = this.typeCastToParameter(expr);
+      }
+    }
+    super.toAssignableList(exprList, trailingCommaLoc, isLHS);
   }
-  isValidLVal(type, isParenthesized, binding) {
-    return type === "Placeholder" || super.isValidLVal(type, isParenthesized, binding);
+  typeCastToParameter(node) {
+    node.expression.typeAnnotation = node.typeAnnotation;
+    this.resetEndLocation(node.expression, node.typeAnnotation.loc.end);
+    return node.expression;
   }
-  toAssignable(node, isLHS) {
-    if (node && node.type === "Placeholder" && node.expectedNode === "Expression") {
-      node.expectedNode = "Pattern";
-    } else {
-      super.toAssignable(node, isLHS);
+  shouldParseArrow(params) {
+    if (this.match(14)) {
+      return params.every(expr => this.isAssignable(expr, true));
     }
+    return super.shouldParseArrow(params);
   }
-  chStartsBindingIdentifier(ch, pos) {
-    if (super.chStartsBindingIdentifier(ch, pos)) {
-      return true;
-    }
-    const nextToken = this.lookahead();
-    if (nextToken.type === 142) {
-      return true;
-    }
-    return false;
+  shouldParseAsyncArrow() {
+    return this.match(14) || super.shouldParseAsyncArrow();
   }
-  verifyBreakContinue(node, isBreak) {
-    if (node.label && node.label.type === "Placeholder") return;
-    super.verifyBreakContinue(node, isBreak);
+  canHaveLeadingDecorator() {
+    return super.canHaveLeadingDecorator() || this.isAbstractClass();
   }
-  parseExpressionStatement(node, expr) {
-    if (expr.type !== "Placeholder" || expr.extra && expr.extra.parenthesized) {
-      return super.parseExpressionStatement(node, expr);
-    }
-    if (this.match(14)) {
-      const stmt = node;
-      stmt.label = this.finishPlaceholder(expr, "Identifier");
-      this.next();
-      stmt.body = super.parseStatementOrFunctionDeclaration(false);
-      return this.finishNode(stmt, "LabeledStatement");
+  jsxParseOpeningElementAfterName(node) {
+    if (this.match(47) || this.match(51)) {
+      const typeArguments = this.tsTryParseAndCatch(() => this.tsParseTypeArgumentsInExpression());
+      if (typeArguments) node.typeParameters = typeArguments;
     }
-    this.semicolon();
-    node.name = expr.name;
-    return this.finishPlaceholder(node, "Statement");
+    return super.jsxParseOpeningElementAfterName(node);
   }
-  parseBlock(allowDirectives, createNewLexicalScope, afterBlockParse) {
-    return this.parsePlaceholder("BlockStatement") || super.parseBlock(allowDirectives, createNewLexicalScope, afterBlockParse);
+  getGetterSetterExpectedParamCount(method) {
+    const baseCount = super.getGetterSetterExpectedParamCount(method);
+    const params = this.getObjectOrClassMethodParams(method);
+    const firstParam = params[0];
+    const hasContextParam = firstParam && this.isThisParam(firstParam);
+    return hasContextParam ? baseCount + 1 : baseCount;
   }
-  parseFunctionId(requireId) {
-    return this.parsePlaceholder("Identifier") || super.parseFunctionId(requireId);
+  parseCatchClauseParam() {
+    const param = super.parseCatchClauseParam();
+    const type = this.tsTryParseTypeAnnotation();
+    if (type) {
+      param.typeAnnotation = type;
+      this.resetEndLocation(param);
+    }
+    return param;
+  }
+  tsInAmbientContext(cb) {
+    const oldIsAmbientContext = this.state.isAmbientContext;
+    this.state.isAmbientContext = true;
+    try {
+      return cb();
+    } finally {
+      this.state.isAmbientContext = oldIsAmbientContext;
+    }
   }
   parseClass(node, isStatement, optionalId) {
-    const type = isStatement ? "ClassDeclaration" : "ClassExpression";
-    this.next();
-    const oldStrict = this.state.strict;
-    const placeholder = this.parsePlaceholder("Identifier");
-    if (placeholder) {
-      if (this.match(81) || this.match(142) || this.match(5)) {
-        node.id = placeholder;
-      } else if (optionalId || !isStatement) {
-        node.id = null;
-        node.body = this.finishPlaceholder(placeholder, "ClassBody");
-        return this.finishNode(node, type);
-      } else {
-        throw this.raise(PlaceholderErrors.ClassNameIsRequired, {
-          at: this.state.startLoc
+    const oldInAbstractClass = this.state.inAbstractClass;
+    this.state.inAbstractClass = !!node.abstract;
+    try {
+      return super.parseClass(node, isStatement, optionalId);
+    } finally {
+      this.state.inAbstractClass = oldInAbstractClass;
+    }
+  }
+  tsParseAbstractDeclaration(node, decorators) {
+    if (this.match(80)) {
+      node.abstract = true;
+      return this.maybeTakeDecorators(decorators, this.parseClass(node, true, false));
+    } else if (this.isContextual(127)) {
+      if (!this.hasFollowingLineBreak()) {
+        node.abstract = true;
+        this.raise(TSErrors.NonClassMethodPropertyHasAbstractModifer, {
+          at: node
         });
+        return this.tsParseInterfaceDeclaration(node);
       }
     } else {
-      this.parseClassId(node, isStatement, optionalId);
-    }
-    super.parseClassSuper(node);
-    node.body = this.parsePlaceholder("ClassBody") || super.parseClassBody(!!node.superClass, oldStrict);
-    return this.finishNode(node, type);
-  }
-  parseExport(node, decorators) {
-    const placeholder = this.parsePlaceholder("Identifier");
-    if (!placeholder) return super.parseExport(node, decorators);
-    if (!this.isContextual(97) && !this.match(12)) {
-      node.specifiers = [];
-      node.source = null;
-      node.declaration = this.finishPlaceholder(placeholder, "Declaration");
-      return this.finishNode(node, "ExportNamedDeclaration");
+      this.unexpected(null, 80);
     }
-    this.expectPlugin("exportDefaultFrom");
-    const specifier = this.startNode();
-    specifier.exported = placeholder;
-    node.specifiers = [this.finishNode(specifier, "ExportDefaultSpecifier")];
-    return super.parseExport(node, decorators);
   }
-  isExportDefaultSpecifier() {
-    if (this.match(65)) {
-      const next = this.nextTokenStart();
-      if (this.isUnparsedContextual(next, "from")) {
-        if (this.input.startsWith(tokenLabelName(142), this.nextTokenStartSince(next + 4))) {
-          return true;
-        }
+  parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope) {
+    const method = super.parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope);
+    if (method.abstract) {
+      const hasBody = this.hasPlugin("estree") ? !!method.value.body : !!method.body;
+      if (hasBody) {
+        const {
+          key
+        } = method;
+        this.raise(TSErrors.AbstractMethodHasImplementation, {
+          at: method,
+          methodName: key.type === "Identifier" && !method.computed ? key.name : `[${this.input.slice(key.start, key.end)}]`
+        });
       }
     }
-    return super.isExportDefaultSpecifier();
+    return method;
   }
-  maybeParseExportDefaultSpecifier(node) {
-    if (node.specifiers && node.specifiers.length > 0) {
-      return true;
-    }
-    return super.maybeParseExportDefaultSpecifier(node);
+  tsParseTypeParameterName() {
+    const typeName = this.parseIdentifier();
+    return typeName.name;
   }
-  checkExport(node) {
-    const {
-      specifiers
-    } = node;
-    if (specifiers != null && specifiers.length) {
-      node.specifiers = specifiers.filter(node => node.exported.type === "Placeholder");
-    }
-    super.checkExport(node);
-    node.specifiers = specifiers;
+  shouldParseAsAmbientContext() {
+    return !!this.getPluginOption("typescript", "dts");
   }
-  parseImport(node) {
-    const placeholder = this.parsePlaceholder("Identifier");
-    if (!placeholder) return super.parseImport(node);
-    node.specifiers = [];
-    if (!this.isContextual(97) && !this.match(12)) {
-      node.source = this.finishPlaceholder(placeholder, "StringLiteral");
-      this.semicolon();
-      return this.finishNode(node, "ImportDeclaration");
-    }
-    const specifier = this.startNodeAtNode(placeholder);
-    specifier.local = placeholder;
-    node.specifiers.push(this.finishNode(specifier, "ImportDefaultSpecifier"));
-    if (this.eat(12)) {
-      const hasStarImport = this.maybeParseStarImportSpecifier(node);
-      if (!hasStarImport) this.parseNamedImportSpecifiers(node);
+  parse() {
+    if (this.shouldParseAsAmbientContext()) {
+      this.state.isAmbientContext = true;
     }
-    this.expectContextual(97);
-    node.source = this.parseImportSource();
-    this.semicolon();
-    return this.finishNode(node, "ImportDeclaration");
-  }
-  parseImportSource() {
-    return this.parsePlaceholder("StringLiteral") || super.parseImportSource();
+    return super.parse();
   }
-  assertNoSpace() {
-    if (this.state.start > this.state.lastTokEndLoc.index) {
-      this.raise(PlaceholderErrors.UnexpectedSpace, {
-        at: this.state.lastTokEndLoc
-      });
+  getExpression() {
+    if (this.shouldParseAsAmbientContext()) {
+      this.state.isAmbientContext = true;
     }
+    return super.getExpression();
   }
-});
-
-var v8intrinsic = (superClass => class V8IntrinsicMixin extends superClass {
-  parseV8Intrinsic() {
-    if (this.match(54)) {
-      const v8IntrinsicStartLoc = this.state.startLoc;
-      const node = this.startNode();
-      this.next();
-      if (tokenIsIdentifier(this.state.type)) {
-        const name = this.parseIdentifierName();
-        const identifier = this.createIdentifier(node, name);
-        identifier.type = "V8IntrinsicIdentifier";
-        if (this.match(10)) {
-          return identifier;
-        }
-      }
-      this.unexpected(v8IntrinsicStartLoc);
+  parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly) {
+    if (!isString && isMaybeTypeOnly) {
+      this.parseTypeOnlyImportExportSpecifier(node, false, isInTypeExport);
+      return this.finishNode(node, "ExportSpecifier");
     }
+    node.exportKind = "value";
+    return super.parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly);
   }
-  parseExprAtom(refExpressionErrors) {
-    return this.parseV8Intrinsic() || super.parseExprAtom(refExpressionErrors);
+  parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {
+    if (!importedIsString && isMaybeTypeOnly) {
+      this.parseTypeOnlyImportExportSpecifier(specifier, true, isInTypeOnlyImport);
+      return this.finishNode(specifier, "ImportSpecifier");
+    }
+    specifier.importKind = "value";
+    return super.parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, isInTypeOnlyImport ? BIND_TS_TYPE_IMPORT : BIND_FLAGS_TS_IMPORT);
   }
-});
-
-function hasPlugin(plugins, expectedConfig) {
-  const [expectedName, expectedOptions] = typeof expectedConfig === "string" ? [expectedConfig, {}] : expectedConfig;
-  const expectedKeys = Object.keys(expectedOptions);
-  const expectedOptionsIsEmpty = expectedKeys.length === 0;
-  return plugins.some(p => {
-    if (typeof p === "string") {
-      return expectedOptionsIsEmpty && p === expectedName;
-    } else {
-      const [pluginName, pluginOptions] = p;
-      if (pluginName !== expectedName) {
-        return false;
+  parseTypeOnlyImportExportSpecifier(node, isImport, isInTypeOnlyImportExport) {
+    const leftOfAsKey = isImport ? "imported" : "local";
+    const rightOfAsKey = isImport ? "local" : "exported";
+    let leftOfAs = node[leftOfAsKey];
+    let rightOfAs;
+    let hasTypeSpecifier = false;
+    let canParseAsKeyword = true;
+    const loc = leftOfAs.loc.start;
+    if (this.isContextual(93)) {
+      const firstAs = this.parseIdentifier();
+      if (this.isContextual(93)) {
+        const secondAs = this.parseIdentifier();
+        if (tokenIsKeywordOrIdentifier(this.state.type)) {
+          hasTypeSpecifier = true;
+          leftOfAs = firstAs;
+          rightOfAs = isImport ? this.parseIdentifier() : this.parseModuleExportName();
+          canParseAsKeyword = false;
+        } else {
+          rightOfAs = secondAs;
+          canParseAsKeyword = false;
+        }
+      } else if (tokenIsKeywordOrIdentifier(this.state.type)) {
+        canParseAsKeyword = false;
+        rightOfAs = isImport ? this.parseIdentifier() : this.parseModuleExportName();
+      } else {
+        hasTypeSpecifier = true;
+        leftOfAs = firstAs;
       }
-      for (const key of expectedKeys) {
-        if (pluginOptions[key] !== expectedOptions[key]) {
-          return false;
+    } else if (tokenIsKeywordOrIdentifier(this.state.type)) {
+      hasTypeSpecifier = true;
+      if (isImport) {
+        leftOfAs = this.parseIdentifier(true);
+        if (!this.isContextual(93)) {
+          this.checkReservedWord(leftOfAs.name, leftOfAs.loc.start, true, true);
         }
+      } else {
+        leftOfAs = this.parseModuleExportName();
       }
-      return true;
     }
-  });
-}
-function getPluginOption(plugins, name, option) {
-  const plugin = plugins.find(plugin => {
-    if (Array.isArray(plugin)) {
-      return plugin[0] === name;
-    } else {
-      return plugin === name;
+    if (hasTypeSpecifier && isInTypeOnlyImportExport) {
+      this.raise(isImport ? TSErrors.TypeModifierIsUsedInTypeImports : TSErrors.TypeModifierIsUsedInTypeExports, {
+        at: loc
+      });
     }
-  });
-  if (plugin && Array.isArray(plugin) && plugin.length > 1) {
-    return plugin[1][option];
-  }
-  return null;
-}
-const PIPELINE_PROPOSALS = ["minimal", "fsharp", "hack", "smart"];
-const TOPIC_TOKENS = ["^^", "@@", "^", "%", "#"];
-const RECORD_AND_TUPLE_SYNTAX_TYPES = ["hash", "bar"];
-function validatePlugins(plugins) {
-  if (hasPlugin(plugins, "decorators")) {
-    if (hasPlugin(plugins, "decorators-legacy")) {
-      throw new Error("Cannot use the decorators and decorators-legacy plugin together");
+    node[leftOfAsKey] = leftOfAs;
+    node[rightOfAsKey] = rightOfAs;
+    const kindKey = isImport ? "importKind" : "exportKind";
+    node[kindKey] = hasTypeSpecifier ? "type" : "value";
+    if (canParseAsKeyword && this.eatContextual(93)) {
+      node[rightOfAsKey] = isImport ? this.parseIdentifier() : this.parseModuleExportName();
     }
-    const decoratorsBeforeExport = getPluginOption(plugins, "decorators", "decoratorsBeforeExport");
-    if (decoratorsBeforeExport != null && typeof decoratorsBeforeExport !== "boolean") {
-      throw new Error("'decoratorsBeforeExport' must be a boolean.");
+    if (!node[rightOfAsKey]) {
+      node[rightOfAsKey] = cloneIdentifier(node[leftOfAsKey]);
     }
-    const allowCallParenthesized = getPluginOption(plugins, "decorators", "allowCallParenthesized");
-    if (allowCallParenthesized != null && typeof allowCallParenthesized !== "boolean") {
-      throw new Error("'allowCallParenthesized' must be a boolean.");
+    if (isImport) {
+      this.checkIdentifier(node[rightOfAsKey], hasTypeSpecifier ? BIND_TS_TYPE_IMPORT : BIND_FLAGS_TS_IMPORT);
     }
   }
-  if (hasPlugin(plugins, "flow") && hasPlugin(plugins, "typescript")) {
-    throw new Error("Cannot combine flow and typescript plugins.");
+});
+function isPossiblyLiteralEnum(expression) {
+  if (expression.type !== "MemberExpression") return false;
+  const {
+    computed,
+    property
+  } = expression;
+  if (computed && property.type !== "StringLiteral" && (property.type !== "TemplateLiteral" || property.expressions.length > 0)) {
+    return false;
   }
-  if (hasPlugin(plugins, "placeholders") && hasPlugin(plugins, "v8intrinsic")) {
-    throw new Error("Cannot combine placeholders and v8intrinsic plugins.");
+  return isUncomputedMemberExpressionChain(expression.object);
+}
+function isValidAmbientConstInitializer(expression, estree) {
+  var _expression$extra;
+  const {
+    type
+  } = expression;
+  if ((_expression$extra = expression.extra) != null && _expression$extra.parenthesized) {
+    return false;
   }
-  if (hasPlugin(plugins, "pipelineOperator")) {
-    const proposal = getPluginOption(plugins, "pipelineOperator", "proposal");
-    if (!PIPELINE_PROPOSALS.includes(proposal)) {
-      const proposalList = PIPELINE_PROPOSALS.map(p => `"${p}"`).join(", ");
-      throw new Error(`"pipelineOperator" requires "proposal" option whose value must be one of: ${proposalList}.`);
-    }
-    const tupleSyntaxIsHash = hasPlugin(plugins, ["recordAndTuple", {
-      syntaxType: "hash"
-    }]);
-    if (proposal === "hack") {
-      if (hasPlugin(plugins, "placeholders")) {
-        throw new Error("Cannot combine placeholders plugin and Hack-style pipes.");
-      }
-      if (hasPlugin(plugins, "v8intrinsic")) {
-        throw new Error("Cannot combine v8intrinsic plugin and Hack-style pipes.");
-      }
-      const topicToken = getPluginOption(plugins, "pipelineOperator", "topicToken");
-      if (!TOPIC_TOKENS.includes(topicToken)) {
-        const tokenList = TOPIC_TOKENS.map(t => `"${t}"`).join(", ");
-        throw new Error(`"pipelineOperator" in "proposal": "hack" mode also requires a "topicToken" option whose value must be one of: ${tokenList}.`);
-      }
-      if (topicToken === "#" && tupleSyntaxIsHash) {
-        throw new Error('Plugin conflict between `["pipelineOperator", { proposal: "hack", topicToken: "#" }]` and `["recordAndtuple", { syntaxType: "hash"}]`.');
+  if (estree) {
+    if (type === "Literal") {
+      const {
+        value
+      } = expression;
+      if (typeof value === "string" || typeof value === "boolean") {
+        return true;
       }
-    } else if (proposal === "smart" && tupleSyntaxIsHash) {
-      throw new Error('Plugin conflict between `["pipelineOperator", { proposal: "smart" }]` and `["recordAndtuple", { syntaxType: "hash"}]`.');
     }
-  }
-  if (hasPlugin(plugins, "moduleAttributes")) {
-    {
-      if (hasPlugin(plugins, "importAssertions")) {
-        throw new Error("Cannot combine importAssertions and moduleAttributes plugins.");
-      }
-      const moduleAttributesVersionPluginOption = getPluginOption(plugins, "moduleAttributes", "version");
-      if (moduleAttributesVersionPluginOption !== "may-2020") {
-        throw new Error("The 'moduleAttributes' plugin requires a 'version' option," + " representing the last proposal update. Currently, the" + " only supported value is 'may-2020'.");
-      }
+  } else {
+    if (type === "StringLiteral" || type === "BooleanLiteral") {
+      return true;
     }
   }
-  if (hasPlugin(plugins, "recordAndTuple") && getPluginOption(plugins, "recordAndTuple", "syntaxType") != null && !RECORD_AND_TUPLE_SYNTAX_TYPES.includes(getPluginOption(plugins, "recordAndTuple", "syntaxType"))) {
-    throw new Error("The 'syntaxType' option of the 'recordAndTuple' plugin must be one of: " + RECORD_AND_TUPLE_SYNTAX_TYPES.map(p => `'${p}'`).join(", "));
+  if (isNumber(expression, estree) || isNegativeNumber(expression, estree)) {
+    return true;
+  }
+  if (type === "TemplateLiteral" && expression.expressions.length === 0) {
+    return true;
   }
-  if (hasPlugin(plugins, "asyncDoExpressions") && !hasPlugin(plugins, "doExpressions")) {
-    const error = new Error("'asyncDoExpressions' requires 'doExpressions', please add 'doExpressions' to parser plugins.");
-    error.missingPlugins = "doExpressions";
-    throw error;
+  if (isPossiblyLiteralEnum(expression)) {
+    return true;
   }
+  return false;
 }
-const mixinPlugins = {
-  estree,
-  jsx,
-  flow,
-  typescript,
-  v8intrinsic,
-  placeholders
-};
-const mixinPluginNames = Object.keys(mixinPlugins);
-
-const defaultOptions = {
-  sourceType: "script",
-  sourceFilename: undefined,
-  startColumn: 0,
-  startLine: 1,
-  allowAwaitOutsideFunction: false,
-  allowReturnOutsideFunction: false,
-  allowImportExportEverywhere: false,
-  allowSuperOutsideMethod: false,
-  allowUndeclaredExports: false,
-  plugins: [],
-  strictMode: null,
-  ranges: false,
-  tokens: false,
-  createParenthesizedExpressions: false,
-  errorRecovery: false,
-  attachComment: true
-};
-function getOptions(opts) {
-  const options = {};
-  for (const key of Object.keys(defaultOptions)) {
-    options[key] = opts && opts[key] != null ? opts[key] : defaultOptions[key];
+function isNumber(expression, estree) {
+  if (estree) {
+    return expression.type === "Literal" && (typeof expression.value === "number" || "bigint" in expression);
+  } else {
+    return expression.type === "NumericLiteral" || expression.type === "BigIntLiteral";
   }
-  return options;
 }
-
-const getOwn = (object, key) => Object.hasOwnProperty.call(object, key) && object[key];
-const unwrapParenthesizedExpression = node => {
-  return node.type === "ParenthesizedExpression" ? unwrapParenthesizedExpression(node.expression) : node;
-};
-class LValParser extends NodeUtils {
-  toAssignable(node, isLHS = false) {
-    var _node$extra, _node$extra3;
-    let parenthesized = undefined;
-    if (node.type === "ParenthesizedExpression" || (_node$extra = node.extra) != null && _node$extra.parenthesized) {
-      parenthesized = unwrapParenthesizedExpression(node);
-      if (isLHS) {
-        if (parenthesized.type === "Identifier") {
-          this.expressionScope.recordArrowParameterBindingError(Errors.InvalidParenthesizedAssignment, {
-            at: node
-          });
-        } else if (parenthesized.type !== "MemberExpression") {
-          this.raise(Errors.InvalidParenthesizedAssignment, {
-            at: node
-          });
-        }
-      } else {
-        this.raise(Errors.InvalidParenthesizedAssignment, {
-          at: node
-        });
-      }
+function isNegativeNumber(expression, estree) {
+  if (expression.type === "UnaryExpression") {
+    const {
+      operator,
+      argument
+    } = expression;
+    if (operator === "-" && isNumber(argument, estree)) {
+      return true;
     }
-    switch (node.type) {
-      case "Identifier":
-      case "ObjectPattern":
-      case "ArrayPattern":
-      case "AssignmentPattern":
-      case "RestElement":
-        break;
-      case "ObjectExpression":
-        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, isLast, isLHS);
-          if (isLast && prop.type === "RestElement" && (_node$extra2 = node.extra) != null && _node$extra2.trailingCommaLoc) {
-            this.raise(Errors.RestTrailingComma, {
-              at: node.extra.trailingCommaLoc
-            });
-          }
-        }
-        break;
-      case "ObjectProperty":
-        {
-          const {
-            key,
-            value
-          } = node;
-          if (this.isPrivateName(key)) {
-            this.classScope.usePrivateName(this.getPrivateNameSV(key), key.loc.start);
-          }
-          this.toAssignable(value, isLHS);
-          break;
-        }
-      case "SpreadElement":
-        {
-          throw new Error("Internal @babel/parser error (this is a bug, please report it)." + " SpreadElement should be converted by .toAssignable's caller.");
-        }
-      case "ArrayExpression":
-        node.type = "ArrayPattern";
-        this.toAssignableList(node.elements, (_node$extra3 = node.extra) == null ? void 0 : _node$extra3.trailingCommaLoc, isLHS);
-        break;
-      case "AssignmentExpression":
-        if (node.operator !== "=") {
-          this.raise(Errors.MissingEqInAssignment, {
-            at: node.left.loc.end
-          });
-        }
-        node.type = "AssignmentPattern";
-        delete node.operator;
-        this.toAssignable(node.left, isLHS);
-        break;
-      case "ParenthesizedExpression":
-        this.toAssignable(parenthesized, isLHS);
-        break;
+  }
+  return false;
+}
+function isUncomputedMemberExpressionChain(expression) {
+  if (expression.type === "Identifier") return true;
+  if (expression.type !== "MemberExpression") return false;
+  if (expression.computed) return false;
+  return isUncomputedMemberExpressionChain(expression.object);
+}
+
+const PlaceholderErrors = ParseErrorEnum`placeholders`({
+  ClassNameIsRequired: "A class name is required.",
+  UnexpectedSpace: "Unexpected space in placeholder."
+});
+var placeholders = (superClass => class PlaceholdersParserMixin extends superClass {
+  parsePlaceholder(expectedNode) {
+    if (this.match(142)) {
+      const node = this.startNode();
+      this.next();
+      this.assertNoSpace();
+      node.name = super.parseIdentifier(true);
+      this.assertNoSpace();
+      this.expect(142);
+      return this.finishPlaceholder(node, expectedNode);
     }
   }
-  toAssignableObjectExpressionProp(prop, isLast, isLHS) {
-    if (prop.type === "ObjectMethod") {
-      this.raise(prop.kind === "get" || prop.kind === "set" ? Errors.PatternHasAccessor : Errors.PatternHasMethod, {
-        at: prop.key
-      });
-    } else if (prop.type === "SpreadElement") {
-      prop.type = "RestElement";
-      const arg = prop.argument;
-      this.checkToRestConversion(arg, false);
-      this.toAssignable(arg, isLHS);
-      if (!isLast) {
-        this.raise(Errors.RestTrailingComma, {
-          at: prop
-        });
-      }
-    } else {
-      this.toAssignable(prop, isLHS);
+  finishPlaceholder(node, expectedNode) {
+    const isFinished = !!(node.expectedNode && node.type === "Placeholder");
+    node.expectedNode = expectedNode;
+    return isFinished ? node : this.finishNode(node, "Placeholder");
+  }
+  getTokenFromCode(code) {
+    if (code === 37 && this.input.charCodeAt(this.state.pos + 1) === 37) {
+      return this.finishOp(142, 2);
     }
+    return super.getTokenFromCode(code);
   }
-  toAssignableList(exprList, trailingCommaLoc, isLHS) {
-    const end = exprList.length - 1;
-    for (let i = 0; i <= end; i++) {
-      const elt = exprList[i];
-      if (!elt) continue;
-      if (elt.type === "SpreadElement") {
-        elt.type = "RestElement";
-        const arg = elt.argument;
-        this.checkToRestConversion(arg, true);
-        this.toAssignable(arg, isLHS);
-      } else {
-        this.toAssignable(elt, isLHS);
-      }
-      if (elt.type === "RestElement") {
-        if (i < end) {
-          this.raise(Errors.RestTrailingComma, {
-            at: elt
-          });
-        } else if (trailingCommaLoc) {
-          this.raise(Errors.RestTrailingComma, {
-            at: trailingCommaLoc
-          });
-        }
-      }
+  parseExprAtom(refExpressionErrors) {
+    return this.parsePlaceholder("Expression") || super.parseExprAtom(refExpressionErrors);
+  }
+  parseIdentifier(liberal) {
+    return this.parsePlaceholder("Identifier") || super.parseIdentifier(liberal);
+  }
+  checkReservedWord(word, startLoc, checkKeywords, isBinding) {
+    if (word !== undefined) {
+      super.checkReservedWord(word, startLoc, checkKeywords, isBinding);
     }
   }
-  isAssignable(node, isBinding) {
-    switch (node.type) {
-      case "Identifier":
-      case "ObjectPattern":
-      case "ArrayPattern":
-      case "AssignmentPattern":
-      case "RestElement":
-        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 => element === null || this.isAssignable(element));
-      case "AssignmentExpression":
-        return node.operator === "=";
-      case "ParenthesizedExpression":
-        return this.isAssignable(node.expression);
-      case "MemberExpression":
-      case "OptionalMemberExpression":
-        return !isBinding;
-      default:
-        return false;
+  parseBindingAtom() {
+    return this.parsePlaceholder("Pattern") || super.parseBindingAtom();
+  }
+  isValidLVal(type, isParenthesized, binding) {
+    return type === "Placeholder" || super.isValidLVal(type, isParenthesized, binding);
+  }
+  toAssignable(node, isLHS) {
+    if (node && node.type === "Placeholder" && node.expectedNode === "Expression") {
+      node.expectedNode = "Pattern";
+    } else {
+      super.toAssignable(node, isLHS);
     }
   }
-  toReferencedList(exprList, isParenthesizedExpr) {
-    return exprList;
+  chStartsBindingIdentifier(ch, pos) {
+    if (super.chStartsBindingIdentifier(ch, pos)) {
+      return true;
+    }
+    const nextToken = this.lookahead();
+    if (nextToken.type === 142) {
+      return true;
+    }
+    return false;
   }
-  toReferencedListDeep(exprList, isParenthesizedExpr) {
-    this.toReferencedList(exprList, isParenthesizedExpr);
-    for (const expr of exprList) {
-      if ((expr == null ? void 0 : expr.type) === "ArrayExpression") {
-        this.toReferencedListDeep(expr.elements);
-      }
+  verifyBreakContinue(node, isBreak) {
+    if (node.label && node.label.type === "Placeholder") return;
+    super.verifyBreakContinue(node, isBreak);
+  }
+  parseExpressionStatement(node, expr) {
+    if (expr.type !== "Placeholder" || expr.extra && expr.extra.parenthesized) {
+      return super.parseExpressionStatement(node, expr);
+    }
+    if (this.match(14)) {
+      const stmt = node;
+      stmt.label = this.finishPlaceholder(expr, "Identifier");
+      this.next();
+      stmt.body = super.parseStatementOrSloppyAnnexBFunctionDeclaration();
+      return this.finishNode(stmt, "LabeledStatement");
     }
+    this.semicolon();
+    node.name = expr.name;
+    return this.finishPlaceholder(node, "Statement");
   }
-  parseSpread(refExpressionErrors) {
-    const node = this.startNode();
-    this.next();
-    node.argument = this.parseMaybeAssignAllowIn(refExpressionErrors, undefined);
-    return this.finishNode(node, "SpreadElement");
+  parseBlock(allowDirectives, createNewLexicalScope, afterBlockParse) {
+    return this.parsePlaceholder("BlockStatement") || super.parseBlock(allowDirectives, createNewLexicalScope, afterBlockParse);
   }
-  parseRestBinding() {
-    const node = this.startNode();
+  parseFunctionId(requireId) {
+    return this.parsePlaceholder("Identifier") || super.parseFunctionId(requireId);
+  }
+  parseClass(node, isStatement, optionalId) {
+    const type = isStatement ? "ClassDeclaration" : "ClassExpression";
     this.next();
-    node.argument = this.parseBindingAtom();
-    return this.finishNode(node, "RestElement");
+    const oldStrict = this.state.strict;
+    const placeholder = this.parsePlaceholder("Identifier");
+    if (placeholder) {
+      if (this.match(81) || this.match(142) || this.match(5)) {
+        node.id = placeholder;
+      } else if (optionalId || !isStatement) {
+        node.id = null;
+        node.body = this.finishPlaceholder(placeholder, "ClassBody");
+        return this.finishNode(node, type);
+      } else {
+        throw this.raise(PlaceholderErrors.ClassNameIsRequired, {
+          at: this.state.startLoc
+        });
+      }
+    } else {
+      this.parseClassId(node, isStatement, optionalId);
+    }
+    super.parseClassSuper(node);
+    node.body = this.parsePlaceholder("ClassBody") || super.parseClassBody(!!node.superClass, oldStrict);
+    return this.finishNode(node, type);
   }
-  parseBindingAtom() {
-    switch (this.state.type) {
-      case 0:
-        {
-          const node = this.startNode();
-          this.next();
-          node.elements = this.parseBindingList(3, 93, true);
-          return this.finishNode(node, "ArrayPattern");
-        }
-      case 5:
-        return this.parseObjectLike(8, true);
+  parseExport(node, decorators) {
+    const placeholder = this.parsePlaceholder("Identifier");
+    if (!placeholder) return super.parseExport(node, decorators);
+    if (!this.isContextual(97) && !this.match(12)) {
+      node.specifiers = [];
+      node.source = null;
+      node.declaration = this.finishPlaceholder(placeholder, "Declaration");
+      return this.finishNode(node, "ExportNamedDeclaration");
     }
-    return this.parseIdentifier();
+    this.expectPlugin("exportDefaultFrom");
+    const specifier = this.startNode();
+    specifier.exported = placeholder;
+    node.specifiers = [this.finishNode(specifier, "ExportDefaultSpecifier")];
+    return super.parseExport(node, decorators);
   }
-  parseBindingList(close, closeCharCode, allowEmpty, allowModifiers) {
-    const elts = [];
-    let first = true;
-    while (!this.eat(close)) {
-      if (first) {
-        first = false;
-      } else {
-        this.expect(12);
-      }
-      if (allowEmpty && this.match(12)) {
-        elts.push(null);
-      } else if (this.eat(close)) {
-        break;
-      } else if (this.match(21)) {
-        elts.push(this.parseAssignableListItemTypes(this.parseRestBinding()));
-        if (!this.checkCommaAfterRest(closeCharCode)) {
-          this.expect(close);
-          break;
-        }
-      } else {
-        const decorators = [];
-        if (this.match(26) && this.hasPlugin("decorators")) {
-          this.raise(Errors.UnsupportedParameterDecorator, {
-            at: this.state.startLoc
-          });
-        }
-        while (this.match(26)) {
-          decorators.push(this.parseDecorator());
+  isExportDefaultSpecifier() {
+    if (this.match(65)) {
+      const next = this.nextTokenStart();
+      if (this.isUnparsedContextual(next, "from")) {
+        if (this.input.startsWith(tokenLabelName(142), this.nextTokenStartSince(next + 4))) {
+          return true;
         }
-        elts.push(this.parseAssignableListItem(allowModifiers, decorators));
       }
     }
-    return elts;
+    return super.isExportDefaultSpecifier();
   }
-  parseBindingRestProperty(prop) {
-    this.next();
-    prop.argument = this.parseIdentifier();
-    this.checkCommaAfterRest(125);
-    return this.finishNode(prop, "RestElement");
+  maybeParseExportDefaultSpecifier(node) {
+    if (node.specifiers && node.specifiers.length > 0) {
+      return true;
+    }
+    return super.maybeParseExportDefaultSpecifier(node);
   }
-  parseBindingProperty() {
-    const prop = this.startNode();
+  checkExport(node) {
     const {
-      type,
-      startLoc
-    } = this.state;
-    if (type === 21) {
-      return this.parseBindingRestProperty(prop);
-    } else if (type === 136) {
-      this.expectPlugin("destructuringPrivate", startLoc);
-      this.classScope.usePrivateName(this.state.value, startLoc);
-      prop.key = this.parsePrivateName();
-    } else {
-      this.parsePropertyName(prop);
+      specifiers
+    } = node;
+    if (specifiers != null && specifiers.length) {
+      node.specifiers = specifiers.filter(node => node.exported.type === "Placeholder");
     }
-    prop.method = false;
-    return this.parseObjPropValue(prop, startLoc, false, false, true, false);
+    super.checkExport(node);
+    node.specifiers = specifiers;
   }
-  parseAssignableListItem(allowModifiers, decorators) {
-    const left = this.parseMaybeDefault();
-    this.parseAssignableListItemTypes(left);
-    const elt = this.parseMaybeDefault(left.loc.start, left);
-    if (decorators.length) {
-      left.decorators = decorators;
+  parseImport(node) {
+    const placeholder = this.parsePlaceholder("Identifier");
+    if (!placeholder) return super.parseImport(node);
+    node.specifiers = [];
+    if (!this.isContextual(97) && !this.match(12)) {
+      node.source = this.finishPlaceholder(placeholder, "StringLiteral");
+      this.semicolon();
+      return this.finishNode(node, "ImportDeclaration");
     }
-    return elt;
-  }
-  parseAssignableListItemTypes(param) {
-    return param;
-  }
-  parseMaybeDefault(startLoc, left) {
-    var _startLoc, _left;
-    (_startLoc = startLoc) != null ? _startLoc : startLoc = this.state.startLoc;
-    left = (_left = left) != null ? _left : this.parseBindingAtom();
-    if (!this.eat(29)) return left;
-    const node = this.startNodeAt(startLoc);
-    node.left = left;
-    node.right = this.parseMaybeAssignAllowIn();
-    return this.finishNode(node, "AssignmentPattern");
+    const specifier = this.startNodeAtNode(placeholder);
+    specifier.local = placeholder;
+    node.specifiers.push(this.finishNode(specifier, "ImportDefaultSpecifier"));
+    if (this.eat(12)) {
+      const hasStarImport = this.maybeParseStarImportSpecifier(node);
+      if (!hasStarImport) this.parseNamedImportSpecifiers(node);
+    }
+    this.expectContextual(97);
+    node.source = this.parseImportSource();
+    this.semicolon();
+    return this.finishNode(node, "ImportDeclaration");
   }
-  isValidLVal(type, isUnparenthesizedInAssign, binding) {
-    return getOwn({
-      AssignmentPattern: "left",
-      RestElement: "argument",
-      ObjectProperty: "value",
-      ParenthesizedExpression: "expression",
-      ArrayPattern: "elements",
-      ObjectPattern: "properties"
-    }, type);
+  parseImportSource() {
+    return this.parsePlaceholder("StringLiteral") || super.parseImportSource();
   }
-  checkLVal(expression, {
-    in: ancestor,
-    binding = BIND_NONE,
-    checkClashes = false,
-    strictModeChanged = false,
-    hasParenthesizedAncestor = false
-  }) {
-    var _expression$extra;
-    const type = expression.type;
-    if (this.isObjectMethod(expression)) return;
-    if (type === "MemberExpression") {
-      if (binding !== BIND_NONE) {
-        this.raise(Errors.InvalidPropertyBindingPattern, {
-          at: expression
-        });
-      }
-      return;
+  assertNoSpace() {
+    if (this.state.start > this.state.lastTokEndLoc.index) {
+      this.raise(PlaceholderErrors.UnexpectedSpace, {
+        at: this.state.lastTokEndLoc
+      });
     }
-    if (type === "Identifier") {
-      this.checkIdentifier(expression, binding, strictModeChanged);
-      const {
-        name
-      } = expression;
-      if (checkClashes) {
-        if (checkClashes.has(name)) {
-          this.raise(Errors.ParamDupe, {
-            at: expression
-          });
-        } else {
-          checkClashes.add(name);
+  }
+});
+
+var v8intrinsic = (superClass => class V8IntrinsicMixin extends superClass {
+  parseV8Intrinsic() {
+    if (this.match(54)) {
+      const v8IntrinsicStartLoc = this.state.startLoc;
+      const node = this.startNode();
+      this.next();
+      if (tokenIsIdentifier(this.state.type)) {
+        const name = this.parseIdentifierName();
+        const identifier = this.createIdentifier(node, name);
+        identifier.type = "V8IntrinsicIdentifier";
+        if (this.match(10)) {
+          return identifier;
         }
       }
-      return;
-    }
-    const validity = this.isValidLVal(type, !(hasParenthesizedAncestor || (_expression$extra = expression.extra) != null && _expression$extra.parenthesized) && ancestor.type === "AssignmentExpression", binding);
-    if (validity === true) return;
-    if (validity === false) {
-      const ParseErrorClass = binding === BIND_NONE ? Errors.InvalidLhs : Errors.InvalidLhsBinding;
-      this.raise(ParseErrorClass, {
-        at: expression,
-        ancestor
-      });
-      return;
+      this.unexpected(v8IntrinsicStartLoc);
     }
-    const [key, isParenthesizedExpression] = Array.isArray(validity) ? validity : [validity, type === "ParenthesizedExpression"];
-    const nextAncestor = type === "ArrayPattern" || type === "ObjectPattern" || type === "ParenthesizedExpression" ? {
-      type
-    } : ancestor;
-    for (const child of [].concat(expression[key])) {
-      if (child) {
-        this.checkLVal(child, {
-          in: nextAncestor,
-          binding,
-          checkClashes,
-          strictModeChanged,
-          hasParenthesizedAncestor: isParenthesizedExpression
-        });
+  }
+  parseExprAtom(refExpressionErrors) {
+    return this.parseV8Intrinsic() || super.parseExprAtom(refExpressionErrors);
+  }
+});
+
+function hasPlugin(plugins, expectedConfig) {
+  const [expectedName, expectedOptions] = typeof expectedConfig === "string" ? [expectedConfig, {}] : expectedConfig;
+  const expectedKeys = Object.keys(expectedOptions);
+  const expectedOptionsIsEmpty = expectedKeys.length === 0;
+  return plugins.some(p => {
+    if (typeof p === "string") {
+      return expectedOptionsIsEmpty && p === expectedName;
+    } else {
+      const [pluginName, pluginOptions] = p;
+      if (pluginName !== expectedName) {
+        return false;
+      }
+      for (const key of expectedKeys) {
+        if (pluginOptions[key] !== expectedOptions[key]) {
+          return false;
+        }
       }
+      return true;
+    }
+  });
+}
+function getPluginOption(plugins, name, option) {
+  const plugin = plugins.find(plugin => {
+    if (Array.isArray(plugin)) {
+      return plugin[0] === name;
+    } else {
+      return plugin === name;
     }
+  });
+  if (plugin && Array.isArray(plugin) && plugin.length > 1) {
+    return plugin[1][option];
   }
-  checkIdentifier(at, bindingType, strictModeChanged = false) {
-    if (this.state.strict && (strictModeChanged ? isStrictBindReservedWord(at.name, this.inModule) : isStrictBindOnlyReservedWord(at.name))) {
-      if (bindingType === BIND_NONE) {
-        this.raise(Errors.StrictEvalArguments, {
-          at,
-          referenceName: at.name
-        });
-      } else {
-        this.raise(Errors.StrictEvalArgumentsBinding, {
-          at,
-          bindingName: at.name
-        });
-      }
+  return null;
+}
+const PIPELINE_PROPOSALS = ["minimal", "fsharp", "hack", "smart"];
+const TOPIC_TOKENS = ["^^", "@@", "^", "%", "#"];
+const RECORD_AND_TUPLE_SYNTAX_TYPES = ["hash", "bar"];
+function validatePlugins(plugins) {
+  if (hasPlugin(plugins, "decorators")) {
+    if (hasPlugin(plugins, "decorators-legacy")) {
+      throw new Error("Cannot use the decorators and decorators-legacy plugin together");
     }
-    if (bindingType & BIND_FLAGS_NO_LET_IN_LEXICAL && at.name === "let") {
-      this.raise(Errors.LetInLexicalBinding, {
-        at
-      });
+    const decoratorsBeforeExport = getPluginOption(plugins, "decorators", "decoratorsBeforeExport");
+    if (decoratorsBeforeExport != null && typeof decoratorsBeforeExport !== "boolean") {
+      throw new Error("'decoratorsBeforeExport' must be a boolean, if specified.");
     }
-    if (!(bindingType & BIND_NONE)) {
-      this.declareNameFromIdentifier(at, bindingType);
+    const allowCallParenthesized = getPluginOption(plugins, "decorators", "allowCallParenthesized");
+    if (allowCallParenthesized != null && typeof allowCallParenthesized !== "boolean") {
+      throw new Error("'allowCallParenthesized' must be a boolean.");
     }
   }
-  declareNameFromIdentifier(identifier, binding) {
-    this.scope.declareName(identifier.name, binding, identifier.loc.start);
+  if (hasPlugin(plugins, "flow") && hasPlugin(plugins, "typescript")) {
+    throw new Error("Cannot combine flow and typescript plugins.");
   }
-  checkToRestConversion(node, allowPattern) {
-    switch (node.type) {
-      case "ParenthesizedExpression":
-        this.checkToRestConversion(node.expression, allowPattern);
-        break;
-      case "Identifier":
-      case "MemberExpression":
-        break;
-      case "ArrayExpression":
-      case "ObjectExpression":
-        if (allowPattern) break;
-      default:
-        this.raise(Errors.InvalidRestAssignmentPattern, {
-          at: node
-        });
+  if (hasPlugin(plugins, "placeholders") && hasPlugin(plugins, "v8intrinsic")) {
+    throw new Error("Cannot combine placeholders and v8intrinsic plugins.");
+  }
+  if (hasPlugin(plugins, "pipelineOperator")) {
+    const proposal = getPluginOption(plugins, "pipelineOperator", "proposal");
+    if (!PIPELINE_PROPOSALS.includes(proposal)) {
+      const proposalList = PIPELINE_PROPOSALS.map(p => `"${p}"`).join(", ");
+      throw new Error(`"pipelineOperator" requires "proposal" option whose value must be one of: ${proposalList}.`);
+    }
+    const tupleSyntaxIsHash = hasPlugin(plugins, ["recordAndTuple", {
+      syntaxType: "hash"
+    }]);
+    if (proposal === "hack") {
+      if (hasPlugin(plugins, "placeholders")) {
+        throw new Error("Cannot combine placeholders plugin and Hack-style pipes.");
+      }
+      if (hasPlugin(plugins, "v8intrinsic")) {
+        throw new Error("Cannot combine v8intrinsic plugin and Hack-style pipes.");
+      }
+      const topicToken = getPluginOption(plugins, "pipelineOperator", "topicToken");
+      if (!TOPIC_TOKENS.includes(topicToken)) {
+        const tokenList = TOPIC_TOKENS.map(t => `"${t}"`).join(", ");
+        throw new Error(`"pipelineOperator" in "proposal": "hack" mode also requires a "topicToken" option whose value must be one of: ${tokenList}.`);
+      }
+      if (topicToken === "#" && tupleSyntaxIsHash) {
+        throw new Error('Plugin conflict between `["pipelineOperator", { proposal: "hack", topicToken: "#" }]` and `["recordAndtuple", { syntaxType: "hash"}]`.');
+      }
+    } else if (proposal === "smart" && tupleSyntaxIsHash) {
+      throw new Error('Plugin conflict between `["pipelineOperator", { proposal: "smart" }]` and `["recordAndtuple", { syntaxType: "hash"}]`.');
     }
   }
-  checkCommaAfterRest(close) {
-    if (!this.match(12)) {
-      return false;
+  if (hasPlugin(plugins, "moduleAttributes")) {
+    {
+      if (hasPlugin(plugins, "importAssertions")) {
+        throw new Error("Cannot combine importAssertions and moduleAttributes plugins.");
+      }
+      const moduleAttributesVersionPluginOption = getPluginOption(plugins, "moduleAttributes", "version");
+      if (moduleAttributesVersionPluginOption !== "may-2020") {
+        throw new Error("The 'moduleAttributes' plugin requires a 'version' option," + " representing the last proposal update. Currently, the" + " only supported value is 'may-2020'.");
+      }
     }
-    this.raise(this.lookaheadCharCode() === close ? Errors.RestTrailingComma : Errors.ElementAfterRest, {
-      at: this.state.startLoc
-    });
-    return true;
   }
+  if (hasPlugin(plugins, "recordAndTuple") && getPluginOption(plugins, "recordAndTuple", "syntaxType") != null && !RECORD_AND_TUPLE_SYNTAX_TYPES.includes(getPluginOption(plugins, "recordAndTuple", "syntaxType"))) {
+    throw new Error("The 'syntaxType' option of the 'recordAndTuple' plugin must be one of: " + RECORD_AND_TUPLE_SYNTAX_TYPES.map(p => `'${p}'`).join(", "));
+  }
+  if (hasPlugin(plugins, "asyncDoExpressions") && !hasPlugin(plugins, "doExpressions")) {
+    const error = new Error("'asyncDoExpressions' requires 'doExpressions', please add 'doExpressions' to parser plugins.");
+    error.missingPlugins = "doExpressions";
+    throw error;
+  }
+}
+const mixinPlugins = {
+  estree,
+  jsx,
+  flow,
+  typescript,
+  v8intrinsic,
+  placeholders
+};
+const mixinPluginNames = Object.keys(mixinPlugins);
+
+const defaultOptions = {
+  sourceType: "script",
+  sourceFilename: undefined,
+  startColumn: 0,
+  startLine: 1,
+  allowAwaitOutsideFunction: false,
+  allowReturnOutsideFunction: false,
+  allowNewTargetOutsideFunction: false,
+  allowImportExportEverywhere: false,
+  allowSuperOutsideMethod: false,
+  allowUndeclaredExports: false,
+  plugins: [],
+  strictMode: null,
+  ranges: false,
+  tokens: false,
+  createParenthesizedExpressions: false,
+  errorRecovery: false,
+  attachComment: true,
+  annexB: true
+};
+function getOptions(opts) {
+  if (opts && opts.annexB != null && opts.annexB !== false) {
+    throw new Error("The `annexB` option can only be set to `false`.");
+  }
+  const options = {};
+  for (const key of Object.keys(defaultOptions)) {
+    options[key] = opts && opts[key] != null ? opts[key] : defaultOptions[key];
+  }
+  return options;
 }
 
 class ExpressionParser extends LValParser {
@@ -10873,9 +10885,14 @@ class ExpressionParser extends LValParser {
     }
     let optional = false;
     if (type === 18) {
-      if (noCalls && this.lookaheadCharCode() === 40) {
-        state.stop = true;
-        return base;
+      if (noCalls) {
+        this.raise(Errors.OptionalChainingNoNew, {
+          at: this.state.startLoc
+        });
+        if (this.lookaheadCharCode() === 40) {
+          state.stop = true;
+          return base;
+        }
       }
       state.optionalChainMember = optional = true;
       this.next();
@@ -11519,7 +11536,7 @@ class ExpressionParser extends LValParser {
       const meta = this.createIdentifier(this.startNodeAtNode(node), "new");
       this.next();
       const metaProp = this.parseMetaProperty(node, meta, "target");
-      if (!this.scope.inNonArrowFunction && !this.scope.inClass) {
+      if (!this.scope.inNonArrowFunction && !this.scope.inClass && !this.options.allowNewTargetOutsideFunction) {
         this.raise(Errors.UnexpectedNewTarget, {
           at: metaProp
         });
@@ -11540,20 +11557,11 @@ class ExpressionParser extends LValParser {
     return this.finishNode(node, "NewExpression");
   }
   parseNewCallee(node) {
-    var _node$callee$extra;
     node.callee = this.parseNoCallExpr();
     if (node.callee.type === "Import") {
       this.raise(Errors.ImportCallNotNewExpression, {
         at: node.callee
       });
-    } else if (this.isOptionalChain(node.callee) && !((_node$callee$extra = node.callee.extra) != null && _node$callee$extra.parenthesized)) {
-      this.raise(Errors.OptionalChainingNoNew, {
-        at: this.state.lastTokEndLoc
-      });
-    } else if (this.eat(18)) {
-      this.raise(Errors.OptionalChainingNoNew, {
-        at: this.state.startLoc
-      });
     }
   }
   parseTemplateElement(isTagged) {
@@ -11841,10 +11849,9 @@ class ExpressionParser extends LValParser {
   parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope = false) {
     this.initFunction(node, isAsync);
     node.generator = isGenerator;
-    const allowModifiers = isConstructor;
     this.scope.enter(SCOPE_FUNCTION | SCOPE_SUPER | (inClassScope ? SCOPE_CLASS : 0) | (allowDirectSuper ? SCOPE_DIRECT_SUPER : 0));
     this.prodParam.enter(functionFlags(isAsync, node.generator));
-    this.parseFunctionParams(node, allowModifiers);
+    this.parseFunctionParams(node, isConstructor);
     const finishedNode = this.parseFunctionBodyAndFinish(node, type, true);
     this.prodParam.exit();
     this.scope.exit();
@@ -12029,7 +12036,21 @@ class ExpressionParser extends LValParser {
     if (!canBeReservedWord(word)) {
       return;
     }
-    if (word === "yield") {
+    if (checkKeywords && isKeyword(word)) {
+      this.raise(Errors.UnexpectedKeyword, {
+        at: startLoc,
+        keyword: word
+      });
+      return;
+    }
+    const reservedTest = !this.state.strict ? isReservedWord : isBinding ? isStrictBindReservedWord : isStrictReservedWord;
+    if (reservedTest(word, this.inModule)) {
+      this.raise(Errors.UnexpectedReservedWord, {
+        at: startLoc,
+        reservedWord: word
+      });
+      return;
+    } else if (word === "yield") {
       if (this.prodParam.hasYield) {
         this.raise(Errors.YieldBindingIdentifier, {
           at: startLoc
@@ -12060,20 +12081,6 @@ class ExpressionParser extends LValParser {
         return;
       }
     }
-    if (checkKeywords && isKeyword(word)) {
-      this.raise(Errors.UnexpectedKeyword, {
-        at: startLoc,
-        keyword: word
-      });
-      return;
-    }
-    const reservedTest = !this.state.strict ? isReservedWord : isBinding ? isStrictBindReservedWord : isStrictReservedWord;
-    if (reservedTest(word, this.inModule)) {
-      this.raise(Errors.UnexpectedReservedWord, {
-        at: startLoc,
-        reservedWord: word
-      });
-    }
   }
   isAwaitAllowed() {
     if (this.prodParam.hasAwait) return true;
@@ -12518,10 +12525,17 @@ class StatementParser extends ExpressionParser {
     return this.parseStatementLike(ParseStatementFlag.AllowImportExport | ParseStatementFlag.AllowDeclaration | ParseStatementFlag.AllowFunctionDeclaration | ParseStatementFlag.AllowLabeledFunction);
   }
   parseStatementListItem() {
-    return this.parseStatementLike(ParseStatementFlag.AllowDeclaration | ParseStatementFlag.AllowFunctionDeclaration | ParseStatementFlag.AllowLabeledFunction);
+    return this.parseStatementLike(ParseStatementFlag.AllowDeclaration | ParseStatementFlag.AllowFunctionDeclaration | (!this.options.annexB || this.state.strict ? 0 : ParseStatementFlag.AllowLabeledFunction));
   }
-  parseStatementOrFunctionDeclaration(disallowLabeledFunction) {
-    return this.parseStatementLike(ParseStatementFlag.AllowFunctionDeclaration | (disallowLabeledFunction ? 0 : ParseStatementFlag.AllowLabeledFunction));
+  parseStatementOrSloppyAnnexBFunctionDeclaration(allowLabeledFunction = false) {
+    let flags = ParseStatementFlag.StatementOnly;
+    if (this.options.annexB && !this.state.strict) {
+      flags |= ParseStatementFlag.AllowFunctionDeclaration;
+      if (allowLabeledFunction) {
+        flags |= ParseStatementFlag.AllowLabeledFunction;
+      }
+    }
+    return this.parseStatementLike(flags);
   }
   parseStatement() {
     return this.parseStatementLike(ParseStatementFlag.StatementOnly);
@@ -12552,16 +12566,10 @@ class StatementParser extends ExpressionParser {
         return this.parseForStatement(node);
       case 68:
         if (this.lookaheadCharCode() === 46) break;
-        if (!allowDeclaration) {
-          if (this.state.strict) {
-            this.raise(Errors.StrictFunction, {
-              at: this.state.startLoc
-            });
-          } else if (!allowFunctionDeclaration) {
-            this.raise(Errors.SloppyFunction, {
-              at: this.state.startLoc
-            });
-          }
+        if (!allowFunctionDeclaration) {
+          this.raise(this.state.strict ? Errors.StrictFunction : this.options.annexB ? Errors.SloppyFunctionAnnexB : Errors.SloppyFunction, {
+            at: this.state.startLoc
+          });
         }
         return this.parseFunctionStatement(node, false, !allowDeclaration && allowFunctionDeclaration);
       case 80:
@@ -12687,11 +12695,20 @@ class StatementParser extends ExpressionParser {
   }
   decoratorsEnabledBeforeExport() {
     if (this.hasPlugin("decorators-legacy")) return true;
-    return this.hasPlugin("decorators") && !!this.getPluginOption("decorators", "decoratorsBeforeExport");
+    return this.hasPlugin("decorators") && this.getPluginOption("decorators", "decoratorsBeforeExport") !== false;
   }
   maybeTakeDecorators(maybeDecorators, classNode, exportNode) {
     if (maybeDecorators) {
-      classNode.decorators = maybeDecorators;
+      if (classNode.decorators && classNode.decorators.length > 0) {
+        if (typeof this.getPluginOption("decorators", "decoratorsBeforeExport") !== "boolean") {
+          this.raise(Errors.DecoratorsBeforeAfterExport, {
+            at: classNode.decorators[0]
+          });
+        }
+        classNode.decorators.unshift(...maybeDecorators);
+      } else {
+        classNode.decorators = maybeDecorators;
+      }
       this.resetStartLocationFromNode(classNode, maybeDecorators[0]);
       if (exportNode) this.resetStartLocationFromNode(exportNode, classNode);
     }
@@ -12900,8 +12917,8 @@ class StatementParser extends ExpressionParser {
   parseIfStatement(node) {
     this.next();
     node.test = this.parseHeaderExpression();
-    node.consequent = this.parseStatementOrFunctionDeclaration(true);
-    node.alternate = this.eat(66) ? this.parseStatementOrFunctionDeclaration(true) : null;
+    node.consequent = this.parseStatementOrSloppyAnnexBFunctionDeclaration();
+    node.alternate = this.eat(66) ? this.parseStatementOrSloppyAnnexBFunctionDeclaration() : null;
     return this.finishNode(node, "IfStatement");
   }
   parseReturnStatement(node) {
@@ -12973,8 +12990,7 @@ class StatementParser extends ExpressionParser {
   }
   parseCatchClauseParam() {
     const param = this.parseBindingAtom();
-    const simple = param.type === "Identifier";
-    this.scope.enter(simple ? SCOPE_SIMPLE_CATCH : 0);
+    this.scope.enter(this.options.annexB && param.type === "Identifier" ? SCOPE_SIMPLE_CATCH : 0);
     this.checkLVal(param, {
       in: {
         type: "CatchClause"
@@ -13063,7 +13079,7 @@ class StatementParser extends ExpressionParser {
       kind: kind,
       statementStart: this.state.start
     });
-    node.body = flags & ParseStatementFlag.AllowLabeledFunction ? this.parseStatementOrFunctionDeclaration(false) : this.parseStatement();
+    node.body = flags & ParseStatementFlag.AllowLabeledFunction ? this.parseStatementOrSloppyAnnexBFunctionDeclaration(true) : this.parseStatement();
     this.state.labels.pop();
     node.label = expr;
     return this.finishNode(node, "LabeledStatement");
@@ -13145,7 +13161,7 @@ class StatementParser extends ExpressionParser {
     } else {
       node.await = awaitAt !== null;
     }
-    if (init.type === "VariableDeclaration" && init.declarations[0].init != null && (!isForIn || this.state.strict || init.kind !== "var" || init.declarations[0].id.type !== "Identifier")) {
+    if (init.type === "VariableDeclaration" && init.declarations[0].init != null && (!isForIn || !this.options.annexB || this.state.strict || init.kind !== "var" || init.declarations[0].id.type !== "Identifier")) {
       this.raise(Errors.ForInOfLoopInitializer, {
         at: init,
         type: isForIn ? "ForInStatement" : "ForOfStatement"
@@ -13250,15 +13266,15 @@ class StatementParser extends ExpressionParser {
   parseFunctionId(requireId) {
     return requireId || tokenIsIdentifier(this.state.type) ? this.parseIdentifier() : null;
   }
-  parseFunctionParams(node, allowModifiers) {
+  parseFunctionParams(node, isConstructor) {
     this.expect(10);
     this.expressionScope.enter(newParameterDeclarationScope());
-    node.params = this.parseBindingList(11, 41, false, allowModifiers);
+    node.params = this.parseBindingList(11, 41, ParseBindingListFlags.IS_FUNCTION_PARAMS | (isConstructor ? ParseBindingListFlags.IS_CONSTRUCTOR_PARAMS : 0));
     this.expressionScope.exit();
   }
   registerFunctionStatementId(node) {
     if (!node.id) return;
-    this.scope.declareName(node.id.name, this.state.strict || node.generator || node.async ? this.scope.treatFunctionsAsVar ? BIND_VAR : BIND_LEXICAL : BIND_FUNCTION, node.id.loc.start);
+    this.scope.declareName(node.id.name, !this.options.annexB || this.state.strict || node.generator || node.async ? this.scope.treatFunctionsAsVar ? BIND_VAR : BIND_LEXICAL : BIND_FUNCTION, node.id.loc.start);
   }
   parseClass(node, isStatement, optionalId) {
     this.next();
@@ -13731,7 +13747,7 @@ class StatementParser extends ExpressionParser {
       return this.parseClass(expr, true, true);
     }
     if (this.match(26)) {
-      if (this.hasPlugin("decorators") && this.getPluginOption("decorators", "decoratorsBeforeExport")) {
+      if (this.hasPlugin("decorators") && this.getPluginOption("decorators", "decoratorsBeforeExport") === true) {
         this.raise(Errors.DecoratorBeforeExport, {
           at: this.state.startLoc
         });
@@ -13806,8 +13822,8 @@ class StatementParser extends ExpressionParser {
     if (type === 26) {
       this.expectOnePlugin(["decorators", "decorators-legacy"]);
       if (this.hasPlugin("decorators")) {
-        if (this.getPluginOption("decorators", "decoratorsBeforeExport")) {
-          throw this.raise(Errors.DecoratorBeforeExport, {
+        if (this.getPluginOption("decorators", "decoratorsBeforeExport") === true) {
+          this.raise(Errors.DecoratorBeforeExport, {
             at: this.state.startLoc
           });
         }