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 ? M : unknown; type UnparenthesizedPipeBodyTypes = GetSetMemberType; 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, 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; } 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; 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; 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; 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 = (loc: Position, pos: number, details: ErrorDetails) => ParseError; type ToMessage = (self: ErrorDetails) => string; type ErrorToObject = { [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; } ? T[K]["message"] extends ToMessage ? Parameters[0] : object : T[K] extends ToMessage ? Parameters[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; type ErrorsObjects = ErrorToObject<__ExtractMe>; type ErrorInfo = __PatchMe | ErrorsObjects[keyof ErrorsObjects]; type ErrorInfoCompressed = {}; type Decompress = { [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, KeepOptionalKeys> & Pick; type ParserOptions = Partial; type ParseResult = 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; declare function parseExpression(input: string, options?: ParserOptions): ParseResult; declare const tokTypes: Record; 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 };