@code-yeongyu/senpi 2026.8.18 → 2026.8.19

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/@babel/parser/lib/index.d.ts

@@ -0,0 +1,1035 @@
+import * as _babel_types from '@babel/types';
+import { File, Expression } from '@babel/types';
+export { Expression, File } from '@babel/types';
+
+declare const UnparenthesizedPipeBodyDescriptions: Set<"AssignmentExpression" | "ArrowFunctionExpression" | "ConditionalExpression" | "YieldExpression">;
+type GetSetMemberType<T extends Set<any>> = T extends Set<infer M> ? M : unknown;
+type UnparenthesizedPipeBodyTypes = GetSetMemberType<typeof UnparenthesizedPipeBodyDescriptions>;
+declare const _default$5: {
+    PipeTopicRequiresHackPipes: string;
+    PipeTopicUnbound: string;
+    PipeTopicUnconfiguredToken: ({ token }: {
+        token: string;
+    }) => string;
+    PipeTopicUnused: string;
+    PipeUnparenthesizedBody: ({ type }: {
+        type: UnparenthesizedPipeBodyTypes;
+    }) => string;
+    PipelineUnparenthesized: string;
+};
+
+declare class Position {
+    line: number;
+    column: number;
+    index: number;
+    constructor(line: number, col: number, index?: number);
+}
+declare class SourceLocation {
+    start: Position;
+    end: Position;
+    filename: string | undefined;
+    identifierName: string | undefined | null;
+    constructor(start: Position, end?: Position);
+}
+
+declare const _default$4: {
+    ImportMetaOutsideModule: {
+        message: string;
+        code: "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED";
+    };
+    ImportOutsideModule: {
+        message: string;
+        code: "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED";
+    };
+};
+//# sourceMappingURL=module-errors.d.ts.map
+
+type LValAncestor = {
+    type: "UpdateExpression";
+    prefix: boolean;
+} | {
+    type: "ArrayPattern" | "AssignmentExpression" | "CatchClause" | "ForOfStatement" | "FormalParameters" | "ForInStatement" | "ForStatement" | "ImportSpecifier" | "ImportNamespaceSpecifier" | "ImportDefaultSpecifier" | "ParenthesizedExpression" | "ObjectPattern" | "RestElement" | "VariableDeclarator";
+};
+declare const _default$3: {
+    AccessorIsGenerator: ({ kind }: {
+        kind: "get" | "set";
+    }) => string;
+    ArgumentsInClass: string;
+    AsyncFunctionInSingleStatementContext: string;
+    AwaitBindingIdentifier: string;
+    AwaitBindingIdentifierInStaticBlock: string;
+    AwaitExpressionFormalParameter: string;
+    AwaitUsingNotInAsyncContext: string;
+    AwaitNotInAsyncContext: string;
+    BadGetterArity: string;
+    BadSetterArity: string;
+    BadSetterRestParameter: string;
+    ConstructorClassField: string;
+    ConstructorClassPrivateField: string;
+    ConstructorIsAccessor: string;
+    ConstructorIsAsync: string;
+    ConstructorIsGenerator: string;
+    DeclarationMissingInitializer: ({ kind, }: {
+        kind: "await using" | "const" | "destructuring" | "using";
+    }) => string;
+    DecoratorArgumentsOutsideParentheses: string;
+    DecoratorsBeforeAfterExport: string;
+    DecoratorConstructor: string;
+    DecoratorSemicolon: string;
+    DecoratorStaticBlock: string;
+    DeferImportRequiresNamespace: string;
+    DeletePrivateField: string;
+    DestructureNamedImport: string;
+    DuplicateConstructor: string;
+    DuplicateDefaultExport: string;
+    DuplicateExport: ({ exportName }: {
+        exportName: string;
+    }) => string;
+    DuplicateProto: string;
+    DuplicateRegExpFlags: string;
+    ElementAfterRest: string;
+    EscapedCharNotAnIdentifier: string;
+    ExportBindingIsString: ({ localName, exportName, }: {
+        localName: string;
+        exportName: string;
+    }) => string;
+    ExportDefaultFromAsIdentifier: string;
+    ForInOfLoopInitializer: ({ type, }: {
+        type: "ForInStatement" | "ForOfStatement";
+    }) => string;
+    ForInUsing: string;
+    ForOfAsync: string;
+    ForOfLet: string;
+    GeneratorInSingleStatementContext: string;
+    IllegalBreakContinue: ({ type, }: {
+        type: "BreakStatement" | "ContinueStatement";
+    }) => string;
+    IllegalLanguageModeDirective: string;
+    IllegalReturn: string;
+    ImportBindingIsString: ({ importName }: {
+        importName: string;
+    }) => string;
+    ImportCallArity: ({ phase }: {
+        phase?: string | null;
+    }) => string;
+    ImportCallNotNewExpression: ({ phase }: {
+        phase?: string | null;
+    }) => string;
+    ImportCallSpreadArgument: ({ phase }: {
+        phase?: string | null;
+    }) => string;
+    IncompatibleRegExpUVFlags: string;
+    InvalidBigIntLiteral: string;
+    InvalidCodePoint: string;
+    InvalidCoverDiscardElement: string;
+    InvalidCoverInitializedName: string;
+    InvalidDigit: ({ radix }: {
+        radix: number;
+    }) => string;
+    InvalidEscapeSequence: string;
+    InvalidEscapeSequenceTemplate: string;
+    InvalidEscapedReservedWord: ({ reservedWord }: {
+        reservedWord: string;
+    }) => string;
+    InvalidIdentifier: ({ identifierName }: {
+        identifierName: string;
+    }) => string;
+    InvalidLhs: ({ ancestor }: {
+        ancestor: LValAncestor;
+    }) => string;
+    InvalidLhsBinding: ({ ancestor }: {
+        ancestor: LValAncestor;
+    }) => string;
+    InvalidLhsOptionalChaining: ({ ancestor }: {
+        ancestor: LValAncestor;
+    }) => string;
+    InvalidNumber: string;
+    InvalidOrMissingExponent: string;
+    InvalidOrUnexpectedToken: ({ unexpected }: {
+        unexpected: string;
+    }) => string;
+    InvalidParenthesizedAssignment: string;
+    InvalidPrivateFieldResolution: ({ identifierName, }: {
+        identifierName: string;
+    }) => string;
+    InvalidPropertyBindingPattern: string;
+    InvalidRestAssignmentPattern: string;
+    LabelRedeclaration: ({ labelName }: {
+        labelName: string;
+    }) => string;
+    LetInLexicalBinding: string;
+    LineTerminatorBeforeArrow: string;
+    MalformedRegExpFlags: string;
+    MissingClassName: string;
+    MissingEqInAssignment: string;
+    MissingSemicolon: string;
+    MissingPlugin: ({ missingPlugin }: {
+        missingPlugin: [string];
+    }) => string;
+    MissingOneOfPlugins: ({ missingPlugin }: {
+        missingPlugin: string[];
+    }) => string;
+    MissingUnicodeEscape: string;
+    MixingCoalesceWithLogical: string;
+    ModuleAttributeInvalidValue: string;
+    ModuleAttributesWithDuplicateKeys: ({ key }: {
+        key: string;
+    }) => string;
+    ModuleExportNameHasLoneSurrogate: ({ surrogateCharCode, }: {
+        surrogateCharCode: number;
+    }) => string;
+    ModuleExportUndefined: ({ localName }: {
+        localName: string;
+    }) => string;
+    MultipleDefaultsInSwitch: string;
+    NewlineAfterThrow: string;
+    NoCatchOrFinally: string;
+    NumberIdentifier: string;
+    NumericSeparatorInEscapeSequence: string;
+    ObsoleteAwaitStar: string;
+    OptionalChainingNoNew: string;
+    OptionalChainingNoTemplate: string;
+    OverrideOnConstructor: string;
+    ParamDupe: string;
+    PatternHasAccessor: string;
+    PatternHasMethod: string;
+    PrivateInExpectedIn: ({ identifierName }: {
+        identifierName: string;
+    }) => string;
+    PrivateNameRedeclaration: ({ identifierName }: {
+        identifierName: string;
+    }) => string;
+    RestTrailingComma: string;
+    SloppyFunction: string;
+    SloppyFunctionAnnexB: string;
+    SourcePhaseImportRequiresDefault: string;
+    StaticPrototype: string;
+    SuperCallNotNewExpression: string;
+    SuperNotAllowed: string;
+    SuperPrivateField: string;
+    TrailingDecorator: string;
+    UnexpectedArgumentPlaceholder: string;
+    UnexpectedDigitAfterHash: string;
+    UnexpectedImportExport: string;
+    UnexpectedKeyword: ({ keyword }: {
+        keyword: string;
+    }) => string;
+    UnexpectedLeadingDecorator: string;
+    UnexpectedLexicalDeclaration: string;
+    UnexpectedNewTarget: string;
+    UnexpectedNumericSeparator: string;
+    UnexpectedPrivateField: string;
+    UnexpectedReservedWord: ({ reservedWord }: {
+        reservedWord: string;
+    }) => string;
+    UnexpectedSuper: string;
+    UnexpectedToken: ({ expected, unexpected, }: {
+        expected?: string | null;
+        unexpected?: string | null;
+    }) => string;
+    UnexpectedTokenUnaryExponentiation: string;
+    UnexpectedUsingDeclaration: string;
+    UnexpectedVoidPattern: string;
+    UnsupportedDecoratorExport: string;
+    UnsupportedDefaultExport: string;
+    UnsupportedImport: string;
+    UnsupportedMetaProperty: ({ target, onlyValidPropertyName, }: {
+        target: string;
+        onlyValidPropertyName: string;
+    }) => string;
+    UnsupportedParameterDecorator: string;
+    UnsupportedPropertyDecorator: string;
+    UnsupportedSuper: string;
+    UnterminatedComment: string;
+    UnterminatedRegExp: string;
+    UnterminatedString: string;
+    UnterminatedTemplate: string;
+    UsingDeclarationExport: string;
+    UsingDeclarationHasBindingPattern: string;
+    VarRedeclaration: ({ identifierName }: {
+        identifierName: string;
+    }) => string;
+    VoidPatternCatchClauseParam: string;
+    VoidPatternInitializer: string;
+    YieldBindingIdentifier: string;
+    YieldInParameter: string;
+    YieldNotInGeneratorFunction: string;
+    ZeroDigitNumericSeparator: string;
+};
+
+declare const _default$2: {
+    StrictDelete: string;
+    StrictEvalArguments: ({ referenceName }: {
+        referenceName: string;
+    }) => string;
+    StrictEvalArgumentsBinding: ({ bindingName }: {
+        bindingName: string;
+    }) => string;
+    StrictFunction: string;
+    StrictNumericEscape: string;
+    StrictOctalLiteral: string;
+    StrictWith: string;
+};
+//# sourceMappingURL=strict-mode-errors.d.ts.map
+
+declare const _default$1: {
+    ParseExpressionEmptyInput: string;
+    ParseExpressionExpectsEOF: ({ unexpected }: {
+        unexpected: number;
+    }) => string;
+};
+//# sourceMappingURL=parse-expression-errors.d.ts.map
+
+declare const _default: {
+    UnsupportedBind: string;
+    UnsupportedBindRHS: string;
+};
+//# sourceMappingURL=bind-operator-errors.d.ts.map
+
+declare class TokContext {
+    constructor(token: string, preserveSpace?: boolean);
+    token: string;
+    preserveSpace: boolean;
+}
+
+type TokenOptions = {
+    keyword?: string;
+    beforeExpr?: boolean;
+    startsExpr?: boolean;
+    rightAssociative?: boolean;
+    isLoop?: boolean;
+    isAssign?: boolean;
+    prefix?: boolean;
+    postfix?: boolean;
+    binop?: number | null;
+};
+type TokenType = number;
+declare class ExportedTokenType {
+    label: string;
+    keyword: string | undefined | null;
+    beforeExpr: boolean;
+    startsExpr: boolean;
+    rightAssociative: boolean;
+    isLoop: boolean;
+    isAssign: boolean;
+    prefix: boolean;
+    postfix: boolean;
+    binop: number | undefined | null;
+    constructor(label: string, conf?: TokenOptions);
+}
+
+declare const enum LoopLabelKind {
+    Loop = 1,
+    Switch = 2
+}
+declare class State {
+    flags: number;
+    accessor strict: boolean;
+    startIndex: number;
+    curLine: number;
+    lineStart: number;
+    startLoc: Position;
+    endLoc: Position;
+    init({ strictMode, sourceType, startIndex, startLine, startColumn, }: OptionsWithDefaults): void;
+    errors: ParseError[];
+    noArrowAt: number[];
+    noArrowParamsConversionAt: number[];
+    /**
+     * Track whether the current start is the start of an AssignmentExpression production.
+     * The ArrowFunctionExpression and AsyncArrowFunctionExpression productions can only be
+     * parsed if this is true.
+     */
+    accessor canStartArrow: boolean;
+    accessor inType: boolean;
+    accessor noAnonFunctionType: boolean;
+    accessor hasFlowComment: boolean;
+    accessor isAmbientContext: boolean;
+    accessor inAbstractClass: boolean;
+    accessor inDisallowConditionalTypesContext: boolean;
+    accessor inConditionalConsequent: boolean;
+    accessor inHackPipelineBody: boolean;
+    accessor seenTopicReference: boolean;
+    labels: {
+        kind: LoopLabelKind | null;
+        name?: string | null;
+        statementStart?: number;
+    }[];
+    commentsLen: number;
+    commentStack: CommentWhitespace[];
+    pos: number;
+    type: TokenType;
+    value: any;
+    start: number;
+    end: number;
+    lastTokEndLoc: Position | null;
+    lastTokStartLoc: Position | null;
+    context: TokContext[];
+    accessor canStartJSXElement: boolean;
+    accessor containsEsc: boolean;
+    firstInvalidTemplateEscapePos: null | Position;
+    accessor hasTopLevelAwait: boolean;
+    strictErrors: Map<number, [ParseErrorConstructor<object>, Position]>;
+    tokensLength: number;
+    /**
+     * When we add a new property, we must manually update the `clone` method
+     * @see State#clone
+     */
+    curPosition(): Position;
+    clone(): State;
+}
+
+interface CommentBase {
+    type: "CommentBlock" | "CommentLine";
+    value: string;
+    start?: number | undefined;
+    end?: number | undefined;
+    loc?: SourceLocation | undefined;
+}
+interface CommentBlock extends CommentBase {
+    type: "CommentBlock";
+}
+interface CommentLine extends CommentBase {
+    type: "CommentLine";
+}
+type Comment = CommentBlock | CommentLine;
+interface BaseNode {
+    leadingComments?: Comment[] | null;
+    innerComments?: Comment[] | null;
+    trailingComments?: Comment[] | null;
+    start?: number | null;
+    end?: number | null;
+    loc?: SourceLocation | null;
+    range?: [number, number];
+    extra?: Record<string, unknown>;
+}
+type Accessibility = "public" | "protected" | "private";
+type VarianceAnnotations = "in" | "out";
+/**
+ * TSTypeCastExpression is not a valid TS production, the parser
+ * generates such code so that it can cast it to a valid pattern or
+ * throw an error
+ */
+interface TSTypeCastExpression extends BaseNode {
+    type: "TSTypeCastExpression";
+    expression: _babel_types.Expression;
+    typeAnnotation: _babel_types.TSTypeAnnotation;
+}
+type ESTreeNode = ESTreeClassElement | ESTreeExpression | EstreePrivateIdentifier | EstreeProperty | EstreeRegExpLiteral;
+type ESTreeClassElement = EstreeAccessorProperty | EstreeMethodDefinition | EstreePropertyDefinition | EstreeTSAbstractMethodDefinition | EstreeTSAbstractPropertyDefinition | EstreeTSAbstractAccessorProperty;
+type ESTreeLiteral = EstreeLiteral | EstreeBigIntLiteral;
+type ESTreeExpression = EstreeChainExpression | ESTreeLiteral | EstreeTSEmptyBodyFunctionExpression;
+type Node = _babel_types.Node | ESTreeNode | TSTypeCastExpression;
+interface EstreeLiteral extends BaseNode {
+    type: "Literal";
+    value: any;
+    raw: any;
+}
+interface EstreeRegExpLiteralRegex {
+    pattern: string;
+    flags: string;
+}
+interface EstreeRegExpLiteral extends EstreeLiteral {
+    regex: EstreeRegExpLiteralRegex;
+}
+interface EstreeBigIntLiteral extends EstreeLiteral {
+    value: number | null;
+    bigint: string;
+}
+interface EstreeProperty extends BaseNode {
+    type: "Property";
+    method: boolean;
+    shorthand: boolean;
+    key: _babel_types.Expression | EstreePrivateIdentifier;
+    computed: boolean;
+    value: _babel_types.Expression;
+    decorators: _babel_types.Decorator[];
+    kind?: "get" | "set" | "init";
+    variance?: _babel_types.Variance | null;
+    optional?: boolean;
+}
+interface EstreeMethodDefinitionBase extends BaseNode {
+    static: boolean;
+    key: _babel_types.Expression;
+    computed: boolean;
+    decorators: _babel_types.Decorator[];
+    kind?: "get" | "set" | "method";
+    accessibility?: Accessibility;
+    override?: boolean;
+    optional?: boolean;
+}
+interface EstreeMethodDefinition extends EstreeMethodDefinitionBase {
+    type: "MethodDefinition";
+    value: _babel_types.FunctionExpression;
+    variance?: _babel_types.Variance | null;
+}
+interface EstreePrivateIdentifier extends BaseNode {
+    type: "PrivateIdentifier";
+    name: string;
+}
+interface EstreePropertyDefinitionBase extends BaseNode {
+    static: boolean;
+    key: _babel_types.Expression | EstreePrivateIdentifier;
+    computed: boolean;
+    accessibility?: Accessibility;
+    override?: boolean;
+    optional?: boolean;
+    declare?: boolean;
+    decorators?: _babel_types.Decorator[];
+    definite?: boolean;
+    readonly?: boolean;
+    typeAnnotation?: _babel_types.TSTypeAnnotation | null;
+}
+interface EstreePropertyDefinition extends EstreePropertyDefinitionBase {
+    type: "PropertyDefinition";
+    value: _babel_types.Expression;
+}
+interface EstreeAccessorProperty extends EstreePropertyDefinitionBase {
+    type: "AccessorProperty";
+    value: _babel_types.Expression;
+}
+interface EstreeChainExpression extends BaseNode {
+    type: "ChainExpression";
+    expression: _babel_types.Expression;
+}
+interface DeclarationBase extends BaseNode {
+    declare?: boolean;
+}
+interface HasDecorators extends BaseNode {
+    decorators?: _babel_types.Decorator[];
+}
+interface TypeParameterDeclarationBase extends BaseNode {
+    params: (_babel_types.TypeParameter | _babel_types.TSTypeParameter)[];
+}
+interface TypeAnnotationBase extends BaseNode {
+    typeAnnotation: _babel_types.Node;
+}
+interface BodilessFunctionOrMethodBase extends HasDecorators {
+    id: _babel_types.Identifier | undefined | null;
+    params: (_babel_types.Pattern | _babel_types.TSParameterProperty)[];
+    generator: boolean;
+    async: boolean;
+    expression: boolean;
+    typeParameters?: TypeParameterDeclarationBase | null;
+    returnType?: TypeAnnotationBase | null;
+}
+interface EstreeTSEmptyBodyFunctionExpression extends BodilessFunctionOrMethodBase, DeclarationBase {
+    type: "TSEmptyBodyFunctionExpression";
+    body: null;
+}
+interface EstreeTSAbstractMethodDefinition extends EstreeMethodDefinitionBase {
+    type: "TSAbstractMethodDefinition";
+    value: EstreeTSEmptyBodyFunctionExpression;
+}
+interface EstreeTSAbstractPropertyDefinition extends EstreePropertyDefinitionBase {
+    type: "TSAbstractPropertyDefinition";
+    value: null;
+}
+interface EstreeTSAbstractAccessorProperty extends EstreePropertyDefinitionBase {
+    type: "TSAbstractAccessorProperty";
+    value: null;
+}
+
+type Plugin$1 =
+  | "asyncDoExpressions"
+  | "decorators"
+  | "decorators-legacy"
+  | "decoratorAutoAccessors"
+  | "deferredImportEvaluation"
+  | "destructuringPrivate"
+  | "doExpressions"
+  | "exportDefaultFrom"
+  | "flow"
+  | "flowComments"
+  | "functionBind"
+  | "functionSent"
+  | "importMeta"
+  | "jsx"
+  | "moduleBlocks"
+  | "placeholders"
+  | "sourcePhaseImports"
+  | "throwExpressions"
+  | "v8intrinsic"
+  | ParserPluginWithOptions[0];
+
+type ParserPluginWithOptions =
+  | ["discardBinding", { syntaxType: "void" }]
+  | ["estree", { classFeatures?: boolean }]
+  | ["optionalChainingAssign", { version: "2023-07" }]
+  | ["partialApplication", PartialApplicationPluginOptions]
+  | ["pipelineOperator", PipelineOperatorPluginOptions]
+  | ["flow", FlowPluginOptions]
+  | ["typescript", TypeScriptPluginOptions];
+
+type PluginConfig = Plugin$1 | ParserPluginWithOptions;
+
+interface PartialApplicationPluginOptions {
+  version: "2018-07";
+}
+
+interface PipelineOperatorPluginOptions {
+  proposal: "fsharp" | "hack";
+  topicToken?: "%" | "#" | "@@" | "^^" | "^";
+}
+
+interface FlowPluginOptions {
+  all?: boolean;
+}
+
+interface TypeScriptPluginOptions {
+  dts?: boolean;
+  disallowAmbiguousJSXLike?: boolean;
+}
+
+/**
+ * A whitespace token containing comments
+ */
+type CommentWhitespace = {
+    /**
+     * the start of the whitespace token.
+     */
+    start: number;
+    /**
+     * the end of the whitespace token.
+     */
+    end: number;
+    /**
+     * the containing comments
+     */
+    comments: Comment[];
+    /**
+     * the immediately preceding AST node of the whitespace token
+     */
+    leadingNode: Node | null;
+    /**
+     * the immediately following AST node of the whitespace token
+     */
+    trailingNode: Node | null;
+    /**
+     * the innermost AST node containing the whitespace with minimal size (|end - start|)
+     */
+    containingNode: Node | null;
+};
+
+declare class Token {
+    constructor(state: State);
+    type: TokenType;
+    value: any;
+    start: number;
+    end: number;
+    loc: SourceLocation;
+}
+
+declare const JsxErrorTemplates: {
+    AttributeIsEmpty: string;
+    MissingClosingTagElement: ({ openingTagName }: {
+        openingTagName: string;
+    }) => string;
+    MissingClosingTagFragment: string;
+    UnexpectedSequenceExpression: string;
+    UnexpectedToken: ({ unexpected, HTMLEntity, }: {
+        unexpected: string;
+        HTMLEntity: string;
+    }) => string;
+    UnsupportedJsxValue: string;
+    UnterminatedJsxContent: string;
+    UnwrappedAdjacentJSXElements: string;
+};
+
+type TsModifier = "readonly" | "abstract" | "declare" | "static" | "override" | "const" | Accessibility | VarianceAnnotations;
+declare const TSErrorTemplates: {
+    AbstractMethodHasImplementation: ({ methodName }: {
+        methodName: string;
+    }) => string;
+    AbstractPropertyHasInitializer: ({ propertyName, }: {
+        propertyName: string;
+    }) => string;
+    AccessorCannotBeOptional: string;
+    AccessorCannotDeclareThisParameter: string;
+    AccessorCannotHaveTypeParameters: string;
+    ClassMethodHasDeclare: string;
+    ClassMethodHasReadonly: string;
+    ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference: string;
+    ConstructorHasTypeParameters: string;
+    DeclaratorDefiniteAssertionRequiresTypeAnnotation: string;
+    DeclaratorDefiniteAssertionWithInitializer: string;
+    DeclareAccessor: ({ kind }: {
+        kind: "get" | "set";
+    }) => string;
+    DeclareClassFieldHasInitializer: string;
+    DeclareFunctionHasImplementation: string;
+    DecoratorAbstractMethod: ({ kind, }: {
+        kind: "abstract method" | "abstract field" | "declare field";
+    }) => string;
+    DuplicateAccessibilityModifier: ({ modifier, }: {
+        modifier: Accessibility;
+    }) => string;
+    DuplicateModifier: ({ modifier }: {
+        modifier: TsModifier;
+    }) => string;
+    EmptyHeritageClauseType: ({ token }: {
+        token: "extends" | "implements";
+    }) => string;
+    EmptyNamespaceName: string;
+    EmptyTypeArguments: string;
+    EmptyTypeParameters: string;
+    ExpectedAmbientAfterExportDeclare: string;
+    ExportAssignmentInTSNamespace: string;
+    ExportInTSNamespace: string;
+    ImportAliasHasImportType: string;
+    ImportInTSNamespace: string;
+    IncompatibleModifiers: ({ modifiers, }: {
+        modifiers: [TsModifier, TsModifier];
+    }) => string;
+    IndexSignatureHasAbstract: string;
+    IndexSignatureHasAccessibility: ({ modifier, }: {
+        modifier: Accessibility;
+    }) => string;
+    IndexSignatureHasDeclare: string;
+    IndexSignatureHasOverride: string;
+    IndexSignatureHasStatic: string;
+    InitializerNotAllowedInAmbientContext: string;
+    InlineModuleDeclarationMustUseString: string;
+    InvalidHeritageClauseType: ({ token }: {
+        token: "extends" | "implements";
+    }) => string;
+    InvalidModifierOnAwaitUsingDeclaration: (modifier: TsModifier) => string;
+    InvalidModifierOnTypeMember: ({ modifier }: {
+        modifier: TsModifier;
+    }) => string;
+    InvalidModifierOnTypeParameter: ({ modifier }: {
+        modifier: TsModifier;
+    }) => string;
+    InvalidModifierOnTypeParameterPositions: ({ modifier, }: {
+        modifier: TsModifier;
+    }) => string;
+    InvalidModifierOnUsingDeclaration: (modifier: TsModifier) => string;
+    InvalidModifiersOrder: ({ orderedModifiers, }: {
+        orderedModifiers: [TsModifier, TsModifier];
+    }) => string;
+    InvalidNamespaceName: (value: string | number) => string;
+    InvalidPropertyAccessAfterInstantiationExpression: string;
+    InvalidTupleMemberLabel: string;
+    MissingInterfaceName: string;
+    NamespaceExportInTSNamespace: string;
+    NonAbstractClassHasAbstractMethod: string;
+    NonClassMethodPropertyHasAbstractModifier: string;
+    OptionalTypeBeforeRequired: string;
+    OverrideNotInSubClass: string;
+    PatternIsOptional: string;
+    PrivateElementHasAbstract: string;
+    PrivateElementHasAccessibility: ({ modifier, }: {
+        modifier: Accessibility;
+    }) => string;
+    ReadonlyForMethodSignature: string;
+    ReservedArrowTypeParam: string;
+    ReservedTypeAssertion: string;
+    SetAccessorCannotHaveOptionalParameter: string;
+    SetAccessorCannotHaveRestParameter: string;
+    SetAccessorCannotHaveReturnType: string;
+    SingleTypeParameterWithoutTrailingComma: ({ typeParameterName, }: {
+        typeParameterName: string;
+    }) => string;
+    StaticBlockCannotHaveModifier: string;
+    TupleOptionalAfterType: string;
+    TypeAnnotationAfterAssign: string;
+    TypeImportCannotSpecifyDefaultAndNamed: string;
+    TypeModifierIsUsedInTypeExports: string;
+    TypeModifierIsUsedInTypeImports: string;
+    UnexpectedParameterInitializer: string;
+    UnexpectedParameterModifier: string;
+    UnexpectedReadonly: string;
+    UnexpectedTypeAnnotation: string;
+    UnexpectedTypeCastInParameter: string;
+    UnexpectedTypeDeclaration: (type: "interface" | "type") => string;
+    UnsupportedImportTypeArgument: string;
+    UnsupportedParameterPropertyKind: string;
+    UnsupportedSignatureParameterKind: ({ type }: {
+        type: string;
+    }) => string;
+    UsingDeclarationInAmbientContext: (kind: "using" | "await using") => string;
+};
+
+declare const FlowErrorTemplates: {
+    AmbiguousConditionalArrow: string;
+    AmbiguousDeclareModuleKind: string;
+    AssignReservedType: ({ reservedType }: {
+        reservedType: string;
+    }) => string;
+    DeclareClassElement: string;
+    DeclareClassFieldInitializer: string;
+    DuplicateDeclareModuleExports: string;
+    EnumBooleanMemberNotInitialized: ({ memberName, enumName, }: {
+        memberName: string;
+        enumName: string;
+    }) => string;
+    EnumDuplicateMemberName: ({ memberName, enumName, }: {
+        memberName: string;
+        enumName: string;
+    }) => string;
+    EnumInconsistentMemberValues: ({ enumName }: {
+        enumName: string;
+    }) => string;
+    EnumInvalidExplicitType: ({ invalidEnumType, enumName, }: {
+        invalidEnumType: string;
+        enumName: string;
+    }) => string;
+    EnumInvalidExplicitTypeUnknownSupplied: ({ enumName, }: {
+        enumName: string;
+    }) => string;
+    EnumInvalidMemberInitializerPrimaryType: ({ enumName, memberName, explicitType, }: {
+        enumName: string;
+        memberName: string;
+        explicitType: EnumExplicitType;
+    }) => string;
+    EnumInvalidMemberInitializerSymbolType: ({ enumName, memberName, }: {
+        enumName: string;
+        memberName: string;
+        explicitType: EnumExplicitType;
+    }) => string;
+    EnumInvalidMemberInitializerUnknownType: ({ enumName, memberName, }: {
+        enumName: string;
+        memberName: string;
+        explicitType: EnumExplicitType;
+    }) => string;
+    EnumInvalidMemberName: ({ enumName, memberName, suggestion, }: {
+        enumName: string;
+        memberName: string;
+        suggestion: string;
+    }) => string;
+    EnumNumberMemberNotInitialized: ({ enumName, memberName, }: {
+        enumName: string;
+        memberName: string;
+    }) => string;
+    EnumStringMemberInconsistentlyInitialized: ({ enumName, }: {
+        enumName: string;
+    }) => string;
+    GetterMayNotHaveThisParam: string;
+    ImportTypeShorthandOnlyInPureImport: string;
+    InexactInsideExact: string;
+    InexactInsideNonObject: string;
+    InexactVariance: string;
+    InvalidNonTypeImportInDeclareModule: string;
+    MissingTypeParamDefault: string;
+    NestedDeclareModule: string;
+    NestedFlowComment: string;
+    PatternIsOptional: {
+        message: string;
+    };
+    SetterMayNotHaveThisParam: string;
+    SpreadVariance: string;
+    ThisParamAnnotationRequired: string;
+    ThisParamBannedInConstructor: string;
+    ThisParamMayNotBeOptional: string;
+    ThisParamMustBeFirst: string;
+    ThisParamNoDefault: string;
+    TypeBeforeInitializer: string;
+    TypeCastInPattern: string;
+    UnexpectedExplicitInexactInObject: string;
+    UnexpectedReservedType: ({ reservedType }: {
+        reservedType: string;
+    }) => string;
+    UnexpectedReservedUnderscore: string;
+    UnexpectedSpaceBetweenModuloChecks: string;
+    UnexpectedSpreadType: string;
+    UnexpectedSubtractionOperand: string;
+    UnexpectedTokenAfterTypeParameter: string;
+    UnexpectedTypeParameterBeforeAsyncArrowFunction: string;
+    UnsupportedDeclareExportKind: ({ unsupportedExportKind, suggestion, }: {
+        unsupportedExportKind: string;
+        suggestion: string;
+    }) => string;
+    UnsupportedStatementInDeclareModule: string;
+    UnterminatedFlowComment: string;
+};
+type EnumExplicitType = null | "boolean" | "number" | "string" | "symbol";
+
+type ParseError = SyntaxError & {
+    missingPlugin?: string | string[];
+    loc: Position;
+    pos: number;
+} & ErrorInfo;
+type ParseErrorConstructor<ErrorDetails> = (loc: Position, pos: number, details: ErrorDetails) => ParseError;
+type ToMessage<ErrorDetails> = (self: ErrorDetails) => string;
+type ErrorToObject<T> = {
+    [K in keyof T]: {
+        code: T[K] extends {
+            code: string;
+        } ? T[K]["code"] : "BABEL_PARSER_SYNTAX_ERROR";
+        reasonCode: K;
+        details: T[K] extends {
+            message: string | ToMessage<any>;
+        } ? T[K]["message"] extends ToMessage<any> ? Parameters<T[K]["message"]>[0] : object : T[K] extends ToMessage<any> ? Parameters<T[K]>[0] : object;
+    };
+};
+type __ExtractMe = typeof _default$4 & typeof _default$3 & typeof _default$2 & typeof _default$1 & typeof _default & typeof _default$5 & typeof TSErrorTemplates & typeof FlowErrorTemplates & typeof JsxErrorTemplates & typeof PlaceholderErrorTemplates;
+type __PatchMe = never & Decompress<ErrorInfoCompressed>;
+type ErrorsObjects = ErrorToObject<__ExtractMe>;
+type ErrorInfo = __PatchMe | ErrorsObjects[keyof ErrorsObjects];
+type ErrorInfoCompressed = {};
+type Decompress<T extends object> = {
+    [K in keyof T]: T[K] extends [infer Param, infer Code] ? {
+        code: Code;
+        reasonCode: K;
+        details: Param;
+    } : T[K] extends [infer Param] ? {
+        code: "BABEL_PARSER_SYNTAX_ERROR";
+        reasonCode: K;
+        details: Param;
+    } : T[K] extends [] ? {
+        code: "BABEL_PARSER_SYNTAX_ERROR";
+        reasonCode: K;
+        details: object;
+    } : never;
+};
+
+declare const PlaceholderErrorTemplates: {
+    ClassNameIsRequired: string;
+    UnexpectedSpace: string;
+};
+
+type Plugin = PluginConfig;
+
+type SourceType = "script" | "commonjs" | "module" | "unambiguous";
+interface Options {
+    /**
+     * By default, import and export declarations can only appear at a program's top level.
+     * Setting this option to true allows them anywhere where a statement is allowed.
+     */
+    allowImportExportEverywhere?: boolean;
+    /**
+     * By default, await use is not allowed outside of an async function.
+     * Set this to true to accept such code.
+     */
+    allowAwaitOutsideFunction?: boolean;
+    /**
+     * By default, a return statement at the top level raises an error.
+     * Set this to true to accept such code.
+     */
+    allowReturnOutsideFunction?: boolean;
+    /**
+     * By default, new.target use is not allowed outside of a function or class.
+     * Set this to true to accept such code.
+     */
+    allowNewTargetOutsideFunction?: boolean;
+    /**
+     * By default, super calls are not allowed outside of a method.
+     * Set this to true to accept such code.
+     */
+    allowSuperOutsideMethod?: boolean;
+    /**
+     * By default, exported identifiers must refer to a declared variable.
+     * Set this to true to allow export statements to reference undeclared variables.
+     */
+    allowUndeclaredExports?: boolean;
+    /**
+     * By default, yield use is not allowed outside of a generator function.
+     * Set this to true to accept such code.
+     */
+    allowYieldOutsideFunction?: boolean;
+    /**
+     * By default, Babel parser JavaScript code according to Annex B syntax.
+     * Set this to `false` to disable such behavior.
+     */
+    annexB?: boolean;
+    /**
+     * By default, Babel attaches comments to adjacent AST nodes.
+     * When this option is set to false, comments are not attached.
+     * It can provide up to 30% performance improvement when the input code has many comments.
+     * @babel/eslint-parser will set it for you.
+     * It is not recommended to use attachComment: false with Babel transform,
+     * as doing so removes all the comments in output code, and renders annotations such as
+     * /* istanbul ignore next *\/ nonfunctional.
+     */
+    attachComment?: boolean;
+    /**
+     * By default, Babel always throws an error when it finds some invalid code.
+     * When this option is set to true, it will store the parsing error and
+     * try to continue parsing the invalid input file.
+     */
+    errorRecovery?: boolean;
+    /**
+     * Indicate the mode the code should be parsed in.
+     * Can be one of "script", "commonjs", "module", or "unambiguous". Defaults to "script".
+     * "unambiguous" will make @babel/parser attempt to guess, based on the presence
+     * of ES6 import or export statements.
+     * Files with ES6 imports and exports are considered "module" and are otherwise "script".
+     *
+     * Use "commonjs" to parse code that is intended to be run in a CommonJS environment such as Node.js.
+     */
+    sourceType?: SourceType;
+    /**
+     * Correlate output AST nodes with their source filename.
+     * Useful when generating code and source maps from the ASTs of multiple input files.
+     */
+    sourceFilename?: string;
+    /**
+     * By default, all source indexes start from 0.
+     * You can provide a start index to alternatively start with.
+     * Useful for integration with other source tools.
+     */
+    startIndex?: number;
+    /**
+     * By default, the first line of code parsed is treated as line 1.
+     * You can provide a line number to alternatively start with.
+     * Useful for integration with other source tools.
+     */
+    startLine?: number;
+    /**
+     * By default, the parsed code is treated as if it starts from line 1, column 0.
+     * You can provide a column number to alternatively start with.
+     * Useful for integration with other source tools.
+     */
+    startColumn?: number;
+    /**
+     * Array containing the plugins that you want to enable.
+     */
+    plugins?: Plugin[];
+    /**
+     * Should the parser work in strict mode.
+     * Defaults to true if sourceType === 'module'. Otherwise, false.
+     */
+    strictMode?: boolean;
+    /**
+     * Adds a ranges property to each node: [node.start, node.end]
+     */
+    ranges?: boolean;
+    /**
+     * Adds a locations property to each node: [node.loc]
+     */
+    locations?: boolean;
+    /**
+     * Adds all parsed tokens to a tokens property on the File node.
+     */
+    tokens?: boolean;
+    /**
+     * By default, the parser adds information about parentheses by setting
+     * `extra.parenthesized` to `true` as needed.
+     * When this option is `true` the parser creates `ParenthesizedExpression`
+     * AST nodes instead of using the `extra` property.
+     */
+    createParenthesizedExpressions?: boolean;
+    /**
+     * By default, the parser parses import expressions as an `ImportExpression` node.
+     * Set this to false to parse it as `CallExpression(Import, [Identifier(foo)])`.
+     */
+    createImportExpressions?: boolean;
+}
+type KeepOptionalKeys = "sourceFilename" | "strictMode";
+type OptionsWithDefaults = Omit<Required<Options>, KeepOptionalKeys> & Pick<Options, KeepOptionalKeys>;
+
+type ParserOptions = Partial<Options>;
+type ParseResult<Result extends File | Expression = File> = Result & {
+    comments: File["comments"];
+    errors: ParseError[];
+    tokens?: File["tokens"];
+};
+/**
+ * Parse the provided code as an entire ECMAScript program.
+ */
+declare function parse(input: string, options?: ParserOptions): ParseResult<File>;
+declare function parseExpression(input: string, options?: ParserOptions): ParseResult<Expression>;
+declare const tokTypes: Record<string, ExportedTokenType>;
+declare function getLine(locData: Uint32Array, pos: number): number;
+declare function getColumn(locData: Uint32Array, pos: number): number;
+
+export { type FlowPluginOptions, type ParseError, type ParseResult, type ParserOptions, type PluginConfig as ParserPlugin, type PipelineOperatorPluginOptions, Token, type TypeScriptPluginOptions, getColumn, getLine, parse, parseExpression, tokTypes };