(function (f) {
  function e() {
    var i = f();
    return i.default || i;
  }
  if (typeof exports == "object" && typeof module == "object")
    module.exports = e();
  else if (typeof define == "function" && define.amd) define(e);
  else {
    var t =
      typeof globalThis < "u"
        ? globalThis
        : typeof global < "u"
          ? global
          : typeof self < "u"
            ? self
            : this || {};
    (t.prettierPlugins = t.prettierPlugins || {}),
      (t.prettierPlugins.babel = e());
  }
})(function () {
  "use strict";
  var $s = Object.create;
  var Se = Object.defineProperty;
  var Vs = Object.getOwnPropertyDescriptor;
  var qs = Object.getOwnPropertyNames;
  var zs = Object.getPrototypeOf,
    Ks = Object.prototype.hasOwnProperty;
  var Hs = (a, t) => () => (
      t || a((t = { exports: {} }).exports, t), t.exports
    ),
    Ws = (a, t) => {
      for (var e in t) Se(a, e, { get: t[e], enumerable: !0 });
    },
    kt = (a, t, e, s) => {
      if ((t && typeof t == "object") || typeof t == "function")
        for (let i of qs(t))
          !Ks.call(a, i) &&
            i !== e &&
            Se(a, i, {
              get: () => t[i],
              enumerable: !(s = Vs(t, i)) || s.enumerable,
            });
      return a;
    };
  var vt = (a, t, e) => (
      (e = a != null ? $s(zs(a)) : {}),
      kt(
        t || !a || !a.__esModule
          ? Se(e, "default", { value: a, enumerable: !0 })
          : e,
        a,
      )
    ),
    Js = (a) => kt(Se({}, "__esModule", { value: !0 }), a);
  var At = Hs((xe) => {
    "use strict";
    Object.defineProperty(xe, "__esModule", { value: !0 });
    function Ht(a, t) {
      if (a == null) return {};
      var e = {},
        s = Object.keys(a),
        i,
        r;
      for (r = 0; r < s.length; r++)
        (i = s[r]), !(t.indexOf(i) >= 0) && (e[i] = a[i]);
      return e;
    }
    var F = class {
        constructor(t, e, s) {
          (this.line = void 0),
            (this.column = void 0),
            (this.index = void 0),
            (this.line = t),
            (this.column = e),
            (this.index = s);
        }
      },
      ee = class {
        constructor(t, e) {
          (this.start = void 0),
            (this.end = void 0),
            (this.filename = void 0),
            (this.identifierName = void 0),
            (this.start = t),
            (this.end = e);
        }
      };
    function v(a, t) {
      let { line: e, column: s, index: i } = a;
      return new F(e, s + t, i + t);
    }
    var Lt = "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED",
      Xs = {
        ImportMetaOutsideModule: {
          message: `import.meta may appear only with 'sourceType: "module"'`,
          code: Lt,
        },
        ImportOutsideModule: {
          message: `'import' and 'export' may appear only with 'sourceType: "module"'`,
          code: Lt,
        },
      },
      Dt = {
        ArrayPattern: "array destructuring pattern",
        AssignmentExpression: "assignment expression",
        AssignmentPattern: "assignment expression",
        ArrowFunctionExpression: "arrow function expression",
        ConditionalExpression: "conditional expression",
        CatchClause: "catch clause",
        ForOfStatement: "for-of statement",
        ForInStatement: "for-in statement",
        ForStatement: "for-loop",
        FormalParameters: "function parameter list",
        Identifier: "identifier",
        ImportSpecifier: "import specifier",
        ImportDefaultSpecifier: "import default specifier",
        ImportNamespaceSpecifier: "import namespace specifier",
        ObjectPattern: "object destructuring pattern",
        ParenthesizedExpression: "parenthesized expression",
        RestElement: "rest element",
        UpdateExpression: {
          true: "prefix operation",
          false: "postfix operation",
        },
        VariableDeclarator: "variable declaration",
        YieldExpression: "yield expression",
      },
      Ee = (a) =>
        a.type === "UpdateExpression"
          ? Dt.UpdateExpression[`${a.prefix}`]
          : Dt[a.type],
      Gs = {
        AccessorIsGenerator: ({ kind: a }) =>
          `A ${a}ter cannot be a generator.`,
        ArgumentsInClass:
          "'arguments' is only allowed in functions and class methods.",
        AsyncFunctionInSingleStatementContext:
          "Async functions can only be declared at the top level or inside a block.",
        AwaitBindingIdentifier:
          "Can not use 'await' as identifier inside an async function.",
        AwaitBindingIdentifierInStaticBlock:
          "Can not use 'await' as identifier inside a static block.",
        AwaitExpressionFormalParameter:
          "'await' is not allowed in async function parameters.",
        AwaitUsingNotInAsyncContext:
          "'await using' is only allowed within async functions and at the top levels of modules.",
        AwaitNotInAsyncContext:
          "'await' is only allowed within async functions and at the top levels of modules.",
        AwaitNotInAsyncFunction:
          "'await' is only allowed within async functions.",
        BadGetterArity: "A 'get' accessor must not have any formal parameters.",
        BadSetterArity:
          "A 'set' accessor must have exactly one formal parameter.",
        BadSetterRestParameter:
          "A 'set' accessor function argument must not be a rest parameter.",
        ConstructorClassField:
          "Classes may not have a field named 'constructor'.",
        ConstructorClassPrivateField:
          "Classes may not have a private field named '#constructor'.",
        ConstructorIsAccessor: "Class constructor may not be an accessor.",
        ConstructorIsAsync: "Constructor can't be an async function.",
        ConstructorIsGenerator: "Constructor can't be a generator.",
        DeclarationMissingInitializer: ({ kind: a }) =>
          `Missing initializer in ${a} declaration.`,
        DecoratorArgumentsOutsideParentheses:
          "Decorator arguments must be moved inside parentheses: use '@(decorator(args))' instead of '@(decorator)(args)'.",
        DecoratorBeforeExport:
          "Decorators must be placed *before* the 'export' keyword. Remove the 'decoratorsBeforeExport: true' option to use the 'export @decorator class {}' syntax.",
        DecoratorsBeforeAfterExport:
          "Decorators can be placed *either* before or after the 'export' keyword, but not in both locations at the same time.",
        DecoratorConstructor:
          "Decorators can't be used with a constructor. Did you mean '@dec class { ... }'?",
        DecoratorExportClass:
          "Decorators must be placed *after* the 'export' keyword. Remove the 'decoratorsBeforeExport: false' option to use the '@decorator export class {}' syntax.",
        DecoratorSemicolon: "Decorators must not be followed by a semicolon.",
        DecoratorStaticBlock: "Decorators can't be used with a static block.",
        DeferImportRequiresNamespace:
          'Only `import defer * as x from "./module"` is valid.',
        DeletePrivateField: "Deleting a private field is not allowed.",
        DestructureNamedImport:
          "ES2015 named imports do not destructure. Use another statement for destructuring after the import.",
        DuplicateConstructor: "Duplicate constructor in the same class.",
        DuplicateDefaultExport: "Only one default export allowed per module.",
        DuplicateExport: ({ exportName: a }) =>
          `\`${a}\` has already been exported. Exported identifiers must be unique.`,
        DuplicateProto: "Redefinition of __proto__ property.",
        DuplicateRegExpFlags: "Duplicate regular expression flag.",
        DynamicImportPhaseRequiresImportExpressions: ({ phase: a }) =>
          `'import.${a}(...)' can only be parsed when using the 'createImportExpressions' option.`,
        ElementAfterRest: "Rest element must be last element.",
        EscapedCharNotAnIdentifier: "Invalid Unicode escape.",
        ExportBindingIsString: ({
          localName: a,
          exportName: t,
        }) => `A string literal cannot be used as an exported binding without \`from\`.
- Did you mean \`export { '${a}' as '${t}' } from 'some-module'\`?`,
        ExportDefaultFromAsIdentifier:
          "'from' is not allowed as an identifier after 'export default'.",
        ForInOfLoopInitializer: ({ type: a }) =>
          `'${a === "ForInStatement" ? "for-in" : "for-of"}' loop variable declaration may not have an initializer.`,
        ForInUsing: "For-in loop may not start with 'using' declaration.",
        ForOfAsync: "The left-hand side of a for-of loop may not be 'async'.",
        ForOfLet:
          "The left-hand side of a for-of loop may not start with 'let'.",
        GeneratorInSingleStatementContext:
          "Generators can only be declared at the top level or inside a block.",
        IllegalBreakContinue: ({ type: a }) =>
          `Unsyntactic ${a === "BreakStatement" ? "break" : "continue"}.`,
        IllegalLanguageModeDirective:
          "Illegal 'use strict' directive in function with non-simple parameter list.",
        IllegalReturn: "'return' outside of function.",
        ImportAttributesUseAssert:
          "The `assert` keyword in import attributes is deprecated and it has been replaced by the `with` keyword. You can enable the `deprecatedAssertSyntax: true` option in the import attributes plugin to suppress this error.",
        ImportBindingIsString: ({
          importName: a,
        }) => `A string literal cannot be used as an imported binding.
- Did you mean \`import { "${a}" as foo }\`?`,
        ImportCallArgumentTrailingComma:
          "Trailing comma is disallowed inside import(...) arguments.",
        ImportCallArity: ({ maxArgumentCount: a }) =>
          `\`import()\` requires exactly ${a === 1 ? "one argument" : "one or two arguments"}.`,
        ImportCallNotNewExpression: "Cannot use new with import(...).",
        ImportCallSpreadArgument: "`...` is not allowed in `import()`.",
        ImportJSONBindingNotDefault:
          "A JSON module can only be imported with `default`.",
        ImportReflectionHasAssertion:
          "`import module x` cannot have assertions.",
        ImportReflectionNotBinding:
          'Only `import module x from "./module"` is valid.',
        IncompatibleRegExpUVFlags:
          "The 'u' and 'v' regular expression flags cannot be enabled at the same time.",
        InvalidBigIntLiteral: "Invalid BigIntLiteral.",
        InvalidCodePoint: "Code point out of bounds.",
        InvalidCoverInitializedName: "Invalid shorthand property initializer.",
        InvalidDecimal: "Invalid decimal.",
        InvalidDigit: ({ radix: a }) => `Expected number in radix ${a}.`,
        InvalidEscapeSequence: "Bad character escape sequence.",
        InvalidEscapeSequenceTemplate: "Invalid escape sequence in template.",
        InvalidEscapedReservedWord: ({ reservedWord: a }) =>
          `Escape sequence in keyword ${a}.`,
        InvalidIdentifier: ({ identifierName: a }) =>
          `Invalid identifier ${a}.`,
        InvalidLhs: ({ ancestor: a }) => `Invalid left-hand side in ${Ee(a)}.`,
        InvalidLhsBinding: ({ ancestor: a }) =>
          `Binding invalid left-hand side in ${Ee(a)}.`,
        InvalidLhsOptionalChaining: ({ ancestor: a }) =>
          `Invalid optional chaining in the left-hand side of ${Ee(a)}.`,
        InvalidNumber: "Invalid number.",
        InvalidOrMissingExponent:
          "Floating-point numbers require a valid exponent after the 'e'.",
        InvalidOrUnexpectedToken: ({ unexpected: a }) =>
          `Unexpected character '${a}'.`,
        InvalidParenthesizedAssignment:
          "Invalid parenthesized assignment pattern.",
        InvalidPrivateFieldResolution: ({ identifierName: a }) =>
          `Private name #${a} is not defined.`,
        InvalidPropertyBindingPattern: "Binding member expression.",
        InvalidRecordProperty:
          "Only properties and spread elements are allowed in record definitions.",
        InvalidRestAssignmentPattern: "Invalid rest operator's argument.",
        LabelRedeclaration: ({ labelName: a }) =>
          `Label '${a}' is already declared.`,
        LetInLexicalBinding: "'let' is disallowed as a lexically bound name.",
        LineTerminatorBeforeArrow: "No line break is allowed before '=>'.",
        MalformedRegExpFlags: "Invalid regular expression flag.",
        MissingClassName: "A class name is required.",
        MissingEqInAssignment:
          "Only '=' operator can be used for specifying default value.",
        MissingSemicolon: "Missing semicolon.",
        MissingPlugin: ({ missingPlugin: a }) =>
          `This experimental syntax requires enabling the parser plugin: ${a.map((t) => JSON.stringify(t)).join(", ")}.`,
        MissingOneOfPlugins: ({ missingPlugin: a }) =>
          `This experimental syntax requires enabling one of the following parser plugin(s): ${a.map((t) => JSON.stringify(t)).join(", ")}.`,
        MissingUnicodeEscape: "Expecting Unicode escape sequence \\uXXXX.",
        MixingCoalesceWithLogical:
          "Nullish coalescing operator(??) requires parens when mixing with logical operators.",
        ModuleAttributeDifferentFromType:
          "The only accepted module attribute is `type`.",
        ModuleAttributeInvalidValue:
          "Only string literals are allowed as module attribute values.",
        ModuleAttributesWithDuplicateKeys: ({ key: a }) =>
          `Duplicate key "${a}" is not allowed in module attributes.`,
        ModuleExportNameHasLoneSurrogate: ({ surrogateCharCode: a }) =>
          `An export name cannot include a lone surrogate, found '\\u${a.toString(16)}'.`,
        ModuleExportUndefined: ({ localName: a }) =>
          `Export '${a}' is not defined.`,
        MultipleDefaultsInSwitch: "Multiple default clauses.",
        NewlineAfterThrow: "Illegal newline after throw.",
        NoCatchOrFinally: "Missing catch or finally clause.",
        NumberIdentifier: "Identifier directly after number.",
        NumericSeparatorInEscapeSequence:
          "Numeric separators are not allowed inside unicode escape sequences or hex escape sequences.",
        ObsoleteAwaitStar:
          "'await*' has been removed from the async functions proposal. Use Promise.all() instead.",
        OptionalChainingNoNew:
          "Constructors in/after an Optional Chain are not allowed.",
        OptionalChainingNoTemplate:
          "Tagged Template Literals are not allowed in optionalChain.",
        OverrideOnConstructor:
          "'override' modifier cannot appear on a constructor declaration.",
        ParamDupe: "Argument name clash.",
        PatternHasAccessor: "Object pattern can't contain getter or setter.",
        PatternHasMethod: "Object pattern can't contain methods.",
        PrivateInExpectedIn: ({ identifierName: a }) =>
          `Private names are only allowed in property accesses (\`obj.#${a}\`) or in \`in\` expressions (\`#${a} in obj\`).`,
        PrivateNameRedeclaration: ({ identifierName: a }) =>
          `Duplicate private name #${a}.`,
        RecordExpressionBarIncorrectEndSyntaxType:
          "Record expressions ending with '|}' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.",
        RecordExpressionBarIncorrectStartSyntaxType:
          "Record expressions starting with '{|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.",
        RecordExpressionHashIncorrectStartSyntaxType:
          "Record expressions starting with '#{' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'hash'.",
        RecordNoProto: "'__proto__' is not allowed in Record expressions.",
        RestTrailingComma: "Unexpected trailing comma after rest element.",
        SloppyFunction:
          "In non-strict mode code, functions can only be declared at top level or inside a block.",
        SloppyFunctionAnnexB:
          "In non-strict mode code, functions can only be declared at top level, inside a block, or as the body of an if statement.",
        SourcePhaseImportRequiresDefault:
          'Only `import source x from "./module"` is valid.',
        StaticPrototype:
          "Classes may not have static property named prototype.",
        SuperNotAllowed:
          "`super()` is only valid inside a class constructor of a subclass. Maybe a typo in the method name ('constructor') or not extending another class?",
        SuperPrivateField: "Private fields can't be accessed on super.",
        TrailingDecorator: "Decorators must be attached to a class element.",
        TupleExpressionBarIncorrectEndSyntaxType:
          "Tuple expressions ending with '|]' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.",
        TupleExpressionBarIncorrectStartSyntaxType:
          "Tuple expressions starting with '[|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.",
        TupleExpressionHashIncorrectStartSyntaxType:
          "Tuple expressions starting with '#[' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'hash'.",
        UnexpectedArgumentPlaceholder: "Unexpected argument placeholder.",
        UnexpectedAwaitAfterPipelineBody:
          'Unexpected "await" after pipeline body; await must have parentheses in minimal proposal.',
        UnexpectedDigitAfterHash: "Unexpected digit after hash token.",
        UnexpectedImportExport:
          "'import' and 'export' may only appear at the top level.",
        UnexpectedKeyword: ({ keyword: a }) => `Unexpected keyword '${a}'.`,
        UnexpectedLeadingDecorator:
          "Leading decorators must be attached to a class declaration.",
        UnexpectedLexicalDeclaration:
          "Lexical declaration cannot appear in a single-statement context.",
        UnexpectedNewTarget:
          "`new.target` can only be used in functions or class properties.",
        UnexpectedNumericSeparator:
          "A numeric separator is only allowed between two digits.",
        UnexpectedPrivateField: "Unexpected private name.",
        UnexpectedReservedWord: ({ reservedWord: a }) =>
          `Unexpected reserved word '${a}'.`,
        UnexpectedSuper:
          "'super' is only allowed in object methods and classes.",
        UnexpectedToken: ({ expected: a, unexpected: t }) =>
          `Unexpected token${t ? ` '${t}'.` : ""}${a ? `, expected "${a}"` : ""}`,
        UnexpectedTokenUnaryExponentiation:
          "Illegal expression. Wrap left hand side or entire exponentiation in parentheses.",
        UnexpectedUsingDeclaration:
          "Using declaration cannot appear in the top level when source type is `script`.",
        UnsupportedBind: "Binding should be performed on object property.",
        UnsupportedDecoratorExport:
          "A decorated export must export a class declaration.",
        UnsupportedDefaultExport:
          "Only expressions, functions or classes are allowed as the `default` export.",
        UnsupportedImport:
          "`import` can only be used in `import()` or `import.meta`.",
        UnsupportedMetaProperty: ({ target: a, onlyValidPropertyName: t }) =>
          `The only valid meta property for ${a} is ${a}.${t}.`,
        UnsupportedParameterDecorator:
          "Decorators cannot be used to decorate parameters.",
        UnsupportedPropertyDecorator:
          "Decorators cannot be used to decorate object literal properties.",
        UnsupportedSuper:
          "'super' can only be used with function calls (i.e. super()) or in property accesses (i.e. super.prop or super[prop]).",
        UnterminatedComment: "Unterminated comment.",
        UnterminatedRegExp: "Unterminated regular expression.",
        UnterminatedString: "Unterminated string constant.",
        UnterminatedTemplate: "Unterminated template.",
        UsingDeclarationExport: "Using declaration cannot be exported.",
        UsingDeclarationHasBindingPattern:
          "Using declaration cannot have destructuring patterns.",
        VarRedeclaration: ({ identifierName: a }) =>
          `Identifier '${a}' has already been declared.`,
        YieldBindingIdentifier:
          "Can not use 'yield' as identifier inside a generator.",
        YieldInParameter:
          "Yield expression is not allowed in formal parameters.",
        ZeroDigitNumericSeparator:
          "Numeric separator can not be used after leading 0.",
      },
      Ys = {
        StrictDelete: "Deleting local variable in strict mode.",
        StrictEvalArguments: ({ referenceName: a }) =>
          `Assigning to '${a}' in strict mode.`,
        StrictEvalArgumentsBinding: ({ bindingName: a }) =>
          `Binding '${a}' in strict mode.`,
        StrictFunction:
          "In strict mode code, functions can only be declared at top level or inside a block.",
        StrictNumericEscape:
          "The only valid numeric escape in strict mode is '\\0'.",
        StrictOctalLiteral:
          "Legacy octal literals are not allowed in strict mode.",
        StrictWith: "'with' in strict mode.",
      },
      Qs = new Set([
        "ArrowFunctionExpression",
        "AssignmentExpression",
        "ConditionalExpression",
        "YieldExpression",
      ]),
      Zs = {
        PipeBodyIsTighter:
          "Unexpected yield after pipeline body; any yield expression acting as Hack-style pipe body must be parenthesized due to its loose operator precedence.",
        PipeTopicRequiresHackPipes:
          'Topic reference is used, but the pipelineOperator plugin was not passed a "proposal": "hack" or "smart" option.',
        PipeTopicUnbound:
          "Topic reference is unbound; it must be inside a pipe body.",
        PipeTopicUnconfiguredToken: ({ token: a }) =>
          `Invalid topic token ${a}. In order to use ${a} as a topic reference, the pipelineOperator plugin must be configured with { "proposal": "hack", "topicToken": "${a}" }.`,
        PipeTopicUnused:
          "Hack-style pipe body does not contain a topic reference; Hack-style pipes must use topic at least once.",
        PipeUnparenthesizedBody: ({ type: a }) =>
          `Hack-style pipe body cannot be an unparenthesized ${Ee({ type: a })}; please wrap it in parentheses.`,
        PipelineBodyNoArrow:
          'Unexpected arrow "=>" after pipeline body; arrow function in pipeline body must be parenthesized.',
        PipelineBodySequenceExpression:
          "Pipeline body may not be a comma-separated sequence expression.",
        PipelineHeadSequenceExpression:
          "Pipeline head should not be a comma-separated sequence expression.",
        PipelineTopicUnused:
          "Pipeline is in topic style but does not use topic reference.",
        PrimaryTopicNotAllowed:
          "Topic reference was used in a lexical context without topic binding.",
        PrimaryTopicRequiresSmartPipeline:
          'Topic reference is used, but the pipelineOperator plugin was not passed a "proposal": "hack" or "smart" option.',
      },
      ei = ["toMessage"],
      ti = ["message"];
    function Mt(a, t, e) {
      Object.defineProperty(a, t, {
        enumerable: !1,
        configurable: !0,
        value: e,
      });
    }
    function si(a) {
      let { toMessage: t } = a,
        e = Ht(a, ei);
      return function s(i, r) {
        let n = new SyntaxError();
        return (
          Object.assign(n, e, { loc: i, pos: i.index }),
          "missingPlugin" in r &&
            Object.assign(n, { missingPlugin: r.missingPlugin }),
          Mt(n, "clone", function (h = {}) {
            var c;
            let { line: l, column: u, index: f } = (c = h.loc) != null ? c : i;
            return s(new F(l, u, f), Object.assign({}, r, h.details));
          }),
          Mt(n, "details", r),
          Object.defineProperty(n, "message", {
            configurable: !0,
            get() {
              let o = `${t(r)} (${i.line}:${i.column})`;
              return (this.message = o), o;
            },
            set(o) {
              Object.defineProperty(this, "message", {
                value: o,
                writable: !0,
              });
            },
          }),
          n
        );
      };
    }
    function j(a, t) {
      if (Array.isArray(a)) return (s) => j(s, a[0]);
      let e = {};
      for (let s of Object.keys(a)) {
        let i = a[s],
          r =
            typeof i == "string"
              ? { message: () => i }
              : typeof i == "function"
                ? { message: i }
                : i,
          { message: n } = r,
          o = Ht(r, ti),
          h = typeof n == "string" ? () => n : n;
        e[s] = si(
          Object.assign(
            { code: "BABEL_PARSER_SYNTAX_ERROR", reasonCode: s, toMessage: h },
            t ? { syntaxPlugin: t } : {},
            o,
          ),
        );
      }
      return e;
    }
    var p = Object.assign({}, j(Xs), j(Gs), j(Ys), j`pipelineOperator`(Zs)),
      { defineProperty: ii } = Object,
      Ot = (a, t) => {
        a && ii(a, t, { enumerable: !1, value: a[t] });
      };
    function oe(a) {
      return Ot(a.loc.start, "index"), Ot(a.loc.end, "index"), a;
    }
    var ri = (a) =>
        class extends a {
          parse() {
            let e = oe(super.parse());
            return this.options.tokens && (e.tokens = e.tokens.map(oe)), e;
          }
          parseRegExpLiteral({ pattern: e, flags: s }) {
            let i = null;
            try {
              i = new RegExp(e, s);
            } catch {}
            let r = this.estreeParseLiteral(i);
            return (r.regex = { pattern: e, flags: s }), r;
          }
          parseBigIntLiteral(e) {
            let s;
            try {
              s = BigInt(e);
            } catch {
              s = null;
            }
            let i = this.estreeParseLiteral(s);
            return (i.bigint = String(i.value || e)), i;
          }
          parseDecimalLiteral(e) {
            let i = this.estreeParseLiteral(null);
            return (i.decimal = String(i.value || e)), i;
          }
          estreeParseLiteral(e) {
            return this.parseLiteral(e, "Literal");
          }
          parseStringLiteral(e) {
            return this.estreeParseLiteral(e);
          }
          parseNumericLiteral(e) {
            return this.estreeParseLiteral(e);
          }
          parseNullLiteral() {
            return this.estreeParseLiteral(null);
          }
          parseBooleanLiteral(e) {
            return this.estreeParseLiteral(e);
          }
          directiveToStmt(e) {
            let s = e.value;
            delete e.value,
              (s.type = "Literal"),
              (s.raw = s.extra.raw),
              (s.value = s.extra.expressionValue);
            let i = e;
            return (
              (i.type = "ExpressionStatement"),
              (i.expression = s),
              (i.directive = s.extra.rawValue),
              delete s.extra,
              i
            );
          }
          initFunction(e, s) {
            super.initFunction(e, s), (e.expression = !1);
          }
          checkDeclaration(e) {
            e != null && this.isObjectProperty(e)
              ? this.checkDeclaration(e.value)
              : super.checkDeclaration(e);
          }
          getObjectOrClassMethodParams(e) {
            return e.value.params;
          }
          isValidDirective(e) {
            var s;
            return (
              e.type === "ExpressionStatement" &&
              e.expression.type === "Literal" &&
              typeof e.expression.value == "string" &&
              !((s = e.expression.extra) != null && s.parenthesized)
            );
          }
          parseBlockBody(e, s, i, r, n) {
            super.parseBlockBody(e, s, i, r, n);
            let o = e.directives.map((h) => this.directiveToStmt(h));
            (e.body = o.concat(e.body)), delete e.directives;
          }
          pushClassMethod(e, s, i, r, n, o) {
            this.parseMethod(s, i, r, n, o, "ClassMethod", !0),
              s.typeParameters &&
                ((s.value.typeParameters = s.typeParameters),
                delete s.typeParameters),
              e.body.push(s);
          }
          parsePrivateName() {
            let e = super.parsePrivateName();
            return this.getPluginOption("estree", "classFeatures")
              ? this.convertPrivateNameToPrivateIdentifier(e)
              : e;
          }
          convertPrivateNameToPrivateIdentifier(e) {
            let s = super.getPrivateNameSV(e);
            return (
              (e = e),
              delete e.id,
              (e.name = s),
              (e.type = "PrivateIdentifier"),
              e
            );
          }
          isPrivateName(e) {
            return this.getPluginOption("estree", "classFeatures")
              ? e.type === "PrivateIdentifier"
              : super.isPrivateName(e);
          }
          getPrivateNameSV(e) {
            return this.getPluginOption("estree", "classFeatures")
              ? e.name
              : super.getPrivateNameSV(e);
          }
          parseLiteral(e, s) {
            let i = super.parseLiteral(e, s);
            return (i.raw = i.extra.raw), delete i.extra, i;
          }
          parseFunctionBody(e, s, i = !1) {
            super.parseFunctionBody(e, s, i),
              (e.expression = e.body.type !== "BlockStatement");
          }
          parseMethod(e, s, i, r, n, o, h = !1) {
            let c = this.startNode();
            return (
              (c.kind = e.kind),
              (c = super.parseMethod(c, s, i, r, n, o, h)),
              (c.type = "FunctionExpression"),
              delete c.kind,
              (e.value = c),
              o === "ClassPrivateMethod" && (e.computed = !1),
              this.finishNode(e, "MethodDefinition")
            );
          }
          nameIsConstructor(e) {
            return e.type === "Literal"
              ? e.value === "constructor"
              : super.nameIsConstructor(e);
          }
          parseClassProperty(...e) {
            let s = super.parseClassProperty(...e);
            return (
              this.getPluginOption("estree", "classFeatures") &&
                (s.type = "PropertyDefinition"),
              s
            );
          }
          parseClassPrivateProperty(...e) {
            let s = super.parseClassPrivateProperty(...e);
            return (
              this.getPluginOption("estree", "classFeatures") &&
                ((s.type = "PropertyDefinition"), (s.computed = !1)),
              s
            );
          }
          parseObjectMethod(e, s, i, r, n) {
            let o = super.parseObjectMethod(e, s, i, r, n);
            return (
              o &&
                ((o.type = "Property"),
                o.kind === "method" && (o.kind = "init"),
                (o.shorthand = !1)),
              o
            );
          }
          parseObjectProperty(e, s, i, r) {
            let n = super.parseObjectProperty(e, s, i, r);
            return n && ((n.kind = "init"), (n.type = "Property")), n;
          }
          isValidLVal(e, s, i) {
            return e === "Property" ? "value" : super.isValidLVal(e, s, i);
          }
          isAssignable(e, s) {
            return e != null && this.isObjectProperty(e)
              ? this.isAssignable(e.value, s)
              : super.isAssignable(e, s);
          }
          toAssignable(e, s = !1) {
            if (e != null && this.isObjectProperty(e)) {
              let { key: i, value: r } = e;
              this.isPrivateName(i) &&
                this.classScope.usePrivateName(
                  this.getPrivateNameSV(i),
                  i.loc.start,
                ),
                this.toAssignable(r, s);
            } else super.toAssignable(e, s);
          }
          toAssignableObjectExpressionProp(e, s, i) {
            e.type === "Property" && (e.kind === "get" || e.kind === "set")
              ? this.raise(p.PatternHasAccessor, e.key)
              : e.type === "Property" && e.method
                ? this.raise(p.PatternHasMethod, e.key)
                : super.toAssignableObjectExpressionProp(e, s, i);
          }
          finishCallExpression(e, s) {
            let i = super.finishCallExpression(e, s);
            if (i.callee.type === "Import") {
              if (
                ((i.type = "ImportExpression"),
                (i.source = i.arguments[0]),
                this.hasPlugin("importAttributes") ||
                  this.hasPlugin("importAssertions"))
              ) {
                var r, n;
                (i.options = (r = i.arguments[1]) != null ? r : null),
                  (i.attributes = (n = i.arguments[1]) != null ? n : null);
              }
              delete i.arguments, delete i.callee;
            }
            return i;
          }
          toReferencedArguments(e) {
            e.type !== "ImportExpression" && super.toReferencedArguments(e);
          }
          parseExport(e, s) {
            let i = this.state.lastTokStartLoc,
              r = super.parseExport(e, s);
            switch (r.type) {
              case "ExportAllDeclaration":
                r.exported = null;
                break;
              case "ExportNamedDeclaration":
                r.specifiers.length === 1 &&
                  r.specifiers[0].type === "ExportNamespaceSpecifier" &&
                  ((r.type = "ExportAllDeclaration"),
                  (r.exported = r.specifiers[0].exported),
                  delete r.specifiers);
              case "ExportDefaultDeclaration":
                {
                  var n;
                  let { declaration: o } = r;
                  (o == null ? void 0 : o.type) === "ClassDeclaration" &&
                    ((n = o.decorators) == null ? void 0 : n.length) > 0 &&
                    o.start === r.start &&
                    this.resetStartLocation(r, i);
                }
                break;
            }
            return r;
          }
          parseSubscript(e, s, i, r) {
            let n = super.parseSubscript(e, s, i, r);
            if (r.optionalChainMember) {
              if (
                ((n.type === "OptionalMemberExpression" ||
                  n.type === "OptionalCallExpression") &&
                  (n.type = n.type.substring(8)),
                r.stop)
              ) {
                let o = this.startNodeAtNode(n);
                return (
                  (o.expression = n), this.finishNode(o, "ChainExpression")
                );
              }
            } else
              (n.type === "MemberExpression" || n.type === "CallExpression") &&
                (n.optional = !1);
            return n;
          }
          isOptionalMemberExpression(e) {
            return e.type === "ChainExpression"
              ? e.expression.type === "MemberExpression"
              : super.isOptionalMemberExpression(e);
          }
          hasPropertyAsPrivateName(e) {
            return (
              e.type === "ChainExpression" && (e = e.expression),
              super.hasPropertyAsPrivateName(e)
            );
          }
          isObjectProperty(e) {
            return e.type === "Property" && e.kind === "init" && !e.method;
          }
          isObjectMethod(e) {
            return (
              e.type === "Property" &&
              (e.method || e.kind === "get" || e.kind === "set")
            );
          }
          finishNodeAt(e, s, i) {
            return oe(super.finishNodeAt(e, s, i));
          }
          resetStartLocation(e, s) {
            super.resetStartLocation(e, s), oe(e);
          }
          resetEndLocation(e, s = this.state.lastTokEndLoc) {
            super.resetEndLocation(e, s), oe(e);
          }
        },
      X = class {
        constructor(t, e) {
          (this.token = void 0),
            (this.preserveSpace = void 0),
            (this.token = t),
            (this.preserveSpace = !!e);
        }
      },
      C = {
        brace: new X("{"),
        j_oTag: new X("<tag"),
        j_cTag: new X("</tag"),
        j_expr: new X("<tag>...</tag>", !0),
      };
    C.template = new X("`", !0);
    var b = !0,
      m = !0,
      $e = !0,
      he = !0,
      q = !0,
      ai = !0,
      ve = class {
        constructor(t, e = {}) {
          (this.label = void 0),
            (this.keyword = void 0),
            (this.beforeExpr = void 0),
            (this.startsExpr = void 0),
            (this.rightAssociative = void 0),
            (this.isLoop = void 0),
            (this.isAssign = void 0),
            (this.prefix = void 0),
            (this.postfix = void 0),
            (this.binop = void 0),
            (this.label = t),
            (this.keyword = e.keyword),
            (this.beforeExpr = !!e.beforeExpr),
            (this.startsExpr = !!e.startsExpr),
            (this.rightAssociative = !!e.rightAssociative),
            (this.isLoop = !!e.isLoop),
            (this.isAssign = !!e.isAssign),
            (this.prefix = !!e.prefix),
            (this.postfix = !!e.postfix),
            (this.binop = e.binop != null ? e.binop : null),
            (this.updateContext = null);
        }
      },
      ut = new Map();
    function A(a, t = {}) {
      t.keyword = a;
      let e = P(a, t);
      return ut.set(a, e), e;
    }
    function k(a, t) {
      return P(a, { beforeExpr: b, binop: t });
    }
    var ue = -1,
      U = [],
      ft = [],
      dt = [],
      mt = [],
      yt = [],
      xt = [];
    function P(a, t = {}) {
      var e, s, i, r;
      return (
        ++ue,
        ft.push(a),
        dt.push((e = t.binop) != null ? e : -1),
        mt.push((s = t.beforeExpr) != null ? s : !1),
        yt.push((i = t.startsExpr) != null ? i : !1),
        xt.push((r = t.prefix) != null ? r : !1),
        U.push(new ve(a, t)),
        ue
      );
    }
    function T(a, t = {}) {
      var e, s, i, r;
      return (
        ++ue,
        ut.set(a, ue),
        ft.push(a),
        dt.push((e = t.binop) != null ? e : -1),
        mt.push((s = t.beforeExpr) != null ? s : !1),
        yt.push((i = t.startsExpr) != null ? i : !1),
        xt.push((r = t.prefix) != null ? r : !1),
        U.push(new ve("name", t)),
        ue
      );
    }
    var ni = {
      bracketL: P("[", { beforeExpr: b, startsExpr: m }),
      bracketHashL: P("#[", { beforeExpr: b, startsExpr: m }),
      bracketBarL: P("[|", { beforeExpr: b, startsExpr: m }),
      bracketR: P("]"),
      bracketBarR: P("|]"),
      braceL: P("{", { beforeExpr: b, startsExpr: m }),
      braceBarL: P("{|", { beforeExpr: b, startsExpr: m }),
      braceHashL: P("#{", { beforeExpr: b, startsExpr: m }),
      braceR: P("}"),
      braceBarR: P("|}"),
      parenL: P("(", { beforeExpr: b, startsExpr: m }),
      parenR: P(")"),
      comma: P(",", { beforeExpr: b }),
      semi: P(";", { beforeExpr: b }),
      colon: P(":", { beforeExpr: b }),
      doubleColon: P("::", { beforeExpr: b }),
      dot: P("."),
      question: P("?", { beforeExpr: b }),
      questionDot: P("?."),
      arrow: P("=>", { beforeExpr: b }),
      template: P("template"),
      ellipsis: P("...", { beforeExpr: b }),
      backQuote: P("`", { startsExpr: m }),
      dollarBraceL: P("${", { beforeExpr: b, startsExpr: m }),
      templateTail: P("...`", { startsExpr: m }),
      templateNonTail: P("...${", { beforeExpr: b, startsExpr: m }),
      at: P("@"),
      hash: P("#", { startsExpr: m }),
      interpreterDirective: P("#!..."),
      eq: P("=", { beforeExpr: b, isAssign: he }),
      assign: P("_=", { beforeExpr: b, isAssign: he }),
      slashAssign: P("_=", { beforeExpr: b, isAssign: he }),
      xorAssign: P("_=", { beforeExpr: b, isAssign: he }),
      moduloAssign: P("_=", { beforeExpr: b, isAssign: he }),
      incDec: P("++/--", { prefix: q, postfix: ai, startsExpr: m }),
      bang: P("!", { beforeExpr: b, prefix: q, startsExpr: m }),
      tilde: P("~", { beforeExpr: b, prefix: q, startsExpr: m }),
      doubleCaret: P("^^", { startsExpr: m }),
      doubleAt: P("@@", { startsExpr: m }),
      pipeline: k("|>", 0),
      nullishCoalescing: k("??", 1),
      logicalOR: k("||", 1),
      logicalAND: k("&&", 2),
      bitwiseOR: k("|", 3),
      bitwiseXOR: k("^", 4),
      bitwiseAND: k("&", 5),
      equality: k("==/!=/===/!==", 6),
      lt: k("</>/<=/>=", 7),
      gt: k("</>/<=/>=", 7),
      relational: k("</>/<=/>=", 7),
      bitShift: k("<</>>/>>>", 8),
      bitShiftL: k("<</>>/>>>", 8),
      bitShiftR: k("<</>>/>>>", 8),
      plusMin: P("+/-", { beforeExpr: b, binop: 9, prefix: q, startsExpr: m }),
      modulo: P("%", { binop: 10, startsExpr: m }),
      star: P("*", { binop: 10 }),
      slash: k("/", 10),
      exponent: P("**", { beforeExpr: b, binop: 11, rightAssociative: !0 }),
      _in: A("in", { beforeExpr: b, binop: 7 }),
      _instanceof: A("instanceof", { beforeExpr: b, binop: 7 }),
      _break: A("break"),
      _case: A("case", { beforeExpr: b }),
      _catch: A("catch"),
      _continue: A("continue"),
      _debugger: A("debugger"),
      _default: A("default", { beforeExpr: b }),
      _else: A("else", { beforeExpr: b }),
      _finally: A("finally"),
      _function: A("function", { startsExpr: m }),
      _if: A("if"),
      _return: A("return", { beforeExpr: b }),
      _switch: A("switch"),
      _throw: A("throw", { beforeExpr: b, prefix: q, startsExpr: m }),
      _try: A("try"),
      _var: A("var"),
      _const: A("const"),
      _with: A("with"),
      _new: A("new", { beforeExpr: b, startsExpr: m }),
      _this: A("this", { startsExpr: m }),
      _super: A("super", { startsExpr: m }),
      _class: A("class", { startsExpr: m }),
      _extends: A("extends", { beforeExpr: b }),
      _export: A("export"),
      _import: A("import", { startsExpr: m }),
      _null: A("null", { startsExpr: m }),
      _true: A("true", { startsExpr: m }),
      _false: A("false", { startsExpr: m }),
      _typeof: A("typeof", { beforeExpr: b, prefix: q, startsExpr: m }),
      _void: A("void", { beforeExpr: b, prefix: q, startsExpr: m }),
      _delete: A("delete", { beforeExpr: b, prefix: q, startsExpr: m }),
      _do: A("do", { isLoop: $e, beforeExpr: b }),
      _for: A("for", { isLoop: $e }),
      _while: A("while", { isLoop: $e }),
      _as: T("as", { startsExpr: m }),
      _assert: T("assert", { startsExpr: m }),
      _async: T("async", { startsExpr: m }),
      _await: T("await", { startsExpr: m }),
      _defer: T("defer", { startsExpr: m }),
      _from: T("from", { startsExpr: m }),
      _get: T("get", { startsExpr: m }),
      _let: T("let", { startsExpr: m }),
      _meta: T("meta", { startsExpr: m }),
      _of: T("of", { startsExpr: m }),
      _sent: T("sent", { startsExpr: m }),
      _set: T("set", { startsExpr: m }),
      _source: T("source", { startsExpr: m }),
      _static: T("static", { startsExpr: m }),
      _using: T("using", { startsExpr: m }),
      _yield: T("yield", { startsExpr: m }),
      _asserts: T("asserts", { startsExpr: m }),
      _checks: T("checks", { startsExpr: m }),
      _exports: T("exports", { startsExpr: m }),
      _global: T("global", { startsExpr: m }),
      _implements: T("implements", { startsExpr: m }),
      _intrinsic: T("intrinsic", { startsExpr: m }),
      _infer: T("infer", { startsExpr: m }),
      _is: T("is", { startsExpr: m }),
      _mixins: T("mixins", { startsExpr: m }),
      _proto: T("proto", { startsExpr: m }),
      _require: T("require", { startsExpr: m }),
      _satisfies: T("satisfies", { startsExpr: m }),
      _keyof: T("keyof", { startsExpr: m }),
      _readonly: T("readonly", { startsExpr: m }),
      _unique: T("unique", { startsExpr: m }),
      _abstract: T("abstract", { startsExpr: m }),
      _declare: T("declare", { startsExpr: m }),
      _enum: T("enum", { startsExpr: m }),
      _module: T("module", { startsExpr: m }),
      _namespace: T("namespace", { startsExpr: m }),
      _interface: T("interface", { startsExpr: m }),
      _type: T("type", { startsExpr: m }),
      _opaque: T("opaque", { startsExpr: m }),
      name: P("name", { startsExpr: m }),
      string: P("string", { startsExpr: m }),
      num: P("num", { startsExpr: m }),
      bigint: P("bigint", { startsExpr: m }),
      decimal: P("decimal", { startsExpr: m }),
      regexp: P("regexp", { startsExpr: m }),
      privateName: P("#name", { startsExpr: m }),
      eof: P("eof"),
      jsxName: P("jsxName"),
      jsxText: P("jsxText", { beforeExpr: !0 }),
      jsxTagStart: P("jsxTagStart", { startsExpr: !0 }),
      jsxTagEnd: P("jsxTagEnd"),
      placeholder: P("%%", { startsExpr: !0 }),
    };
    function w(a) {
      return a >= 93 && a <= 132;
    }
    function oi(a) {
      return a <= 92;
    }
    function M(a) {
      return a >= 58 && a <= 132;
    }
    function Wt(a) {
      return a >= 58 && a <= 136;
    }
    function hi(a) {
      return mt[a];
    }
    function He(a) {
      return yt[a];
    }
    function li(a) {
      return a >= 29 && a <= 33;
    }
    function Ft(a) {
      return a >= 129 && a <= 131;
    }
    function ci(a) {
      return a >= 90 && a <= 92;
    }
    function Pt(a) {
      return a >= 58 && a <= 92;
    }
    function pi(a) {
      return a >= 39 && a <= 59;
    }
    function ui(a) {
      return a === 34;
    }
    function fi(a) {
      return xt[a];
    }
    function di(a) {
      return a >= 121 && a <= 123;
    }
    function mi(a) {
      return a >= 124 && a <= 130;
    }
    function K(a) {
      return ft[a];
    }
    function Ie(a) {
      return dt[a];
    }
    function yi(a) {
      return a === 57;
    }
    function Le(a) {
      return a >= 24 && a <= 25;
    }
    function R(a) {
      return U[a];
    }
    (U[8].updateContext = (a) => {
      a.pop();
    }),
      (U[5].updateContext =
        U[7].updateContext =
        U[23].updateContext =
          (a) => {
            a.push(C.brace);
          }),
      (U[22].updateContext = (a) => {
        a[a.length - 1] === C.template ? a.pop() : a.push(C.template);
      }),
      (U[142].updateContext = (a) => {
        a.push(C.j_expr, C.j_oTag);
      });
    var gt =
        "\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u05D0-\u05EA\u05EF-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u0870-\u0887\u0889-\u088E\u08A0-\u08C9\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C5D\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u1711\u171F-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1878\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4C\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1C90-\u1CBA\u1CBD-\u1CBF\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309B-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u31A0-\u31BF\u31F0-\u31FF\u3400-\u4DBF\u4E00-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7CA\uA7D0\uA7D1\uA7D3\uA7D5-\uA7D9\uA7F2-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA8FE\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC",
      Jt =
        "\u200C\u200D\xB7\u0300-\u036F\u0387\u0483-\u0487\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u0669\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u06F0-\u06F9\u0711\u0730-\u074A\u07A6-\u07B0\u07C0-\u07C9\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u0898-\u089F\u08CA-\u08E1\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0966-\u096F\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09E6-\u09EF\u09FE\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A66-\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AE6-\u0AEF\u0AFA-\u0AFF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B55-\u0B57\u0B62\u0B63\u0B66-\u0B6F\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0BE6-\u0BEF\u0C00-\u0C04\u0C3C\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0CE6-\u0CEF\u0CF3\u0D00-\u0D03\u0D3B\u0D3C\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D66-\u0D6F\u0D81-\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0E50-\u0E59\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECE\u0ED0-\u0ED9\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1040-\u1049\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F-\u109D\u135D-\u135F\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u17E0-\u17E9\u180B-\u180D\u180F-\u1819\u18A9\u1920-\u192B\u1930-\u193B\u1946-\u194F\u19D0-\u19DA\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AB0-\u1ABD\u1ABF-\u1ACE\u1B00-\u1B04\u1B34-\u1B44\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BB0-\u1BB9\u1BE6-\u1BF3\u1C24-\u1C37\u1C40-\u1C49\u1C50-\u1C59\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF4\u1CF7-\u1CF9\u1DC0-\u1DFF\u200C\u200D\u203F\u2040\u2054\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\u30FB\uA620-\uA629\uA66F\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA82C\uA880\uA881\uA8B4-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F1\uA8FF-\uA909\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9D0-\uA9D9\uA9E5\uA9F0-\uA9F9\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA50-\uAA59\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uABF0-\uABF9\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFF10-\uFF19\uFF3F\uFF65",
      xi = new RegExp("[" + gt + "]"),
      Pi = new RegExp("[" + gt + Jt + "]");
    gt = Jt = null;
    var Xt = [
        0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4,
        48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35,
        5, 35, 5, 39, 9, 51, 13, 10, 2, 14, 2, 6, 2, 1, 2, 10, 2, 14, 2, 6, 2,
        1, 68, 310, 10, 21, 11, 7, 25, 5, 2, 41, 2, 8, 70, 5, 3, 0, 2, 43, 2, 1,
        4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1,
        65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21,
        11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 349, 41, 7, 1, 79, 28,
        11, 0, 9, 21, 43, 17, 47, 20, 28, 22, 13, 52, 58, 1, 3, 0, 14, 44, 33,
        24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36,
        17, 2, 24, 20, 1, 64, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3,
        21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 159, 52, 19, 3, 21, 2, 31, 47,
        21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 38,
        6, 186, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7,
        3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 19, 72,
        264, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1,
        2, 31, 15, 0, 328, 18, 16, 0, 2, 12, 2, 33, 125, 0, 80, 921, 103, 110,
        18, 195, 2637, 96, 16, 1071, 18, 5, 4026, 582, 8634, 568, 8, 30, 18, 78,
        18, 29, 19, 47, 17, 3, 32, 20, 6, 18, 689, 63, 129, 74, 6, 0, 67, 12,
        65, 1, 2, 0, 29, 6135, 9, 1237, 43, 8, 8936, 3, 2, 6, 2, 1, 2, 290, 16,
        0, 30, 2, 3, 0, 15, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84,
        2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2,
        6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2,
        30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 1845, 30, 7, 5, 262, 61,
        147, 44, 11, 6, 17, 0, 322, 29, 19, 43, 485, 27, 757, 6, 2, 3, 2, 1, 2,
        14, 2, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3,
        2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0,
        2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2,
        2, 4, 2, 16, 4421, 42719, 33, 4153, 7, 221, 3, 5761, 15, 7472, 16, 621,
        2467, 541, 1507, 4938, 6, 4191,
      ],
      gi = [
        509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166,
        1, 574, 3, 9, 9, 370, 1, 81, 2, 71, 10, 50, 3, 123, 2, 54, 14, 32, 10,
        3, 1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13,
        2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 3, 0, 158, 11, 6, 9, 7, 3, 56, 1,
        2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 193, 17, 10, 9, 5, 0, 82,
        19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 84, 14, 5,
        9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6,
        4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 406, 7, 2, 7, 17, 9, 57,
        21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9,
        9, 330, 3, 10, 1, 2, 0, 49, 6, 4, 4, 14, 9, 5351, 0, 7, 14, 13835, 9,
        87, 9, 39, 4, 60, 6, 26, 9, 1014, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628,
        1, 4706, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49,
        513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1,
        2, 4, 101, 0, 161, 6, 10, 9, 357, 0, 62, 13, 499, 13, 983, 6, 110, 6, 6,
        9, 4759, 9, 787719, 239,
      ];
    function We(a, t) {
      let e = 65536;
      for (let s = 0, i = t.length; s < i; s += 2) {
        if (((e += t[s]), e > a)) return !1;
        if (((e += t[s + 1]), e >= a)) return !0;
      }
      return !1;
    }
    function _(a) {
      return a < 65
        ? a === 36
        : a <= 90
          ? !0
          : a < 97
            ? a === 95
            : a <= 122
              ? !0
              : a <= 65535
                ? a >= 170 && xi.test(String.fromCharCode(a))
                : We(a, Xt);
    }
    function Q(a) {
      return a < 48
        ? a === 36
        : a < 58
          ? !0
          : a < 65
            ? !1
            : a <= 90
              ? !0
              : a < 97
                ? a === 95
                : a <= 122
                  ? !0
                  : a <= 65535
                    ? a >= 170 && Pi.test(String.fromCharCode(a))
                    : We(a, Xt) || We(a, gi);
    }
    var Tt = {
        keyword: [
          "break",
          "case",
          "catch",
          "continue",
          "debugger",
          "default",
          "do",
          "else",
          "finally",
          "for",
          "function",
          "if",
          "return",
          "switch",
          "throw",
          "try",
          "var",
          "const",
          "while",
          "with",
          "new",
          "this",
          "super",
          "class",
          "extends",
          "export",
          "import",
          "null",
          "true",
          "false",
          "in",
          "instanceof",
          "typeof",
          "void",
          "delete",
        ],
        strict: [
          "implements",
          "interface",
          "let",
          "package",
          "private",
          "protected",
          "public",
          "static",
          "yield",
        ],
        strictBind: ["eval", "arguments"],
      },
      Ti = new Set(Tt.keyword),
      bi = new Set(Tt.strict),
      Ai = new Set(Tt.strictBind);
    function Gt(a, t) {
      return (t && a === "await") || a === "enum";
    }
    function Yt(a, t) {
      return Gt(a, t) || bi.has(a);
    }
    function Qt(a) {
      return Ai.has(a);
    }
    function Zt(a, t) {
      return Yt(a, t) || Qt(a);
    }
    function Si(a) {
      return Ti.has(a);
    }
    function wi(a, t, e) {
      return a === 64 && t === 64 && _(e);
    }
    var Ci = new Set([
      "break",
      "case",
      "catch",
      "continue",
      "debugger",
      "default",
      "do",
      "else",
      "finally",
      "for",
      "function",
      "if",
      "return",
      "switch",
      "throw",
      "try",
      "var",
      "const",
      "while",
      "with",
      "new",
      "this",
      "super",
      "class",
      "extends",
      "export",
      "import",
      "null",
      "true",
      "false",
      "in",
      "instanceof",
      "typeof",
      "void",
      "delete",
      "implements",
      "interface",
      "let",
      "package",
      "private",
      "protected",
      "public",
      "static",
      "yield",
      "eval",
      "arguments",
      "enum",
      "await",
    ]);
    function Ei(a) {
      return Ci.has(a);
    }
    var de = class {
        constructor(t) {
          (this.flags = 0),
            (this.names = new Map()),
            (this.firstLexicalName = ""),
            (this.flags = t);
        }
      },
      me = class {
        constructor(t, e) {
          (this.parser = void 0),
            (this.scopeStack = []),
            (this.inModule = void 0),
            (this.undefinedExports = new Map()),
            (this.parser = t),
            (this.inModule = e);
        }
        get inTopLevel() {
          return (this.currentScope().flags & 1) > 0;
        }
        get inFunction() {
          return (this.currentVarScopeFlags() & 2) > 0;
        }
        get allowSuper() {
          return (this.currentThisScopeFlags() & 16) > 0;
        }
        get allowDirectSuper() {
          return (this.currentThisScopeFlags() & 32) > 0;
        }
        get inClass() {
          return (this.currentThisScopeFlags() & 64) > 0;
        }
        get inClassAndNotInNonArrowFunction() {
          let t = this.currentThisScopeFlags();
          return (t & 64) > 0 && (t & 2) === 0;
        }
        get inStaticBlock() {
          for (let t = this.scopeStack.length - 1; ; t--) {
            let { flags: e } = this.scopeStack[t];
            if (e & 128) return !0;
            if (e & 451) return !1;
          }
        }
        get inNonArrowFunction() {
          return (this.currentThisScopeFlags() & 2) > 0;
        }
        get treatFunctionsAsVar() {
          return this.treatFunctionsAsVarInScope(this.currentScope());
        }
        createScope(t) {
          return new de(t);
        }
        enter(t) {
          this.scopeStack.push(this.createScope(t));
        }
        exit() {
          return this.scopeStack.pop().flags;
        }
        treatFunctionsAsVarInScope(t) {
          return !!(t.flags & 130 || (!this.parser.inModule && t.flags & 1));
        }
        declareName(t, e, s) {
          let i = this.currentScope();
          if (e & 8 || e & 16) {
            this.checkRedeclarationInScope(i, t, e, s);
            let r = i.names.get(t) || 0;
            e & 16
              ? (r = r | 4)
              : (i.firstLexicalName || (i.firstLexicalName = t), (r = r | 2)),
              i.names.set(t, r),
              e & 8 && this.maybeExportDefined(i, t);
          } else if (e & 4)
            for (
              let r = this.scopeStack.length - 1;
              r >= 0 &&
              ((i = this.scopeStack[r]),
              this.checkRedeclarationInScope(i, t, e, s),
              i.names.set(t, (i.names.get(t) || 0) | 1),
              this.maybeExportDefined(i, t),
              !(i.flags & 387));
              --r
            );
          this.parser.inModule &&
            i.flags & 1 &&
            this.undefinedExports.delete(t);
        }
        maybeExportDefined(t, e) {
          this.parser.inModule &&
            t.flags & 1 &&
            this.undefinedExports.delete(e);
        }
        checkRedeclarationInScope(t, e, s, i) {
          this.isRedeclaredInScope(t, e, s) &&
            this.parser.raise(p.VarRedeclaration, i, { identifierName: e });
        }
        isRedeclaredInScope(t, e, s) {
          if (!(s & 1)) return !1;
          if (s & 8) return t.names.has(e);
          let i = t.names.get(e);
          return s & 16
            ? (i & 2) > 0 ||
                (!this.treatFunctionsAsVarInScope(t) && (i & 1) > 0)
            : ((i & 2) > 0 && !(t.flags & 8 && t.firstLexicalName === e)) ||
                (!this.treatFunctionsAsVarInScope(t) && (i & 4) > 0);
        }
        checkLocalExport(t) {
          let { name: e } = t;
          this.scopeStack[0].names.has(e) ||
            this.undefinedExports.set(e, t.loc.start);
        }
        currentScope() {
          return this.scopeStack[this.scopeStack.length - 1];
        }
        currentVarScopeFlags() {
          for (let t = this.scopeStack.length - 1; ; t--) {
            let { flags: e } = this.scopeStack[t];
            if (e & 387) return e;
          }
        }
        currentThisScopeFlags() {
          for (let t = this.scopeStack.length - 1; ; t--) {
            let { flags: e } = this.scopeStack[t];
            if (e & 451 && !(e & 4)) return e;
          }
        }
      },
      Je = class extends de {
        constructor(...t) {
          super(...t), (this.declareFunctions = new Set());
        }
      },
      Xe = class extends me {
        createScope(t) {
          return new Je(t);
        }
        declareName(t, e, s) {
          let i = this.currentScope();
          if (e & 2048) {
            this.checkRedeclarationInScope(i, t, e, s),
              this.maybeExportDefined(i, t),
              i.declareFunctions.add(t);
            return;
          }
          super.declareName(t, e, s);
        }
        isRedeclaredInScope(t, e, s) {
          if (super.isRedeclaredInScope(t, e, s)) return !0;
          if (s & 2048 && !t.declareFunctions.has(e)) {
            let i = t.names.get(e);
            return (i & 4) > 0 || (i & 2) > 0;
          }
          return !1;
        }
        checkLocalExport(t) {
          this.scopeStack[0].declareFunctions.has(t.name) ||
            super.checkLocalExport(t);
        }
      },
      Ge = class {
        constructor() {
          (this.sawUnambiguousESM = !1),
            (this.ambiguousScriptDifferentAst = !1);
        }
        hasPlugin(t) {
          if (typeof t == "string") return this.plugins.has(t);
          {
            let [e, s] = t;
            if (!this.hasPlugin(e)) return !1;
            let i = this.plugins.get(e);
            for (let r of Object.keys(s))
              if ((i == null ? void 0 : i[r]) !== s[r]) return !1;
            return !0;
          }
        }
        getPluginOption(t, e) {
          var s;
          return (s = this.plugins.get(t)) == null ? void 0 : s[e];
        }
      };
    function es(a, t) {
      a.trailingComments === void 0
        ? (a.trailingComments = t)
        : a.trailingComments.unshift(...t);
    }
    function Ii(a, t) {
      a.leadingComments === void 0
        ? (a.leadingComments = t)
        : a.leadingComments.unshift(...t);
    }
    function ye(a, t) {
      a.innerComments === void 0
        ? (a.innerComments = t)
        : a.innerComments.unshift(...t);
    }
    function le(a, t, e) {
      let s = null,
        i = t.length;
      for (; s === null && i > 0; ) s = t[--i];
      s === null || s.start > e.start ? ye(a, e.comments) : es(s, e.comments);
    }
    var Ye = class extends Ge {
        addComment(t) {
          this.filename && (t.loc.filename = this.filename);
          let { commentsLen: e } = this.state;
          this.comments.length !== e && (this.comments.length = e),
            this.comments.push(t),
            this.state.commentsLen++;
        }
        processComment(t) {
          let { commentStack: e } = this.state,
            s = e.length;
          if (s === 0) return;
          let i = s - 1,
            r = e[i];
          r.start === t.end && ((r.leadingNode = t), i--);
          let { start: n } = t;
          for (; i >= 0; i--) {
            let o = e[i],
              h = o.end;
            if (h > n)
              (o.containingNode = t), this.finalizeComment(o), e.splice(i, 1);
            else {
              h === n && (o.trailingNode = t);
              break;
            }
          }
        }
        finalizeComment(t) {
          let { comments: e } = t;
          if (t.leadingNode !== null || t.trailingNode !== null)
            t.leadingNode !== null && es(t.leadingNode, e),
              t.trailingNode !== null && Ii(t.trailingNode, e);
          else {
            let { containingNode: s, start: i } = t;
            if (this.input.charCodeAt(i - 1) === 44)
              switch (s.type) {
                case "ObjectExpression":
                case "ObjectPattern":
                case "RecordExpression":
                  le(s, s.properties, t);
                  break;
                case "CallExpression":
                case "OptionalCallExpression":
                  le(s, s.arguments, t);
                  break;
                case "FunctionDeclaration":
                case "FunctionExpression":
                case "ArrowFunctionExpression":
                case "ObjectMethod":
                case "ClassMethod":
                case "ClassPrivateMethod":
                  le(s, s.params, t);
                  break;
                case "ArrayExpression":
                case "ArrayPattern":
                case "TupleExpression":
                  le(s, s.elements, t);
                  break;
                case "ExportNamedDeclaration":
                case "ImportDeclaration":
                  le(s, s.specifiers, t);
                  break;
                default:
                  ye(s, e);
              }
            else ye(s, e);
          }
        }
        finalizeRemainingComments() {
          let { commentStack: t } = this.state;
          for (let e = t.length - 1; e >= 0; e--) this.finalizeComment(t[e]);
          this.state.commentStack = [];
        }
        resetPreviousNodeTrailingComments(t) {
          let { commentStack: e } = this.state,
            { length: s } = e;
          if (s === 0) return;
          let i = e[s - 1];
          i.leadingNode === t && (i.leadingNode = null);
        }
        resetPreviousIdentifierLeadingComments(t) {
          let { commentStack: e } = this.state,
            { length: s } = e;
          s !== 0 &&
            (e[s - 1].trailingNode === t
              ? (e[s - 1].trailingNode = null)
              : s >= 2 &&
                e[s - 2].trailingNode === t &&
                (e[s - 2].trailingNode = null));
        }
        takeSurroundingComments(t, e, s) {
          let { commentStack: i } = this.state,
            r = i.length;
          if (r === 0) return;
          let n = r - 1;
          for (; n >= 0; n--) {
            let o = i[n],
              h = o.end;
            if (o.start === s) o.leadingNode = t;
            else if (h === e) o.trailingNode = t;
            else if (h < e) break;
          }
        }
      },
      ts = /\r\n?|[\n\u2028\u2029]/,
      we = new RegExp(ts.source, "g");
    function fe(a) {
      switch (a) {
        case 10:
        case 13:
        case 8232:
        case 8233:
          return !0;
        default:
          return !1;
      }
    }
    var Ve = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g,
      Ne = /(?:[^\S\n\r\u2028\u2029]|\/\/.*|\/\*.*?\*\/)*/g,
      Bt = new RegExp(
        "(?=(" +
          Ne.source +
          "))\\1" +
          /(?=[\n\r\u2028\u2029]|\/\*(?!.*?\*\/)|$)/.source,
        "y",
      );
    function Ni(a) {
      switch (a) {
        case 9:
        case 11:
        case 12:
        case 32:
        case 160:
        case 5760:
        case 8192:
        case 8193:
        case 8194:
        case 8195:
        case 8196:
        case 8197:
        case 8198:
        case 8199:
        case 8200:
        case 8201:
        case 8202:
        case 8239:
        case 8287:
        case 12288:
        case 65279:
          return !0;
        default:
          return !1;
      }
    }
    var Qe = class a {
        constructor() {
          (this.flags = 1024),
            (this.curLine = void 0),
            (this.lineStart = void 0),
            (this.startLoc = void 0),
            (this.endLoc = void 0),
            (this.errors = []),
            (this.potentialArrowAt = -1),
            (this.noArrowAt = []),
            (this.noArrowParamsConversionAt = []),
            (this.topicContext = {
              maxNumOfResolvableTopics: 0,
              maxTopicIndex: null,
            }),
            (this.labels = []),
            (this.commentsLen = 0),
            (this.commentStack = []),
            (this.pos = 0),
            (this.type = 139),
            (this.value = null),
            (this.start = 0),
            (this.end = 0),
            (this.lastTokEndLoc = null),
            (this.lastTokStartLoc = null),
            (this.context = [C.brace]),
            (this.firstInvalidTemplateEscapePos = null),
            (this.strictErrors = new Map()),
            (this.tokensLength = 0);
        }
        get strict() {
          return (this.flags & 1) > 0;
        }
        set strict(t) {
          t ? (this.flags |= 1) : (this.flags &= -2);
        }
        init({ strictMode: t, sourceType: e, startLine: s, startColumn: i }) {
          (this.strict = t === !1 ? !1 : t === !0 ? !0 : e === "module"),
            (this.curLine = s),
            (this.lineStart = -i),
            (this.startLoc = this.endLoc = new F(s, i, 0));
        }
        get maybeInArrowParameters() {
          return (this.flags & 2) > 0;
        }
        set maybeInArrowParameters(t) {
          t ? (this.flags |= 2) : (this.flags &= -3);
        }
        get inType() {
          return (this.flags & 4) > 0;
        }
        set inType(t) {
          t ? (this.flags |= 4) : (this.flags &= -5);
        }
        get noAnonFunctionType() {
          return (this.flags & 8) > 0;
        }
        set noAnonFunctionType(t) {
          t ? (this.flags |= 8) : (this.flags &= -9);
        }
        get hasFlowComment() {
          return (this.flags & 16) > 0;
        }
        set hasFlowComment(t) {
          t ? (this.flags |= 16) : (this.flags &= -17);
        }
        get isAmbientContext() {
          return (this.flags & 32) > 0;
        }
        set isAmbientContext(t) {
          t ? (this.flags |= 32) : (this.flags &= -33);
        }
        get inAbstractClass() {
          return (this.flags & 64) > 0;
        }
        set inAbstractClass(t) {
          t ? (this.flags |= 64) : (this.flags &= -65);
        }
        get inDisallowConditionalTypesContext() {
          return (this.flags & 128) > 0;
        }
        set inDisallowConditionalTypesContext(t) {
          t ? (this.flags |= 128) : (this.flags &= -129);
        }
        get soloAwait() {
          return (this.flags & 256) > 0;
        }
        set soloAwait(t) {
          t ? (this.flags |= 256) : (this.flags &= -257);
        }
        get inFSharpPipelineDirectBody() {
          return (this.flags & 512) > 0;
        }
        set inFSharpPipelineDirectBody(t) {
          t ? (this.flags |= 512) : (this.flags &= -513);
        }
        get canStartJSXElement() {
          return (this.flags & 1024) > 0;
        }
        set canStartJSXElement(t) {
          t ? (this.flags |= 1024) : (this.flags &= -1025);
        }
        get containsEsc() {
          return (this.flags & 2048) > 0;
        }
        set containsEsc(t) {
          t ? (this.flags |= 2048) : (this.flags &= -2049);
        }
        curPosition() {
          return new F(this.curLine, this.pos - this.lineStart, this.pos);
        }
        clone() {
          let t = new a();
          return (
            (t.flags = this.flags),
            (t.curLine = this.curLine),
            (t.lineStart = this.lineStart),
            (t.startLoc = this.startLoc),
            (t.endLoc = this.endLoc),
            (t.errors = this.errors.slice()),
            (t.potentialArrowAt = this.potentialArrowAt),
            (t.noArrowAt = this.noArrowAt.slice()),
            (t.noArrowParamsConversionAt =
              this.noArrowParamsConversionAt.slice()),
            (t.topicContext = this.topicContext),
            (t.labels = this.labels.slice()),
            (t.commentsLen = this.commentsLen),
            (t.commentStack = this.commentStack.slice()),
            (t.pos = this.pos),
            (t.type = this.type),
            (t.value = this.value),
            (t.start = this.start),
            (t.end = this.end),
            (t.lastTokEndLoc = this.lastTokEndLoc),
            (t.lastTokStartLoc = this.lastTokStartLoc),
            (t.context = this.context.slice()),
            (t.firstInvalidTemplateEscapePos =
              this.firstInvalidTemplateEscapePos),
            (t.strictErrors = this.strictErrors),
            (t.tokensLength = this.tokensLength),
            t
          );
        }
      },
      ki = function (t) {
        return t >= 48 && t <= 57;
      },
      Rt = {
        decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),
        hex: new Set([46, 88, 95, 120]),
      },
      Ce = {
        bin: (a) => a === 48 || a === 49,
        oct: (a) => a >= 48 && a <= 55,
        dec: (a) => a >= 48 && a <= 57,
        hex: (a) =>
          (a >= 48 && a <= 57) || (a >= 65 && a <= 70) || (a >= 97 && a <= 102),
      };
    function Ut(a, t, e, s, i, r) {
      let n = e,
        o = s,
        h = i,
        c = "",
        l = null,
        u = e,
        { length: f } = t;
      for (;;) {
        if (e >= f) {
          r.unterminated(n, o, h), (c += t.slice(u, e));
          break;
        }
        let d = t.charCodeAt(e);
        if (vi(a, d, t, e)) {
          c += t.slice(u, e);
          break;
        }
        if (d === 92) {
          c += t.slice(u, e);
          let y = Li(t, e, s, i, a === "template", r);
          y.ch === null && !l
            ? (l = { pos: e, lineStart: s, curLine: i })
            : (c += y.ch),
            ({ pos: e, lineStart: s, curLine: i } = y),
            (u = e);
        } else
          d === 8232 || d === 8233
            ? (++e, ++i, (s = e))
            : d === 10 || d === 13
              ? a === "template"
                ? ((c +=
                    t.slice(u, e) +
                    `
`),
                  ++e,
                  d === 13 && t.charCodeAt(e) === 10 && ++e,
                  ++i,
                  (u = s = e))
                : r.unterminated(n, o, h)
              : ++e;
      }
      return {
        pos: e,
        str: c,
        firstInvalidLoc: l,
        lineStart: s,
        curLine: i,
        containsInvalid: !!l,
      };
    }
    function vi(a, t, e, s) {
      return a === "template"
        ? t === 96 || (t === 36 && e.charCodeAt(s + 1) === 123)
        : t === (a === "double" ? 34 : 39);
    }
    function Li(a, t, e, s, i, r) {
      let n = !i;
      t++;
      let o = (c) => ({ pos: t, ch: c, lineStart: e, curLine: s }),
        h = a.charCodeAt(t++);
      switch (h) {
        case 110:
          return o(`
`);
        case 114:
          return o("\r");
        case 120: {
          let c;
          return (
            ({ code: c, pos: t } = Ze(a, t, e, s, 2, !1, n, r)),
            o(c === null ? null : String.fromCharCode(c))
          );
        }
        case 117: {
          let c;
          return (
            ({ code: c, pos: t } = is(a, t, e, s, n, r)),
            o(c === null ? null : String.fromCodePoint(c))
          );
        }
        case 116:
          return o("	");
        case 98:
          return o("\b");
        case 118:
          return o("\v");
        case 102:
          return o("\f");
        case 13:
          a.charCodeAt(t) === 10 && ++t;
        case 10:
          (e = t), ++s;
        case 8232:
        case 8233:
          return o("");
        case 56:
        case 57:
          if (i) return o(null);
          r.strictNumericEscape(t - 1, e, s);
        default:
          if (h >= 48 && h <= 55) {
            let c = t - 1,
              u = /^[0-7]+/.exec(a.slice(c, t + 2))[0],
              f = parseInt(u, 8);
            f > 255 && ((u = u.slice(0, -1)), (f = parseInt(u, 8))),
              (t += u.length - 1);
            let d = a.charCodeAt(t);
            if (u !== "0" || d === 56 || d === 57) {
              if (i) return o(null);
              r.strictNumericEscape(c, e, s);
            }
            return o(String.fromCharCode(f));
          }
          return o(String.fromCharCode(h));
      }
    }
    function Ze(a, t, e, s, i, r, n, o) {
      let h = t,
        c;
      return (
        ({ n: c, pos: t } = ss(a, t, e, s, 16, i, r, !1, o, !n)),
        c === null && (n ? o.invalidEscapeSequence(h, e, s) : (t = h - 1)),
        { code: c, pos: t }
      );
    }
    function ss(a, t, e, s, i, r, n, o, h, c) {
      let l = t,
        u = i === 16 ? Rt.hex : Rt.decBinOct,
        f = i === 16 ? Ce.hex : i === 10 ? Ce.dec : i === 8 ? Ce.oct : Ce.bin,
        d = !1,
        y = 0;
      for (let E = 0, L = r ?? 1 / 0; E < L; ++E) {
        let S = a.charCodeAt(t),
          I;
        if (S === 95 && o !== "bail") {
          let Ae = a.charCodeAt(t - 1),
            ne = a.charCodeAt(t + 1);
          if (o) {
            if (Number.isNaN(ne) || !f(ne) || u.has(Ae) || u.has(ne)) {
              if (c) return { n: null, pos: t };
              h.unexpectedNumericSeparator(t, e, s);
            }
          } else {
            if (c) return { n: null, pos: t };
            h.numericSeparatorInEscapeSequence(t, e, s);
          }
          ++t;
          continue;
        }
        if (
          (S >= 97
            ? (I = S - 97 + 10)
            : S >= 65
              ? (I = S - 65 + 10)
              : ki(S)
                ? (I = S - 48)
                : (I = 1 / 0),
          I >= i)
        ) {
          if (I <= 9 && c) return { n: null, pos: t };
          if (I <= 9 && h.invalidDigit(t, e, s, i)) I = 0;
          else if (n) (I = 0), (d = !0);
          else break;
        }
        ++t, (y = y * i + I);
      }
      return t === l || (r != null && t - l !== r) || d
        ? { n: null, pos: t }
        : { n: y, pos: t };
    }
    function is(a, t, e, s, i, r) {
      let n = a.charCodeAt(t),
        o;
      if (n === 123) {
        if (
          (++t,
          ({ code: o, pos: t } = Ze(
            a,
            t,
            e,
            s,
            a.indexOf("}", t) - t,
            !0,
            i,
            r,
          )),
          ++t,
          o !== null && o > 1114111)
        )
          if (i) r.invalidCodePoint(t, e, s);
          else return { code: null, pos: t };
      } else ({ code: o, pos: t } = Ze(a, t, e, s, 4, !1, i, r));
      return { code: o, pos: t };
    }
    function ce(a, t, e) {
      return new F(e, a - t, a);
    }
    var Di = new Set([103, 109, 115, 105, 121, 117, 100, 118]),
      O = class {
        constructor(t) {
          (this.type = t.type),
            (this.value = t.value),
            (this.start = t.start),
            (this.end = t.end),
            (this.loc = new ee(t.startLoc, t.endLoc));
        }
      },
      et = class extends Ye {
        constructor(t, e) {
          super(),
            (this.isLookahead = void 0),
            (this.tokens = []),
            (this.errorHandlers_readInt = {
              invalidDigit: (s, i, r, n) =>
                this.options.errorRecovery
                  ? (this.raise(p.InvalidDigit, ce(s, i, r), { radix: n }), !0)
                  : !1,
              numericSeparatorInEscapeSequence: this.errorBuilder(
                p.NumericSeparatorInEscapeSequence,
              ),
              unexpectedNumericSeparator: this.errorBuilder(
                p.UnexpectedNumericSeparator,
              ),
            }),
            (this.errorHandlers_readCodePoint = Object.assign(
              {},
              this.errorHandlers_readInt,
              {
                invalidEscapeSequence: this.errorBuilder(
                  p.InvalidEscapeSequence,
                ),
                invalidCodePoint: this.errorBuilder(p.InvalidCodePoint),
              },
            )),
            (this.errorHandlers_readStringContents_string = Object.assign(
              {},
              this.errorHandlers_readCodePoint,
              {
                strictNumericEscape: (s, i, r) => {
                  this.recordStrictModeErrors(
                    p.StrictNumericEscape,
                    ce(s, i, r),
                  );
                },
                unterminated: (s, i, r) => {
                  throw this.raise(p.UnterminatedString, ce(s - 1, i, r));
                },
              },
            )),
            (this.errorHandlers_readStringContents_template = Object.assign(
              {},
              this.errorHandlers_readCodePoint,
              {
                strictNumericEscape: this.errorBuilder(p.StrictNumericEscape),
                unterminated: (s, i, r) => {
                  throw this.raise(p.UnterminatedTemplate, ce(s, i, r));
                },
              },
            )),
            (this.state = new Qe()),
            this.state.init(t),
            (this.input = e),
            (this.length = e.length),
            (this.comments = []),
            (this.isLookahead = !1);
        }
        pushToken(t) {
          (this.tokens.length = this.state.tokensLength),
            this.tokens.push(t),
            ++this.state.tokensLength;
        }
        next() {
          this.checkKeywordEscapes(),
            this.options.tokens && this.pushToken(new O(this.state)),
            (this.state.lastTokEndLoc = this.state.endLoc),
            (this.state.lastTokStartLoc = this.state.startLoc),
            this.nextToken();
        }
        eat(t) {
          return this.match(t) ? (this.next(), !0) : !1;
        }
        match(t) {
          return this.state.type === t;
        }
        createLookaheadState(t) {
          return {
            pos: t.pos,
            value: null,
            type: t.type,
            start: t.start,
            end: t.end,
            context: [this.curContext()],
            inType: t.inType,
            startLoc: t.startLoc,
            lastTokEndLoc: t.lastTokEndLoc,
            curLine: t.curLine,
            lineStart: t.lineStart,
            curPosition: t.curPosition,
          };
        }
        lookahead() {
          let t = this.state;
          (this.state = this.createLookaheadState(t)),
            (this.isLookahead = !0),
            this.nextToken(),
            (this.isLookahead = !1);
          let e = this.state;
          return (this.state = t), e;
        }
        nextTokenStart() {
          return this.nextTokenStartSince(this.state.pos);
        }
        nextTokenStartSince(t) {
          return (Ve.lastIndex = t), Ve.test(this.input) ? Ve.lastIndex : t;
        }
        lookaheadCharCode() {
          return this.input.charCodeAt(this.nextTokenStart());
        }
        nextTokenInLineStart() {
          return this.nextTokenInLineStartSince(this.state.pos);
        }
        nextTokenInLineStartSince(t) {
          return (Ne.lastIndex = t), Ne.test(this.input) ? Ne.lastIndex : t;
        }
        lookaheadInLineCharCode() {
          return this.input.charCodeAt(this.nextTokenInLineStart());
        }
        codePointAtPos(t) {
          let e = this.input.charCodeAt(t);
          if ((e & 64512) === 55296 && ++t < this.input.length) {
            let s = this.input.charCodeAt(t);
            (s & 64512) === 56320 &&
              (e = 65536 + ((e & 1023) << 10) + (s & 1023));
          }
          return e;
        }
        setStrict(t) {
          (this.state.strict = t),
            t &&
              (this.state.strictErrors.forEach(([e, s]) => this.raise(e, s)),
              this.state.strictErrors.clear());
        }
        curContext() {
          return this.state.context[this.state.context.length - 1];
        }
        nextToken() {
          if (
            (this.skipSpace(),
            (this.state.start = this.state.pos),
            this.isLookahead ||
              (this.state.startLoc = this.state.curPosition()),
            this.state.pos >= this.length)
          ) {
            this.finishToken(139);
            return;
          }
          this.getTokenFromCode(this.codePointAtPos(this.state.pos));
        }
        skipBlockComment(t) {
          let e;
          this.isLookahead || (e = this.state.curPosition());
          let s = this.state.pos,
            i = this.input.indexOf(t, s + 2);
          if (i === -1)
            throw this.raise(p.UnterminatedComment, this.state.curPosition());
          for (
            this.state.pos = i + t.length, we.lastIndex = s + 2;
            we.test(this.input) && we.lastIndex <= i;

          )
            ++this.state.curLine, (this.state.lineStart = we.lastIndex);
          if (this.isLookahead) return;
          let r = {
            type: "CommentBlock",
            value: this.input.slice(s + 2, i),
            start: s,
            end: i + t.length,
            loc: new ee(e, this.state.curPosition()),
          };
          return this.options.tokens && this.pushToken(r), r;
        }
        skipLineComment(t) {
          let e = this.state.pos,
            s;
          this.isLookahead || (s = this.state.curPosition());
          let i = this.input.charCodeAt((this.state.pos += t));
          if (this.state.pos < this.length)
            for (; !fe(i) && ++this.state.pos < this.length; )
              i = this.input.charCodeAt(this.state.pos);
          if (this.isLookahead) return;
          let r = this.state.pos,
            o = {
              type: "CommentLine",
              value: this.input.slice(e + t, r),
              start: e,
              end: r,
              loc: new ee(s, this.state.curPosition()),
            };
          return this.options.tokens && this.pushToken(o), o;
        }
        skipSpace() {
          let t = this.state.pos,
            e = [];
          e: for (; this.state.pos < this.length; ) {
            let s = this.input.charCodeAt(this.state.pos);
            switch (s) {
              case 32:
              case 160:
              case 9:
                ++this.state.pos;
                break;
              case 13:
                this.input.charCodeAt(this.state.pos + 1) === 10 &&
                  ++this.state.pos;
              case 10:
              case 8232:
              case 8233:
                ++this.state.pos,
                  ++this.state.curLine,
                  (this.state.lineStart = this.state.pos);
                break;
              case 47:
                switch (this.input.charCodeAt(this.state.pos + 1)) {
                  case 42: {
                    let i = this.skipBlockComment("*/");
                    i !== void 0 &&
                      (this.addComment(i),
                      this.options.attachComment && e.push(i));
                    break;
                  }
                  case 47: {
                    let i = this.skipLineComment(2);
                    i !== void 0 &&
                      (this.addComment(i),
                      this.options.attachComment && e.push(i));
                    break;
                  }
                  default:
                    break e;
                }
                break;
              default:
                if (Ni(s)) ++this.state.pos;
                else if (s === 45 && !this.inModule && this.options.annexB) {
                  let i = this.state.pos;
                  if (
                    this.input.charCodeAt(i + 1) === 45 &&
                    this.input.charCodeAt(i + 2) === 62 &&
                    (t === 0 || this.state.lineStart > t)
                  ) {
                    let r = this.skipLineComment(3);
                    r !== void 0 &&
                      (this.addComment(r),
                      this.options.attachComment && e.push(r));
                  } else break e;
                } else if (s === 60 && !this.inModule && this.options.annexB) {
                  let i = this.state.pos;
                  if (
                    this.input.charCodeAt(i + 1) === 33 &&
                    this.input.charCodeAt(i + 2) === 45 &&
                    this.input.charCodeAt(i + 3) === 45
                  ) {
                    let r = this.skipLineComment(4);
                    r !== void 0 &&
                      (this.addComment(r),
                      this.options.attachComment && e.push(r));
                  } else break e;
                } else break e;
            }
          }
          if (e.length > 0) {
            let s = this.state.pos,
              i = {
                start: t,
                end: s,
                comments: e,
                leadingNode: null,
                trailingNode: null,
                containingNode: null,
              };
            this.state.commentStack.push(i);
          }
        }
        finishToken(t, e) {
          (this.state.end = this.state.pos),
            (this.state.endLoc = this.state.curPosition());
          let s = this.state.type;
          (this.state.type = t),
            (this.state.value = e),
            this.isLookahead || this.updateContext(s);
        }
        replaceToken(t) {
          (this.state.type = t), this.updateContext();
        }
        readToken_numberSign() {
          if (this.state.pos === 0 && this.readToken_interpreter()) return;
          let t = this.state.pos + 1,
            e = this.codePointAtPos(t);
          if (e >= 48 && e <= 57)
            throw this.raise(
              p.UnexpectedDigitAfterHash,
              this.state.curPosition(),
            );
          if (e === 123 || (e === 91 && this.hasPlugin("recordAndTuple"))) {
            if (
              (this.expectPlugin("recordAndTuple"),
              this.getPluginOption("recordAndTuple", "syntaxType") === "bar")
            )
              throw this.raise(
                e === 123
                  ? p.RecordExpressionHashIncorrectStartSyntaxType
                  : p.TupleExpressionHashIncorrectStartSyntaxType,
                this.state.curPosition(),
              );
            (this.state.pos += 2),
              e === 123 ? this.finishToken(7) : this.finishToken(1);
          } else
            _(e)
              ? (++this.state.pos, this.finishToken(138, this.readWord1(e)))
              : e === 92
                ? (++this.state.pos, this.finishToken(138, this.readWord1()))
                : this.finishOp(27, 1);
        }
        readToken_dot() {
          let t = this.input.charCodeAt(this.state.pos + 1);
          if (t >= 48 && t <= 57) {
            this.readNumber(!0);
            return;
          }
          t === 46 && this.input.charCodeAt(this.state.pos + 2) === 46
            ? ((this.state.pos += 3), this.finishToken(21))
            : (++this.state.pos, this.finishToken(16));
        }
        readToken_slash() {
          this.input.charCodeAt(this.state.pos + 1) === 61
            ? this.finishOp(31, 2)
            : this.finishOp(56, 1);
        }
        readToken_interpreter() {
          if (this.state.pos !== 0 || this.length < 2) return !1;
          let t = this.input.charCodeAt(this.state.pos + 1);
          if (t !== 33) return !1;
          let e = this.state.pos;
          for (this.state.pos += 1; !fe(t) && ++this.state.pos < this.length; )
            t = this.input.charCodeAt(this.state.pos);
          let s = this.input.slice(e + 2, this.state.pos);
          return this.finishToken(28, s), !0;
        }
        readToken_mult_modulo(t) {
          let e = t === 42 ? 55 : 54,
            s = 1,
            i = this.input.charCodeAt(this.state.pos + 1);
          t === 42 &&
            i === 42 &&
            (s++, (i = this.input.charCodeAt(this.state.pos + 2)), (e = 57)),
            i === 61 && !this.state.inType && (s++, (e = t === 37 ? 33 : 30)),
            this.finishOp(e, s);
        }
        readToken_pipe_amp(t) {
          let e = this.input.charCodeAt(this.state.pos + 1);
          if (e === t) {
            this.input.charCodeAt(this.state.pos + 2) === 61
              ? this.finishOp(30, 3)
              : this.finishOp(t === 124 ? 41 : 42, 2);
            return;
          }
          if (t === 124) {
            if (e === 62) {
              this.finishOp(39, 2);
              return;
            }
            if (this.hasPlugin("recordAndTuple") && e === 125) {
              if (
                this.getPluginOption("recordAndTuple", "syntaxType") !== "bar"
              )
                throw this.raise(
                  p.RecordExpressionBarIncorrectEndSyntaxType,
                  this.state.curPosition(),
                );
              (this.state.pos += 2), this.finishToken(9);
              return;
            }
            if (this.hasPlugin("recordAndTuple") && e === 93) {
              if (
                this.getPluginOption("recordAndTuple", "syntaxType") !== "bar"
              )
                throw this.raise(
                  p.TupleExpressionBarIncorrectEndSyntaxType,
                  this.state.curPosition(),
                );
              (this.state.pos += 2), this.finishToken(4);
              return;
            }
          }
          if (e === 61) {
            this.finishOp(30, 2);
            return;
          }
          this.finishOp(t === 124 ? 43 : 45, 1);
        }
        readToken_caret() {
          let t = this.input.charCodeAt(this.state.pos + 1);
          t === 61 && !this.state.inType
            ? this.finishOp(32, 2)
            : t === 94 &&
                this.hasPlugin([
                  "pipelineOperator",
                  { proposal: "hack", topicToken: "^^" },
                ])
              ? (this.finishOp(37, 2),
                this.input.codePointAt(this.state.pos) === 94 &&
                  this.unexpected())
              : this.finishOp(44, 1);
        }
        readToken_atSign() {
          this.input.charCodeAt(this.state.pos + 1) === 64 &&
          this.hasPlugin([
            "pipelineOperator",
            { proposal: "hack", topicToken: "@@" },
          ])
            ? this.finishOp(38, 2)
            : this.finishOp(26, 1);
        }
        readToken_plus_min(t) {
          let e = this.input.charCodeAt(this.state.pos + 1);
          if (e === t) {
            this.finishOp(34, 2);
            return;
          }
          e === 61 ? this.finishOp(30, 2) : this.finishOp(53, 1);
        }
        readToken_lt() {
          let { pos: t } = this.state,
            e = this.input.charCodeAt(t + 1);
          if (e === 60) {
            if (this.input.charCodeAt(t + 2) === 61) {
              this.finishOp(30, 3);
              return;
            }
            this.finishOp(51, 2);
            return;
          }
          if (e === 61) {
            this.finishOp(49, 2);
            return;
          }
          this.finishOp(47, 1);
        }
        readToken_gt() {
          let { pos: t } = this.state,
            e = this.input.charCodeAt(t + 1);
          if (e === 62) {
            let s = this.input.charCodeAt(t + 2) === 62 ? 3 : 2;
            if (this.input.charCodeAt(t + s) === 61) {
              this.finishOp(30, s + 1);
              return;
            }
            this.finishOp(52, s);
            return;
          }
          if (e === 61) {
            this.finishOp(49, 2);
            return;
          }
          this.finishOp(48, 1);
        }
        readToken_eq_excl(t) {
          let e = this.input.charCodeAt(this.state.pos + 1);
          if (e === 61) {
            this.finishOp(
              46,
              this.input.charCodeAt(this.state.pos + 2) === 61 ? 3 : 2,
            );
            return;
          }
          if (t === 61 && e === 62) {
            (this.state.pos += 2), this.finishToken(19);
            return;
          }
          this.finishOp(t === 61 ? 29 : 35, 1);
        }
        readToken_question() {
          let t = this.input.charCodeAt(this.state.pos + 1),
            e = this.input.charCodeAt(this.state.pos + 2);
          t === 63
            ? e === 61
              ? this.finishOp(30, 3)
              : this.finishOp(40, 2)
            : t === 46 && !(e >= 48 && e <= 57)
              ? ((this.state.pos += 2), this.finishToken(18))
              : (++this.state.pos, this.finishToken(17));
        }
        getTokenFromCode(t) {
          switch (t) {
            case 46:
              this.readToken_dot();
              return;
            case 40:
              ++this.state.pos, this.finishToken(10);
              return;
            case 41:
              ++this.state.pos, this.finishToken(11);
              return;
            case 59:
              ++this.state.pos, this.finishToken(13);
              return;
            case 44:
              ++this.state.pos, this.finishToken(12);
              return;
            case 91:
              if (
                this.hasPlugin("recordAndTuple") &&
                this.input.charCodeAt(this.state.pos + 1) === 124
              ) {
                if (
                  this.getPluginOption("recordAndTuple", "syntaxType") !== "bar"
                )
                  throw this.raise(
                    p.TupleExpressionBarIncorrectStartSyntaxType,
                    this.state.curPosition(),
                  );
                (this.state.pos += 2), this.finishToken(2);
              } else ++this.state.pos, this.finishToken(0);
              return;
            case 93:
              ++this.state.pos, this.finishToken(3);
              return;
            case 123:
              if (
                this.hasPlugin("recordAndTuple") &&
                this.input.charCodeAt(this.state.pos + 1) === 124
              ) {
                if (
                  this.getPluginOption("recordAndTuple", "syntaxType") !== "bar"
                )
                  throw this.raise(
                    p.RecordExpressionBarIncorrectStartSyntaxType,
                    this.state.curPosition(),
                  );
                (this.state.pos += 2), this.finishToken(6);
              } else ++this.state.pos, this.finishToken(5);
              return;
            case 125:
              ++this.state.pos, this.finishToken(8);
              return;
            case 58:
              this.hasPlugin("functionBind") &&
              this.input.charCodeAt(this.state.pos + 1) === 58
                ? this.finishOp(15, 2)
                : (++this.state.pos, this.finishToken(14));
              return;
            case 63:
              this.readToken_question();
              return;
            case 96:
              this.readTemplateToken();
              return;
            case 48: {
              let e = this.input.charCodeAt(this.state.pos + 1);
              if (e === 120 || e === 88) {
                this.readRadixNumber(16);
                return;
              }
              if (e === 111 || e === 79) {
                this.readRadixNumber(8);
                return;
              }
              if (e === 98 || e === 66) {
                this.readRadixNumber(2);
                return;
              }
            }
            case 49:
            case 50:
            case 51:
            case 52:
            case 53:
            case 54:
            case 55:
            case 56:
            case 57:
              this.readNumber(!1);
              return;
            case 34:
            case 39:
              this.readString(t);
              return;
            case 47:
              this.readToken_slash();
              return;
            case 37:
            case 42:
              this.readToken_mult_modulo(t);
              return;
            case 124:
            case 38:
              this.readToken_pipe_amp(t);
              return;
            case 94:
              this.readToken_caret();
              return;
            case 43:
            case 45:
              this.readToken_plus_min(t);
              return;
            case 60:
              this.readToken_lt();
              return;
            case 62:
              this.readToken_gt();
              return;
            case 61:
            case 33:
              this.readToken_eq_excl(t);
              return;
            case 126:
              this.finishOp(36, 1);
              return;
            case 64:
              this.readToken_atSign();
              return;
            case 35:
              this.readToken_numberSign();
              return;
            case 92:
              this.readWord();
              return;
            default:
              if (_(t)) {
                this.readWord(t);
                return;
              }
          }
          throw this.raise(
            p.InvalidOrUnexpectedToken,
            this.state.curPosition(),
            { unexpected: String.fromCodePoint(t) },
          );
        }
        finishOp(t, e) {
          let s = this.input.slice(this.state.pos, this.state.pos + e);
          (this.state.pos += e), this.finishToken(t, s);
        }
        readRegexp() {
          let t = this.state.startLoc,
            e = this.state.start + 1,
            s,
            i,
            { pos: r } = this.state;
          for (; ; ++r) {
            if (r >= this.length)
              throw this.raise(p.UnterminatedRegExp, v(t, 1));
            let c = this.input.charCodeAt(r);
            if (fe(c)) throw this.raise(p.UnterminatedRegExp, v(t, 1));
            if (s) s = !1;
            else {
              if (c === 91) i = !0;
              else if (c === 93 && i) i = !1;
              else if (c === 47 && !i) break;
              s = c === 92;
            }
          }
          let n = this.input.slice(e, r);
          ++r;
          let o = "",
            h = () => v(t, r + 2 - e);
          for (; r < this.length; ) {
            let c = this.codePointAtPos(r),
              l = String.fromCharCode(c);
            if (Di.has(c))
              c === 118
                ? o.includes("u") &&
                  this.raise(p.IncompatibleRegExpUVFlags, h())
                : c === 117 &&
                  o.includes("v") &&
                  this.raise(p.IncompatibleRegExpUVFlags, h()),
                o.includes(l) && this.raise(p.DuplicateRegExpFlags, h());
            else if (Q(c) || c === 92) this.raise(p.MalformedRegExpFlags, h());
            else break;
            ++r, (o += l);
          }
          (this.state.pos = r), this.finishToken(137, { pattern: n, flags: o });
        }
        readInt(t, e, s = !1, i = !0) {
          let { n: r, pos: n } = ss(
            this.input,
            this.state.pos,
            this.state.lineStart,
            this.state.curLine,
            t,
            e,
            s,
            i,
            this.errorHandlers_readInt,
            !1,
          );
          return (this.state.pos = n), r;
        }
        readRadixNumber(t) {
          let e = this.state.curPosition(),
            s = !1;
          this.state.pos += 2;
          let i = this.readInt(t);
          i == null && this.raise(p.InvalidDigit, v(e, 2), { radix: t });
          let r = this.input.charCodeAt(this.state.pos);
          if (r === 110) ++this.state.pos, (s = !0);
          else if (r === 109) throw this.raise(p.InvalidDecimal, e);
          if (_(this.codePointAtPos(this.state.pos)))
            throw this.raise(p.NumberIdentifier, this.state.curPosition());
          if (s) {
            let n = this.input
              .slice(e.index, this.state.pos)
              .replace(/[_n]/g, "");
            this.finishToken(135, n);
            return;
          }
          this.finishToken(134, i);
        }
        readNumber(t) {
          let e = this.state.pos,
            s = this.state.curPosition(),
            i = !1,
            r = !1,
            n = !1,
            o = !1,
            h = !1;
          !t &&
            this.readInt(10) === null &&
            this.raise(p.InvalidNumber, this.state.curPosition());
          let c = this.state.pos - e >= 2 && this.input.charCodeAt(e) === 48;
          if (c) {
            let d = this.input.slice(e, this.state.pos);
            if (
              (this.recordStrictModeErrors(p.StrictOctalLiteral, s),
              !this.state.strict)
            ) {
              let y = d.indexOf("_");
              y > 0 && this.raise(p.ZeroDigitNumericSeparator, v(s, y));
            }
            h = c && !/[89]/.test(d);
          }
          let l = this.input.charCodeAt(this.state.pos);
          if (
            (l === 46 &&
              !h &&
              (++this.state.pos,
              this.readInt(10),
              (i = !0),
              (l = this.input.charCodeAt(this.state.pos))),
            (l === 69 || l === 101) &&
              !h &&
              ((l = this.input.charCodeAt(++this.state.pos)),
              (l === 43 || l === 45) && ++this.state.pos,
              this.readInt(10) === null &&
                this.raise(p.InvalidOrMissingExponent, s),
              (i = !0),
              (o = !0),
              (l = this.input.charCodeAt(this.state.pos))),
            l === 110 &&
              ((i || c) && this.raise(p.InvalidBigIntLiteral, s),
              ++this.state.pos,
              (r = !0)),
            l === 109 &&
              (this.expectPlugin("decimal", this.state.curPosition()),
              (o || c) && this.raise(p.InvalidDecimal, s),
              ++this.state.pos,
              (n = !0)),
            _(this.codePointAtPos(this.state.pos)))
          )
            throw this.raise(p.NumberIdentifier, this.state.curPosition());
          let u = this.input.slice(e, this.state.pos).replace(/[_mn]/g, "");
          if (r) {
            this.finishToken(135, u);
            return;
          }
          if (n) {
            this.finishToken(136, u);
            return;
          }
          let f = h ? parseInt(u, 8) : parseFloat(u);
          this.finishToken(134, f);
        }
        readCodePoint(t) {
          let { code: e, pos: s } = is(
            this.input,
            this.state.pos,
            this.state.lineStart,
            this.state.curLine,
            t,
            this.errorHandlers_readCodePoint,
          );
          return (this.state.pos = s), e;
        }
        readString(t) {
          let {
            str: e,
            pos: s,
            curLine: i,
            lineStart: r,
          } = Ut(
            t === 34 ? "double" : "single",
            this.input,
            this.state.pos + 1,
            this.state.lineStart,
            this.state.curLine,
            this.errorHandlers_readStringContents_string,
          );
          (this.state.pos = s + 1),
            (this.state.lineStart = r),
            (this.state.curLine = i),
            this.finishToken(133, e);
        }
        readTemplateContinuation() {
          this.match(8) || this.unexpected(null, 8),
            this.state.pos--,
            this.readTemplateToken();
        }
        readTemplateToken() {
          let t = this.input[this.state.pos],
            {
              str: e,
              firstInvalidLoc: s,
              pos: i,
              curLine: r,
              lineStart: n,
            } = Ut(
              "template",
              this.input,
              this.state.pos + 1,
              this.state.lineStart,
              this.state.curLine,
              this.errorHandlers_readStringContents_template,
            );
          (this.state.pos = i + 1),
            (this.state.lineStart = n),
            (this.state.curLine = r),
            s &&
              (this.state.firstInvalidTemplateEscapePos = new F(
                s.curLine,
                s.pos - s.lineStart,
                s.pos,
              )),
            this.input.codePointAt(i) === 96
              ? this.finishToken(24, s ? null : t + e + "`")
              : (this.state.pos++,
                this.finishToken(25, s ? null : t + e + "${"));
        }
        recordStrictModeErrors(t, e) {
          let s = e.index;
          this.state.strict && !this.state.strictErrors.has(s)
            ? this.raise(t, e)
            : this.state.strictErrors.set(s, [t, e]);
        }
        readWord1(t) {
          this.state.containsEsc = !1;
          let e = "",
            s = this.state.pos,
            i = this.state.pos;
          for (
            t !== void 0 && (this.state.pos += t <= 65535 ? 1 : 2);
            this.state.pos < this.length;

          ) {
            let r = this.codePointAtPos(this.state.pos);
            if (Q(r)) this.state.pos += r <= 65535 ? 1 : 2;
            else if (r === 92) {
              (this.state.containsEsc = !0),
                (e += this.input.slice(i, this.state.pos));
              let n = this.state.curPosition(),
                o = this.state.pos === s ? _ : Q;
              if (this.input.charCodeAt(++this.state.pos) !== 117) {
                this.raise(p.MissingUnicodeEscape, this.state.curPosition()),
                  (i = this.state.pos - 1);
                continue;
              }
              ++this.state.pos;
              let h = this.readCodePoint(!0);
              h !== null &&
                (o(h) || this.raise(p.EscapedCharNotAnIdentifier, n),
                (e += String.fromCodePoint(h))),
                (i = this.state.pos);
            } else break;
          }
          return e + this.input.slice(i, this.state.pos);
        }
        readWord(t) {
          let e = this.readWord1(t),
            s = ut.get(e);
          s !== void 0 ? this.finishToken(s, K(s)) : this.finishToken(132, e);
        }
        checkKeywordEscapes() {
          let { type: t } = this.state;
          Pt(t) &&
            this.state.containsEsc &&
            this.raise(p.InvalidEscapedReservedWord, this.state.startLoc, {
              reservedWord: K(t),
            });
        }
        raise(t, e, s = {}) {
          let i = e instanceof F ? e : e.loc.start,
            r = t(i, s);
          if (!this.options.errorRecovery) throw r;
          return this.isLookahead || this.state.errors.push(r), r;
        }
        raiseOverwrite(t, e, s = {}) {
          let i = e instanceof F ? e : e.loc.start,
            r = i.index,
            n = this.state.errors;
          for (let o = n.length - 1; o >= 0; o--) {
            let h = n[o];
            if (h.loc.index === r) return (n[o] = t(i, s));
            if (h.loc.index < r) break;
          }
          return this.raise(t, e, s);
        }
        updateContext(t) {}
        unexpected(t, e) {
          throw this.raise(p.UnexpectedToken, t ?? this.state.startLoc, {
            expected: e ? K(e) : null,
          });
        }
        expectPlugin(t, e) {
          if (this.hasPlugin(t)) return !0;
          throw this.raise(p.MissingPlugin, e ?? this.state.startLoc, {
            missingPlugin: [t],
          });
        }
        expectOnePlugin(t) {
          if (!t.some((e) => this.hasPlugin(e)))
            throw this.raise(p.MissingOneOfPlugins, this.state.startLoc, {
              missingPlugin: t,
            });
        }
        errorBuilder(t) {
          return (e, s, i) => {
            this.raise(t, ce(e, s, i));
          };
        }
      },
      tt = class {
        constructor() {
          (this.privateNames = new Set()),
            (this.loneAccessors = new Map()),
            (this.undefinedPrivateNames = new Map());
        }
      },
      st = class {
        constructor(t) {
          (this.parser = void 0),
            (this.stack = []),
            (this.undefinedPrivateNames = new Map()),
            (this.parser = t);
        }
        current() {
          return this.stack[this.stack.length - 1];
        }
        enter() {
          this.stack.push(new tt());
        }
        exit() {
          let t = this.stack.pop(),
            e = this.current();
          for (let [s, i] of Array.from(t.undefinedPrivateNames))
            e
              ? e.undefinedPrivateNames.has(s) ||
                e.undefinedPrivateNames.set(s, i)
              : this.parser.raise(p.InvalidPrivateFieldResolution, i, {
                  identifierName: s,
                });
        }
        declarePrivateName(t, e, s) {
          let {
              privateNames: i,
              loneAccessors: r,
              undefinedPrivateNames: n,
            } = this.current(),
            o = i.has(t);
          if (e & 3) {
            let h = o && r.get(t);
            if (h) {
              let c = h & 4,
                l = e & 4,
                u = h & 3,
                f = e & 3;
              (o = u === f || c !== l), o || r.delete(t);
            } else o || r.set(t, e);
          }
          o &&
            this.parser.raise(p.PrivateNameRedeclaration, s, {
              identifierName: t,
            }),
            i.add(t),
            n.delete(t);
        }
        usePrivateName(t, e) {
          let s;
          for (s of this.stack) if (s.privateNames.has(t)) return;
          s
            ? s.undefinedPrivateNames.set(t, e)
            : this.parser.raise(p.InvalidPrivateFieldResolution, e, {
                identifierName: t,
              });
        }
      },
      te = class {
        constructor(t = 0) {
          this.type = t;
        }
        canBeArrowParameterDeclaration() {
          return this.type === 2 || this.type === 1;
        }
        isCertainlyParameterDeclaration() {
          return this.type === 3;
        }
      },
      De = class extends te {
        constructor(t) {
          super(t), (this.declarationErrors = new Map());
        }
        recordDeclarationError(t, e) {
          let s = e.index;
          this.declarationErrors.set(s, [t, e]);
        }
        clearDeclarationError(t) {
          this.declarationErrors.delete(t);
        }
        iterateErrors(t) {
          this.declarationErrors.forEach(t);
        }
      },
      it = class {
        constructor(t) {
          (this.parser = void 0), (this.stack = [new te()]), (this.parser = t);
        }
        enter(t) {
          this.stack.push(t);
        }
        exit() {
          this.stack.pop();
        }
        recordParameterInitializerError(t, e) {
          let s = e.loc.start,
            { stack: i } = this,
            r = i.length - 1,
            n = i[r];
          for (; !n.isCertainlyParameterDeclaration(); ) {
            if (n.canBeArrowParameterDeclaration())
              n.recordDeclarationError(t, s);
            else return;
            n = i[--r];
          }
          this.parser.raise(t, s);
        }
        recordArrowParameterBindingError(t, e) {
          let { stack: s } = this,
            i = s[s.length - 1],
            r = e.loc.start;
          if (i.isCertainlyParameterDeclaration()) this.parser.raise(t, r);
          else if (i.canBeArrowParameterDeclaration())
            i.recordDeclarationError(t, r);
          else return;
        }
        recordAsyncArrowParametersError(t) {
          let { stack: e } = this,
            s = e.length - 1,
            i = e[s];
          for (; i.canBeArrowParameterDeclaration(); )
            i.type === 2 &&
              i.recordDeclarationError(p.AwaitBindingIdentifier, t),
              (i = e[--s]);
        }
        validateAsPattern() {
          let { stack: t } = this,
            e = t[t.length - 1];
          e.canBeArrowParameterDeclaration() &&
            e.iterateErrors(([s, i]) => {
              this.parser.raise(s, i);
              let r = t.length - 2,
                n = t[r];
              for (; n.canBeArrowParameterDeclaration(); )
                n.clearDeclarationError(i.index), (n = t[--r]);
            });
        }
      };
    function Mi() {
      return new te(3);
    }
    function Oi() {
      return new De(1);
    }
    function Fi() {
      return new De(2);
    }
    function rs() {
      return new te();
    }
    var rt = class {
      constructor() {
        this.stacks = [];
      }
      enter(t) {
        this.stacks.push(t);
      }
      exit() {
        this.stacks.pop();
      }
      currentFlags() {
        return this.stacks[this.stacks.length - 1];
      }
      get hasAwait() {
        return (this.currentFlags() & 2) > 0;
      }
      get hasYield() {
        return (this.currentFlags() & 1) > 0;
      }
      get hasReturn() {
        return (this.currentFlags() & 4) > 0;
      }
      get hasIn() {
        return (this.currentFlags() & 8) > 0;
      }
    };
    function ke(a, t) {
      return (a ? 2 : 0) | (t ? 1 : 0);
    }
    var at = class extends et {
        addExtra(t, e, s, i = !0) {
          if (!t) return;
          let r = (t.extra = t.extra || {});
          i
            ? (r[e] = s)
            : Object.defineProperty(r, e, { enumerable: i, value: s });
        }
        isContextual(t) {
          return this.state.type === t && !this.state.containsEsc;
        }
        isUnparsedContextual(t, e) {
          let s = t + e.length;
          if (this.input.slice(t, s) === e) {
            let i = this.input.charCodeAt(s);
            return !(Q(i) || (i & 64512) === 55296);
          }
          return !1;
        }
        isLookaheadContextual(t) {
          let e = this.nextTokenStart();
          return this.isUnparsedContextual(e, t);
        }
        eatContextual(t) {
          return this.isContextual(t) ? (this.next(), !0) : !1;
        }
        expectContextual(t, e) {
          if (!this.eatContextual(t)) {
            if (e != null) throw this.raise(e, this.state.startLoc);
            this.unexpected(null, t);
          }
        }
        canInsertSemicolon() {
          return (
            this.match(139) || this.match(8) || this.hasPrecedingLineBreak()
          );
        }
        hasPrecedingLineBreak() {
          return ts.test(
            this.input.slice(this.state.lastTokEndLoc.index, this.state.start),
          );
        }
        hasFollowingLineBreak() {
          return (Bt.lastIndex = this.state.end), Bt.test(this.input);
        }
        isLineTerminator() {
          return this.eat(13) || this.canInsertSemicolon();
        }
        semicolon(t = !0) {
          (t ? this.isLineTerminator() : this.eat(13)) ||
            this.raise(p.MissingSemicolon, this.state.lastTokEndLoc);
        }
        expect(t, e) {
          this.eat(t) || this.unexpected(e, t);
        }
        tryParse(t, e = this.state.clone()) {
          let s = { node: null };
          try {
            let i = t((r = null) => {
              throw ((s.node = r), s);
            });
            if (this.state.errors.length > e.errors.length) {
              let r = this.state;
              return (
                (this.state = e),
                (this.state.tokensLength = r.tokensLength),
                {
                  node: i,
                  error: r.errors[e.errors.length],
                  thrown: !1,
                  aborted: !1,
                  failState: r,
                }
              );
            }
            return {
              node: i,
              error: null,
              thrown: !1,
              aborted: !1,
              failState: null,
            };
          } catch (i) {
            let r = this.state;
            if (((this.state = e), i instanceof SyntaxError))
              return {
                node: null,
                error: i,
                thrown: !0,
                aborted: !1,
                failState: r,
              };
            if (i === s)
              return {
                node: s.node,
                error: null,
                thrown: !1,
                aborted: !0,
                failState: r,
              };
            throw i;
          }
        }
        checkExpressionErrors(t, e) {
          if (!t) return !1;
          let {
              shorthandAssignLoc: s,
              doubleProtoLoc: i,
              privateKeyLoc: r,
              optionalParametersLoc: n,
            } = t,
            o = !!s || !!i || !!n || !!r;
          if (!e) return o;
          s != null && this.raise(p.InvalidCoverInitializedName, s),
            i != null && this.raise(p.DuplicateProto, i),
            r != null && this.raise(p.UnexpectedPrivateField, r),
            n != null && this.unexpected(n);
        }
        isLiteralPropertyName() {
          return Wt(this.state.type);
        }
        isPrivateName(t) {
          return t.type === "PrivateName";
        }
        getPrivateNameSV(t) {
          return t.id.name;
        }
        hasPropertyAsPrivateName(t) {
          return (
            (t.type === "MemberExpression" ||
              t.type === "OptionalMemberExpression") &&
            this.isPrivateName(t.property)
          );
        }
        isObjectProperty(t) {
          return t.type === "ObjectProperty";
        }
        isObjectMethod(t) {
          return t.type === "ObjectMethod";
        }
        initializeScopes(t = this.options.sourceType === "module") {
          let e = this.state.labels;
          this.state.labels = [];
          let s = this.exportedIdentifiers;
          this.exportedIdentifiers = new Set();
          let i = this.inModule;
          this.inModule = t;
          let r = this.scope,
            n = this.getScopeHandler();
          this.scope = new n(this, t);
          let o = this.prodParam;
          this.prodParam = new rt();
          let h = this.classScope;
          this.classScope = new st(this);
          let c = this.expressionScope;
          return (
            (this.expressionScope = new it(this)),
            () => {
              (this.state.labels = e),
                (this.exportedIdentifiers = s),
                (this.inModule = i),
                (this.scope = r),
                (this.prodParam = o),
                (this.classScope = h),
                (this.expressionScope = c);
            }
          );
        }
        enterInitialScopes() {
          let t = 0;
          this.inModule && (t |= 2),
            this.scope.enter(1),
            this.prodParam.enter(t);
        }
        checkDestructuringPrivate(t) {
          let { privateKeyLoc: e } = t;
          e !== null && this.expectPlugin("destructuringPrivate", e);
        }
      },
      Z = class {
        constructor() {
          (this.shorthandAssignLoc = null),
            (this.doubleProtoLoc = null),
            (this.privateKeyLoc = null),
            (this.optionalParametersLoc = null);
        }
      },
      se = class {
        constructor(t, e, s) {
          (this.type = ""),
            (this.start = e),
            (this.end = 0),
            (this.loc = new ee(s)),
            t != null && t.options.ranges && (this.range = [e, 0]),
            t != null && t.filename && (this.loc.filename = t.filename);
        }
      },
      bt = se.prototype;
    bt.__clone = function () {
      let a = new se(void 0, this.start, this.loc.start),
        t = Object.keys(this);
      for (let e = 0, s = t.length; e < s; e++) {
        let i = t[e];
        i !== "leadingComments" &&
          i !== "trailingComments" &&
          i !== "innerComments" &&
          (a[i] = this[i]);
      }
      return a;
    };
    function Bi(a) {
      return $(a);
    }
    function $(a) {
      let {
          type: t,
          start: e,
          end: s,
          loc: i,
          range: r,
          extra: n,
          name: o,
        } = a,
        h = Object.create(bt);
      return (
        (h.type = t),
        (h.start = e),
        (h.end = s),
        (h.loc = i),
        (h.range = r),
        (h.extra = n),
        (h.name = o),
        t === "Placeholder" && (h.expectedNode = a.expectedNode),
        h
      );
    }
    function Ri(a) {
      let { type: t, start: e, end: s, loc: i, range: r, extra: n } = a;
      if (t === "Placeholder") return Bi(a);
      let o = Object.create(bt);
      return (
        (o.type = t),
        (o.start = e),
        (o.end = s),
        (o.loc = i),
        (o.range = r),
        a.raw !== void 0 ? (o.raw = a.raw) : (o.extra = n),
        (o.value = a.value),
        o
      );
    }
    var nt = class extends at {
        startNode() {
          let t = this.state.startLoc;
          return new se(this, t.index, t);
        }
        startNodeAt(t) {
          return new se(this, t.index, t);
        }
        startNodeAtNode(t) {
          return this.startNodeAt(t.loc.start);
        }
        finishNode(t, e) {
          return this.finishNodeAt(t, e, this.state.lastTokEndLoc);
        }
        finishNodeAt(t, e, s) {
          return (
            (t.type = e),
            (t.end = s.index),
            (t.loc.end = s),
            this.options.ranges && (t.range[1] = s.index),
            this.options.attachComment && this.processComment(t),
            t
          );
        }
        resetStartLocation(t, e) {
          (t.start = e.index),
            (t.loc.start = e),
            this.options.ranges && (t.range[0] = e.index);
        }
        resetEndLocation(t, e = this.state.lastTokEndLoc) {
          (t.end = e.index),
            (t.loc.end = e),
            this.options.ranges && (t.range[1] = e.index);
        }
        resetStartLocationFromNode(t, e) {
          this.resetStartLocation(t, e.loc.start);
        }
      },
      Ui = new Set([
        "_",
        "any",
        "bool",
        "boolean",
        "empty",
        "extends",
        "false",
        "interface",
        "mixed",
        "null",
        "number",
        "static",
        "string",
        "true",
        "typeof",
        "void",
      ]),
      g = j`flow`({
        AmbiguousConditionalArrow:
          "Ambiguous expression: wrap the arrow functions in parentheses to disambiguate.",
        AmbiguousDeclareModuleKind:
          "Found both `declare module.exports` and `declare export` in the same module. Modules can only have 1 since they are either an ES module or they are a CommonJS module.",
        AssignReservedType: ({ reservedType: a }) =>
          `Cannot overwrite reserved type ${a}.`,
        DeclareClassElement:
          "The `declare` modifier can only appear on class fields.",
        DeclareClassFieldInitializer:
          "Initializers are not allowed in fields with the `declare` modifier.",
        DuplicateDeclareModuleExports:
          "Duplicate `declare module.exports` statement.",
        EnumBooleanMemberNotInitialized: ({ memberName: a, enumName: t }) =>
          `Boolean enum members need to be initialized. Use either \`${a} = true,\` or \`${a} = false,\` in enum \`${t}\`.`,
        EnumDuplicateMemberName: ({ memberName: a, enumName: t }) =>
          `Enum member names need to be unique, but the name \`${a}\` has already been used before in enum \`${t}\`.`,
        EnumInconsistentMemberValues: ({ enumName: a }) =>
          `Enum \`${a}\` has inconsistent member initializers. Either use no initializers, or consistently use literals (either booleans, numbers, or strings) for all member initializers.`,
        EnumInvalidExplicitType: ({ invalidEnumType: a, enumName: t }) =>
          `Enum type \`${a}\` is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${t}\`.`,
        EnumInvalidExplicitTypeUnknownSupplied: ({ enumName: a }) =>
          `Supplied enum type is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${a}\`.`,
        EnumInvalidMemberInitializerPrimaryType: ({
          enumName: a,
          memberName: t,
          explicitType: e,
        }) =>
          `Enum \`${a}\` has type \`${e}\`, so the initializer of \`${t}\` needs to be a ${e} literal.`,
        EnumInvalidMemberInitializerSymbolType: ({
          enumName: a,
          memberName: t,
        }) =>
          `Symbol enum members cannot be initialized. Use \`${t},\` in enum \`${a}\`.`,
        EnumInvalidMemberInitializerUnknownType: ({
          enumName: a,
          memberName: t,
        }) =>
          `The enum member initializer for \`${t}\` needs to be a literal (either a boolean, number, or string) in enum \`${a}\`.`,
        EnumInvalidMemberName: ({
          enumName: a,
          memberName: t,
          suggestion: e,
        }) =>
          `Enum member names cannot start with lowercase 'a' through 'z'. Instead of using \`${t}\`, consider using \`${e}\`, in enum \`${a}\`.`,
        EnumNumberMemberNotInitialized: ({ enumName: a, memberName: t }) =>
          `Number enum members need to be initialized, e.g. \`${t} = 1\` in enum \`${a}\`.`,
        EnumStringMemberInconsistentlyInitialized: ({ enumName: a }) =>
          `String enum members need to consistently either all use initializers, or use no initializers, in enum \`${a}\`.`,
        GetterMayNotHaveThisParam: "A getter cannot have a `this` parameter.",
        ImportReflectionHasImportType:
          "An `import module` declaration can not use `type` or `typeof` keyword.",
        ImportTypeShorthandOnlyInPureImport:
          "The `type` and `typeof` keywords on named imports can only be used on regular `import` statements. It cannot be used with `import type` or `import typeof` statements.",
        InexactInsideExact:
          "Explicit inexact syntax cannot appear inside an explicit exact object type.",
        InexactInsideNonObject:
          "Explicit inexact syntax cannot appear in class or interface definitions.",
        InexactVariance: "Explicit inexact syntax cannot have variance.",
        InvalidNonTypeImportInDeclareModule:
          "Imports within a `declare module` body must always be `import type` or `import typeof`.",
        MissingTypeParamDefault:
          "Type parameter declaration needs a default, since a preceding type parameter declaration has a default.",
        NestedDeclareModule:
          "`declare module` cannot be used inside another `declare module`.",
        NestedFlowComment:
          "Cannot have a flow comment inside another flow comment.",
        PatternIsOptional: Object.assign(
          {
            message:
              "A binding pattern parameter cannot be optional in an implementation signature.",
          },
          { reasonCode: "OptionalBindingPattern" },
        ),
        SetterMayNotHaveThisParam: "A setter cannot have a `this` parameter.",
        SpreadVariance: "Spread properties cannot have variance.",
        ThisParamAnnotationRequired:
          "A type annotation is required for the `this` parameter.",
        ThisParamBannedInConstructor:
          "Constructors cannot have a `this` parameter; constructors don't bind `this` like other functions.",
        ThisParamMayNotBeOptional: "The `this` parameter cannot be optional.",
        ThisParamMustBeFirst:
          "The `this` parameter must be the first function parameter.",
        ThisParamNoDefault:
          "The `this` parameter may not have a default value.",
        TypeBeforeInitializer:
          "Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.",
        TypeCastInPattern:
          "The type cast expression is expected to be wrapped with parenthesis.",
        UnexpectedExplicitInexactInObject:
          "Explicit inexact syntax must appear at the end of an inexact object.",
        UnexpectedReservedType: ({ reservedType: a }) =>
          `Unexpected reserved type ${a}.`,
        UnexpectedReservedUnderscore:
          "`_` is only allowed as a type argument to call or new.",
        UnexpectedSpaceBetweenModuloChecks:
          "Spaces between `%` and `checks` are not allowed here.",
        UnexpectedSpreadType:
          "Spread operator cannot appear in class or interface definitions.",
        UnexpectedSubtractionOperand:
          'Unexpected token, expected "number" or "bigint".',
        UnexpectedTokenAfterTypeParameter:
          "Expected an arrow function after this type parameter declaration.",
        UnexpectedTypeParameterBeforeAsyncArrowFunction:
          "Type parameters must come after the async keyword, e.g. instead of `<T> async () => {}`, use `async <T>() => {}`.",
        UnsupportedDeclareExportKind: ({
          unsupportedExportKind: a,
          suggestion: t,
        }) => `\`declare export ${a}\` is not supported. Use \`${t}\` instead.`,
        UnsupportedStatementInDeclareModule:
          "Only declares and type imports are allowed inside declare module.",
        UnterminatedFlowComment: "Unterminated flow-comment.",
      });
    function _i(a) {
      return (
        a.type === "DeclareExportAllDeclaration" ||
        (a.type === "DeclareExportDeclaration" &&
          (!a.declaration ||
            (a.declaration.type !== "TypeAlias" &&
              a.declaration.type !== "InterfaceDeclaration")))
      );
    }
    function _t(a) {
      return a.importKind === "type" || a.importKind === "typeof";
    }
    var ji = {
      const: "declare export var",
      let: "declare export var",
      type: "export type",
      interface: "export interface",
    };
    function $i(a, t) {
      let e = [],
        s = [];
      for (let i = 0; i < a.length; i++) (t(a[i], i, a) ? e : s).push(a[i]);
      return [e, s];
    }
    var Vi = /\*?\s*@((?:no)?flow)\b/,
      qi = (a) =>
        class extends a {
          constructor(...e) {
            super(...e), (this.flowPragma = void 0);
          }
          getScopeHandler() {
            return Xe;
          }
          shouldParseTypes() {
            return (
              this.getPluginOption("flow", "all") || this.flowPragma === "flow"
            );
          }
          shouldParseEnums() {
            return !!this.getPluginOption("flow", "enums");
          }
          finishToken(e, s) {
            e !== 133 &&
              e !== 13 &&
              e !== 28 &&
              this.flowPragma === void 0 &&
              (this.flowPragma = null),
              super.finishToken(e, s);
          }
          addComment(e) {
            if (this.flowPragma === void 0) {
              let s = Vi.exec(e.value);
              if (s)
                if (s[1] === "flow") this.flowPragma = "flow";
                else if (s[1] === "noflow") this.flowPragma = "noflow";
                else throw new Error("Unexpected flow pragma");
            }
            super.addComment(e);
          }
          flowParseTypeInitialiser(e) {
            let s = this.state.inType;
            (this.state.inType = !0), this.expect(e || 14);
            let i = this.flowParseType();
            return (this.state.inType = s), i;
          }
          flowParsePredicate() {
            let e = this.startNode(),
              s = this.state.startLoc;
            return (
              this.next(),
              this.expectContextual(110),
              this.state.lastTokStartLoc.index > s.index + 1 &&
                this.raise(g.UnexpectedSpaceBetweenModuloChecks, s),
              this.eat(10)
                ? ((e.value = super.parseExpression()),
                  this.expect(11),
                  this.finishNode(e, "DeclaredPredicate"))
                : this.finishNode(e, "InferredPredicate")
            );
          }
          flowParseTypeAndPredicateInitialiser() {
            let e = this.state.inType;
            (this.state.inType = !0), this.expect(14);
            let s = null,
              i = null;
            return (
              this.match(54)
                ? ((this.state.inType = e), (i = this.flowParsePredicate()))
                : ((s = this.flowParseType()),
                  (this.state.inType = e),
                  this.match(54) && (i = this.flowParsePredicate())),
              [s, i]
            );
          }
          flowParseDeclareClass(e) {
            return (
              this.next(),
              this.flowParseInterfaceish(e, !0),
              this.finishNode(e, "DeclareClass")
            );
          }
          flowParseDeclareFunction(e) {
            this.next();
            let s = (e.id = this.parseIdentifier()),
              i = this.startNode(),
              r = this.startNode();
            this.match(47)
              ? (i.typeParameters = this.flowParseTypeParameterDeclaration())
              : (i.typeParameters = null),
              this.expect(10);
            let n = this.flowParseFunctionTypeParams();
            return (
              (i.params = n.params),
              (i.rest = n.rest),
              (i.this = n._this),
              this.expect(11),
              ([i.returnType, e.predicate] =
                this.flowParseTypeAndPredicateInitialiser()),
              (r.typeAnnotation = this.finishNode(i, "FunctionTypeAnnotation")),
              (s.typeAnnotation = this.finishNode(r, "TypeAnnotation")),
              this.resetEndLocation(s),
              this.semicolon(),
              this.scope.declareName(e.id.name, 2048, e.id.loc.start),
              this.finishNode(e, "DeclareFunction")
            );
          }
          flowParseDeclare(e, s) {
            if (this.match(80)) return this.flowParseDeclareClass(e);
            if (this.match(68)) return this.flowParseDeclareFunction(e);
            if (this.match(74)) return this.flowParseDeclareVariable(e);
            if (this.eatContextual(127))
              return this.match(16)
                ? this.flowParseDeclareModuleExports(e)
                : (s &&
                    this.raise(
                      g.NestedDeclareModule,
                      this.state.lastTokStartLoc,
                    ),
                  this.flowParseDeclareModule(e));
            if (this.isContextual(130))
              return this.flowParseDeclareTypeAlias(e);
            if (this.isContextual(131))
              return this.flowParseDeclareOpaqueType(e);
            if (this.isContextual(129))
              return this.flowParseDeclareInterface(e);
            if (this.match(82))
              return this.flowParseDeclareExportDeclaration(e, s);
            this.unexpected();
          }
          flowParseDeclareVariable(e) {
            return (
              this.next(),
              (e.id = this.flowParseTypeAnnotatableIdentifier(!0)),
              this.scope.declareName(e.id.name, 5, e.id.loc.start),
              this.semicolon(),
              this.finishNode(e, "DeclareVariable")
            );
          }
          flowParseDeclareModule(e) {
            this.scope.enter(0),
              this.match(133)
                ? (e.id = super.parseExprAtom())
                : (e.id = this.parseIdentifier());
            let s = (e.body = this.startNode()),
              i = (s.body = []);
            for (this.expect(5); !this.match(8); ) {
              let o = this.startNode();
              this.match(83)
                ? (this.next(),
                  !this.isContextual(130) &&
                    !this.match(87) &&
                    this.raise(
                      g.InvalidNonTypeImportInDeclareModule,
                      this.state.lastTokStartLoc,
                    ),
                  super.parseImport(o))
                : (this.expectContextual(
                    125,
                    g.UnsupportedStatementInDeclareModule,
                  ),
                  (o = this.flowParseDeclare(o, !0))),
                i.push(o);
            }
            this.scope.exit(),
              this.expect(8),
              this.finishNode(s, "BlockStatement");
            let r = null,
              n = !1;
            return (
              i.forEach((o) => {
                _i(o)
                  ? (r === "CommonJS" &&
                      this.raise(g.AmbiguousDeclareModuleKind, o),
                    (r = "ES"))
                  : o.type === "DeclareModuleExports" &&
                    (n && this.raise(g.DuplicateDeclareModuleExports, o),
                    r === "ES" && this.raise(g.AmbiguousDeclareModuleKind, o),
                    (r = "CommonJS"),
                    (n = !0));
              }),
              (e.kind = r || "CommonJS"),
              this.finishNode(e, "DeclareModule")
            );
          }
          flowParseDeclareExportDeclaration(e, s) {
            if ((this.expect(82), this.eat(65)))
              return (
                this.match(68) || this.match(80)
                  ? (e.declaration = this.flowParseDeclare(this.startNode()))
                  : ((e.declaration = this.flowParseType()), this.semicolon()),
                (e.default = !0),
                this.finishNode(e, "DeclareExportDeclaration")
              );
            if (
              this.match(75) ||
              this.isLet() ||
              ((this.isContextual(130) || this.isContextual(129)) && !s)
            ) {
              let i = this.state.value;
              throw this.raise(
                g.UnsupportedDeclareExportKind,
                this.state.startLoc,
                { unsupportedExportKind: i, suggestion: ji[i] },
              );
            }
            if (
              this.match(74) ||
              this.match(68) ||
              this.match(80) ||
              this.isContextual(131)
            )
              return (
                (e.declaration = this.flowParseDeclare(this.startNode())),
                (e.default = !1),
                this.finishNode(e, "DeclareExportDeclaration")
              );
            if (
              this.match(55) ||
              this.match(5) ||
              this.isContextual(129) ||
              this.isContextual(130) ||
              this.isContextual(131)
            )
              return (
                (e = this.parseExport(e, null)),
                e.type === "ExportNamedDeclaration" &&
                  ((e.type = "ExportDeclaration"),
                  (e.default = !1),
                  delete e.exportKind),
                (e.type = "Declare" + e.type),
                e
              );
            this.unexpected();
          }
          flowParseDeclareModuleExports(e) {
            return (
              this.next(),
              this.expectContextual(111),
              (e.typeAnnotation = this.flowParseTypeAnnotation()),
              this.semicolon(),
              this.finishNode(e, "DeclareModuleExports")
            );
          }
          flowParseDeclareTypeAlias(e) {
            this.next();
            let s = this.flowParseTypeAlias(e);
            return (s.type = "DeclareTypeAlias"), s;
          }
          flowParseDeclareOpaqueType(e) {
            this.next();
            let s = this.flowParseOpaqueType(e, !0);
            return (s.type = "DeclareOpaqueType"), s;
          }
          flowParseDeclareInterface(e) {
            return (
              this.next(),
              this.flowParseInterfaceish(e, !1),
              this.finishNode(e, "DeclareInterface")
            );
          }
          flowParseInterfaceish(e, s) {
            if (
              ((e.id = this.flowParseRestrictedIdentifier(!s, !0)),
              this.scope.declareName(e.id.name, s ? 17 : 8201, e.id.loc.start),
              this.match(47)
                ? (e.typeParameters = this.flowParseTypeParameterDeclaration())
                : (e.typeParameters = null),
              (e.extends = []),
              this.eat(81))
            )
              do e.extends.push(this.flowParseInterfaceExtends());
              while (!s && this.eat(12));
            if (s) {
              if (
                ((e.implements = []), (e.mixins = []), this.eatContextual(117))
              )
                do e.mixins.push(this.flowParseInterfaceExtends());
                while (this.eat(12));
              if (this.eatContextual(113))
                do e.implements.push(this.flowParseInterfaceExtends());
                while (this.eat(12));
            }
            e.body = this.flowParseObjectType({
              allowStatic: s,
              allowExact: !1,
              allowSpread: !1,
              allowProto: s,
              allowInexact: !1,
            });
          }
          flowParseInterfaceExtends() {
            let e = this.startNode();
            return (
              (e.id = this.flowParseQualifiedTypeIdentifier()),
              this.match(47)
                ? (e.typeParameters =
                    this.flowParseTypeParameterInstantiation())
                : (e.typeParameters = null),
              this.finishNode(e, "InterfaceExtends")
            );
          }
          flowParseInterface(e) {
            return (
              this.flowParseInterfaceish(e, !1),
              this.finishNode(e, "InterfaceDeclaration")
            );
          }
          checkNotUnderscore(e) {
            e === "_" &&
              this.raise(g.UnexpectedReservedUnderscore, this.state.startLoc);
          }
          checkReservedType(e, s, i) {
            Ui.has(e) &&
              this.raise(
                i ? g.AssignReservedType : g.UnexpectedReservedType,
                s,
                { reservedType: e },
              );
          }
          flowParseRestrictedIdentifier(e, s) {
            return (
              this.checkReservedType(this.state.value, this.state.startLoc, s),
              this.parseIdentifier(e)
            );
          }
          flowParseTypeAlias(e) {
            return (
              (e.id = this.flowParseRestrictedIdentifier(!1, !0)),
              this.scope.declareName(e.id.name, 8201, e.id.loc.start),
              this.match(47)
                ? (e.typeParameters = this.flowParseTypeParameterDeclaration())
                : (e.typeParameters = null),
              (e.right = this.flowParseTypeInitialiser(29)),
              this.semicolon(),
              this.finishNode(e, "TypeAlias")
            );
          }
          flowParseOpaqueType(e, s) {
            return (
              this.expectContextual(130),
              (e.id = this.flowParseRestrictedIdentifier(!0, !0)),
              this.scope.declareName(e.id.name, 8201, e.id.loc.start),
              this.match(47)
                ? (e.typeParameters = this.flowParseTypeParameterDeclaration())
                : (e.typeParameters = null),
              (e.supertype = null),
              this.match(14) &&
                (e.supertype = this.flowParseTypeInitialiser(14)),
              (e.impltype = null),
              s || (e.impltype = this.flowParseTypeInitialiser(29)),
              this.semicolon(),
              this.finishNode(e, "OpaqueType")
            );
          }
          flowParseTypeParameter(e = !1) {
            let s = this.state.startLoc,
              i = this.startNode(),
              r = this.flowParseVariance(),
              n = this.flowParseTypeAnnotatableIdentifier();
            return (
              (i.name = n.name),
              (i.variance = r),
              (i.bound = n.typeAnnotation),
              this.match(29)
                ? (this.eat(29), (i.default = this.flowParseType()))
                : e && this.raise(g.MissingTypeParamDefault, s),
              this.finishNode(i, "TypeParameter")
            );
          }
          flowParseTypeParameterDeclaration() {
            let e = this.state.inType,
              s = this.startNode();
            (s.params = []),
              (this.state.inType = !0),
              this.match(47) || this.match(142)
                ? this.next()
                : this.unexpected();
            let i = !1;
            do {
              let r = this.flowParseTypeParameter(i);
              s.params.push(r),
                r.default && (i = !0),
                this.match(48) || this.expect(12);
            } while (!this.match(48));
            return (
              this.expect(48),
              (this.state.inType = e),
              this.finishNode(s, "TypeParameterDeclaration")
            );
          }
          flowParseTypeParameterInstantiation() {
            let e = this.startNode(),
              s = this.state.inType;
            (e.params = []), (this.state.inType = !0), this.expect(47);
            let i = this.state.noAnonFunctionType;
            for (this.state.noAnonFunctionType = !1; !this.match(48); )
              e.params.push(this.flowParseType()),
                this.match(48) || this.expect(12);
            return (
              (this.state.noAnonFunctionType = i),
              this.expect(48),
              (this.state.inType = s),
              this.finishNode(e, "TypeParameterInstantiation")
            );
          }
          flowParseTypeParameterInstantiationCallOrNew() {
            let e = this.startNode(),
              s = this.state.inType;
            for (
              e.params = [], this.state.inType = !0, this.expect(47);
              !this.match(48);

            )
              e.params.push(this.flowParseTypeOrImplicitInstantiation()),
                this.match(48) || this.expect(12);
            return (
              this.expect(48),
              (this.state.inType = s),
              this.finishNode(e, "TypeParameterInstantiation")
            );
          }
          flowParseInterfaceType() {
            let e = this.startNode();
            if ((this.expectContextual(129), (e.extends = []), this.eat(81)))
              do e.extends.push(this.flowParseInterfaceExtends());
              while (this.eat(12));
            return (
              (e.body = this.flowParseObjectType({
                allowStatic: !1,
                allowExact: !1,
                allowSpread: !1,
                allowProto: !1,
                allowInexact: !1,
              })),
              this.finishNode(e, "InterfaceTypeAnnotation")
            );
          }
          flowParseObjectPropertyKey() {
            return this.match(134) || this.match(133)
              ? super.parseExprAtom()
              : this.parseIdentifier(!0);
          }
          flowParseObjectTypeIndexer(e, s, i) {
            return (
              (e.static = s),
              this.lookahead().type === 14
                ? ((e.id = this.flowParseObjectPropertyKey()),
                  (e.key = this.flowParseTypeInitialiser()))
                : ((e.id = null), (e.key = this.flowParseType())),
              this.expect(3),
              (e.value = this.flowParseTypeInitialiser()),
              (e.variance = i),
              this.finishNode(e, "ObjectTypeIndexer")
            );
          }
          flowParseObjectTypeInternalSlot(e, s) {
            return (
              (e.static = s),
              (e.id = this.flowParseObjectPropertyKey()),
              this.expect(3),
              this.expect(3),
              this.match(47) || this.match(10)
                ? ((e.method = !0),
                  (e.optional = !1),
                  (e.value = this.flowParseObjectTypeMethodish(
                    this.startNodeAt(e.loc.start),
                  )))
                : ((e.method = !1),
                  this.eat(17) && (e.optional = !0),
                  (e.value = this.flowParseTypeInitialiser())),
              this.finishNode(e, "ObjectTypeInternalSlot")
            );
          }
          flowParseObjectTypeMethodish(e) {
            for (
              e.params = [],
                e.rest = null,
                e.typeParameters = null,
                e.this = null,
                this.match(47) &&
                  (e.typeParameters = this.flowParseTypeParameterDeclaration()),
                this.expect(10),
                this.match(78) &&
                  ((e.this = this.flowParseFunctionTypeParam(!0)),
                  (e.this.name = null),
                  this.match(11) || this.expect(12));
              !this.match(11) && !this.match(21);

            )
              e.params.push(this.flowParseFunctionTypeParam(!1)),
                this.match(11) || this.expect(12);
            return (
              this.eat(21) && (e.rest = this.flowParseFunctionTypeParam(!1)),
              this.expect(11),
              (e.returnType = this.flowParseTypeInitialiser()),
              this.finishNode(e, "FunctionTypeAnnotation")
            );
          }
          flowParseObjectTypeCallProperty(e, s) {
            let i = this.startNode();
            return (
              (e.static = s),
              (e.value = this.flowParseObjectTypeMethodish(i)),
              this.finishNode(e, "ObjectTypeCallProperty")
            );
          }
          flowParseObjectType({
            allowStatic: e,
            allowExact: s,
            allowSpread: i,
            allowProto: r,
            allowInexact: n,
          }) {
            let o = this.state.inType;
            this.state.inType = !0;
            let h = this.startNode();
            (h.callProperties = []),
              (h.properties = []),
              (h.indexers = []),
              (h.internalSlots = []);
            let c,
              l,
              u = !1;
            for (
              s && this.match(6)
                ? (this.expect(6), (c = 9), (l = !0))
                : (this.expect(5), (c = 8), (l = !1)),
                h.exact = l;
              !this.match(c);

            ) {
              let d = !1,
                y = null,
                E = null,
                L = this.startNode();
              if (r && this.isContextual(118)) {
                let I = this.lookahead();
                I.type !== 14 &&
                  I.type !== 17 &&
                  (this.next(), (y = this.state.startLoc), (e = !1));
              }
              if (e && this.isContextual(106)) {
                let I = this.lookahead();
                I.type !== 14 && I.type !== 17 && (this.next(), (d = !0));
              }
              let S = this.flowParseVariance();
              if (this.eat(0))
                y != null && this.unexpected(y),
                  this.eat(0)
                    ? (S && this.unexpected(S.loc.start),
                      h.internalSlots.push(
                        this.flowParseObjectTypeInternalSlot(L, d),
                      ))
                    : h.indexers.push(this.flowParseObjectTypeIndexer(L, d, S));
              else if (this.match(10) || this.match(47))
                y != null && this.unexpected(y),
                  S && this.unexpected(S.loc.start),
                  h.callProperties.push(
                    this.flowParseObjectTypeCallProperty(L, d),
                  );
              else {
                let I = "init";
                if (this.isContextual(99) || this.isContextual(104)) {
                  let ne = this.lookahead();
                  Wt(ne.type) && ((I = this.state.value), this.next());
                }
                let Ae = this.flowParseObjectTypeProperty(
                  L,
                  d,
                  y,
                  S,
                  I,
                  i,
                  n ?? !l,
                );
                Ae === null
                  ? ((u = !0), (E = this.state.lastTokStartLoc))
                  : h.properties.push(Ae);
              }
              this.flowObjectTypeSemicolon(),
                E &&
                  !this.match(8) &&
                  !this.match(9) &&
                  this.raise(g.UnexpectedExplicitInexactInObject, E);
            }
            this.expect(c), i && (h.inexact = u);
            let f = this.finishNode(h, "ObjectTypeAnnotation");
            return (this.state.inType = o), f;
          }
          flowParseObjectTypeProperty(e, s, i, r, n, o, h) {
            if (this.eat(21))
              return this.match(12) ||
                this.match(13) ||
                this.match(8) ||
                this.match(9)
                ? (o
                    ? h ||
                      this.raise(
                        g.InexactInsideExact,
                        this.state.lastTokStartLoc,
                      )
                    : this.raise(
                        g.InexactInsideNonObject,
                        this.state.lastTokStartLoc,
                      ),
                  r && this.raise(g.InexactVariance, r),
                  null)
                : (o ||
                    this.raise(
                      g.UnexpectedSpreadType,
                      this.state.lastTokStartLoc,
                    ),
                  i != null && this.unexpected(i),
                  r && this.raise(g.SpreadVariance, r),
                  (e.argument = this.flowParseType()),
                  this.finishNode(e, "ObjectTypeSpreadProperty"));
            {
              (e.key = this.flowParseObjectPropertyKey()),
                (e.static = s),
                (e.proto = i != null),
                (e.kind = n);
              let c = !1;
              return (
                this.match(47) || this.match(10)
                  ? ((e.method = !0),
                    i != null && this.unexpected(i),
                    r && this.unexpected(r.loc.start),
                    (e.value = this.flowParseObjectTypeMethodish(
                      this.startNodeAt(e.loc.start),
                    )),
                    (n === "get" || n === "set") &&
                      this.flowCheckGetterSetterParams(e),
                    !o &&
                      e.key.name === "constructor" &&
                      e.value.this &&
                      this.raise(g.ThisParamBannedInConstructor, e.value.this))
                  : (n !== "init" && this.unexpected(),
                    (e.method = !1),
                    this.eat(17) && (c = !0),
                    (e.value = this.flowParseTypeInitialiser()),
                    (e.variance = r)),
                (e.optional = c),
                this.finishNode(e, "ObjectTypeProperty")
              );
            }
          }
          flowCheckGetterSetterParams(e) {
            let s = e.kind === "get" ? 0 : 1,
              i = e.value.params.length + (e.value.rest ? 1 : 0);
            e.value.this &&
              this.raise(
                e.kind === "get"
                  ? g.GetterMayNotHaveThisParam
                  : g.SetterMayNotHaveThisParam,
                e.value.this,
              ),
              i !== s &&
                this.raise(
                  e.kind === "get" ? p.BadGetterArity : p.BadSetterArity,
                  e,
                ),
              e.kind === "set" &&
                e.value.rest &&
                this.raise(p.BadSetterRestParameter, e);
          }
          flowObjectTypeSemicolon() {
            !this.eat(13) &&
              !this.eat(12) &&
              !this.match(8) &&
              !this.match(9) &&
              this.unexpected();
          }
          flowParseQualifiedTypeIdentifier(e, s) {
            var i;
            (i = e) != null || (e = this.state.startLoc);
            let r = s || this.flowParseRestrictedIdentifier(!0);
            for (; this.eat(16); ) {
              let n = this.startNodeAt(e);
              (n.qualification = r),
                (n.id = this.flowParseRestrictedIdentifier(!0)),
                (r = this.finishNode(n, "QualifiedTypeIdentifier"));
            }
            return r;
          }
          flowParseGenericType(e, s) {
            let i = this.startNodeAt(e);
            return (
              (i.typeParameters = null),
              (i.id = this.flowParseQualifiedTypeIdentifier(e, s)),
              this.match(47) &&
                (i.typeParameters = this.flowParseTypeParameterInstantiation()),
              this.finishNode(i, "GenericTypeAnnotation")
            );
          }
          flowParseTypeofType() {
            let e = this.startNode();
            return (
              this.expect(87),
              (e.argument = this.flowParsePrimaryType()),
              this.finishNode(e, "TypeofTypeAnnotation")
            );
          }
          flowParseTupleType() {
            let e = this.startNode();
            for (
              e.types = [], this.expect(0);
              this.state.pos < this.length &&
              !this.match(3) &&
              (e.types.push(this.flowParseType()), !this.match(3));

            )
              this.expect(12);
            return this.expect(3), this.finishNode(e, "TupleTypeAnnotation");
          }
          flowParseFunctionTypeParam(e) {
            let s = null,
              i = !1,
              r = null,
              n = this.startNode(),
              o = this.lookahead(),
              h = this.state.type === 78;
            return (
              o.type === 14 || o.type === 17
                ? (h && !e && this.raise(g.ThisParamMustBeFirst, n),
                  (s = this.parseIdentifier(h)),
                  this.eat(17) &&
                    ((i = !0), h && this.raise(g.ThisParamMayNotBeOptional, n)),
                  (r = this.flowParseTypeInitialiser()))
                : (r = this.flowParseType()),
              (n.name = s),
              (n.optional = i),
              (n.typeAnnotation = r),
              this.finishNode(n, "FunctionTypeParam")
            );
          }
          reinterpretTypeAsFunctionTypeParam(e) {
            let s = this.startNodeAt(e.loc.start);
            return (
              (s.name = null),
              (s.optional = !1),
              (s.typeAnnotation = e),
              this.finishNode(s, "FunctionTypeParam")
            );
          }
          flowParseFunctionTypeParams(e = []) {
            let s = null,
              i = null;
            for (
              this.match(78) &&
              ((i = this.flowParseFunctionTypeParam(!0)),
              (i.name = null),
              this.match(11) || this.expect(12));
              !this.match(11) && !this.match(21);

            )
              e.push(this.flowParseFunctionTypeParam(!1)),
                this.match(11) || this.expect(12);
            return (
              this.eat(21) && (s = this.flowParseFunctionTypeParam(!1)),
              { params: e, rest: s, _this: i }
            );
          }
          flowIdentToTypeAnnotation(e, s, i) {
            switch (i.name) {
              case "any":
                return this.finishNode(s, "AnyTypeAnnotation");
              case "bool":
              case "boolean":
                return this.finishNode(s, "BooleanTypeAnnotation");
              case "mixed":
                return this.finishNode(s, "MixedTypeAnnotation");
              case "empty":
                return this.finishNode(s, "EmptyTypeAnnotation");
              case "number":
                return this.finishNode(s, "NumberTypeAnnotation");
              case "string":
                return this.finishNode(s, "StringTypeAnnotation");
              case "symbol":
                return this.finishNode(s, "SymbolTypeAnnotation");
              default:
                return (
                  this.checkNotUnderscore(i.name),
                  this.flowParseGenericType(e, i)
                );
            }
          }
          flowParsePrimaryType() {
            let e = this.state.startLoc,
              s = this.startNode(),
              i,
              r,
              n = !1,
              o = this.state.noAnonFunctionType;
            switch (this.state.type) {
              case 5:
                return this.flowParseObjectType({
                  allowStatic: !1,
                  allowExact: !1,
                  allowSpread: !0,
                  allowProto: !1,
                  allowInexact: !0,
                });
              case 6:
                return this.flowParseObjectType({
                  allowStatic: !1,
                  allowExact: !0,
                  allowSpread: !0,
                  allowProto: !1,
                  allowInexact: !1,
                });
              case 0:
                return (
                  (this.state.noAnonFunctionType = !1),
                  (r = this.flowParseTupleType()),
                  (this.state.noAnonFunctionType = o),
                  r
                );
              case 47: {
                let h = this.startNode();
                return (
                  (h.typeParameters = this.flowParseTypeParameterDeclaration()),
                  this.expect(10),
                  (i = this.flowParseFunctionTypeParams()),
                  (h.params = i.params),
                  (h.rest = i.rest),
                  (h.this = i._this),
                  this.expect(11),
                  this.expect(19),
                  (h.returnType = this.flowParseType()),
                  this.finishNode(h, "FunctionTypeAnnotation")
                );
              }
              case 10: {
                let h = this.startNode();
                if ((this.next(), !this.match(11) && !this.match(21)))
                  if (w(this.state.type) || this.match(78)) {
                    let c = this.lookahead().type;
                    n = c !== 17 && c !== 14;
                  } else n = !0;
                if (n) {
                  if (
                    ((this.state.noAnonFunctionType = !1),
                    (r = this.flowParseType()),
                    (this.state.noAnonFunctionType = o),
                    this.state.noAnonFunctionType ||
                      !(
                        this.match(12) ||
                        (this.match(11) && this.lookahead().type === 19)
                      ))
                  )
                    return this.expect(11), r;
                  this.eat(12);
                }
                return (
                  r
                    ? (i = this.flowParseFunctionTypeParams([
                        this.reinterpretTypeAsFunctionTypeParam(r),
                      ]))
                    : (i = this.flowParseFunctionTypeParams()),
                  (h.params = i.params),
                  (h.rest = i.rest),
                  (h.this = i._this),
                  this.expect(11),
                  this.expect(19),
                  (h.returnType = this.flowParseType()),
                  (h.typeParameters = null),
                  this.finishNode(h, "FunctionTypeAnnotation")
                );
              }
              case 133:
                return this.parseLiteral(
                  this.state.value,
                  "StringLiteralTypeAnnotation",
                );
              case 85:
              case 86:
                return (
                  (s.value = this.match(85)),
                  this.next(),
                  this.finishNode(s, "BooleanLiteralTypeAnnotation")
                );
              case 53:
                if (this.state.value === "-") {
                  if ((this.next(), this.match(134)))
                    return this.parseLiteralAtNode(
                      -this.state.value,
                      "NumberLiteralTypeAnnotation",
                      s,
                    );
                  if (this.match(135))
                    return this.parseLiteralAtNode(
                      -this.state.value,
                      "BigIntLiteralTypeAnnotation",
                      s,
                    );
                  throw this.raise(
                    g.UnexpectedSubtractionOperand,
                    this.state.startLoc,
                  );
                }
                this.unexpected();
                return;
              case 134:
                return this.parseLiteral(
                  this.state.value,
                  "NumberLiteralTypeAnnotation",
                );
              case 135:
                return this.parseLiteral(
                  this.state.value,
                  "BigIntLiteralTypeAnnotation",
                );
              case 88:
                return this.next(), this.finishNode(s, "VoidTypeAnnotation");
              case 84:
                return (
                  this.next(), this.finishNode(s, "NullLiteralTypeAnnotation")
                );
              case 78:
                return this.next(), this.finishNode(s, "ThisTypeAnnotation");
              case 55:
                return this.next(), this.finishNode(s, "ExistsTypeAnnotation");
              case 87:
                return this.flowParseTypeofType();
              default:
                if (Pt(this.state.type)) {
                  let h = K(this.state.type);
                  return this.next(), super.createIdentifier(s, h);
                } else if (w(this.state.type))
                  return this.isContextual(129)
                    ? this.flowParseInterfaceType()
                    : this.flowIdentToTypeAnnotation(
                        e,
                        s,
                        this.parseIdentifier(),
                      );
            }
            this.unexpected();
          }
          flowParsePostfixType() {
            let e = this.state.startLoc,
              s = this.flowParsePrimaryType(),
              i = !1;
            for (
              ;
              (this.match(0) || this.match(18)) && !this.canInsertSemicolon();

            ) {
              let r = this.startNodeAt(e),
                n = this.eat(18);
              (i = i || n),
                this.expect(0),
                !n && this.match(3)
                  ? ((r.elementType = s),
                    this.next(),
                    (s = this.finishNode(r, "ArrayTypeAnnotation")))
                  : ((r.objectType = s),
                    (r.indexType = this.flowParseType()),
                    this.expect(3),
                    i
                      ? ((r.optional = n),
                        (s = this.finishNode(r, "OptionalIndexedAccessType")))
                      : (s = this.finishNode(r, "IndexedAccessType")));
            }
            return s;
          }
          flowParsePrefixType() {
            let e = this.startNode();
            return this.eat(17)
              ? ((e.typeAnnotation = this.flowParsePrefixType()),
                this.finishNode(e, "NullableTypeAnnotation"))
              : this.flowParsePostfixType();
          }
          flowParseAnonFunctionWithoutParens() {
            let e = this.flowParsePrefixType();
            if (!this.state.noAnonFunctionType && this.eat(19)) {
              let s = this.startNodeAt(e.loc.start);
              return (
                (s.params = [this.reinterpretTypeAsFunctionTypeParam(e)]),
                (s.rest = null),
                (s.this = null),
                (s.returnType = this.flowParseType()),
                (s.typeParameters = null),
                this.finishNode(s, "FunctionTypeAnnotation")
              );
            }
            return e;
          }
          flowParseIntersectionType() {
            let e = this.startNode();
            this.eat(45);
            let s = this.flowParseAnonFunctionWithoutParens();
            for (e.types = [s]; this.eat(45); )
              e.types.push(this.flowParseAnonFunctionWithoutParens());
            return e.types.length === 1
              ? s
              : this.finishNode(e, "IntersectionTypeAnnotation");
          }
          flowParseUnionType() {
            let e = this.startNode();
            this.eat(43);
            let s = this.flowParseIntersectionType();
            for (e.types = [s]; this.eat(43); )
              e.types.push(this.flowParseIntersectionType());
            return e.types.length === 1
              ? s
              : this.finishNode(e, "UnionTypeAnnotation");
          }
          flowParseType() {
            let e = this.state.inType;
            this.state.inType = !0;
            let s = this.flowParseUnionType();
            return (this.state.inType = e), s;
          }
          flowParseTypeOrImplicitInstantiation() {
            if (this.state.type === 132 && this.state.value === "_") {
              let e = this.state.startLoc,
                s = this.parseIdentifier();
              return this.flowParseGenericType(e, s);
            } else return this.flowParseType();
          }
          flowParseTypeAnnotation() {
            let e = this.startNode();
            return (
              (e.typeAnnotation = this.flowParseTypeInitialiser()),
              this.finishNode(e, "TypeAnnotation")
            );
          }
          flowParseTypeAnnotatableIdentifier(e) {
            let s = e
              ? this.parseIdentifier()
              : this.flowParseRestrictedIdentifier();
            return (
              this.match(14) &&
                ((s.typeAnnotation = this.flowParseTypeAnnotation()),
                this.resetEndLocation(s)),
              s
            );
          }
          typeCastToParameter(e) {
            return (
              (e.expression.typeAnnotation = e.typeAnnotation),
              this.resetEndLocation(e.expression, e.typeAnnotation.loc.end),
              e.expression
            );
          }
          flowParseVariance() {
            let e = null;
            return this.match(53)
              ? ((e = this.startNode()),
                this.state.value === "+"
                  ? (e.kind = "plus")
                  : (e.kind = "minus"),
                this.next(),
                this.finishNode(e, "Variance"))
              : e;
          }
          parseFunctionBody(e, s, i = !1) {
            if (s) {
              this.forwardNoArrowParamsConversionAt(e, () =>
                super.parseFunctionBody(e, !0, i),
              );
              return;
            }
            super.parseFunctionBody(e, !1, i);
          }
          parseFunctionBodyAndFinish(e, s, i = !1) {
            if (this.match(14)) {
              let r = this.startNode();
              ([r.typeAnnotation, e.predicate] =
                this.flowParseTypeAndPredicateInitialiser()),
                (e.returnType = r.typeAnnotation
                  ? this.finishNode(r, "TypeAnnotation")
                  : null);
            }
            return super.parseFunctionBodyAndFinish(e, s, i);
          }
          parseStatementLike(e) {
            if (this.state.strict && this.isContextual(129)) {
              let i = this.lookahead();
              if (M(i.type)) {
                let r = this.startNode();
                return this.next(), this.flowParseInterface(r);
              }
            } else if (this.shouldParseEnums() && this.isContextual(126)) {
              let i = this.startNode();
              return this.next(), this.flowParseEnumDeclaration(i);
            }
            let s = super.parseStatementLike(e);
            return (
              this.flowPragma === void 0 &&
                !this.isValidDirective(s) &&
                (this.flowPragma = null),
              s
            );
          }
          parseExpressionStatement(e, s, i) {
            if (s.type === "Identifier") {
              if (s.name === "declare") {
                if (
                  this.match(80) ||
                  w(this.state.type) ||
                  this.match(68) ||
                  this.match(74) ||
                  this.match(82)
                )
                  return this.flowParseDeclare(e);
              } else if (w(this.state.type)) {
                if (s.name === "interface") return this.flowParseInterface(e);
                if (s.name === "type") return this.flowParseTypeAlias(e);
                if (s.name === "opaque") return this.flowParseOpaqueType(e, !1);
              }
            }
            return super.parseExpressionStatement(e, s, i);
          }
          shouldParseExportDeclaration() {
            let { type: e } = this.state;
            return Ft(e) || (this.shouldParseEnums() && e === 126)
              ? !this.state.containsEsc
              : super.shouldParseExportDeclaration();
          }
          isExportDefaultSpecifier() {
            let { type: e } = this.state;
            return Ft(e) || (this.shouldParseEnums() && e === 126)
              ? this.state.containsEsc
              : super.isExportDefaultSpecifier();
          }
          parseExportDefaultExpression() {
            if (this.shouldParseEnums() && this.isContextual(126)) {
              let e = this.startNode();
              return this.next(), this.flowParseEnumDeclaration(e);
            }
            return super.parseExportDefaultExpression();
          }
          parseConditional(e, s, i) {
            if (!this.match(17)) return e;
            if (this.state.maybeInArrowParameters) {
              let f = this.lookaheadCharCode();
              if (f === 44 || f === 61 || f === 58 || f === 41)
                return this.setOptionalParametersError(i), e;
            }
            this.expect(17);
            let r = this.state.clone(),
              n = this.state.noArrowAt,
              o = this.startNodeAt(s),
              { consequent: h, failed: c } =
                this.tryParseConditionalConsequent(),
              [l, u] = this.getArrowLikeExpressions(h);
            if (c || u.length > 0) {
              let f = [...n];
              if (u.length > 0) {
                (this.state = r), (this.state.noArrowAt = f);
                for (let d = 0; d < u.length; d++) f.push(u[d].start);
                ({ consequent: h, failed: c } =
                  this.tryParseConditionalConsequent()),
                  ([l, u] = this.getArrowLikeExpressions(h));
              }
              c &&
                l.length > 1 &&
                this.raise(g.AmbiguousConditionalArrow, r.startLoc),
                c &&
                  l.length === 1 &&
                  ((this.state = r),
                  f.push(l[0].start),
                  (this.state.noArrowAt = f),
                  ({ consequent: h, failed: c } =
                    this.tryParseConditionalConsequent()));
            }
            return (
              this.getArrowLikeExpressions(h, !0),
              (this.state.noArrowAt = n),
              this.expect(14),
              (o.test = e),
              (o.consequent = h),
              (o.alternate = this.forwardNoArrowParamsConversionAt(o, () =>
                this.parseMaybeAssign(void 0, void 0),
              )),
              this.finishNode(o, "ConditionalExpression")
            );
          }
          tryParseConditionalConsequent() {
            this.state.noArrowParamsConversionAt.push(this.state.start);
            let e = this.parseMaybeAssignAllowIn(),
              s = !this.match(14);
            return (
              this.state.noArrowParamsConversionAt.pop(),
              { consequent: e, failed: s }
            );
          }
          getArrowLikeExpressions(e, s) {
            let i = [e],
              r = [];
            for (; i.length !== 0; ) {
              let n = i.pop();
              n.type === "ArrowFunctionExpression" &&
              n.body.type !== "BlockStatement"
                ? (n.typeParameters || !n.returnType
                    ? this.finishArrowValidation(n)
                    : r.push(n),
                  i.push(n.body))
                : n.type === "ConditionalExpression" &&
                  (i.push(n.consequent), i.push(n.alternate));
            }
            return s
              ? (r.forEach((n) => this.finishArrowValidation(n)), [r, []])
              : $i(r, (n) => n.params.every((o) => this.isAssignable(o, !0)));
          }
          finishArrowValidation(e) {
            var s;
            this.toAssignableList(
              e.params,
              (s = e.extra) == null ? void 0 : s.trailingCommaLoc,
              !1,
            ),
              this.scope.enter(6),
              super.checkParams(e, !1, !0),
              this.scope.exit();
          }
          forwardNoArrowParamsConversionAt(e, s) {
            let i;
            return (
              this.state.noArrowParamsConversionAt.includes(e.start)
                ? (this.state.noArrowParamsConversionAt.push(this.state.start),
                  (i = s()),
                  this.state.noArrowParamsConversionAt.pop())
                : (i = s()),
              i
            );
          }
          parseParenItem(e, s) {
            let i = super.parseParenItem(e, s);
            if (
              (this.eat(17) && ((i.optional = !0), this.resetEndLocation(e)),
              this.match(14))
            ) {
              let r = this.startNodeAt(s);
              return (
                (r.expression = i),
                (r.typeAnnotation = this.flowParseTypeAnnotation()),
                this.finishNode(r, "TypeCastExpression")
              );
            }
            return i;
          }
          assertModuleNodeAllowed(e) {
            (e.type === "ImportDeclaration" &&
              (e.importKind === "type" || e.importKind === "typeof")) ||
              (e.type === "ExportNamedDeclaration" &&
                e.exportKind === "type") ||
              (e.type === "ExportAllDeclaration" && e.exportKind === "type") ||
              super.assertModuleNodeAllowed(e);
          }
          parseExportDeclaration(e) {
            if (this.isContextual(130)) {
              e.exportKind = "type";
              let s = this.startNode();
              return (
                this.next(),
                this.match(5)
                  ? ((e.specifiers = this.parseExportSpecifiers(!0)),
                    super.parseExportFrom(e),
                    null)
                  : this.flowParseTypeAlias(s)
              );
            } else if (this.isContextual(131)) {
              e.exportKind = "type";
              let s = this.startNode();
              return this.next(), this.flowParseOpaqueType(s, !1);
            } else if (this.isContextual(129)) {
              e.exportKind = "type";
              let s = this.startNode();
              return this.next(), this.flowParseInterface(s);
            } else if (this.shouldParseEnums() && this.isContextual(126)) {
              e.exportKind = "value";
              let s = this.startNode();
              return this.next(), this.flowParseEnumDeclaration(s);
            } else return super.parseExportDeclaration(e);
          }
          eatExportStar(e) {
            return super.eatExportStar(e)
              ? !0
              : this.isContextual(130) && this.lookahead().type === 55
                ? ((e.exportKind = "type"), this.next(), this.next(), !0)
                : !1;
          }
          maybeParseExportNamespaceSpecifier(e) {
            let { startLoc: s } = this.state,
              i = super.maybeParseExportNamespaceSpecifier(e);
            return i && e.exportKind === "type" && this.unexpected(s), i;
          }
          parseClassId(e, s, i) {
            super.parseClassId(e, s, i),
              this.match(47) &&
                (e.typeParameters = this.flowParseTypeParameterDeclaration());
          }
          parseClassMember(e, s, i) {
            let { startLoc: r } = this.state;
            if (this.isContextual(125)) {
              if (super.parseClassMemberFromModifier(e, s)) return;
              s.declare = !0;
            }
            super.parseClassMember(e, s, i),
              s.declare &&
                (s.type !== "ClassProperty" &&
                s.type !== "ClassPrivateProperty" &&
                s.type !== "PropertyDefinition"
                  ? this.raise(g.DeclareClassElement, r)
                  : s.value &&
                    this.raise(g.DeclareClassFieldInitializer, s.value));
          }
          isIterator(e) {
            return e === "iterator" || e === "asyncIterator";
          }
          readIterator() {
            let e = super.readWord1(),
              s = "@@" + e;
            (!this.isIterator(e) || !this.state.inType) &&
              this.raise(p.InvalidIdentifier, this.state.curPosition(), {
                identifierName: s,
              }),
              this.finishToken(132, s);
          }
          getTokenFromCode(e) {
            let s = this.input.charCodeAt(this.state.pos + 1);
            e === 123 && s === 124
              ? this.finishOp(6, 2)
              : this.state.inType && (e === 62 || e === 60)
                ? this.finishOp(e === 62 ? 48 : 47, 1)
                : this.state.inType && e === 63
                  ? s === 46
                    ? this.finishOp(18, 2)
                    : this.finishOp(17, 1)
                  : wi(e, s, this.input.charCodeAt(this.state.pos + 2))
                    ? ((this.state.pos += 2), this.readIterator())
                    : super.getTokenFromCode(e);
          }
          isAssignable(e, s) {
            return e.type === "TypeCastExpression"
              ? this.isAssignable(e.expression, s)
              : super.isAssignable(e, s);
          }
          toAssignable(e, s = !1) {
            !s &&
              e.type === "AssignmentExpression" &&
              e.left.type === "TypeCastExpression" &&
              (e.left = this.typeCastToParameter(e.left)),
              super.toAssignable(e, s);
          }
          toAssignableList(e, s, i) {
            for (let r = 0; r < e.length; r++) {
              let n = e[r];
              (n == null ? void 0 : n.type) === "TypeCastExpression" &&
                (e[r] = this.typeCastToParameter(n));
            }
            super.toAssignableList(e, s, i);
          }
          toReferencedList(e, s) {
            for (let r = 0; r < e.length; r++) {
              var i;
              let n = e[r];
              n &&
                n.type === "TypeCastExpression" &&
                !((i = n.extra) != null && i.parenthesized) &&
                (e.length > 1 || !s) &&
                this.raise(g.TypeCastInPattern, n.typeAnnotation);
            }
            return e;
          }
          parseArrayLike(e, s, i, r) {
            let n = super.parseArrayLike(e, s, i, r);
            return (
              s &&
                !this.state.maybeInArrowParameters &&
                this.toReferencedList(n.elements),
              n
            );
          }
          isValidLVal(e, s, i) {
            return e === "TypeCastExpression" || super.isValidLVal(e, s, i);
          }
          parseClassProperty(e) {
            return (
              this.match(14) &&
                (e.typeAnnotation = this.flowParseTypeAnnotation()),
              super.parseClassProperty(e)
            );
          }
          parseClassPrivateProperty(e) {
            return (
              this.match(14) &&
                (e.typeAnnotation = this.flowParseTypeAnnotation()),
              super.parseClassPrivateProperty(e)
            );
          }
          isClassMethod() {
            return this.match(47) || super.isClassMethod();
          }
          isClassProperty() {
            return this.match(14) || super.isClassProperty();
          }
          isNonstaticConstructor(e) {
            return !this.match(14) && super.isNonstaticConstructor(e);
          }
          pushClassMethod(e, s, i, r, n, o) {
            if (
              (s.variance && this.unexpected(s.variance.loc.start),
              delete s.variance,
              this.match(47) &&
                (s.typeParameters = this.flowParseTypeParameterDeclaration()),
              super.pushClassMethod(e, s, i, r, n, o),
              s.params && n)
            ) {
              let h = s.params;
              h.length > 0 &&
                this.isThisParam(h[0]) &&
                this.raise(g.ThisParamBannedInConstructor, s);
            } else if (s.type === "MethodDefinition" && n && s.value.params) {
              let h = s.value.params;
              h.length > 0 &&
                this.isThisParam(h[0]) &&
                this.raise(g.ThisParamBannedInConstructor, s);
            }
          }
          pushClassPrivateMethod(e, s, i, r) {
            s.variance && this.unexpected(s.variance.loc.start),
              delete s.variance,
              this.match(47) &&
                (s.typeParameters = this.flowParseTypeParameterDeclaration()),
              super.pushClassPrivateMethod(e, s, i, r);
          }
          parseClassSuper(e) {
            if (
              (super.parseClassSuper(e),
              e.superClass &&
                this.match(47) &&
                (e.superTypeParameters =
                  this.flowParseTypeParameterInstantiation()),
              this.isContextual(113))
            ) {
              this.next();
              let s = (e.implements = []);
              do {
                let i = this.startNode();
                (i.id = this.flowParseRestrictedIdentifier(!0)),
                  this.match(47)
                    ? (i.typeParameters =
                        this.flowParseTypeParameterInstantiation())
                    : (i.typeParameters = null),
                  s.push(this.finishNode(i, "ClassImplements"));
              } while (this.eat(12));
            }
          }
          checkGetterSetterParams(e) {
            super.checkGetterSetterParams(e);
            let s = this.getObjectOrClassMethodParams(e);
            if (s.length > 0) {
              let i = s[0];
              this.isThisParam(i) && e.kind === "get"
                ? this.raise(g.GetterMayNotHaveThisParam, i)
                : this.isThisParam(i) &&
                  this.raise(g.SetterMayNotHaveThisParam, i);
            }
          }
          parsePropertyNamePrefixOperator(e) {
            e.variance = this.flowParseVariance();
          }
          parseObjPropValue(e, s, i, r, n, o, h) {
            e.variance && this.unexpected(e.variance.loc.start),
              delete e.variance;
            let c;
            this.match(47) &&
              !o &&
              ((c = this.flowParseTypeParameterDeclaration()),
              this.match(10) || this.unexpected());
            let l = super.parseObjPropValue(e, s, i, r, n, o, h);
            return c && ((l.value || l).typeParameters = c), l;
          }
          parseAssignableListItemTypes(e) {
            return (
              this.eat(17) &&
                (e.type !== "Identifier" && this.raise(g.PatternIsOptional, e),
                this.isThisParam(e) &&
                  this.raise(g.ThisParamMayNotBeOptional, e),
                (e.optional = !0)),
              this.match(14)
                ? (e.typeAnnotation = this.flowParseTypeAnnotation())
                : this.isThisParam(e) &&
                  this.raise(g.ThisParamAnnotationRequired, e),
              this.match(29) &&
                this.isThisParam(e) &&
                this.raise(g.ThisParamNoDefault, e),
              this.resetEndLocation(e),
              e
            );
          }
          parseMaybeDefault(e, s) {
            let i = super.parseMaybeDefault(e, s);
            return (
              i.type === "AssignmentPattern" &&
                i.typeAnnotation &&
                i.right.start < i.typeAnnotation.start &&
                this.raise(g.TypeBeforeInitializer, i.typeAnnotation),
              i
            );
          }
          checkImportReflection(e) {
            super.checkImportReflection(e),
              e.module &&
                e.importKind !== "value" &&
                this.raise(
                  g.ImportReflectionHasImportType,
                  e.specifiers[0].loc.start,
                );
          }
          parseImportSpecifierLocal(e, s, i) {
            (s.local = _t(e)
              ? this.flowParseRestrictedIdentifier(!0, !0)
              : this.parseIdentifier()),
              e.specifiers.push(this.finishImportSpecifier(s, i));
          }
          isPotentialImportPhase(e) {
            if (super.isPotentialImportPhase(e)) return !0;
            if (this.isContextual(130)) {
              if (!e) return !0;
              let s = this.lookaheadCharCode();
              return s === 123 || s === 42;
            }
            return !e && this.isContextual(87);
          }
          applyImportPhase(e, s, i, r) {
            if ((super.applyImportPhase(e, s, i, r), s)) {
              if (!i && this.match(65)) return;
              e.exportKind = i === "type" ? i : "value";
            } else
              i === "type" && this.match(55) && this.unexpected(),
                (e.importKind = i === "type" || i === "typeof" ? i : "value");
          }
          parseImportSpecifier(e, s, i, r, n) {
            let o = e.imported,
              h = null;
            o.type === "Identifier" &&
              (o.name === "type"
                ? (h = "type")
                : o.name === "typeof" && (h = "typeof"));
            let c = !1;
            if (this.isContextual(93) && !this.isLookaheadContextual("as")) {
              let u = this.parseIdentifier(!0);
              h !== null && !M(this.state.type)
                ? ((e.imported = u), (e.importKind = h), (e.local = $(u)))
                : ((e.imported = o),
                  (e.importKind = null),
                  (e.local = this.parseIdentifier()));
            } else {
              if (h !== null && M(this.state.type))
                (e.imported = this.parseIdentifier(!0)), (e.importKind = h);
              else {
                if (s)
                  throw this.raise(p.ImportBindingIsString, e, {
                    importName: o.value,
                  });
                (e.imported = o), (e.importKind = null);
              }
              this.eatContextual(93)
                ? (e.local = this.parseIdentifier())
                : ((c = !0), (e.local = $(e.imported)));
            }
            let l = _t(e);
            return (
              i && l && this.raise(g.ImportTypeShorthandOnlyInPureImport, e),
              (i || l) &&
                this.checkReservedType(e.local.name, e.local.loc.start, !0),
              c &&
                !i &&
                !l &&
                this.checkReservedWord(e.local.name, e.loc.start, !0, !0),
              this.finishImportSpecifier(e, "ImportSpecifier")
            );
          }
          parseBindingAtom() {
            switch (this.state.type) {
              case 78:
                return this.parseIdentifier(!0);
              default:
                return super.parseBindingAtom();
            }
          }
          parseFunctionParams(e, s) {
            let i = e.kind;
            i !== "get" &&
              i !== "set" &&
              this.match(47) &&
              (e.typeParameters = this.flowParseTypeParameterDeclaration()),
              super.parseFunctionParams(e, s);
          }
          parseVarId(e, s) {
            super.parseVarId(e, s),
              this.match(14) &&
                ((e.id.typeAnnotation = this.flowParseTypeAnnotation()),
                this.resetEndLocation(e.id));
          }
          parseAsyncArrowFromCallExpression(e, s) {
            if (this.match(14)) {
              let i = this.state.noAnonFunctionType;
              (this.state.noAnonFunctionType = !0),
                (e.returnType = this.flowParseTypeAnnotation()),
                (this.state.noAnonFunctionType = i);
            }
            return super.parseAsyncArrowFromCallExpression(e, s);
          }
          shouldParseAsyncArrow() {
            return this.match(14) || super.shouldParseAsyncArrow();
          }
          parseMaybeAssign(e, s) {
            var i;
            let r = null,
              n;
            if (this.hasPlugin("jsx") && (this.match(142) || this.match(47))) {
              if (
                ((r = this.state.clone()),
                (n = this.tryParse(() => super.parseMaybeAssign(e, s), r)),
                !n.error)
              )
                return n.node;
              let { context: c } = this.state,
                l = c[c.length - 1];
              (l === C.j_oTag || l === C.j_expr) && c.pop();
            }
            if (((i = n) != null && i.error) || this.match(47)) {
              var o, h;
              r = r || this.state.clone();
              let c,
                l = this.tryParse((f) => {
                  var d;
                  c = this.flowParseTypeParameterDeclaration();
                  let y = this.forwardNoArrowParamsConversionAt(c, () => {
                    let L = super.parseMaybeAssign(e, s);
                    return this.resetStartLocationFromNode(L, c), L;
                  });
                  (d = y.extra) != null && d.parenthesized && f();
                  let E = this.maybeUnwrapTypeCastExpression(y);
                  return (
                    E.type !== "ArrowFunctionExpression" && f(),
                    (E.typeParameters = c),
                    this.resetStartLocationFromNode(E, c),
                    y
                  );
                }, r),
                u = null;
              if (
                l.node &&
                this.maybeUnwrapTypeCastExpression(l.node).type ===
                  "ArrowFunctionExpression"
              ) {
                if (!l.error && !l.aborted)
                  return (
                    l.node.async &&
                      this.raise(
                        g.UnexpectedTypeParameterBeforeAsyncArrowFunction,
                        c,
                      ),
                    l.node
                  );
                u = l.node;
              }
              if ((o = n) != null && o.node)
                return (this.state = n.failState), n.node;
              if (u) return (this.state = l.failState), u;
              throw (h = n) != null && h.thrown
                ? n.error
                : l.thrown
                  ? l.error
                  : this.raise(g.UnexpectedTokenAfterTypeParameter, c);
            }
            return super.parseMaybeAssign(e, s);
          }
          parseArrow(e) {
            if (this.match(14)) {
              let s = this.tryParse(() => {
                let i = this.state.noAnonFunctionType;
                this.state.noAnonFunctionType = !0;
                let r = this.startNode();
                return (
                  ([r.typeAnnotation, e.predicate] =
                    this.flowParseTypeAndPredicateInitialiser()),
                  (this.state.noAnonFunctionType = i),
                  this.canInsertSemicolon() && this.unexpected(),
                  this.match(19) || this.unexpected(),
                  r
                );
              });
              if (s.thrown) return null;
              s.error && (this.state = s.failState),
                (e.returnType = s.node.typeAnnotation
                  ? this.finishNode(s.node, "TypeAnnotation")
                  : null);
            }
            return super.parseArrow(e);
          }
          shouldParseArrow(e) {
            return this.match(14) || super.shouldParseArrow(e);
          }
          setArrowFunctionParameters(e, s) {
            this.state.noArrowParamsConversionAt.includes(e.start)
              ? (e.params = s)
              : super.setArrowFunctionParameters(e, s);
          }
          checkParams(e, s, i, r = !0) {
            if (
              !(i && this.state.noArrowParamsConversionAt.includes(e.start))
            ) {
              for (let n = 0; n < e.params.length; n++)
                this.isThisParam(e.params[n]) &&
                  n > 0 &&
                  this.raise(g.ThisParamMustBeFirst, e.params[n]);
              super.checkParams(e, s, i, r);
            }
          }
          parseParenAndDistinguishExpression(e) {
            return super.parseParenAndDistinguishExpression(
              e && !this.state.noArrowAt.includes(this.state.start),
            );
          }
          parseSubscripts(e, s, i) {
            if (
              e.type === "Identifier" &&
              e.name === "async" &&
              this.state.noArrowAt.includes(s.index)
            ) {
              this.next();
              let r = this.startNodeAt(s);
              (r.callee = e),
                (r.arguments = super.parseCallExpressionArguments(11, !1)),
                (e = this.finishNode(r, "CallExpression"));
            } else if (
              e.type === "Identifier" &&
              e.name === "async" &&
              this.match(47)
            ) {
              let r = this.state.clone(),
                n = this.tryParse(
                  (h) => this.parseAsyncArrowWithTypeParameters(s) || h(),
                  r,
                );
              if (!n.error && !n.aborted) return n.node;
              let o = this.tryParse(() => super.parseSubscripts(e, s, i), r);
              if (o.node && !o.error) return o.node;
              if (n.node) return (this.state = n.failState), n.node;
              if (o.node) return (this.state = o.failState), o.node;
              throw n.error || o.error;
            }
            return super.parseSubscripts(e, s, i);
          }
          parseSubscript(e, s, i, r) {
            if (this.match(18) && this.isLookaheadToken_lt()) {
              if (((r.optionalChainMember = !0), i)) return (r.stop = !0), e;
              this.next();
              let n = this.startNodeAt(s);
              return (
                (n.callee = e),
                (n.typeArguments = this.flowParseTypeParameterInstantiation()),
                this.expect(10),
                (n.arguments = this.parseCallExpressionArguments(11, !1)),
                (n.optional = !0),
                this.finishCallExpression(n, !0)
              );
            } else if (!i && this.shouldParseTypes() && this.match(47)) {
              let n = this.startNodeAt(s);
              n.callee = e;
              let o = this.tryParse(
                () => (
                  (n.typeArguments =
                    this.flowParseTypeParameterInstantiationCallOrNew()),
                  this.expect(10),
                  (n.arguments = super.parseCallExpressionArguments(11, !1)),
                  r.optionalChainMember && (n.optional = !1),
                  this.finishCallExpression(n, r.optionalChainMember)
                ),
              );
              if (o.node) return o.error && (this.state = o.failState), o.node;
            }
            return super.parseSubscript(e, s, i, r);
          }
          parseNewCallee(e) {
            super.parseNewCallee(e);
            let s = null;
            this.shouldParseTypes() &&
              this.match(47) &&
              (s = this.tryParse(() =>
                this.flowParseTypeParameterInstantiationCallOrNew(),
              ).node),
              (e.typeArguments = s);
          }
          parseAsyncArrowWithTypeParameters(e) {
            let s = this.startNodeAt(e);
            if ((this.parseFunctionParams(s, !1), !!this.parseArrow(s)))
              return super.parseArrowExpression(s, void 0, !0);
          }
          readToken_mult_modulo(e) {
            let s = this.input.charCodeAt(this.state.pos + 1);
            if (e === 42 && s === 47 && this.state.hasFlowComment) {
              (this.state.hasFlowComment = !1),
                (this.state.pos += 2),
                this.nextToken();
              return;
            }
            super.readToken_mult_modulo(e);
          }
          readToken_pipe_amp(e) {
            let s = this.input.charCodeAt(this.state.pos + 1);
            if (e === 124 && s === 125) {
              this.finishOp(9, 2);
              return;
            }
            super.readToken_pipe_amp(e);
          }
          parseTopLevel(e, s) {
            let i = super.parseTopLevel(e, s);
            return (
              this.state.hasFlowComment &&
                this.raise(g.UnterminatedFlowComment, this.state.curPosition()),
              i
            );
          }
          skipBlockComment() {
            if (this.hasPlugin("flowComments") && this.skipFlowComment()) {
              if (this.state.hasFlowComment)
                throw this.raise(g.NestedFlowComment, this.state.startLoc);
              this.hasFlowCommentCompletion();
              let e = this.skipFlowComment();
              e && ((this.state.pos += e), (this.state.hasFlowComment = !0));
              return;
            }
            return super.skipBlockComment(
              this.state.hasFlowComment ? "*-/" : "*/",
            );
          }
          skipFlowComment() {
            let { pos: e } = this.state,
              s = 2;
            for (; [32, 9].includes(this.input.charCodeAt(e + s)); ) s++;
            let i = this.input.charCodeAt(s + e),
              r = this.input.charCodeAt(s + e + 1);
            return i === 58 && r === 58
              ? s + 2
              : this.input.slice(s + e, s + e + 12) === "flow-include"
                ? s + 12
                : i === 58 && r !== 58
                  ? s
                  : !1;
          }
          hasFlowCommentCompletion() {
            if (this.input.indexOf("*/", this.state.pos) === -1)
              throw this.raise(p.UnterminatedComment, this.state.curPosition());
          }
          flowEnumErrorBooleanMemberNotInitialized(
            e,
            { enumName: s, memberName: i },
          ) {
            this.raise(g.EnumBooleanMemberNotInitialized, e, {
              memberName: i,
              enumName: s,
            });
          }
          flowEnumErrorInvalidMemberInitializer(e, s) {
            return this.raise(
              s.explicitType
                ? s.explicitType === "symbol"
                  ? g.EnumInvalidMemberInitializerSymbolType
                  : g.EnumInvalidMemberInitializerPrimaryType
                : g.EnumInvalidMemberInitializerUnknownType,
              e,
              s,
            );
          }
          flowEnumErrorNumberMemberNotInitialized(e, s) {
            this.raise(g.EnumNumberMemberNotInitialized, e, s);
          }
          flowEnumErrorStringMemberInconsistentlyInitialized(e, s) {
            this.raise(g.EnumStringMemberInconsistentlyInitialized, e, s);
          }
          flowEnumMemberInit() {
            let e = this.state.startLoc,
              s = () => this.match(12) || this.match(8);
            switch (this.state.type) {
              case 134: {
                let i = this.parseNumericLiteral(this.state.value);
                return s()
                  ? { type: "number", loc: i.loc.start, value: i }
                  : { type: "invalid", loc: e };
              }
              case 133: {
                let i = this.parseStringLiteral(this.state.value);
                return s()
                  ? { type: "string", loc: i.loc.start, value: i }
                  : { type: "invalid", loc: e };
              }
              case 85:
              case 86: {
                let i = this.parseBooleanLiteral(this.match(85));
                return s()
                  ? { type: "boolean", loc: i.loc.start, value: i }
                  : { type: "invalid", loc: e };
              }
              default:
                return { type: "invalid", loc: e };
            }
          }
          flowEnumMemberRaw() {
            let e = this.state.startLoc,
              s = this.parseIdentifier(!0),
              i = this.eat(29)
                ? this.flowEnumMemberInit()
                : { type: "none", loc: e };
            return { id: s, init: i };
          }
          flowEnumCheckExplicitTypeMismatch(e, s, i) {
            let { explicitType: r } = s;
            r !== null &&
              r !== i &&
              this.flowEnumErrorInvalidMemberInitializer(e, s);
          }
          flowEnumMembers({ enumName: e, explicitType: s }) {
            let i = new Set(),
              r = {
                booleanMembers: [],
                numberMembers: [],
                stringMembers: [],
                defaultedMembers: [],
              },
              n = !1;
            for (; !this.match(8); ) {
              if (this.eat(21)) {
                n = !0;
                break;
              }
              let o = this.startNode(),
                { id: h, init: c } = this.flowEnumMemberRaw(),
                l = h.name;
              if (l === "") continue;
              /^[a-z]/.test(l) &&
                this.raise(g.EnumInvalidMemberName, h, {
                  memberName: l,
                  suggestion: l[0].toUpperCase() + l.slice(1),
                  enumName: e,
                }),
                i.has(l) &&
                  this.raise(g.EnumDuplicateMemberName, h, {
                    memberName: l,
                    enumName: e,
                  }),
                i.add(l);
              let u = { enumName: e, explicitType: s, memberName: l };
              switch (((o.id = h), c.type)) {
                case "boolean": {
                  this.flowEnumCheckExplicitTypeMismatch(c.loc, u, "boolean"),
                    (o.init = c.value),
                    r.booleanMembers.push(
                      this.finishNode(o, "EnumBooleanMember"),
                    );
                  break;
                }
                case "number": {
                  this.flowEnumCheckExplicitTypeMismatch(c.loc, u, "number"),
                    (o.init = c.value),
                    r.numberMembers.push(
                      this.finishNode(o, "EnumNumberMember"),
                    );
                  break;
                }
                case "string": {
                  this.flowEnumCheckExplicitTypeMismatch(c.loc, u, "string"),
                    (o.init = c.value),
                    r.stringMembers.push(
                      this.finishNode(o, "EnumStringMember"),
                    );
                  break;
                }
                case "invalid":
                  throw this.flowEnumErrorInvalidMemberInitializer(c.loc, u);
                case "none":
                  switch (s) {
                    case "boolean":
                      this.flowEnumErrorBooleanMemberNotInitialized(c.loc, u);
                      break;
                    case "number":
                      this.flowEnumErrorNumberMemberNotInitialized(c.loc, u);
                      break;
                    default:
                      r.defaultedMembers.push(
                        this.finishNode(o, "EnumDefaultedMember"),
                      );
                  }
              }
              this.match(8) || this.expect(12);
            }
            return { members: r, hasUnknownMembers: n };
          }
          flowEnumStringMembers(e, s, { enumName: i }) {
            if (e.length === 0) return s;
            if (s.length === 0) return e;
            if (s.length > e.length) {
              for (let r of e)
                this.flowEnumErrorStringMemberInconsistentlyInitialized(r, {
                  enumName: i,
                });
              return s;
            } else {
              for (let r of s)
                this.flowEnumErrorStringMemberInconsistentlyInitialized(r, {
                  enumName: i,
                });
              return e;
            }
          }
          flowEnumParseExplicitType({ enumName: e }) {
            if (!this.eatContextual(102)) return null;
            if (!w(this.state.type))
              throw this.raise(
                g.EnumInvalidExplicitTypeUnknownSupplied,
                this.state.startLoc,
                { enumName: e },
              );
            let { value: s } = this.state;
            return (
              this.next(),
              s !== "boolean" &&
                s !== "number" &&
                s !== "string" &&
                s !== "symbol" &&
                this.raise(g.EnumInvalidExplicitType, this.state.startLoc, {
                  enumName: e,
                  invalidEnumType: s,
                }),
              s
            );
          }
          flowEnumBody(e, s) {
            let i = s.name,
              r = s.loc.start,
              n = this.flowEnumParseExplicitType({ enumName: i });
            this.expect(5);
            let { members: o, hasUnknownMembers: h } = this.flowEnumMembers({
              enumName: i,
              explicitType: n,
            });
            switch (((e.hasUnknownMembers = h), n)) {
              case "boolean":
                return (
                  (e.explicitType = !0),
                  (e.members = o.booleanMembers),
                  this.expect(8),
                  this.finishNode(e, "EnumBooleanBody")
                );
              case "number":
                return (
                  (e.explicitType = !0),
                  (e.members = o.numberMembers),
                  this.expect(8),
                  this.finishNode(e, "EnumNumberBody")
                );
              case "string":
                return (
                  (e.explicitType = !0),
                  (e.members = this.flowEnumStringMembers(
                    o.stringMembers,
                    o.defaultedMembers,
                    { enumName: i },
                  )),
                  this.expect(8),
                  this.finishNode(e, "EnumStringBody")
                );
              case "symbol":
                return (
                  (e.members = o.defaultedMembers),
                  this.expect(8),
                  this.finishNode(e, "EnumSymbolBody")
                );
              default: {
                let c = () => (
                  (e.members = []),
                  this.expect(8),
                  this.finishNode(e, "EnumStringBody")
                );
                e.explicitType = !1;
                let l = o.booleanMembers.length,
                  u = o.numberMembers.length,
                  f = o.stringMembers.length,
                  d = o.defaultedMembers.length;
                if (!l && !u && !f && !d) return c();
                if (!l && !u)
                  return (
                    (e.members = this.flowEnumStringMembers(
                      o.stringMembers,
                      o.defaultedMembers,
                      { enumName: i },
                    )),
                    this.expect(8),
                    this.finishNode(e, "EnumStringBody")
                  );
                if (!u && !f && l >= d) {
                  for (let y of o.defaultedMembers)
                    this.flowEnumErrorBooleanMemberNotInitialized(y.loc.start, {
                      enumName: i,
                      memberName: y.id.name,
                    });
                  return (
                    (e.members = o.booleanMembers),
                    this.expect(8),
                    this.finishNode(e, "EnumBooleanBody")
                  );
                } else if (!l && !f && u >= d) {
                  for (let y of o.defaultedMembers)
                    this.flowEnumErrorNumberMemberNotInitialized(y.loc.start, {
                      enumName: i,
                      memberName: y.id.name,
                    });
                  return (
                    (e.members = o.numberMembers),
                    this.expect(8),
                    this.finishNode(e, "EnumNumberBody")
                  );
                } else
                  return (
                    this.raise(g.EnumInconsistentMemberValues, r, {
                      enumName: i,
                    }),
                    c()
                  );
              }
            }
          }
          flowParseEnumDeclaration(e) {
            let s = this.parseIdentifier();
            return (
              (e.id = s),
              (e.body = this.flowEnumBody(this.startNode(), s)),
              this.finishNode(e, "EnumDeclaration")
            );
          }
          isLookaheadToken_lt() {
            let e = this.nextTokenStart();
            if (this.input.charCodeAt(e) === 60) {
              let s = this.input.charCodeAt(e + 1);
              return s !== 60 && s !== 61;
            }
            return !1;
          }
          maybeUnwrapTypeCastExpression(e) {
            return e.type === "TypeCastExpression" ? e.expression : e;
          }
        },
      W = j`jsx`({
        AttributeIsEmpty:
          "JSX attributes must only be assigned a non-empty expression.",
        MissingClosingTagElement: ({ openingTagName: a }) =>
          `Expected corresponding JSX closing tag for <${a}>.`,
        MissingClosingTagFragment:
          "Expected corresponding JSX closing tag for <>.",
        UnexpectedSequenceExpression:
          "Sequence expressions cannot be directly nested inside JSX. Did you mean to wrap it in parentheses (...)?",
        UnexpectedToken: ({ unexpected: a, HTMLEntity: t }) =>
          `Unexpected token \`${a}\`. Did you mean \`${t}\` or \`{'${a}'}\`?`,
        UnsupportedJsxValue:
          "JSX value should be either an expression or a quoted JSX text.",
        UnterminatedJsxContent: "Unterminated JSX contents.",
        UnwrappedAdjacentJSXElements:
          "Adjacent JSX elements must be wrapped in an enclosing tag. Did you want a JSX fragment <>...</>?",
      });
    function z(a) {
      return a
        ? a.type === "JSXOpeningFragment" || a.type === "JSXClosingFragment"
        : !1;
    }
    function Y(a) {
      if (a.type === "JSXIdentifier") return a.name;
      if (a.type === "JSXNamespacedName")
        return a.namespace.name + ":" + a.name.name;
      if (a.type === "JSXMemberExpression")
        return Y(a.object) + "." + Y(a.property);
      throw new Error("Node had unexpected type: " + a.type);
    }
    var zi = (a) =>
        class extends a {
          jsxReadToken() {
            let e = "",
              s = this.state.pos;
            for (;;) {
              if (this.state.pos >= this.length)
                throw this.raise(W.UnterminatedJsxContent, this.state.startLoc);
              let i = this.input.charCodeAt(this.state.pos);
              switch (i) {
                case 60:
                case 123:
                  if (this.state.pos === this.state.start) {
                    i === 60 && this.state.canStartJSXElement
                      ? (++this.state.pos, this.finishToken(142))
                      : super.getTokenFromCode(i);
                    return;
                  }
                  (e += this.input.slice(s, this.state.pos)),
                    this.finishToken(141, e);
                  return;
                case 38:
                  (e += this.input.slice(s, this.state.pos)),
                    (e += this.jsxReadEntity()),
                    (s = this.state.pos);
                  break;
                case 62:
                case 125:
                default:
                  fe(i)
                    ? ((e += this.input.slice(s, this.state.pos)),
                      (e += this.jsxReadNewLine(!0)),
                      (s = this.state.pos))
                    : ++this.state.pos;
              }
            }
          }
          jsxReadNewLine(e) {
            let s = this.input.charCodeAt(this.state.pos),
              i;
            return (
              ++this.state.pos,
              s === 13 && this.input.charCodeAt(this.state.pos) === 10
                ? (++this.state.pos,
                  (i = e
                    ? `
`
                    : `\r
`))
                : (i = String.fromCharCode(s)),
              ++this.state.curLine,
              (this.state.lineStart = this.state.pos),
              i
            );
          }
          jsxReadString(e) {
            let s = "",
              i = ++this.state.pos;
            for (;;) {
              if (this.state.pos >= this.length)
                throw this.raise(p.UnterminatedString, this.state.startLoc);
              let r = this.input.charCodeAt(this.state.pos);
              if (r === e) break;
              r === 38
                ? ((s += this.input.slice(i, this.state.pos)),
                  (s += this.jsxReadEntity()),
                  (i = this.state.pos))
                : fe(r)
                  ? ((s += this.input.slice(i, this.state.pos)),
                    (s += this.jsxReadNewLine(!1)),
                    (i = this.state.pos))
                  : ++this.state.pos;
            }
            (s += this.input.slice(i, this.state.pos++)),
              this.finishToken(133, s);
          }
          jsxReadEntity() {
            let e = ++this.state.pos;
            if (this.codePointAtPos(this.state.pos) === 35) {
              ++this.state.pos;
              let s = 10;
              this.codePointAtPos(this.state.pos) === 120 &&
                ((s = 16), ++this.state.pos);
              let i = this.readInt(s, void 0, !1, "bail");
              if (i !== null && this.codePointAtPos(this.state.pos) === 59)
                return ++this.state.pos, String.fromCodePoint(i);
            } else {
              let s = 0,
                i = !1;
              for (
                ;
                s++ < 10 &&
                this.state.pos < this.length &&
                !(i = this.codePointAtPos(this.state.pos) === 59);

              )
                ++this.state.pos;
              if (i) {
                let r = this.input.slice(e, this.state.pos),
                  n = void 0;
                if ((++this.state.pos, n)) return n;
              }
            }
            return (this.state.pos = e), "&";
          }
          jsxReadWord() {
            let e,
              s = this.state.pos;
            do e = this.input.charCodeAt(++this.state.pos);
            while (Q(e) || e === 45);
            this.finishToken(140, this.input.slice(s, this.state.pos));
          }
          jsxParseIdentifier() {
            let e = this.startNode();
            return (
              this.match(140)
                ? (e.name = this.state.value)
                : Pt(this.state.type)
                  ? (e.name = K(this.state.type))
                  : this.unexpected(),
              this.next(),
              this.finishNode(e, "JSXIdentifier")
            );
          }
          jsxParseNamespacedName() {
            let e = this.state.startLoc,
              s = this.jsxParseIdentifier();
            if (!this.eat(14)) return s;
            let i = this.startNodeAt(e);
            return (
              (i.namespace = s),
              (i.name = this.jsxParseIdentifier()),
              this.finishNode(i, "JSXNamespacedName")
            );
          }
          jsxParseElementName() {
            let e = this.state.startLoc,
              s = this.jsxParseNamespacedName();
            if (s.type === "JSXNamespacedName") return s;
            for (; this.eat(16); ) {
              let i = this.startNodeAt(e);
              (i.object = s),
                (i.property = this.jsxParseIdentifier()),
                (s = this.finishNode(i, "JSXMemberExpression"));
            }
            return s;
          }
          jsxParseAttributeValue() {
            let e;
            switch (this.state.type) {
              case 5:
                return (
                  (e = this.startNode()),
                  this.setContext(C.brace),
                  this.next(),
                  (e = this.jsxParseExpressionContainer(e, C.j_oTag)),
                  e.expression.type === "JSXEmptyExpression" &&
                    this.raise(W.AttributeIsEmpty, e),
                  e
                );
              case 142:
              case 133:
                return this.parseExprAtom();
              default:
                throw this.raise(W.UnsupportedJsxValue, this.state.startLoc);
            }
          }
          jsxParseEmptyExpression() {
            let e = this.startNodeAt(this.state.lastTokEndLoc);
            return this.finishNodeAt(
              e,
              "JSXEmptyExpression",
              this.state.startLoc,
            );
          }
          jsxParseSpreadChild(e) {
            return (
              this.next(),
              (e.expression = this.parseExpression()),
              this.setContext(C.j_expr),
              (this.state.canStartJSXElement = !0),
              this.expect(8),
              this.finishNode(e, "JSXSpreadChild")
            );
          }
          jsxParseExpressionContainer(e, s) {
            if (this.match(8)) e.expression = this.jsxParseEmptyExpression();
            else {
              let i = this.parseExpression();
              e.expression = i;
            }
            return (
              this.setContext(s),
              (this.state.canStartJSXElement = !0),
              this.expect(8),
              this.finishNode(e, "JSXExpressionContainer")
            );
          }
          jsxParseAttribute() {
            let e = this.startNode();
            return this.match(5)
              ? (this.setContext(C.brace),
                this.next(),
                this.expect(21),
                (e.argument = this.parseMaybeAssignAllowIn()),
                this.setContext(C.j_oTag),
                (this.state.canStartJSXElement = !0),
                this.expect(8),
                this.finishNode(e, "JSXSpreadAttribute"))
              : ((e.name = this.jsxParseNamespacedName()),
                (e.value = this.eat(29) ? this.jsxParseAttributeValue() : null),
                this.finishNode(e, "JSXAttribute"));
          }
          jsxParseOpeningElementAt(e) {
            let s = this.startNodeAt(e);
            return this.eat(143)
              ? this.finishNode(s, "JSXOpeningFragment")
              : ((s.name = this.jsxParseElementName()),
                this.jsxParseOpeningElementAfterName(s));
          }
          jsxParseOpeningElementAfterName(e) {
            let s = [];
            for (; !this.match(56) && !this.match(143); )
              s.push(this.jsxParseAttribute());
            return (
              (e.attributes = s),
              (e.selfClosing = this.eat(56)),
              this.expect(143),
              this.finishNode(e, "JSXOpeningElement")
            );
          }
          jsxParseClosingElementAt(e) {
            let s = this.startNodeAt(e);
            return this.eat(143)
              ? this.finishNode(s, "JSXClosingFragment")
              : ((s.name = this.jsxParseElementName()),
                this.expect(143),
                this.finishNode(s, "JSXClosingElement"));
          }
          jsxParseElementAt(e) {
            let s = this.startNodeAt(e),
              i = [],
              r = this.jsxParseOpeningElementAt(e),
              n = null;
            if (!r.selfClosing) {
              e: for (;;)
                switch (this.state.type) {
                  case 142:
                    if (
                      ((e = this.state.startLoc), this.next(), this.eat(56))
                    ) {
                      n = this.jsxParseClosingElementAt(e);
                      break e;
                    }
                    i.push(this.jsxParseElementAt(e));
                    break;
                  case 141:
                    i.push(this.parseLiteral(this.state.value, "JSXText"));
                    break;
                  case 5: {
                    let o = this.startNode();
                    this.setContext(C.brace),
                      this.next(),
                      this.match(21)
                        ? i.push(this.jsxParseSpreadChild(o))
                        : i.push(this.jsxParseExpressionContainer(o, C.j_expr));
                    break;
                  }
                  default:
                    this.unexpected();
                }
              z(r) && !z(n) && n !== null
                ? this.raise(W.MissingClosingTagFragment, n)
                : !z(r) && z(n)
                  ? this.raise(W.MissingClosingTagElement, n, {
                      openingTagName: Y(r.name),
                    })
                  : !z(r) &&
                    !z(n) &&
                    Y(n.name) !== Y(r.name) &&
                    this.raise(W.MissingClosingTagElement, n, {
                      openingTagName: Y(r.name),
                    });
            }
            if (
              (z(r)
                ? ((s.openingFragment = r), (s.closingFragment = n))
                : ((s.openingElement = r), (s.closingElement = n)),
              (s.children = i),
              this.match(47))
            )
              throw this.raise(
                W.UnwrappedAdjacentJSXElements,
                this.state.startLoc,
              );
            return z(r)
              ? this.finishNode(s, "JSXFragment")
              : this.finishNode(s, "JSXElement");
          }
          jsxParseElement() {
            let e = this.state.startLoc;
            return this.next(), this.jsxParseElementAt(e);
          }
          setContext(e) {
            let { context: s } = this.state;
            s[s.length - 1] = e;
          }
          parseExprAtom(e) {
            return this.match(142)
              ? this.jsxParseElement()
              : this.match(47) && this.input.charCodeAt(this.state.pos) !== 33
                ? (this.replaceToken(142), this.jsxParseElement())
                : super.parseExprAtom(e);
          }
          skipSpace() {
            this.curContext().preserveSpace || super.skipSpace();
          }
          getTokenFromCode(e) {
            let s = this.curContext();
            if (s === C.j_expr) {
              this.jsxReadToken();
              return;
            }
            if (s === C.j_oTag || s === C.j_cTag) {
              if (_(e)) {
                this.jsxReadWord();
                return;
              }
              if (e === 62) {
                ++this.state.pos, this.finishToken(143);
                return;
              }
              if ((e === 34 || e === 39) && s === C.j_oTag) {
                this.jsxReadString(e);
                return;
              }
            }
            if (
              e === 60 &&
              this.state.canStartJSXElement &&
              this.input.charCodeAt(this.state.pos + 1) !== 33
            ) {
              ++this.state.pos, this.finishToken(142);
              return;
            }
            super.getTokenFromCode(e);
          }
          updateContext(e) {
            let { context: s, type: i } = this.state;
            if (i === 56 && e === 142)
              s.splice(-2, 2, C.j_cTag), (this.state.canStartJSXElement = !1);
            else if (i === 142) s.push(C.j_oTag);
            else if (i === 143) {
              let r = s[s.length - 1];
              (r === C.j_oTag && e === 56) || r === C.j_cTag
                ? (s.pop(),
                  (this.state.canStartJSXElement =
                    s[s.length - 1] === C.j_expr))
                : (this.setContext(C.j_expr),
                  (this.state.canStartJSXElement = !0));
            } else this.state.canStartJSXElement = hi(i);
          }
        },
      ot = class extends de {
        constructor(...t) {
          super(...t), (this.tsNames = new Map());
        }
      },
      ht = class extends me {
        constructor(...t) {
          super(...t), (this.importsStack = []);
        }
        createScope(t) {
          return this.importsStack.push(new Set()), new ot(t);
        }
        enter(t) {
          t === 256 && this.importsStack.push(new Set()), super.enter(t);
        }
        exit() {
          let t = super.exit();
          return t === 256 && this.importsStack.pop(), t;
        }
        hasImport(t, e) {
          let s = this.importsStack.length;
          if (this.importsStack[s - 1].has(t)) return !0;
          if (!e && s > 1) {
            for (let i = 0; i < s - 1; i++)
              if (this.importsStack[i].has(t)) return !0;
          }
          return !1;
        }
        declareName(t, e, s) {
          if (e & 4096) {
            this.hasImport(t, !0) &&
              this.parser.raise(p.VarRedeclaration, s, { identifierName: t }),
              this.importsStack[this.importsStack.length - 1].add(t);
            return;
          }
          let i = this.currentScope(),
            r = i.tsNames.get(t) || 0;
          if (e & 1024) {
            this.maybeExportDefined(i, t), i.tsNames.set(t, r | 16);
            return;
          }
          super.declareName(t, e, s),
            e & 2 &&
              (e & 1 ||
                (this.checkRedeclarationInScope(i, t, e, s),
                this.maybeExportDefined(i, t)),
              (r = r | 1)),
            e & 256 && (r = r | 2),
            e & 512 && (r = r | 4),
            e & 128 && (r = r | 8),
            r && i.tsNames.set(t, r);
        }
        isRedeclaredInScope(t, e, s) {
          let i = t.tsNames.get(e);
          if ((i & 2) > 0) {
            if (s & 256) {
              let r = !!(s & 512),
                n = (i & 4) > 0;
              return r !== n;
            }
            return !0;
          }
          return s & 128 && (i & 8) > 0
            ? t.names.get(e) & 2
              ? !!(s & 1)
              : !1
            : s & 2 && (i & 1) > 0
              ? !0
              : super.isRedeclaredInScope(t, e, s);
        }
        checkLocalExport(t) {
          let { name: e } = t;
          if (this.hasImport(e)) return;
          let s = this.scopeStack.length;
          for (let i = s - 1; i >= 0; i--) {
            let n = this.scopeStack[i].tsNames.get(e);
            if ((n & 1) > 0 || (n & 16) > 0) return;
          }
          super.checkLocalExport(t);
        }
      },
      Ki = (a, t) => hasOwnProperty.call(a, t) && a[t],
      as = (a) => (a.type === "ParenthesizedExpression" ? as(a.expression) : a),
      lt = class extends nt {
        toAssignable(t, e = !1) {
          var s, i;
          let r;
          switch (
            ((t.type === "ParenthesizedExpression" ||
              ((s = t.extra) != null && s.parenthesized)) &&
              ((r = as(t)),
              e
                ? r.type === "Identifier"
                  ? this.expressionScope.recordArrowParameterBindingError(
                      p.InvalidParenthesizedAssignment,
                      t,
                    )
                  : r.type !== "MemberExpression" &&
                    !this.isOptionalMemberExpression(r) &&
                    this.raise(p.InvalidParenthesizedAssignment, t)
                : this.raise(p.InvalidParenthesizedAssignment, t)),
            t.type)
          ) {
            case "Identifier":
            case "ObjectPattern":
            case "ArrayPattern":
            case "AssignmentPattern":
            case "RestElement":
              break;
            case "ObjectExpression":
              t.type = "ObjectPattern";
              for (let o = 0, h = t.properties.length, c = h - 1; o < h; o++) {
                var n;
                let l = t.properties[o],
                  u = o === c;
                this.toAssignableObjectExpressionProp(l, u, e),
                  u &&
                    l.type === "RestElement" &&
                    (n = t.extra) != null &&
                    n.trailingCommaLoc &&
                    this.raise(p.RestTrailingComma, t.extra.trailingCommaLoc);
              }
              break;
            case "ObjectProperty": {
              let { key: o, value: h } = t;
              this.isPrivateName(o) &&
                this.classScope.usePrivateName(
                  this.getPrivateNameSV(o),
                  o.loc.start,
                ),
                this.toAssignable(h, e);
              break;
            }
            case "SpreadElement":
              throw new Error(
                "Internal @babel/parser error (this is a bug, please report it). SpreadElement should be converted by .toAssignable's caller.",
              );
            case "ArrayExpression":
              (t.type = "ArrayPattern"),
                this.toAssignableList(
                  t.elements,
                  (i = t.extra) == null ? void 0 : i.trailingCommaLoc,
                  e,
                );
              break;
            case "AssignmentExpression":
              t.operator !== "=" &&
                this.raise(p.MissingEqInAssignment, t.left.loc.end),
                (t.type = "AssignmentPattern"),
                delete t.operator,
                this.toAssignable(t.left, e);
              break;
            case "ParenthesizedExpression":
              this.toAssignable(r, e);
              break;
          }
        }
        toAssignableObjectExpressionProp(t, e, s) {
          if (t.type === "ObjectMethod")
            this.raise(
              t.kind === "get" || t.kind === "set"
                ? p.PatternHasAccessor
                : p.PatternHasMethod,
              t.key,
            );
          else if (t.type === "SpreadElement") {
            t.type = "RestElement";
            let i = t.argument;
            this.checkToRestConversion(i, !1),
              this.toAssignable(i, s),
              e || this.raise(p.RestTrailingComma, t);
          } else this.toAssignable(t, s);
        }
        toAssignableList(t, e, s) {
          let i = t.length - 1;
          for (let r = 0; r <= i; r++) {
            let n = t[r];
            if (n) {
              if (n.type === "SpreadElement") {
                n.type = "RestElement";
                let o = n.argument;
                this.checkToRestConversion(o, !0), this.toAssignable(o, s);
              } else this.toAssignable(n, s);
              n.type === "RestElement" &&
                (r < i
                  ? this.raise(p.RestTrailingComma, n)
                  : e && this.raise(p.RestTrailingComma, e));
            }
          }
        }
        isAssignable(t, e) {
          switch (t.type) {
            case "Identifier":
            case "ObjectPattern":
            case "ArrayPattern":
            case "AssignmentPattern":
            case "RestElement":
              return !0;
            case "ObjectExpression": {
              let s = t.properties.length - 1;
              return t.properties.every(
                (i, r) =>
                  i.type !== "ObjectMethod" &&
                  (r === s || i.type !== "SpreadElement") &&
                  this.isAssignable(i),
              );
            }
            case "ObjectProperty":
              return this.isAssignable(t.value);
            case "SpreadElement":
              return this.isAssignable(t.argument);
            case "ArrayExpression":
              return t.elements.every(
                (s) => s === null || this.isAssignable(s),
              );
            case "AssignmentExpression":
              return t.operator === "=";
            case "ParenthesizedExpression":
              return this.isAssignable(t.expression);
            case "MemberExpression":
            case "OptionalMemberExpression":
              return !e;
            default:
              return !1;
          }
        }
        toReferencedList(t, e) {
          return t;
        }
        toReferencedListDeep(t, e) {
          this.toReferencedList(t, e);
          for (let s of t)
            (s == null ? void 0 : s.type) === "ArrayExpression" &&
              this.toReferencedListDeep(s.elements);
        }
        parseSpread(t) {
          let e = this.startNode();
          return (
            this.next(),
            (e.argument = this.parseMaybeAssignAllowIn(t, void 0)),
            this.finishNode(e, "SpreadElement")
          );
        }
        parseRestBinding() {
          let t = this.startNode();
          return (
            this.next(),
            (t.argument = this.parseBindingAtom()),
            this.finishNode(t, "RestElement")
          );
        }
        parseBindingAtom() {
          switch (this.state.type) {
            case 0: {
              let t = this.startNode();
              return (
                this.next(),
                (t.elements = this.parseBindingList(3, 93, 1)),
                this.finishNode(t, "ArrayPattern")
              );
            }
            case 5:
              return this.parseObjectLike(8, !0);
          }
          return this.parseIdentifier();
        }
        parseBindingList(t, e, s) {
          let i = s & 1,
            r = [],
            n = !0;
          for (; !this.eat(t); )
            if ((n ? (n = !1) : this.expect(12), i && this.match(12)))
              r.push(null);
            else {
              if (this.eat(t)) break;
              if (this.match(21)) {
                if (
                  (r.push(
                    this.parseAssignableListItemTypes(
                      this.parseRestBinding(),
                      s,
                    ),
                  ),
                  !this.checkCommaAfterRest(e))
                ) {
                  this.expect(t);
                  break;
                }
              } else {
                let o = [];
                for (
                  this.match(26) &&
                  this.hasPlugin("decorators") &&
                  this.raise(
                    p.UnsupportedParameterDecorator,
                    this.state.startLoc,
                  );
                  this.match(26);

                )
                  o.push(this.parseDecorator());
                r.push(this.parseAssignableListItem(s, o));
              }
            }
          return r;
        }
        parseBindingRestProperty(t) {
          return (
            this.next(),
            (t.argument = this.parseIdentifier()),
            this.checkCommaAfterRest(125),
            this.finishNode(t, "RestElement")
          );
        }
        parseBindingProperty() {
          let { type: t, startLoc: e } = this.state;
          if (t === 21) return this.parseBindingRestProperty(this.startNode());
          let s = this.startNode();
          return (
            t === 138
              ? (this.expectPlugin("destructuringPrivate", e),
                this.classScope.usePrivateName(this.state.value, e),
                (s.key = this.parsePrivateName()))
              : this.parsePropertyName(s),
            (s.method = !1),
            this.parseObjPropValue(s, e, !1, !1, !0, !1)
          );
        }
        parseAssignableListItem(t, e) {
          let s = this.parseMaybeDefault();
          this.parseAssignableListItemTypes(s, t);
          let i = this.parseMaybeDefault(s.loc.start, s);
          return e.length && (s.decorators = e), i;
        }
        parseAssignableListItemTypes(t, e) {
          return t;
        }
        parseMaybeDefault(t, e) {
          var s, i;
          if (
            ((s = t) != null || (t = this.state.startLoc),
            (e = (i = e) != null ? i : this.parseBindingAtom()),
            !this.eat(29))
          )
            return e;
          let r = this.startNodeAt(t);
          return (
            (r.left = e),
            (r.right = this.parseMaybeAssignAllowIn()),
            this.finishNode(r, "AssignmentPattern")
          );
        }
        isValidLVal(t, e, s) {
          return Ki(
            {
              AssignmentPattern: "left",
              RestElement: "argument",
              ObjectProperty: "value",
              ParenthesizedExpression: "expression",
              ArrayPattern: "elements",
              ObjectPattern: "properties",
            },
            t,
          );
        }
        isOptionalMemberExpression(t) {
          return t.type === "OptionalMemberExpression";
        }
        checkLVal(
          t,
          {
            in: e,
            binding: s = 64,
            checkClashes: i = !1,
            strictModeChanged: r = !1,
            hasParenthesizedAncestor: n = !1,
          },
        ) {
          var o;
          let h = t.type;
          if (this.isObjectMethod(t)) return;
          let c = this.isOptionalMemberExpression(t);
          if (c || h === "MemberExpression") {
            c &&
              (this.expectPlugin("optionalChainingAssign", t.loc.start),
              e.type !== "AssignmentExpression" &&
                this.raise(p.InvalidLhsOptionalChaining, t, { ancestor: e })),
              s !== 64 && this.raise(p.InvalidPropertyBindingPattern, t);
            return;
          }
          if (h === "Identifier") {
            this.checkIdentifier(t, s, r);
            let { name: y } = t;
            i && (i.has(y) ? this.raise(p.ParamDupe, t) : i.add(y));
            return;
          }
          let l = this.isValidLVal(
            h,
            !(n || ((o = t.extra) != null && o.parenthesized)) &&
              e.type === "AssignmentExpression",
            s,
          );
          if (l === !0) return;
          if (l === !1) {
            let y = s === 64 ? p.InvalidLhs : p.InvalidLhsBinding;
            this.raise(y, t, { ancestor: e });
            return;
          }
          let [u, f] = Array.isArray(l)
              ? l
              : [l, h === "ParenthesizedExpression"],
            d = h === "ArrayPattern" || h === "ObjectPattern" ? { type: h } : e;
          for (let y of [].concat(t[u]))
            y &&
              this.checkLVal(y, {
                in: d,
                binding: s,
                checkClashes: i,
                strictModeChanged: r,
                hasParenthesizedAncestor: f,
              });
        }
        checkIdentifier(t, e, s = !1) {
          this.state.strict &&
            (s ? Zt(t.name, this.inModule) : Qt(t.name)) &&
            (e === 64
              ? this.raise(p.StrictEvalArguments, t, { referenceName: t.name })
              : this.raise(p.StrictEvalArgumentsBinding, t, {
                  bindingName: t.name,
                })),
            e & 8192 &&
              t.name === "let" &&
              this.raise(p.LetInLexicalBinding, t),
            e & 64 || this.declareNameFromIdentifier(t, e);
        }
        declareNameFromIdentifier(t, e) {
          this.scope.declareName(t.name, e, t.loc.start);
        }
        checkToRestConversion(t, e) {
          switch (t.type) {
            case "ParenthesizedExpression":
              this.checkToRestConversion(t.expression, e);
              break;
            case "Identifier":
            case "MemberExpression":
              break;
            case "ArrayExpression":
            case "ObjectExpression":
              if (e) break;
            default:
              this.raise(p.InvalidRestAssignmentPattern, t);
          }
        }
        checkCommaAfterRest(t) {
          return this.match(12)
            ? (this.raise(
                this.lookaheadCharCode() === t
                  ? p.RestTrailingComma
                  : p.ElementAfterRest,
                this.state.startLoc,
              ),
              !0)
            : !1;
        }
      },
      Hi = (a, t) => hasOwnProperty.call(a, t) && a[t];
    function Wi(a) {
      if (a == null) throw new Error(`Unexpected ${a} value.`);
      return a;
    }
    function jt(a) {
      if (!a) throw new Error("Assert fail");
    }
    var x = j`typescript`({
      AbstractMethodHasImplementation: ({ methodName: a }) =>
        `Method '${a}' cannot have an implementation because it is marked abstract.`,
      AbstractPropertyHasInitializer: ({ propertyName: a }) =>
        `Property '${a}' 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: a }) => `'declare' is not allowed in ${a}ters.`,
      DeclareClassFieldHasInitializer:
        "Initializers are not allowed in ambient contexts.",
      DeclareFunctionHasImplementation:
        "An implementation cannot be declared in ambient contexts.",
      DuplicateAccessibilityModifier: ({ modifier: a }) =>
        "Accessibility modifier already seen.",
      DuplicateModifier: ({ modifier: a }) => `Duplicate modifier: '${a}'.`,
      EmptyHeritageClauseType: ({ token: a }) => `'${a}' 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: a }) =>
        `'${a[0]}' modifier cannot be used with '${a[1]}' modifier.`,
      IndexSignatureHasAbstract:
        "Index signatures cannot have the 'abstract' modifier.",
      IndexSignatureHasAccessibility: ({ modifier: a }) =>
        `Index signatures cannot have an accessibility modifier ('${a}').`,
      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: a }) =>
        `'${a}' modifier cannot appear on a type member.`,
      InvalidModifierOnTypeParameter: ({ modifier: a }) =>
        `'${a}' modifier cannot appear on a type parameter.`,
      InvalidModifierOnTypeParameterPositions: ({ modifier: a }) =>
        `'${a}' modifier can only appear on a type parameter of a class, interface or type alias.`,
      InvalidModifiersOrder: ({ orderedModifiers: a }) =>
        `'${a[0]}' modifier must precede '${a[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.",
      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: a }) =>
        `Private elements cannot have an accessibility modifier ('${a}').`,
      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: a }) =>
        `Single type parameter ${a} should have a trailing comma. Example usage: <${a},>.`,
      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: a }) =>
        `Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got ${a}.`,
    });
    function Ji(a) {
      switch (a) {
        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;
      }
    }
    function $t(a) {
      return a === "private" || a === "public" || a === "protected";
    }
    function Xi(a) {
      return a === "in" || a === "out";
    }
    var Gi = (a) =>
      class extends a {
        constructor(...e) {
          super(...e),
            (this.tsParseInOutModifiers = this.tsParseModifiers.bind(this, {
              allowedModifiers: ["in", "out"],
              disallowedModifiers: [
                "const",
                "public",
                "private",
                "protected",
                "readonly",
                "declare",
                "abstract",
                "override",
              ],
              errorTemplate: x.InvalidModifierOnTypeParameter,
            })),
            (this.tsParseConstModifier = this.tsParseModifiers.bind(this, {
              allowedModifiers: ["const"],
              disallowedModifiers: ["in", "out"],
              errorTemplate: x.InvalidModifierOnTypeParameterPositions,
            })),
            (this.tsParseInOutConstModifiers = this.tsParseModifiers.bind(
              this,
              {
                allowedModifiers: ["in", "out", "const"],
                disallowedModifiers: [
                  "public",
                  "private",
                  "protected",
                  "readonly",
                  "declare",
                  "abstract",
                  "override",
                ],
                errorTemplate: x.InvalidModifierOnTypeParameter,
              },
            ));
        }
        getScopeHandler() {
          return ht;
        }
        tsIsIdentifier() {
          return w(this.state.type);
        }
        tsTokenCanFollowModifier() {
          return (
            (this.match(0) ||
              this.match(5) ||
              this.match(55) ||
              this.match(21) ||
              this.match(138) ||
              this.isLiteralPropertyName()) &&
            !this.hasPrecedingLineBreak()
          );
        }
        tsNextTokenCanFollowModifier() {
          return this.next(), this.tsTokenCanFollowModifier();
        }
        tsParseModifier(e, s) {
          if (
            !w(this.state.type) &&
            this.state.type !== 58 &&
            this.state.type !== 75
          )
            return;
          let i = this.state.value;
          if (e.includes(i)) {
            if (s && this.tsIsStartOfStaticBlocks()) return;
            if (this.tsTryParse(this.tsNextTokenCanFollowModifier.bind(this)))
              return i;
          }
        }
        tsParseModifiers(
          {
            allowedModifiers: e,
            disallowedModifiers: s,
            stopOnStartOfClassStaticBlock: i,
            errorTemplate: r = x.InvalidModifierOnTypeMember,
          },
          n,
        ) {
          let o = (c, l, u, f) => {
              l === u &&
                n[f] &&
                this.raise(x.InvalidModifiersOrder, c, {
                  orderedModifiers: [u, f],
                });
            },
            h = (c, l, u, f) => {
              ((n[u] && l === f) || (n[f] && l === u)) &&
                this.raise(x.IncompatibleModifiers, c, { modifiers: [u, f] });
            };
          for (;;) {
            let { startLoc: c } = this.state,
              l = this.tsParseModifier(e.concat(s ?? []), i);
            if (!l) break;
            $t(l)
              ? n.accessibility
                ? this.raise(x.DuplicateAccessibilityModifier, c, {
                    modifier: l,
                  })
                : (o(c, l, l, "override"),
                  o(c, l, l, "static"),
                  o(c, l, l, "readonly"),
                  (n.accessibility = l))
              : Xi(l)
                ? (n[l] && this.raise(x.DuplicateModifier, c, { modifier: l }),
                  (n[l] = !0),
                  o(c, l, "in", "out"))
                : (hasOwnProperty.call(n, l)
                    ? this.raise(x.DuplicateModifier, c, { modifier: l })
                    : (o(c, l, "static", "readonly"),
                      o(c, l, "static", "override"),
                      o(c, l, "override", "readonly"),
                      o(c, l, "abstract", "override"),
                      h(c, l, "declare", "override"),
                      h(c, l, "static", "abstract")),
                  (n[l] = !0)),
              s != null && s.includes(l) && this.raise(r, c, { modifier: l });
          }
        }
        tsIsListTerminator(e) {
          switch (e) {
            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(e, s) {
          let i = [];
          for (; !this.tsIsListTerminator(e); ) i.push(s());
          return i;
        }
        tsParseDelimitedList(e, s, i) {
          return Wi(this.tsParseDelimitedListWorker(e, s, !0, i));
        }
        tsParseDelimitedListWorker(e, s, i, r) {
          let n = [],
            o = -1;
          for (; !this.tsIsListTerminator(e); ) {
            o = -1;
            let h = s();
            if (h == null) return;
            if ((n.push(h), this.eat(12))) {
              o = this.state.lastTokStartLoc.index;
              continue;
            }
            if (this.tsIsListTerminator(e)) break;
            i && this.expect(12);
            return;
          }
          return r && (r.value = o), n;
        }
        tsParseBracketedList(e, s, i, r, n) {
          r || (i ? this.expect(0) : this.expect(47));
          let o = this.tsParseDelimitedList(e, s, n);
          return i ? this.expect(3) : this.expect(48), o;
        }
        tsParseImportType() {
          let e = this.startNode();
          return (
            this.expect(83),
            this.expect(10),
            this.match(133) ||
              this.raise(x.UnsupportedImportTypeArgument, this.state.startLoc),
            (e.argument = super.parseExprAtom()),
            (this.hasPlugin("importAttributes") ||
              this.hasPlugin("importAssertions")) &&
              (e.options = null),
            this.eat(12) &&
              (this.expectImportAttributesPlugin(),
              this.match(11) ||
                ((e.options = super.parseMaybeAssignAllowIn()), this.eat(12))),
            this.expect(11),
            this.eat(16) && (e.qualifier = this.tsParseEntityName()),
            this.match(47) && (e.typeParameters = this.tsParseTypeArguments()),
            this.finishNode(e, "TSImportType")
          );
        }
        tsParseEntityName(e = !0) {
          let s = this.parseIdentifier(e);
          for (; this.eat(16); ) {
            let i = this.startNodeAtNode(s);
            (i.left = s),
              (i.right = this.parseIdentifier(e)),
              (s = this.finishNode(i, "TSQualifiedName"));
          }
          return s;
        }
        tsParseTypeReference() {
          let e = this.startNode();
          return (
            (e.typeName = this.tsParseEntityName()),
            !this.hasPrecedingLineBreak() &&
              this.match(47) &&
              (e.typeParameters = this.tsParseTypeArguments()),
            this.finishNode(e, "TSTypeReference")
          );
        }
        tsParseThisTypePredicate(e) {
          this.next();
          let s = this.startNodeAtNode(e);
          return (
            (s.parameterName = e),
            (s.typeAnnotation = this.tsParseTypeAnnotation(!1)),
            (s.asserts = !1),
            this.finishNode(s, "TSTypePredicate")
          );
        }
        tsParseThisTypeNode() {
          let e = this.startNode();
          return this.next(), this.finishNode(e, "TSThisType");
        }
        tsParseTypeQuery() {
          let e = this.startNode();
          return (
            this.expect(87),
            this.match(83)
              ? (e.exprName = this.tsParseImportType())
              : (e.exprName = this.tsParseEntityName()),
            !this.hasPrecedingLineBreak() &&
              this.match(47) &&
              (e.typeParameters = this.tsParseTypeArguments()),
            this.finishNode(e, "TSTypeQuery")
          );
        }
        tsParseTypeParameter(e) {
          let s = this.startNode();
          return (
            e(s),
            (s.name = this.tsParseTypeParameterName()),
            (s.constraint = this.tsEatThenParseType(81)),
            (s.default = this.tsEatThenParseType(29)),
            this.finishNode(s, "TSTypeParameter")
          );
        }
        tsTryParseTypeParameters(e) {
          if (this.match(47)) return this.tsParseTypeParameters(e);
        }
        tsParseTypeParameters(e) {
          let s = this.startNode();
          this.match(47) || this.match(142) ? this.next() : this.unexpected();
          let i = { value: -1 };
          return (
            (s.params = this.tsParseBracketedList(
              "TypeParametersOrArguments",
              this.tsParseTypeParameter.bind(this, e),
              !1,
              !0,
              i,
            )),
            s.params.length === 0 && this.raise(x.EmptyTypeParameters, s),
            i.value !== -1 && this.addExtra(s, "trailingComma", i.value),
            this.finishNode(s, "TSTypeParameterDeclaration")
          );
        }
        tsFillSignature(e, s) {
          let i = e === 19,
            r = "parameters",
            n = "typeAnnotation";
          (s.typeParameters = this.tsTryParseTypeParameters(
            this.tsParseConstModifier,
          )),
            this.expect(10),
            (s[r] = this.tsParseBindingListForSignature()),
            i
              ? (s[n] = this.tsParseTypeOrTypePredicateAnnotation(e))
              : this.match(e) &&
                (s[n] = this.tsParseTypeOrTypePredicateAnnotation(e));
        }
        tsParseBindingListForSignature() {
          let e = super.parseBindingList(11, 41, 2);
          for (let s of e) {
            let { type: i } = s;
            (i === "AssignmentPattern" || i === "TSParameterProperty") &&
              this.raise(x.UnsupportedSignatureParameterKind, s, { type: i });
          }
          return e;
        }
        tsParseTypeMemberSemicolon() {
          !this.eat(12) && !this.isLineTerminator() && this.expect(13);
        }
        tsParseSignatureMember(e, s) {
          return (
            this.tsFillSignature(14, s),
            this.tsParseTypeMemberSemicolon(),
            this.finishNode(s, e)
          );
        }
        tsIsUnambiguouslyIndexSignature() {
          return (
            this.next(), w(this.state.type) ? (this.next(), this.match(14)) : !1
          );
        }
        tsTryParseIndexSignature(e) {
          if (
            !(
              this.match(0) &&
              this.tsLookAhead(this.tsIsUnambiguouslyIndexSignature.bind(this))
            )
          )
            return;
          this.expect(0);
          let s = this.parseIdentifier();
          (s.typeAnnotation = this.tsParseTypeAnnotation()),
            this.resetEndLocation(s),
            this.expect(3),
            (e.parameters = [s]);
          let i = this.tsTryParseTypeAnnotation();
          return (
            i && (e.typeAnnotation = i),
            this.tsParseTypeMemberSemicolon(),
            this.finishNode(e, "TSIndexSignature")
          );
        }
        tsParsePropertyOrMethodSignature(e, s) {
          this.eat(17) && (e.optional = !0);
          let i = e;
          if (this.match(10) || this.match(47)) {
            s && this.raise(x.ReadonlyForMethodSignature, e);
            let r = i;
            r.kind &&
              this.match(47) &&
              this.raise(
                x.AccesorCannotHaveTypeParameters,
                this.state.curPosition(),
              ),
              this.tsFillSignature(14, r),
              this.tsParseTypeMemberSemicolon();
            let n = "parameters",
              o = "typeAnnotation";
            if (r.kind === "get")
              r[n].length > 0 &&
                (this.raise(p.BadGetterArity, this.state.curPosition()),
                this.isThisParam(r[n][0]) &&
                  this.raise(
                    x.AccesorCannotDeclareThisParameter,
                    this.state.curPosition(),
                  ));
            else if (r.kind === "set") {
              if (r[n].length !== 1)
                this.raise(p.BadSetterArity, this.state.curPosition());
              else {
                let h = r[n][0];
                this.isThisParam(h) &&
                  this.raise(
                    x.AccesorCannotDeclareThisParameter,
                    this.state.curPosition(),
                  ),
                  h.type === "Identifier" &&
                    h.optional &&
                    this.raise(
                      x.SetAccesorCannotHaveOptionalParameter,
                      this.state.curPosition(),
                    ),
                  h.type === "RestElement" &&
                    this.raise(
                      x.SetAccesorCannotHaveRestParameter,
                      this.state.curPosition(),
                    );
              }
              r[o] && this.raise(x.SetAccesorCannotHaveReturnType, r[o]);
            } else r.kind = "method";
            return this.finishNode(r, "TSMethodSignature");
          } else {
            let r = i;
            s && (r.readonly = !0);
            let n = this.tsTryParseTypeAnnotation();
            return (
              n && (r.typeAnnotation = n),
              this.tsParseTypeMemberSemicolon(),
              this.finishNode(r, "TSPropertySignature")
            );
          }
        }
        tsParseTypeMember() {
          let e = this.startNode();
          if (this.match(10) || this.match(47))
            return this.tsParseSignatureMember("TSCallSignatureDeclaration", e);
          if (this.match(77)) {
            let i = this.startNode();
            return (
              this.next(),
              this.match(10) || this.match(47)
                ? this.tsParseSignatureMember(
                    "TSConstructSignatureDeclaration",
                    e,
                  )
                : ((e.key = this.createIdentifier(i, "new")),
                  this.tsParsePropertyOrMethodSignature(e, !1))
            );
          }
          this.tsParseModifiers(
            {
              allowedModifiers: ["readonly"],
              disallowedModifiers: [
                "declare",
                "abstract",
                "private",
                "protected",
                "public",
                "static",
                "override",
              ],
            },
            e,
          );
          let s = this.tsTryParseIndexSignature(e);
          return (
            s ||
            (super.parsePropertyName(e),
            !e.computed &&
              e.key.type === "Identifier" &&
              (e.key.name === "get" || e.key.name === "set") &&
              this.tsTokenCanFollowModifier() &&
              ((e.kind = e.key.name), super.parsePropertyName(e)),
            this.tsParsePropertyOrMethodSignature(e, !!e.readonly))
          );
        }
        tsParseTypeLiteral() {
          let e = this.startNode();
          return (
            (e.members = this.tsParseObjectTypeMembers()),
            this.finishNode(e, "TSTypeLiteral")
          );
        }
        tsParseObjectTypeMembers() {
          this.expect(5);
          let e = this.tsParseList(
            "TypeMembers",
            this.tsParseTypeMember.bind(this),
          );
          return this.expect(8), e;
        }
        tsIsStartOfMappedType() {
          return (
            this.next(),
            this.eat(53)
              ? this.isContextual(122)
              : (this.isContextual(122) && this.next(),
                !this.match(0) || (this.next(), !this.tsIsIdentifier())
                  ? !1
                  : (this.next(), this.match(58)))
          );
        }
        tsParseMappedTypeParameter() {
          let e = this.startNode();
          return (
            (e.name = this.tsParseTypeParameterName()),
            (e.constraint = this.tsExpectThenParseType(58)),
            this.finishNode(e, "TSTypeParameter")
          );
        }
        tsParseMappedType() {
          let e = this.startNode();
          return (
            this.expect(5),
            this.match(53)
              ? ((e.readonly = this.state.value),
                this.next(),
                this.expectContextual(122))
              : this.eatContextual(122) && (e.readonly = !0),
            this.expect(0),
            (e.typeParameter = this.tsParseMappedTypeParameter()),
            (e.nameType = this.eatContextual(93) ? this.tsParseType() : null),
            this.expect(3),
            this.match(53)
              ? ((e.optional = this.state.value), this.next(), this.expect(17))
              : this.eat(17) && (e.optional = !0),
            (e.typeAnnotation = this.tsTryParseType()),
            this.semicolon(),
            this.expect(8),
            this.finishNode(e, "TSMappedType")
          );
        }
        tsParseTupleType() {
          let e = this.startNode();
          e.elementTypes = this.tsParseBracketedList(
            "TupleElementTypes",
            this.tsParseTupleElementType.bind(this),
            !0,
            !1,
          );
          let s = !1;
          return (
            e.elementTypes.forEach((i) => {
              let { type: r } = i;
              s &&
                r !== "TSRestType" &&
                r !== "TSOptionalType" &&
                !(r === "TSNamedTupleMember" && i.optional) &&
                this.raise(x.OptionalTypeBeforeRequired, i),
                s ||
                  (s =
                    (r === "TSNamedTupleMember" && i.optional) ||
                    r === "TSOptionalType");
            }),
            this.finishNode(e, "TSTupleType")
          );
        }
        tsParseTupleElementType() {
          let { startLoc: e } = this.state,
            s = this.eat(21),
            i,
            r,
            n,
            o,
            c = M(this.state.type) ? this.lookaheadCharCode() : null;
          if (c === 58)
            (i = !0),
              (n = !1),
              (r = this.parseIdentifier(!0)),
              this.expect(14),
              (o = this.tsParseType());
          else if (c === 63) {
            n = !0;
            let l = this.state.startLoc,
              u = this.state.value,
              f = this.tsParseNonArrayType();
            this.lookaheadCharCode() === 58
              ? ((i = !0),
                (r = this.createIdentifier(this.startNodeAt(l), u)),
                this.expect(17),
                this.expect(14),
                (o = this.tsParseType()))
              : ((i = !1), (o = f), this.expect(17));
          } else
            (o = this.tsParseType()), (n = this.eat(17)), (i = this.eat(14));
          if (i) {
            let l;
            r
              ? ((l = this.startNodeAtNode(r)),
                (l.optional = n),
                (l.label = r),
                (l.elementType = o),
                this.eat(17) &&
                  ((l.optional = !0),
                  this.raise(
                    x.TupleOptionalAfterType,
                    this.state.lastTokStartLoc,
                  )))
              : ((l = this.startNodeAtNode(o)),
                (l.optional = n),
                this.raise(x.InvalidTupleMemberLabel, o),
                (l.label = o),
                (l.elementType = this.tsParseType())),
              (o = this.finishNode(l, "TSNamedTupleMember"));
          } else if (n) {
            let l = this.startNodeAtNode(o);
            (l.typeAnnotation = o), (o = this.finishNode(l, "TSOptionalType"));
          }
          if (s) {
            let l = this.startNodeAt(e);
            (l.typeAnnotation = o), (o = this.finishNode(l, "TSRestType"));
          }
          return o;
        }
        tsParseParenthesizedType() {
          let e = this.startNode();
          return (
            this.expect(10),
            (e.typeAnnotation = this.tsParseType()),
            this.expect(11),
            this.finishNode(e, "TSParenthesizedType")
          );
        }
        tsParseFunctionOrConstructorType(e, s) {
          let i = this.startNode();
          return (
            e === "TSConstructorType" &&
              ((i.abstract = !!s), s && this.next(), this.next()),
            this.tsInAllowConditionalTypesContext(() =>
              this.tsFillSignature(19, i),
            ),
            this.finishNode(i, e)
          );
        }
        tsParseLiteralTypeNode() {
          let e = this.startNode();
          switch (this.state.type) {
            case 134:
            case 135:
            case 133:
            case 85:
            case 86:
              e.literal = super.parseExprAtom();
              break;
            default:
              this.unexpected();
          }
          return this.finishNode(e, "TSLiteralType");
        }
        tsParseTemplateLiteralType() {
          let e = this.startNode();
          return (
            (e.literal = super.parseTemplate(!1)),
            this.finishNode(e, "TSLiteralType")
          );
        }
        parseTemplateSubstitution() {
          return this.state.inType
            ? this.tsParseType()
            : super.parseTemplateSubstitution();
        }
        tsParseThisTypeOrThisTypePredicate() {
          let e = this.tsParseThisTypeNode();
          return this.isContextual(116) && !this.hasPrecedingLineBreak()
            ? this.tsParseThisTypePredicate(e)
            : e;
        }
        tsParseNonArrayType() {
          switch (this.state.type) {
            case 133:
            case 134:
            case 135:
            case 85:
            case 86:
              return this.tsParseLiteralTypeNode();
            case 53:
              if (this.state.value === "-") {
                let e = this.startNode(),
                  s = this.lookahead();
                return (
                  s.type !== 134 && s.type !== 135 && this.unexpected(),
                  (e.literal = this.parseMaybeUnary()),
                  this.finishNode(e, "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: {
              let { type: e } = this.state;
              if (w(e) || e === 88 || e === 84) {
                let s =
                  e === 88
                    ? "TSVoidKeyword"
                    : e === 84
                      ? "TSNullKeyword"
                      : Ji(this.state.value);
                if (s !== void 0 && this.lookaheadCharCode() !== 46) {
                  let i = this.startNode();
                  return this.next(), this.finishNode(i, s);
                }
                return this.tsParseTypeReference();
              }
            }
          }
          this.unexpected();
        }
        tsParseArrayTypeOrHigher() {
          let e = this.tsParseNonArrayType();
          for (; !this.hasPrecedingLineBreak() && this.eat(0); )
            if (this.match(3)) {
              let s = this.startNodeAtNode(e);
              (s.elementType = e),
                this.expect(3),
                (e = this.finishNode(s, "TSArrayType"));
            } else {
              let s = this.startNodeAtNode(e);
              (s.objectType = e),
                (s.indexType = this.tsParseType()),
                this.expect(3),
                (e = this.finishNode(s, "TSIndexedAccessType"));
            }
          return e;
        }
        tsParseTypeOperator() {
          let e = this.startNode(),
            s = this.state.value;
          return (
            this.next(),
            (e.operator = s),
            (e.typeAnnotation = this.tsParseTypeOperatorOrHigher()),
            s === "readonly" && this.tsCheckTypeAnnotationForReadOnly(e),
            this.finishNode(e, "TSTypeOperator")
          );
        }
        tsCheckTypeAnnotationForReadOnly(e) {
          switch (e.typeAnnotation.type) {
            case "TSTupleType":
            case "TSArrayType":
              return;
            default:
              this.raise(x.UnexpectedReadonly, e);
          }
        }
        tsParseInferType() {
          let e = this.startNode();
          this.expectContextual(115);
          let s = this.startNode();
          return (
            (s.name = this.tsParseTypeParameterName()),
            (s.constraint = this.tsTryParse(() =>
              this.tsParseConstraintForInferType(),
            )),
            (e.typeParameter = this.finishNode(s, "TSTypeParameter")),
            this.finishNode(e, "TSInferType")
          );
        }
        tsParseConstraintForInferType() {
          if (this.eat(81)) {
            let e = this.tsInDisallowConditionalTypesContext(() =>
              this.tsParseType(),
            );
            if (this.state.inDisallowConditionalTypesContext || !this.match(17))
              return e;
          }
        }
        tsParseTypeOperatorOrHigher() {
          return di(this.state.type) && !this.state.containsEsc
            ? this.tsParseTypeOperator()
            : this.isContextual(115)
              ? this.tsParseInferType()
              : this.tsInAllowConditionalTypesContext(() =>
                  this.tsParseArrayTypeOrHigher(),
                );
        }
        tsParseUnionOrIntersectionType(e, s, i) {
          let r = this.startNode(),
            n = this.eat(i),
            o = [];
          do o.push(s());
          while (this.eat(i));
          return o.length === 1 && !n
            ? o[0]
            : ((r.types = o), this.finishNode(r, e));
        }
        tsParseIntersectionTypeOrHigher() {
          return this.tsParseUnionOrIntersectionType(
            "TSIntersectionType",
            this.tsParseTypeOperatorOrHigher.bind(this),
            45,
          );
        }
        tsParseUnionTypeOrHigher() {
          return this.tsParseUnionOrIntersectionType(
            "TSUnionType",
            this.tsParseIntersectionTypeOrHigher.bind(this),
            43,
          );
        }
        tsIsStartOfFunctionType() {
          return this.match(47)
            ? !0
            : this.match(10) &&
                this.tsLookAhead(
                  this.tsIsUnambiguouslyStartOfFunctionType.bind(this),
                );
        }
        tsSkipParameterStart() {
          if (w(this.state.type) || this.match(78)) return this.next(), !0;
          if (this.match(5)) {
            let { errors: e } = this.state,
              s = e.length;
            try {
              return this.parseObjectLike(8, !0), e.length === s;
            } catch {
              return !1;
            }
          }
          if (this.match(0)) {
            this.next();
            let { errors: e } = this.state,
              s = e.length;
            try {
              return super.parseBindingList(3, 93, 1), e.length === s;
            } catch {
              return !1;
            }
          }
          return !1;
        }
        tsIsUnambiguouslyStartOfFunctionType() {
          return (
            this.next(),
            !!(
              this.match(11) ||
              this.match(21) ||
              (this.tsSkipParameterStart() &&
                (this.match(14) ||
                  this.match(12) ||
                  this.match(17) ||
                  this.match(29) ||
                  (this.match(11) && (this.next(), this.match(19)))))
            )
          );
        }
        tsParseTypeOrTypePredicateAnnotation(e) {
          return this.tsInType(() => {
            let s = this.startNode();
            this.expect(e);
            let i = this.startNode(),
              r = !!this.tsTryParse(
                this.tsParseTypePredicateAsserts.bind(this),
              );
            if (r && this.match(78)) {
              let h = this.tsParseThisTypeOrThisTypePredicate();
              return (
                h.type === "TSThisType"
                  ? ((i.parameterName = h),
                    (i.asserts = !0),
                    (i.typeAnnotation = null),
                    (h = this.finishNode(i, "TSTypePredicate")))
                  : (this.resetStartLocationFromNode(h, i), (h.asserts = !0)),
                (s.typeAnnotation = h),
                this.finishNode(s, "TSTypeAnnotation")
              );
            }
            let n =
              this.tsIsIdentifier() &&
              this.tsTryParse(this.tsParseTypePredicatePrefix.bind(this));
            if (!n)
              return r
                ? ((i.parameterName = this.parseIdentifier()),
                  (i.asserts = r),
                  (i.typeAnnotation = null),
                  (s.typeAnnotation = this.finishNode(i, "TSTypePredicate")),
                  this.finishNode(s, "TSTypeAnnotation"))
                : this.tsParseTypeAnnotation(!1, s);
            let o = this.tsParseTypeAnnotation(!1);
            return (
              (i.parameterName = n),
              (i.typeAnnotation = o),
              (i.asserts = r),
              (s.typeAnnotation = this.finishNode(i, "TSTypePredicate")),
              this.finishNode(s, "TSTypeAnnotation")
            );
          });
        }
        tsTryParseTypeOrTypePredicateAnnotation() {
          if (this.match(14))
            return this.tsParseTypeOrTypePredicateAnnotation(14);
        }
        tsTryParseTypeAnnotation() {
          if (this.match(14)) return this.tsParseTypeAnnotation();
        }
        tsTryParseType() {
          return this.tsEatThenParseType(14);
        }
        tsParseTypePredicatePrefix() {
          let e = this.parseIdentifier();
          if (this.isContextual(116) && !this.hasPrecedingLineBreak())
            return this.next(), e;
        }
        tsParseTypePredicateAsserts() {
          if (this.state.type !== 109) return !1;
          let e = this.state.containsEsc;
          return (
            this.next(),
            !w(this.state.type) && !this.match(78)
              ? !1
              : (e &&
                  this.raise(
                    p.InvalidEscapedReservedWord,
                    this.state.lastTokStartLoc,
                    { reservedWord: "asserts" },
                  ),
                !0)
          );
        }
        tsParseTypeAnnotation(e = !0, s = this.startNode()) {
          return (
            this.tsInType(() => {
              e && this.expect(14), (s.typeAnnotation = this.tsParseType());
            }),
            this.finishNode(s, "TSTypeAnnotation")
          );
        }
        tsParseType() {
          jt(this.state.inType);
          let e = this.tsParseNonConditionalType();
          if (
            this.state.inDisallowConditionalTypesContext ||
            this.hasPrecedingLineBreak() ||
            !this.eat(81)
          )
            return e;
          let s = this.startNodeAtNode(e);
          return (
            (s.checkType = e),
            (s.extendsType = this.tsInDisallowConditionalTypesContext(() =>
              this.tsParseNonConditionalType(),
            )),
            this.expect(17),
            (s.trueType = this.tsInAllowConditionalTypesContext(() =>
              this.tsParseType(),
            )),
            this.expect(14),
            (s.falseType = this.tsInAllowConditionalTypesContext(() =>
              this.tsParseType(),
            )),
            this.finishNode(s, "TSConditionalType")
          );
        }
        isAbstractConstructorSignature() {
          return this.isContextual(124) && this.lookahead().type === 77;
        }
        tsParseNonConditionalType() {
          return this.tsIsStartOfFunctionType()
            ? this.tsParseFunctionOrConstructorType("TSFunctionType")
            : this.match(77)
              ? this.tsParseFunctionOrConstructorType("TSConstructorType")
              : this.isAbstractConstructorSignature()
                ? this.tsParseFunctionOrConstructorType("TSConstructorType", !0)
                : this.tsParseUnionTypeOrHigher();
        }
        tsParseTypeAssertion() {
          this.getPluginOption("typescript", "disallowAmbiguousJSXLike") &&
            this.raise(x.ReservedTypeAssertion, this.state.startLoc);
          let e = this.startNode();
          return (
            (e.typeAnnotation = this.tsInType(
              () => (
                this.next(),
                this.match(75)
                  ? this.tsParseTypeReference()
                  : this.tsParseType()
              ),
            )),
            this.expect(48),
            (e.expression = this.parseMaybeUnary()),
            this.finishNode(e, "TSTypeAssertion")
          );
        }
        tsParseHeritageClause(e) {
          let s = this.state.startLoc,
            i = this.tsParseDelimitedList("HeritageClauseElement", () => {
              let r = this.startNode();
              return (
                (r.expression = this.tsParseEntityName()),
                this.match(47) &&
                  (r.typeParameters = this.tsParseTypeArguments()),
                this.finishNode(r, "TSExpressionWithTypeArguments")
              );
            });
          return (
            i.length || this.raise(x.EmptyHeritageClauseType, s, { token: e }),
            i
          );
        }
        tsParseInterfaceDeclaration(e, s = {}) {
          if (this.hasFollowingLineBreak()) return null;
          this.expectContextual(129),
            s.declare && (e.declare = !0),
            w(this.state.type)
              ? ((e.id = this.parseIdentifier()),
                this.checkIdentifier(e.id, 130))
              : ((e.id = null),
                this.raise(x.MissingInterfaceName, this.state.startLoc)),
            (e.typeParameters = this.tsTryParseTypeParameters(
              this.tsParseInOutConstModifiers,
            )),
            this.eat(81) && (e.extends = this.tsParseHeritageClause("extends"));
          let i = this.startNode();
          return (
            (i.body = this.tsInType(this.tsParseObjectTypeMembers.bind(this))),
            (e.body = this.finishNode(i, "TSInterfaceBody")),
            this.finishNode(e, "TSInterfaceDeclaration")
          );
        }
        tsParseTypeAliasDeclaration(e) {
          return (
            (e.id = this.parseIdentifier()),
            this.checkIdentifier(e.id, 2),
            (e.typeAnnotation = this.tsInType(() => {
              if (
                ((e.typeParameters = this.tsTryParseTypeParameters(
                  this.tsParseInOutModifiers,
                )),
                this.expect(29),
                this.isContextual(114) && this.lookahead().type !== 16)
              ) {
                let s = this.startNode();
                return this.next(), this.finishNode(s, "TSIntrinsicKeyword");
              }
              return this.tsParseType();
            })),
            this.semicolon(),
            this.finishNode(e, "TSTypeAliasDeclaration")
          );
        }
        tsInNoContext(e) {
          let s = this.state.context;
          this.state.context = [s[0]];
          try {
            return e();
          } finally {
            this.state.context = s;
          }
        }
        tsInType(e) {
          let s = this.state.inType;
          this.state.inType = !0;
          try {
            return e();
          } finally {
            this.state.inType = s;
          }
        }
        tsInDisallowConditionalTypesContext(e) {
          let s = this.state.inDisallowConditionalTypesContext;
          this.state.inDisallowConditionalTypesContext = !0;
          try {
            return e();
          } finally {
            this.state.inDisallowConditionalTypesContext = s;
          }
        }
        tsInAllowConditionalTypesContext(e) {
          let s = this.state.inDisallowConditionalTypesContext;
          this.state.inDisallowConditionalTypesContext = !1;
          try {
            return e();
          } finally {
            this.state.inDisallowConditionalTypesContext = s;
          }
        }
        tsEatThenParseType(e) {
          if (this.match(e)) return this.tsNextThenParseType();
        }
        tsExpectThenParseType(e) {
          return this.tsInType(() => (this.expect(e), this.tsParseType()));
        }
        tsNextThenParseType() {
          return this.tsInType(() => (this.next(), this.tsParseType()));
        }
        tsParseEnumMember() {
          let e = this.startNode();
          return (
            (e.id = this.match(133)
              ? super.parseStringLiteral(this.state.value)
              : this.parseIdentifier(!0)),
            this.eat(29) && (e.initializer = super.parseMaybeAssignAllowIn()),
            this.finishNode(e, "TSEnumMember")
          );
        }
        tsParseEnumDeclaration(e, s = {}) {
          return (
            s.const && (e.const = !0),
            s.declare && (e.declare = !0),
            this.expectContextual(126),
            (e.id = this.parseIdentifier()),
            this.checkIdentifier(e.id, e.const ? 8971 : 8459),
            this.expect(5),
            (e.members = this.tsParseDelimitedList(
              "EnumMembers",
              this.tsParseEnumMember.bind(this),
            )),
            this.expect(8),
            this.finishNode(e, "TSEnumDeclaration")
          );
        }
        tsParseModuleBlock() {
          let e = this.startNode();
          return (
            this.scope.enter(0),
            this.expect(5),
            super.parseBlockOrModuleBlockBody((e.body = []), void 0, !0, 8),
            this.scope.exit(),
            this.finishNode(e, "TSModuleBlock")
          );
        }
        tsParseModuleOrNamespaceDeclaration(e, s = !1) {
          if (
            ((e.id = this.parseIdentifier()),
            s || this.checkIdentifier(e.id, 1024),
            this.eat(16))
          ) {
            let i = this.startNode();
            this.tsParseModuleOrNamespaceDeclaration(i, !0), (e.body = i);
          } else
            this.scope.enter(256),
              this.prodParam.enter(0),
              (e.body = this.tsParseModuleBlock()),
              this.prodParam.exit(),
              this.scope.exit();
          return this.finishNode(e, "TSModuleDeclaration");
        }
        tsParseAmbientExternalModuleDeclaration(e) {
          return (
            this.isContextual(112)
              ? ((e.global = !0), (e.id = this.parseIdentifier()))
              : this.match(133)
                ? (e.id = super.parseStringLiteral(this.state.value))
                : this.unexpected(),
            this.match(5)
              ? (this.scope.enter(256),
                this.prodParam.enter(0),
                (e.body = this.tsParseModuleBlock()),
                this.prodParam.exit(),
                this.scope.exit())
              : this.semicolon(),
            this.finishNode(e, "TSModuleDeclaration")
          );
        }
        tsParseImportEqualsDeclaration(e, s, i) {
          (e.isExport = i || !1),
            (e.id = s || this.parseIdentifier()),
            this.checkIdentifier(e.id, 4096),
            this.expect(29);
          let r = this.tsParseModuleReference();
          return (
            e.importKind === "type" &&
              r.type !== "TSExternalModuleReference" &&
              this.raise(x.ImportAliasHasImportType, r),
            (e.moduleReference = r),
            this.semicolon(),
            this.finishNode(e, "TSImportEqualsDeclaration")
          );
        }
        tsIsExternalModuleReference() {
          return this.isContextual(119) && this.lookaheadCharCode() === 40;
        }
        tsParseModuleReference() {
          return this.tsIsExternalModuleReference()
            ? this.tsParseExternalModuleReference()
            : this.tsParseEntityName(!1);
        }
        tsParseExternalModuleReference() {
          let e = this.startNode();
          return (
            this.expectContextual(119),
            this.expect(10),
            this.match(133) || this.unexpected(),
            (e.expression = super.parseExprAtom()),
            this.expect(11),
            (this.sawUnambiguousESM = !0),
            this.finishNode(e, "TSExternalModuleReference")
          );
        }
        tsLookAhead(e) {
          let s = this.state.clone(),
            i = e();
          return (this.state = s), i;
        }
        tsTryParseAndCatch(e) {
          let s = this.tryParse((i) => e() || i());
          if (!(s.aborted || !s.node))
            return s.error && (this.state = s.failState), s.node;
        }
        tsTryParse(e) {
          let s = this.state.clone(),
            i = e();
          if (i !== void 0 && i !== !1) return i;
          this.state = s;
        }
        tsTryParseDeclare(e) {
          if (this.isLineTerminator()) return;
          let s = this.state.type,
            i;
          return (
            this.isContextual(100) && ((s = 74), (i = "let")),
            this.tsInAmbientContext(() => {
              switch (s) {
                case 68:
                  return (
                    (e.declare = !0), super.parseFunctionStatement(e, !1, !1)
                  );
                case 80:
                  return (e.declare = !0), this.parseClass(e, !0, !1);
                case 126:
                  return this.tsParseEnumDeclaration(e, { declare: !0 });
                case 112:
                  return this.tsParseAmbientExternalModuleDeclaration(e);
                case 75:
                case 74:
                  return !this.match(75) || !this.isLookaheadContextual("enum")
                    ? ((e.declare = !0),
                      this.parseVarStatement(e, i || this.state.value, !0))
                    : (this.expect(75),
                      this.tsParseEnumDeclaration(e, {
                        const: !0,
                        declare: !0,
                      }));
                case 129: {
                  let r = this.tsParseInterfaceDeclaration(e, { declare: !0 });
                  if (r) return r;
                }
                default:
                  if (w(s))
                    return this.tsParseDeclaration(
                      e,
                      this.state.value,
                      !0,
                      null,
                    );
              }
            })
          );
        }
        tsTryParseExportDeclaration() {
          return this.tsParseDeclaration(
            this.startNode(),
            this.state.value,
            !0,
            null,
          );
        }
        tsParseExpressionStatement(e, s, i) {
          switch (s.name) {
            case "declare": {
              let r = this.tsTryParseDeclare(e);
              return r && (r.declare = !0), r;
            }
            case "global":
              if (this.match(5)) {
                this.scope.enter(256), this.prodParam.enter(0);
                let r = e;
                return (
                  (r.global = !0),
                  (r.id = s),
                  (r.body = this.tsParseModuleBlock()),
                  this.scope.exit(),
                  this.prodParam.exit(),
                  this.finishNode(r, "TSModuleDeclaration")
                );
              }
              break;
            default:
              return this.tsParseDeclaration(e, s.name, !1, i);
          }
        }
        tsParseDeclaration(e, s, i, r) {
          switch (s) {
            case "abstract":
              if (
                this.tsCheckLineTerminator(i) &&
                (this.match(80) || w(this.state.type))
              )
                return this.tsParseAbstractDeclaration(e, r);
              break;
            case "module":
              if (this.tsCheckLineTerminator(i)) {
                if (this.match(133))
                  return this.tsParseAmbientExternalModuleDeclaration(e);
                if (w(this.state.type))
                  return this.tsParseModuleOrNamespaceDeclaration(e);
              }
              break;
            case "namespace":
              if (this.tsCheckLineTerminator(i) && w(this.state.type))
                return this.tsParseModuleOrNamespaceDeclaration(e);
              break;
            case "type":
              if (this.tsCheckLineTerminator(i) && w(this.state.type))
                return this.tsParseTypeAliasDeclaration(e);
              break;
          }
        }
        tsCheckLineTerminator(e) {
          return e
            ? this.hasFollowingLineBreak()
              ? !1
              : (this.next(), !0)
            : !this.isLineTerminator();
        }
        tsTryParseGenericAsyncArrowFunction(e) {
          if (!this.match(47)) return;
          let s = this.state.maybeInArrowParameters;
          this.state.maybeInArrowParameters = !0;
          let i = this.tsTryParseAndCatch(() => {
            let r = this.startNodeAt(e);
            return (
              (r.typeParameters = this.tsParseTypeParameters(
                this.tsParseConstModifier,
              )),
              super.parseFunctionParams(r),
              (r.returnType = this.tsTryParseTypeOrTypePredicateAnnotation()),
              this.expect(19),
              r
            );
          });
          if (((this.state.maybeInArrowParameters = s), !!i))
            return super.parseArrowExpression(i, null, !0);
        }
        tsParseTypeArgumentsInExpression() {
          if (this.reScan_lt() === 47) return this.tsParseTypeArguments();
        }
        tsParseTypeArguments() {
          let e = this.startNode();
          return (
            (e.params = this.tsInType(() =>
              this.tsInNoContext(
                () => (
                  this.expect(47),
                  this.tsParseDelimitedList(
                    "TypeParametersOrArguments",
                    this.tsParseType.bind(this),
                  )
                ),
              ),
            )),
            e.params.length === 0
              ? this.raise(x.EmptyTypeArguments, e)
              : !this.state.inType &&
                this.curContext() === C.brace &&
                this.reScan_lt_gt(),
            this.expect(48),
            this.finishNode(e, "TSTypeParameterInstantiation")
          );
        }
        tsIsDeclarationStart() {
          return mi(this.state.type);
        }
        isExportDefaultSpecifier() {
          return this.tsIsDeclarationStart()
            ? !1
            : super.isExportDefaultSpecifier();
        }
        parseAssignableListItem(e, s) {
          let i = this.state.startLoc,
            r = {};
          this.tsParseModifiers(
            {
              allowedModifiers: [
                "public",
                "private",
                "protected",
                "override",
                "readonly",
              ],
            },
            r,
          );
          let n = r.accessibility,
            o = r.override,
            h = r.readonly;
          !(e & 4) &&
            (n || h || o) &&
            this.raise(x.UnexpectedParameterModifier, i);
          let c = this.parseMaybeDefault();
          this.parseAssignableListItemTypes(c, e);
          let l = this.parseMaybeDefault(c.loc.start, c);
          if (n || h || o) {
            let u = this.startNodeAt(i);
            return (
              s.length && (u.decorators = s),
              n && (u.accessibility = n),
              h && (u.readonly = h),
              o && (u.override = o),
              l.type !== "Identifier" &&
                l.type !== "AssignmentPattern" &&
                this.raise(x.UnsupportedParameterPropertyKind, u),
              (u.parameter = l),
              this.finishNode(u, "TSParameterProperty")
            );
          }
          return s.length && (c.decorators = s), l;
        }
        isSimpleParameter(e) {
          return (
            (e.type === "TSParameterProperty" &&
              super.isSimpleParameter(e.parameter)) ||
            super.isSimpleParameter(e)
          );
        }
        tsDisallowOptionalPattern(e) {
          for (let s of e.params)
            s.type !== "Identifier" &&
              s.optional &&
              !this.state.isAmbientContext &&
              this.raise(x.PatternIsOptional, s);
        }
        setArrowFunctionParameters(e, s, i) {
          super.setArrowFunctionParameters(e, s, i),
            this.tsDisallowOptionalPattern(e);
        }
        parseFunctionBodyAndFinish(e, s, i = !1) {
          this.match(14) &&
            (e.returnType = this.tsParseTypeOrTypePredicateAnnotation(14));
          let r =
            s === "FunctionDeclaration"
              ? "TSDeclareFunction"
              : s === "ClassMethod" || s === "ClassPrivateMethod"
                ? "TSDeclareMethod"
                : void 0;
          return r && !this.match(5) && this.isLineTerminator()
            ? this.finishNode(e, r)
            : r === "TSDeclareFunction" &&
                this.state.isAmbientContext &&
                (this.raise(x.DeclareFunctionHasImplementation, e), e.declare)
              ? super.parseFunctionBodyAndFinish(e, r, i)
              : (this.tsDisallowOptionalPattern(e),
                super.parseFunctionBodyAndFinish(e, s, i));
        }
        registerFunctionStatementId(e) {
          !e.body && e.id
            ? this.checkIdentifier(e.id, 1024)
            : super.registerFunctionStatementId(e);
        }
        tsCheckForInvalidTypeCasts(e) {
          e.forEach((s) => {
            (s == null ? void 0 : s.type) === "TSTypeCastExpression" &&
              this.raise(x.UnexpectedTypeAnnotation, s.typeAnnotation);
          });
        }
        toReferencedList(e, s) {
          return this.tsCheckForInvalidTypeCasts(e), e;
        }
        parseArrayLike(e, s, i, r) {
          let n = super.parseArrayLike(e, s, i, r);
          return (
            n.type === "ArrayExpression" &&
              this.tsCheckForInvalidTypeCasts(n.elements),
            n
          );
        }
        parseSubscript(e, s, i, r) {
          if (!this.hasPrecedingLineBreak() && this.match(35)) {
            (this.state.canStartJSXElement = !1), this.next();
            let o = this.startNodeAt(s);
            return (
              (o.expression = e), this.finishNode(o, "TSNonNullExpression")
            );
          }
          let n = !1;
          if (this.match(18) && this.lookaheadCharCode() === 60) {
            if (i) return (r.stop = !0), e;
            (r.optionalChainMember = n = !0), this.next();
          }
          if (this.match(47) || this.match(51)) {
            let o,
              h = this.tsTryParseAndCatch(() => {
                if (!i && this.atPossibleAsyncArrow(e)) {
                  let f = this.tsTryParseGenericAsyncArrowFunction(s);
                  if (f) return f;
                }
                let c = this.tsParseTypeArgumentsInExpression();
                if (!c) return;
                if (n && !this.match(10)) {
                  o = this.state.curPosition();
                  return;
                }
                if (Le(this.state.type)) {
                  let f = super.parseTaggedTemplateExpression(e, s, r);
                  return (f.typeParameters = c), f;
                }
                if (!i && this.eat(10)) {
                  let f = this.startNodeAt(s);
                  return (
                    (f.callee = e),
                    (f.arguments = this.parseCallExpressionArguments(11, !1)),
                    this.tsCheckForInvalidTypeCasts(f.arguments),
                    (f.typeParameters = c),
                    r.optionalChainMember && (f.optional = n),
                    this.finishCallExpression(f, r.optionalChainMember)
                  );
                }
                let l = this.state.type;
                if (
                  l === 48 ||
                  l === 52 ||
                  (l !== 10 && He(l) && !this.hasPrecedingLineBreak())
                )
                  return;
                let u = this.startNodeAt(s);
                return (
                  (u.expression = e),
                  (u.typeParameters = c),
                  this.finishNode(u, "TSInstantiationExpression")
                );
              });
            if ((o && this.unexpected(o, 10), h))
              return (
                h.type === "TSInstantiationExpression" &&
                  (this.match(16) ||
                    (this.match(18) && this.lookaheadCharCode() !== 40)) &&
                  this.raise(
                    x.InvalidPropertyAccessAfterInstantiationExpression,
                    this.state.startLoc,
                  ),
                h
              );
          }
          return super.parseSubscript(e, s, i, r);
        }
        parseNewCallee(e) {
          var s;
          super.parseNewCallee(e);
          let { callee: i } = e;
          i.type === "TSInstantiationExpression" &&
            !((s = i.extra) != null && s.parenthesized) &&
            ((e.typeParameters = i.typeParameters), (e.callee = i.expression));
        }
        parseExprOp(e, s, i) {
          let r;
          if (
            Ie(58) > i &&
            !this.hasPrecedingLineBreak() &&
            (this.isContextual(93) || (r = this.isContextual(120)))
          ) {
            let n = this.startNodeAt(s);
            return (
              (n.expression = e),
              (n.typeAnnotation = this.tsInType(
                () => (
                  this.next(),
                  this.match(75)
                    ? (r &&
                        this.raise(p.UnexpectedKeyword, this.state.startLoc, {
                          keyword: "const",
                        }),
                      this.tsParseTypeReference())
                    : this.tsParseType()
                ),
              )),
              this.finishNode(
                n,
                r ? "TSSatisfiesExpression" : "TSAsExpression",
              ),
              this.reScan_lt_gt(),
              this.parseExprOp(n, s, i)
            );
          }
          return super.parseExprOp(e, s, i);
        }
        checkReservedWord(e, s, i, r) {
          this.state.isAmbientContext || super.checkReservedWord(e, s, i, r);
        }
        checkImportReflection(e) {
          super.checkImportReflection(e),
            e.module &&
              e.importKind !== "value" &&
              this.raise(
                x.ImportReflectionHasImportType,
                e.specifiers[0].loc.start,
              );
        }
        checkDuplicateExports() {}
        isPotentialImportPhase(e) {
          if (super.isPotentialImportPhase(e)) return !0;
          if (this.isContextual(130)) {
            let s = this.lookaheadCharCode();
            return e ? s === 123 || s === 42 : s !== 61;
          }
          return !e && this.isContextual(87);
        }
        applyImportPhase(e, s, i, r) {
          super.applyImportPhase(e, s, i, r),
            s
              ? (e.exportKind = i === "type" ? "type" : "value")
              : (e.importKind = i === "type" || i === "typeof" ? i : "value");
        }
        parseImport(e) {
          if (this.match(133))
            return (e.importKind = "value"), super.parseImport(e);
          let s;
          if (w(this.state.type) && this.lookaheadCharCode() === 61)
            return (
              (e.importKind = "value"), this.tsParseImportEqualsDeclaration(e)
            );
          if (this.isContextual(130)) {
            let i = this.parseMaybeImportPhase(e, !1);
            if (this.lookaheadCharCode() === 61)
              return this.tsParseImportEqualsDeclaration(e, i);
            s = super.parseImportSpecifiersAndAfter(e, i);
          } else s = super.parseImport(e);
          return (
            s.importKind === "type" &&
              s.specifiers.length > 1 &&
              s.specifiers[0].type === "ImportDefaultSpecifier" &&
              this.raise(x.TypeImportCannotSpecifyDefaultAndNamed, s),
            s
          );
        }
        parseExport(e, s) {
          if (this.match(83)) {
            this.next();
            let i = e,
              r = null;
            return (
              this.isContextual(130) && this.isPotentialImportPhase(!1)
                ? (r = this.parseMaybeImportPhase(i, !1))
                : (i.importKind = "value"),
              this.tsParseImportEqualsDeclaration(i, r, !0)
            );
          } else if (this.eat(29)) {
            let i = e;
            return (
              (i.expression = super.parseExpression()),
              this.semicolon(),
              (this.sawUnambiguousESM = !0),
              this.finishNode(i, "TSExportAssignment")
            );
          } else if (this.eatContextual(93)) {
            let i = e;
            return (
              this.expectContextual(128),
              (i.id = this.parseIdentifier()),
              this.semicolon(),
              this.finishNode(i, "TSNamespaceExportDeclaration")
            );
          } else return super.parseExport(e, s);
        }
        isAbstractClass() {
          return this.isContextual(124) && this.lookahead().type === 80;
        }
        parseExportDefaultExpression() {
          if (this.isAbstractClass()) {
            let e = this.startNode();
            return this.next(), (e.abstract = !0), this.parseClass(e, !0, !0);
          }
          if (this.match(129)) {
            let e = this.tsParseInterfaceDeclaration(this.startNode());
            if (e) return e;
          }
          return super.parseExportDefaultExpression();
        }
        parseVarStatement(e, s, i = !1) {
          let { isAmbientContext: r } = this.state,
            n = super.parseVarStatement(e, s, i || r);
          if (!r) return n;
          for (let { id: o, init: h } of n.declarations)
            h &&
              (s !== "const" || o.typeAnnotation
                ? this.raise(x.InitializerNotAllowedInAmbientContext, h)
                : Qi(h, this.hasPlugin("estree")) ||
                  this.raise(
                    x.ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference,
                    h,
                  ));
          return n;
        }
        parseStatementContent(e, s) {
          if (this.match(75) && this.isLookaheadContextual("enum")) {
            let i = this.startNode();
            return (
              this.expect(75), this.tsParseEnumDeclaration(i, { const: !0 })
            );
          }
          if (this.isContextual(126))
            return this.tsParseEnumDeclaration(this.startNode());
          if (this.isContextual(129)) {
            let i = this.tsParseInterfaceDeclaration(this.startNode());
            if (i) return i;
          }
          return super.parseStatementContent(e, s);
        }
        parseAccessModifier() {
          return this.tsParseModifier(["public", "protected", "private"]);
        }
        tsHasSomeModifiers(e, s) {
          return s.some((i) => ($t(i) ? e.accessibility === i : !!e[i]));
        }
        tsIsStartOfStaticBlocks() {
          return this.isContextual(106) && this.lookaheadCharCode() === 123;
        }
        parseClassMember(e, s, i) {
          let r = [
            "declare",
            "private",
            "public",
            "protected",
            "override",
            "abstract",
            "readonly",
            "static",
          ];
          this.tsParseModifiers(
            {
              allowedModifiers: r,
              disallowedModifiers: ["in", "out"],
              stopOnStartOfClassStaticBlock: !0,
              errorTemplate: x.InvalidModifierOnTypeParameterPositions,
            },
            s,
          );
          let n = () => {
            this.tsIsStartOfStaticBlocks()
              ? (this.next(),
                this.next(),
                this.tsHasSomeModifiers(s, r) &&
                  this.raise(
                    x.StaticBlockCannotHaveModifier,
                    this.state.curPosition(),
                  ),
                super.parseClassStaticBlock(e, s))
              : this.parseClassMemberWithIsStatic(e, s, i, !!s.static);
          };
          s.declare ? this.tsInAmbientContext(n) : n();
        }
        parseClassMemberWithIsStatic(e, s, i, r) {
          let n = this.tsTryParseIndexSignature(s);
          if (n) {
            e.body.push(n),
              s.abstract && this.raise(x.IndexSignatureHasAbstract, s),
              s.accessibility &&
                this.raise(x.IndexSignatureHasAccessibility, s, {
                  modifier: s.accessibility,
                }),
              s.declare && this.raise(x.IndexSignatureHasDeclare, s),
              s.override && this.raise(x.IndexSignatureHasOverride, s);
            return;
          }
          !this.state.inAbstractClass &&
            s.abstract &&
            this.raise(x.NonAbstractClassHasAbstractMethod, s),
            s.override &&
              (i.hadSuperClass || this.raise(x.OverrideNotInSubClass, s)),
            super.parseClassMemberWithIsStatic(e, s, i, r);
        }
        parsePostMemberNameModifiers(e) {
          this.eat(17) && (e.optional = !0),
            e.readonly &&
              this.match(10) &&
              this.raise(x.ClassMethodHasReadonly, e),
            e.declare &&
              this.match(10) &&
              this.raise(x.ClassMethodHasDeclare, e);
        }
        parseExpressionStatement(e, s, i) {
          return (
            (s.type === "Identifier"
              ? this.tsParseExpressionStatement(e, s, i)
              : void 0) || super.parseExpressionStatement(e, s, i)
          );
        }
        shouldParseExportDeclaration() {
          return this.tsIsDeclarationStart()
            ? !0
            : super.shouldParseExportDeclaration();
        }
        parseConditional(e, s, i) {
          if (!this.state.maybeInArrowParameters || !this.match(17))
            return super.parseConditional(e, s, i);
          let r = this.tryParse(() => super.parseConditional(e, s));
          return r.node
            ? (r.error && (this.state = r.failState), r.node)
            : (r.error && super.setOptionalParametersError(i, r.error), e);
        }
        parseParenItem(e, s) {
          let i = super.parseParenItem(e, s);
          if (
            (this.eat(17) && ((i.optional = !0), this.resetEndLocation(e)),
            this.match(14))
          ) {
            let r = this.startNodeAt(s);
            return (
              (r.expression = e),
              (r.typeAnnotation = this.tsParseTypeAnnotation()),
              this.finishNode(r, "TSTypeCastExpression")
            );
          }
          return e;
        }
        parseExportDeclaration(e) {
          if (!this.state.isAmbientContext && this.isContextual(125))
            return this.tsInAmbientContext(() =>
              this.parseExportDeclaration(e),
            );
          let s = this.state.startLoc,
            i = this.eatContextual(125);
          if (
            i &&
            (this.isContextual(125) || !this.shouldParseExportDeclaration())
          )
            throw this.raise(
              x.ExpectedAmbientAfterExportDeclare,
              this.state.startLoc,
            );
          let n =
            (w(this.state.type) && this.tsTryParseExportDeclaration()) ||
            super.parseExportDeclaration(e);
          return n
            ? ((n.type === "TSInterfaceDeclaration" ||
                n.type === "TSTypeAliasDeclaration" ||
                i) &&
                (e.exportKind = "type"),
              i && (this.resetStartLocation(n, s), (n.declare = !0)),
              n)
            : null;
        }
        parseClassId(e, s, i, r) {
          if ((!s || i) && this.isContextual(113)) return;
          super.parseClassId(e, s, i, e.declare ? 1024 : 8331);
          let n = this.tsTryParseTypeParameters(
            this.tsParseInOutConstModifiers,
          );
          n && (e.typeParameters = n);
        }
        parseClassPropertyAnnotation(e) {
          e.optional ||
            (this.eat(35)
              ? (e.definite = !0)
              : this.eat(17) && (e.optional = !0));
          let s = this.tsTryParseTypeAnnotation();
          s && (e.typeAnnotation = s);
        }
        parseClassProperty(e) {
          if (
            (this.parseClassPropertyAnnotation(e),
            this.state.isAmbientContext &&
              !(e.readonly && !e.typeAnnotation) &&
              this.match(29) &&
              this.raise(
                x.DeclareClassFieldHasInitializer,
                this.state.startLoc,
              ),
            e.abstract && this.match(29))
          ) {
            let { key: s } = e;
            this.raise(x.AbstractPropertyHasInitializer, this.state.startLoc, {
              propertyName:
                s.type === "Identifier" && !e.computed
                  ? s.name
                  : `[${this.input.slice(s.start, s.end)}]`,
            });
          }
          return super.parseClassProperty(e);
        }
        parseClassPrivateProperty(e) {
          return (
            e.abstract && this.raise(x.PrivateElementHasAbstract, e),
            e.accessibility &&
              this.raise(x.PrivateElementHasAccessibility, e, {
                modifier: e.accessibility,
              }),
            this.parseClassPropertyAnnotation(e),
            super.parseClassPrivateProperty(e)
          );
        }
        parseClassAccessorProperty(e) {
          return (
            this.parseClassPropertyAnnotation(e),
            e.optional && this.raise(x.AccessorCannotBeOptional, e),
            super.parseClassAccessorProperty(e)
          );
        }
        pushClassMethod(e, s, i, r, n, o) {
          let h = this.tsTryParseTypeParameters(this.tsParseConstModifier);
          h && n && this.raise(x.ConstructorHasTypeParameters, h);
          let { declare: c = !1, kind: l } = s;
          c &&
            (l === "get" || l === "set") &&
            this.raise(x.DeclareAccessor, s, { kind: l }),
            h && (s.typeParameters = h),
            super.pushClassMethod(e, s, i, r, n, o);
        }
        pushClassPrivateMethod(e, s, i, r) {
          let n = this.tsTryParseTypeParameters(this.tsParseConstModifier);
          n && (s.typeParameters = n), super.pushClassPrivateMethod(e, s, i, r);
        }
        declareClassPrivateMethodInScope(e, s) {
          e.type !== "TSDeclareMethod" &&
            ((e.type === "MethodDefinition" &&
              !hasOwnProperty.call(e.value, "body")) ||
              super.declareClassPrivateMethodInScope(e, s));
        }
        parseClassSuper(e) {
          super.parseClassSuper(e),
            e.superClass &&
              (this.match(47) || this.match(51)) &&
              (e.superTypeParameters = this.tsParseTypeArgumentsInExpression()),
            this.eatContextual(113) &&
              (e.implements = this.tsParseHeritageClause("implements"));
        }
        parseObjPropValue(e, s, i, r, n, o, h) {
          let c = this.tsTryParseTypeParameters(this.tsParseConstModifier);
          return (
            c && (e.typeParameters = c),
            super.parseObjPropValue(e, s, i, r, n, o, h)
          );
        }
        parseFunctionParams(e, s) {
          let i = this.tsTryParseTypeParameters(this.tsParseConstModifier);
          i && (e.typeParameters = i), super.parseFunctionParams(e, s);
        }
        parseVarId(e, s) {
          super.parseVarId(e, s),
            e.id.type === "Identifier" &&
              !this.hasPrecedingLineBreak() &&
              this.eat(35) &&
              (e.definite = !0);
          let i = this.tsTryParseTypeAnnotation();
          i && ((e.id.typeAnnotation = i), this.resetEndLocation(e.id));
        }
        parseAsyncArrowFromCallExpression(e, s) {
          return (
            this.match(14) && (e.returnType = this.tsParseTypeAnnotation()),
            super.parseAsyncArrowFromCallExpression(e, s)
          );
        }
        parseMaybeAssign(e, s) {
          var i, r, n, o, h;
          let c, l, u;
          if (this.hasPlugin("jsx") && (this.match(142) || this.match(47))) {
            if (
              ((c = this.state.clone()),
              (l = this.tryParse(() => super.parseMaybeAssign(e, s), c)),
              !l.error)
            )
              return l.node;
            let { context: y } = this.state,
              E = y[y.length - 1];
            (E === C.j_oTag || E === C.j_expr) && y.pop();
          }
          if (!((i = l) != null && i.error) && !this.match(47))
            return super.parseMaybeAssign(e, s);
          (!c || c === this.state) && (c = this.state.clone());
          let f,
            d = this.tryParse((y) => {
              var E, L;
              f = this.tsParseTypeParameters(this.tsParseConstModifier);
              let S = super.parseMaybeAssign(e, s);
              return (
                (S.type !== "ArrowFunctionExpression" ||
                  ((E = S.extra) != null && E.parenthesized)) &&
                  y(),
                ((L = f) == null ? void 0 : L.params.length) !== 0 &&
                  this.resetStartLocationFromNode(S, f),
                (S.typeParameters = f),
                S
              );
            }, c);
          if (!d.error && !d.aborted)
            return f && this.reportReservedArrowTypeParam(f), d.node;
          if (
            !l &&
            (jt(!this.hasPlugin("jsx")),
            (u = this.tryParse(() => super.parseMaybeAssign(e, s), c)),
            !u.error)
          )
            return u.node;
          if ((r = l) != null && r.node)
            return (this.state = l.failState), l.node;
          if (d.node)
            return (
              (this.state = d.failState),
              f && this.reportReservedArrowTypeParam(f),
              d.node
            );
          if ((n = u) != null && n.node)
            return (this.state = u.failState), u.node;
          throw (
            ((o = l) == null ? void 0 : o.error) ||
            d.error ||
            ((h = u) == null ? void 0 : h.error)
          );
        }
        reportReservedArrowTypeParam(e) {
          var s;
          e.params.length === 1 &&
            !e.params[0].constraint &&
            !((s = e.extra) != null && s.trailingComma) &&
            this.getPluginOption("typescript", "disallowAmbiguousJSXLike") &&
            this.raise(x.ReservedArrowTypeParam, e);
        }
        parseMaybeUnary(e, s) {
          return !this.hasPlugin("jsx") && this.match(47)
            ? this.tsParseTypeAssertion()
            : super.parseMaybeUnary(e, s);
        }
        parseArrow(e) {
          if (this.match(14)) {
            let s = this.tryParse((i) => {
              let r = this.tsParseTypeOrTypePredicateAnnotation(14);
              return (this.canInsertSemicolon() || !this.match(19)) && i(), r;
            });
            if (s.aborted) return;
            s.thrown ||
              (s.error && (this.state = s.failState), (e.returnType = s.node));
          }
          return super.parseArrow(e);
        }
        parseAssignableListItemTypes(e, s) {
          if (!(s & 2)) return e;
          this.eat(17) && (e.optional = !0);
          let i = this.tsTryParseTypeAnnotation();
          return i && (e.typeAnnotation = i), this.resetEndLocation(e), e;
        }
        isAssignable(e, s) {
          switch (e.type) {
            case "TSTypeCastExpression":
              return this.isAssignable(e.expression, s);
            case "TSParameterProperty":
              return !0;
            default:
              return super.isAssignable(e, s);
          }
        }
        toAssignable(e, s = !1) {
          switch (e.type) {
            case "ParenthesizedExpression":
              this.toAssignableParenthesizedExpression(e, s);
              break;
            case "TSAsExpression":
            case "TSSatisfiesExpression":
            case "TSNonNullExpression":
            case "TSTypeAssertion":
              s
                ? this.expressionScope.recordArrowParameterBindingError(
                    x.UnexpectedTypeCastInParameter,
                    e,
                  )
                : this.raise(x.UnexpectedTypeCastInParameter, e),
                this.toAssignable(e.expression, s);
              break;
            case "AssignmentExpression":
              !s &&
                e.left.type === "TSTypeCastExpression" &&
                (e.left = this.typeCastToParameter(e.left));
            default:
              super.toAssignable(e, s);
          }
        }
        toAssignableParenthesizedExpression(e, s) {
          switch (e.expression.type) {
            case "TSAsExpression":
            case "TSSatisfiesExpression":
            case "TSNonNullExpression":
            case "TSTypeAssertion":
            case "ParenthesizedExpression":
              this.toAssignable(e.expression, s);
              break;
            default:
              super.toAssignable(e, s);
          }
        }
        checkToRestConversion(e, s) {
          switch (e.type) {
            case "TSAsExpression":
            case "TSSatisfiesExpression":
            case "TSTypeAssertion":
            case "TSNonNullExpression":
              this.checkToRestConversion(e.expression, !1);
              break;
            default:
              super.checkToRestConversion(e, s);
          }
        }
        isValidLVal(e, s, i) {
          return (
            Hi(
              {
                TSTypeCastExpression: !0,
                TSParameterProperty: "parameter",
                TSNonNullExpression: "expression",
                TSInstantiationExpression: "expression",
                TSAsExpression: (i !== 64 || !s) && ["expression", !0],
                TSSatisfiesExpression: (i !== 64 || !s) && ["expression", !0],
                TSTypeAssertion: (i !== 64 || !s) && ["expression", !0],
              },
              e,
            ) || super.isValidLVal(e, s, i)
          );
        }
        parseBindingAtom() {
          return this.state.type === 78
            ? this.parseIdentifier(!0)
            : super.parseBindingAtom();
        }
        parseMaybeDecoratorArguments(e) {
          if (this.match(47) || this.match(51)) {
            let s = this.tsParseTypeArgumentsInExpression();
            if (this.match(10)) {
              let i = super.parseMaybeDecoratorArguments(e);
              return (i.typeParameters = s), i;
            }
            this.unexpected(null, 10);
          }
          return super.parseMaybeDecoratorArguments(e);
        }
        checkCommaAfterRest(e) {
          return this.state.isAmbientContext &&
            this.match(12) &&
            this.lookaheadCharCode() === e
            ? (this.next(), !1)
            : super.checkCommaAfterRest(e);
        }
        isClassMethod() {
          return this.match(47) || super.isClassMethod();
        }
        isClassProperty() {
          return this.match(35) || this.match(14) || super.isClassProperty();
        }
        parseMaybeDefault(e, s) {
          let i = super.parseMaybeDefault(e, s);
          return (
            i.type === "AssignmentPattern" &&
              i.typeAnnotation &&
              i.right.start < i.typeAnnotation.start &&
              this.raise(x.TypeAnnotationAfterAssign, i.typeAnnotation),
            i
          );
        }
        getTokenFromCode(e) {
          if (this.state.inType) {
            if (e === 62) {
              this.finishOp(48, 1);
              return;
            }
            if (e === 60) {
              this.finishOp(47, 1);
              return;
            }
          }
          super.getTokenFromCode(e);
        }
        reScan_lt_gt() {
          let { type: e } = this.state;
          e === 47
            ? ((this.state.pos -= 1), this.readToken_lt())
            : e === 48 && ((this.state.pos -= 1), this.readToken_gt());
        }
        reScan_lt() {
          let { type: e } = this.state;
          return e === 51
            ? ((this.state.pos -= 2), this.finishOp(47, 1), 47)
            : e;
        }
        toAssignableList(e, s, i) {
          for (let r = 0; r < e.length; r++) {
            let n = e[r];
            (n == null ? void 0 : n.type) === "TSTypeCastExpression" &&
              (e[r] = this.typeCastToParameter(n));
          }
          super.toAssignableList(e, s, i);
        }
        typeCastToParameter(e) {
          return (
            (e.expression.typeAnnotation = e.typeAnnotation),
            this.resetEndLocation(e.expression, e.typeAnnotation.loc.end),
            e.expression
          );
        }
        shouldParseArrow(e) {
          return this.match(14)
            ? e.every((s) => this.isAssignable(s, !0))
            : super.shouldParseArrow(e);
        }
        shouldParseAsyncArrow() {
          return this.match(14) || super.shouldParseAsyncArrow();
        }
        canHaveLeadingDecorator() {
          return super.canHaveLeadingDecorator() || this.isAbstractClass();
        }
        jsxParseOpeningElementAfterName(e) {
          if (this.match(47) || this.match(51)) {
            let s = this.tsTryParseAndCatch(() =>
              this.tsParseTypeArgumentsInExpression(),
            );
            s && (e.typeParameters = s);
          }
          return super.jsxParseOpeningElementAfterName(e);
        }
        getGetterSetterExpectedParamCount(e) {
          let s = super.getGetterSetterExpectedParamCount(e),
            r = this.getObjectOrClassMethodParams(e)[0];
          return r && this.isThisParam(r) ? s + 1 : s;
        }
        parseCatchClauseParam() {
          let e = super.parseCatchClauseParam(),
            s = this.tsTryParseTypeAnnotation();
          return s && ((e.typeAnnotation = s), this.resetEndLocation(e)), e;
        }
        tsInAmbientContext(e) {
          let { isAmbientContext: s, strict: i } = this.state;
          (this.state.isAmbientContext = !0), (this.state.strict = !1);
          try {
            return e();
          } finally {
            (this.state.isAmbientContext = s), (this.state.strict = i);
          }
        }
        parseClass(e, s, i) {
          let r = this.state.inAbstractClass;
          this.state.inAbstractClass = !!e.abstract;
          try {
            return super.parseClass(e, s, i);
          } finally {
            this.state.inAbstractClass = r;
          }
        }
        tsParseAbstractDeclaration(e, s) {
          if (this.match(80))
            return (
              (e.abstract = !0),
              this.maybeTakeDecorators(s, this.parseClass(e, !0, !1))
            );
          if (this.isContextual(129)) {
            if (!this.hasFollowingLineBreak())
              return (
                (e.abstract = !0),
                this.raise(x.NonClassMethodPropertyHasAbstractModifer, e),
                this.tsParseInterfaceDeclaration(e)
              );
          } else this.unexpected(null, 80);
        }
        parseMethod(e, s, i, r, n, o, h) {
          let c = super.parseMethod(e, s, i, r, n, o, h);
          if (
            c.abstract &&
            (this.hasPlugin("estree") ? !!c.value.body : !!c.body)
          ) {
            let { key: u } = c;
            this.raise(x.AbstractMethodHasImplementation, c, {
              methodName:
                u.type === "Identifier" && !c.computed
                  ? u.name
                  : `[${this.input.slice(u.start, u.end)}]`,
            });
          }
          return c;
        }
        tsParseTypeParameterName() {
          return this.parseIdentifier().name;
        }
        shouldParseAsAmbientContext() {
          return !!this.getPluginOption("typescript", "dts");
        }
        parse() {
          return (
            this.shouldParseAsAmbientContext() &&
              (this.state.isAmbientContext = !0),
            super.parse()
          );
        }
        getExpression() {
          return (
            this.shouldParseAsAmbientContext() &&
              (this.state.isAmbientContext = !0),
            super.getExpression()
          );
        }
        parseExportSpecifier(e, s, i, r) {
          return !s && r
            ? (this.parseTypeOnlyImportExportSpecifier(e, !1, i),
              this.finishNode(e, "ExportSpecifier"))
            : ((e.exportKind = "value"),
              super.parseExportSpecifier(e, s, i, r));
        }
        parseImportSpecifier(e, s, i, r, n) {
          return !s && r
            ? (this.parseTypeOnlyImportExportSpecifier(e, !0, i),
              this.finishNode(e, "ImportSpecifier"))
            : ((e.importKind = "value"),
              super.parseImportSpecifier(e, s, i, r, i ? 4098 : 4096));
        }
        parseTypeOnlyImportExportSpecifier(e, s, i) {
          let r = s ? "imported" : "local",
            n = s ? "local" : "exported",
            o = e[r],
            h,
            c = !1,
            l = !0,
            u = o.loc.start;
          if (this.isContextual(93)) {
            let d = this.parseIdentifier();
            if (this.isContextual(93)) {
              let y = this.parseIdentifier();
              M(this.state.type)
                ? ((c = !0),
                  (o = d),
                  (h = s
                    ? this.parseIdentifier()
                    : this.parseModuleExportName()),
                  (l = !1))
                : ((h = y), (l = !1));
            } else
              M(this.state.type)
                ? ((l = !1),
                  (h = s
                    ? this.parseIdentifier()
                    : this.parseModuleExportName()))
                : ((c = !0), (o = d));
          } else
            M(this.state.type) &&
              ((c = !0),
              s
                ? ((o = this.parseIdentifier(!0)),
                  this.isContextual(93) ||
                    this.checkReservedWord(o.name, o.loc.start, !0, !0))
                : (o = this.parseModuleExportName()));
          c &&
            i &&
            this.raise(
              s
                ? x.TypeModifierIsUsedInTypeImports
                : x.TypeModifierIsUsedInTypeExports,
              u,
            ),
            (e[r] = o),
            (e[n] = h);
          let f = s ? "importKind" : "exportKind";
          (e[f] = c ? "type" : "value"),
            l &&
              this.eatContextual(93) &&
              (e[n] = s
                ? this.parseIdentifier()
                : this.parseModuleExportName()),
            e[n] || (e[n] = $(e[r])),
            s && this.checkIdentifier(e[n], c ? 4098 : 4096);
        }
      };
    function Yi(a) {
      if (a.type !== "MemberExpression") return !1;
      let { computed: t, property: e } = a;
      return t &&
        e.type !== "StringLiteral" &&
        (e.type !== "TemplateLiteral" || e.expressions.length > 0)
        ? !1
        : os(a.object);
    }
    function Qi(a, t) {
      var e;
      let { type: s } = a;
      if ((e = a.extra) != null && e.parenthesized) return !1;
      if (t) {
        if (s === "Literal") {
          let { value: i } = a;
          if (typeof i == "string" || typeof i == "boolean") return !0;
        }
      } else if (s === "StringLiteral" || s === "BooleanLiteral") return !0;
      return !!(
        ns(a, t) ||
        Zi(a, t) ||
        (s === "TemplateLiteral" && a.expressions.length === 0) ||
        Yi(a)
      );
    }
    function ns(a, t) {
      return t
        ? a.type === "Literal" && (typeof a.value == "number" || "bigint" in a)
        : a.type === "NumericLiteral" || a.type === "BigIntLiteral";
    }
    function Zi(a, t) {
      if (a.type === "UnaryExpression") {
        let { operator: e, argument: s } = a;
        if (e === "-" && ns(s, t)) return !0;
      }
      return !1;
    }
    function os(a) {
      return a.type === "Identifier"
        ? !0
        : a.type !== "MemberExpression" || a.computed
          ? !1
          : os(a.object);
    }
    var Vt = j`placeholders`({
        ClassNameIsRequired: "A class name is required.",
        UnexpectedSpace: "Unexpected space in placeholder.",
      }),
      er = (a) =>
        class extends a {
          parsePlaceholder(e) {
            if (this.match(144)) {
              let s = this.startNode();
              return (
                this.next(),
                this.assertNoSpace(),
                (s.name = super.parseIdentifier(!0)),
                this.assertNoSpace(),
                this.expect(144),
                this.finishPlaceholder(s, e)
              );
            }
          }
          finishPlaceholder(e, s) {
            let i = e;
            return (
              (!i.expectedNode || !i.type) &&
                (i = this.finishNode(i, "Placeholder")),
              (i.expectedNode = s),
              i
            );
          }
          getTokenFromCode(e) {
            e === 37 && this.input.charCodeAt(this.state.pos + 1) === 37
              ? this.finishOp(144, 2)
              : super.getTokenFromCode(e);
          }
          parseExprAtom(e) {
            return (
              this.parsePlaceholder("Expression") || super.parseExprAtom(e)
            );
          }
          parseIdentifier(e) {
            return (
              this.parsePlaceholder("Identifier") || super.parseIdentifier(e)
            );
          }
          checkReservedWord(e, s, i, r) {
            e !== void 0 && super.checkReservedWord(e, s, i, r);
          }
          parseBindingAtom() {
            return this.parsePlaceholder("Pattern") || super.parseBindingAtom();
          }
          isValidLVal(e, s, i) {
            return e === "Placeholder" || super.isValidLVal(e, s, i);
          }
          toAssignable(e, s) {
            e && e.type === "Placeholder" && e.expectedNode === "Expression"
              ? (e.expectedNode = "Pattern")
              : super.toAssignable(e, s);
          }
          chStartsBindingIdentifier(e, s) {
            return !!(
              super.chStartsBindingIdentifier(e, s) ||
              this.lookahead().type === 144
            );
          }
          verifyBreakContinue(e, s) {
            (e.label && e.label.type === "Placeholder") ||
              super.verifyBreakContinue(e, s);
          }
          parseExpressionStatement(e, s) {
            var i;
            if (
              s.type !== "Placeholder" ||
              ((i = s.extra) != null && i.parenthesized)
            )
              return super.parseExpressionStatement(e, s);
            if (this.match(14)) {
              let n = e;
              return (
                (n.label = this.finishPlaceholder(s, "Identifier")),
                this.next(),
                (n.body =
                  super.parseStatementOrSloppyAnnexBFunctionDeclaration()),
                this.finishNode(n, "LabeledStatement")
              );
            }
            this.semicolon();
            let r = e;
            return (r.name = s.name), this.finishPlaceholder(r, "Statement");
          }
          parseBlock(e, s, i) {
            return (
              this.parsePlaceholder("BlockStatement") ||
              super.parseBlock(e, s, i)
            );
          }
          parseFunctionId(e) {
            return (
              this.parsePlaceholder("Identifier") || super.parseFunctionId(e)
            );
          }
          parseClass(e, s, i) {
            let r = s ? "ClassDeclaration" : "ClassExpression";
            this.next();
            let n = this.state.strict,
              o = this.parsePlaceholder("Identifier");
            if (o)
              if (this.match(81) || this.match(144) || this.match(5)) e.id = o;
              else {
                if (i || !s)
                  return (
                    (e.id = null),
                    (e.body = this.finishPlaceholder(o, "ClassBody")),
                    this.finishNode(e, r)
                  );
                throw this.raise(Vt.ClassNameIsRequired, this.state.startLoc);
              }
            else this.parseClassId(e, s, i);
            return (
              super.parseClassSuper(e),
              (e.body =
                this.parsePlaceholder("ClassBody") ||
                super.parseClassBody(!!e.superClass, n)),
              this.finishNode(e, r)
            );
          }
          parseExport(e, s) {
            let i = this.parsePlaceholder("Identifier");
            if (!i) return super.parseExport(e, s);
            let r = e;
            if (!this.isContextual(98) && !this.match(12))
              return (
                (r.specifiers = []),
                (r.source = null),
                (r.declaration = this.finishPlaceholder(i, "Declaration")),
                this.finishNode(r, "ExportNamedDeclaration")
              );
            this.expectPlugin("exportDefaultFrom");
            let n = this.startNode();
            return (
              (n.exported = i),
              (r.specifiers = [this.finishNode(n, "ExportDefaultSpecifier")]),
              super.parseExport(r, s)
            );
          }
          isExportDefaultSpecifier() {
            if (this.match(65)) {
              let e = this.nextTokenStart();
              if (
                this.isUnparsedContextual(e, "from") &&
                this.input.startsWith(K(144), this.nextTokenStartSince(e + 4))
              )
                return !0;
            }
            return super.isExportDefaultSpecifier();
          }
          maybeParseExportDefaultSpecifier(e, s) {
            var i;
            return (i = e.specifiers) != null && i.length
              ? !0
              : super.maybeParseExportDefaultSpecifier(e, s);
          }
          checkExport(e) {
            let { specifiers: s } = e;
            s != null &&
              s.length &&
              (e.specifiers = s.filter(
                (i) => i.exported.type === "Placeholder",
              )),
              super.checkExport(e),
              (e.specifiers = s);
          }
          parseImport(e) {
            let s = this.parsePlaceholder("Identifier");
            if (!s) return super.parseImport(e);
            if (
              ((e.specifiers = []), !this.isContextual(98) && !this.match(12))
            )
              return (
                (e.source = this.finishPlaceholder(s, "StringLiteral")),
                this.semicolon(),
                this.finishNode(e, "ImportDeclaration")
              );
            let i = this.startNodeAtNode(s);
            return (
              (i.local = s),
              e.specifiers.push(this.finishNode(i, "ImportDefaultSpecifier")),
              this.eat(12) &&
                (this.maybeParseStarImportSpecifier(e) ||
                  this.parseNamedImportSpecifiers(e)),
              this.expectContextual(98),
              (e.source = this.parseImportSource()),
              this.semicolon(),
              this.finishNode(e, "ImportDeclaration")
            );
          }
          parseImportSource() {
            return (
              this.parsePlaceholder("StringLiteral") ||
              super.parseImportSource()
            );
          }
          assertNoSpace() {
            this.state.start > this.state.lastTokEndLoc.index &&
              this.raise(Vt.UnexpectedSpace, this.state.lastTokEndLoc);
          }
        },
      tr = (a) =>
        class extends a {
          parseV8Intrinsic() {
            if (this.match(54)) {
              let e = this.state.startLoc,
                s = this.startNode();
              if ((this.next(), w(this.state.type))) {
                let i = this.parseIdentifierName(),
                  r = this.createIdentifier(s, i);
                if (((r.type = "V8IntrinsicIdentifier"), this.match(10)))
                  return r;
              }
              this.unexpected(e);
            }
          }
          parseExprAtom(e) {
            return this.parseV8Intrinsic() || super.parseExprAtom(e);
          }
        };
    function N(a, t) {
      let [e, s] = typeof t == "string" ? [t, {}] : t,
        i = Object.keys(s),
        r = i.length === 0;
      return a.some((n) => {
        if (typeof n == "string") return r && n === e;
        {
          let [o, h] = n;
          if (o !== e) return !1;
          for (let c of i) if (h[c] !== s[c]) return !1;
          return !0;
        }
      });
    }
    function J(a, t, e) {
      let s = a.find((i) => (Array.isArray(i) ? i[0] === t : i === t));
      return s && Array.isArray(s) && s.length > 1 ? s[1][e] : null;
    }
    var qt = ["minimal", "fsharp", "hack", "smart"],
      zt = ["^^", "@@", "^", "%", "#"];
    function sr(a) {
      if (N(a, "decorators")) {
        if (N(a, "decorators-legacy"))
          throw new Error(
            "Cannot use the decorators and decorators-legacy plugin together",
          );
        let t = J(a, "decorators", "decoratorsBeforeExport");
        if (t != null && typeof t != "boolean")
          throw new Error(
            "'decoratorsBeforeExport' must be a boolean, if specified.",
          );
        let e = J(a, "decorators", "allowCallParenthesized");
        if (e != null && typeof e != "boolean")
          throw new Error("'allowCallParenthesized' must be a boolean.");
      }
      if (N(a, "flow") && N(a, "typescript"))
        throw new Error("Cannot combine flow and typescript plugins.");
      if (N(a, "placeholders") && N(a, "v8intrinsic"))
        throw new Error("Cannot combine placeholders and v8intrinsic plugins.");
      if (N(a, "pipelineOperator")) {
        let t = J(a, "pipelineOperator", "proposal");
        if (!qt.includes(t)) {
          let i = qt.map((r) => `"${r}"`).join(", ");
          throw new Error(
            `"pipelineOperator" requires "proposal" option whose value must be one of: ${i}.`,
          );
        }
        let e = ["recordAndTuple", { syntaxType: "hash" }],
          s = N(a, e);
        if (t === "hack") {
          if (N(a, "placeholders"))
            throw new Error(
              "Cannot combine placeholders plugin and Hack-style pipes.",
            );
          if (N(a, "v8intrinsic"))
            throw new Error(
              "Cannot combine v8intrinsic plugin and Hack-style pipes.",
            );
          let i = J(a, "pipelineOperator", "topicToken");
          if (!zt.includes(i)) {
            let r = zt.map((n) => `"${n}"`).join(", ");
            throw new Error(
              `"pipelineOperator" in "proposal": "hack" mode also requires a "topicToken" option whose value must be one of: ${r}.`,
            );
          }
          if (i === "#" && s)
            throw new Error(
              `Plugin conflict between \`["pipelineOperator", { proposal: "hack", topicToken: "#" }]\` and \`${JSON.stringify(e)}\`.`,
            );
        } else if (t === "smart" && s)
          throw new Error(
            `Plugin conflict between \`["pipelineOperator", { proposal: "smart" }]\` and \`${JSON.stringify(e)}\`.`,
          );
      }
      if (N(a, "moduleAttributes")) {
        if (N(a, "importAssertions") || N(a, "importAttributes"))
          throw new Error(
            "Cannot combine importAssertions, importAttributes and moduleAttributes plugins.",
          );
        if (J(a, "moduleAttributes", "version") !== "may-2020")
          throw new Error(
            "The 'moduleAttributes' plugin requires a 'version' option, representing the last proposal update. Currently, the only supported value is 'may-2020'.",
          );
      }
      if (N(a, "importAssertions") && N(a, "importAttributes"))
        throw new Error(
          "Cannot combine importAssertions and importAttributes plugins.",
        );
      if (N(a, "recordAndTuple")) {
        let t = J(a, "recordAndTuple", "syntaxType");
        if (t != null) {
          let e = ["hash", "bar"];
          if (!e.includes(t))
            throw new Error(
              "The 'syntaxType' option of the 'recordAndTuple' plugin must be one of: " +
                e.map((s) => `'${s}'`).join(", "),
            );
        }
      }
      if (N(a, "asyncDoExpressions") && !N(a, "doExpressions")) {
        let t = new Error(
          "'asyncDoExpressions' requires 'doExpressions', please add 'doExpressions' to parser plugins.",
        );
        throw ((t.missingPlugins = "doExpressions"), t);
      }
      if (
        N(a, "optionalChainingAssign") &&
        J(a, "optionalChainingAssign", "version") !== "2023-07"
      )
        throw new Error(
          "The 'optionalChainingAssign' plugin requires a 'version' option, representing the last proposal update. Currently, the only supported value is '2023-07'.",
        );
    }
    var hs = {
        estree: ri,
        jsx: zi,
        flow: qi,
        typescript: Gi,
        v8intrinsic: tr,
        placeholders: er,
      },
      ir = Object.keys(hs),
      qe = {
        sourceType: "script",
        sourceFilename: void 0,
        startColumn: 0,
        startLine: 1,
        allowAwaitOutsideFunction: !1,
        allowReturnOutsideFunction: !1,
        allowNewTargetOutsideFunction: !1,
        allowImportExportEverywhere: !1,
        allowSuperOutsideMethod: !1,
        allowUndeclaredExports: !1,
        plugins: [],
        strictMode: null,
        ranges: !1,
        tokens: !1,
        createImportExpressions: !1,
        createParenthesizedExpressions: !1,
        errorRecovery: !1,
        attachComment: !0,
        annexB: !0,
      };
    function rr(a) {
      if (a == null) return Object.assign({}, qe);
      if (a.annexB != null && a.annexB !== !1)
        throw new Error("The `annexB` option can only be set to `false`.");
      let t = {};
      for (let s of Object.keys(qe)) {
        var e;
        t[s] = (e = a[s]) != null ? e : qe[s];
      }
      return t;
    }
    var ct = class extends lt {
        checkProto(t, e, s, i) {
          if (
            t.type === "SpreadElement" ||
            this.isObjectMethod(t) ||
            t.computed ||
            t.shorthand
          )
            return;
          let r = t.key;
          if ((r.type === "Identifier" ? r.name : r.value) === "__proto__") {
            if (e) {
              this.raise(p.RecordNoProto, r);
              return;
            }
            s.used &&
              (i
                ? i.doubleProtoLoc === null && (i.doubleProtoLoc = r.loc.start)
                : this.raise(p.DuplicateProto, r)),
              (s.used = !0);
          }
        }
        shouldExitDescending(t, e) {
          return t.type === "ArrowFunctionExpression" && t.start === e;
        }
        getExpression() {
          this.enterInitialScopes(), this.nextToken();
          let t = this.parseExpression();
          return (
            this.match(139) || this.unexpected(),
            this.finalizeRemainingComments(),
            (t.comments = this.comments),
            (t.errors = this.state.errors),
            this.options.tokens && (t.tokens = this.tokens),
            t
          );
        }
        parseExpression(t, e) {
          return t
            ? this.disallowInAnd(() => this.parseExpressionBase(e))
            : this.allowInAnd(() => this.parseExpressionBase(e));
        }
        parseExpressionBase(t) {
          let e = this.state.startLoc,
            s = this.parseMaybeAssign(t);
          if (this.match(12)) {
            let i = this.startNodeAt(e);
            for (i.expressions = [s]; this.eat(12); )
              i.expressions.push(this.parseMaybeAssign(t));
            return (
              this.toReferencedList(i.expressions),
              this.finishNode(i, "SequenceExpression")
            );
          }
          return s;
        }
        parseMaybeAssignDisallowIn(t, e) {
          return this.disallowInAnd(() => this.parseMaybeAssign(t, e));
        }
        parseMaybeAssignAllowIn(t, e) {
          return this.allowInAnd(() => this.parseMaybeAssign(t, e));
        }
        setOptionalParametersError(t, e) {
          var s;
          t.optionalParametersLoc =
            (s = e == null ? void 0 : e.loc) != null ? s : this.state.startLoc;
        }
        parseMaybeAssign(t, e) {
          let s = this.state.startLoc;
          if (this.isContextual(108) && this.prodParam.hasYield) {
            let o = this.parseYield();
            return e && (o = e.call(this, o, s)), o;
          }
          let i;
          t ? (i = !1) : ((t = new Z()), (i = !0));
          let { type: r } = this.state;
          (r === 10 || w(r)) &&
            (this.state.potentialArrowAt = this.state.start);
          let n = this.parseMaybeConditional(t);
          if ((e && (n = e.call(this, n, s)), li(this.state.type))) {
            let o = this.startNodeAt(s),
              h = this.state.value;
            if (((o.operator = h), this.match(29))) {
              this.toAssignable(n, !0), (o.left = n);
              let c = s.index;
              t.doubleProtoLoc != null &&
                t.doubleProtoLoc.index >= c &&
                (t.doubleProtoLoc = null),
                t.shorthandAssignLoc != null &&
                  t.shorthandAssignLoc.index >= c &&
                  (t.shorthandAssignLoc = null),
                t.privateKeyLoc != null &&
                  t.privateKeyLoc.index >= c &&
                  (this.checkDestructuringPrivate(t), (t.privateKeyLoc = null));
            } else o.left = n;
            return (
              this.next(),
              (o.right = this.parseMaybeAssign()),
              this.checkLVal(n, {
                in: this.finishNode(o, "AssignmentExpression"),
              }),
              o
            );
          } else i && this.checkExpressionErrors(t, !0);
          return n;
        }
        parseMaybeConditional(t) {
          let e = this.state.startLoc,
            s = this.state.potentialArrowAt,
            i = this.parseExprOps(t);
          return this.shouldExitDescending(i, s)
            ? i
            : this.parseConditional(i, e, t);
        }
        parseConditional(t, e, s) {
          if (this.eat(17)) {
            let i = this.startNodeAt(e);
            return (
              (i.test = t),
              (i.consequent = this.parseMaybeAssignAllowIn()),
              this.expect(14),
              (i.alternate = this.parseMaybeAssign()),
              this.finishNode(i, "ConditionalExpression")
            );
          }
          return t;
        }
        parseMaybeUnaryOrPrivate(t) {
          return this.match(138)
            ? this.parsePrivateName()
            : this.parseMaybeUnary(t);
        }
        parseExprOps(t) {
          let e = this.state.startLoc,
            s = this.state.potentialArrowAt,
            i = this.parseMaybeUnaryOrPrivate(t);
          return this.shouldExitDescending(i, s)
            ? i
            : this.parseExprOp(i, e, -1);
        }
        parseExprOp(t, e, s) {
          if (this.isPrivateName(t)) {
            let r = this.getPrivateNameSV(t);
            (s >= Ie(58) || !this.prodParam.hasIn || !this.match(58)) &&
              this.raise(p.PrivateInExpectedIn, t, { identifierName: r }),
              this.classScope.usePrivateName(r, t.loc.start);
          }
          let i = this.state.type;
          if (pi(i) && (this.prodParam.hasIn || !this.match(58))) {
            let r = Ie(i);
            if (r > s) {
              if (i === 39) {
                if (
                  (this.expectPlugin("pipelineOperator"),
                  this.state.inFSharpPipelineDirectBody)
                )
                  return t;
                this.checkPipelineAtInfixOperator(t, e);
              }
              let n = this.startNodeAt(e);
              (n.left = t), (n.operator = this.state.value);
              let o = i === 41 || i === 42,
                h = i === 40;
              if (
                (h && (r = Ie(42)),
                this.next(),
                i === 39 &&
                  this.hasPlugin([
                    "pipelineOperator",
                    { proposal: "minimal" },
                  ]) &&
                  this.state.type === 96 &&
                  this.prodParam.hasAwait)
              )
                throw this.raise(
                  p.UnexpectedAwaitAfterPipelineBody,
                  this.state.startLoc,
                );
              n.right = this.parseExprOpRightExpr(i, r);
              let c = this.finishNode(
                  n,
                  o || h ? "LogicalExpression" : "BinaryExpression",
                ),
                l = this.state.type;
              if ((h && (l === 41 || l === 42)) || (o && l === 40))
                throw this.raise(
                  p.MixingCoalesceWithLogical,
                  this.state.startLoc,
                );
              return this.parseExprOp(c, e, s);
            }
          }
          return t;
        }
        parseExprOpRightExpr(t, e) {
          let s = this.state.startLoc;
          switch (t) {
            case 39:
              switch (this.getPluginOption("pipelineOperator", "proposal")) {
                case "hack":
                  return this.withTopicBindingContext(() =>
                    this.parseHackPipeBody(),
                  );
                case "smart":
                  return this.withTopicBindingContext(() => {
                    if (this.prodParam.hasYield && this.isContextual(108))
                      throw this.raise(
                        p.PipeBodyIsTighter,
                        this.state.startLoc,
                      );
                    return this.parseSmartPipelineBodyInStyle(
                      this.parseExprOpBaseRightExpr(t, e),
                      s,
                    );
                  });
                case "fsharp":
                  return this.withSoloAwaitPermittingContext(() =>
                    this.parseFSharpPipelineBody(e),
                  );
              }
            default:
              return this.parseExprOpBaseRightExpr(t, e);
          }
        }
        parseExprOpBaseRightExpr(t, e) {
          let s = this.state.startLoc;
          return this.parseExprOp(
            this.parseMaybeUnaryOrPrivate(),
            s,
            yi(t) ? e - 1 : e,
          );
        }
        parseHackPipeBody() {
          var t;
          let { startLoc: e } = this.state,
            s = this.parseMaybeAssign();
          return (
            Qs.has(s.type) &&
              !((t = s.extra) != null && t.parenthesized) &&
              this.raise(p.PipeUnparenthesizedBody, e, { type: s.type }),
            this.topicReferenceWasUsedInCurrentContext() ||
              this.raise(p.PipeTopicUnused, e),
            s
          );
        }
        checkExponentialAfterUnary(t) {
          this.match(57) &&
            this.raise(p.UnexpectedTokenUnaryExponentiation, t.argument);
        }
        parseMaybeUnary(t, e) {
          let s = this.state.startLoc,
            i = this.isContextual(96);
          if (i && this.isAwaitAllowed()) {
            this.next();
            let h = this.parseAwait(s);
            return e || this.checkExponentialAfterUnary(h), h;
          }
          let r = this.match(34),
            n = this.startNode();
          if (fi(this.state.type)) {
            (n.operator = this.state.value),
              (n.prefix = !0),
              this.match(72) && this.expectPlugin("throwExpressions");
            let h = this.match(89);
            if (
              (this.next(),
              (n.argument = this.parseMaybeUnary(null, !0)),
              this.checkExpressionErrors(t, !0),
              this.state.strict && h)
            ) {
              let c = n.argument;
              c.type === "Identifier"
                ? this.raise(p.StrictDelete, n)
                : this.hasPropertyAsPrivateName(c) &&
                  this.raise(p.DeletePrivateField, n);
            }
            if (!r)
              return (
                e || this.checkExponentialAfterUnary(n),
                this.finishNode(n, "UnaryExpression")
              );
          }
          let o = this.parseUpdate(n, r, t);
          if (i) {
            let { type: h } = this.state;
            if (
              (this.hasPlugin("v8intrinsic")
                ? He(h)
                : He(h) && !this.match(54)) &&
              !this.isAmbiguousAwait()
            )
              return (
                this.raiseOverwrite(p.AwaitNotInAsyncContext, s),
                this.parseAwait(s)
              );
          }
          return o;
        }
        parseUpdate(t, e, s) {
          if (e) {
            let n = t;
            return (
              this.checkLVal(n.argument, {
                in: this.finishNode(n, "UpdateExpression"),
              }),
              t
            );
          }
          let i = this.state.startLoc,
            r = this.parseExprSubscripts(s);
          if (this.checkExpressionErrors(s, !1)) return r;
          for (; ui(this.state.type) && !this.canInsertSemicolon(); ) {
            let n = this.startNodeAt(i);
            (n.operator = this.state.value),
              (n.prefix = !1),
              (n.argument = r),
              this.next(),
              this.checkLVal(r, {
                in: (r = this.finishNode(n, "UpdateExpression")),
              });
          }
          return r;
        }
        parseExprSubscripts(t) {
          let e = this.state.startLoc,
            s = this.state.potentialArrowAt,
            i = this.parseExprAtom(t);
          return this.shouldExitDescending(i, s)
            ? i
            : this.parseSubscripts(i, e);
        }
        parseSubscripts(t, e, s) {
          let i = {
            optionalChainMember: !1,
            maybeAsyncArrow: this.atPossibleAsyncArrow(t),
            stop: !1,
          };
          do (t = this.parseSubscript(t, e, s, i)), (i.maybeAsyncArrow = !1);
          while (!i.stop);
          return t;
        }
        parseSubscript(t, e, s, i) {
          let { type: r } = this.state;
          if (!s && r === 15) return this.parseBind(t, e, s, i);
          if (Le(r)) return this.parseTaggedTemplateExpression(t, e, i);
          let n = !1;
          if (r === 18) {
            if (
              s &&
              (this.raise(p.OptionalChainingNoNew, this.state.startLoc),
              this.lookaheadCharCode() === 40)
            )
              return (i.stop = !0), t;
            (i.optionalChainMember = n = !0), this.next();
          }
          if (!s && this.match(10))
            return this.parseCoverCallAndAsyncArrowHead(t, e, i, n);
          {
            let o = this.eat(0);
            return o || n || this.eat(16)
              ? this.parseMember(t, e, i, o, n)
              : ((i.stop = !0), t);
          }
        }
        parseMember(t, e, s, i, r) {
          let n = this.startNodeAt(e);
          return (
            (n.object = t),
            (n.computed = i),
            i
              ? ((n.property = this.parseExpression()), this.expect(3))
              : this.match(138)
                ? (t.type === "Super" && this.raise(p.SuperPrivateField, e),
                  this.classScope.usePrivateName(
                    this.state.value,
                    this.state.startLoc,
                  ),
                  (n.property = this.parsePrivateName()))
                : (n.property = this.parseIdentifier(!0)),
            s.optionalChainMember
              ? ((n.optional = r),
                this.finishNode(n, "OptionalMemberExpression"))
              : this.finishNode(n, "MemberExpression")
          );
        }
        parseBind(t, e, s, i) {
          let r = this.startNodeAt(e);
          return (
            (r.object = t),
            this.next(),
            (r.callee = this.parseNoCallExpr()),
            (i.stop = !0),
            this.parseSubscripts(this.finishNode(r, "BindExpression"), e, s)
          );
        }
        parseCoverCallAndAsyncArrowHead(t, e, s, i) {
          let r = this.state.maybeInArrowParameters,
            n = null;
          (this.state.maybeInArrowParameters = !0), this.next();
          let o = this.startNodeAt(e);
          o.callee = t;
          let { maybeAsyncArrow: h, optionalChainMember: c } = s;
          h && (this.expressionScope.enter(Fi()), (n = new Z())),
            c && (o.optional = i),
            i
              ? (o.arguments = this.parseCallExpressionArguments(11))
              : (o.arguments = this.parseCallExpressionArguments(
                  11,
                  t.type === "Import",
                  t.type !== "Super",
                  o,
                  n,
                ));
          let l = this.finishCallExpression(o, c);
          return (
            h && this.shouldParseAsyncArrow() && !i
              ? ((s.stop = !0),
                this.checkDestructuringPrivate(n),
                this.expressionScope.validateAsPattern(),
                this.expressionScope.exit(),
                (l = this.parseAsyncArrowFromCallExpression(
                  this.startNodeAt(e),
                  l,
                )))
              : (h &&
                  (this.checkExpressionErrors(n, !0),
                  this.expressionScope.exit()),
                this.toReferencedArguments(l)),
            (this.state.maybeInArrowParameters = r),
            l
          );
        }
        toReferencedArguments(t, e) {
          this.toReferencedListDeep(t.arguments, e);
        }
        parseTaggedTemplateExpression(t, e, s) {
          let i = this.startNodeAt(e);
          return (
            (i.tag = t),
            (i.quasi = this.parseTemplate(!0)),
            s.optionalChainMember &&
              this.raise(p.OptionalChainingNoTemplate, e),
            this.finishNode(i, "TaggedTemplateExpression")
          );
        }
        atPossibleAsyncArrow(t) {
          return (
            t.type === "Identifier" &&
            t.name === "async" &&
            this.state.lastTokEndLoc.index === t.end &&
            !this.canInsertSemicolon() &&
            t.end - t.start === 5 &&
            t.start === this.state.potentialArrowAt
          );
        }
        expectImportAttributesPlugin() {
          this.hasPlugin("importAssertions") ||
            this.expectPlugin("importAttributes");
        }
        finishCallExpression(t, e) {
          if (t.callee.type === "Import")
            if (
              (t.arguments.length === 2 &&
                (this.hasPlugin("moduleAttributes") ||
                  this.expectImportAttributesPlugin()),
              t.arguments.length === 0 || t.arguments.length > 2)
            )
              this.raise(p.ImportCallArity, t, {
                maxArgumentCount:
                  this.hasPlugin("importAttributes") ||
                  this.hasPlugin("importAssertions") ||
                  this.hasPlugin("moduleAttributes")
                    ? 2
                    : 1,
              });
            else
              for (let s of t.arguments)
                s.type === "SpreadElement" &&
                  this.raise(p.ImportCallSpreadArgument, s);
          return this.finishNode(
            t,
            e ? "OptionalCallExpression" : "CallExpression",
          );
        }
        parseCallExpressionArguments(t, e, s, i, r) {
          let n = [],
            o = !0,
            h = this.state.inFSharpPipelineDirectBody;
          for (this.state.inFSharpPipelineDirectBody = !1; !this.eat(t); ) {
            if (o) o = !1;
            else if ((this.expect(12), this.match(t))) {
              e &&
                !this.hasPlugin("importAttributes") &&
                !this.hasPlugin("importAssertions") &&
                !this.hasPlugin("moduleAttributes") &&
                this.raise(
                  p.ImportCallArgumentTrailingComma,
                  this.state.lastTokStartLoc,
                ),
                i && this.addTrailingCommaExtraToNode(i),
                this.next();
              break;
            }
            n.push(this.parseExprListItem(!1, r, s));
          }
          return (this.state.inFSharpPipelineDirectBody = h), n;
        }
        shouldParseAsyncArrow() {
          return this.match(19) && !this.canInsertSemicolon();
        }
        parseAsyncArrowFromCallExpression(t, e) {
          var s;
          return (
            this.resetPreviousNodeTrailingComments(e),
            this.expect(19),
            this.parseArrowExpression(
              t,
              e.arguments,
              !0,
              (s = e.extra) == null ? void 0 : s.trailingCommaLoc,
            ),
            e.innerComments && ye(t, e.innerComments),
            e.callee.trailingComments && ye(t, e.callee.trailingComments),
            t
          );
        }
        parseNoCallExpr() {
          let t = this.state.startLoc;
          return this.parseSubscripts(this.parseExprAtom(), t, !0);
        }
        parseExprAtom(t) {
          let e,
            s = null,
            { type: i } = this.state;
          switch (i) {
            case 79:
              return this.parseSuper();
            case 83:
              return (
                (e = this.startNode()),
                this.next(),
                this.match(16)
                  ? this.parseImportMetaProperty(e)
                  : this.match(10)
                    ? this.options.createImportExpressions
                      ? this.parseImportCall(e)
                      : this.finishNode(e, "Import")
                    : (this.raise(
                        p.UnsupportedImport,
                        this.state.lastTokStartLoc,
                      ),
                      this.finishNode(e, "Import"))
              );
            case 78:
              return (
                (e = this.startNode()),
                this.next(),
                this.finishNode(e, "ThisExpression")
              );
            case 90:
              return this.parseDo(this.startNode(), !1);
            case 56:
            case 31:
              return (
                this.readRegexp(), this.parseRegExpLiteral(this.state.value)
              );
            case 134:
              return this.parseNumericLiteral(this.state.value);
            case 135:
              return this.parseBigIntLiteral(this.state.value);
            case 136:
              return this.parseDecimalLiteral(this.state.value);
            case 133:
              return this.parseStringLiteral(this.state.value);
            case 84:
              return this.parseNullLiteral();
            case 85:
              return this.parseBooleanLiteral(!0);
            case 86:
              return this.parseBooleanLiteral(!1);
            case 10: {
              let r = this.state.potentialArrowAt === this.state.start;
              return this.parseParenAndDistinguishExpression(r);
            }
            case 2:
            case 1:
              return this.parseArrayLike(this.state.type === 2 ? 4 : 3, !1, !0);
            case 0:
              return this.parseArrayLike(3, !0, !1, t);
            case 6:
            case 7:
              return this.parseObjectLike(
                this.state.type === 6 ? 9 : 8,
                !1,
                !0,
              );
            case 5:
              return this.parseObjectLike(8, !1, !1, t);
            case 68:
              return this.parseFunctionOrFunctionSent();
            case 26:
              s = this.parseDecorators();
            case 80:
              return this.parseClass(
                this.maybeTakeDecorators(s, this.startNode()),
                !1,
              );
            case 77:
              return this.parseNewOrNewTarget();
            case 25:
            case 24:
              return this.parseTemplate(!1);
            case 15: {
              (e = this.startNode()), this.next(), (e.object = null);
              let r = (e.callee = this.parseNoCallExpr());
              if (r.type === "MemberExpression")
                return this.finishNode(e, "BindExpression");
              throw this.raise(p.UnsupportedBind, r);
            }
            case 138:
              return (
                this.raise(p.PrivateInExpectedIn, this.state.startLoc, {
                  identifierName: this.state.value,
                }),
                this.parsePrivateName()
              );
            case 33:
              return this.parseTopicReferenceThenEqualsSign(54, "%");
            case 32:
              return this.parseTopicReferenceThenEqualsSign(44, "^");
            case 37:
            case 38:
              return this.parseTopicReference("hack");
            case 44:
            case 54:
            case 27: {
              let r = this.getPluginOption("pipelineOperator", "proposal");
              if (r) return this.parseTopicReference(r);
              this.unexpected();
              break;
            }
            case 47: {
              let r = this.input.codePointAt(this.nextTokenStart());
              _(r) || r === 62
                ? this.expectOnePlugin(["jsx", "flow", "typescript"])
                : this.unexpected();
              break;
            }
            default:
              if (w(i)) {
                if (
                  this.isContextual(127) &&
                  this.lookaheadInLineCharCode() === 123
                )
                  return this.parseModuleExpression();
                let r = this.state.potentialArrowAt === this.state.start,
                  n = this.state.containsEsc,
                  o = this.parseIdentifier();
                if (!n && o.name === "async" && !this.canInsertSemicolon()) {
                  let { type: h } = this.state;
                  if (h === 68)
                    return (
                      this.resetPreviousNodeTrailingComments(o),
                      this.next(),
                      this.parseAsyncFunctionExpression(this.startNodeAtNode(o))
                    );
                  if (w(h))
                    return this.lookaheadCharCode() === 61
                      ? this.parseAsyncArrowUnaryFunction(
                          this.startNodeAtNode(o),
                        )
                      : o;
                  if (h === 90)
                    return (
                      this.resetPreviousNodeTrailingComments(o),
                      this.parseDo(this.startNodeAtNode(o), !0)
                    );
                }
                return r && this.match(19) && !this.canInsertSemicolon()
                  ? (this.next(),
                    this.parseArrowExpression(this.startNodeAtNode(o), [o], !1))
                  : o;
              } else this.unexpected();
          }
        }
        parseTopicReferenceThenEqualsSign(t, e) {
          let s = this.getPluginOption("pipelineOperator", "proposal");
          if (s)
            return (
              (this.state.type = t),
              (this.state.value = e),
              this.state.pos--,
              this.state.end--,
              (this.state.endLoc = v(this.state.endLoc, -1)),
              this.parseTopicReference(s)
            );
          this.unexpected();
        }
        parseTopicReference(t) {
          let e = this.startNode(),
            s = this.state.startLoc,
            i = this.state.type;
          return this.next(), this.finishTopicReference(e, s, t, i);
        }
        finishTopicReference(t, e, s, i) {
          if (this.testTopicReferenceConfiguration(s, e, i)) {
            let r =
              s === "smart"
                ? "PipelinePrimaryTopicReference"
                : "TopicReference";
            return (
              this.topicReferenceIsAllowedInCurrentContext() ||
                this.raise(
                  s === "smart" ? p.PrimaryTopicNotAllowed : p.PipeTopicUnbound,
                  e,
                ),
              this.registerTopicReference(),
              this.finishNode(t, r)
            );
          } else
            throw this.raise(p.PipeTopicUnconfiguredToken, e, { token: K(i) });
        }
        testTopicReferenceConfiguration(t, e, s) {
          switch (t) {
            case "hack":
              return this.hasPlugin(["pipelineOperator", { topicToken: K(s) }]);
            case "smart":
              return s === 27;
            default:
              throw this.raise(p.PipeTopicRequiresHackPipes, e);
          }
        }
        parseAsyncArrowUnaryFunction(t) {
          this.prodParam.enter(ke(!0, this.prodParam.hasYield));
          let e = [this.parseIdentifier()];
          return (
            this.prodParam.exit(),
            this.hasPrecedingLineBreak() &&
              this.raise(p.LineTerminatorBeforeArrow, this.state.curPosition()),
            this.expect(19),
            this.parseArrowExpression(t, e, !0)
          );
        }
        parseDo(t, e) {
          this.expectPlugin("doExpressions"),
            e && this.expectPlugin("asyncDoExpressions"),
            (t.async = e),
            this.next();
          let s = this.state.labels;
          return (
            (this.state.labels = []),
            e
              ? (this.prodParam.enter(2),
                (t.body = this.parseBlock()),
                this.prodParam.exit())
              : (t.body = this.parseBlock()),
            (this.state.labels = s),
            this.finishNode(t, "DoExpression")
          );
        }
        parseSuper() {
          let t = this.startNode();
          return (
            this.next(),
            this.match(10) &&
            !this.scope.allowDirectSuper &&
            !this.options.allowSuperOutsideMethod
              ? this.raise(p.SuperNotAllowed, t)
              : !this.scope.allowSuper &&
                !this.options.allowSuperOutsideMethod &&
                this.raise(p.UnexpectedSuper, t),
            !this.match(10) &&
              !this.match(0) &&
              !this.match(16) &&
              this.raise(p.UnsupportedSuper, t),
            this.finishNode(t, "Super")
          );
        }
        parsePrivateName() {
          let t = this.startNode(),
            e = this.startNodeAt(v(this.state.startLoc, 1)),
            s = this.state.value;
          return (
            this.next(),
            (t.id = this.createIdentifier(e, s)),
            this.finishNode(t, "PrivateName")
          );
        }
        parseFunctionOrFunctionSent() {
          let t = this.startNode();
          if ((this.next(), this.prodParam.hasYield && this.match(16))) {
            let e = this.createIdentifier(this.startNodeAtNode(t), "function");
            return (
              this.next(),
              this.match(103)
                ? this.expectPlugin("functionSent")
                : this.hasPlugin("functionSent") || this.unexpected(),
              this.parseMetaProperty(t, e, "sent")
            );
          }
          return this.parseFunction(t);
        }
        parseMetaProperty(t, e, s) {
          t.meta = e;
          let i = this.state.containsEsc;
          return (
            (t.property = this.parseIdentifier(!0)),
            (t.property.name !== s || i) &&
              this.raise(p.UnsupportedMetaProperty, t.property, {
                target: e.name,
                onlyValidPropertyName: s,
              }),
            this.finishNode(t, "MetaProperty")
          );
        }
        parseImportMetaProperty(t) {
          let e = this.createIdentifier(this.startNodeAtNode(t), "import");
          if ((this.next(), this.isContextual(101)))
            this.inModule || this.raise(p.ImportMetaOutsideModule, e),
              (this.sawUnambiguousESM = !0);
          else if (this.isContextual(105) || this.isContextual(97)) {
            let s = this.isContextual(105);
            if (
              (s || this.unexpected(),
              this.expectPlugin(
                s ? "sourcePhaseImports" : "deferredImportEvaluation",
              ),
              !this.options.createImportExpressions)
            )
              throw this.raise(
                p.DynamicImportPhaseRequiresImportExpressions,
                this.state.startLoc,
                { phase: this.state.value },
              );
            return (
              this.next(),
              (t.phase = s ? "source" : "defer"),
              this.parseImportCall(t)
            );
          }
          return this.parseMetaProperty(t, e, "meta");
        }
        parseLiteralAtNode(t, e, s) {
          return (
            this.addExtra(s, "rawValue", t),
            this.addExtra(s, "raw", this.input.slice(s.start, this.state.end)),
            (s.value = t),
            this.next(),
            this.finishNode(s, e)
          );
        }
        parseLiteral(t, e) {
          let s = this.startNode();
          return this.parseLiteralAtNode(t, e, s);
        }
        parseStringLiteral(t) {
          return this.parseLiteral(t, "StringLiteral");
        }
        parseNumericLiteral(t) {
          return this.parseLiteral(t, "NumericLiteral");
        }
        parseBigIntLiteral(t) {
          return this.parseLiteral(t, "BigIntLiteral");
        }
        parseDecimalLiteral(t) {
          return this.parseLiteral(t, "DecimalLiteral");
        }
        parseRegExpLiteral(t) {
          let e = this.startNode();
          return (
            this.addExtra(e, "raw", this.input.slice(e.start, this.state.end)),
            (e.pattern = t.pattern),
            (e.flags = t.flags),
            this.next(),
            this.finishNode(e, "RegExpLiteral")
          );
        }
        parseBooleanLiteral(t) {
          let e = this.startNode();
          return (
            (e.value = t), this.next(), this.finishNode(e, "BooleanLiteral")
          );
        }
        parseNullLiteral() {
          let t = this.startNode();
          return this.next(), this.finishNode(t, "NullLiteral");
        }
        parseParenAndDistinguishExpression(t) {
          let e = this.state.startLoc,
            s;
          this.next(), this.expressionScope.enter(Oi());
          let i = this.state.maybeInArrowParameters,
            r = this.state.inFSharpPipelineDirectBody;
          (this.state.maybeInArrowParameters = !0),
            (this.state.inFSharpPipelineDirectBody = !1);
          let n = this.state.startLoc,
            o = [],
            h = new Z(),
            c = !0,
            l,
            u;
          for (; !this.match(11); ) {
            if (c) c = !1;
            else if (
              (this.expect(
                12,
                h.optionalParametersLoc === null
                  ? null
                  : h.optionalParametersLoc,
              ),
              this.match(11))
            ) {
              u = this.state.startLoc;
              break;
            }
            if (this.match(21)) {
              let y = this.state.startLoc;
              if (
                ((l = this.state.startLoc),
                o.push(this.parseParenItem(this.parseRestBinding(), y)),
                !this.checkCommaAfterRest(41))
              )
                break;
            } else o.push(this.parseMaybeAssignAllowIn(h, this.parseParenItem));
          }
          let f = this.state.lastTokEndLoc;
          this.expect(11),
            (this.state.maybeInArrowParameters = i),
            (this.state.inFSharpPipelineDirectBody = r);
          let d = this.startNodeAt(e);
          return t && this.shouldParseArrow(o) && (d = this.parseArrow(d))
            ? (this.checkDestructuringPrivate(h),
              this.expressionScope.validateAsPattern(),
              this.expressionScope.exit(),
              this.parseArrowExpression(d, o, !1),
              d)
            : (this.expressionScope.exit(),
              o.length || this.unexpected(this.state.lastTokStartLoc),
              u && this.unexpected(u),
              l && this.unexpected(l),
              this.checkExpressionErrors(h, !0),
              this.toReferencedListDeep(o, !0),
              o.length > 1
                ? ((s = this.startNodeAt(n)),
                  (s.expressions = o),
                  this.finishNode(s, "SequenceExpression"),
                  this.resetEndLocation(s, f))
                : (s = o[0]),
              this.wrapParenthesis(e, s));
        }
        wrapParenthesis(t, e) {
          if (!this.options.createParenthesizedExpressions)
            return (
              this.addExtra(e, "parenthesized", !0),
              this.addExtra(e, "parenStart", t.index),
              this.takeSurroundingComments(
                e,
                t.index,
                this.state.lastTokEndLoc.index,
              ),
              e
            );
          let s = this.startNodeAt(t);
          return (
            (s.expression = e), this.finishNode(s, "ParenthesizedExpression")
          );
        }
        shouldParseArrow(t) {
          return !this.canInsertSemicolon();
        }
        parseArrow(t) {
          if (this.eat(19)) return t;
        }
        parseParenItem(t, e) {
          return t;
        }
        parseNewOrNewTarget() {
          let t = this.startNode();
          if ((this.next(), this.match(16))) {
            let e = this.createIdentifier(this.startNodeAtNode(t), "new");
            this.next();
            let s = this.parseMetaProperty(t, e, "target");
            return (
              !this.scope.inNonArrowFunction &&
                !this.scope.inClass &&
                !this.options.allowNewTargetOutsideFunction &&
                this.raise(p.UnexpectedNewTarget, s),
              s
            );
          }
          return this.parseNew(t);
        }
        parseNew(t) {
          if ((this.parseNewCallee(t), this.eat(10))) {
            let e = this.parseExprList(11);
            this.toReferencedList(e), (t.arguments = e);
          } else t.arguments = [];
          return this.finishNode(t, "NewExpression");
        }
        parseNewCallee(t) {
          let e = this.match(83),
            s = this.parseNoCallExpr();
          (t.callee = s),
            e &&
              (s.type === "Import" || s.type === "ImportExpression") &&
              this.raise(p.ImportCallNotNewExpression, s);
        }
        parseTemplateElement(t) {
          let { start: e, startLoc: s, end: i, value: r } = this.state,
            n = e + 1,
            o = this.startNodeAt(v(s, 1));
          r === null &&
            (t ||
              this.raise(
                p.InvalidEscapeSequenceTemplate,
                v(this.state.firstInvalidTemplateEscapePos, 1),
              ));
          let h = this.match(24),
            c = h ? -1 : -2,
            l = i + c;
          (o.value = {
            raw: this.input.slice(n, l).replace(
              /\r\n?/g,
              `
`,
            ),
            cooked: r === null ? null : r.slice(1, c),
          }),
            (o.tail = h),
            this.next();
          let u = this.finishNode(o, "TemplateElement");
          return this.resetEndLocation(u, v(this.state.lastTokEndLoc, c)), u;
        }
        parseTemplate(t) {
          let e = this.startNode(),
            s = this.parseTemplateElement(t),
            i = [s],
            r = [];
          for (; !s.tail; )
            r.push(this.parseTemplateSubstitution()),
              this.readTemplateContinuation(),
              i.push((s = this.parseTemplateElement(t)));
          return (
            (e.expressions = r),
            (e.quasis = i),
            this.finishNode(e, "TemplateLiteral")
          );
        }
        parseTemplateSubstitution() {
          return this.parseExpression();
        }
        parseObjectLike(t, e, s, i) {
          s && this.expectPlugin("recordAndTuple");
          let r = this.state.inFSharpPipelineDirectBody;
          this.state.inFSharpPipelineDirectBody = !1;
          let n = Object.create(null),
            o = !0,
            h = this.startNode();
          for (h.properties = [], this.next(); !this.match(t); ) {
            if (o) o = !1;
            else if ((this.expect(12), this.match(t))) {
              this.addTrailingCommaExtraToNode(h);
              break;
            }
            let l;
            e
              ? (l = this.parseBindingProperty())
              : ((l = this.parsePropertyDefinition(i)),
                this.checkProto(l, s, n, i)),
              s &&
                !this.isObjectProperty(l) &&
                l.type !== "SpreadElement" &&
                this.raise(p.InvalidRecordProperty, l),
              l.shorthand && this.addExtra(l, "shorthand", !0),
              h.properties.push(l);
          }
          this.next(), (this.state.inFSharpPipelineDirectBody = r);
          let c = "ObjectExpression";
          return (
            e ? (c = "ObjectPattern") : s && (c = "RecordExpression"),
            this.finishNode(h, c)
          );
        }
        addTrailingCommaExtraToNode(t) {
          this.addExtra(t, "trailingComma", this.state.lastTokStartLoc.index),
            this.addExtra(
              t,
              "trailingCommaLoc",
              this.state.lastTokStartLoc,
              !1,
            );
        }
        maybeAsyncOrAccessorProp(t) {
          return (
            !t.computed &&
            t.key.type === "Identifier" &&
            (this.isLiteralPropertyName() || this.match(0) || this.match(55))
          );
        }
        parsePropertyDefinition(t) {
          let e = [];
          if (this.match(26))
            for (
              this.hasPlugin("decorators") &&
              this.raise(p.UnsupportedPropertyDecorator, this.state.startLoc);
              this.match(26);

            )
              e.push(this.parseDecorator());
          let s = this.startNode(),
            i = !1,
            r = !1,
            n;
          if (this.match(21))
            return e.length && this.unexpected(), this.parseSpread();
          e.length && ((s.decorators = e), (e = [])),
            (s.method = !1),
            t && (n = this.state.startLoc);
          let o = this.eat(55);
          this.parsePropertyNamePrefixOperator(s);
          let h = this.state.containsEsc;
          if (
            (this.parsePropertyName(s, t),
            !o && !h && this.maybeAsyncOrAccessorProp(s))
          ) {
            let { key: c } = s,
              l = c.name;
            l === "async" &&
              !this.hasPrecedingLineBreak() &&
              ((i = !0),
              this.resetPreviousNodeTrailingComments(c),
              (o = this.eat(55)),
              this.parsePropertyName(s)),
              (l === "get" || l === "set") &&
                ((r = !0),
                this.resetPreviousNodeTrailingComments(c),
                (s.kind = l),
                this.match(55) &&
                  ((o = !0),
                  this.raise(p.AccessorIsGenerator, this.state.curPosition(), {
                    kind: l,
                  }),
                  this.next()),
                this.parsePropertyName(s));
          }
          return this.parseObjPropValue(s, n, o, i, !1, r, t);
        }
        getGetterSetterExpectedParamCount(t) {
          return t.kind === "get" ? 0 : 1;
        }
        getObjectOrClassMethodParams(t) {
          return t.params;
        }
        checkGetterSetterParams(t) {
          var e;
          let s = this.getGetterSetterExpectedParamCount(t),
            i = this.getObjectOrClassMethodParams(t);
          i.length !== s &&
            this.raise(
              t.kind === "get" ? p.BadGetterArity : p.BadSetterArity,
              t,
            ),
            t.kind === "set" &&
              ((e = i[i.length - 1]) == null ? void 0 : e.type) ===
                "RestElement" &&
              this.raise(p.BadSetterRestParameter, t);
        }
        parseObjectMethod(t, e, s, i, r) {
          if (r) {
            let n = this.parseMethod(t, e, !1, !1, !1, "ObjectMethod");
            return this.checkGetterSetterParams(n), n;
          }
          if (s || e || this.match(10))
            return (
              i && this.unexpected(),
              (t.kind = "method"),
              (t.method = !0),
              this.parseMethod(t, e, s, !1, !1, "ObjectMethod")
            );
        }
        parseObjectProperty(t, e, s, i) {
          if (((t.shorthand = !1), this.eat(14)))
            return (
              (t.value = s
                ? this.parseMaybeDefault(this.state.startLoc)
                : this.parseMaybeAssignAllowIn(i)),
              this.finishNode(t, "ObjectProperty")
            );
          if (!t.computed && t.key.type === "Identifier") {
            if (
              (this.checkReservedWord(t.key.name, t.key.loc.start, !0, !1), s)
            )
              t.value = this.parseMaybeDefault(e, $(t.key));
            else if (this.match(29)) {
              let r = this.state.startLoc;
              i != null
                ? i.shorthandAssignLoc === null && (i.shorthandAssignLoc = r)
                : this.raise(p.InvalidCoverInitializedName, r),
                (t.value = this.parseMaybeDefault(e, $(t.key)));
            } else t.value = $(t.key);
            return (t.shorthand = !0), this.finishNode(t, "ObjectProperty");
          }
        }
        parseObjPropValue(t, e, s, i, r, n, o) {
          let h =
            this.parseObjectMethod(t, s, i, r, n) ||
            this.parseObjectProperty(t, e, r, o);
          return h || this.unexpected(), h;
        }
        parsePropertyName(t, e) {
          if (this.eat(0))
            (t.computed = !0),
              (t.key = this.parseMaybeAssignAllowIn()),
              this.expect(3);
          else {
            let { type: s, value: i } = this.state,
              r;
            if (M(s)) r = this.parseIdentifier(!0);
            else
              switch (s) {
                case 134:
                  r = this.parseNumericLiteral(i);
                  break;
                case 133:
                  r = this.parseStringLiteral(i);
                  break;
                case 135:
                  r = this.parseBigIntLiteral(i);
                  break;
                case 136:
                  r = this.parseDecimalLiteral(i);
                  break;
                case 138: {
                  let n = this.state.startLoc;
                  e != null
                    ? e.privateKeyLoc === null && (e.privateKeyLoc = n)
                    : this.raise(p.UnexpectedPrivateField, n),
                    (r = this.parsePrivateName());
                  break;
                }
                default:
                  this.unexpected();
              }
            (t.key = r), s !== 138 && (t.computed = !1);
          }
        }
        initFunction(t, e) {
          (t.id = null), (t.generator = !1), (t.async = e);
        }
        parseMethod(t, e, s, i, r, n, o = !1) {
          this.initFunction(t, s),
            (t.generator = e),
            this.scope.enter(18 | (o ? 64 : 0) | (r ? 32 : 0)),
            this.prodParam.enter(ke(s, t.generator)),
            this.parseFunctionParams(t, i);
          let h = this.parseFunctionBodyAndFinish(t, n, !0);
          return this.prodParam.exit(), this.scope.exit(), h;
        }
        parseArrayLike(t, e, s, i) {
          s && this.expectPlugin("recordAndTuple");
          let r = this.state.inFSharpPipelineDirectBody;
          this.state.inFSharpPipelineDirectBody = !1;
          let n = this.startNode();
          return (
            this.next(),
            (n.elements = this.parseExprList(t, !s, i, n)),
            (this.state.inFSharpPipelineDirectBody = r),
            this.finishNode(n, s ? "TupleExpression" : "ArrayExpression")
          );
        }
        parseArrowExpression(t, e, s, i) {
          this.scope.enter(6);
          let r = ke(s, !1);
          !this.match(5) && this.prodParam.hasIn && (r |= 8),
            this.prodParam.enter(r),
            this.initFunction(t, s);
          let n = this.state.maybeInArrowParameters;
          return (
            e &&
              ((this.state.maybeInArrowParameters = !0),
              this.setArrowFunctionParameters(t, e, i)),
            (this.state.maybeInArrowParameters = !1),
            this.parseFunctionBody(t, !0),
            this.prodParam.exit(),
            this.scope.exit(),
            (this.state.maybeInArrowParameters = n),
            this.finishNode(t, "ArrowFunctionExpression")
          );
        }
        setArrowFunctionParameters(t, e, s) {
          this.toAssignableList(e, s, !1), (t.params = e);
        }
        parseFunctionBodyAndFinish(t, e, s = !1) {
          return this.parseFunctionBody(t, !1, s), this.finishNode(t, e);
        }
        parseFunctionBody(t, e, s = !1) {
          let i = e && !this.match(5);
          if ((this.expressionScope.enter(rs()), i))
            (t.body = this.parseMaybeAssign()), this.checkParams(t, !1, e, !1);
          else {
            let r = this.state.strict,
              n = this.state.labels;
            (this.state.labels = []),
              this.prodParam.enter(this.prodParam.currentFlags() | 4),
              (t.body = this.parseBlock(!0, !1, (o) => {
                let h = !this.isSimpleParamList(t.params);
                o &&
                  h &&
                  this.raise(
                    p.IllegalLanguageModeDirective,
                    (t.kind === "method" || t.kind === "constructor") && t.key
                      ? t.key.loc.end
                      : t,
                  );
                let c = !r && this.state.strict;
                this.checkParams(t, !this.state.strict && !e && !s && !h, e, c),
                  this.state.strict &&
                    t.id &&
                    this.checkIdentifier(t.id, 65, c);
              })),
              this.prodParam.exit(),
              (this.state.labels = n);
          }
          this.expressionScope.exit();
        }
        isSimpleParameter(t) {
          return t.type === "Identifier";
        }
        isSimpleParamList(t) {
          for (let e = 0, s = t.length; e < s; e++)
            if (!this.isSimpleParameter(t[e])) return !1;
          return !0;
        }
        checkParams(t, e, s, i = !0) {
          let r = !e && new Set(),
            n = { type: "FormalParameters" };
          for (let o of t.params)
            this.checkLVal(o, {
              in: n,
              binding: 5,
              checkClashes: r,
              strictModeChanged: i,
            });
        }
        parseExprList(t, e, s, i) {
          let r = [],
            n = !0;
          for (; !this.eat(t); ) {
            if (n) n = !1;
            else if ((this.expect(12), this.match(t))) {
              i && this.addTrailingCommaExtraToNode(i), this.next();
              break;
            }
            r.push(this.parseExprListItem(e, s));
          }
          return r;
        }
        parseExprListItem(t, e, s) {
          let i;
          if (this.match(12))
            t ||
              this.raise(p.UnexpectedToken, this.state.curPosition(), {
                unexpected: ",",
              }),
              (i = null);
          else if (this.match(21)) {
            let r = this.state.startLoc;
            i = this.parseParenItem(this.parseSpread(e), r);
          } else if (this.match(17)) {
            this.expectPlugin("partialApplication"),
              s ||
                this.raise(
                  p.UnexpectedArgumentPlaceholder,
                  this.state.startLoc,
                );
            let r = this.startNode();
            this.next(), (i = this.finishNode(r, "ArgumentPlaceholder"));
          } else i = this.parseMaybeAssignAllowIn(e, this.parseParenItem);
          return i;
        }
        parseIdentifier(t) {
          let e = this.startNode(),
            s = this.parseIdentifierName(t);
          return this.createIdentifier(e, s);
        }
        createIdentifier(t, e) {
          return (
            (t.name = e),
            (t.loc.identifierName = e),
            this.finishNode(t, "Identifier")
          );
        }
        parseIdentifierName(t) {
          let e,
            { startLoc: s, type: i } = this.state;
          M(i) ? (e = this.state.value) : this.unexpected();
          let r = oi(i);
          return (
            t
              ? r && this.replaceToken(132)
              : this.checkReservedWord(e, s, r, !1),
            this.next(),
            e
          );
        }
        checkReservedWord(t, e, s, i) {
          if (t.length > 10 || !Ei(t)) return;
          if (s && Si(t)) {
            this.raise(p.UnexpectedKeyword, e, { keyword: t });
            return;
          }
          if ((this.state.strict ? (i ? Zt : Yt) : Gt)(t, this.inModule)) {
            this.raise(p.UnexpectedReservedWord, e, { reservedWord: t });
            return;
          } else if (t === "yield") {
            if (this.prodParam.hasYield) {
              this.raise(p.YieldBindingIdentifier, e);
              return;
            }
          } else if (t === "await") {
            if (this.prodParam.hasAwait) {
              this.raise(p.AwaitBindingIdentifier, e);
              return;
            }
            if (this.scope.inStaticBlock) {
              this.raise(p.AwaitBindingIdentifierInStaticBlock, e);
              return;
            }
            this.expressionScope.recordAsyncArrowParametersError(e);
          } else if (
            t === "arguments" &&
            this.scope.inClassAndNotInNonArrowFunction
          ) {
            this.raise(p.ArgumentsInClass, e);
            return;
          }
        }
        isAwaitAllowed() {
          return !!(
            this.prodParam.hasAwait ||
            (this.options.allowAwaitOutsideFunction && !this.scope.inFunction)
          );
        }
        parseAwait(t) {
          let e = this.startNodeAt(t);
          return (
            this.expressionScope.recordParameterInitializerError(
              p.AwaitExpressionFormalParameter,
              e,
            ),
            this.eat(55) && this.raise(p.ObsoleteAwaitStar, e),
            !this.scope.inFunction &&
              !this.options.allowAwaitOutsideFunction &&
              (this.isAmbiguousAwait()
                ? (this.ambiguousScriptDifferentAst = !0)
                : (this.sawUnambiguousESM = !0)),
            this.state.soloAwait ||
              (e.argument = this.parseMaybeUnary(null, !0)),
            this.finishNode(e, "AwaitExpression")
          );
        }
        isAmbiguousAwait() {
          if (this.hasPrecedingLineBreak()) return !0;
          let { type: t } = this.state;
          return (
            t === 53 ||
            t === 10 ||
            t === 0 ||
            Le(t) ||
            (t === 102 && !this.state.containsEsc) ||
            t === 137 ||
            t === 56 ||
            (this.hasPlugin("v8intrinsic") && t === 54)
          );
        }
        parseYield() {
          let t = this.startNode();
          this.expressionScope.recordParameterInitializerError(
            p.YieldInParameter,
            t,
          ),
            this.next();
          let e = !1,
            s = null;
          if (!this.hasPrecedingLineBreak())
            switch (((e = this.eat(55)), this.state.type)) {
              case 13:
              case 139:
              case 8:
              case 11:
              case 3:
              case 9:
              case 14:
              case 12:
                if (!e) break;
              default:
                s = this.parseMaybeAssign();
            }
          return (
            (t.delegate = e),
            (t.argument = s),
            this.finishNode(t, "YieldExpression")
          );
        }
        parseImportCall(t) {
          return (
            this.next(),
            (t.source = this.parseMaybeAssignAllowIn()),
            (this.hasPlugin("importAttributes") ||
              this.hasPlugin("importAssertions")) &&
              (t.options = null),
            this.eat(12) &&
              (this.expectImportAttributesPlugin(),
              this.match(11) ||
                ((t.options = this.parseMaybeAssignAllowIn()), this.eat(12))),
            this.expect(11),
            this.finishNode(t, "ImportExpression")
          );
        }
        checkPipelineAtInfixOperator(t, e) {
          this.hasPlugin(["pipelineOperator", { proposal: "smart" }]) &&
            t.type === "SequenceExpression" &&
            this.raise(p.PipelineHeadSequenceExpression, e);
        }
        parseSmartPipelineBodyInStyle(t, e) {
          if (this.isSimpleReference(t)) {
            let s = this.startNodeAt(e);
            return (s.callee = t), this.finishNode(s, "PipelineBareFunction");
          } else {
            let s = this.startNodeAt(e);
            return (
              this.checkSmartPipeTopicBodyEarlyErrors(e),
              (s.expression = t),
              this.finishNode(s, "PipelineTopicExpression")
            );
          }
        }
        isSimpleReference(t) {
          switch (t.type) {
            case "MemberExpression":
              return !t.computed && this.isSimpleReference(t.object);
            case "Identifier":
              return !0;
            default:
              return !1;
          }
        }
        checkSmartPipeTopicBodyEarlyErrors(t) {
          if (this.match(19))
            throw this.raise(p.PipelineBodyNoArrow, this.state.startLoc);
          this.topicReferenceWasUsedInCurrentContext() ||
            this.raise(p.PipelineTopicUnused, t);
        }
        withTopicBindingContext(t) {
          let e = this.state.topicContext;
          this.state.topicContext = {
            maxNumOfResolvableTopics: 1,
            maxTopicIndex: null,
          };
          try {
            return t();
          } finally {
            this.state.topicContext = e;
          }
        }
        withSmartMixTopicForbiddingContext(t) {
          if (this.hasPlugin(["pipelineOperator", { proposal: "smart" }])) {
            let e = this.state.topicContext;
            this.state.topicContext = {
              maxNumOfResolvableTopics: 0,
              maxTopicIndex: null,
            };
            try {
              return t();
            } finally {
              this.state.topicContext = e;
            }
          } else return t();
        }
        withSoloAwaitPermittingContext(t) {
          let e = this.state.soloAwait;
          this.state.soloAwait = !0;
          try {
            return t();
          } finally {
            this.state.soloAwait = e;
          }
        }
        allowInAnd(t) {
          let e = this.prodParam.currentFlags();
          if (8 & ~e) {
            this.prodParam.enter(e | 8);
            try {
              return t();
            } finally {
              this.prodParam.exit();
            }
          }
          return t();
        }
        disallowInAnd(t) {
          let e = this.prodParam.currentFlags();
          if (8 & e) {
            this.prodParam.enter(e & -9);
            try {
              return t();
            } finally {
              this.prodParam.exit();
            }
          }
          return t();
        }
        registerTopicReference() {
          this.state.topicContext.maxTopicIndex = 0;
        }
        topicReferenceIsAllowedInCurrentContext() {
          return this.state.topicContext.maxNumOfResolvableTopics >= 1;
        }
        topicReferenceWasUsedInCurrentContext() {
          return (
            this.state.topicContext.maxTopicIndex != null &&
            this.state.topicContext.maxTopicIndex >= 0
          );
        }
        parseFSharpPipelineBody(t) {
          let e = this.state.startLoc;
          this.state.potentialArrowAt = this.state.start;
          let s = this.state.inFSharpPipelineDirectBody;
          this.state.inFSharpPipelineDirectBody = !0;
          let i = this.parseExprOp(this.parseMaybeUnaryOrPrivate(), e, t);
          return (this.state.inFSharpPipelineDirectBody = s), i;
        }
        parseModuleExpression() {
          this.expectPlugin("moduleBlocks");
          let t = this.startNode();
          this.next(), this.match(5) || this.unexpected(null, 5);
          let e = this.startNodeAt(this.state.endLoc);
          this.next();
          let s = this.initializeScopes(!0);
          this.enterInitialScopes();
          try {
            t.body = this.parseProgram(e, 8, "module");
          } finally {
            s();
          }
          return this.finishNode(t, "ModuleExpression");
        }
        parsePropertyNamePrefixOperator(t) {}
      },
      ze = { kind: 1 },
      ar = { kind: 2 },
      nr = /[\uD800-\uDFFF]/u,
      Ke = /in(?:stanceof)?/y;
    function or(a, t) {
      for (let e = 0; e < a.length; e++) {
        let s = a[e],
          { type: i } = s;
        if (typeof i == "number") {
          {
            if (i === 138) {
              let { loc: r, start: n, value: o, end: h } = s,
                c = n + 1,
                l = v(r.start, 1);
              a.splice(
                e,
                1,
                new O({
                  type: R(27),
                  value: "#",
                  start: n,
                  end: c,
                  startLoc: r.start,
                  endLoc: l,
                }),
                new O({
                  type: R(132),
                  value: o,
                  start: c,
                  end: h,
                  startLoc: l,
                  endLoc: r.end,
                }),
              ),
                e++;
              continue;
            }
            if (Le(i)) {
              let { loc: r, start: n, value: o, end: h } = s,
                c = n + 1,
                l = v(r.start, 1),
                u;
              t.charCodeAt(n) === 96
                ? (u = new O({
                    type: R(22),
                    value: "`",
                    start: n,
                    end: c,
                    startLoc: r.start,
                    endLoc: l,
                  }))
                : (u = new O({
                    type: R(8),
                    value: "}",
                    start: n,
                    end: c,
                    startLoc: r.start,
                    endLoc: l,
                  }));
              let f, d, y, E;
              i === 24
                ? ((d = h - 1),
                  (y = v(r.end, -1)),
                  (f = o === null ? null : o.slice(1, -1)),
                  (E = new O({
                    type: R(22),
                    value: "`",
                    start: d,
                    end: h,
                    startLoc: y,
                    endLoc: r.end,
                  })))
                : ((d = h - 2),
                  (y = v(r.end, -2)),
                  (f = o === null ? null : o.slice(1, -2)),
                  (E = new O({
                    type: R(23),
                    value: "${",
                    start: d,
                    end: h,
                    startLoc: y,
                    endLoc: r.end,
                  }))),
                a.splice(
                  e,
                  1,
                  u,
                  new O({
                    type: R(20),
                    value: f,
                    start: c,
                    end: d,
                    startLoc: l,
                    endLoc: y,
                  }),
                  E,
                ),
                (e += 2);
              continue;
            }
          }
          s.type = R(i);
        }
      }
      return a;
    }
    var pt = class extends ct {
        parseTopLevel(t, e) {
          return (
            (t.program = this.parseProgram(e)),
            (t.comments = this.comments),
            this.options.tokens && (t.tokens = or(this.tokens, this.input)),
            this.finishNode(t, "File")
          );
        }
        parseProgram(t, e = 139, s = this.options.sourceType) {
          if (
            ((t.sourceType = s),
            (t.interpreter = this.parseInterpreterDirective()),
            this.parseBlockBody(t, !0, !0, e),
            this.inModule &&
              !this.options.allowUndeclaredExports &&
              this.scope.undefinedExports.size > 0)
          )
            for (let [r, n] of Array.from(this.scope.undefinedExports))
              this.raise(p.ModuleExportUndefined, n, { localName: r });
          let i;
          return (
            e === 139
              ? (i = this.finishNode(t, "Program"))
              : (i = this.finishNodeAt(
                  t,
                  "Program",
                  v(this.state.startLoc, -1),
                )),
            i
          );
        }
        stmtToDirective(t) {
          let e = t;
          (e.type = "Directive"), (e.value = e.expression), delete e.expression;
          let s = e.value,
            i = s.value,
            r = this.input.slice(s.start, s.end),
            n = (s.value = r.slice(1, -1));
          return (
            this.addExtra(s, "raw", r),
            this.addExtra(s, "rawValue", n),
            this.addExtra(s, "expressionValue", i),
            (s.type = "DirectiveLiteral"),
            e
          );
        }
        parseInterpreterDirective() {
          if (!this.match(28)) return null;
          let t = this.startNode();
          return (
            (t.value = this.state.value),
            this.next(),
            this.finishNode(t, "InterpreterDirective")
          );
        }
        isLet() {
          return this.isContextual(100) ? this.hasFollowingBindingAtom() : !1;
        }
        chStartsBindingIdentifier(t, e) {
          if (_(t)) {
            if (((Ke.lastIndex = e), Ke.test(this.input))) {
              let s = this.codePointAtPos(Ke.lastIndex);
              if (!Q(s) && s !== 92) return !1;
            }
            return !0;
          } else return t === 92;
        }
        chStartsBindingPattern(t) {
          return t === 91 || t === 123;
        }
        hasFollowingBindingAtom() {
          let t = this.nextTokenStart(),
            e = this.codePointAtPos(t);
          return (
            this.chStartsBindingPattern(e) ||
            this.chStartsBindingIdentifier(e, t)
          );
        }
        hasInLineFollowingBindingIdentifierOrBrace() {
          let t = this.nextTokenInLineStart(),
            e = this.codePointAtPos(t);
          return e === 123 || this.chStartsBindingIdentifier(e, t);
        }
        startsUsingForOf() {
          let { type: t, containsEsc: e } = this.lookahead();
          if (t === 102 && !e) return !1;
          if (w(t) && !this.hasFollowingLineBreak())
            return this.expectPlugin("explicitResourceManagement"), !0;
        }
        startsAwaitUsing() {
          let t = this.nextTokenInLineStart();
          if (this.isUnparsedContextual(t, "using")) {
            t = this.nextTokenInLineStartSince(t + 5);
            let e = this.codePointAtPos(t);
            if (this.chStartsBindingIdentifier(e, t))
              return this.expectPlugin("explicitResourceManagement"), !0;
          }
          return !1;
        }
        parseModuleItem() {
          return this.parseStatementLike(15);
        }
        parseStatementListItem() {
          return this.parseStatementLike(
            6 | (!this.options.annexB || this.state.strict ? 0 : 8),
          );
        }
        parseStatementOrSloppyAnnexBFunctionDeclaration(t = !1) {
          let e = 0;
          return (
            this.options.annexB &&
              !this.state.strict &&
              ((e |= 4), t && (e |= 8)),
            this.parseStatementLike(e)
          );
        }
        parseStatement() {
          return this.parseStatementLike(0);
        }
        parseStatementLike(t) {
          let e = null;
          return (
            this.match(26) && (e = this.parseDecorators(!0)),
            this.parseStatementContent(t, e)
          );
        }
        parseStatementContent(t, e) {
          let s = this.state.type,
            i = this.startNode(),
            r = !!(t & 2),
            n = !!(t & 4),
            o = t & 1;
          switch (s) {
            case 60:
              return this.parseBreakContinueStatement(i, !0);
            case 63:
              return this.parseBreakContinueStatement(i, !1);
            case 64:
              return this.parseDebuggerStatement(i);
            case 90:
              return this.parseDoWhileStatement(i);
            case 91:
              return this.parseForStatement(i);
            case 68:
              if (this.lookaheadCharCode() === 46) break;
              return (
                n ||
                  this.raise(
                    this.state.strict
                      ? p.StrictFunction
                      : this.options.annexB
                        ? p.SloppyFunctionAnnexB
                        : p.SloppyFunction,
                    this.state.startLoc,
                  ),
                this.parseFunctionStatement(i, !1, !r && n)
              );
            case 80:
              return (
                r || this.unexpected(),
                this.parseClass(this.maybeTakeDecorators(e, i), !0)
              );
            case 69:
              return this.parseIfStatement(i);
            case 70:
              return this.parseReturnStatement(i);
            case 71:
              return this.parseSwitchStatement(i);
            case 72:
              return this.parseThrowStatement(i);
            case 73:
              return this.parseTryStatement(i);
            case 96:
              if (!this.state.containsEsc && this.startsAwaitUsing())
                return (
                  this.isAwaitAllowed()
                    ? r || this.raise(p.UnexpectedLexicalDeclaration, i)
                    : this.raise(p.AwaitUsingNotInAsyncContext, i),
                  this.next(),
                  this.parseVarStatement(i, "await using")
                );
              break;
            case 107:
              if (
                this.state.containsEsc ||
                !this.hasInLineFollowingBindingIdentifierOrBrace()
              )
                break;
              return (
                this.expectPlugin("explicitResourceManagement"),
                !this.scope.inModule && this.scope.inTopLevel
                  ? this.raise(
                      p.UnexpectedUsingDeclaration,
                      this.state.startLoc,
                    )
                  : r ||
                    this.raise(
                      p.UnexpectedLexicalDeclaration,
                      this.state.startLoc,
                    ),
                this.parseVarStatement(i, "using")
              );
            case 100: {
              if (this.state.containsEsc) break;
              let l = this.nextTokenStart(),
                u = this.codePointAtPos(l);
              if (
                u !== 91 &&
                ((!r && this.hasFollowingLineBreak()) ||
                  (!this.chStartsBindingIdentifier(u, l) && u !== 123))
              )
                break;
            }
            case 75:
              r ||
                this.raise(p.UnexpectedLexicalDeclaration, this.state.startLoc);
            case 74: {
              let l = this.state.value;
              return this.parseVarStatement(i, l);
            }
            case 92:
              return this.parseWhileStatement(i);
            case 76:
              return this.parseWithStatement(i);
            case 5:
              return this.parseBlock();
            case 13:
              return this.parseEmptyStatement(i);
            case 83: {
              let l = this.lookaheadCharCode();
              if (l === 40 || l === 46) break;
            }
            case 82: {
              !this.options.allowImportExportEverywhere &&
                !o &&
                this.raise(p.UnexpectedImportExport, this.state.startLoc),
                this.next();
              let l;
              return (
                s === 83
                  ? ((l = this.parseImport(i)),
                    l.type === "ImportDeclaration" &&
                      (!l.importKind || l.importKind === "value") &&
                      (this.sawUnambiguousESM = !0))
                  : ((l = this.parseExport(i, e)),
                    ((l.type === "ExportNamedDeclaration" &&
                      (!l.exportKind || l.exportKind === "value")) ||
                      (l.type === "ExportAllDeclaration" &&
                        (!l.exportKind || l.exportKind === "value")) ||
                      l.type === "ExportDefaultDeclaration") &&
                      (this.sawUnambiguousESM = !0)),
                this.assertModuleNodeAllowed(l),
                l
              );
            }
            default:
              if (this.isAsyncFunction())
                return (
                  r ||
                    this.raise(
                      p.AsyncFunctionInSingleStatementContext,
                      this.state.startLoc,
                    ),
                  this.next(),
                  this.parseFunctionStatement(i, !0, !r && n)
                );
          }
          let h = this.state.value,
            c = this.parseExpression();
          return w(s) && c.type === "Identifier" && this.eat(14)
            ? this.parseLabeledStatement(i, h, c, t)
            : this.parseExpressionStatement(i, c, e);
        }
        assertModuleNodeAllowed(t) {
          !this.options.allowImportExportEverywhere &&
            !this.inModule &&
            this.raise(p.ImportOutsideModule, t);
        }
        decoratorsEnabledBeforeExport() {
          return this.hasPlugin("decorators-legacy")
            ? !0
            : this.hasPlugin("decorators") &&
                this.getPluginOption("decorators", "decoratorsBeforeExport") !==
                  !1;
        }
        maybeTakeDecorators(t, e, s) {
          return (
            t &&
              (e.decorators && e.decorators.length > 0
                ? (typeof this.getPluginOption(
                    "decorators",
                    "decoratorsBeforeExport",
                  ) != "boolean" &&
                    this.raise(p.DecoratorsBeforeAfterExport, e.decorators[0]),
                  e.decorators.unshift(...t))
                : (e.decorators = t),
              this.resetStartLocationFromNode(e, t[0]),
              s && this.resetStartLocationFromNode(s, e)),
            e
          );
        }
        canHaveLeadingDecorator() {
          return this.match(80);
        }
        parseDecorators(t) {
          let e = [];
          do e.push(this.parseDecorator());
          while (this.match(26));
          if (this.match(82))
            t || this.unexpected(),
              this.decoratorsEnabledBeforeExport() ||
                this.raise(p.DecoratorExportClass, this.state.startLoc);
          else if (!this.canHaveLeadingDecorator())
            throw this.raise(p.UnexpectedLeadingDecorator, this.state.startLoc);
          return e;
        }
        parseDecorator() {
          this.expectOnePlugin(["decorators", "decorators-legacy"]);
          let t = this.startNode();
          if ((this.next(), this.hasPlugin("decorators"))) {
            let e = this.state.startLoc,
              s;
            if (this.match(10)) {
              let i = this.state.startLoc;
              this.next(),
                (s = this.parseExpression()),
                this.expect(11),
                (s = this.wrapParenthesis(i, s));
              let r = this.state.startLoc;
              (t.expression = this.parseMaybeDecoratorArguments(s)),
                this.getPluginOption("decorators", "allowCallParenthesized") ===
                  !1 &&
                  t.expression !== s &&
                  this.raise(p.DecoratorArgumentsOutsideParentheses, r);
            } else {
              for (s = this.parseIdentifier(!1); this.eat(16); ) {
                let i = this.startNodeAt(e);
                (i.object = s),
                  this.match(138)
                    ? (this.classScope.usePrivateName(
                        this.state.value,
                        this.state.startLoc,
                      ),
                      (i.property = this.parsePrivateName()))
                    : (i.property = this.parseIdentifier(!0)),
                  (i.computed = !1),
                  (s = this.finishNode(i, "MemberExpression"));
              }
              t.expression = this.parseMaybeDecoratorArguments(s);
            }
          } else t.expression = this.parseExprSubscripts();
          return this.finishNode(t, "Decorator");
        }
        parseMaybeDecoratorArguments(t) {
          if (this.eat(10)) {
            let e = this.startNodeAtNode(t);
            return (
              (e.callee = t),
              (e.arguments = this.parseCallExpressionArguments(11, !1)),
              this.toReferencedList(e.arguments),
              this.finishNode(e, "CallExpression")
            );
          }
          return t;
        }
        parseBreakContinueStatement(t, e) {
          return (
            this.next(),
            this.isLineTerminator()
              ? (t.label = null)
              : ((t.label = this.parseIdentifier()), this.semicolon()),
            this.verifyBreakContinue(t, e),
            this.finishNode(t, e ? "BreakStatement" : "ContinueStatement")
          );
        }
        verifyBreakContinue(t, e) {
          let s;
          for (s = 0; s < this.state.labels.length; ++s) {
            let i = this.state.labels[s];
            if (
              (t.label == null || i.name === t.label.name) &&
              ((i.kind != null && (e || i.kind === 1)) || (t.label && e))
            )
              break;
          }
          if (s === this.state.labels.length) {
            let i = e ? "BreakStatement" : "ContinueStatement";
            this.raise(p.IllegalBreakContinue, t, { type: i });
          }
        }
        parseDebuggerStatement(t) {
          return (
            this.next(),
            this.semicolon(),
            this.finishNode(t, "DebuggerStatement")
          );
        }
        parseHeaderExpression() {
          this.expect(10);
          let t = this.parseExpression();
          return this.expect(11), t;
        }
        parseDoWhileStatement(t) {
          return (
            this.next(),
            this.state.labels.push(ze),
            (t.body = this.withSmartMixTopicForbiddingContext(() =>
              this.parseStatement(),
            )),
            this.state.labels.pop(),
            this.expect(92),
            (t.test = this.parseHeaderExpression()),
            this.eat(13),
            this.finishNode(t, "DoWhileStatement")
          );
        }
        parseForStatement(t) {
          this.next(), this.state.labels.push(ze);
          let e = null;
          if (
            (this.isAwaitAllowed() &&
              this.eatContextual(96) &&
              (e = this.state.lastTokStartLoc),
            this.scope.enter(0),
            this.expect(10),
            this.match(13))
          )
            return e !== null && this.unexpected(e), this.parseFor(t, null);
          let s = this.isContextual(100);
          {
            let h = this.isContextual(96) && this.startsAwaitUsing(),
              c = h || (this.isContextual(107) && this.startsUsingForOf()),
              l = (s && this.hasFollowingBindingAtom()) || c;
            if (this.match(74) || this.match(75) || l) {
              let u = this.startNode(),
                f;
              h
                ? ((f = "await using"),
                  this.isAwaitAllowed() ||
                    this.raise(
                      p.AwaitUsingNotInAsyncContext,
                      this.state.startLoc,
                    ),
                  this.next())
                : (f = this.state.value),
                this.next(),
                this.parseVar(u, !0, f);
              let d = this.finishNode(u, "VariableDeclaration"),
                y = this.match(58);
              return (
                y && c && this.raise(p.ForInUsing, d),
                (y || this.isContextual(102)) && d.declarations.length === 1
                  ? this.parseForIn(t, d, e)
                  : (e !== null && this.unexpected(e), this.parseFor(t, d))
              );
            }
          }
          let i = this.isContextual(95),
            r = new Z(),
            n = this.parseExpression(!0, r),
            o = this.isContextual(102);
          if (
            (o &&
              (s && this.raise(p.ForOfLet, n),
              e === null &&
                i &&
                n.type === "Identifier" &&
                this.raise(p.ForOfAsync, n)),
            o || this.match(58))
          ) {
            this.checkDestructuringPrivate(r), this.toAssignable(n, !0);
            let h = o ? "ForOfStatement" : "ForInStatement";
            return (
              this.checkLVal(n, { in: { type: h } }), this.parseForIn(t, n, e)
            );
          } else this.checkExpressionErrors(r, !0);
          return e !== null && this.unexpected(e), this.parseFor(t, n);
        }
        parseFunctionStatement(t, e, s) {
          return (
            this.next(), this.parseFunction(t, 1 | (s ? 2 : 0) | (e ? 8 : 0))
          );
        }
        parseIfStatement(t) {
          return (
            this.next(),
            (t.test = this.parseHeaderExpression()),
            (t.consequent =
              this.parseStatementOrSloppyAnnexBFunctionDeclaration()),
            (t.alternate = this.eat(66)
              ? this.parseStatementOrSloppyAnnexBFunctionDeclaration()
              : null),
            this.finishNode(t, "IfStatement")
          );
        }
        parseReturnStatement(t) {
          return (
            !this.prodParam.hasReturn &&
              !this.options.allowReturnOutsideFunction &&
              this.raise(p.IllegalReturn, this.state.startLoc),
            this.next(),
            this.isLineTerminator()
              ? (t.argument = null)
              : ((t.argument = this.parseExpression()), this.semicolon()),
            this.finishNode(t, "ReturnStatement")
          );
        }
        parseSwitchStatement(t) {
          this.next(), (t.discriminant = this.parseHeaderExpression());
          let e = (t.cases = []);
          this.expect(5), this.state.labels.push(ar), this.scope.enter(0);
          let s;
          for (let i; !this.match(8); )
            if (this.match(61) || this.match(65)) {
              let r = this.match(61);
              s && this.finishNode(s, "SwitchCase"),
                e.push((s = this.startNode())),
                (s.consequent = []),
                this.next(),
                r
                  ? (s.test = this.parseExpression())
                  : (i &&
                      this.raise(
                        p.MultipleDefaultsInSwitch,
                        this.state.lastTokStartLoc,
                      ),
                    (i = !0),
                    (s.test = null)),
                this.expect(14);
            } else
              s
                ? s.consequent.push(this.parseStatementListItem())
                : this.unexpected();
          return (
            this.scope.exit(),
            s && this.finishNode(s, "SwitchCase"),
            this.next(),
            this.state.labels.pop(),
            this.finishNode(t, "SwitchStatement")
          );
        }
        parseThrowStatement(t) {
          return (
            this.next(),
            this.hasPrecedingLineBreak() &&
              this.raise(p.NewlineAfterThrow, this.state.lastTokEndLoc),
            (t.argument = this.parseExpression()),
            this.semicolon(),
            this.finishNode(t, "ThrowStatement")
          );
        }
        parseCatchClauseParam() {
          let t = this.parseBindingAtom();
          return (
            this.scope.enter(
              this.options.annexB && t.type === "Identifier" ? 8 : 0,
            ),
            this.checkLVal(t, { in: { type: "CatchClause" }, binding: 9 }),
            t
          );
        }
        parseTryStatement(t) {
          if (
            (this.next(),
            (t.block = this.parseBlock()),
            (t.handler = null),
            this.match(62))
          ) {
            let e = this.startNode();
            this.next(),
              this.match(10)
                ? (this.expect(10),
                  (e.param = this.parseCatchClauseParam()),
                  this.expect(11))
                : ((e.param = null), this.scope.enter(0)),
              (e.body = this.withSmartMixTopicForbiddingContext(() =>
                this.parseBlock(!1, !1),
              )),
              this.scope.exit(),
              (t.handler = this.finishNode(e, "CatchClause"));
          }
          return (
            (t.finalizer = this.eat(67) ? this.parseBlock() : null),
            !t.handler && !t.finalizer && this.raise(p.NoCatchOrFinally, t),
            this.finishNode(t, "TryStatement")
          );
        }
        parseVarStatement(t, e, s = !1) {
          return (
            this.next(),
            this.parseVar(t, !1, e, s),
            this.semicolon(),
            this.finishNode(t, "VariableDeclaration")
          );
        }
        parseWhileStatement(t) {
          return (
            this.next(),
            (t.test = this.parseHeaderExpression()),
            this.state.labels.push(ze),
            (t.body = this.withSmartMixTopicForbiddingContext(() =>
              this.parseStatement(),
            )),
            this.state.labels.pop(),
            this.finishNode(t, "WhileStatement")
          );
        }
        parseWithStatement(t) {
          return (
            this.state.strict && this.raise(p.StrictWith, this.state.startLoc),
            this.next(),
            (t.object = this.parseHeaderExpression()),
            (t.body = this.withSmartMixTopicForbiddingContext(() =>
              this.parseStatement(),
            )),
            this.finishNode(t, "WithStatement")
          );
        }
        parseEmptyStatement(t) {
          return this.next(), this.finishNode(t, "EmptyStatement");
        }
        parseLabeledStatement(t, e, s, i) {
          for (let n of this.state.labels)
            n.name === e &&
              this.raise(p.LabelRedeclaration, s, { labelName: e });
          let r = ci(this.state.type) ? 1 : this.match(71) ? 2 : null;
          for (let n = this.state.labels.length - 1; n >= 0; n--) {
            let o = this.state.labels[n];
            if (o.statementStart === t.start)
              (o.statementStart = this.state.start), (o.kind = r);
            else break;
          }
          return (
            this.state.labels.push({
              name: e,
              kind: r,
              statementStart: this.state.start,
            }),
            (t.body =
              i & 8
                ? this.parseStatementOrSloppyAnnexBFunctionDeclaration(!0)
                : this.parseStatement()),
            this.state.labels.pop(),
            (t.label = s),
            this.finishNode(t, "LabeledStatement")
          );
        }
        parseExpressionStatement(t, e, s) {
          return (
            (t.expression = e),
            this.semicolon(),
            this.finishNode(t, "ExpressionStatement")
          );
        }
        parseBlock(t = !1, e = !0, s) {
          let i = this.startNode();
          return (
            t && this.state.strictErrors.clear(),
            this.expect(5),
            e && this.scope.enter(0),
            this.parseBlockBody(i, t, !1, 8, s),
            e && this.scope.exit(),
            this.finishNode(i, "BlockStatement")
          );
        }
        isValidDirective(t) {
          return (
            t.type === "ExpressionStatement" &&
            t.expression.type === "StringLiteral" &&
            !t.expression.extra.parenthesized
          );
        }
        parseBlockBody(t, e, s, i, r) {
          let n = (t.body = []),
            o = (t.directives = []);
          this.parseBlockOrModuleBlockBody(n, e ? o : void 0, s, i, r);
        }
        parseBlockOrModuleBlockBody(t, e, s, i, r) {
          let n = this.state.strict,
            o = !1,
            h = !1;
          for (; !this.match(i); ) {
            let c = s ? this.parseModuleItem() : this.parseStatementListItem();
            if (e && !h) {
              if (this.isValidDirective(c)) {
                let l = this.stmtToDirective(c);
                e.push(l),
                  !o &&
                    l.value.value === "use strict" &&
                    ((o = !0), this.setStrict(!0));
                continue;
              }
              (h = !0), this.state.strictErrors.clear();
            }
            t.push(c);
          }
          r == null || r.call(this, o), n || this.setStrict(!1), this.next();
        }
        parseFor(t, e) {
          return (
            (t.init = e),
            this.semicolon(!1),
            (t.test = this.match(13) ? null : this.parseExpression()),
            this.semicolon(!1),
            (t.update = this.match(11) ? null : this.parseExpression()),
            this.expect(11),
            (t.body = this.withSmartMixTopicForbiddingContext(() =>
              this.parseStatement(),
            )),
            this.scope.exit(),
            this.state.labels.pop(),
            this.finishNode(t, "ForStatement")
          );
        }
        parseForIn(t, e, s) {
          let i = this.match(58);
          return (
            this.next(),
            i ? s !== null && this.unexpected(s) : (t.await = s !== null),
            e.type === "VariableDeclaration" &&
              e.declarations[0].init != null &&
              (!i ||
                !this.options.annexB ||
                this.state.strict ||
                e.kind !== "var" ||
                e.declarations[0].id.type !== "Identifier") &&
              this.raise(p.ForInOfLoopInitializer, e, {
                type: i ? "ForInStatement" : "ForOfStatement",
              }),
            e.type === "AssignmentPattern" &&
              this.raise(p.InvalidLhs, e, {
                ancestor: { type: "ForStatement" },
              }),
            (t.left = e),
            (t.right = i
              ? this.parseExpression()
              : this.parseMaybeAssignAllowIn()),
            this.expect(11),
            (t.body = this.withSmartMixTopicForbiddingContext(() =>
              this.parseStatement(),
            )),
            this.scope.exit(),
            this.state.labels.pop(),
            this.finishNode(t, i ? "ForInStatement" : "ForOfStatement")
          );
        }
        parseVar(t, e, s, i = !1) {
          let r = (t.declarations = []);
          for (t.kind = s; ; ) {
            let n = this.startNode();
            if (
              (this.parseVarId(n, s),
              (n.init = this.eat(29)
                ? e
                  ? this.parseMaybeAssignDisallowIn()
                  : this.parseMaybeAssignAllowIn()
                : null),
              n.init === null &&
                !i &&
                (n.id.type !== "Identifier" &&
                !(e && (this.match(58) || this.isContextual(102)))
                  ? this.raise(
                      p.DeclarationMissingInitializer,
                      this.state.lastTokEndLoc,
                      { kind: "destructuring" },
                    )
                  : (s === "const" || s === "using" || s === "await using") &&
                    !(this.match(58) || this.isContextual(102)) &&
                    this.raise(
                      p.DeclarationMissingInitializer,
                      this.state.lastTokEndLoc,
                      { kind: s },
                    )),
              r.push(this.finishNode(n, "VariableDeclarator")),
              !this.eat(12))
            )
              break;
          }
          return t;
        }
        parseVarId(t, e) {
          let s = this.parseBindingAtom();
          (e === "using" || e === "await using") &&
            (s.type === "ArrayPattern" || s.type === "ObjectPattern") &&
            this.raise(p.UsingDeclarationHasBindingPattern, s.loc.start),
            this.checkLVal(s, {
              in: { type: "VariableDeclarator" },
              binding: e === "var" ? 5 : 8201,
            }),
            (t.id = s);
        }
        parseAsyncFunctionExpression(t) {
          return this.parseFunction(t, 8);
        }
        parseFunction(t, e = 0) {
          let s = e & 2,
            i = !!(e & 1),
            r = i && !(e & 4),
            n = !!(e & 8);
          this.initFunction(t, n),
            this.match(55) &&
              (s &&
                this.raise(
                  p.GeneratorInSingleStatementContext,
                  this.state.startLoc,
                ),
              this.next(),
              (t.generator = !0)),
            i && (t.id = this.parseFunctionId(r));
          let o = this.state.maybeInArrowParameters;
          return (
            (this.state.maybeInArrowParameters = !1),
            this.scope.enter(2),
            this.prodParam.enter(ke(n, t.generator)),
            i || (t.id = this.parseFunctionId()),
            this.parseFunctionParams(t, !1),
            this.withSmartMixTopicForbiddingContext(() => {
              this.parseFunctionBodyAndFinish(
                t,
                i ? "FunctionDeclaration" : "FunctionExpression",
              );
            }),
            this.prodParam.exit(),
            this.scope.exit(),
            i && !s && this.registerFunctionStatementId(t),
            (this.state.maybeInArrowParameters = o),
            t
          );
        }
        parseFunctionId(t) {
          return t || w(this.state.type) ? this.parseIdentifier() : null;
        }
        parseFunctionParams(t, e) {
          this.expect(10),
            this.expressionScope.enter(Mi()),
            (t.params = this.parseBindingList(11, 41, 2 | (e ? 4 : 0))),
            this.expressionScope.exit();
        }
        registerFunctionStatementId(t) {
          t.id &&
            this.scope.declareName(
              t.id.name,
              !this.options.annexB ||
                this.state.strict ||
                t.generator ||
                t.async
                ? this.scope.treatFunctionsAsVar
                  ? 5
                  : 8201
                : 17,
              t.id.loc.start,
            );
        }
        parseClass(t, e, s) {
          this.next();
          let i = this.state.strict;
          return (
            (this.state.strict = !0),
            this.parseClassId(t, e, s),
            this.parseClassSuper(t),
            (t.body = this.parseClassBody(!!t.superClass, i)),
            this.finishNode(t, e ? "ClassDeclaration" : "ClassExpression")
          );
        }
        isClassProperty() {
          return this.match(29) || this.match(13) || this.match(8);
        }
        isClassMethod() {
          return this.match(10);
        }
        nameIsConstructor(t) {
          return (
            (t.type === "Identifier" && t.name === "constructor") ||
            (t.type === "StringLiteral" && t.value === "constructor")
          );
        }
        isNonstaticConstructor(t) {
          return !t.computed && !t.static && this.nameIsConstructor(t.key);
        }
        parseClassBody(t, e) {
          this.classScope.enter();
          let s = { hadConstructor: !1, hadSuperClass: t },
            i = [],
            r = this.startNode();
          if (
            ((r.body = []),
            this.expect(5),
            this.withSmartMixTopicForbiddingContext(() => {
              for (; !this.match(8); ) {
                if (this.eat(13)) {
                  if (i.length > 0)
                    throw this.raise(
                      p.DecoratorSemicolon,
                      this.state.lastTokEndLoc,
                    );
                  continue;
                }
                if (this.match(26)) {
                  i.push(this.parseDecorator());
                  continue;
                }
                let n = this.startNode();
                i.length &&
                  ((n.decorators = i),
                  this.resetStartLocationFromNode(n, i[0]),
                  (i = [])),
                  this.parseClassMember(r, n, s),
                  n.kind === "constructor" &&
                    n.decorators &&
                    n.decorators.length > 0 &&
                    this.raise(p.DecoratorConstructor, n);
              }
            }),
            (this.state.strict = e),
            this.next(),
            i.length)
          )
            throw this.raise(p.TrailingDecorator, this.state.startLoc);
          return this.classScope.exit(), this.finishNode(r, "ClassBody");
        }
        parseClassMemberFromModifier(t, e) {
          let s = this.parseIdentifier(!0);
          if (this.isClassMethod()) {
            let i = e;
            return (
              (i.kind = "method"),
              (i.computed = !1),
              (i.key = s),
              (i.static = !1),
              this.pushClassMethod(t, i, !1, !1, !1, !1),
              !0
            );
          } else if (this.isClassProperty()) {
            let i = e;
            return (
              (i.computed = !1),
              (i.key = s),
              (i.static = !1),
              t.body.push(this.parseClassProperty(i)),
              !0
            );
          }
          return this.resetPreviousNodeTrailingComments(s), !1;
        }
        parseClassMember(t, e, s) {
          let i = this.isContextual(106);
          if (i) {
            if (this.parseClassMemberFromModifier(t, e)) return;
            if (this.eat(5)) {
              this.parseClassStaticBlock(t, e);
              return;
            }
          }
          this.parseClassMemberWithIsStatic(t, e, s, i);
        }
        parseClassMemberWithIsStatic(t, e, s, i) {
          let r = e,
            n = e,
            o = e,
            h = e,
            c = e,
            l = r,
            u = r;
          if (
            ((e.static = i),
            this.parsePropertyNamePrefixOperator(e),
            this.eat(55))
          ) {
            l.kind = "method";
            let S = this.match(138);
            if ((this.parseClassElementName(l), S)) {
              this.pushClassPrivateMethod(t, n, !0, !1);
              return;
            }
            this.isNonstaticConstructor(r) &&
              this.raise(p.ConstructorIsGenerator, r.key),
              this.pushClassMethod(t, r, !0, !1, !1, !1);
            return;
          }
          let f = !this.state.containsEsc && w(this.state.type),
            d = this.parseClassElementName(e),
            y = f ? d.name : null,
            E = this.isPrivateName(d),
            L = this.state.startLoc;
          if ((this.parsePostMemberNameModifiers(u), this.isClassMethod())) {
            if (((l.kind = "method"), E)) {
              this.pushClassPrivateMethod(t, n, !1, !1);
              return;
            }
            let S = this.isNonstaticConstructor(r),
              I = !1;
            S &&
              ((r.kind = "constructor"),
              s.hadConstructor &&
                !this.hasPlugin("typescript") &&
                this.raise(p.DuplicateConstructor, d),
              S &&
                this.hasPlugin("typescript") &&
                e.override &&
                this.raise(p.OverrideOnConstructor, d),
              (s.hadConstructor = !0),
              (I = s.hadSuperClass)),
              this.pushClassMethod(t, r, !1, !1, S, I);
          } else if (this.isClassProperty())
            E
              ? this.pushClassPrivateProperty(t, h)
              : this.pushClassProperty(t, o);
          else if (y === "async" && !this.isLineTerminator()) {
            this.resetPreviousNodeTrailingComments(d);
            let S = this.eat(55);
            u.optional && this.unexpected(L), (l.kind = "method");
            let I = this.match(138);
            this.parseClassElementName(l),
              this.parsePostMemberNameModifiers(u),
              I
                ? this.pushClassPrivateMethod(t, n, S, !0)
                : (this.isNonstaticConstructor(r) &&
                    this.raise(p.ConstructorIsAsync, r.key),
                  this.pushClassMethod(t, r, S, !0, !1, !1));
          } else if (
            (y === "get" || y === "set") &&
            !(this.match(55) && this.isLineTerminator())
          ) {
            this.resetPreviousNodeTrailingComments(d), (l.kind = y);
            let S = this.match(138);
            this.parseClassElementName(r),
              S
                ? this.pushClassPrivateMethod(t, n, !1, !1)
                : (this.isNonstaticConstructor(r) &&
                    this.raise(p.ConstructorIsAccessor, r.key),
                  this.pushClassMethod(t, r, !1, !1, !1, !1)),
              this.checkGetterSetterParams(r);
          } else if (y === "accessor" && !this.isLineTerminator()) {
            this.expectPlugin("decoratorAutoAccessors"),
              this.resetPreviousNodeTrailingComments(d);
            let S = this.match(138);
            this.parseClassElementName(o),
              this.pushClassAccessorProperty(t, c, S);
          } else
            this.isLineTerminator()
              ? E
                ? this.pushClassPrivateProperty(t, h)
                : this.pushClassProperty(t, o)
              : this.unexpected();
        }
        parseClassElementName(t) {
          let { type: e, value: s } = this.state;
          if (
            ((e === 132 || e === 133) &&
              t.static &&
              s === "prototype" &&
              this.raise(p.StaticPrototype, this.state.startLoc),
            e === 138)
          ) {
            s === "constructor" &&
              this.raise(p.ConstructorClassPrivateField, this.state.startLoc);
            let i = this.parsePrivateName();
            return (t.key = i), i;
          }
          return this.parsePropertyName(t), t.key;
        }
        parseClassStaticBlock(t, e) {
          var s;
          this.scope.enter(208);
          let i = this.state.labels;
          (this.state.labels = []), this.prodParam.enter(0);
          let r = (e.body = []);
          this.parseBlockOrModuleBlockBody(r, void 0, !1, 8),
            this.prodParam.exit(),
            this.scope.exit(),
            (this.state.labels = i),
            t.body.push(this.finishNode(e, "StaticBlock")),
            (s = e.decorators) != null &&
              s.length &&
              this.raise(p.DecoratorStaticBlock, e);
        }
        pushClassProperty(t, e) {
          !e.computed &&
            this.nameIsConstructor(e.key) &&
            this.raise(p.ConstructorClassField, e.key),
            t.body.push(this.parseClassProperty(e));
        }
        pushClassPrivateProperty(t, e) {
          let s = this.parseClassPrivateProperty(e);
          t.body.push(s),
            this.classScope.declarePrivateName(
              this.getPrivateNameSV(s.key),
              0,
              s.key.loc.start,
            );
        }
        pushClassAccessorProperty(t, e, s) {
          !s &&
            !e.computed &&
            this.nameIsConstructor(e.key) &&
            this.raise(p.ConstructorClassField, e.key);
          let i = this.parseClassAccessorProperty(e);
          t.body.push(i),
            s &&
              this.classScope.declarePrivateName(
                this.getPrivateNameSV(i.key),
                0,
                i.key.loc.start,
              );
        }
        pushClassMethod(t, e, s, i, r, n) {
          t.body.push(this.parseMethod(e, s, i, r, n, "ClassMethod", !0));
        }
        pushClassPrivateMethod(t, e, s, i) {
          let r = this.parseMethod(e, s, i, !1, !1, "ClassPrivateMethod", !0);
          t.body.push(r);
          let n =
            r.kind === "get"
              ? r.static
                ? 6
                : 2
              : r.kind === "set"
                ? r.static
                  ? 5
                  : 1
                : 0;
          this.declareClassPrivateMethodInScope(r, n);
        }
        declareClassPrivateMethodInScope(t, e) {
          this.classScope.declarePrivateName(
            this.getPrivateNameSV(t.key),
            e,
            t.key.loc.start,
          );
        }
        parsePostMemberNameModifiers(t) {}
        parseClassPrivateProperty(t) {
          return (
            this.parseInitializer(t),
            this.semicolon(),
            this.finishNode(t, "ClassPrivateProperty")
          );
        }
        parseClassProperty(t) {
          return (
            this.parseInitializer(t),
            this.semicolon(),
            this.finishNode(t, "ClassProperty")
          );
        }
        parseClassAccessorProperty(t) {
          return (
            this.parseInitializer(t),
            this.semicolon(),
            this.finishNode(t, "ClassAccessorProperty")
          );
        }
        parseInitializer(t) {
          this.scope.enter(80),
            this.expressionScope.enter(rs()),
            this.prodParam.enter(0),
            (t.value = this.eat(29) ? this.parseMaybeAssignAllowIn() : null),
            this.expressionScope.exit(),
            this.prodParam.exit(),
            this.scope.exit();
        }
        parseClassId(t, e, s, i = 8331) {
          if (w(this.state.type))
            (t.id = this.parseIdentifier()),
              e && this.declareNameFromIdentifier(t.id, i);
          else if (s || !e) t.id = null;
          else throw this.raise(p.MissingClassName, this.state.startLoc);
        }
        parseClassSuper(t) {
          t.superClass = this.eat(81) ? this.parseExprSubscripts() : null;
        }
        parseExport(t, e) {
          let s = this.parseMaybeImportPhase(t, !0),
            i = this.maybeParseExportDefaultSpecifier(t, s),
            r = !i || this.eat(12),
            n = r && this.eatExportStar(t),
            o = n && this.maybeParseExportNamespaceSpecifier(t),
            h = r && (!o || this.eat(12)),
            c = i || n;
          if (n && !o) {
            if ((i && this.unexpected(), e))
              throw this.raise(p.UnsupportedDecoratorExport, t);
            return (
              this.parseExportFrom(t, !0),
              this.finishNode(t, "ExportAllDeclaration")
            );
          }
          let l = this.maybeParseExportNamedSpecifiers(t);
          i && r && !n && !l && this.unexpected(null, 5),
            o && h && this.unexpected(null, 98);
          let u;
          if (c || l) {
            if (((u = !1), e))
              throw this.raise(p.UnsupportedDecoratorExport, t);
            this.parseExportFrom(t, c);
          } else u = this.maybeParseExportDeclaration(t);
          if (c || l || u) {
            var f;
            let d = t;
            if (
              (this.checkExport(d, !0, !1, !!d.source),
              ((f = d.declaration) == null ? void 0 : f.type) ===
                "ClassDeclaration")
            )
              this.maybeTakeDecorators(e, d.declaration, d);
            else if (e) throw this.raise(p.UnsupportedDecoratorExport, t);
            return this.finishNode(d, "ExportNamedDeclaration");
          }
          if (this.eat(65)) {
            let d = t,
              y = this.parseExportDefaultExpression();
            if (((d.declaration = y), y.type === "ClassDeclaration"))
              this.maybeTakeDecorators(e, y, d);
            else if (e) throw this.raise(p.UnsupportedDecoratorExport, t);
            return (
              this.checkExport(d, !0, !0),
              this.finishNode(d, "ExportDefaultDeclaration")
            );
          }
          this.unexpected(null, 5);
        }
        eatExportStar(t) {
          return this.eat(55);
        }
        maybeParseExportDefaultSpecifier(t, e) {
          if (e || this.isExportDefaultSpecifier()) {
            this.expectPlugin(
              "exportDefaultFrom",
              e == null ? void 0 : e.loc.start,
            );
            let s = e || this.parseIdentifier(!0),
              i = this.startNodeAtNode(s);
            return (
              (i.exported = s),
              (t.specifiers = [this.finishNode(i, "ExportDefaultSpecifier")]),
              !0
            );
          }
          return !1;
        }
        maybeParseExportNamespaceSpecifier(t) {
          if (this.isContextual(93)) {
            var e, s;
            (s = (e = t).specifiers) != null || (e.specifiers = []);
            let i = this.startNodeAt(this.state.lastTokStartLoc);
            return (
              this.next(),
              (i.exported = this.parseModuleExportName()),
              t.specifiers.push(this.finishNode(i, "ExportNamespaceSpecifier")),
              !0
            );
          }
          return !1;
        }
        maybeParseExportNamedSpecifiers(t) {
          if (this.match(5)) {
            let e = t;
            e.specifiers || (e.specifiers = []);
            let s = e.exportKind === "type";
            return (
              e.specifiers.push(...this.parseExportSpecifiers(s)),
              (e.source = null),
              (e.declaration = null),
              this.hasPlugin("importAssertions") && (e.assertions = []),
              !0
            );
          }
          return !1;
        }
        maybeParseExportDeclaration(t) {
          return this.shouldParseExportDeclaration()
            ? ((t.specifiers = []),
              (t.source = null),
              this.hasPlugin("importAssertions") && (t.assertions = []),
              (t.declaration = this.parseExportDeclaration(t)),
              !0)
            : !1;
        }
        isAsyncFunction() {
          if (!this.isContextual(95)) return !1;
          let t = this.nextTokenInLineStart();
          return this.isUnparsedContextual(t, "function");
        }
        parseExportDefaultExpression() {
          let t = this.startNode();
          if (this.match(68)) return this.next(), this.parseFunction(t, 5);
          if (this.isAsyncFunction())
            return this.next(), this.next(), this.parseFunction(t, 13);
          if (this.match(80)) return this.parseClass(t, !0, !0);
          if (this.match(26))
            return (
              this.hasPlugin("decorators") &&
                this.getPluginOption("decorators", "decoratorsBeforeExport") ===
                  !0 &&
                this.raise(p.DecoratorBeforeExport, this.state.startLoc),
              this.parseClass(
                this.maybeTakeDecorators(
                  this.parseDecorators(!1),
                  this.startNode(),
                ),
                !0,
                !0,
              )
            );
          if (this.match(75) || this.match(74) || this.isLet())
            throw this.raise(p.UnsupportedDefaultExport, this.state.startLoc);
          let e = this.parseMaybeAssignAllowIn();
          return this.semicolon(), e;
        }
        parseExportDeclaration(t) {
          return this.match(80)
            ? this.parseClass(this.startNode(), !0, !1)
            : this.parseStatementListItem();
        }
        isExportDefaultSpecifier() {
          let { type: t } = this.state;
          if (w(t)) {
            if ((t === 95 && !this.state.containsEsc) || t === 100) return !1;
            if ((t === 130 || t === 129) && !this.state.containsEsc) {
              let { type: i } = this.lookahead();
              if ((w(i) && i !== 98) || i === 5)
                return this.expectOnePlugin(["flow", "typescript"]), !1;
            }
          } else if (!this.match(65)) return !1;
          let e = this.nextTokenStart(),
            s = this.isUnparsedContextual(e, "from");
          if (this.input.charCodeAt(e) === 44 || (w(this.state.type) && s))
            return !0;
          if (this.match(65) && s) {
            let i = this.input.charCodeAt(this.nextTokenStartSince(e + 4));
            return i === 34 || i === 39;
          }
          return !1;
        }
        parseExportFrom(t, e) {
          this.eatContextual(98)
            ? ((t.source = this.parseImportSource()),
              this.checkExport(t),
              this.maybeParseImportAttributes(t),
              this.checkJSONModuleImport(t))
            : e && this.unexpected(),
            this.semicolon();
        }
        shouldParseExportDeclaration() {
          let { type: t } = this.state;
          return t === 26 &&
            (this.expectOnePlugin(["decorators", "decorators-legacy"]),
            this.hasPlugin("decorators"))
            ? (this.getPluginOption("decorators", "decoratorsBeforeExport") ===
                !0 && this.raise(p.DecoratorBeforeExport, this.state.startLoc),
              !0)
            : this.isContextual(107)
              ? (this.raise(p.UsingDeclarationExport, this.state.startLoc), !0)
              : this.isContextual(96) && this.startsAwaitUsing()
                ? (this.raise(p.UsingDeclarationExport, this.state.startLoc),
                  !0)
                : t === 74 ||
                  t === 75 ||
                  t === 68 ||
                  t === 80 ||
                  this.isLet() ||
                  this.isAsyncFunction();
        }
        checkExport(t, e, s, i) {
          if (e) {
            var r;
            if (s) {
              if (
                (this.checkDuplicateExports(t, "default"),
                this.hasPlugin("exportDefaultFrom"))
              ) {
                var n;
                let o = t.declaration;
                o.type === "Identifier" &&
                  o.name === "from" &&
                  o.end - o.start === 4 &&
                  !((n = o.extra) != null && n.parenthesized) &&
                  this.raise(p.ExportDefaultFromAsIdentifier, o);
              }
            } else if ((r = t.specifiers) != null && r.length)
              for (let o of t.specifiers) {
                let { exported: h } = o,
                  c = h.type === "Identifier" ? h.name : h.value;
                if ((this.checkDuplicateExports(o, c), !i && o.local)) {
                  let { local: l } = o;
                  l.type !== "Identifier"
                    ? this.raise(p.ExportBindingIsString, o, {
                        localName: l.value,
                        exportName: c,
                      })
                    : (this.checkReservedWord(l.name, l.loc.start, !0, !1),
                      this.scope.checkLocalExport(l));
                }
              }
            else if (t.declaration) {
              let o = t.declaration;
              if (
                o.type === "FunctionDeclaration" ||
                o.type === "ClassDeclaration"
              ) {
                let { id: h } = o;
                if (!h) throw new Error("Assertion failure");
                this.checkDuplicateExports(t, h.name);
              } else if (o.type === "VariableDeclaration")
                for (let h of o.declarations) this.checkDeclaration(h.id);
            }
          }
        }
        checkDeclaration(t) {
          if (t.type === "Identifier") this.checkDuplicateExports(t, t.name);
          else if (t.type === "ObjectPattern")
            for (let e of t.properties) this.checkDeclaration(e);
          else if (t.type === "ArrayPattern")
            for (let e of t.elements) e && this.checkDeclaration(e);
          else
            t.type === "ObjectProperty"
              ? this.checkDeclaration(t.value)
              : t.type === "RestElement"
                ? this.checkDeclaration(t.argument)
                : t.type === "AssignmentPattern" &&
                  this.checkDeclaration(t.left);
        }
        checkDuplicateExports(t, e) {
          this.exportedIdentifiers.has(e) &&
            (e === "default"
              ? this.raise(p.DuplicateDefaultExport, t)
              : this.raise(p.DuplicateExport, t, { exportName: e })),
            this.exportedIdentifiers.add(e);
        }
        parseExportSpecifiers(t) {
          let e = [],
            s = !0;
          for (this.expect(5); !this.eat(8); ) {
            if (s) s = !1;
            else if ((this.expect(12), this.eat(8))) break;
            let i = this.isContextual(130),
              r = this.match(133),
              n = this.startNode();
            (n.local = this.parseModuleExportName()),
              e.push(this.parseExportSpecifier(n, r, t, i));
          }
          return e;
        }
        parseExportSpecifier(t, e, s, i) {
          return (
            this.eatContextual(93)
              ? (t.exported = this.parseModuleExportName())
              : e
                ? (t.exported = Ri(t.local))
                : t.exported || (t.exported = $(t.local)),
            this.finishNode(t, "ExportSpecifier")
          );
        }
        parseModuleExportName() {
          if (this.match(133)) {
            let t = this.parseStringLiteral(this.state.value),
              e = nr.exec(t.value);
            return (
              e &&
                this.raise(p.ModuleExportNameHasLoneSurrogate, t, {
                  surrogateCharCode: e[0].charCodeAt(0),
                }),
              t
            );
          }
          return this.parseIdentifier(!0);
        }
        isJSONModuleImport(t) {
          return t.assertions != null
            ? t.assertions.some(
                ({ key: e, value: s }) =>
                  s.value === "json" &&
                  (e.type === "Identifier"
                    ? e.name === "type"
                    : e.value === "type"),
              )
            : !1;
        }
        checkImportReflection(t) {
          let { specifiers: e } = t,
            s = e.length === 1 ? e[0].type : null;
          if (t.phase === "source")
            s !== "ImportDefaultSpecifier" &&
              this.raise(p.SourcePhaseImportRequiresDefault, e[0].loc.start);
          else if (t.phase === "defer")
            s !== "ImportNamespaceSpecifier" &&
              this.raise(p.DeferImportRequiresNamespace, e[0].loc.start);
          else if (t.module) {
            var i;
            s !== "ImportDefaultSpecifier" &&
              this.raise(p.ImportReflectionNotBinding, e[0].loc.start),
              ((i = t.assertions) == null ? void 0 : i.length) > 0 &&
                this.raise(p.ImportReflectionHasAssertion, e[0].loc.start);
          }
        }
        checkJSONModuleImport(t) {
          if (this.isJSONModuleImport(t) && t.type !== "ExportAllDeclaration") {
            let { specifiers: e } = t;
            if (e != null) {
              let s = e.find((i) => {
                let r;
                if (
                  (i.type === "ExportSpecifier"
                    ? (r = i.local)
                    : i.type === "ImportSpecifier" && (r = i.imported),
                  r !== void 0)
                )
                  return r.type === "Identifier"
                    ? r.name !== "default"
                    : r.value !== "default";
              });
              s !== void 0 &&
                this.raise(p.ImportJSONBindingNotDefault, s.loc.start);
            }
          }
        }
        isPotentialImportPhase(t) {
          return t
            ? !1
            : this.isContextual(105) ||
                this.isContextual(97) ||
                this.isContextual(127);
        }
        applyImportPhase(t, e, s, i) {
          e ||
            (s === "module"
              ? (this.expectPlugin("importReflection", i), (t.module = !0))
              : this.hasPlugin("importReflection") && (t.module = !1),
            s === "source"
              ? (this.expectPlugin("sourcePhaseImports", i),
                (t.phase = "source"))
              : s === "defer"
                ? (this.expectPlugin("deferredImportEvaluation", i),
                  (t.phase = "defer"))
                : this.hasPlugin("sourcePhaseImports") && (t.phase = null));
        }
        parseMaybeImportPhase(t, e) {
          if (!this.isPotentialImportPhase(e))
            return this.applyImportPhase(t, e, null), null;
          let s = this.parseIdentifier(!0),
            { type: i } = this.state;
          return (
            M(i) ? i !== 98 || this.lookaheadCharCode() === 102 : i !== 12
          )
            ? (this.resetPreviousIdentifierLeadingComments(s),
              this.applyImportPhase(t, e, s.name, s.loc.start),
              null)
            : (this.applyImportPhase(t, e, null), s);
        }
        isPrecedingIdImportPhase(t) {
          let { type: e } = this.state;
          return w(e) ? e !== 98 || this.lookaheadCharCode() === 102 : e !== 12;
        }
        parseImport(t) {
          return this.match(133)
            ? this.parseImportSourceAndAttributes(t)
            : this.parseImportSpecifiersAndAfter(
                t,
                this.parseMaybeImportPhase(t, !1),
              );
        }
        parseImportSpecifiersAndAfter(t, e) {
          t.specifiers = [];
          let i = !this.maybeParseDefaultImportSpecifier(t, e) || this.eat(12),
            r = i && this.maybeParseStarImportSpecifier(t);
          return (
            i && !r && this.parseNamedImportSpecifiers(t),
            this.expectContextual(98),
            this.parseImportSourceAndAttributes(t)
          );
        }
        parseImportSourceAndAttributes(t) {
          var e;
          return (
            (e = t.specifiers) != null || (t.specifiers = []),
            (t.source = this.parseImportSource()),
            this.maybeParseImportAttributes(t),
            this.checkImportReflection(t),
            this.checkJSONModuleImport(t),
            this.semicolon(),
            this.finishNode(t, "ImportDeclaration")
          );
        }
        parseImportSource() {
          return this.match(133) || this.unexpected(), this.parseExprAtom();
        }
        parseImportSpecifierLocal(t, e, s) {
          (e.local = this.parseIdentifier()),
            t.specifiers.push(this.finishImportSpecifier(e, s));
        }
        finishImportSpecifier(t, e, s = 8201) {
          return (
            this.checkLVal(t.local, { in: { type: e }, binding: s }),
            this.finishNode(t, e)
          );
        }
        parseImportAttributes() {
          this.expect(5);
          let t = [],
            e = new Set();
          do {
            if (this.match(8)) break;
            let s = this.startNode(),
              i = this.state.value;
            if (
              (e.has(i) &&
                this.raise(
                  p.ModuleAttributesWithDuplicateKeys,
                  this.state.startLoc,
                  { key: i },
                ),
              e.add(i),
              this.match(133)
                ? (s.key = this.parseStringLiteral(i))
                : (s.key = this.parseIdentifier(!0)),
              this.expect(14),
              !this.match(133))
            )
              throw this.raise(
                p.ModuleAttributeInvalidValue,
                this.state.startLoc,
              );
            (s.value = this.parseStringLiteral(this.state.value)),
              t.push(this.finishNode(s, "ImportAttribute"));
          } while (this.eat(12));
          return this.expect(8), t;
        }
        parseModuleAttributes() {
          let t = [],
            e = new Set();
          do {
            let s = this.startNode();
            if (
              ((s.key = this.parseIdentifier(!0)),
              s.key.name !== "type" &&
                this.raise(p.ModuleAttributeDifferentFromType, s.key),
              e.has(s.key.name) &&
                this.raise(p.ModuleAttributesWithDuplicateKeys, s.key, {
                  key: s.key.name,
                }),
              e.add(s.key.name),
              this.expect(14),
              !this.match(133))
            )
              throw this.raise(
                p.ModuleAttributeInvalidValue,
                this.state.startLoc,
              );
            (s.value = this.parseStringLiteral(this.state.value)),
              t.push(this.finishNode(s, "ImportAttribute"));
          } while (this.eat(12));
          return t;
        }
        maybeParseImportAttributes(t) {
          let e,
            s = !1;
          if (this.match(76)) {
            if (this.hasPrecedingLineBreak() && this.lookaheadCharCode() === 40)
              return;
            this.next(),
              this.hasPlugin("moduleAttributes")
                ? (e = this.parseModuleAttributes())
                : (this.expectImportAttributesPlugin(),
                  (e = this.parseImportAttributes())),
              (s = !0);
          } else if (this.isContextual(94) && !this.hasPrecedingLineBreak())
            this.hasPlugin("importAttributes")
              ? (this.getPluginOption(
                  "importAttributes",
                  "deprecatedAssertSyntax",
                ) !== !0 &&
                  this.raise(p.ImportAttributesUseAssert, this.state.startLoc),
                this.addExtra(t, "deprecatedAssertSyntax", !0))
              : this.expectOnePlugin(["importAttributes", "importAssertions"]),
              this.next(),
              (e = this.parseImportAttributes());
          else if (
            this.hasPlugin("importAttributes") ||
            this.hasPlugin("importAssertions")
          )
            e = [];
          else if (this.hasPlugin("moduleAttributes")) e = [];
          else return;
          !s && this.hasPlugin("importAssertions")
            ? (t.assertions = e)
            : (t.attributes = e);
        }
        maybeParseDefaultImportSpecifier(t, e) {
          if (e) {
            let s = this.startNodeAtNode(e);
            return (
              (s.local = e),
              t.specifiers.push(
                this.finishImportSpecifier(s, "ImportDefaultSpecifier"),
              ),
              !0
            );
          } else if (M(this.state.type))
            return (
              this.parseImportSpecifierLocal(
                t,
                this.startNode(),
                "ImportDefaultSpecifier",
              ),
              !0
            );
          return !1;
        }
        maybeParseStarImportSpecifier(t) {
          if (this.match(55)) {
            let e = this.startNode();
            return (
              this.next(),
              this.expectContextual(93),
              this.parseImportSpecifierLocal(t, e, "ImportNamespaceSpecifier"),
              !0
            );
          }
          return !1;
        }
        parseNamedImportSpecifiers(t) {
          let e = !0;
          for (this.expect(5); !this.eat(8); ) {
            if (e) e = !1;
            else {
              if (this.eat(14))
                throw this.raise(p.DestructureNamedImport, this.state.startLoc);
              if ((this.expect(12), this.eat(8))) break;
            }
            let s = this.startNode(),
              i = this.match(133),
              r = this.isContextual(130);
            s.imported = this.parseModuleExportName();
            let n = this.parseImportSpecifier(
              s,
              i,
              t.importKind === "type" || t.importKind === "typeof",
              r,
              void 0,
            );
            t.specifiers.push(n);
          }
        }
        parseImportSpecifier(t, e, s, i, r) {
          if (this.eatContextual(93)) t.local = this.parseIdentifier();
          else {
            let { imported: n } = t;
            if (e)
              throw this.raise(p.ImportBindingIsString, t, {
                importName: n.value,
              });
            this.checkReservedWord(n.name, t.loc.start, !0, !0),
              t.local || (t.local = $(n));
          }
          return this.finishImportSpecifier(t, "ImportSpecifier", r);
        }
        isThisParam(t) {
          return t.type === "Identifier" && t.name === "this";
        }
      },
      Me = class extends pt {
        constructor(t, e) {
          (t = rr(t)),
            super(t, e),
            (this.options = t),
            this.initializeScopes(),
            (this.plugins = hr(this.options.plugins)),
            (this.filename = t.sourceFilename);
        }
        getScopeHandler() {
          return me;
        }
        parse() {
          this.enterInitialScopes();
          let t = this.startNode(),
            e = this.startNode();
          return (
            this.nextToken(),
            (t.errors = null),
            this.parseTopLevel(t, e),
            (t.errors = this.state.errors),
            (t.comments.length = this.state.commentsLen),
            t
          );
        }
      };
    function hr(a) {
      let t = new Map();
      for (let e of a) {
        let [s, i] = Array.isArray(e) ? e : [e, {}];
        t.has(s) || t.set(s, i || {});
      }
      return t;
    }
    function lr(a, t) {
      var e;
      if (((e = t) == null ? void 0 : e.sourceType) === "unambiguous") {
        t = Object.assign({}, t);
        try {
          t.sourceType = "module";
          let s = pe(t, a),
            i = s.parse();
          if (s.sawUnambiguousESM) return i;
          if (s.ambiguousScriptDifferentAst)
            try {
              return (t.sourceType = "script"), pe(t, a).parse();
            } catch {}
          else i.program.sourceType = "script";
          return i;
        } catch (s) {
          try {
            return (t.sourceType = "script"), pe(t, a).parse();
          } catch {}
          throw s;
        }
      } else return pe(t, a).parse();
    }
    function cr(a, t) {
      let e = pe(t, a);
      return e.options.strictMode && (e.state.strict = !0), e.getExpression();
    }
    function pr(a) {
      let t = {};
      for (let e of Object.keys(a)) t[e] = R(a[e]);
      return t;
    }
    var ur = pr(ni);
    function pe(a, t) {
      let e = Me;
      return (
        a != null && a.plugins && (sr(a.plugins), (e = fr(a.plugins))),
        new e(a, t)
      );
    }
    var Kt = {};
    function fr(a) {
      let t = ir.filter((i) => N(a, i)),
        e = t.join("/"),
        s = Kt[e];
      if (!s) {
        s = Me;
        for (let i of t) s = hs[i](s);
        Kt[e] = s;
      }
      return s;
    }
    xe.parse = lr;
    xe.parseExpression = cr;
    xe.tokTypes = ur;
  });
  var Zr = {};
  Ws(Zr, { parsers: () => Qr });
  var je = vt(At(), 1);
  function Oe(a) {
    return (t, e, s) => {
      let i = !!(s != null && s.backwards);
      if (e === !1) return !1;
      let { length: r } = t,
        n = e;
      for (; n >= 0 && n < r; ) {
        let o = t.charAt(n);
        if (a instanceof RegExp) {
          if (!a.test(o)) return n;
        } else if (!a.includes(o)) return n;
        i ? n-- : n++;
      }
      return n === -1 || n === r ? n : !1;
    };
  }
  var ha = Oe(/\s/u),
    ls = Oe(" 	"),
    la = Oe(",; 	"),
    cs = Oe(/[^\n\r]/u);
  function dr(a, t) {
    if (t === !1) return !1;
    if (a.charAt(t) === "/" && a.charAt(t + 1) === "*") {
      for (let e = t + 2; e < a.length; ++e)
        if (a.charAt(e) === "*" && a.charAt(e + 1) === "/") return e + 2;
    }
    return t;
  }
  var ps = dr;
  function mr(a, t, e) {
    let s = !!(e != null && e.backwards);
    if (t === !1) return !1;
    let i = a.charAt(t);
    if (s) {
      if (
        a.charAt(t - 1) === "\r" &&
        i ===
          `
`
      )
        return t - 2;
      if (
        i ===
          `
` ||
        i === "\r" ||
        i === "\u2028" ||
        i === "\u2029"
      )
        return t - 1;
    } else {
      if (
        i === "\r" &&
        a.charAt(t + 1) ===
          `
`
      )
        return t + 2;
      if (
        i ===
          `
` ||
        i === "\r" ||
        i === "\u2028" ||
        i === "\u2029"
      )
        return t + 1;
    }
    return t;
  }
  var us = mr;
  function yr(a, t) {
    return t === !1
      ? !1
      : a.charAt(t) === "/" && a.charAt(t + 1) === "/"
        ? cs(a, t)
        : t;
  }
  var fs = yr;
  function xr(a, t) {
    let e = null,
      s = t;
    for (; s !== e; )
      (e = s), (s = ls(a, s)), (s = ps(a, s)), (s = fs(a, s)), (s = us(a, s));
    return s;
  }
  var ds = xr;
  function Pr(a) {
    let t = [];
    for (let e of a)
      try {
        return e();
      } catch (s) {
        t.push(s);
      }
    throw Object.assign(new Error("All combinations failed"), { errors: t });
  }
  var ms = Pr;
  function gr(a) {
    if (!a.startsWith("#!")) return "";
    let t = a.indexOf(`
`);
    return t === -1 ? a : a.slice(0, t);
  }
  var Fe = gr;
  var Tr = (a, t, e) => {
      if (!(a && t == null))
        return Array.isArray(t) || typeof t == "string"
          ? t[e < 0 ? t.length + e : e]
          : t.at(e);
    },
    St = Tr;
  function br(a) {
    return Array.isArray(a) && a.length > 0;
  }
  var Pe = br;
  function D(a) {
    var s, i, r;
    let t = ((s = a.range) == null ? void 0 : s[0]) ?? a.start,
      e =
        (r =
          ((i = a.declaration) == null ? void 0 : i.decorators) ??
          a.decorators) == null
          ? void 0
          : r[0];
    return e ? Math.min(D(e), t) : t;
  }
  function B(a) {
    var t;
    return ((t = a.range) == null ? void 0 : t[1]) ?? a.end;
  }
  function Ar(a) {
    let t = new Set(a);
    return (e) => t.has(e == null ? void 0 : e.type);
  }
  var ys = Ar;
  var Sr = ys(["Block", "CommentBlock", "MultiLine"]),
    ge = Sr;
  function wr(a) {
    let t = `*${a.value}*`.split(`
`);
    return t.length > 1 && t.every((e) => e.trimStart()[0] === "*");
  }
  var wt = wr;
  function Cr(a) {
    return (
      ge(a) && a.value[0] === "*" && /@(?:type|satisfies)\b/u.test(a.value)
    );
  }
  var xs = Cr;
  var Te = null;
  function be(a) {
    if (Te !== null && typeof Te.property) {
      let t = Te;
      return (Te = be.prototype = null), t;
    }
    return (Te = be.prototype = a ?? Object.create(null)), new be();
  }
  var Er = 10;
  for (let a = 0; a <= Er; a++) be();
  function Ct(a) {
    return be(a);
  }
  function Ir(a, t = "type") {
    Ct(a);
    function e(s) {
      let i = s[t],
        r = a[i];
      if (!Array.isArray(r))
        throw Object.assign(new Error(`Missing visitor keys for '${i}'.`), {
          node: s,
        });
      return r;
    }
    return e;
  }
  var Ps = Ir;
  var gs = {
    ArrayExpression: ["elements"],
    AssignmentExpression: ["left", "right"],
    BinaryExpression: ["left", "right"],
    InterpreterDirective: [],
    Directive: ["value"],
    DirectiveLiteral: [],
    BlockStatement: ["directives", "body"],
    BreakStatement: ["label"],
    CallExpression: ["callee", "arguments", "typeParameters", "typeArguments"],
    CatchClause: ["param", "body"],
    ConditionalExpression: ["test", "consequent", "alternate"],
    ContinueStatement: ["label"],
    DebuggerStatement: [],
    DoWhileStatement: ["test", "body"],
    EmptyStatement: [],
    ExpressionStatement: ["expression"],
    File: ["program"],
    ForInStatement: ["left", "right", "body"],
    ForStatement: ["init", "test", "update", "body"],
    FunctionDeclaration: [
      "id",
      "params",
      "body",
      "returnType",
      "typeParameters",
      "predicate",
    ],
    FunctionExpression: [
      "id",
      "params",
      "body",
      "returnType",
      "typeParameters",
    ],
    Identifier: ["typeAnnotation", "decorators"],
    IfStatement: ["test", "consequent", "alternate"],
    LabeledStatement: ["label", "body"],
    StringLiteral: [],
    NumericLiteral: [],
    NullLiteral: [],
    BooleanLiteral: [],
    RegExpLiteral: [],
    LogicalExpression: ["left", "right"],
    MemberExpression: ["object", "property"],
    NewExpression: ["callee", "arguments", "typeParameters", "typeArguments"],
    Program: ["directives", "body"],
    ObjectExpression: ["properties"],
    ObjectMethod: [
      "key",
      "params",
      "body",
      "decorators",
      "returnType",
      "typeParameters",
    ],
    ObjectProperty: ["key", "value", "decorators"],
    RestElement: ["argument", "typeAnnotation", "decorators"],
    ReturnStatement: ["argument"],
    SequenceExpression: ["expressions"],
    ParenthesizedExpression: ["expression"],
    SwitchCase: ["test", "consequent"],
    SwitchStatement: ["discriminant", "cases"],
    ThisExpression: [],
    ThrowStatement: ["argument"],
    TryStatement: ["block", "handler", "finalizer"],
    UnaryExpression: ["argument"],
    UpdateExpression: ["argument"],
    VariableDeclaration: ["declarations"],
    VariableDeclarator: ["id", "init"],
    WhileStatement: ["test", "body"],
    WithStatement: ["object", "body"],
    AssignmentPattern: ["left", "right", "decorators", "typeAnnotation"],
    ArrayPattern: ["elements", "typeAnnotation", "decorators"],
    ArrowFunctionExpression: [
      "params",
      "body",
      "returnType",
      "typeParameters",
      "predicate",
    ],
    ClassBody: ["body"],
    ClassExpression: [
      "id",
      "body",
      "superClass",
      "mixins",
      "typeParameters",
      "superTypeParameters",
      "implements",
      "decorators",
      "superTypeArguments",
    ],
    ClassDeclaration: [
      "id",
      "body",
      "superClass",
      "mixins",
      "typeParameters",
      "superTypeParameters",
      "implements",
      "decorators",
      "superTypeArguments",
    ],
    ExportAllDeclaration: ["source", "attributes", "exported"],
    ExportDefaultDeclaration: ["declaration"],
    ExportNamedDeclaration: [
      "declaration",
      "specifiers",
      "source",
      "attributes",
    ],
    ExportSpecifier: ["local", "exported"],
    ForOfStatement: ["left", "right", "body"],
    ImportDeclaration: ["specifiers", "source", "attributes"],
    ImportDefaultSpecifier: ["local"],
    ImportNamespaceSpecifier: ["local"],
    ImportSpecifier: ["local", "imported"],
    ImportExpression: ["source", "options", "attributes"],
    MetaProperty: ["meta", "property"],
    ClassMethod: [
      "key",
      "params",
      "body",
      "decorators",
      "returnType",
      "typeParameters",
    ],
    ObjectPattern: ["properties", "typeAnnotation", "decorators"],
    SpreadElement: ["argument"],
    Super: [],
    TaggedTemplateExpression: [
      "tag",
      "quasi",
      "typeParameters",
      "typeArguments",
    ],
    TemplateElement: [],
    TemplateLiteral: ["quasis", "expressions"],
    YieldExpression: ["argument"],
    AwaitExpression: ["argument"],
    Import: [],
    BigIntLiteral: [],
    ExportNamespaceSpecifier: ["exported"],
    OptionalMemberExpression: ["object", "property"],
    OptionalCallExpression: [
      "callee",
      "arguments",
      "typeParameters",
      "typeArguments",
    ],
    ClassProperty: ["key", "value", "typeAnnotation", "decorators", "variance"],
    ClassAccessorProperty: ["key", "value", "typeAnnotation", "decorators"],
    ClassPrivateProperty: [
      "key",
      "value",
      "decorators",
      "typeAnnotation",
      "variance",
    ],
    ClassPrivateMethod: [
      "key",
      "params",
      "body",
      "decorators",
      "returnType",
      "typeParameters",
    ],
    PrivateName: ["id"],
    StaticBlock: ["body"],
    AnyTypeAnnotation: [],
    ArrayTypeAnnotation: ["elementType"],
    BooleanTypeAnnotation: [],
    BooleanLiteralTypeAnnotation: [],
    NullLiteralTypeAnnotation: [],
    ClassImplements: ["id", "typeParameters"],
    DeclareClass: [
      "id",
      "typeParameters",
      "extends",
      "mixins",
      "implements",
      "body",
    ],
    DeclareFunction: ["id", "predicate"],
    DeclareInterface: ["id", "typeParameters", "extends", "body"],
    DeclareModule: ["id", "body"],
    DeclareModuleExports: ["typeAnnotation"],
    DeclareTypeAlias: ["id", "typeParameters", "right"],
    DeclareOpaqueType: ["id", "typeParameters", "supertype"],
    DeclareVariable: ["id"],
    DeclareExportDeclaration: ["declaration", "specifiers", "source"],
    DeclareExportAllDeclaration: ["source"],
    DeclaredPredicate: ["value"],
    ExistsTypeAnnotation: [],
    FunctionTypeAnnotation: [
      "typeParameters",
      "params",
      "rest",
      "returnType",
      "this",
    ],
    FunctionTypeParam: ["name", "typeAnnotation"],
    GenericTypeAnnotation: ["id", "typeParameters"],
    InferredPredicate: [],
    InterfaceExtends: ["id", "typeParameters"],
    InterfaceDeclaration: ["id", "typeParameters", "extends", "body"],
    InterfaceTypeAnnotation: ["extends", "body"],
    IntersectionTypeAnnotation: ["types"],
    MixedTypeAnnotation: [],
    EmptyTypeAnnotation: [],
    NullableTypeAnnotation: ["typeAnnotation"],
    NumberLiteralTypeAnnotation: [],
    NumberTypeAnnotation: [],
    ObjectTypeAnnotation: [
      "properties",
      "indexers",
      "callProperties",
      "internalSlots",
    ],
    ObjectTypeInternalSlot: ["id", "value"],
    ObjectTypeCallProperty: ["value"],
    ObjectTypeIndexer: ["id", "key", "value", "variance"],
    ObjectTypeProperty: ["key", "value", "variance"],
    ObjectTypeSpreadProperty: ["argument"],
    OpaqueType: ["id", "typeParameters", "supertype", "impltype"],
    QualifiedTypeIdentifier: ["id", "qualification"],
    StringLiteralTypeAnnotation: [],
    StringTypeAnnotation: [],
    SymbolTypeAnnotation: [],
    ThisTypeAnnotation: [],
    TupleTypeAnnotation: ["types", "elementTypes"],
    TypeofTypeAnnotation: ["argument", "typeArguments"],
    TypeAlias: ["id", "typeParameters", "right"],
    TypeAnnotation: ["typeAnnotation"],
    TypeCastExpression: ["expression", "typeAnnotation"],
    TypeParameter: ["bound", "default", "variance"],
    TypeParameterDeclaration: ["params"],
    TypeParameterInstantiation: ["params"],
    UnionTypeAnnotation: ["types"],
    Variance: [],
    VoidTypeAnnotation: [],
    EnumDeclaration: ["id", "body"],
    EnumBooleanBody: ["members"],
    EnumNumberBody: ["members"],
    EnumStringBody: ["members"],
    EnumSymbolBody: ["members"],
    EnumBooleanMember: ["id", "init"],
    EnumNumberMember: ["id", "init"],
    EnumStringMember: ["id", "init"],
    EnumDefaultedMember: ["id"],
    IndexedAccessType: ["objectType", "indexType"],
    OptionalIndexedAccessType: ["objectType", "indexType"],
    JSXAttribute: ["name", "value"],
    JSXClosingElement: ["name"],
    JSXElement: ["openingElement", "children", "closingElement"],
    JSXEmptyExpression: [],
    JSXExpressionContainer: ["expression"],
    JSXSpreadChild: ["expression"],
    JSXIdentifier: [],
    JSXMemberExpression: ["object", "property"],
    JSXNamespacedName: ["namespace", "name"],
    JSXOpeningElement: [
      "name",
      "attributes",
      "typeArguments",
      "typeParameters",
    ],
    JSXSpreadAttribute: ["argument"],
    JSXText: [],
    JSXFragment: ["openingFragment", "children", "closingFragment"],
    JSXOpeningFragment: [],
    JSXClosingFragment: [],
    Noop: [],
    Placeholder: [],
    V8IntrinsicIdentifier: [],
    ArgumentPlaceholder: [],
    BindExpression: ["object", "callee"],
    ImportAttribute: ["key", "value"],
    Decorator: ["expression"],
    DoExpression: ["body"],
    ExportDefaultSpecifier: ["exported"],
    RecordExpression: ["properties"],
    TupleExpression: ["elements"],
    DecimalLiteral: [],
    ModuleExpression: ["body"],
    TopicReference: [],
    PipelineTopicExpression: ["expression"],
    PipelineBareFunction: ["callee"],
    PipelinePrimaryTopicReference: [],
    TSParameterProperty: ["parameter", "decorators"],
    TSDeclareFunction: ["id", "typeParameters", "params", "returnType", "body"],
    TSDeclareMethod: [
      "decorators",
      "key",
      "typeParameters",
      "params",
      "returnType",
    ],
    TSQualifiedName: ["left", "right"],
    TSCallSignatureDeclaration: [
      "typeParameters",
      "parameters",
      "typeAnnotation",
      "params",
      "returnType",
    ],
    TSConstructSignatureDeclaration: [
      "typeParameters",
      "parameters",
      "typeAnnotation",
      "params",
      "returnType",
    ],
    TSPropertySignature: ["key", "typeAnnotation"],
    TSMethodSignature: [
      "key",
      "typeParameters",
      "parameters",
      "typeAnnotation",
      "params",
      "returnType",
    ],
    TSIndexSignature: ["parameters", "typeAnnotation"],
    TSAnyKeyword: [],
    TSBooleanKeyword: [],
    TSBigIntKeyword: [],
    TSIntrinsicKeyword: [],
    TSNeverKeyword: [],
    TSNullKeyword: [],
    TSNumberKeyword: [],
    TSObjectKeyword: [],
    TSStringKeyword: [],
    TSSymbolKeyword: [],
    TSUndefinedKeyword: [],
    TSUnknownKeyword: [],
    TSVoidKeyword: [],
    TSThisType: [],
    TSFunctionType: [
      "typeParameters",
      "parameters",
      "typeAnnotation",
      "params",
      "returnType",
    ],
    TSConstructorType: [
      "typeParameters",
      "parameters",
      "typeAnnotation",
      "params",
      "returnType",
    ],
    TSTypeReference: ["typeName", "typeParameters", "typeArguments"],
    TSTypePredicate: ["parameterName", "typeAnnotation"],
    TSTypeQuery: ["exprName", "typeParameters", "typeArguments"],
    TSTypeLiteral: ["members"],
    TSArrayType: ["elementType"],
    TSTupleType: ["elementTypes"],
    TSOptionalType: ["typeAnnotation"],
    TSRestType: ["typeAnnotation"],
    TSNamedTupleMember: ["label", "elementType"],
    TSUnionType: ["types"],
    TSIntersectionType: ["types"],
    TSConditionalType: ["checkType", "extendsType", "trueType", "falseType"],
    TSInferType: ["typeParameter"],
    TSParenthesizedType: ["typeAnnotation"],
    TSTypeOperator: ["typeAnnotation"],
    TSIndexedAccessType: ["objectType", "indexType"],
    TSMappedType: ["typeParameter", "typeAnnotation", "nameType"],
    TSLiteralType: ["literal"],
    TSExpressionWithTypeArguments: ["expression", "typeParameters"],
    TSInterfaceDeclaration: ["id", "typeParameters", "extends", "body"],
    TSInterfaceBody: ["body"],
    TSTypeAliasDeclaration: ["id", "typeParameters", "typeAnnotation"],
    TSInstantiationExpression: [
      "expression",
      "typeParameters",
      "typeArguments",
    ],
    TSAsExpression: ["expression", "typeAnnotation"],
    TSSatisfiesExpression: ["expression", "typeAnnotation"],
    TSTypeAssertion: ["typeAnnotation", "expression"],
    TSEnumDeclaration: ["id", "members"],
    TSEnumMember: ["id", "initializer"],
    TSModuleDeclaration: ["id", "body"],
    TSModuleBlock: ["body"],
    TSImportType: ["argument", "qualifier", "typeParameters", "typeArguments"],
    TSImportEqualsDeclaration: ["id", "moduleReference"],
    TSExternalModuleReference: ["expression"],
    TSNonNullExpression: ["expression"],
    TSExportAssignment: ["expression"],
    TSNamespaceExportDeclaration: ["id"],
    TSTypeAnnotation: ["typeAnnotation"],
    TSTypeParameterInstantiation: ["params"],
    TSTypeParameterDeclaration: ["params"],
    TSTypeParameter: ["constraint", "default", "name"],
    ChainExpression: ["expression"],
    ExperimentalRestProperty: ["argument"],
    ExperimentalSpreadProperty: ["argument"],
    Literal: [],
    MethodDefinition: ["decorators", "key", "value"],
    PrivateIdentifier: [],
    Property: ["key", "value"],
    PropertyDefinition: [
      "decorators",
      "key",
      "typeAnnotation",
      "value",
      "variance",
    ],
    AccessorProperty: ["decorators", "key", "typeAnnotation", "value"],
    TSAbstractAccessorProperty: ["decorators", "key", "typeAnnotation"],
    TSAbstractKeyword: [],
    TSAbstractMethodDefinition: ["key", "value"],
    TSAbstractPropertyDefinition: ["decorators", "key", "typeAnnotation"],
    TSAsyncKeyword: [],
    TSClassImplements: ["expression", "typeArguments", "typeParameters"],
    TSDeclareKeyword: [],
    TSEmptyBodyFunctionExpression: [
      "id",
      "typeParameters",
      "params",
      "returnType",
    ],
    TSEnumBody: ["members"],
    TSExportKeyword: [],
    TSInterfaceHeritage: ["expression", "typeArguments", "typeParameters"],
    TSPrivateKeyword: [],
    TSProtectedKeyword: [],
    TSPublicKeyword: [],
    TSReadonlyKeyword: [],
    TSStaticKeyword: [],
    TSTemplateLiteralType: ["quasis", "types"],
    AsConstExpression: ["expression"],
    AsExpression: ["expression", "typeAnnotation"],
    BigIntLiteralTypeAnnotation: [],
    BigIntTypeAnnotation: [],
    ComponentDeclaration: [
      "id",
      "params",
      "body",
      "typeParameters",
      "rendersType",
    ],
    ComponentParameter: ["name", "local"],
    ComponentTypeAnnotation: [
      "params",
      "rest",
      "typeParameters",
      "rendersType",
    ],
    ComponentTypeParameter: ["name", "typeAnnotation"],
    ConditionalTypeAnnotation: [
      "checkType",
      "extendsType",
      "trueType",
      "falseType",
    ],
    DeclareComponent: ["id", "params", "rest", "typeParameters", "rendersType"],
    DeclareEnum: ["id", "body"],
    DeclareHook: ["id"],
    DeclareNamespace: ["id", "body"],
    EnumBigIntBody: ["members"],
    EnumBigIntMember: ["id", "init"],
    HookDeclaration: ["id", "params", "body", "typeParameters", "returnType"],
    HookTypeAnnotation: ["params", "returnType", "rest", "typeParameters"],
    InferTypeAnnotation: ["typeParameter"],
    KeyofTypeAnnotation: ["argument"],
    ObjectTypeMappedTypeProperty: [
      "keyTparam",
      "propType",
      "sourceType",
      "variance",
    ],
    QualifiedTypeofIdentifier: ["qualification", "id"],
    TupleTypeLabeledElement: ["label", "elementType", "variance"],
    TupleTypeSpreadElement: ["label", "typeAnnotation"],
    TypeOperator: ["typeAnnotation"],
    TypePredicate: ["parameterName", "typeAnnotation", "asserts"],
    NGRoot: ["node"],
    NGPipeExpression: ["left", "right", "arguments"],
    NGChainedExpression: ["expressions"],
    NGEmptyExpression: [],
    NGMicrosyntax: ["body"],
    NGMicrosyntaxKey: [],
    NGMicrosyntaxExpression: ["expression", "alias"],
    NGMicrosyntaxKeyedExpression: ["key", "expression"],
    NGMicrosyntaxLet: ["key", "value"],
    NGMicrosyntaxAs: ["key", "alias"],
    JsExpressionRoot: ["node"],
    JsonRoot: ["node"],
    TSJSDocAllType: [],
    TSJSDocUnknownType: [],
    TSJSDocNullableType: ["typeAnnotation"],
    TSJSDocNonNullableType: ["typeAnnotation"],
    NeverTypeAnnotation: [],
    UndefinedTypeAnnotation: [],
    UnknownTypeAnnotation: [],
    SatisfiesExpression: ["expression", "typeAnnotation"],
  };
  var Nr = Ps(gs),
    Ts = Nr;
  function Et(a, t) {
    if (!(a !== null && typeof a == "object")) return a;
    if (Array.isArray(a)) {
      for (let s = 0; s < a.length; s++) a[s] = Et(a[s], t);
      return a;
    }
    let e = Ts(a);
    for (let s = 0; s < e.length; s++) a[e[s]] = Et(a[e[s]], t);
    return t(a) || a;
  }
  var Be = Et;
  function kr(a, t) {
    let { parser: e, text: s } = t;
    if (a.type === "File" && a.program.interpreter) {
      let {
        program: { interpreter: i },
        comments: r,
      } = a;
      delete a.program.interpreter, r.unshift(i);
    }
    if (e === "babel") {
      let i = new Set();
      (a = Be(a, (r) => {
        var n;
        (n = r.leadingComments) != null && n.some(xs) && i.add(D(r));
      })),
        (a = Be(a, (r) => {
          if (r.type === "ParenthesizedExpression") {
            let { expression: n } = r;
            if (n.type === "TypeCastExpression")
              return (n.range = [...r.range]), n;
            let o = D(r);
            if (!i.has(o))
              return (n.extra = { ...n.extra, parenthesized: !0 }), n;
          }
        }));
    }
    if (
      ((a = Be(a, (i) => {
        var r;
        switch (i.type) {
          case "LogicalExpression":
            if (bs(i)) return It(i);
            break;
          case "VariableDeclaration": {
            let n = St(!1, i.declarations, -1);
            n != null && n.init && s[B(n)] !== ";" && (i.range = [D(i), B(n)]);
            break;
          }
          case "TSParenthesizedType":
            return i.typeAnnotation;
          case "TSTypeParameter":
            if (typeof i.name == "string") {
              let n = D(i);
              i.name = {
                type: "Identifier",
                name: i.name,
                range: [n, n + i.name.length],
              };
            }
            break;
          case "TopicReference":
            a.extra = { ...a.extra, __isUsingHackPipeline: !0 };
            break;
          case "ExportAllDeclaration":
            if (
              e === "meriyah" &&
              ((r = i.exported) == null ? void 0 : r.type) === "Identifier"
            ) {
              let { exported: n } = i,
                o = s.slice(D(n), B(n));
              (o.startsWith('"') || o.startsWith("'")) &&
                (i.exported = {
                  ...i.exported,
                  type: "Literal",
                  value: i.exported.name,
                  raw: o,
                });
            }
            break;
          case "TSUnionType":
          case "TSIntersectionType":
            if (i.types.length === 1) return i.types[0];
            break;
        }
      })),
      Pe(a.comments))
    ) {
      let i = St(!1, a.comments, -1);
      for (let r = a.comments.length - 2; r >= 0; r--) {
        let n = a.comments[r];
        B(n) === D(i) &&
          ge(n) &&
          ge(i) &&
          wt(n) &&
          wt(i) &&
          (a.comments.splice(r + 1, 1),
          (n.value += "*//*" + i.value),
          (n.range = [D(n), B(i)])),
          (i = n);
      }
    }
    return a.type === "Program" && (a.range = [0, s.length]), a;
  }
  function bs(a) {
    return (
      a.type === "LogicalExpression" &&
      a.right.type === "LogicalExpression" &&
      a.operator === a.right.operator
    );
  }
  function It(a) {
    return bs(a)
      ? It({
          type: "LogicalExpression",
          operator: a.operator,
          left: It({
            type: "LogicalExpression",
            operator: a.operator,
            left: a.left,
            right: a.right.left,
            range: [D(a.left), B(a.right.left)],
          }),
          right: a.right.right,
          range: [D(a), B(a)],
        })
      : a;
  }
  var As = kr;
  function vr(a, t) {
    let e = new SyntaxError(
      a + " (" + t.loc.start.line + ":" + t.loc.start.column + ")",
    );
    return Object.assign(e, t);
  }
  var Re = vr;
  function Lr(a) {
    let {
        message: t,
        loc: { line: e, column: s },
        reasonCode: i,
      } = a,
      r = a;
    (i === "MissingPlugin" || i === "MissingOneOfPlugins") &&
      ((t = "Unexpected token."), (r = void 0));
    let n = ` (${e}:${s})`;
    return (
      t.endsWith(n) && (t = t.slice(0, -n.length)),
      Re(t, { loc: { start: { line: e, column: s + 1 } }, cause: r })
    );
  }
  var Ue = Lr;
  var Dr = (a, t, e, s) => {
      if (!(a && t == null))
        return t.replaceAll
          ? t.replaceAll(e, s)
          : e.global
            ? t.replace(e, s)
            : t.split(e).join(s);
    },
    ie = Dr;
  var Mr = /\*\/$/,
    Or = /^\/\*\*?/,
    Fr = /^\s*(\/\*\*?(.|\r?\n)*?\*\/)/,
    Br = /(^|\s+)\/\/([^\n\r]*)/g,
    Ss = /^(\r?\n)+/,
    Rr =
      /(?:^|\r?\n) *(@[^\n\r]*?) *\r?\n *(?![^\n\r@]*\/\/[^]*)([^\s@][^\n\r@]+?) *\r?\n/g,
    ws = /(?:^|\r?\n) *@(\S+) *([^\n\r]*)/g,
    Ur = /(\r?\n|^) *\* ?/g,
    _r = [];
  function Cs(a) {
    let t = a.match(Fr);
    return t ? t[0].trimStart() : "";
  }
  function Es(a) {
    let t = `
`;
    a = ie(!1, a.replace(Or, "").replace(Mr, ""), Ur, "$1");
    let e = "";
    for (; e !== a; ) (e = a), (a = ie(!1, a, Rr, `${t}$1 $2${t}`));
    a = a.replace(Ss, "").trimEnd();
    let s = Object.create(null),
      i = ie(!1, a, ws, "").replace(Ss, "").trimEnd(),
      r;
    for (; (r = ws.exec(a)); ) {
      let n = ie(!1, r[2], Br, "");
      if (typeof s[r[1]] == "string" || Array.isArray(s[r[1]])) {
        let o = s[r[1]];
        s[r[1]] = [..._r, ...(Array.isArray(o) ? o : [o]), n];
      } else s[r[1]] = n;
    }
    return { comments: i, pragmas: s };
  }
  function jr(a) {
    let t = Fe(a);
    t && (a = a.slice(t.length + 1));
    let e = Cs(a),
      { pragmas: s, comments: i } = Es(e);
    return { shebang: t, text: a, pragmas: s, comments: i };
  }
  function Is(a) {
    let { pragmas: t } = jr(a);
    return (
      Object.prototype.hasOwnProperty.call(t, "prettier") ||
      Object.prototype.hasOwnProperty.call(t, "format")
    );
  }
  function $r(a) {
    return (
      (a = typeof a == "function" ? { parse: a } : a),
      { astFormat: "estree", hasPragma: Is, locStart: D, locEnd: B, ...a }
    );
  }
  var G = $r;
  function Vr(a) {
    let { filepath: t } = a;
    if (t) {
      if (((t = t.toLowerCase()), t.endsWith(".cjs"))) return "script";
      if (t.endsWith(".mjs")) return "module";
    }
  }
  var Ns = Vr;
  function qr(a, t) {
    let { type: e = "JsExpressionRoot", rootMarker: s, text: i } = t,
      { tokens: r, comments: n } = a;
    return (
      delete a.tokens,
      delete a.comments,
      {
        tokens: r,
        comments: n,
        type: e,
        node: a,
        range: [0, i.length],
        rootMarker: s,
      }
    );
  }
  var _e = qr;
  var re = (a) => G(Jr(a)),
    zr = {
      sourceType: "module",
      allowImportExportEverywhere: !0,
      allowReturnOutsideFunction: !0,
      allowNewTargetOutsideFunction: !0,
      allowSuperOutsideMethod: !0,
      allowUndeclaredExports: !0,
      errorRecovery: !0,
      createParenthesizedExpressions: !0,
      createImportExpressions: !0,
      plugins: [
        "doExpressions",
        "exportDefaultFrom",
        "functionBind",
        "functionSent",
        "throwExpressions",
        "partialApplication",
        "decorators",
        "decimal",
        "moduleBlocks",
        "asyncDoExpressions",
        "destructuringPrivate",
        "decoratorAutoAccessors",
        "importReflection",
        "explicitResourceManagement",
        ["importAttributes", { deprecatedAssertSyntax: !0 }],
        "sourcePhaseImports",
        "deferredImportEvaluation",
        ["optionalChainingAssign", { version: "2023-07" }],
        "recordAndTuple",
      ],
      tokens: !0,
      ranges: !0,
    },
    ks = "v8intrinsic",
    vs = [
      ["pipelineOperator", { proposal: "hack", topicToken: "%" }],
      ["pipelineOperator", { proposal: "minimal" }],
      ["pipelineOperator", { proposal: "fsharp" }],
    ],
    V = (a, t = zr) => ({ ...t, plugins: [...t.plugins, ...a] }),
    Kr = /@(?:no)?flow\b/u;
  function Hr(a, t) {
    var i;
    if ((i = t.filepath) != null && i.endsWith(".js.flow")) return !0;
    let e = Fe(a);
    e && (a = a.slice(e.length));
    let s = ds(a, 0);
    return s !== !1 && (a = a.slice(0, s)), Kr.test(a);
  }
  function Wr(a, t, e) {
    let s = a(t, e),
      i = s.errors.find((r) => !Xr.has(r.reasonCode));
    if (i) throw i;
    return s;
  }
  function Jr({ isExpression: a = !1, optionsCombinations: t }) {
    return (e, s = {}) => {
      if ((s.parser === "babel" || s.parser === "__babel_estree") && Hr(e, s))
        return (s.parser = "babel-flow"), Bs.parse(e, s);
      let i = t;
      (s.__babelSourceType ?? Ns(s)) === "script" &&
        (i = i.map((c) => ({ ...c, sourceType: "script" })));
      let n = /%[A-Z]/u.test(e);
      e.includes("|>")
        ? (i = (n ? [...vs, ks] : vs).flatMap((l) => i.map((u) => V([l], u))))
        : n && (i = i.map((c) => V([ks], c)));
      let o = a ? je.parseExpression : je.parse,
        h;
      try {
        h = ms(i.map((c) => () => Wr(o, e, c)));
      } catch ({ errors: [c] }) {
        throw Ue(c);
      }
      return (
        a && (h = _e(h, { text: e, rootMarker: s.rootMarker })),
        As(h, { parser: "babel", text: e })
      );
    };
  }
  var Xr = new Set([
      "StrictNumericEscape",
      "StrictWith",
      "StrictOctalLiteral",
      "StrictDelete",
      "StrictEvalArguments",
      "StrictEvalArgumentsBinding",
      "StrictFunction",
      "ForInOfLoopInitializer",
      "EmptyTypeArguments",
      "EmptyTypeParameters",
      "ConstructorHasTypeParameters",
      "UnsupportedParameterPropertyKind",
      "DecoratorExportClass",
      "ParamDupe",
      "InvalidDecimal",
      "RestTrailingComma",
      "UnsupportedParameterDecorator",
      "UnterminatedJsxContent",
      "UnexpectedReservedWord",
      "ModuleAttributesWithDuplicateKeys",
      "LineTerminatorBeforeArrow",
      "InvalidEscapeSequenceTemplate",
      "NonAbstractClassHasAbstractMethod",
      "OptionalTypeBeforeRequired",
      "PatternIsOptional",
      "OptionalBindingPattern",
      "DeclareClassFieldHasInitializer",
      "TypeImportCannotSpecifyDefaultAndNamed",
      "ConstructorClassField",
      "VarRedeclaration",
      "InvalidPrivateFieldResolution",
      "DuplicateExport",
    ]),
    Fs = [V(["jsx"])],
    Ls = re({ optionsCombinations: Fs }),
    Ds = re({
      optionsCombinations: [V(["jsx", "typescript"]), V(["typescript"])],
    }),
    Ms = re({ isExpression: !0, optionsCombinations: [V(["jsx"])] }),
    Os = re({ isExpression: !0, optionsCombinations: [V(["typescript"])] }),
    Bs = re({
      optionsCombinations: [
        V(["jsx", ["flow", { all: !0, enums: !0 }], "flowComments"]),
      ],
    }),
    Gr = re({ optionsCombinations: Fs.map((a) => V(["estree"], a)) }),
    Rs = {
      babel: Ls,
      "babel-flow": Bs,
      "babel-ts": Ds,
      __js_expression: Ms,
      __ts_expression: Os,
      __vue_expression: Ms,
      __vue_ts_expression: Os,
      __vue_event_binding: Ls,
      __vue_ts_event_binding: Ds,
      __babel_estree: Gr,
    };
  var Us = vt(At(), 1);
  function _s(a = {}) {
    let { allowComments: t = !0 } = a;
    return function (s) {
      let i;
      try {
        i = (0, Us.parseExpression)(s, {
          tokens: !0,
          ranges: !0,
          attachComment: !1,
        });
      } catch (r) {
        throw Ue(r);
      }
      if (!t && Pe(i.comments)) throw H(i.comments[0], "Comment");
      return ae(i), _e(i, { type: "JsonRoot", text: s });
    };
  }
  function H(a, t) {
    let [e, s] = [a.loc.start, a.loc.end].map(({ line: i, column: r }) => ({
      line: i,
      column: r + 1,
    }));
    return Re(`${t} is not allowed in JSON.`, { loc: { start: e, end: s } });
  }
  function ae(a) {
    switch (a.type) {
      case "ArrayExpression":
        for (let t of a.elements) t !== null && ae(t);
        return;
      case "ObjectExpression":
        for (let t of a.properties) ae(t);
        return;
      case "ObjectProperty":
        if (a.computed) throw H(a.key, "Computed key");
        if (a.shorthand) throw H(a.key, "Shorthand property");
        a.key.type !== "Identifier" && ae(a.key), ae(a.value);
        return;
      case "UnaryExpression": {
        let { operator: t, argument: e } = a;
        if (t !== "+" && t !== "-") throw H(a, `Operator '${a.operator}'`);
        if (
          e.type === "NumericLiteral" ||
          (e.type === "Identifier" &&
            (e.name === "Infinity" || e.name === "NaN"))
        )
          return;
        throw H(e, `Operator '${t}' before '${e.type}'`);
      }
      case "Identifier":
        if (a.name !== "Infinity" && a.name !== "NaN" && a.name !== "undefined")
          throw H(a, `Identifier '${a.name}'`);
        return;
      case "TemplateLiteral":
        if (Pe(a.expressions))
          throw H(a.expressions[0], "'TemplateLiteral' with expression");
        for (let t of a.quasis) ae(t);
        return;
      case "NullLiteral":
      case "BooleanLiteral":
      case "NumericLiteral":
      case "StringLiteral":
      case "TemplateElement":
        return;
      default:
        throw H(a, `'${a.type}'`);
    }
  }
  var Nt = _s(),
    Yr = {
      json: G({
        parse: Nt,
        hasPragma() {
          return !0;
        },
      }),
      json5: G(Nt),
      jsonc: G(Nt),
      "json-stringify": G({
        parse: _s({ allowComments: !1 }),
        astFormat: "estree-json",
      }),
    },
    js = Yr;
  var Qr = { ...Rs, ...js };
  return Js(Zr);
});