@galadrim/galadmin 0.1.38 → 0.1.41

package/src/front/node_modules/@babel/parser/lib/plugins/typescript/index.js

@@ -1,2656 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _types = require("../../tokenizer/types");
-var _context = require("../../tokenizer/context");
-var _location = require("../../util/location");
-var _scopeflags = require("../../util/scopeflags");
-var _scope = require("./scope");
-var _productionParameter = require("../../util/production-parameter");
-var _parseError = require("../../parse-error");
-var _node = require("../../parser/node");
-var _lval = require("../../parser/lval");
-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 = (0, _parseError.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.",
-  TupleOptionalAfterType: "A labeled tuple optional element must be declared using a question mark after the name and before the colon (`name?: type`), rather than after the type (`name: type?`).",
-  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 _default = 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 _scope.default;
-  }
-  tsIsIdentifier() {
-    return (0, _types.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 (!(0, _types.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);
-    }
-  }
-  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() {
-    const list = super.parseBindingList(11, 41, _lval.ParseBindingListFlags.IS_FUNCTION_PARAMS);
-    for (const pattern of list) {
-      const {
-        type
-      } = pattern;
-      if (type === "AssignmentPattern" || type === "TSParameterProperty") {
-        this.raise(TSErrors.UnsupportedSignatureParameterKind, {
-          at: pattern,
-          type
-        });
-      }
-    }
-    return list;
-  }
-  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 ((0, _types.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;
-    }
-    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
-        });
-      }
-      const method = nodeAny;
-      if (method.kind && this.match(47)) {
-        this.raise(TSErrors.AccesorCannotHaveTypeParameters, {
-          at: this.state.curPosition()
-        });
-      }
-      this.tsFillSignature(14, method);
-      this.tsParseTypeMemberSemicolon();
-      const paramsKey = "parameters";
-      const returnTypeKey = "typeAnnotation";
-      if (method.kind === "get") {
-        if (method[paramsKey].length > 0) {
-          this.raise(_parseError.Errors.BadGetterArity, {
-            at: this.state.curPosition()
-          });
-          if (this.isThisParam(method[paramsKey][0])) {
-            this.raise(TSErrors.AccesorCannotDeclareThisParameter, {
-              at: this.state.curPosition()
-            });
-          }
-        }
-      } else if (method.kind === "set") {
-        if (method[paramsKey].length !== 1) {
-          this.raise(_parseError.Errors.BadSetterArity, {
-            at: this.state.curPosition()
-          });
-        } else {
-          const firstParameter = method[paramsKey][0];
-          if (this.isThisParam(firstParameter)) {
-            this.raise(TSErrors.AccesorCannotDeclareThisParameter, {
-              at: this.state.curPosition()
-            });
-          }
-          if (firstParameter.type === "Identifier" && firstParameter.optional) {
-            this.raise(TSErrors.SetAccesorCannotHaveOptionalParameter, {
-              at: this.state.curPosition()
-            });
-          }
-          if (firstParameter.type === "RestElement") {
-            this.raise(TSErrors.SetAccesorCannotHaveRestParameter, {
-              at: this.state.curPosition()
-            });
-          }
-        }
-        if (method[returnTypeKey]) {
-          this.raise(TSErrors.SetAccesorCannotHaveReturnType, {
-            at: method[returnTypeKey]
-          });
-        }
-      } else {
-        method.kind = "method";
-      }
-      return this.finishNode(method, "TSMethodSignature");
-    } else {
-      const property = nodeAny;
-      if (readonly) property.readonly = true;
-      const type = this.tsTryParseTypeAnnotation();
-      if (type) property.typeAnnotation = type;
-      this.tsParseTypeMemberSemicolon();
-      return this.finishNode(property, "TSPropertySignature");
-    }
-  }
-  tsParseTypeMember() {
-    const node = this.startNode();
-    if (this.match(10) || this.match(47)) {
-      return this.tsParseSignatureMember("TSCallSignatureDeclaration", node);
-    }
-    if (this.match(77)) {
-      const id = this.startNode();
-      this.next();
-      if (this.match(10) || this.match(47)) {
-        return this.tsParseSignatureMember("TSConstructSignatureDeclaration", node);
-      } else {
-        node.key = this.createIdentifier(id, "new");
-        return this.tsParsePropertyOrMethodSignature(node, false);
-      }
-    }
-    this.tsParseModifiers({
-      allowedModifiers: ["readonly"],
-      disallowedModifiers: ["declare", "abstract", "private", "protected", "public", "static", "override"]
-    }, node);
-    const idx = this.tsTryParseIndexSignature(node);
-    if (idx) {
-      return idx;
-    }
-    super.parsePropertyName(node);
-    if (!node.computed && node.key.type === "Identifier" && (node.key.name === "get" || node.key.name === "set") && this.tsTokenCanFollowModifier()) {
-      node.kind = node.key.name;
-      super.parsePropertyName(node);
-    }
-    return this.tsParsePropertyOrMethodSignature(node, !!node.readonly);
-  }
-  tsParseTypeLiteral() {
-    const node = this.startNode();
-    node.members = this.tsParseObjectTypeMembers();
-    return this.finishNode(node, "TSTypeLiteral");
-  }
-  tsParseObjectTypeMembers() {
-    this.expect(5);
-    const members = this.tsParseList("TypeMembers", this.tsParseTypeMember.bind(this));
-    this.expect(8);
-    return members;
-  }
-  tsIsStartOfMappedType() {
-    this.next();
-    if (this.eat(53)) {
-      return this.isContextual(120);
-    }
-    if (this.isContextual(120)) {
-      this.next();
-    }
-    if (!this.match(0)) {
-      return false;
-    }
-    this.next();
-    if (!this.tsIsIdentifier()) {
-      return false;
-    }
-    this.next();
-    return this.match(58);
-  }
-  tsParseMappedTypeParameter() {
-    const node = this.startNode();
-    node.name = this.tsParseTypeParameterName();
-    node.constraint = this.tsExpectThenParseType(58);
-    return this.finishNode(node, "TSTypeParameter");
-  }
-  tsParseMappedType() {
-    const node = this.startNode();
-    this.expect(5);
-    if (this.match(53)) {
-      node.readonly = this.state.value;
-      this.next();
-      this.expectContextual(120);
-    } else if (this.eatContextual(120)) {
-      node.readonly = true;
-    }
-    this.expect(0);
-    node.typeParameter = this.tsParseMappedTypeParameter();
-    node.nameType = this.eatContextual(93) ? this.tsParseType() : null;
-    this.expect(3);
-    if (this.match(53)) {
-      node.optional = this.state.value;
-      this.next();
-      this.expect(17);
-    } else if (this.eat(17)) {
-      node.optional = true;
-    }
-    node.typeAnnotation = this.tsTryParseType();
-    this.semicolon();
-    this.expect(8);
-    return this.finishNode(node, "TSMappedType");
-  }
-  tsParseTupleType() {
-    const node = this.startNode();
-    node.elementTypes = this.tsParseBracketedList("TupleElementTypes", this.tsParseTupleElementType.bind(this), true, false);
-    let seenOptionalElement = false;
-    let labeledElements = null;
-    node.elementTypes.forEach(elementNode => {
-      var _labeledElements;
-      const {
-        type
-      } = elementNode;
-      if (seenOptionalElement && type !== "TSRestType" && type !== "TSOptionalType" && !(type === "TSNamedTupleMember" && elementNode.optional)) {
-        this.raise(TSErrors.OptionalTypeBeforeRequired, {
-          at: elementNode
-        });
-      }
-      seenOptionalElement || (seenOptionalElement = type === "TSNamedTupleMember" && elementNode.optional || type === "TSOptionalType");
-      let checkType = type;
-      if (type === "TSRestType") {
-        elementNode = elementNode.typeAnnotation;
-        checkType = elementNode.type;
-      }
-      const isLabeled = checkType === "TSNamedTupleMember";
-      (_labeledElements = labeledElements) != null ? _labeledElements : labeledElements = isLabeled;
-      if (labeledElements !== isLabeled) {
-        this.raise(TSErrors.MixedLabeledAndUnlabeledElements, {
-          at: elementNode
-        });
-      }
-    });
-    return this.finishNode(node, "TSTupleType");
-  }
-  tsParseTupleElementType() {
-    const {
-      startLoc
-    } = this.state;
-    const rest = this.eat(21);
-    let labeled;
-    let label;
-    let optional;
-    let type;
-    const isWord = (0, _types.tokenIsKeywordOrIdentifier)(this.state.type);
-    const chAfterWord = isWord ? this.lookaheadCharCode() : null;
-    if (chAfterWord === 58) {
-      labeled = true;
-      optional = false;
-      label = this.parseIdentifier(true);
-      this.expect(14);
-      type = this.tsParseType();
-    } else if (chAfterWord === 63) {
-      optional = true;
-      const startLoc = this.state.startLoc;
-      const wordName = this.state.value;
-      const typeOrLabel = this.tsParseNonArrayType();
-      if (this.lookaheadCharCode() === 58) {
-        labeled = true;
-        label = this.createIdentifier(this.startNodeAt(startLoc), wordName);
-        this.expect(17);
-        this.expect(14);
-        type = this.tsParseType();
-      } else {
-        labeled = false;
-        type = typeOrLabel;
-        this.expect(17);
-      }
-    } else {
-      type = this.tsParseType();
-      optional = this.eat(17);
-      labeled = this.eat(14);
-    }
-    if (labeled) {
-      let labeledNode;
-      if (label) {
-        labeledNode = this.startNodeAtNode(label);
-        labeledNode.optional = optional;
-        labeledNode.label = label;
-        labeledNode.elementType = type;
-        if (this.eat(17)) {
-          labeledNode.optional = true;
-          this.raise(TSErrors.TupleOptionalAfterType, {
-            at: this.state.lastTokStartLoc
-          });
-        }
-      } else {
-        labeledNode = this.startNodeAtNode(type);
-        labeledNode.optional = optional;
-        this.raise(TSErrors.InvalidTupleMemberLabel, {
-          at: type
-        });
-        labeledNode.label = type;
-        labeledNode.elementType = this.tsParseType();
-      }
-      type = this.finishNode(labeledNode, "TSNamedTupleMember");
-    } else if (optional) {
-      const optionalTypeNode = this.startNodeAtNode(type);
-      optionalTypeNode.typeAnnotation = type;
-      type = this.finishNode(optionalTypeNode, "TSOptionalType");
-    }
-    if (rest) {
-      const restNode = this.startNodeAt(startLoc);
-      restNode.typeAnnotation = type;
-      type = this.finishNode(restNode, "TSRestType");
-    }
-    return type;
-  }
-  tsParseParenthesizedType() {
-    const node = this.startNode();
-    this.expect(10);
-    node.typeAnnotation = this.tsParseType();
-    this.expect(11);
-    return this.finishNode(node, "TSParenthesizedType");
-  }
-  tsParseFunctionOrConstructorType(type, abstract) {
-    const node = this.startNode();
-    if (type === "TSConstructorType") {
-      node.abstract = !!abstract;
-      if (abstract) this.next();
-      this.next();
-    }
-    this.tsInAllowConditionalTypesContext(() => this.tsFillSignature(19, node));
-    return this.finishNode(node, type);
-  }
-  tsParseLiteralTypeNode() {
-    const node = this.startNode();
-    switch (this.state.type) {
-      case 132:
-      case 133:
-      case 131:
-      case 85:
-      case 86:
-        node.literal = super.parseExprAtom();
-        break;
-      default:
-        this.unexpected();
-    }
-    return this.finishNode(node, "TSLiteralType");
-  }
-  tsParseTemplateLiteralType() {
-    const node = this.startNode();
-    node.literal = super.parseTemplate(false);
-    return this.finishNode(node, "TSLiteralType");
-  }
-  parseTemplateSubstitution() {
-    if (this.state.inType) return this.tsParseType();
-    return super.parseTemplateSubstitution();
-  }
-  tsParseThisTypeOrThisTypePredicate() {
-    const thisKeyword = this.tsParseThisTypeNode();
-    if (this.isContextual(114) && !this.hasPrecedingLineBreak()) {
-      return this.tsParseThisTypePredicate(thisKeyword);
-    } else {
-      return thisKeyword;
-    }
-  }
-  tsParseNonArrayType() {
-    switch (this.state.type) {
-      case 131:
-      case 132:
-      case 133:
-      case 85:
-      case 86:
-        return this.tsParseLiteralTypeNode();
-      case 53:
-        if (this.state.value === "-") {
-          const node = this.startNode();
-          const nextToken = this.lookahead();
-          if (nextToken.type !== 132 && nextToken.type !== 133) {
-            this.unexpected();
-          }
-          node.literal = this.parseMaybeUnary();
-          return this.finishNode(node, "TSLiteralType");
-        }
-        break;
-      case 78:
-        return this.tsParseThisTypeOrThisTypePredicate();
-      case 87:
-        return this.tsParseTypeQuery();
-      case 83:
-        return this.tsParseImportType();
-      case 5:
-        return this.tsLookAhead(this.tsIsStartOfMappedType.bind(this)) ? this.tsParseMappedType() : this.tsParseTypeLiteral();
-      case 0:
-        return this.tsParseTupleType();
-      case 10:
-        ;
-        return this.tsParseParenthesizedType();
-      case 25:
-      case 24:
-        return this.tsParseTemplateLiteralType();
-      default:
-        {
-          const {
-            type
-          } = this.state;
-          if ((0, _types.tokenIsIdentifier)(type) || type === 88 || type === 84) {
-            const nodeType = type === 88 ? "TSVoidKeyword" : type === 84 ? "TSNullKeyword" : keywordTypeFromName(this.state.value);
-            if (nodeType !== undefined && this.lookaheadCharCode() !== 46) {
-              const node = this.startNode();
-              this.next();
-              return this.finishNode(node, nodeType);
-            }
-            return this.tsParseTypeReference();
-          }
-        }
-    }
-    this.unexpected();
-  }
-  tsParseArrayTypeOrHigher() {
-    let type = this.tsParseNonArrayType();
-    while (!this.hasPrecedingLineBreak() && this.eat(0)) {
-      if (this.match(3)) {
-        const node = this.startNodeAtNode(type);
-        node.elementType = type;
-        this.expect(3);
-        type = this.finishNode(node, "TSArrayType");
-      } else {
-        const node = this.startNodeAtNode(type);
-        node.objectType = type;
-        node.indexType = this.tsParseType();
-        this.expect(3);
-        type = this.finishNode(node, "TSIndexedAccessType");
-      }
-    }
-    return type;
-  }
-  tsParseTypeOperator() {
-    const node = this.startNode();
-    const operator = this.state.value;
-    this.next();
-    node.operator = operator;
-    node.typeAnnotation = this.tsParseTypeOperatorOrHigher();
-    if (operator === "readonly") {
-      this.tsCheckTypeAnnotationForReadOnly(node);
-    }
-    return this.finishNode(node, "TSTypeOperator");
-  }
-  tsCheckTypeAnnotationForReadOnly(node) {
-    switch (node.typeAnnotation.type) {
-      case "TSTupleType":
-      case "TSArrayType":
-        return;
-      default:
-        this.raise(TSErrors.UnexpectedReadonly, {
-          at: node
-        });
-    }
-  }
-  tsParseInferType() {
-    const node = this.startNode();
-    this.expectContextual(113);
-    const typeParameter = this.startNode();
-    typeParameter.name = this.tsParseTypeParameterName();
-    typeParameter.constraint = this.tsTryParse(() => this.tsParseConstraintForInferType());
-    node.typeParameter = this.finishNode(typeParameter, "TSTypeParameter");
-    return this.finishNode(node, "TSInferType");
-  }
-  tsParseConstraintForInferType() {
-    if (this.eat(81)) {
-      const constraint = this.tsInDisallowConditionalTypesContext(() => this.tsParseType());
-      if (this.state.inDisallowConditionalTypesContext || !this.match(17)) {
-        return constraint;
-      }
-    }
-  }
-  tsParseTypeOperatorOrHigher() {
-    const isTypeOperator = (0, _types.tokenIsTSTypeOperator)(this.state.type) && !this.state.containsEsc;
-    return isTypeOperator ? this.tsParseTypeOperator() : this.isContextual(113) ? this.tsParseInferType() : this.tsInAllowConditionalTypesContext(() => this.tsParseArrayTypeOrHigher());
-  }
-  tsParseUnionOrIntersectionType(kind, parseConstituentType, operator) {
-    const node = this.startNode();
-    const hasLeadingOperator = this.eat(operator);
-    const types = [];
-    do {
-      types.push(parseConstituentType());
-    } while (this.eat(operator));
-    if (types.length === 1 && !hasLeadingOperator) {
-      return types[0];
-    }
-    node.types = types;
-    return this.finishNode(node, kind);
-  }
-  tsParseIntersectionTypeOrHigher() {
-    return this.tsParseUnionOrIntersectionType("TSIntersectionType", this.tsParseTypeOperatorOrHigher.bind(this), 45);
-  }
-  tsParseUnionTypeOrHigher() {
-    return this.tsParseUnionOrIntersectionType("TSUnionType", this.tsParseIntersectionTypeOrHigher.bind(this), 43);
-  }
-  tsIsStartOfFunctionType() {
-    if (this.match(47)) {
-      return true;
-    }
-    return this.match(10) && this.tsLookAhead(this.tsIsUnambiguouslyStartOfFunctionType.bind(this));
-  }
-  tsSkipParameterStart() {
-    if ((0, _types.tokenIsIdentifier)(this.state.type) || this.match(78)) {
-      this.next();
-      return true;
-    }
-    if (this.match(5)) {
-      const {
-        errors
-      } = this.state;
-      const previousErrorCount = errors.length;
-      try {
-        this.parseObjectLike(8, true);
-        return errors.length === previousErrorCount;
-      } catch (_unused) {
-        return false;
-      }
-    }
-    if (this.match(0)) {
-      this.next();
-      const {
-        errors
-      } = this.state;
-      const previousErrorCount = errors.length;
-      try {
-        super.parseBindingList(3, 93, _lval.ParseBindingListFlags.ALLOW_EMPTY);
-        return errors.length === previousErrorCount;
-      } catch (_unused2) {
-        return false;
-      }
-    }
-    return false;
-  }
-  tsIsUnambiguouslyStartOfFunctionType() {
-    this.next();
-    if (this.match(11) || this.match(21)) {
-      return true;
-    }
-    if (this.tsSkipParameterStart()) {
-      if (this.match(14) || this.match(12) || this.match(17) || this.match(29)) {
-        return true;
-      }
-      if (this.match(11)) {
-        this.next();
-        if (this.match(19)) {
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-  tsParseTypeOrTypePredicateAnnotation(returnToken) {
-    return this.tsInType(() => {
-      const t = this.startNode();
-      this.expect(returnToken);
-      const node = this.startNode();
-      const asserts = !!this.tsTryParse(this.tsParseTypePredicateAsserts.bind(this));
-      if (asserts && this.match(78)) {
-        let thisTypePredicate = this.tsParseThisTypeOrThisTypePredicate();
-        if (thisTypePredicate.type === "TSThisType") {
-          node.parameterName = thisTypePredicate;
-          node.asserts = true;
-          node.typeAnnotation = null;
-          thisTypePredicate = this.finishNode(node, "TSTypePredicate");
-        } else {
-          this.resetStartLocationFromNode(thisTypePredicate, node);
-          thisTypePredicate.asserts = true;
-        }
-        t.typeAnnotation = thisTypePredicate;
-        return this.finishNode(t, "TSTypeAnnotation");
-      }
-      const typePredicateVariable = this.tsIsIdentifier() && this.tsTryParse(this.tsParseTypePredicatePrefix.bind(this));
-      if (!typePredicateVariable) {
-        if (!asserts) {
-          return this.tsParseTypeAnnotation(false, t);
-        }
-        node.parameterName = this.parseIdentifier();
-        node.asserts = asserts;
-        node.typeAnnotation = null;
-        t.typeAnnotation = this.finishNode(node, "TSTypePredicate");
-        return this.finishNode(t, "TSTypeAnnotation");
-      }
-      const type = this.tsParseTypeAnnotation(false);
-      node.parameterName = typePredicateVariable;
-      node.typeAnnotation = type;
-      node.asserts = asserts;
-      t.typeAnnotation = this.finishNode(node, "TSTypePredicate");
-      return this.finishNode(t, "TSTypeAnnotation");
-    });
-  }
-  tsTryParseTypeOrTypePredicateAnnotation() {
-    if (this.match(14)) {
-      return this.tsParseTypeOrTypePredicateAnnotation(14);
-    }
-  }
-  tsTryParseTypeAnnotation() {
-    if (this.match(14)) {
-      return this.tsParseTypeAnnotation();
-    }
-  }
-  tsTryParseType() {
-    return this.tsEatThenParseType(14);
-  }
-  tsParseTypePredicatePrefix() {
-    const id = this.parseIdentifier();
-    if (this.isContextual(114) && !this.hasPrecedingLineBreak()) {
-      this.next();
-      return id;
-    }
-  }
-  tsParseTypePredicateAsserts() {
-    if (this.state.type !== 107) {
-      return false;
-    }
-    const containsEsc = this.state.containsEsc;
-    this.next();
-    if (!(0, _types.tokenIsIdentifier)(this.state.type) && !this.match(78)) {
-      return false;
-    }
-    if (containsEsc) {
-      this.raise(_parseError.Errors.InvalidEscapedReservedWord, {
-        at: this.state.lastTokStartLoc,
-        reservedWord: "asserts"
-      });
-    }
-    return true;
-  }
-  tsParseTypeAnnotation(eatColon = true, t = this.startNode()) {
-    this.tsInType(() => {
-      if (eatColon) this.expect(14);
-      t.typeAnnotation = this.tsParseType();
-    });
-    return this.finishNode(t, "TSTypeAnnotation");
-  }
-  tsParseType() {
-    assert(this.state.inType);
-    const type = this.tsParseNonConditionalType();
-    if (this.state.inDisallowConditionalTypesContext || this.hasPrecedingLineBreak() || !this.eat(81)) {
-      return type;
-    }
-    const node = this.startNodeAtNode(type);
-    node.checkType = type;
-    node.extendsType = this.tsInDisallowConditionalTypesContext(() => this.tsParseNonConditionalType());
-    this.expect(17);
-    node.trueType = this.tsInAllowConditionalTypesContext(() => this.tsParseType());
-    this.expect(14);
-    node.falseType = this.tsInAllowConditionalTypesContext(() => this.tsParseType());
-    return this.finishNode(node, "TSConditionalType");
-  }
-  isAbstractConstructorSignature() {
-    return this.isContextual(122) && this.lookahead().type === 77;
-  }
-  tsParseNonConditionalType() {
-    if (this.tsIsStartOfFunctionType()) {
-      return this.tsParseFunctionOrConstructorType("TSFunctionType");
-    }
-    if (this.match(77)) {
-      return this.tsParseFunctionOrConstructorType("TSConstructorType");
-    } else if (this.isAbstractConstructorSignature()) {
-      return this.tsParseFunctionOrConstructorType("TSConstructorType", true);
-    }
-    return this.tsParseUnionTypeOrHigher();
-  }
-  tsParseTypeAssertion() {
-    if (this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) {
-      this.raise(TSErrors.ReservedTypeAssertion, {
-        at: this.state.startLoc
-      });
-    }
-    const node = this.startNode();
-    node.typeAnnotation = this.tsInType(() => {
-      this.next();
-      return this.match(75) ? this.tsParseTypeReference() : this.tsParseType();
-    });
-    this.expect(48);
-    node.expression = this.parseMaybeUnary();
-    return this.finishNode(node, "TSTypeAssertion");
-  }
-  tsParseHeritageClause(token) {
-    const originalStartLoc = this.state.startLoc;
-    const delimitedList = this.tsParseDelimitedList("HeritageClauseElement", () => {
-      const node = this.startNode();
-      node.expression = this.tsParseEntityName();
-      if (this.match(47)) {
-        node.typeParameters = this.tsParseTypeArguments();
-      }
-      return this.finishNode(node, "TSExpressionWithTypeArguments");
-    });
-    if (!delimitedList.length) {
-      this.raise(TSErrors.EmptyHeritageClauseType, {
-        at: originalStartLoc,
-        token
-      });
-    }
-    return delimitedList;
-  }
-  tsParseInterfaceDeclaration(node, properties = {}) {
-    if (this.hasFollowingLineBreak()) return null;
-    this.expectContextual(127);
-    if (properties.declare) node.declare = true;
-    if ((0, _types.tokenIsIdentifier)(this.state.type)) {
-      node.id = this.parseIdentifier();
-      this.checkIdentifier(node.id, _scopeflags.BindingFlag.TYPE_TS_INTERFACE);
-    } else {
-      node.id = null;
-      this.raise(TSErrors.MissingInterfaceName, {
-        at: this.state.startLoc
-      });
-    }
-    node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutConstModifiers);
-    if (this.eat(81)) {
-      node.extends = this.tsParseHeritageClause("extends");
-    }
-    const body = this.startNode();
-    body.body = this.tsInType(this.tsParseObjectTypeMembers.bind(this));
-    node.body = this.finishNode(body, "TSInterfaceBody");
-    return this.finishNode(node, "TSInterfaceDeclaration");
-  }
-  tsParseTypeAliasDeclaration(node) {
-    node.id = this.parseIdentifier();
-    this.checkIdentifier(node.id, _scopeflags.BindingFlag.TYPE_TS_TYPE);
-    node.typeAnnotation = this.tsInType(() => {
-      node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers);
-      this.expect(29);
-      if (this.isContextual(112) && this.lookahead().type !== 16) {
-        const node = this.startNode();
-        this.next();
-        return this.finishNode(node, "TSIntrinsicKeyword");
-      }
-      return this.tsParseType();
-    });
-    this.semicolon();
-    return this.finishNode(node, "TSTypeAliasDeclaration");
-  }
-  tsInNoContext(cb) {
-    const oldContext = this.state.context;
-    this.state.context = [oldContext[0]];
-    try {
-      return cb();
-    } finally {
-      this.state.context = oldContext;
-    }
-  }
-  tsInType(cb) {
-    const oldInType = this.state.inType;
-    this.state.inType = true;
-    try {
-      return cb();
-    } finally {
-      this.state.inType = oldInType;
-    }
-  }
-  tsInDisallowConditionalTypesContext(cb) {
-    const oldInDisallowConditionalTypesContext = this.state.inDisallowConditionalTypesContext;
-    this.state.inDisallowConditionalTypesContext = true;
-    try {
-      return cb();
-    } finally {
-      this.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;
-    }
-  }
-  tsInAllowConditionalTypesContext(cb) {
-    const oldInDisallowConditionalTypesContext = this.state.inDisallowConditionalTypesContext;
-    this.state.inDisallowConditionalTypesContext = false;
-    try {
-      return cb();
-    } finally {
-      this.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;
-    }
-  }
-  tsEatThenParseType(token) {
-    if (this.match(token)) {
-      return this.tsNextThenParseType();
-    }
-  }
-  tsExpectThenParseType(token) {
-    return this.tsInType(() => {
-      this.expect(token);
-      return this.tsParseType();
-    });
-  }
-  tsNextThenParseType() {
-    return this.tsInType(() => {
-      this.next();
-      return this.tsParseType();
-    });
-  }
-  tsParseEnumMember() {
-    const node = this.startNode();
-    node.id = this.match(131) ? super.parseStringLiteral(this.state.value) : this.parseIdentifier(true);
-    if (this.eat(29)) {
-      node.initializer = super.parseMaybeAssignAllowIn();
-    }
-    return this.finishNode(node, "TSEnumMember");
-  }
-  tsParseEnumDeclaration(node, properties = {}) {
-    if (properties.const) node.const = true;
-    if (properties.declare) node.declare = true;
-    this.expectContextual(124);
-    node.id = this.parseIdentifier();
-    this.checkIdentifier(node.id, node.const ? _scopeflags.BindingFlag.TYPE_TS_CONST_ENUM : _scopeflags.BindingFlag.TYPE_TS_ENUM);
-    this.expect(5);
-    node.members = this.tsParseDelimitedList("EnumMembers", this.tsParseEnumMember.bind(this));
-    this.expect(8);
-    return this.finishNode(node, "TSEnumDeclaration");
-  }
-  tsParseModuleBlock() {
-    const node = this.startNode();
-    this.scope.enter(_scopeflags.ScopeFlag.OTHER);
-    this.expect(5);
-    super.parseBlockOrModuleBlockBody(node.body = [], undefined, true, 8);
-    this.scope.exit();
-    return this.finishNode(node, "TSModuleBlock");
-  }
-  tsParseModuleOrNamespaceDeclaration(node, nested = false) {
-    node.id = this.parseIdentifier();
-    if (!nested) {
-      this.checkIdentifier(node.id, _scopeflags.BindingFlag.TYPE_TS_NAMESPACE);
-    }
-    if (this.eat(16)) {
-      const inner = this.startNode();
-      this.tsParseModuleOrNamespaceDeclaration(inner, true);
-      node.body = inner;
-    } else {
-      this.scope.enter(_scopeflags.ScopeFlag.TS_MODULE);
-      this.prodParam.enter(_productionParameter.PARAM);
-      node.body = this.tsParseModuleBlock();
-      this.prodParam.exit();
-      this.scope.exit();
-    }
-    return this.finishNode(node, "TSModuleDeclaration");
-  }
-  tsParseAmbientExternalModuleDeclaration(node) {
-    if (this.isContextual(110)) {
-      node.global = true;
-      node.id = this.parseIdentifier();
-    } else if (this.match(131)) {
-      node.id = super.parseStringLiteral(this.state.value);
-    } else {
-      this.unexpected();
-    }
-    if (this.match(5)) {
-      this.scope.enter(_scopeflags.ScopeFlag.TS_MODULE);
-      this.prodParam.enter(_productionParameter.PARAM);
-      node.body = this.tsParseModuleBlock();
-      this.prodParam.exit();
-      this.scope.exit();
-    } else {
-      this.semicolon();
-    }
-    return this.finishNode(node, "TSModuleDeclaration");
-  }
-  tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier, isExport) {
-    node.isExport = isExport || false;
-    node.id = maybeDefaultIdentifier || this.parseIdentifier();
-    this.checkIdentifier(node.id, _scopeflags.BindingFlag.TYPE_TS_VALUE_IMPORT);
-    this.expect(29);
-    const moduleReference = this.tsParseModuleReference();
-    if (node.importKind === "type" && moduleReference.type !== "TSExternalModuleReference") {
-      this.raise(TSErrors.ImportAliasHasImportType, {
-        at: moduleReference
-      });
-    }
-    node.moduleReference = moduleReference;
-    this.semicolon();
-    return this.finishNode(node, "TSImportEqualsDeclaration");
-  }
-  tsIsExternalModuleReference() {
-    return this.isContextual(117) && this.lookaheadCharCode() === 40;
-  }
-  tsParseModuleReference() {
-    return this.tsIsExternalModuleReference() ? this.tsParseExternalModuleReference() : this.tsParseEntityName(false);
-  }
-  tsParseExternalModuleReference() {
-    const node = this.startNode();
-    this.expectContextual(117);
-    this.expect(10);
-    if (!this.match(131)) {
-      this.unexpected();
-    }
-    node.expression = super.parseExprAtom();
-    this.expect(11);
-    this.sawUnambiguousESM = true;
-    return this.finishNode(node, "TSExternalModuleReference");
-  }
-  tsLookAhead(f) {
-    const state = this.state.clone();
-    const res = f();
-    this.state = state;
-    return res;
-  }
-  tsTryParseAndCatch(f) {
-    const result = this.tryParse(abort => f() || abort());
-    if (result.aborted || !result.node) return;
-    if (result.error) this.state = result.failState;
-    return result.node;
-  }
-  tsTryParse(f) {
-    const state = this.state.clone();
-    const result = f();
-    if (result !== undefined && result !== false) {
-      return result;
-    }
-    this.state = state;
-  }
-  tsTryParseDeclare(nany) {
-    if (this.isLineTerminator()) {
-      return;
-    }
-    let startType = this.state.type;
-    let kind;
-    if (this.isContextual(99)) {
-      startType = 74;
-      kind = "let";
-    }
-    return this.tsInAmbientContext(() => {
-      switch (startType) {
-        case 68:
-          nany.declare = true;
-          return super.parseFunctionStatement(nany, false, false);
-        case 80:
-          nany.declare = true;
-          return this.parseClass(nany, true, false);
-        case 124:
-          return this.tsParseEnumDeclaration(nany, {
-            declare: true
-          });
-        case 110:
-          return this.tsParseAmbientExternalModuleDeclaration(nany);
-        case 75:
-        case 74:
-          if (!this.match(75) || !this.isLookaheadContextual("enum")) {
-            nany.declare = true;
-            return this.parseVarStatement(nany, kind || this.state.value, true);
-          }
-          this.expect(75);
-          return this.tsParseEnumDeclaration(nany, {
-            const: true,
-            declare: true
-          });
-        case 127:
-          {
-            const result = this.tsParseInterfaceDeclaration(nany, {
-              declare: true
-            });
-            if (result) return result;
-          }
-        default:
-          if ((0, _types.tokenIsIdentifier)(startType)) {
-            return this.tsParseDeclaration(nany, this.state.value, true, null);
-          }
-      }
-    });
-  }
-  tsTryParseExportDeclaration() {
-    return this.tsParseDeclaration(this.startNode(), this.state.value, true, null);
-  }
-  tsParseExpressionStatement(node, expr, decorators) {
-    switch (expr.name) {
-      case "declare":
-        {
-          const declaration = this.tsTryParseDeclare(node);
-          if (declaration) {
-            declaration.declare = true;
-          }
-          return declaration;
-        }
-      case "global":
-        if (this.match(5)) {
-          this.scope.enter(_scopeflags.ScopeFlag.TS_MODULE);
-          this.prodParam.enter(_productionParameter.PARAM);
-          const mod = node;
-          mod.global = true;
-          mod.id = expr;
-          mod.body = this.tsParseModuleBlock();
-          this.scope.exit();
-          this.prodParam.exit();
-          return this.finishNode(mod, "TSModuleDeclaration");
-        }
-        break;
-      default:
-        return this.tsParseDeclaration(node, expr.name, false, decorators);
-    }
-  }
-  tsParseDeclaration(node, value, next, decorators) {
-    switch (value) {
-      case "abstract":
-        if (this.tsCheckLineTerminator(next) && (this.match(80) || (0, _types.tokenIsIdentifier)(this.state.type))) {
-          return this.tsParseAbstractDeclaration(node, decorators);
-        }
-        break;
-      case "module":
-        if (this.tsCheckLineTerminator(next)) {
-          if (this.match(131)) {
-            return this.tsParseAmbientExternalModuleDeclaration(node);
-          } else if ((0, _types.tokenIsIdentifier)(this.state.type)) {
-            return this.tsParseModuleOrNamespaceDeclaration(node);
-          }
-        }
-        break;
-      case "namespace":
-        if (this.tsCheckLineTerminator(next) && (0, _types.tokenIsIdentifier)(this.state.type)) {
-          return this.tsParseModuleOrNamespaceDeclaration(node);
-        }
-        break;
-      case "type":
-        if (this.tsCheckLineTerminator(next) && (0, _types.tokenIsIdentifier)(this.state.type)) {
-          return this.tsParseTypeAliasDeclaration(node);
-        }
-        break;
-    }
-  }
-  tsCheckLineTerminator(next) {
-    if (next) {
-      if (this.hasFollowingLineBreak()) return false;
-      this.next();
-      return true;
-    }
-    return !this.isLineTerminator();
-  }
-  tsTryParseGenericAsyncArrowFunction(startLoc) {
-    if (!this.match(47)) return;
-    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
-    this.state.maybeInArrowParameters = true;
-    const res = this.tsTryParseAndCatch(() => {
-      const node = this.startNodeAt(startLoc);
-      node.typeParameters = this.tsParseTypeParameters(this.tsParseConstModifier);
-      super.parseFunctionParams(node);
-      node.returnType = this.tsTryParseTypeOrTypePredicateAnnotation();
-      this.expect(19);
-      return node;
-    });
-    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
-    if (!res) return;
-    return super.parseArrowExpression(res, null, true);
-  }
-  tsParseTypeArgumentsInExpression() {
-    if (this.reScan_lt() !== 47) return;
-    return this.tsParseTypeArguments();
-  }
-  tsParseTypeArguments() {
-    const node = this.startNode();
-    node.params = this.tsInType(() => this.tsInNoContext(() => {
-      this.expect(47);
-      return this.tsParseDelimitedList("TypeParametersOrArguments", this.tsParseType.bind(this));
-    }));
-    if (node.params.length === 0) {
-      this.raise(TSErrors.EmptyTypeArguments, {
-        at: node
-      });
-    } else if (!this.state.inType && this.curContext() === _context.types.brace) {
-      this.reScan_lt_gt();
-    }
-    this.expect(48);
-    return this.finishNode(node, "TSTypeParameterInstantiation");
-  }
-  tsIsDeclarationStart() {
-    return (0, _types.tokenIsTSDeclarationStart)(this.state.type);
-  }
-  isExportDefaultSpecifier() {
-    if (this.tsIsDeclarationStart()) return false;
-    return super.isExportDefaultSpecifier();
-  }
-  parseAssignableListItem(flags, decorators) {
-    const startLoc = this.state.startLoc;
-    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 & _lval.ParseBindingListFlags.IS_CONSTRUCTOR_PARAMS) && (accessibility || readonly || override)) {
-      this.raise(TSErrors.UnexpectedParameterModifier, {
-        at: startLoc
-      });
-    }
-    const left = this.parseMaybeDefault();
-    this.parseAssignableListItemTypes(left, flags);
-    const elt = this.parseMaybeDefault(left.loc.start, left);
-    if (accessibility || readonly || override) {
-      const pp = this.startNodeAt(startLoc);
-      if (decorators.length) {
-        pp.decorators = decorators;
-      }
-      if (accessibility) pp.accessibility = accessibility;
-      if (readonly) pp.readonly = readonly;
-      if (override) pp.override = override;
-      if (elt.type !== "Identifier" && elt.type !== "AssignmentPattern") {
-        this.raise(TSErrors.UnsupportedParameterPropertyKind, {
-          at: pp
-        });
-      }
-      pp.parameter = elt;
-      return this.finishNode(pp, "TSParameterProperty");
-    }
-    if (decorators.length) {
-      left.decorators = decorators;
-    }
-    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
-        });
-      }
-    }
-  }
-  setArrowFunctionParameters(node, params, trailingCommaLoc) {
-    super.setArrowFunctionParameters(node, params, trailingCommaLoc);
-    this.tsDisallowOptionalPattern(node);
-  }
-  parseFunctionBodyAndFinish(node, type, isMethod = false) {
-    if (this.match(14)) {
-      node.returnType = this.tsParseTypeOrTypePredicateAnnotation(14);
-    }
-    const bodilessType = type === "FunctionDeclaration" ? "TSDeclareFunction" : type === "ClassMethod" || type === "ClassPrivateMethod" ? "TSDeclareMethod" : undefined;
-    if (bodilessType && !this.match(5) && this.isLineTerminator()) {
-      return this.finishNode(node, bodilessType);
-    }
-    if (bodilessType === "TSDeclareFunction" && this.state.isAmbientContext) {
-      this.raise(TSErrors.DeclareFunctionHasImplementation, {
-        at: node
-      });
-      if (node.declare) {
-        return super.parseFunctionBodyAndFinish(node, bodilessType, isMethod);
-      }
-    }
-    this.tsDisallowOptionalPattern(node);
-    return super.parseFunctionBodyAndFinish(node, type, isMethod);
-  }
-  registerFunctionStatementId(node) {
-    if (!node.body && node.id) {
-      this.checkIdentifier(node.id, _scopeflags.BindingFlag.TYPE_TS_AMBIENT);
-    } else {
-      super.registerFunctionStatementId(node);
-    }
-  }
-  tsCheckForInvalidTypeCasts(items) {
-    items.forEach(node => {
-      if ((node == null ? void 0 : node.type) === "TSTypeCastExpression") {
-        this.raise(TSErrors.UnexpectedTypeAnnotation, {
-          at: node.typeAnnotation
-        });
-      }
-    });
-  }
-  toReferencedList(exprList, isInParens) {
-    this.tsCheckForInvalidTypeCasts(exprList);
-    return exprList;
-  }
-  parseArrayLike(close, canBePattern, isTuple, refExpressionErrors) {
-    const node = super.parseArrayLike(close, canBePattern, isTuple, refExpressionErrors);
-    if (node.type === "ArrayExpression") {
-      this.tsCheckForInvalidTypeCasts(node.elements);
-    }
-    return node;
-  }
-  parseSubscript(base, startLoc, noCalls, state) {
-    if (!this.hasPrecedingLineBreak() && this.match(35)) {
-      this.state.canStartJSXElement = false;
-      this.next();
-      const nonNullExpression = this.startNodeAt(startLoc);
-      nonNullExpression.expression = base;
-      return this.finishNode(nonNullExpression, "TSNonNullExpression");
-    }
-    let isOptionalCall = false;
-    if (this.match(18) && this.lookaheadCharCode() === 60) {
-      if (noCalls) {
-        state.stop = true;
-        return base;
-      }
-      state.optionalChainMember = isOptionalCall = true;
-      this.next();
-    }
-    if (this.match(47) || this.match(51)) {
-      let missingParenErrorLoc;
-      const result = this.tsTryParseAndCatch(() => {
-        if (!noCalls && this.atPossibleAsyncArrow(base)) {
-          const asyncArrowFn = this.tsTryParseGenericAsyncArrowFunction(startLoc);
-          if (asyncArrowFn) {
-            return asyncArrowFn;
-          }
-        }
-        const typeArguments = this.tsParseTypeArgumentsInExpression();
-        if (!typeArguments) return;
-        if (isOptionalCall && !this.match(10)) {
-          missingParenErrorLoc = this.state.curPosition();
-          return;
-        }
-        if ((0, _types.tokenIsTemplate)(this.state.type)) {
-          const result = super.parseTaggedTemplateExpression(base, startLoc, state);
-          result.typeParameters = typeArguments;
-          return result;
-        }
-        if (!noCalls && this.eat(10)) {
-          const node = this.startNodeAt(startLoc);
-          node.callee = base;
-          node.arguments = this.parseCallExpressionArguments(11, false);
-          this.tsCheckForInvalidTypeCasts(node.arguments);
-          node.typeParameters = typeArguments;
-          if (state.optionalChainMember) {
-            node.optional = isOptionalCall;
-          }
-          return this.finishCallExpression(node, state.optionalChainMember);
-        }
-        const tokenType = this.state.type;
-        if (tokenType === 48 || tokenType === 52 || tokenType !== 10 && (0, _types.tokenCanStartExpression)(tokenType) && !this.hasPrecedingLineBreak()) {
-          return;
-        }
-        const node = this.startNodeAt(startLoc);
-        node.expression = base;
-        node.typeParameters = typeArguments;
-        return this.finishNode(node, "TSInstantiationExpression");
-      });
-      if (missingParenErrorLoc) {
-        this.unexpected(missingParenErrorLoc, 10);
-      }
-      if (result) {
-        if (result.type === "TSInstantiationExpression" && (this.match(16) || this.match(18) && this.lookaheadCharCode() !== 40)) {
-          this.raise(TSErrors.InvalidPropertyAccessAfterInstantiationExpression, {
-            at: this.state.startLoc
-          });
-        }
-        return result;
-      }
-    }
-    return super.parseSubscript(base, startLoc, noCalls, state);
-  }
-  parseNewCallee(node) {
-    var _callee$extra;
-    super.parseNewCallee(node);
-    const {
-      callee
-    } = node;
-    if (callee.type === "TSInstantiationExpression" && !((_callee$extra = callee.extra) != null && _callee$extra.parenthesized)) {
-      node.typeParameters = callee.typeParameters;
-      node.callee = callee.expression;
-    }
-  }
-  parseExprOp(left, leftStartLoc, minPrec) {
-    let isSatisfies;
-    if ((0, _types.tokenOperatorPrecedence)(58) > minPrec && !this.hasPrecedingLineBreak() && (this.isContextual(93) || (isSatisfies = this.isContextual(118)))) {
-      const node = this.startNodeAt(leftStartLoc);
-      node.expression = left;
-      node.typeAnnotation = this.tsInType(() => {
-        this.next();
-        if (this.match(75)) {
-          if (isSatisfies) {
-            this.raise(_parseError.Errors.UnexpectedKeyword, {
-              at: this.state.startLoc,
-              keyword: "const"
-            });
-          }
-          return this.tsParseTypeReference();
-        }
-        return this.tsParseType();
-      });
-      this.finishNode(node, isSatisfies ? "TSSatisfiesExpression" : "TSAsExpression");
-      this.reScan_lt_gt();
-      return this.parseExprOp(node, leftStartLoc, minPrec);
-    }
-    return super.parseExprOp(left, leftStartLoc, minPrec);
-  }
-  checkReservedWord(word, startLoc, checkKeywords, isBinding) {
-    if (!this.state.isAmbientContext) {
-      super.checkReservedWord(word, startLoc, checkKeywords, isBinding);
-    }
-  }
-  checkImportReflection(node) {
-    super.checkImportReflection(node);
-    if (node.module && node.importKind !== "value") {
-      this.raise(TSErrors.ImportReflectionHasImportType, {
-        at: node.specifiers[0].loc.start
-      });
-    }
-  }
-  checkDuplicateExports() {}
-  isPotentialImportPhase(isExport) {
-    if (super.isPotentialImportPhase(isExport)) return true;
-    if (this.isContextual(128)) {
-      const ch = this.lookaheadCharCode();
-      return isExport ? ch === 123 || ch === 42 : ch !== 61;
-    }
-    return !isExport && this.isContextual(87);
-  }
-  applyImportPhase(node, isExport, phase, loc) {
-    super.applyImportPhase(node, isExport, phase, loc);
-    if (isExport) {
-      node.exportKind = phase === "type" ? "type" : "value";
-    } else {
-      node.importKind = phase === "type" || phase === "typeof" ? phase : "value";
-    }
-  }
-  parseImport(node) {
-    if (this.match(131)) {
-      node.importKind = "value";
-      return super.parseImport(node);
-    }
-    let importNode;
-    if ((0, _types.tokenIsIdentifier)(this.state.type) && this.lookaheadCharCode() === 61) {
-      node.importKind = "value";
-      return this.tsParseImportEqualsDeclaration(node);
-    } else if (this.isContextual(128)) {
-      const maybeDefaultIdentifier = this.parseMaybeImportPhase(node, false);
-      if (this.lookaheadCharCode() === 61) {
-        return this.tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier);
-      } else {
-        importNode = super.parseImportSpecifiersAndAfter(node, maybeDefaultIdentifier);
-      }
-    } else {
-      importNode = super.parseImport(node);
-    }
-    if (importNode.importKind === "type" && importNode.specifiers.length > 1 && importNode.specifiers[0].type === "ImportDefaultSpecifier") {
-      this.raise(TSErrors.TypeImportCannotSpecifyDefaultAndNamed, {
-        at: importNode
-      });
-    }
-    return importNode;
-  }
-  parseExport(node, decorators) {
-    if (this.match(83)) {
-      this.next();
-      let maybeDefaultIdentifier = null;
-      if (this.isContextual(128) && this.isPotentialImportPhase(false)) {
-        maybeDefaultIdentifier = this.parseMaybeImportPhase(node, false);
-      } else {
-        node.importKind = "value";
-      }
-      return this.tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier, true);
-    } else if (this.eat(29)) {
-      const assign = node;
-      assign.expression = super.parseExpression();
-      this.semicolon();
-      this.sawUnambiguousESM = true;
-      return this.finishNode(assign, "TSExportAssignment");
-    } else if (this.eatContextual(93)) {
-      const decl = node;
-      this.expectContextual(126);
-      decl.id = this.parseIdentifier();
-      this.semicolon();
-      return this.finishNode(decl, "TSNamespaceExportDeclaration");
-    } else {
-      return super.parseExport(node, decorators);
-    }
-  }
-  isAbstractClass() {
-    return this.isContextual(122) && this.lookahead().type === 80;
-  }
-  parseExportDefaultExpression() {
-    if (this.isAbstractClass()) {
-      const cls = this.startNode();
-      this.next();
-      cls.abstract = true;
-      return this.parseClass(cls, true, true);
-    }
-    if (this.match(127)) {
-      const result = this.tsParseInterfaceDeclaration(this.startNode());
-      if (result) return result;
-    }
-    return super.parseExportDefaultExpression();
-  }
-  parseVarStatement(node, kind, allowMissingInitializer = false) {
-    const {
-      isAmbientContext
-    } = this.state;
-    const declaration = super.parseVarStatement(node, kind, allowMissingInitializer || isAmbientContext);
-    if (!isAmbientContext) return declaration;
-    for (const {
-      id,
-      init
-    } of declaration.declarations) {
-      if (!init) continue;
-      if (kind !== "const" || !!id.typeAnnotation) {
-        this.raise(TSErrors.InitializerNotAllowedInAmbientContext, {
-          at: init
-        });
-      } else if (!isValidAmbientConstInitializer(init, this.hasPlugin("estree"))) {
-        this.raise(TSErrors.ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference, {
-          at: init
-        });
-      }
-    }
-    return declaration;
-  }
-  parseStatementContent(flags, decorators) {
-    if (this.match(75) && this.isLookaheadContextual("enum")) {
-      const node = this.startNode();
-      this.expect(75);
-      return this.tsParseEnumDeclaration(node, {
-        const: true
-      });
-    }
-    if (this.isContextual(124)) {
-      return this.tsParseEnumDeclaration(this.startNode());
-    }
-    if (this.isContextual(127)) {
-      const result = this.tsParseInterfaceDeclaration(this.startNode());
-      if (result) return result;
-    }
-    return super.parseStatementContent(flags, decorators);
-  }
-  parseAccessModifier() {
-    return this.tsParseModifier(["public", "protected", "private"]);
-  }
-  tsHasSomeModifiers(member, modifiers) {
-    return modifiers.some(modifier => {
-      if (tsIsAccessModifier(modifier)) {
-        return member.accessibility === modifier;
-      }
-      return !!member[modifier];
-    });
-  }
-  tsIsStartOfStaticBlocks() {
-    return this.isContextual(104) && this.lookaheadCharCode() === 123;
-  }
-  parseClassMember(classBody, member, state) {
-    const modifiers = ["declare", "private", "public", "protected", "override", "abstract", "readonly", "static"];
-    this.tsParseModifiers({
-      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 = (0, _types.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 ? _scopeflags.BindingFlag.TYPE_TS_AMBIENT : _scopeflags.BindingFlag.TYPE_CLASS);
-    const typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutConstModifiers);
-    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(this.tsParseConstModifier);
-    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(this.tsParseConstModifier);
-    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(this.tsParseConstModifier);
-    if (typeParameters) prop.typeParameters = typeParameters;
-    return super.parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors);
-  }
-  parseFunctionParams(node, isConstructor) {
-    const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
-    if (typeParameters) node.typeParameters = typeParameters;
-    super.parseFunctionParams(node, isConstructor);
-  }
-  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();
-    }
-    return super.parseAsyncArrowFromCallExpression(node, call);
-  }
-  parseMaybeAssign(refExpressionErrors, afterLeftParse) {
-    var _jsx, _jsx2, _typeCast, _jsx3, _typeCast2;
-    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 === _context.types.j_oTag || currentContext === _context.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;
-    }
-    if ((_typeCast = typeCast) != null && _typeCast.node) {
-      this.state = typeCast.failState;
-      return typeCast.node;
-    }
-    throw ((_jsx3 = jsx) == null ? void 0 : _jsx3.error) || arrow.error || ((_typeCast2 = typeCast) == null ? void 0 : _typeCast2.error);
-  }
-  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
-      });
-    }
-  }
-  parseMaybeUnary(refExpressionErrors, sawUnary) {
-    if (!this.hasPlugin("jsx") && this.match(47)) {
-      return this.tsParseTypeAssertion();
-    }
-    return super.parseMaybeUnary(refExpressionErrors, sawUnary);
-  }
-  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.parseArrow(node);
-  }
-  parseAssignableListItemTypes(param, flags) {
-    if (!(flags & _lval.ParseBindingListFlags.IS_FUNCTION_PARAMS)) return param;
-    if (this.eat(17)) {
-      param.optional = true;
-    }
-    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);
-    }
-  }
-  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);
-    }
-  }
-  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);
-    }
-  }
-  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);
-    }
-  }
-  isValidLVal(type, isUnparenthesizedInAssign, binding) {
-    return getOwn({
-      TSTypeCastExpression: true,
-      TSParameterProperty: "parameter",
-      TSNonNullExpression: "expression",
-      TSAsExpression: (binding !== _scopeflags.BindingFlag.TYPE_NONE || !isUnparenthesizedInAssign) && ["expression", true],
-      TSSatisfiesExpression: (binding !== _scopeflags.BindingFlag.TYPE_NONE || !isUnparenthesizedInAssign) && ["expression", true],
-      TSTypeAssertion: (binding !== _scopeflags.BindingFlag.TYPE_NONE || !isUnparenthesizedInAssign) && ["expression", true]
-    }, type) || super.isValidLVal(type, isUnparenthesizedInAssign, binding);
-  }
-  parseBindingAtom() {
-    if (this.state.type === 78) {
-      return this.parseIdentifier(true);
-    }
-    return super.parseBindingAtom();
-  }
-  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);
-  }
-  checkCommaAfterRest(close) {
-    if (this.state.isAmbientContext && this.match(12) && this.lookaheadCharCode() === close) {
-      this.next();
-      return false;
-    }
-    return super.checkCommaAfterRest(close);
-  }
-  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 (this.state.inType) {
-      if (code === 62) {
-        this.finishOp(48, 1);
-        return;
-      }
-      if (code === 60) {
-        this.finishOp(47, 1);
-        return;
-      }
-    }
-    super.getTokenFromCode(code);
-  }
-  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();
-    }
-  }
-  reScan_lt() {
-    const {
-      type
-    } = this.state;
-    if (type === 51) {
-      this.state.pos -= 2;
-      this.finishOp(47, 1);
-      return 47;
-    }
-    return type;
-  }
-  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);
-  }
-  typeCastToParameter(node) {
-    node.expression.typeAnnotation = node.typeAnnotation;
-    this.resetEndLocation(node.expression, node.typeAnnotation.loc.end);
-    return node.expression;
-  }
-  shouldParseArrow(params) {
-    if (this.match(14)) {
-      return params.every(expr => this.isAssignable(expr, true));
-    }
-    return super.shouldParseArrow(params);
-  }
-  shouldParseAsyncArrow() {
-    return this.match(14) || super.shouldParseAsyncArrow();
-  }
-  canHaveLeadingDecorator() {
-    return super.canHaveLeadingDecorator() || this.isAbstractClass();
-  }
-  jsxParseOpeningElementAfterName(node) {
-    if (this.match(47) || this.match(51)) {
-      const typeArguments = this.tsTryParseAndCatch(() => this.tsParseTypeArgumentsInExpression());
-      if (typeArguments) node.typeParameters = typeArguments;
-    }
-    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);
-    }
-    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 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.unexpected(null, 80);
-    }
-  }
-  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 method;
-  }
-  tsParseTypeParameterName() {
-    const typeName = this.parseIdentifier();
-    return typeName.name;
-  }
-  shouldParseAsAmbientContext() {
-    return !!this.getPluginOption("typescript", "dts");
-  }
-  parse() {
-    if (this.shouldParseAsAmbientContext()) {
-      this.state.isAmbientContext = true;
-    }
-    return super.parse();
-  }
-  getExpression() {
-    if (this.shouldParseAsAmbientContext()) {
-      this.state.isAmbientContext = true;
-    }
-    return super.getExpression();
-  }
-  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);
-  }
-  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 ? _scopeflags.BindingFlag.TYPE_TS_TYPE_IMPORT : _scopeflags.BindingFlag.TYPE_TS_VALUE_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 ((0, _types.tokenIsKeywordOrIdentifier)(this.state.type)) {
-          hasTypeSpecifier = true;
-          leftOfAs = firstAs;
-          rightOfAs = isImport ? this.parseIdentifier() : this.parseModuleExportName();
-          canParseAsKeyword = false;
-        } else {
-          rightOfAs = secondAs;
-          canParseAsKeyword = false;
-        }
-      } else if ((0, _types.tokenIsKeywordOrIdentifier)(this.state.type)) {
-        canParseAsKeyword = false;
-        rightOfAs = isImport ? this.parseIdentifier() : this.parseModuleExportName();
-      } else {
-        hasTypeSpecifier = true;
-        leftOfAs = firstAs;
-      }
-    } else if ((0, _types.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();
-      }
-    }
-    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] = (0, _node.cloneIdentifier)(node[leftOfAsKey]);
-    }
-    if (isImport) {
-      this.checkIdentifier(node[rightOfAsKey], hasTypeSpecifier ? _scopeflags.BindingFlag.TYPE_TS_TYPE_IMPORT : _scopeflags.BindingFlag.TYPE_TS_VALUE_IMPORT);
-    }
-  }
-};
-exports.default = _default;
-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;
-    }
-  }
-  if (isNumber(expression, estree) || isNegativeNumber(expression, estree)) {
-    return true;
-  }
-  if (type === "TemplateLiteral" && expression.expressions.length === 0) {
-    return true;
-  }
-  if (isPossiblyLiteralEnum(expression)) {
-    return true;
-  }
-  return false;
-}
-function isNumber(expression, estree) {
-  if (estree) {
-    return expression.type === "Literal" && (typeof expression.value === "number" || "bigint" in expression);
-  }
-  return expression.type === "NumericLiteral" || expression.type === "BigIntLiteral";
-}
-function isNegativeNumber(expression, estree) {
-  if (expression.type === "UnaryExpression") {
-    const {
-      operator,
-      argument
-    } = expression;
-    if (operator === "-" && isNumber(argument, estree)) {
-      return true;
-    }
-  }
-  return false;
-}
-function isUncomputedMemberExpressionChain(expression) {
-  if (expression.type === "Identifier") return true;
-  if (expression.type !== "MemberExpression" || expression.computed) {
-    return false;
-  }
-  return isUncomputedMemberExpressionChain(expression.object);
-}
-
-//# sourceMappingURL=index.js.map