Skip to content
GitLab
Commit 956c501c authored by DatHV's avatar DatHV
Browse files

update build x-app-sdk

parent 9bb8aadd
Show whitespace changes
Inline Side-by-side
node_modules/@babel/types/lib/index.js.flow 0 → 100644
View file @ 956c501c
// NOTE: This file is autogenerated. Do not modify.
// See packages/babel-types/scripts/generators/flow.js for script used.
declare class BabelNodeComment {
value: string;
start: number;
end: number;
loc: BabelNodeSourceLocation;
}
declare class BabelNodeCommentBlock extends BabelNodeComment {
type: "CommentBlock";
}
declare class BabelNodeCommentLine extends BabelNodeComment {
type: "CommentLine";
}
declare class BabelNodeSourceLocation {
start: {
line: number;
column: number;
};
end: {
line: number;
column: number;
};
}
declare class BabelNode {
leadingComments?: Array<BabelNodeComment>;
innerComments?: Array<BabelNodeComment>;
trailingComments?: Array<BabelNodeComment>;
start: ?number;
end: ?number;
loc: ?BabelNodeSourceLocation;
extra?: { [string]: mixed };
}
declare class BabelNodeArrayExpression extends BabelNode {
type: "ArrayExpression";
elements?: Array<null | BabelNodeExpression | BabelNodeSpreadElement>;
}
declare class BabelNodeAssignmentExpression extends BabelNode {
type: "AssignmentExpression";
operator: string;
left: BabelNodeLVal | BabelNodeOptionalMemberExpression;
right: BabelNodeExpression;
}
declare class BabelNodeBinaryExpression extends BabelNode {
type: "BinaryExpression";
operator: "+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "in" | "instanceof" | ">" | "<" | ">=" | "<=" | "|>";
left: BabelNodeExpression | BabelNodePrivateName;
right: BabelNodeExpression;
}
declare class BabelNodeInterpreterDirective extends BabelNode {
type: "InterpreterDirective";
value: string;
}
declare class BabelNodeDirective extends BabelNode {
type: "Directive";
value: BabelNodeDirectiveLiteral;
}
declare class BabelNodeDirectiveLiteral extends BabelNode {
type: "DirectiveLiteral";
value: string;
}
declare class BabelNodeBlockStatement extends BabelNode {
type: "BlockStatement";
body: Array<BabelNodeStatement>;
directives?: Array<BabelNodeDirective>;
}
declare class BabelNodeBreakStatement extends BabelNode {
type: "BreakStatement";
label?: BabelNodeIdentifier;
}
declare class BabelNodeCallExpression extends BabelNode {
type: "CallExpression";
callee: BabelNodeExpression | BabelNodeSuper | BabelNodeV8IntrinsicIdentifier;
arguments: Array<BabelNodeExpression | BabelNodeSpreadElement | BabelNodeArgumentPlaceholder>;
optional?: boolean;
typeArguments?: BabelNodeTypeParameterInstantiation;
typeParameters?: BabelNodeTSTypeParameterInstantiation;
}
declare class BabelNodeCatchClause extends BabelNode {
type: "CatchClause";
param?: BabelNodeIdentifier | BabelNodeArrayPattern | BabelNodeObjectPattern;
body: BabelNodeBlockStatement;
}
declare class BabelNodeConditionalExpression extends BabelNode {
type: "ConditionalExpression";
test: BabelNodeExpression;
consequent: BabelNodeExpression;
alternate: BabelNodeExpression;
}
declare class BabelNodeContinueStatement extends BabelNode {
type: "ContinueStatement";
label?: BabelNodeIdentifier;
}
declare class BabelNodeDebuggerStatement extends BabelNode {
type: "DebuggerStatement";
}
declare class BabelNodeDoWhileStatement extends BabelNode {
type: "DoWhileStatement";
test: BabelNodeExpression;
body: BabelNodeStatement;
}
declare class BabelNodeEmptyStatement extends BabelNode {
type: "EmptyStatement";
}
declare class BabelNodeExpressionStatement extends BabelNode {
type: "ExpressionStatement";
expression: BabelNodeExpression;
}
declare class BabelNodeFile extends BabelNode {
type: "File";
program: BabelNodeProgram;
comments?: Array<BabelNodeCommentBlock | BabelNodeCommentLine>;
tokens?: Array<any>;
}
declare class BabelNodeForInStatement extends BabelNode {
type: "ForInStatement";
left: BabelNodeVariableDeclaration | BabelNodeLVal;
right: BabelNodeExpression;
body: BabelNodeStatement;
}
declare class BabelNodeForStatement extends BabelNode {
type: "ForStatement";
init?: BabelNodeVariableDeclaration | BabelNodeExpression;
test?: BabelNodeExpression;
update?: BabelNodeExpression;
body: BabelNodeStatement;
}
declare class BabelNodeFunctionDeclaration extends BabelNode {
type: "FunctionDeclaration";
id?: BabelNodeIdentifier;
params: Array<BabelNodeFunctionParameter>;
body: BabelNodeBlockStatement;
generator?: boolean;
async?: boolean;
declare?: boolean;
predicate?: BabelNodeDeclaredPredicate | BabelNodeInferredPredicate;
returnType?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop;
}
declare class BabelNodeFunctionExpression extends BabelNode {
type: "FunctionExpression";
id?: BabelNodeIdentifier;
params: Array<BabelNodeFunctionParameter>;
body: BabelNodeBlockStatement;
generator?: boolean;
async?: boolean;
predicate?: BabelNodeDeclaredPredicate | BabelNodeInferredPredicate;
returnType?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop;
}
declare class BabelNodeIdentifier extends BabelNode {
type: "Identifier";
name: string;
decorators?: Array<BabelNodeDecorator>;
optional?: boolean;
typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
}
declare class BabelNodeIfStatement extends BabelNode {
type: "IfStatement";
test: BabelNodeExpression;
consequent: BabelNodeStatement;
alternate?: BabelNodeStatement;
}
declare class BabelNodeLabeledStatement extends BabelNode {
type: "LabeledStatement";
label: BabelNodeIdentifier;
body: BabelNodeStatement;
}
declare class BabelNodeStringLiteral extends BabelNode {
type: "StringLiteral";
value: string;
}
declare class BabelNodeNumericLiteral extends BabelNode {
type: "NumericLiteral";
value: number;
}
declare class BabelNodeNullLiteral extends BabelNode {
type: "NullLiteral";
}
declare class BabelNodeBooleanLiteral extends BabelNode {
type: "BooleanLiteral";
value: boolean;
}
declare class BabelNodeRegExpLiteral extends BabelNode {
type: "RegExpLiteral";
pattern: string;
flags?: string;
}
declare class BabelNodeLogicalExpression extends BabelNode {
type: "LogicalExpression";
operator: "||" | "&&" | "??";
left: BabelNodeExpression;
right: BabelNodeExpression;
}
declare class BabelNodeMemberExpression extends BabelNode {
type: "MemberExpression";
object: BabelNodeExpression | BabelNodeSuper;
property: BabelNodeExpression | BabelNodeIdentifier | BabelNodePrivateName;
computed?: boolean;
optional?: boolean;
}
declare class BabelNodeNewExpression extends BabelNode {
type: "NewExpression";
callee: BabelNodeExpression | BabelNodeSuper | BabelNodeV8IntrinsicIdentifier;
arguments: Array<BabelNodeExpression | BabelNodeSpreadElement | BabelNodeArgumentPlaceholder>;
optional?: boolean;
typeArguments?: BabelNodeTypeParameterInstantiation;
typeParameters?: BabelNodeTSTypeParameterInstantiation;
}
declare class BabelNodeProgram extends BabelNode {
type: "Program";
body: Array<BabelNodeStatement>;
directives?: Array<BabelNodeDirective>;
sourceType?: "script" | "module";
interpreter?: BabelNodeInterpreterDirective;
}
declare class BabelNodeObjectExpression extends BabelNode {
type: "ObjectExpression";
properties: Array<BabelNodeObjectMethod | BabelNodeObjectProperty | BabelNodeSpreadElement>;
}
declare class BabelNodeObjectMethod extends BabelNode {
type: "ObjectMethod";
kind?: "method" | "get" | "set";
key: BabelNodeExpression | BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral;
params: Array<BabelNodeFunctionParameter>;
body: BabelNodeBlockStatement;
computed?: boolean;
generator?: boolean;
async?: boolean;
decorators?: Array<BabelNodeDecorator>;
returnType?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop;
}
declare class BabelNodeObjectProperty extends BabelNode {
type: "ObjectProperty";
key: BabelNodeExpression | BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | BabelNodeDecimalLiteral | BabelNodePrivateName;
value: BabelNodeExpression | BabelNodePatternLike;
computed?: boolean;
shorthand?: boolean;
decorators?: Array<BabelNodeDecorator>;
}
declare class BabelNodeRestElement extends BabelNode {
type: "RestElement";
argument: BabelNodeIdentifier | BabelNodeArrayPattern | BabelNodeObjectPattern | BabelNodeMemberExpression | BabelNodeTSAsExpression | BabelNodeTSSatisfiesExpression | BabelNodeTSTypeAssertion | BabelNodeTSNonNullExpression | BabelNodeRestElement | BabelNodeAssignmentPattern;
decorators?: Array<BabelNodeDecorator>;
optional?: boolean;
typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
}
declare class BabelNodeReturnStatement extends BabelNode {
type: "ReturnStatement";
argument?: BabelNodeExpression;
}
declare class BabelNodeSequenceExpression extends BabelNode {
type: "SequenceExpression";
expressions: Array<BabelNodeExpression>;
}
declare class BabelNodeParenthesizedExpression extends BabelNode {
type: "ParenthesizedExpression";
expression: BabelNodeExpression;
}
declare class BabelNodeSwitchCase extends BabelNode {
type: "SwitchCase";
test?: BabelNodeExpression;
consequent: Array<BabelNodeStatement>;
}
declare class BabelNodeSwitchStatement extends BabelNode {
type: "SwitchStatement";
discriminant: BabelNodeExpression;
cases: Array<BabelNodeSwitchCase>;
}
declare class BabelNodeThisExpression extends BabelNode {
type: "ThisExpression";
}
declare class BabelNodeThrowStatement extends BabelNode {
type: "ThrowStatement";
argument: BabelNodeExpression;
}
declare class BabelNodeTryStatement extends BabelNode {
type: "TryStatement";
block: BabelNodeBlockStatement;
handler?: BabelNodeCatchClause;
finalizer?: BabelNodeBlockStatement;
}
declare class BabelNodeUnaryExpression extends BabelNode {
type: "UnaryExpression";
operator: "void" | "throw" | "delete" | "!" | "+" | "-" | "~" | "typeof";
argument: BabelNodeExpression;
prefix?: boolean;
}
declare class BabelNodeUpdateExpression extends BabelNode {
type: "UpdateExpression";
operator: "++" | "--";
argument: BabelNodeExpression;
prefix?: boolean;
}
declare class BabelNodeVariableDeclaration extends BabelNode {
type: "VariableDeclaration";
kind: "var" | "let" | "const" | "using" | "await using";
declarations: Array<BabelNodeVariableDeclarator>;
declare?: boolean;
}
declare class BabelNodeVariableDeclarator extends BabelNode {
type: "VariableDeclarator";
id: BabelNodeLVal | BabelNodeVoidPattern;
init?: BabelNodeExpression;
definite?: boolean;
}
declare class BabelNodeWhileStatement extends BabelNode {
type: "WhileStatement";
test: BabelNodeExpression;
body: BabelNodeStatement;
}
declare class BabelNodeWithStatement extends BabelNode {
type: "WithStatement";
object: BabelNodeExpression;
body: BabelNodeStatement;
}
declare class BabelNodeAssignmentPattern extends BabelNode {
type: "AssignmentPattern";
left: BabelNodeIdentifier | BabelNodeObjectPattern | BabelNodeArrayPattern | BabelNodeMemberExpression | BabelNodeTSAsExpression | BabelNodeTSSatisfiesExpression | BabelNodeTSTypeAssertion | BabelNodeTSNonNullExpression;
right: BabelNodeExpression;
decorators?: Array<BabelNodeDecorator>;
optional?: boolean;
typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
}
declare class BabelNodeArrayPattern extends BabelNode {
type: "ArrayPattern";
elements: Array<null | BabelNodePatternLike>;
decorators?: Array<BabelNodeDecorator>;
optional?: boolean;
typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
}
declare class BabelNodeArrowFunctionExpression extends BabelNode {
type: "ArrowFunctionExpression";
params: Array<BabelNodeFunctionParameter>;
body: BabelNodeBlockStatement | BabelNodeExpression;
async?: boolean;
expression: boolean;
generator?: boolean;
predicate?: BabelNodeDeclaredPredicate | BabelNodeInferredPredicate;
returnType?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop;
}
declare class BabelNodeClassBody extends BabelNode {
type: "ClassBody";
body: Array<BabelNodeClassMethod | BabelNodeClassPrivateMethod | BabelNodeClassProperty | BabelNodeClassPrivateProperty | BabelNodeClassAccessorProperty | BabelNodeTSDeclareMethod | BabelNodeTSIndexSignature | BabelNodeStaticBlock>;
}
declare class BabelNodeClassExpression extends BabelNode {
type: "ClassExpression";
id?: BabelNodeIdentifier;
superClass?: BabelNodeExpression;
body: BabelNodeClassBody;
decorators?: Array<BabelNodeDecorator>;
mixins?: BabelNodeInterfaceExtends;
superTypeParameters?: BabelNodeTypeParameterInstantiation | BabelNodeTSTypeParameterInstantiation;
typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop;
}
declare class BabelNodeClassDeclaration extends BabelNode {
type: "ClassDeclaration";
id?: BabelNodeIdentifier;
superClass?: BabelNodeExpression;
body: BabelNodeClassBody;
decorators?: Array<BabelNodeDecorator>;
abstract?: boolean;
declare?: boolean;
mixins?: BabelNodeInterfaceExtends;
superTypeParameters?: BabelNodeTypeParameterInstantiation | BabelNodeTSTypeParameterInstantiation;
typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop;
}
declare class BabelNodeExportAllDeclaration extends BabelNode {
type: "ExportAllDeclaration";
source: BabelNodeStringLiteral;
assertions?: Array<BabelNodeImportAttribute>;
attributes?: Array<BabelNodeImportAttribute>;
exportKind?: "type" | "value";
}
declare class BabelNodeExportDefaultDeclaration extends BabelNode {
type: "ExportDefaultDeclaration";
declaration: BabelNodeTSDeclareFunction | BabelNodeFunctionDeclaration | BabelNodeClassDeclaration | BabelNodeExpression;
exportKind?: "value";
}
declare class BabelNodeExportNamedDeclaration extends BabelNode {
type: "ExportNamedDeclaration";
declaration?: BabelNodeDeclaration;
specifiers?: Array<BabelNodeExportSpecifier | BabelNodeExportDefaultSpecifier | BabelNodeExportNamespaceSpecifier>;
source?: BabelNodeStringLiteral;
assertions?: Array<BabelNodeImportAttribute>;
attributes?: Array<BabelNodeImportAttribute>;
exportKind?: "type" | "value";
}
declare class BabelNodeExportSpecifier extends BabelNode {
type: "ExportSpecifier";
local: BabelNodeIdentifier;
exported: BabelNodeIdentifier | BabelNodeStringLiteral;
exportKind?: "type" | "value";
}
declare class BabelNodeForOfStatement extends BabelNode {
type: "ForOfStatement";
left: BabelNodeVariableDeclaration | BabelNodeLVal;
right: BabelNodeExpression;
body: BabelNodeStatement;
}
declare class BabelNodeImportDeclaration extends BabelNode {
type: "ImportDeclaration";
specifiers: Array<BabelNodeImportSpecifier | BabelNodeImportDefaultSpecifier | BabelNodeImportNamespaceSpecifier>;
source: BabelNodeStringLiteral;
assertions?: Array<BabelNodeImportAttribute>;
attributes?: Array<BabelNodeImportAttribute>;
importKind?: "type" | "typeof" | "value";
module?: boolean;
phase?: "source" | "defer";
}
declare class BabelNodeImportDefaultSpecifier extends BabelNode {
type: "ImportDefaultSpecifier";
local: BabelNodeIdentifier;
}
declare class BabelNodeImportNamespaceSpecifier extends BabelNode {
type: "ImportNamespaceSpecifier";
local: BabelNodeIdentifier;
}
declare class BabelNodeImportSpecifier extends BabelNode {
type: "ImportSpecifier";
local: BabelNodeIdentifier;
imported: BabelNodeIdentifier | BabelNodeStringLiteral;
importKind?: "type" | "typeof" | "value";
}
declare class BabelNodeImportExpression extends BabelNode {
type: "ImportExpression";
source: BabelNodeExpression;
options?: BabelNodeExpression;
phase?: "source" | "defer";
}
declare class BabelNodeMetaProperty extends BabelNode {
type: "MetaProperty";
meta: BabelNodeIdentifier;
property: BabelNodeIdentifier;
}
declare class BabelNodeClassMethod extends BabelNode {
type: "ClassMethod";
kind?: "get" | "set" | "method" | "constructor";
key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | BabelNodeExpression;
params: Array<BabelNodeFunctionParameter | BabelNodeTSParameterProperty>;
body: BabelNodeBlockStatement;
computed?: boolean;
generator?: boolean;
async?: boolean;
abstract?: boolean;
access?: "public" | "private" | "protected";
accessibility?: "public" | "private" | "protected";
decorators?: Array<BabelNodeDecorator>;
optional?: boolean;
override?: boolean;
returnType?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop;
}
declare class BabelNodeObjectPattern extends BabelNode {
type: "ObjectPattern";
properties: Array<BabelNodeRestElement | BabelNodeObjectProperty>;
decorators?: Array<BabelNodeDecorator>;
optional?: boolean;
typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
}
declare class BabelNodeSpreadElement extends BabelNode {
type: "SpreadElement";
argument: BabelNodeExpression;
}
declare class BabelNodeSuper extends BabelNode {
type: "Super";
}
declare class BabelNodeTaggedTemplateExpression extends BabelNode {
type: "TaggedTemplateExpression";
tag: BabelNodeExpression;
quasi: BabelNodeTemplateLiteral;
typeParameters?: BabelNodeTypeParameterInstantiation | BabelNodeTSTypeParameterInstantiation;
}
declare class BabelNodeTemplateElement extends BabelNode {
type: "TemplateElement";
value: { raw: string, cooked?: string };
tail?: boolean;
}
declare class BabelNodeTemplateLiteral extends BabelNode {
type: "TemplateLiteral";
quasis: Array<BabelNodeTemplateElement>;
expressions: Array<BabelNodeExpression | BabelNodeTSType>;
}
declare class BabelNodeYieldExpression extends BabelNode {
type: "YieldExpression";
argument?: BabelNodeExpression;
delegate?: boolean;
}
declare class BabelNodeAwaitExpression extends BabelNode {
type: "AwaitExpression";
argument: BabelNodeExpression;
}
declare class BabelNodeImport extends BabelNode {
type: "Import";
}
declare class BabelNodeBigIntLiteral extends BabelNode {
type: "BigIntLiteral";
value: string;
}
declare class BabelNodeExportNamespaceSpecifier extends BabelNode {
type: "ExportNamespaceSpecifier";
exported: BabelNodeIdentifier;
}
declare class BabelNodeOptionalMemberExpression extends BabelNode {
type: "OptionalMemberExpression";
object: BabelNodeExpression;
property: BabelNodeExpression | BabelNodeIdentifier;
computed?: boolean;
optional: boolean;
}
declare class BabelNodeOptionalCallExpression extends BabelNode {
type: "OptionalCallExpression";
callee: BabelNodeExpression;
arguments: Array<BabelNodeExpression | BabelNodeSpreadElement | BabelNodeArgumentPlaceholder>;
optional: boolean;
typeArguments?: BabelNodeTypeParameterInstantiation;
typeParameters?: BabelNodeTSTypeParameterInstantiation;
}
declare class BabelNodeClassProperty extends BabelNode {
type: "ClassProperty";
key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | BabelNodeExpression;
value?: BabelNodeExpression;
typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
decorators?: Array<BabelNodeDecorator>;
computed?: boolean;
abstract?: boolean;
accessibility?: "public" | "private" | "protected";
declare?: boolean;
definite?: boolean;
optional?: boolean;
override?: boolean;
readonly?: boolean;
variance?: BabelNodeVariance;
}
declare class BabelNodeClassAccessorProperty extends BabelNode {
type: "ClassAccessorProperty";
key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | BabelNodeExpression | BabelNodePrivateName;
value?: BabelNodeExpression;
typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
decorators?: Array<BabelNodeDecorator>;
computed?: boolean;
abstract?: boolean;
accessibility?: "public" | "private" | "protected";
declare?: boolean;
definite?: boolean;
optional?: boolean;
override?: boolean;
readonly?: boolean;
variance?: BabelNodeVariance;
}
declare class BabelNodeClassPrivateProperty extends BabelNode {
type: "ClassPrivateProperty";
key: BabelNodePrivateName;
value?: BabelNodeExpression;
decorators?: Array<BabelNodeDecorator>;
definite?: boolean;
optional?: boolean;
readonly?: boolean;
typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
variance?: BabelNodeVariance;
}
declare class BabelNodeClassPrivateMethod extends BabelNode {
type: "ClassPrivateMethod";
kind?: "get" | "set" | "method";
key: BabelNodePrivateName;
params: Array<BabelNodeFunctionParameter | BabelNodeTSParameterProperty>;
body: BabelNodeBlockStatement;
abstract?: boolean;
access?: "public" | "private" | "protected";
accessibility?: "public" | "private" | "protected";
async?: boolean;
computed?: boolean;
decorators?: Array<BabelNodeDecorator>;
generator?: boolean;
optional?: boolean;
override?: boolean;
returnType?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop;
}
declare class BabelNodePrivateName extends BabelNode {
type: "PrivateName";
id: BabelNodeIdentifier;
}
declare class BabelNodeStaticBlock extends BabelNode {
type: "StaticBlock";
body: Array<BabelNodeStatement>;
}
declare class BabelNodeImportAttribute extends BabelNode {
type: "ImportAttribute";
key: BabelNodeIdentifier | BabelNodeStringLiteral;
value: BabelNodeStringLiteral;
}
declare class BabelNodeAnyTypeAnnotation extends BabelNode {
type: "AnyTypeAnnotation";
}
declare class BabelNodeArrayTypeAnnotation extends BabelNode {
type: "ArrayTypeAnnotation";
elementType: BabelNodeFlowType;
}
declare class BabelNodeBooleanTypeAnnotation extends BabelNode {
type: "BooleanTypeAnnotation";
}
declare class BabelNodeBooleanLiteralTypeAnnotation extends BabelNode {
type: "BooleanLiteralTypeAnnotation";
value: boolean;
}
declare class BabelNodeNullLiteralTypeAnnotation extends BabelNode {
type: "NullLiteralTypeAnnotation";
}
declare class BabelNodeClassImplements extends BabelNode {
type: "ClassImplements";
id: BabelNodeIdentifier;
typeParameters?: BabelNodeTypeParameterInstantiation;
}
declare class BabelNodeDeclareClass extends BabelNode {
type: "DeclareClass";
id: BabelNodeIdentifier;
typeParameters?: BabelNodeTypeParameterDeclaration;
body: BabelNodeObjectTypeAnnotation;
mixins?: Array<BabelNodeInterfaceExtends>;
}
declare class BabelNodeDeclareFunction extends BabelNode {
type: "DeclareFunction";
id: BabelNodeIdentifier;
predicate?: BabelNodeDeclaredPredicate;
}
declare class BabelNodeDeclareInterface extends BabelNode {
type: "DeclareInterface";
id: BabelNodeIdentifier;
typeParameters?: BabelNodeTypeParameterDeclaration;
body: BabelNodeObjectTypeAnnotation;
}
declare class BabelNodeDeclareModule extends BabelNode {
type: "DeclareModule";
id: BabelNodeIdentifier | BabelNodeStringLiteral;
body: BabelNodeBlockStatement;
kind?: "CommonJS" | "ES";
}
declare class BabelNodeDeclareModuleExports extends BabelNode {
type: "DeclareModuleExports";
typeAnnotation: BabelNodeTypeAnnotation;
}
declare class BabelNodeDeclareTypeAlias extends BabelNode {
type: "DeclareTypeAlias";
id: BabelNodeIdentifier;
typeParameters?: BabelNodeTypeParameterDeclaration;
right: BabelNodeFlowType;
}
declare class BabelNodeDeclareOpaqueType extends BabelNode {
type: "DeclareOpaqueType";
id: BabelNodeIdentifier;
typeParameters?: BabelNodeTypeParameterDeclaration;
supertype?: BabelNodeFlowType;
impltype?: BabelNodeFlowType;
}
declare class BabelNodeDeclareVariable extends BabelNode {
type: "DeclareVariable";
id: BabelNodeIdentifier;
}
declare class BabelNodeDeclareExportDeclaration extends BabelNode {
type: "DeclareExportDeclaration";
declaration?: BabelNodeFlow;
specifiers?: Array<BabelNodeExportSpecifier | BabelNodeExportNamespaceSpecifier>;
source?: BabelNodeStringLiteral;
attributes?: Array<BabelNodeImportAttribute>;
assertions?: Array<BabelNodeImportAttribute>;
}
declare class BabelNodeDeclareExportAllDeclaration extends BabelNode {
type: "DeclareExportAllDeclaration";
source: BabelNodeStringLiteral;
attributes?: Array<BabelNodeImportAttribute>;
assertions?: Array<BabelNodeImportAttribute>;
exportKind?: "type" | "value";
}
declare class BabelNodeDeclaredPredicate extends BabelNode {
type: "DeclaredPredicate";
value: BabelNodeFlow;
}
declare class BabelNodeExistsTypeAnnotation extends BabelNode {
type: "ExistsTypeAnnotation";
}
declare class BabelNodeFunctionTypeAnnotation extends BabelNode {
type: "FunctionTypeAnnotation";
typeParameters?: BabelNodeTypeParameterDeclaration;
params: Array<BabelNodeFunctionTypeParam>;
rest?: BabelNodeFunctionTypeParam;
returnType: BabelNodeFlowType;
}
declare class BabelNodeFunctionTypeParam extends BabelNode {
type: "FunctionTypeParam";
name?: BabelNodeIdentifier;
typeAnnotation: BabelNodeFlowType;
optional?: boolean;
}
declare class BabelNodeGenericTypeAnnotation extends BabelNode {
type: "GenericTypeAnnotation";
id: BabelNodeIdentifier | BabelNodeQualifiedTypeIdentifier;
typeParameters?: BabelNodeTypeParameterInstantiation;
}
declare class BabelNodeInferredPredicate extends BabelNode {
type: "InferredPredicate";
}
declare class BabelNodeInterfaceExtends extends BabelNode {
type: "InterfaceExtends";
id: BabelNodeIdentifier | BabelNodeQualifiedTypeIdentifier;
typeParameters?: BabelNodeTypeParameterInstantiation;
}
declare class BabelNodeInterfaceDeclaration extends BabelNode {
type: "InterfaceDeclaration";
id: BabelNodeIdentifier;
typeParameters?: BabelNodeTypeParameterDeclaration;
body: BabelNodeObjectTypeAnnotation;
}
declare class BabelNodeInterfaceTypeAnnotation extends BabelNode {
type: "InterfaceTypeAnnotation";
body: BabelNodeObjectTypeAnnotation;
}
declare class BabelNodeIntersectionTypeAnnotation extends BabelNode {
type: "IntersectionTypeAnnotation";
types: Array<BabelNodeFlowType>;
}
declare class BabelNodeMixedTypeAnnotation extends BabelNode {
type: "MixedTypeAnnotation";
}
declare class BabelNodeEmptyTypeAnnotation extends BabelNode {
type: "EmptyTypeAnnotation";
}
declare class BabelNodeNullableTypeAnnotation extends BabelNode {
type: "NullableTypeAnnotation";
typeAnnotation: BabelNodeFlowType;
}
declare class BabelNodeNumberLiteralTypeAnnotation extends BabelNode {
type: "NumberLiteralTypeAnnotation";
value: number;
}
declare class BabelNodeNumberTypeAnnotation extends BabelNode {
type: "NumberTypeAnnotation";
}
declare class BabelNodeObjectTypeAnnotation extends BabelNode {
type: "ObjectTypeAnnotation";
properties: Array<BabelNodeObjectTypeProperty | BabelNodeObjectTypeSpreadProperty>;
indexers?: Array<BabelNodeObjectTypeIndexer>;
callProperties?: Array<BabelNodeObjectTypeCallProperty>;
internalSlots?: Array<BabelNodeObjectTypeInternalSlot>;
exact?: boolean;
inexact?: boolean;
}
declare class BabelNodeObjectTypeInternalSlot extends BabelNode {
type: "ObjectTypeInternalSlot";
id: BabelNodeIdentifier;
value: BabelNodeFlowType;
optional: boolean;
method: boolean;
}
declare class BabelNodeObjectTypeCallProperty extends BabelNode {
type: "ObjectTypeCallProperty";
value: BabelNodeFlowType;
}
declare class BabelNodeObjectTypeIndexer extends BabelNode {
type: "ObjectTypeIndexer";
id?: BabelNodeIdentifier;
key: BabelNodeFlowType;
value: BabelNodeFlowType;
variance?: BabelNodeVariance;
}
declare class BabelNodeObjectTypeProperty extends BabelNode {
type: "ObjectTypeProperty";
key: BabelNodeIdentifier | BabelNodeStringLiteral;
value: BabelNodeFlowType;
variance?: BabelNodeVariance;
kind: "init" | "get" | "set";
method: boolean;
optional: boolean;
proto: boolean;
}
declare class BabelNodeObjectTypeSpreadProperty extends BabelNode {
type: "ObjectTypeSpreadProperty";
argument: BabelNodeFlowType;
}
declare class BabelNodeOpaqueType extends BabelNode {
type: "OpaqueType";
id: BabelNodeIdentifier;
typeParameters?: BabelNodeTypeParameterDeclaration;
supertype?: BabelNodeFlowType;
impltype: BabelNodeFlowType;
}
declare class BabelNodeQualifiedTypeIdentifier extends BabelNode {
type: "QualifiedTypeIdentifier";
id: BabelNodeIdentifier;
qualification: BabelNodeIdentifier | BabelNodeQualifiedTypeIdentifier;
}
declare class BabelNodeStringLiteralTypeAnnotation extends BabelNode {
type: "StringLiteralTypeAnnotation";
value: string;
}
declare class BabelNodeStringTypeAnnotation extends BabelNode {
type: "StringTypeAnnotation";
}
declare class BabelNodeSymbolTypeAnnotation extends BabelNode {
type: "SymbolTypeAnnotation";
}
declare class BabelNodeThisTypeAnnotation extends BabelNode {
type: "ThisTypeAnnotation";
}
declare class BabelNodeTupleTypeAnnotation extends BabelNode {
type: "TupleTypeAnnotation";
types: Array<BabelNodeFlowType>;
}
declare class BabelNodeTypeofTypeAnnotation extends BabelNode {
type: "TypeofTypeAnnotation";
argument: BabelNodeFlowType;
}
declare class BabelNodeTypeAlias extends BabelNode {
type: "TypeAlias";
id: BabelNodeIdentifier;
typeParameters?: BabelNodeTypeParameterDeclaration;
right: BabelNodeFlowType;
}
declare class BabelNodeTypeAnnotation extends BabelNode {
type: "TypeAnnotation";
typeAnnotation: BabelNodeFlowType;
}
declare class BabelNodeTypeCastExpression extends BabelNode {
type: "TypeCastExpression";
expression: BabelNodeExpression;
typeAnnotation: BabelNodeTypeAnnotation;
}
declare class BabelNodeTypeParameter extends BabelNode {
type: "TypeParameter";
bound?: BabelNodeTypeAnnotation;
variance?: BabelNodeVariance;
name: string;
}
declare class BabelNodeTypeParameterDeclaration extends BabelNode {
type: "TypeParameterDeclaration";
params: Array<BabelNodeTypeParameter>;
}
declare class BabelNodeTypeParameterInstantiation extends BabelNode {
type: "TypeParameterInstantiation";
params: Array<BabelNodeFlowType>;
}
declare class BabelNodeUnionTypeAnnotation extends BabelNode {
type: "UnionTypeAnnotation";
types: Array<BabelNodeFlowType>;
}
declare class BabelNodeVariance extends BabelNode {
type: "Variance";
kind: "minus" | "plus";
}
declare class BabelNodeVoidTypeAnnotation extends BabelNode {
type: "VoidTypeAnnotation";
}
declare class BabelNodeEnumDeclaration extends BabelNode {
type: "EnumDeclaration";
id: BabelNodeIdentifier;
body: BabelNodeEnumBooleanBody | BabelNodeEnumNumberBody | BabelNodeEnumStringBody | BabelNodeEnumSymbolBody;
}
declare class BabelNodeEnumBooleanBody extends BabelNode {
type: "EnumBooleanBody";
members: Array<BabelNodeEnumBooleanMember>;
explicitType: boolean;
hasUnknownMembers: boolean;
}
declare class BabelNodeEnumNumberBody extends BabelNode {
type: "EnumNumberBody";
members: Array<BabelNodeEnumNumberMember>;
explicitType: boolean;
hasUnknownMembers: boolean;
}
declare class BabelNodeEnumStringBody extends BabelNode {
type: "EnumStringBody";
members: Array<BabelNodeEnumStringMember | BabelNodeEnumDefaultedMember>;
explicitType: boolean;
hasUnknownMembers: boolean;
}
declare class BabelNodeEnumSymbolBody extends BabelNode {
type: "EnumSymbolBody";
members: Array<BabelNodeEnumDefaultedMember>;
hasUnknownMembers: boolean;
}
declare class BabelNodeEnumBooleanMember extends BabelNode {
type: "EnumBooleanMember";
id: BabelNodeIdentifier;
init: BabelNodeBooleanLiteral;
}
declare class BabelNodeEnumNumberMember extends BabelNode {
type: "EnumNumberMember";
id: BabelNodeIdentifier;
init: BabelNodeNumericLiteral;
}
declare class BabelNodeEnumStringMember extends BabelNode {
type: "EnumStringMember";
id: BabelNodeIdentifier;
init: BabelNodeStringLiteral;
}
declare class BabelNodeEnumDefaultedMember extends BabelNode {
type: "EnumDefaultedMember";
id: BabelNodeIdentifier;
}
declare class BabelNodeIndexedAccessType extends BabelNode {
type: "IndexedAccessType";
objectType: BabelNodeFlowType;
indexType: BabelNodeFlowType;
}
declare class BabelNodeOptionalIndexedAccessType extends BabelNode {
type: "OptionalIndexedAccessType";
objectType: BabelNodeFlowType;
indexType: BabelNodeFlowType;
optional: boolean;
}
declare class BabelNodeJSXAttribute extends BabelNode {
type: "JSXAttribute";
name: BabelNodeJSXIdentifier | BabelNodeJSXNamespacedName;
value?: BabelNodeJSXElement | BabelNodeJSXFragment | BabelNodeStringLiteral | BabelNodeJSXExpressionContainer;
}
declare class BabelNodeJSXClosingElement extends BabelNode {
type: "JSXClosingElement";
name: BabelNodeJSXIdentifier | BabelNodeJSXMemberExpression | BabelNodeJSXNamespacedName;
}
declare class BabelNodeJSXElement extends BabelNode {
type: "JSXElement";
openingElement: BabelNodeJSXOpeningElement;
closingElement?: BabelNodeJSXClosingElement;
children: Array<BabelNodeJSXText | BabelNodeJSXExpressionContainer | BabelNodeJSXSpreadChild | BabelNodeJSXElement | BabelNodeJSXFragment>;
selfClosing?: boolean;
}
declare class BabelNodeJSXEmptyExpression extends BabelNode {
type: "JSXEmptyExpression";
}
declare class BabelNodeJSXExpressionContainer extends BabelNode {
type: "JSXExpressionContainer";
expression: BabelNodeExpression | BabelNodeJSXEmptyExpression;
}
declare class BabelNodeJSXSpreadChild extends BabelNode {
type: "JSXSpreadChild";
expression: BabelNodeExpression;
}
declare class BabelNodeJSXIdentifier extends BabelNode {
type: "JSXIdentifier";
name: string;
}
declare class BabelNodeJSXMemberExpression extends BabelNode {
type: "JSXMemberExpression";
object: BabelNodeJSXMemberExpression | BabelNodeJSXIdentifier;
property: BabelNodeJSXIdentifier;
}
declare class BabelNodeJSXNamespacedName extends BabelNode {
type: "JSXNamespacedName";
namespace: BabelNodeJSXIdentifier;
name: BabelNodeJSXIdentifier;
}
declare class BabelNodeJSXOpeningElement extends BabelNode {
type: "JSXOpeningElement";
name: BabelNodeJSXIdentifier | BabelNodeJSXMemberExpression | BabelNodeJSXNamespacedName;
attributes: Array<BabelNodeJSXAttribute | BabelNodeJSXSpreadAttribute>;
selfClosing?: boolean;
typeArguments?: BabelNodeTypeParameterInstantiation;
typeParameters?: BabelNodeTSTypeParameterInstantiation;
}
declare class BabelNodeJSXSpreadAttribute extends BabelNode {
type: "JSXSpreadAttribute";
argument: BabelNodeExpression;
}
declare class BabelNodeJSXText extends BabelNode {
type: "JSXText";
value: string;
}
declare class BabelNodeJSXFragment extends BabelNode {
type: "JSXFragment";
openingFragment: BabelNodeJSXOpeningFragment;
closingFragment: BabelNodeJSXClosingFragment;
children: Array<BabelNodeJSXText | BabelNodeJSXExpressionContainer | BabelNodeJSXSpreadChild | BabelNodeJSXElement | BabelNodeJSXFragment>;
}
declare class BabelNodeJSXOpeningFragment extends BabelNode {
type: "JSXOpeningFragment";
}
declare class BabelNodeJSXClosingFragment extends BabelNode {
type: "JSXClosingFragment";
}
declare class BabelNodeNoop extends BabelNode {
type: "Noop";
}
declare class BabelNodePlaceholder extends BabelNode {
type: "Placeholder";
expectedNode: "Identifier" | "StringLiteral" | "Expression" | "Statement" | "Declaration" | "BlockStatement" | "ClassBody" | "Pattern";
name: BabelNodeIdentifier;
decorators?: Array<BabelNodeDecorator>;
optional?: boolean;
typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
}
declare class BabelNodeV8IntrinsicIdentifier extends BabelNode {
type: "V8IntrinsicIdentifier";
name: string;
}
declare class BabelNodeArgumentPlaceholder extends BabelNode {
type: "ArgumentPlaceholder";
}
declare class BabelNodeBindExpression extends BabelNode {
type: "BindExpression";
object: BabelNodeExpression;
callee: BabelNodeExpression;
}
declare class BabelNodeDecorator extends BabelNode {
type: "Decorator";
expression: BabelNodeExpression;
}
declare class BabelNodeDoExpression extends BabelNode {
type: "DoExpression";
body: BabelNodeBlockStatement;
async?: boolean;
}
declare class BabelNodeExportDefaultSpecifier extends BabelNode {
type: "ExportDefaultSpecifier";
exported: BabelNodeIdentifier;
}
declare class BabelNodeRecordExpression extends BabelNode {
type: "RecordExpression";
properties: Array<BabelNodeObjectProperty | BabelNodeSpreadElement>;
}
declare class BabelNodeTupleExpression extends BabelNode {
type: "TupleExpression";
elements?: Array<BabelNodeExpression | BabelNodeSpreadElement>;
}
declare class BabelNodeDecimalLiteral extends BabelNode {
type: "DecimalLiteral";
value: string;
}
declare class BabelNodeModuleExpression extends BabelNode {
type: "ModuleExpression";
body: BabelNodeProgram;
}
declare class BabelNodeTopicReference extends BabelNode {
type: "TopicReference";
}
declare class BabelNodePipelineTopicExpression extends BabelNode {
type: "PipelineTopicExpression";
expression: BabelNodeExpression;
}
declare class BabelNodePipelineBareFunction extends BabelNode {
type: "PipelineBareFunction";
callee: BabelNodeExpression;
}
declare class BabelNodePipelinePrimaryTopicReference extends BabelNode {
type: "PipelinePrimaryTopicReference";
}
declare class BabelNodeVoidPattern extends BabelNode {
type: "VoidPattern";
}
declare class BabelNodeTSParameterProperty extends BabelNode {
type: "TSParameterProperty";
parameter: BabelNodeIdentifier | BabelNodeAssignmentPattern;
accessibility?: "public" | "private" | "protected";
decorators?: Array<BabelNodeDecorator>;
override?: boolean;
readonly?: boolean;
}
declare class BabelNodeTSDeclareFunction extends BabelNode {
type: "TSDeclareFunction";
id?: BabelNodeIdentifier;
typeParameters?: BabelNodeTSTypeParameterDeclaration | BabelNodeNoop;
params: Array<BabelNodeFunctionParameter>;
returnType?: BabelNodeTSTypeAnnotation | BabelNodeNoop;
async?: boolean;
declare?: boolean;
generator?: boolean;
}
declare class BabelNodeTSDeclareMethod extends BabelNode {
type: "TSDeclareMethod";
decorators?: Array<BabelNodeDecorator>;
key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | BabelNodeExpression;
typeParameters?: BabelNodeTSTypeParameterDeclaration | BabelNodeNoop;
params: Array<BabelNodeFunctionParameter | BabelNodeTSParameterProperty>;
returnType?: BabelNodeTSTypeAnnotation | BabelNodeNoop;
abstract?: boolean;
access?: "public" | "private" | "protected";
accessibility?: "public" | "private" | "protected";
async?: boolean;
computed?: boolean;
generator?: boolean;
kind?: "get" | "set" | "method" | "constructor";
optional?: boolean;
override?: boolean;
}
declare class BabelNodeTSQualifiedName extends BabelNode {
type: "TSQualifiedName";
left: BabelNodeTSEntityName;
right: BabelNodeIdentifier;
}
declare class BabelNodeTSCallSignatureDeclaration extends BabelNode {
type: "TSCallSignatureDeclaration";
typeParameters?: BabelNodeTSTypeParameterDeclaration;
parameters: Array<BabelNodeArrayPattern | BabelNodeIdentifier | BabelNodeObjectPattern | BabelNodeRestElement>;
typeAnnotation?: BabelNodeTSTypeAnnotation;
}
declare class BabelNodeTSConstructSignatureDeclaration extends BabelNode {
type: "TSConstructSignatureDeclaration";
typeParameters?: BabelNodeTSTypeParameterDeclaration;
parameters: Array<BabelNodeArrayPattern | BabelNodeIdentifier | BabelNodeObjectPattern | BabelNodeRestElement>;
typeAnnotation?: BabelNodeTSTypeAnnotation;
}
declare class BabelNodeTSPropertySignature extends BabelNode {
type: "TSPropertySignature";
key: BabelNodeExpression;
typeAnnotation?: BabelNodeTSTypeAnnotation;
computed?: boolean;
kind?: "get" | "set";
optional?: boolean;
readonly?: boolean;
}
declare class BabelNodeTSMethodSignature extends BabelNode {
type: "TSMethodSignature";
key: BabelNodeExpression;
typeParameters?: BabelNodeTSTypeParameterDeclaration;
parameters: Array<BabelNodeArrayPattern | BabelNodeIdentifier | BabelNodeObjectPattern | BabelNodeRestElement>;
typeAnnotation?: BabelNodeTSTypeAnnotation;
computed?: boolean;
kind: "method" | "get" | "set";
optional?: boolean;
}
declare class BabelNodeTSIndexSignature extends BabelNode {
type: "TSIndexSignature";
parameters: Array<BabelNodeIdentifier>;
typeAnnotation?: BabelNodeTSTypeAnnotation;
readonly?: boolean;
}
declare class BabelNodeTSAnyKeyword extends BabelNode {
type: "TSAnyKeyword";
}
declare class BabelNodeTSBooleanKeyword extends BabelNode {
type: "TSBooleanKeyword";
}
declare class BabelNodeTSBigIntKeyword extends BabelNode {
type: "TSBigIntKeyword";
}
declare class BabelNodeTSIntrinsicKeyword extends BabelNode {
type: "TSIntrinsicKeyword";
}
declare class BabelNodeTSNeverKeyword extends BabelNode {
type: "TSNeverKeyword";
}
declare class BabelNodeTSNullKeyword extends BabelNode {
type: "TSNullKeyword";
}
declare class BabelNodeTSNumberKeyword extends BabelNode {
type: "TSNumberKeyword";
}
declare class BabelNodeTSObjectKeyword extends BabelNode {
type: "TSObjectKeyword";
}
declare class BabelNodeTSStringKeyword extends BabelNode {
type: "TSStringKeyword";
}
declare class BabelNodeTSSymbolKeyword extends BabelNode {
type: "TSSymbolKeyword";
}
declare class BabelNodeTSUndefinedKeyword extends BabelNode {
type: "TSUndefinedKeyword";
}
declare class BabelNodeTSUnknownKeyword extends BabelNode {
type: "TSUnknownKeyword";
}
declare class BabelNodeTSVoidKeyword extends BabelNode {
type: "TSVoidKeyword";
}
declare class BabelNodeTSThisType extends BabelNode {
type: "TSThisType";
}
declare class BabelNodeTSFunctionType extends BabelNode {
type: "TSFunctionType";
typeParameters?: BabelNodeTSTypeParameterDeclaration;
parameters: Array<BabelNodeArrayPattern | BabelNodeIdentifier | BabelNodeObjectPattern | BabelNodeRestElement>;
typeAnnotation?: BabelNodeTSTypeAnnotation;
}
declare class BabelNodeTSConstructorType extends BabelNode {
type: "TSConstructorType";
typeParameters?: BabelNodeTSTypeParameterDeclaration;
parameters: Array<BabelNodeArrayPattern | BabelNodeIdentifier | BabelNodeObjectPattern | BabelNodeRestElement>;
typeAnnotation?: BabelNodeTSTypeAnnotation;
abstract?: boolean;
}
declare class BabelNodeTSTypeReference extends BabelNode {
type: "TSTypeReference";
typeName: BabelNodeTSEntityName;
typeParameters?: BabelNodeTSTypeParameterInstantiation;
}
declare class BabelNodeTSTypePredicate extends BabelNode {
type: "TSTypePredicate";
parameterName: BabelNodeIdentifier | BabelNodeTSThisType;
typeAnnotation?: BabelNodeTSTypeAnnotation;
asserts?: boolean;
}
declare class BabelNodeTSTypeQuery extends BabelNode {
type: "TSTypeQuery";
exprName: BabelNodeTSEntityName | BabelNodeTSImportType;
typeParameters?: BabelNodeTSTypeParameterInstantiation;
}
declare class BabelNodeTSTypeLiteral extends BabelNode {
type: "TSTypeLiteral";
members: Array<BabelNodeTSTypeElement>;
}
declare class BabelNodeTSArrayType extends BabelNode {
type: "TSArrayType";
elementType: BabelNodeTSType;
}
declare class BabelNodeTSTupleType extends BabelNode {
type: "TSTupleType";
elementTypes: Array<BabelNodeTSType | BabelNodeTSNamedTupleMember>;
}
declare class BabelNodeTSOptionalType extends BabelNode {
type: "TSOptionalType";
typeAnnotation: BabelNodeTSType;
}
declare class BabelNodeTSRestType extends BabelNode {
type: "TSRestType";
typeAnnotation: BabelNodeTSType;
}
declare class BabelNodeTSNamedTupleMember extends BabelNode {
type: "TSNamedTupleMember";
label: BabelNodeIdentifier;
elementType: BabelNodeTSType;
optional?: boolean;
}
declare class BabelNodeTSUnionType extends BabelNode {
type: "TSUnionType";
types: Array<BabelNodeTSType>;
}
declare class BabelNodeTSIntersectionType extends BabelNode {
type: "TSIntersectionType";
types: Array<BabelNodeTSType>;
}
declare class BabelNodeTSConditionalType extends BabelNode {
type: "TSConditionalType";
checkType: BabelNodeTSType;
extendsType: BabelNodeTSType;
trueType: BabelNodeTSType;
falseType: BabelNodeTSType;
}
declare class BabelNodeTSInferType extends BabelNode {
type: "TSInferType";
typeParameter: BabelNodeTSTypeParameter;
}
declare class BabelNodeTSParenthesizedType extends BabelNode {
type: "TSParenthesizedType";
typeAnnotation: BabelNodeTSType;
}
declare class BabelNodeTSTypeOperator extends BabelNode {
type: "TSTypeOperator";
typeAnnotation: BabelNodeTSType;
operator?: string;
}
declare class BabelNodeTSIndexedAccessType extends BabelNode {
type: "TSIndexedAccessType";
objectType: BabelNodeTSType;
indexType: BabelNodeTSType;
}
declare class BabelNodeTSMappedType extends BabelNode {
type: "TSMappedType";
typeParameter: BabelNodeTSTypeParameter;
typeAnnotation?: BabelNodeTSType;
nameType?: BabelNodeTSType;
optional?: true | false | "+" | "-";
readonly?: true | false | "+" | "-";
}
declare class BabelNodeTSTemplateLiteralType extends BabelNode {
type: "TSTemplateLiteralType";
quasis: Array<BabelNodeTemplateElement>;
types: Array<BabelNodeTSType>;
}
declare class BabelNodeTSLiteralType extends BabelNode {
type: "TSLiteralType";
literal: BabelNodeNumericLiteral | BabelNodeStringLiteral | BabelNodeBooleanLiteral | BabelNodeBigIntLiteral | BabelNodeTemplateLiteral | BabelNodeUnaryExpression;
}
declare class BabelNodeTSExpressionWithTypeArguments extends BabelNode {
type: "TSExpressionWithTypeArguments";
expression: BabelNodeTSEntityName;
typeParameters?: BabelNodeTSTypeParameterInstantiation;
}
declare class BabelNodeTSInterfaceDeclaration extends BabelNode {
type: "TSInterfaceDeclaration";
id: BabelNodeIdentifier;
typeParameters?: BabelNodeTSTypeParameterDeclaration;
body: BabelNodeTSInterfaceBody;
declare?: boolean;
}
declare class BabelNodeTSInterfaceBody extends BabelNode {
type: "TSInterfaceBody";
body: Array<BabelNodeTSTypeElement>;
}
declare class BabelNodeTSTypeAliasDeclaration extends BabelNode {
type: "TSTypeAliasDeclaration";
id: BabelNodeIdentifier;
typeParameters?: BabelNodeTSTypeParameterDeclaration;
typeAnnotation: BabelNodeTSType;
declare?: boolean;
}
declare class BabelNodeTSInstantiationExpression extends BabelNode {
type: "TSInstantiationExpression";
expression: BabelNodeExpression;
typeParameters?: BabelNodeTSTypeParameterInstantiation;
}
declare class BabelNodeTSAsExpression extends BabelNode {
type: "TSAsExpression";
expression: BabelNodeExpression;
typeAnnotation: BabelNodeTSType;
}
declare class BabelNodeTSSatisfiesExpression extends BabelNode {
type: "TSSatisfiesExpression";
expression: BabelNodeExpression;
typeAnnotation: BabelNodeTSType;
}
declare class BabelNodeTSTypeAssertion extends BabelNode {
type: "TSTypeAssertion";
typeAnnotation: BabelNodeTSType;
expression: BabelNodeExpression;
}
declare class BabelNodeTSEnumBody extends BabelNode {
type: "TSEnumBody";
members: Array<BabelNodeTSEnumMember>;
}
declare class BabelNodeTSEnumDeclaration extends BabelNode {
type: "TSEnumDeclaration";
id: BabelNodeIdentifier;
members: Array<BabelNodeTSEnumMember>;
body?: BabelNodeTSEnumBody;
declare?: boolean;
initializer?: BabelNodeExpression;
}
declare class BabelNodeTSEnumMember extends BabelNode {
type: "TSEnumMember";
id: BabelNodeIdentifier | BabelNodeStringLiteral;
initializer?: BabelNodeExpression;
}
declare class BabelNodeTSModuleDeclaration extends BabelNode {
type: "TSModuleDeclaration";
id: BabelNodeIdentifier | BabelNodeStringLiteral;
body: BabelNodeTSModuleBlock | BabelNodeTSModuleDeclaration;
declare?: boolean;
global?: boolean;
kind: "global" | "module" | "namespace";
}
declare class BabelNodeTSModuleBlock extends BabelNode {
type: "TSModuleBlock";
body: Array<BabelNodeStatement>;
}
declare class BabelNodeTSImportType extends BabelNode {
type: "TSImportType";
argument: BabelNodeStringLiteral;
qualifier?: BabelNodeTSEntityName;
typeParameters?: BabelNodeTSTypeParameterInstantiation;
options?: BabelNodeObjectExpression;
}
declare class BabelNodeTSImportEqualsDeclaration extends BabelNode {
type: "TSImportEqualsDeclaration";
id: BabelNodeIdentifier;
moduleReference: BabelNodeTSEntityName | BabelNodeTSExternalModuleReference;
importKind?: "type" | "value";
isExport: boolean;
}
declare class BabelNodeTSExternalModuleReference extends BabelNode {
type: "TSExternalModuleReference";
expression: BabelNodeStringLiteral;
}
declare class BabelNodeTSNonNullExpression extends BabelNode {
type: "TSNonNullExpression";
expression: BabelNodeExpression;
}
declare class BabelNodeTSExportAssignment extends BabelNode {
type: "TSExportAssignment";
expression: BabelNodeExpression;
}
declare class BabelNodeTSNamespaceExportDeclaration extends BabelNode {
type: "TSNamespaceExportDeclaration";
id: BabelNodeIdentifier;
}
declare class BabelNodeTSTypeAnnotation extends BabelNode {
type: "TSTypeAnnotation";
typeAnnotation: BabelNodeTSType;
}
declare class BabelNodeTSTypeParameterInstantiation extends BabelNode {
type: "TSTypeParameterInstantiation";
params: Array<BabelNodeTSType>;
}
declare class BabelNodeTSTypeParameterDeclaration extends BabelNode {
type: "TSTypeParameterDeclaration";
params: Array<BabelNodeTSTypeParameter>;
}
declare class BabelNodeTSTypeParameter extends BabelNode {
type: "TSTypeParameter";
constraint?: BabelNodeTSType;
name: string;
out?: boolean;
}
type BabelNodeStandardized = BabelNodeArrayExpression | BabelNodeAssignmentExpression | BabelNodeBinaryExpression | BabelNodeInterpreterDirective | BabelNodeDirective | BabelNodeDirectiveLiteral | BabelNodeBlockStatement | BabelNodeBreakStatement | BabelNodeCallExpression | BabelNodeCatchClause | BabelNodeConditionalExpression | BabelNodeContinueStatement | BabelNodeDebuggerStatement | BabelNodeDoWhileStatement | BabelNodeEmptyStatement | BabelNodeExpressionStatement | BabelNodeFile | BabelNodeForInStatement | BabelNodeForStatement | BabelNodeFunctionDeclaration | BabelNodeFunctionExpression | BabelNodeIdentifier | BabelNodeIfStatement | BabelNodeLabeledStatement | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeNullLiteral | BabelNodeBooleanLiteral | BabelNodeRegExpLiteral | BabelNodeLogicalExpression | BabelNodeMemberExpression | BabelNodeNewExpression | BabelNodeProgram | BabelNodeObjectExpression | BabelNodeObjectMethod | BabelNodeObjectProperty | BabelNodeRestElement | BabelNodeReturnStatement | BabelNodeSequenceExpression | BabelNodeParenthesizedExpression | BabelNodeSwitchCase | BabelNodeSwitchStatement | BabelNodeThisExpression | BabelNodeThrowStatement | BabelNodeTryStatement | BabelNodeUnaryExpression | BabelNodeUpdateExpression | BabelNodeVariableDeclaration | BabelNodeVariableDeclarator | BabelNodeWhileStatement | BabelNodeWithStatement | BabelNodeAssignmentPattern | BabelNodeArrayPattern | BabelNodeArrowFunctionExpression | BabelNodeClassBody | BabelNodeClassExpression | BabelNodeClassDeclaration | BabelNodeExportAllDeclaration | BabelNodeExportDefaultDeclaration | BabelNodeExportNamedDeclaration | BabelNodeExportSpecifier | BabelNodeForOfStatement | BabelNodeImportDeclaration | BabelNodeImportDefaultSpecifier | BabelNodeImportNamespaceSpecifier | BabelNodeImportSpecifier | BabelNodeImportExpression | BabelNodeMetaProperty | BabelNodeClassMethod | BabelNodeObjectPattern | BabelNodeSpreadElement | BabelNodeSuper | BabelNodeTaggedTemplateExpression | BabelNodeTemplateElement | BabelNodeTemplateLiteral | BabelNodeYieldExpression | BabelNodeAwaitExpression | BabelNodeImport | BabelNodeBigIntLiteral | BabelNodeExportNamespaceSpecifier | BabelNodeOptionalMemberExpression | BabelNodeOptionalCallExpression | BabelNodeClassProperty | BabelNodeClassAccessorProperty | BabelNodeClassPrivateProperty | BabelNodeClassPrivateMethod | BabelNodePrivateName | BabelNodeStaticBlock | BabelNodeImportAttribute;
type BabelNodeExpression = BabelNodeArrayExpression | BabelNodeAssignmentExpression | BabelNodeBinaryExpression | BabelNodeCallExpression | BabelNodeConditionalExpression | BabelNodeFunctionExpression | BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeNullLiteral | BabelNodeBooleanLiteral | BabelNodeRegExpLiteral | BabelNodeLogicalExpression | BabelNodeMemberExpression | BabelNodeNewExpression | BabelNodeObjectExpression | BabelNodeSequenceExpression | BabelNodeParenthesizedExpression | BabelNodeThisExpression | BabelNodeUnaryExpression | BabelNodeUpdateExpression | BabelNodeArrowFunctionExpression | BabelNodeClassExpression | BabelNodeImportExpression | BabelNodeMetaProperty | BabelNodeSuper | BabelNodeTaggedTemplateExpression | BabelNodeTemplateLiteral | BabelNodeYieldExpression | BabelNodeAwaitExpression | BabelNodeImport | BabelNodeBigIntLiteral | BabelNodeOptionalMemberExpression | BabelNodeOptionalCallExpression | BabelNodeTypeCastExpression | BabelNodeJSXElement | BabelNodeJSXFragment | BabelNodeBindExpression | BabelNodeDoExpression | BabelNodeRecordExpression | BabelNodeTupleExpression | BabelNodeDecimalLiteral | BabelNodeModuleExpression | BabelNodeTopicReference | BabelNodePipelineTopicExpression | BabelNodePipelineBareFunction | BabelNodePipelinePrimaryTopicReference | BabelNodeTSInstantiationExpression | BabelNodeTSAsExpression | BabelNodeTSSatisfiesExpression | BabelNodeTSTypeAssertion | BabelNodeTSNonNullExpression;
type BabelNodeBinary = BabelNodeBinaryExpression | BabelNodeLogicalExpression;
type BabelNodeScopable = BabelNodeBlockStatement | BabelNodeCatchClause | BabelNodeDoWhileStatement | BabelNodeForInStatement | BabelNodeForStatement | BabelNodeFunctionDeclaration | BabelNodeFunctionExpression | BabelNodeProgram | BabelNodeObjectMethod | BabelNodeSwitchStatement | BabelNodeWhileStatement | BabelNodeArrowFunctionExpression | BabelNodeClassExpression | BabelNodeClassDeclaration | BabelNodeForOfStatement | BabelNodeClassMethod | BabelNodeClassPrivateMethod | BabelNodeStaticBlock | BabelNodeTSModuleBlock;
type BabelNodeBlockParent = BabelNodeBlockStatement | BabelNodeCatchClause | BabelNodeDoWhileStatement | BabelNodeForInStatement | BabelNodeForStatement | BabelNodeFunctionDeclaration | BabelNodeFunctionExpression | BabelNodeProgram | BabelNodeObjectMethod | BabelNodeSwitchStatement | BabelNodeWhileStatement | BabelNodeArrowFunctionExpression | BabelNodeForOfStatement | BabelNodeClassMethod | BabelNodeClassPrivateMethod | BabelNodeStaticBlock | BabelNodeTSModuleBlock;
type BabelNodeBlock = BabelNodeBlockStatement | BabelNodeProgram | BabelNodeTSModuleBlock;
type BabelNodeStatement = BabelNodeBlockStatement | BabelNodeBreakStatement | BabelNodeContinueStatement | BabelNodeDebuggerStatement | BabelNodeDoWhileStatement | BabelNodeEmptyStatement | BabelNodeExpressionStatement | BabelNodeForInStatement | BabelNodeForStatement | BabelNodeFunctionDeclaration | BabelNodeIfStatement | BabelNodeLabeledStatement | BabelNodeReturnStatement | BabelNodeSwitchStatement | BabelNodeThrowStatement | BabelNodeTryStatement | BabelNodeVariableDeclaration | BabelNodeWhileStatement | BabelNodeWithStatement | BabelNodeClassDeclaration | BabelNodeExportAllDeclaration | BabelNodeExportDefaultDeclaration | BabelNodeExportNamedDeclaration | BabelNodeForOfStatement | BabelNodeImportDeclaration | BabelNodeDeclareClass | BabelNodeDeclareFunction | BabelNodeDeclareInterface | BabelNodeDeclareModule | BabelNodeDeclareModuleExports | BabelNodeDeclareTypeAlias | BabelNodeDeclareOpaqueType | BabelNodeDeclareVariable | BabelNodeDeclareExportDeclaration | BabelNodeDeclareExportAllDeclaration | BabelNodeInterfaceDeclaration | BabelNodeOpaqueType | BabelNodeTypeAlias | BabelNodeEnumDeclaration | BabelNodeTSDeclareFunction | BabelNodeTSInterfaceDeclaration | BabelNodeTSTypeAliasDeclaration | BabelNodeTSEnumDeclaration | BabelNodeTSModuleDeclaration | BabelNodeTSImportEqualsDeclaration | BabelNodeTSExportAssignment | BabelNodeTSNamespaceExportDeclaration;
type BabelNodeTerminatorless = BabelNodeBreakStatement | BabelNodeContinueStatement | BabelNodeReturnStatement | BabelNodeThrowStatement | BabelNodeYieldExpression | BabelNodeAwaitExpression;
type BabelNodeCompletionStatement = BabelNodeBreakStatement | BabelNodeContinueStatement | BabelNodeReturnStatement | BabelNodeThrowStatement;
type BabelNodeConditional = BabelNodeConditionalExpression | BabelNodeIfStatement;
type BabelNodeLoop = BabelNodeDoWhileStatement | BabelNodeForInStatement | BabelNodeForStatement | BabelNodeWhileStatement | BabelNodeForOfStatement;
type BabelNodeWhile = BabelNodeDoWhileStatement | BabelNodeWhileStatement;
type BabelNodeExpressionWrapper = BabelNodeExpressionStatement | BabelNodeParenthesizedExpression | BabelNodeTypeCastExpression;
type BabelNodeFor = BabelNodeForInStatement | BabelNodeForStatement | BabelNodeForOfStatement;
type BabelNodeForXStatement = BabelNodeForInStatement | BabelNodeForOfStatement;
type BabelNodeFunction = BabelNodeFunctionDeclaration | BabelNodeFunctionExpression | BabelNodeObjectMethod | BabelNodeArrowFunctionExpression | BabelNodeClassMethod | BabelNodeClassPrivateMethod;
type BabelNodeFunctionParent = BabelNodeFunctionDeclaration | BabelNodeFunctionExpression | BabelNodeObjectMethod | BabelNodeArrowFunctionExpression | BabelNodeClassMethod | BabelNodeClassPrivateMethod | BabelNodeStaticBlock | BabelNodeTSModuleBlock;
type BabelNodePureish = BabelNodeFunctionDeclaration | BabelNodeFunctionExpression | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeNullLiteral | BabelNodeBooleanLiteral | BabelNodeRegExpLiteral | BabelNodeArrowFunctionExpression | BabelNodeBigIntLiteral | BabelNodeDecimalLiteral;
type BabelNodeDeclaration = BabelNodeFunctionDeclaration | BabelNodeVariableDeclaration | BabelNodeClassDeclaration | BabelNodeExportAllDeclaration | BabelNodeExportDefaultDeclaration | BabelNodeExportNamedDeclaration | BabelNodeImportDeclaration | BabelNodeDeclareClass | BabelNodeDeclareFunction | BabelNodeDeclareInterface | BabelNodeDeclareModule | BabelNodeDeclareModuleExports | BabelNodeDeclareTypeAlias | BabelNodeDeclareOpaqueType | BabelNodeDeclareVariable | BabelNodeDeclareExportDeclaration | BabelNodeDeclareExportAllDeclaration | BabelNodeInterfaceDeclaration | BabelNodeOpaqueType | BabelNodeTypeAlias | BabelNodeEnumDeclaration | BabelNodeTSDeclareFunction | BabelNodeTSInterfaceDeclaration | BabelNodeTSTypeAliasDeclaration | BabelNodeTSEnumDeclaration | BabelNodeTSModuleDeclaration | BabelNodeTSImportEqualsDeclaration;
type BabelNodeFunctionParameter = BabelNodeIdentifier | BabelNodeRestElement | BabelNodeAssignmentPattern | BabelNodeArrayPattern | BabelNodeObjectPattern | BabelNodeVoidPattern;
type BabelNodePatternLike = BabelNodeIdentifier | BabelNodeMemberExpression | BabelNodeRestElement | BabelNodeAssignmentPattern | BabelNodeArrayPattern | BabelNodeObjectPattern | BabelNodeVoidPattern | BabelNodeTSAsExpression | BabelNodeTSSatisfiesExpression | BabelNodeTSTypeAssertion | BabelNodeTSNonNullExpression;
type BabelNodeLVal = BabelNodeIdentifier | BabelNodeMemberExpression | BabelNodeRestElement | BabelNodeAssignmentPattern | BabelNodeArrayPattern | BabelNodeObjectPattern | BabelNodeTSParameterProperty | BabelNodeTSAsExpression | BabelNodeTSSatisfiesExpression | BabelNodeTSTypeAssertion | BabelNodeTSNonNullExpression;
type BabelNodeTSEntityName = BabelNodeIdentifier | BabelNodeTSQualifiedName;
type BabelNodeLiteral = BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeNullLiteral | BabelNodeBooleanLiteral | BabelNodeRegExpLiteral | BabelNodeTemplateLiteral | BabelNodeBigIntLiteral | BabelNodeDecimalLiteral;
type BabelNodeImmutable = BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeNullLiteral | BabelNodeBooleanLiteral | BabelNodeBigIntLiteral | BabelNodeJSXAttribute | BabelNodeJSXClosingElement | BabelNodeJSXElement | BabelNodeJSXExpressionContainer | BabelNodeJSXSpreadChild | BabelNodeJSXOpeningElement | BabelNodeJSXText | BabelNodeJSXFragment | BabelNodeJSXOpeningFragment | BabelNodeJSXClosingFragment | BabelNodeDecimalLiteral;
type BabelNodeUserWhitespacable = BabelNodeObjectMethod | BabelNodeObjectProperty | BabelNodeObjectTypeInternalSlot | BabelNodeObjectTypeCallProperty | BabelNodeObjectTypeIndexer | BabelNodeObjectTypeProperty | BabelNodeObjectTypeSpreadProperty;
type BabelNodeMethod = BabelNodeObjectMethod | BabelNodeClassMethod | BabelNodeClassPrivateMethod;
type BabelNodeObjectMember = BabelNodeObjectMethod | BabelNodeObjectProperty;
type BabelNodeProperty = BabelNodeObjectProperty | BabelNodeClassProperty | BabelNodeClassAccessorProperty | BabelNodeClassPrivateProperty;
type BabelNodeUnaryLike = BabelNodeUnaryExpression | BabelNodeSpreadElement;
type BabelNodePattern = BabelNodeAssignmentPattern | BabelNodeArrayPattern | BabelNodeObjectPattern | BabelNodeVoidPattern;
type BabelNodeClass = BabelNodeClassExpression | BabelNodeClassDeclaration;
type BabelNodeImportOrExportDeclaration = BabelNodeExportAllDeclaration | BabelNodeExportDefaultDeclaration | BabelNodeExportNamedDeclaration | BabelNodeImportDeclaration;
type BabelNodeExportDeclaration = BabelNodeExportAllDeclaration | BabelNodeExportDefaultDeclaration | BabelNodeExportNamedDeclaration;
type BabelNodeModuleSpecifier = BabelNodeExportSpecifier | BabelNodeImportDefaultSpecifier | BabelNodeImportNamespaceSpecifier | BabelNodeImportSpecifier | BabelNodeExportNamespaceSpecifier | BabelNodeExportDefaultSpecifier;
type BabelNodeAccessor = BabelNodeClassAccessorProperty;
type BabelNodePrivate = BabelNodeClassPrivateProperty | BabelNodeClassPrivateMethod | BabelNodePrivateName;
type BabelNodeFlow = BabelNodeAnyTypeAnnotation | BabelNodeArrayTypeAnnotation | BabelNodeBooleanTypeAnnotation | BabelNodeBooleanLiteralTypeAnnotation | BabelNodeNullLiteralTypeAnnotation | BabelNodeClassImplements | BabelNodeDeclareClass | BabelNodeDeclareFunction | BabelNodeDeclareInterface | BabelNodeDeclareModule | BabelNodeDeclareModuleExports | BabelNodeDeclareTypeAlias | BabelNodeDeclareOpaqueType | BabelNodeDeclareVariable | BabelNodeDeclareExportDeclaration | BabelNodeDeclareExportAllDeclaration | BabelNodeDeclaredPredicate | BabelNodeExistsTypeAnnotation | BabelNodeFunctionTypeAnnotation | BabelNodeFunctionTypeParam | BabelNodeGenericTypeAnnotation | BabelNodeInferredPredicate | BabelNodeInterfaceExtends | BabelNodeInterfaceDeclaration | BabelNodeInterfaceTypeAnnotation | BabelNodeIntersectionTypeAnnotation | BabelNodeMixedTypeAnnotation | BabelNodeEmptyTypeAnnotation | BabelNodeNullableTypeAnnotation | BabelNodeNumberLiteralTypeAnnotation | BabelNodeNumberTypeAnnotation | BabelNodeObjectTypeAnnotation | BabelNodeObjectTypeInternalSlot | BabelNodeObjectTypeCallProperty | BabelNodeObjectTypeIndexer | BabelNodeObjectTypeProperty | BabelNodeObjectTypeSpreadProperty | BabelNodeOpaqueType | BabelNodeQualifiedTypeIdentifier | BabelNodeStringLiteralTypeAnnotation | BabelNodeStringTypeAnnotation | BabelNodeSymbolTypeAnnotation | BabelNodeThisTypeAnnotation | BabelNodeTupleTypeAnnotation | BabelNodeTypeofTypeAnnotation | BabelNodeTypeAlias | BabelNodeTypeAnnotation | BabelNodeTypeCastExpression | BabelNodeTypeParameter | BabelNodeTypeParameterDeclaration | BabelNodeTypeParameterInstantiation | BabelNodeUnionTypeAnnotation | BabelNodeVariance | BabelNodeVoidTypeAnnotation | BabelNodeEnumDeclaration | BabelNodeEnumBooleanBody | BabelNodeEnumNumberBody | BabelNodeEnumStringBody | BabelNodeEnumSymbolBody | BabelNodeEnumBooleanMember | BabelNodeEnumNumberMember | BabelNodeEnumStringMember | BabelNodeEnumDefaultedMember | BabelNodeIndexedAccessType | BabelNodeOptionalIndexedAccessType;
type BabelNodeFlowType = BabelNodeAnyTypeAnnotation | BabelNodeArrayTypeAnnotation | BabelNodeBooleanTypeAnnotation | BabelNodeBooleanLiteralTypeAnnotation | BabelNodeNullLiteralTypeAnnotation | BabelNodeExistsTypeAnnotation | BabelNodeFunctionTypeAnnotation | BabelNodeGenericTypeAnnotation | BabelNodeInterfaceTypeAnnotation | BabelNodeIntersectionTypeAnnotation | BabelNodeMixedTypeAnnotation | BabelNodeEmptyTypeAnnotation | BabelNodeNullableTypeAnnotation | BabelNodeNumberLiteralTypeAnnotation | BabelNodeNumberTypeAnnotation | BabelNodeObjectTypeAnnotation | BabelNodeStringLiteralTypeAnnotation | BabelNodeStringTypeAnnotation | BabelNodeSymbolTypeAnnotation | BabelNodeThisTypeAnnotation | BabelNodeTupleTypeAnnotation | BabelNodeTypeofTypeAnnotation | BabelNodeUnionTypeAnnotation | BabelNodeVoidTypeAnnotation | BabelNodeIndexedAccessType | BabelNodeOptionalIndexedAccessType;
type BabelNodeFlowBaseAnnotation = BabelNodeAnyTypeAnnotation | BabelNodeBooleanTypeAnnotation | BabelNodeNullLiteralTypeAnnotation | BabelNodeMixedTypeAnnotation | BabelNodeEmptyTypeAnnotation | BabelNodeNumberTypeAnnotation | BabelNodeStringTypeAnnotation | BabelNodeSymbolTypeAnnotation | BabelNodeThisTypeAnnotation | BabelNodeVoidTypeAnnotation;
type BabelNodeFlowDeclaration = BabelNodeDeclareClass | BabelNodeDeclareFunction | BabelNodeDeclareInterface | BabelNodeDeclareModule | BabelNodeDeclareModuleExports | BabelNodeDeclareTypeAlias | BabelNodeDeclareOpaqueType | BabelNodeDeclareVariable | BabelNodeDeclareExportDeclaration | BabelNodeDeclareExportAllDeclaration | BabelNodeInterfaceDeclaration | BabelNodeOpaqueType | BabelNodeTypeAlias;
type BabelNodeFlowPredicate = BabelNodeDeclaredPredicate | BabelNodeInferredPredicate;
type BabelNodeEnumBody = BabelNodeEnumBooleanBody | BabelNodeEnumNumberBody | BabelNodeEnumStringBody | BabelNodeEnumSymbolBody;
type BabelNodeEnumMember = BabelNodeEnumBooleanMember | BabelNodeEnumNumberMember | BabelNodeEnumStringMember | BabelNodeEnumDefaultedMember;
type BabelNodeJSX = BabelNodeJSXAttribute | BabelNodeJSXClosingElement | BabelNodeJSXElement | BabelNodeJSXEmptyExpression | BabelNodeJSXExpressionContainer | BabelNodeJSXSpreadChild | BabelNodeJSXIdentifier | BabelNodeJSXMemberExpression | BabelNodeJSXNamespacedName | BabelNodeJSXOpeningElement | BabelNodeJSXSpreadAttribute | BabelNodeJSXText | BabelNodeJSXFragment | BabelNodeJSXOpeningFragment | BabelNodeJSXClosingFragment;
type BabelNodeMiscellaneous = BabelNodeNoop | BabelNodePlaceholder | BabelNodeV8IntrinsicIdentifier;
type BabelNodeTypeScript = BabelNodeTSParameterProperty | BabelNodeTSDeclareFunction | BabelNodeTSDeclareMethod | BabelNodeTSQualifiedName | BabelNodeTSCallSignatureDeclaration | BabelNodeTSConstructSignatureDeclaration | BabelNodeTSPropertySignature | BabelNodeTSMethodSignature | BabelNodeTSIndexSignature | BabelNodeTSAnyKeyword | BabelNodeTSBooleanKeyword | BabelNodeTSBigIntKeyword | BabelNodeTSIntrinsicKeyword | BabelNodeTSNeverKeyword | BabelNodeTSNullKeyword | BabelNodeTSNumberKeyword | BabelNodeTSObjectKeyword | BabelNodeTSStringKeyword | BabelNodeTSSymbolKeyword | BabelNodeTSUndefinedKeyword | BabelNodeTSUnknownKeyword | BabelNodeTSVoidKeyword | BabelNodeTSThisType | BabelNodeTSFunctionType | BabelNodeTSConstructorType | BabelNodeTSTypeReference | BabelNodeTSTypePredicate | BabelNodeTSTypeQuery | BabelNodeTSTypeLiteral | BabelNodeTSArrayType | BabelNodeTSTupleType | BabelNodeTSOptionalType | BabelNodeTSRestType | BabelNodeTSNamedTupleMember | BabelNodeTSUnionType | BabelNodeTSIntersectionType | BabelNodeTSConditionalType | BabelNodeTSInferType | BabelNodeTSParenthesizedType | BabelNodeTSTypeOperator | BabelNodeTSIndexedAccessType | BabelNodeTSMappedType | BabelNodeTSTemplateLiteralType | BabelNodeTSLiteralType | BabelNodeTSExpressionWithTypeArguments | BabelNodeTSInterfaceDeclaration | BabelNodeTSInterfaceBody | BabelNodeTSTypeAliasDeclaration | BabelNodeTSInstantiationExpression | BabelNodeTSAsExpression | BabelNodeTSSatisfiesExpression | BabelNodeTSTypeAssertion | BabelNodeTSEnumBody | BabelNodeTSEnumDeclaration | BabelNodeTSEnumMember | BabelNodeTSModuleDeclaration | BabelNodeTSModuleBlock | BabelNodeTSImportType | BabelNodeTSImportEqualsDeclaration | BabelNodeTSExternalModuleReference | BabelNodeTSNonNullExpression | BabelNodeTSExportAssignment | BabelNodeTSNamespaceExportDeclaration | BabelNodeTSTypeAnnotation | BabelNodeTSTypeParameterInstantiation | BabelNodeTSTypeParameterDeclaration | BabelNodeTSTypeParameter;
type BabelNodeTSTypeElement = BabelNodeTSCallSignatureDeclaration | BabelNodeTSConstructSignatureDeclaration | BabelNodeTSPropertySignature | BabelNodeTSMethodSignature | BabelNodeTSIndexSignature;
type BabelNodeTSType = BabelNodeTSAnyKeyword | BabelNodeTSBooleanKeyword | BabelNodeTSBigIntKeyword | BabelNodeTSIntrinsicKeyword | BabelNodeTSNeverKeyword | BabelNodeTSNullKeyword | BabelNodeTSNumberKeyword | BabelNodeTSObjectKeyword | BabelNodeTSStringKeyword | BabelNodeTSSymbolKeyword | BabelNodeTSUndefinedKeyword | BabelNodeTSUnknownKeyword | BabelNodeTSVoidKeyword | BabelNodeTSThisType | BabelNodeTSFunctionType | BabelNodeTSConstructorType | BabelNodeTSTypeReference | BabelNodeTSTypePredicate | BabelNodeTSTypeQuery | BabelNodeTSTypeLiteral | BabelNodeTSArrayType | BabelNodeTSTupleType | BabelNodeTSOptionalType | BabelNodeTSRestType | BabelNodeTSUnionType | BabelNodeTSIntersectionType | BabelNodeTSConditionalType | BabelNodeTSInferType | BabelNodeTSParenthesizedType | BabelNodeTSTypeOperator | BabelNodeTSIndexedAccessType | BabelNodeTSMappedType | BabelNodeTSTemplateLiteralType | BabelNodeTSLiteralType | BabelNodeTSExpressionWithTypeArguments | BabelNodeTSImportType;
type BabelNodeTSBaseType = BabelNodeTSAnyKeyword | BabelNodeTSBooleanKeyword | BabelNodeTSBigIntKeyword | BabelNodeTSIntrinsicKeyword | BabelNodeTSNeverKeyword | BabelNodeTSNullKeyword | BabelNodeTSNumberKeyword | BabelNodeTSObjectKeyword | BabelNodeTSStringKeyword | BabelNodeTSSymbolKeyword | BabelNodeTSUndefinedKeyword | BabelNodeTSUnknownKeyword | BabelNodeTSVoidKeyword | BabelNodeTSThisType | BabelNodeTSTemplateLiteralType | BabelNodeTSLiteralType;
type BabelNodeModuleDeclaration = BabelNodeExportAllDeclaration | BabelNodeExportDefaultDeclaration | BabelNodeExportNamedDeclaration | BabelNodeImportDeclaration;
declare module "@babel/types" {
declare export function arrayExpression(elements?: Array<null | BabelNodeExpression | BabelNodeSpreadElement>): BabelNodeArrayExpression;
declare export function assignmentExpression(operator: string, left: BabelNodeLVal | BabelNodeOptionalMemberExpression, right: BabelNodeExpression): BabelNodeAssignmentExpression;
declare export function binaryExpression(operator: "+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "in" | "instanceof" | ">" | "<" | ">=" | "<=" | "|>", left: BabelNodeExpression | BabelNodePrivateName, right: BabelNodeExpression): BabelNodeBinaryExpression;
declare export function interpreterDirective(value: string): BabelNodeInterpreterDirective;
declare export function directive(value: BabelNodeDirectiveLiteral): BabelNodeDirective;
declare export function directiveLiteral(value: string): BabelNodeDirectiveLiteral;
declare export function blockStatement(body: Array<BabelNodeStatement>, directives?: Array<BabelNodeDirective>): BabelNodeBlockStatement;
declare export function breakStatement(label?: BabelNodeIdentifier): BabelNodeBreakStatement;
declare export function callExpression(callee: BabelNodeExpression | BabelNodeSuper | BabelNodeV8IntrinsicIdentifier, _arguments: Array<BabelNodeExpression | BabelNodeSpreadElement | BabelNodeArgumentPlaceholder>): BabelNodeCallExpression;
declare export function catchClause(param?: BabelNodeIdentifier | BabelNodeArrayPattern | BabelNodeObjectPattern, body: BabelNodeBlockStatement): BabelNodeCatchClause;
declare export function conditionalExpression(test: BabelNodeExpression, consequent: BabelNodeExpression, alternate: BabelNodeExpression): BabelNodeConditionalExpression;
declare export function continueStatement(label?: BabelNodeIdentifier): BabelNodeContinueStatement;
declare export function debuggerStatement(): BabelNodeDebuggerStatement;
declare export function doWhileStatement(test: BabelNodeExpression, body: BabelNodeStatement): BabelNodeDoWhileStatement;
declare export function emptyStatement(): BabelNodeEmptyStatement;
declare export function expressionStatement(expression: BabelNodeExpression): BabelNodeExpressionStatement;
declare export function file(program: BabelNodeProgram, comments?: Array<BabelNodeCommentBlock | BabelNodeCommentLine>, tokens?: Array<any>): BabelNodeFile;
declare export function forInStatement(left: BabelNodeVariableDeclaration | BabelNodeLVal, right: BabelNodeExpression, body: BabelNodeStatement): BabelNodeForInStatement;
declare export function forStatement(init?: BabelNodeVariableDeclaration | BabelNodeExpression, test?: BabelNodeExpression, update?: BabelNodeExpression, body: BabelNodeStatement): BabelNodeForStatement;
declare export function functionDeclaration(id?: BabelNodeIdentifier, params: Array<BabelNodeFunctionParameter>, body: BabelNodeBlockStatement, generator?: boolean, async?: boolean): BabelNodeFunctionDeclaration;
declare export function functionExpression(id?: BabelNodeIdentifier, params: Array<BabelNodeFunctionParameter>, body: BabelNodeBlockStatement, generator?: boolean, async?: boolean): BabelNodeFunctionExpression;
declare export function identifier(name: string): BabelNodeIdentifier;
declare export function ifStatement(test: BabelNodeExpression, consequent: BabelNodeStatement, alternate?: BabelNodeStatement): BabelNodeIfStatement;
declare export function labeledStatement(label: BabelNodeIdentifier, body: BabelNodeStatement): BabelNodeLabeledStatement;
declare export function stringLiteral(value: string): BabelNodeStringLiteral;
declare export function numericLiteral(value: number): BabelNodeNumericLiteral;
declare export function nullLiteral(): BabelNodeNullLiteral;
declare export function booleanLiteral(value: boolean): BabelNodeBooleanLiteral;
declare export function regExpLiteral(pattern: string, flags?: string): BabelNodeRegExpLiteral;
declare export function logicalExpression(operator: "||" | "&&" | "??", left: BabelNodeExpression, right: BabelNodeExpression): BabelNodeLogicalExpression;
declare export function memberExpression(object: BabelNodeExpression | BabelNodeSuper, property: BabelNodeExpression | BabelNodeIdentifier | BabelNodePrivateName, computed?: boolean, optional?: boolean): BabelNodeMemberExpression;
declare export function newExpression(callee: BabelNodeExpression | BabelNodeSuper | BabelNodeV8IntrinsicIdentifier, _arguments: Array<BabelNodeExpression | BabelNodeSpreadElement | BabelNodeArgumentPlaceholder>): BabelNodeNewExpression;
declare export function program(body: Array<BabelNodeStatement>, directives?: Array<BabelNodeDirective>, sourceType?: "script" | "module", interpreter?: BabelNodeInterpreterDirective): BabelNodeProgram;
declare export function objectExpression(properties: Array<BabelNodeObjectMethod | BabelNodeObjectProperty | BabelNodeSpreadElement>): BabelNodeObjectExpression;
declare export function objectMethod(kind?: "method" | "get" | "set", key: BabelNodeExpression | BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral, params: Array<BabelNodeFunctionParameter>, body: BabelNodeBlockStatement, computed?: boolean, generator?: boolean, async?: boolean): BabelNodeObjectMethod;
declare export function objectProperty(key: BabelNodeExpression | BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | BabelNodeDecimalLiteral | BabelNodePrivateName, value: BabelNodeExpression | BabelNodePatternLike, computed?: boolean, shorthand?: boolean, decorators?: Array<BabelNodeDecorator>): BabelNodeObjectProperty;
declare export function restElement(argument: BabelNodeIdentifier | BabelNodeArrayPattern | BabelNodeObjectPattern | BabelNodeMemberExpression | BabelNodeTSAsExpression | BabelNodeTSSatisfiesExpression | BabelNodeTSTypeAssertion | BabelNodeTSNonNullExpression | BabelNodeRestElement | BabelNodeAssignmentPattern): BabelNodeRestElement;
declare export function returnStatement(argument?: BabelNodeExpression): BabelNodeReturnStatement;
declare export function sequenceExpression(expressions: Array<BabelNodeExpression>): BabelNodeSequenceExpression;
declare export function parenthesizedExpression(expression: BabelNodeExpression): BabelNodeParenthesizedExpression;
declare export function switchCase(test?: BabelNodeExpression, consequent: Array<BabelNodeStatement>): BabelNodeSwitchCase;
declare export function switchStatement(discriminant: BabelNodeExpression, cases: Array<BabelNodeSwitchCase>): BabelNodeSwitchStatement;
declare export function thisExpression(): BabelNodeThisExpression;
declare export function throwStatement(argument: BabelNodeExpression): BabelNodeThrowStatement;
declare export function tryStatement(block: BabelNodeBlockStatement, handler?: BabelNodeCatchClause, finalizer?: BabelNodeBlockStatement): BabelNodeTryStatement;
declare export function unaryExpression(operator: "void" | "throw" | "delete" | "!" | "+" | "-" | "~" | "typeof", argument: BabelNodeExpression, prefix?: boolean): BabelNodeUnaryExpression;
declare export function updateExpression(operator: "++" | "--", argument: BabelNodeExpression, prefix?: boolean): BabelNodeUpdateExpression;
declare export function variableDeclaration(kind: "var" | "let" | "const" | "using" | "await using", declarations: Array<BabelNodeVariableDeclarator>): BabelNodeVariableDeclaration;
declare export function variableDeclarator(id: BabelNodeLVal | BabelNodeVoidPattern, init?: BabelNodeExpression): BabelNodeVariableDeclarator;
declare export function whileStatement(test: BabelNodeExpression, body: BabelNodeStatement): BabelNodeWhileStatement;
declare export function withStatement(object: BabelNodeExpression, body: BabelNodeStatement): BabelNodeWithStatement;
declare export function assignmentPattern(left: BabelNodeIdentifier | BabelNodeObjectPattern | BabelNodeArrayPattern | BabelNodeMemberExpression | BabelNodeTSAsExpression | BabelNodeTSSatisfiesExpression | BabelNodeTSTypeAssertion | BabelNodeTSNonNullExpression, right: BabelNodeExpression): BabelNodeAssignmentPattern;
declare export function arrayPattern(elements: Array<null | BabelNodePatternLike>): BabelNodeArrayPattern;
declare export function arrowFunctionExpression(params: Array<BabelNodeFunctionParameter>, body: BabelNodeBlockStatement | BabelNodeExpression, async?: boolean): BabelNodeArrowFunctionExpression;
declare export function classBody(body: Array<BabelNodeClassMethod | BabelNodeClassPrivateMethod | BabelNodeClassProperty | BabelNodeClassPrivateProperty | BabelNodeClassAccessorProperty | BabelNodeTSDeclareMethod | BabelNodeTSIndexSignature | BabelNodeStaticBlock>): BabelNodeClassBody;
declare export function classExpression(id?: BabelNodeIdentifier, superClass?: BabelNodeExpression, body: BabelNodeClassBody, decorators?: Array<BabelNodeDecorator>): BabelNodeClassExpression;
declare export function classDeclaration(id?: BabelNodeIdentifier, superClass?: BabelNodeExpression, body: BabelNodeClassBody, decorators?: Array<BabelNodeDecorator>): BabelNodeClassDeclaration;
declare export function exportAllDeclaration(source: BabelNodeStringLiteral): BabelNodeExportAllDeclaration;
declare export function exportDefaultDeclaration(declaration: BabelNodeTSDeclareFunction | BabelNodeFunctionDeclaration | BabelNodeClassDeclaration | BabelNodeExpression): BabelNodeExportDefaultDeclaration;
declare export function exportNamedDeclaration(declaration?: BabelNodeDeclaration, specifiers?: Array<BabelNodeExportSpecifier | BabelNodeExportDefaultSpecifier | BabelNodeExportNamespaceSpecifier>, source?: BabelNodeStringLiteral): BabelNodeExportNamedDeclaration;
declare export function exportSpecifier(local: BabelNodeIdentifier, exported: BabelNodeIdentifier | BabelNodeStringLiteral): BabelNodeExportSpecifier;
declare export function forOfStatement(left: BabelNodeVariableDeclaration | BabelNodeLVal, right: BabelNodeExpression, body: BabelNodeStatement, _await?: boolean): BabelNodeForOfStatement;
declare export function importDeclaration(specifiers: Array<BabelNodeImportSpecifier | BabelNodeImportDefaultSpecifier | BabelNodeImportNamespaceSpecifier>, source: BabelNodeStringLiteral): BabelNodeImportDeclaration;
declare export function importDefaultSpecifier(local: BabelNodeIdentifier): BabelNodeImportDefaultSpecifier;
declare export function importNamespaceSpecifier(local: BabelNodeIdentifier): BabelNodeImportNamespaceSpecifier;
declare export function importSpecifier(local: BabelNodeIdentifier, imported: BabelNodeIdentifier | BabelNodeStringLiteral): BabelNodeImportSpecifier;
declare export function importExpression(source: BabelNodeExpression, options?: BabelNodeExpression): BabelNodeImportExpression;
declare export function metaProperty(meta: BabelNodeIdentifier, property: BabelNodeIdentifier): BabelNodeMetaProperty;
declare export function classMethod(kind?: "get" | "set" | "method" | "constructor", key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | BabelNodeExpression, params: Array<BabelNodeFunctionParameter | BabelNodeTSParameterProperty>, body: BabelNodeBlockStatement, computed?: boolean, _static?: boolean, generator?: boolean, async?: boolean): BabelNodeClassMethod;
declare export function objectPattern(properties: Array<BabelNodeRestElement | BabelNodeObjectProperty>): BabelNodeObjectPattern;
declare export function spreadElement(argument: BabelNodeExpression): BabelNodeSpreadElement;
declare function _super(): BabelNodeSuper;
declare export { _super as super }
declare export function taggedTemplateExpression(tag: BabelNodeExpression, quasi: BabelNodeTemplateLiteral): BabelNodeTaggedTemplateExpression;
declare export function templateElement(value: { raw: string, cooked?: string }, tail?: boolean): BabelNodeTemplateElement;
declare export function templateLiteral(quasis: Array<BabelNodeTemplateElement>, expressions: Array<BabelNodeExpression | BabelNodeTSType>): BabelNodeTemplateLiteral;
declare export function yieldExpression(argument?: BabelNodeExpression, delegate?: boolean): BabelNodeYieldExpression;
declare export function awaitExpression(argument: BabelNodeExpression): BabelNodeAwaitExpression;
declare function _import(): BabelNodeImport;
declare export { _import as import }
declare export function bigIntLiteral(value: string): BabelNodeBigIntLiteral;
declare export function exportNamespaceSpecifier(exported: BabelNodeIdentifier): BabelNodeExportNamespaceSpecifier;
declare export function optionalMemberExpression(object: BabelNodeExpression, property: BabelNodeExpression | BabelNodeIdentifier, computed?: boolean, optional: boolean): BabelNodeOptionalMemberExpression;
declare export function optionalCallExpression(callee: BabelNodeExpression, _arguments: Array<BabelNodeExpression | BabelNodeSpreadElement | BabelNodeArgumentPlaceholder>, optional: boolean): BabelNodeOptionalCallExpression;
declare export function classProperty(key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | BabelNodeExpression, value?: BabelNodeExpression, typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop, decorators?: Array<BabelNodeDecorator>, computed?: boolean, _static?: boolean): BabelNodeClassProperty;
declare export function classAccessorProperty(key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | BabelNodeExpression | BabelNodePrivateName, value?: BabelNodeExpression, typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop, decorators?: Array<BabelNodeDecorator>, computed?: boolean, _static?: boolean): BabelNodeClassAccessorProperty;
declare export function classPrivateProperty(key: BabelNodePrivateName, value?: BabelNodeExpression, decorators?: Array<BabelNodeDecorator>, _static?: boolean): BabelNodeClassPrivateProperty;
declare export function classPrivateMethod(kind?: "get" | "set" | "method", key: BabelNodePrivateName, params: Array<BabelNodeFunctionParameter | BabelNodeTSParameterProperty>, body: BabelNodeBlockStatement, _static?: boolean): BabelNodeClassPrivateMethod;
declare export function privateName(id: BabelNodeIdentifier): BabelNodePrivateName;
declare export function staticBlock(body: Array<BabelNodeStatement>): BabelNodeStaticBlock;
declare export function importAttribute(key: BabelNodeIdentifier | BabelNodeStringLiteral, value: BabelNodeStringLiteral): BabelNodeImportAttribute;
declare export function anyTypeAnnotation(): BabelNodeAnyTypeAnnotation;
declare export function arrayTypeAnnotation(elementType: BabelNodeFlowType): BabelNodeArrayTypeAnnotation;
declare export function booleanTypeAnnotation(): BabelNodeBooleanTypeAnnotation;
declare export function booleanLiteralTypeAnnotation(value: boolean): BabelNodeBooleanLiteralTypeAnnotation;
declare export function nullLiteralTypeAnnotation(): BabelNodeNullLiteralTypeAnnotation;
declare export function classImplements(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterInstantiation): BabelNodeClassImplements;
declare export function declareClass(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterDeclaration, _extends?: Array<BabelNodeInterfaceExtends>, body: BabelNodeObjectTypeAnnotation): BabelNodeDeclareClass;
declare export function declareFunction(id: BabelNodeIdentifier): BabelNodeDeclareFunction;
declare export function declareInterface(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterDeclaration, _extends?: Array<BabelNodeInterfaceExtends>, body: BabelNodeObjectTypeAnnotation): BabelNodeDeclareInterface;
declare export function declareModule(id: BabelNodeIdentifier | BabelNodeStringLiteral, body: BabelNodeBlockStatement, kind?: "CommonJS" | "ES"): BabelNodeDeclareModule;
declare export function declareModuleExports(typeAnnotation: BabelNodeTypeAnnotation): BabelNodeDeclareModuleExports;
declare export function declareTypeAlias(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterDeclaration, right: BabelNodeFlowType): BabelNodeDeclareTypeAlias;
declare export function declareOpaqueType(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterDeclaration, supertype?: BabelNodeFlowType): BabelNodeDeclareOpaqueType;
declare export function declareVariable(id: BabelNodeIdentifier): BabelNodeDeclareVariable;
declare export function declareExportDeclaration(declaration?: BabelNodeFlow, specifiers?: Array<BabelNodeExportSpecifier | BabelNodeExportNamespaceSpecifier>, source?: BabelNodeStringLiteral, attributes?: Array<BabelNodeImportAttribute>): BabelNodeDeclareExportDeclaration;
declare export function declareExportAllDeclaration(source: BabelNodeStringLiteral, attributes?: Array<BabelNodeImportAttribute>): BabelNodeDeclareExportAllDeclaration;
declare export function declaredPredicate(value: BabelNodeFlow): BabelNodeDeclaredPredicate;
declare export function existsTypeAnnotation(): BabelNodeExistsTypeAnnotation;
declare export function functionTypeAnnotation(typeParameters?: BabelNodeTypeParameterDeclaration, params: Array<BabelNodeFunctionTypeParam>, rest?: BabelNodeFunctionTypeParam, returnType: BabelNodeFlowType): BabelNodeFunctionTypeAnnotation;
declare export function functionTypeParam(name?: BabelNodeIdentifier, typeAnnotation: BabelNodeFlowType): BabelNodeFunctionTypeParam;
declare export function genericTypeAnnotation(id: BabelNodeIdentifier | BabelNodeQualifiedTypeIdentifier, typeParameters?: BabelNodeTypeParameterInstantiation): BabelNodeGenericTypeAnnotation;
declare export function inferredPredicate(): BabelNodeInferredPredicate;
declare export function interfaceExtends(id: BabelNodeIdentifier | BabelNodeQualifiedTypeIdentifier, typeParameters?: BabelNodeTypeParameterInstantiation): BabelNodeInterfaceExtends;
declare export function interfaceDeclaration(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterDeclaration, _extends?: Array<BabelNodeInterfaceExtends>, body: BabelNodeObjectTypeAnnotation): BabelNodeInterfaceDeclaration;
declare export function interfaceTypeAnnotation(_extends?: Array<BabelNodeInterfaceExtends>, body: BabelNodeObjectTypeAnnotation): BabelNodeInterfaceTypeAnnotation;
declare export function intersectionTypeAnnotation(types: Array<BabelNodeFlowType>): BabelNodeIntersectionTypeAnnotation;
declare export function mixedTypeAnnotation(): BabelNodeMixedTypeAnnotation;
declare export function emptyTypeAnnotation(): BabelNodeEmptyTypeAnnotation;
declare export function nullableTypeAnnotation(typeAnnotation: BabelNodeFlowType): BabelNodeNullableTypeAnnotation;
declare export function numberLiteralTypeAnnotation(value: number): BabelNodeNumberLiteralTypeAnnotation;
declare export function numberTypeAnnotation(): BabelNodeNumberTypeAnnotation;
declare export function objectTypeAnnotation(properties: Array<BabelNodeObjectTypeProperty | BabelNodeObjectTypeSpreadProperty>, indexers?: Array<BabelNodeObjectTypeIndexer>, callProperties?: Array<BabelNodeObjectTypeCallProperty>, internalSlots?: Array<BabelNodeObjectTypeInternalSlot>, exact?: boolean): BabelNodeObjectTypeAnnotation;
declare export function objectTypeInternalSlot(id: BabelNodeIdentifier, value: BabelNodeFlowType, optional: boolean, _static: boolean, method: boolean): BabelNodeObjectTypeInternalSlot;
declare export function objectTypeCallProperty(value: BabelNodeFlowType): BabelNodeObjectTypeCallProperty;
declare export function objectTypeIndexer(id?: BabelNodeIdentifier, key: BabelNodeFlowType, value: BabelNodeFlowType, variance?: BabelNodeVariance): BabelNodeObjectTypeIndexer;
declare export function objectTypeProperty(key: BabelNodeIdentifier | BabelNodeStringLiteral, value: BabelNodeFlowType, variance?: BabelNodeVariance): BabelNodeObjectTypeProperty;
declare export function objectTypeSpreadProperty(argument: BabelNodeFlowType): BabelNodeObjectTypeSpreadProperty;
declare export function opaqueType(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterDeclaration, supertype?: BabelNodeFlowType, impltype: BabelNodeFlowType): BabelNodeOpaqueType;
declare export function qualifiedTypeIdentifier(id: BabelNodeIdentifier, qualification: BabelNodeIdentifier | BabelNodeQualifiedTypeIdentifier): BabelNodeQualifiedTypeIdentifier;
declare export function stringLiteralTypeAnnotation(value: string): BabelNodeStringLiteralTypeAnnotation;
declare export function stringTypeAnnotation(): BabelNodeStringTypeAnnotation;
declare export function symbolTypeAnnotation(): BabelNodeSymbolTypeAnnotation;
declare export function thisTypeAnnotation(): BabelNodeThisTypeAnnotation;
declare export function tupleTypeAnnotation(types: Array<BabelNodeFlowType>): BabelNodeTupleTypeAnnotation;
declare export function typeofTypeAnnotation(argument: BabelNodeFlowType): BabelNodeTypeofTypeAnnotation;
declare export function typeAlias(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterDeclaration, right: BabelNodeFlowType): BabelNodeTypeAlias;
declare export function typeAnnotation(typeAnnotation: BabelNodeFlowType): BabelNodeTypeAnnotation;
declare export function typeCastExpression(expression: BabelNodeExpression, typeAnnotation: BabelNodeTypeAnnotation): BabelNodeTypeCastExpression;
declare export function typeParameter(bound?: BabelNodeTypeAnnotation, _default?: BabelNodeFlowType, variance?: BabelNodeVariance): BabelNodeTypeParameter;
declare export function typeParameterDeclaration(params: Array<BabelNodeTypeParameter>): BabelNodeTypeParameterDeclaration;
declare export function typeParameterInstantiation(params: Array<BabelNodeFlowType>): BabelNodeTypeParameterInstantiation;
declare export function unionTypeAnnotation(types: Array<BabelNodeFlowType>): BabelNodeUnionTypeAnnotation;
declare export function variance(kind: "minus" | "plus"): BabelNodeVariance;
declare export function voidTypeAnnotation(): BabelNodeVoidTypeAnnotation;
declare export function enumDeclaration(id: BabelNodeIdentifier, body: BabelNodeEnumBooleanBody | BabelNodeEnumNumberBody | BabelNodeEnumStringBody | BabelNodeEnumSymbolBody): BabelNodeEnumDeclaration;
declare export function enumBooleanBody(members: Array<BabelNodeEnumBooleanMember>): BabelNodeEnumBooleanBody;
declare export function enumNumberBody(members: Array<BabelNodeEnumNumberMember>): BabelNodeEnumNumberBody;
declare export function enumStringBody(members: Array<BabelNodeEnumStringMember | BabelNodeEnumDefaultedMember>): BabelNodeEnumStringBody;
declare export function enumSymbolBody(members: Array<BabelNodeEnumDefaultedMember>): BabelNodeEnumSymbolBody;
declare export function enumBooleanMember(id: BabelNodeIdentifier): BabelNodeEnumBooleanMember;
declare export function enumNumberMember(id: BabelNodeIdentifier, init: BabelNodeNumericLiteral): BabelNodeEnumNumberMember;
declare export function enumStringMember(id: BabelNodeIdentifier, init: BabelNodeStringLiteral): BabelNodeEnumStringMember;
declare export function enumDefaultedMember(id: BabelNodeIdentifier): BabelNodeEnumDefaultedMember;
declare export function indexedAccessType(objectType: BabelNodeFlowType, indexType: BabelNodeFlowType): BabelNodeIndexedAccessType;
declare export function optionalIndexedAccessType(objectType: BabelNodeFlowType, indexType: BabelNodeFlowType): BabelNodeOptionalIndexedAccessType;
declare export function jsxAttribute(name: BabelNodeJSXIdentifier | BabelNodeJSXNamespacedName, value?: BabelNodeJSXElement | BabelNodeJSXFragment | BabelNodeStringLiteral | BabelNodeJSXExpressionContainer): BabelNodeJSXAttribute;
declare export function jsxClosingElement(name: BabelNodeJSXIdentifier | BabelNodeJSXMemberExpression | BabelNodeJSXNamespacedName): BabelNodeJSXClosingElement;
declare export function jsxElement(openingElement: BabelNodeJSXOpeningElement, closingElement?: BabelNodeJSXClosingElement, children: Array<BabelNodeJSXText | BabelNodeJSXExpressionContainer | BabelNodeJSXSpreadChild | BabelNodeJSXElement | BabelNodeJSXFragment>, selfClosing?: boolean): BabelNodeJSXElement;
declare export function jsxEmptyExpression(): BabelNodeJSXEmptyExpression;
declare export function jsxExpressionContainer(expression: BabelNodeExpression | BabelNodeJSXEmptyExpression): BabelNodeJSXExpressionContainer;
declare export function jsxSpreadChild(expression: BabelNodeExpression): BabelNodeJSXSpreadChild;
declare export function jsxIdentifier(name: string): BabelNodeJSXIdentifier;
declare export function jsxMemberExpression(object: BabelNodeJSXMemberExpression | BabelNodeJSXIdentifier, property: BabelNodeJSXIdentifier): BabelNodeJSXMemberExpression;
declare export function jsxNamespacedName(namespace: BabelNodeJSXIdentifier, name: BabelNodeJSXIdentifier): BabelNodeJSXNamespacedName;
declare export function jsxOpeningElement(name: BabelNodeJSXIdentifier | BabelNodeJSXMemberExpression | BabelNodeJSXNamespacedName, attributes: Array<BabelNodeJSXAttribute | BabelNodeJSXSpreadAttribute>, selfClosing?: boolean): BabelNodeJSXOpeningElement;
declare export function jsxSpreadAttribute(argument: BabelNodeExpression): BabelNodeJSXSpreadAttribute;
declare export function jsxText(value: string): BabelNodeJSXText;
declare export function jsxFragment(openingFragment: BabelNodeJSXOpeningFragment, closingFragment: BabelNodeJSXClosingFragment, children: Array<BabelNodeJSXText | BabelNodeJSXExpressionContainer | BabelNodeJSXSpreadChild | BabelNodeJSXElement | BabelNodeJSXFragment>): BabelNodeJSXFragment;
declare export function jsxOpeningFragment(): BabelNodeJSXOpeningFragment;
declare export function jsxClosingFragment(): BabelNodeJSXClosingFragment;
declare export function noop(): BabelNodeNoop;
declare export function placeholder(expectedNode: "Identifier" | "StringLiteral" | "Expression" | "Statement" | "Declaration" | "BlockStatement" | "ClassBody" | "Pattern", name: BabelNodeIdentifier): BabelNodePlaceholder;
declare export function v8IntrinsicIdentifier(name: string): BabelNodeV8IntrinsicIdentifier;
declare export function argumentPlaceholder(): BabelNodeArgumentPlaceholder;
declare export function bindExpression(object: BabelNodeExpression, callee: BabelNodeExpression): BabelNodeBindExpression;
declare export function decorator(expression: BabelNodeExpression): BabelNodeDecorator;
declare export function doExpression(body: BabelNodeBlockStatement, async?: boolean): BabelNodeDoExpression;
declare export function exportDefaultSpecifier(exported: BabelNodeIdentifier): BabelNodeExportDefaultSpecifier;
declare export function recordExpression(properties: Array<BabelNodeObjectProperty | BabelNodeSpreadElement>): BabelNodeRecordExpression;
declare export function tupleExpression(elements?: Array<BabelNodeExpression | BabelNodeSpreadElement>): BabelNodeTupleExpression;
declare export function decimalLiteral(value: string): BabelNodeDecimalLiteral;
declare export function moduleExpression(body: BabelNodeProgram): BabelNodeModuleExpression;
declare export function topicReference(): BabelNodeTopicReference;
declare export function pipelineTopicExpression(expression: BabelNodeExpression): BabelNodePipelineTopicExpression;
declare export function pipelineBareFunction(callee: BabelNodeExpression): BabelNodePipelineBareFunction;
declare export function pipelinePrimaryTopicReference(): BabelNodePipelinePrimaryTopicReference;
declare export function voidPattern(): BabelNodeVoidPattern;
declare export function tsParameterProperty(parameter: BabelNodeIdentifier | BabelNodeAssignmentPattern): BabelNodeTSParameterProperty;
declare export function tsDeclareFunction(id?: BabelNodeIdentifier, typeParameters?: BabelNodeTSTypeParameterDeclaration | BabelNodeNoop, params: Array<BabelNodeFunctionParameter>, returnType?: BabelNodeTSTypeAnnotation | BabelNodeNoop): BabelNodeTSDeclareFunction;
declare export function tsDeclareMethod(decorators?: Array<BabelNodeDecorator>, key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeBigIntLiteral | BabelNodeExpression, typeParameters?: BabelNodeTSTypeParameterDeclaration | BabelNodeNoop, params: Array<BabelNodeFunctionParameter | BabelNodeTSParameterProperty>, returnType?: BabelNodeTSTypeAnnotation | BabelNodeNoop): BabelNodeTSDeclareMethod;
declare export function tsQualifiedName(left: BabelNodeTSEntityName, right: BabelNodeIdentifier): BabelNodeTSQualifiedName;
declare export function tsCallSignatureDeclaration(typeParameters?: BabelNodeTSTypeParameterDeclaration, parameters: Array<BabelNodeArrayPattern | BabelNodeIdentifier | BabelNodeObjectPattern | BabelNodeRestElement>, typeAnnotation?: BabelNodeTSTypeAnnotation): BabelNodeTSCallSignatureDeclaration;
declare export function tsConstructSignatureDeclaration(typeParameters?: BabelNodeTSTypeParameterDeclaration, parameters: Array<BabelNodeArrayPattern | BabelNodeIdentifier | BabelNodeObjectPattern | BabelNodeRestElement>, typeAnnotation?: BabelNodeTSTypeAnnotation): BabelNodeTSConstructSignatureDeclaration;
declare export function tsPropertySignature(key: BabelNodeExpression, typeAnnotation?: BabelNodeTSTypeAnnotation): BabelNodeTSPropertySignature;
declare export function tsMethodSignature(key: BabelNodeExpression, typeParameters?: BabelNodeTSTypeParameterDeclaration, parameters: Array<BabelNodeArrayPattern | BabelNodeIdentifier | BabelNodeObjectPattern | BabelNodeRestElement>, typeAnnotation?: BabelNodeTSTypeAnnotation): BabelNodeTSMethodSignature;
declare export function tsIndexSignature(parameters: Array<BabelNodeIdentifier>, typeAnnotation?: BabelNodeTSTypeAnnotation): BabelNodeTSIndexSignature;
declare export function tsAnyKeyword(): BabelNodeTSAnyKeyword;
declare export function tsBooleanKeyword(): BabelNodeTSBooleanKeyword;
declare export function tsBigIntKeyword(): BabelNodeTSBigIntKeyword;
declare export function tsIntrinsicKeyword(): BabelNodeTSIntrinsicKeyword;
declare export function tsNeverKeyword(): BabelNodeTSNeverKeyword;
declare export function tsNullKeyword(): BabelNodeTSNullKeyword;
declare export function tsNumberKeyword(): BabelNodeTSNumberKeyword;
declare export function tsObjectKeyword(): BabelNodeTSObjectKeyword;
declare export function tsStringKeyword(): BabelNodeTSStringKeyword;
declare export function tsSymbolKeyword(): BabelNodeTSSymbolKeyword;
declare export function tsUndefinedKeyword(): BabelNodeTSUndefinedKeyword;
declare export function tsUnknownKeyword(): BabelNodeTSUnknownKeyword;
declare export function tsVoidKeyword(): BabelNodeTSVoidKeyword;
declare export function tsThisType(): BabelNodeTSThisType;
declare export function tsFunctionType(typeParameters?: BabelNodeTSTypeParameterDeclaration, parameters: Array<BabelNodeArrayPattern | BabelNodeIdentifier | BabelNodeObjectPattern | BabelNodeRestElement>, typeAnnotation?: BabelNodeTSTypeAnnotation): BabelNodeTSFunctionType;
declare export function tsConstructorType(typeParameters?: BabelNodeTSTypeParameterDeclaration, parameters: Array<BabelNodeArrayPattern | BabelNodeIdentifier | BabelNodeObjectPattern | BabelNodeRestElement>, typeAnnotation?: BabelNodeTSTypeAnnotation): BabelNodeTSConstructorType;
declare export function tsTypeReference(typeName: BabelNodeTSEntityName, typeParameters?: BabelNodeTSTypeParameterInstantiation): BabelNodeTSTypeReference;
declare export function tsTypePredicate(parameterName: BabelNodeIdentifier | BabelNodeTSThisType, typeAnnotation?: BabelNodeTSTypeAnnotation, asserts?: boolean): BabelNodeTSTypePredicate;
declare export function tsTypeQuery(exprName: BabelNodeTSEntityName | BabelNodeTSImportType, typeParameters?: BabelNodeTSTypeParameterInstantiation): BabelNodeTSTypeQuery;
declare export function tsTypeLiteral(members: Array<BabelNodeTSTypeElement>): BabelNodeTSTypeLiteral;
declare export function tsArrayType(elementType: BabelNodeTSType): BabelNodeTSArrayType;
declare export function tsTupleType(elementTypes: Array<BabelNodeTSType | BabelNodeTSNamedTupleMember>): BabelNodeTSTupleType;
declare export function tsOptionalType(typeAnnotation: BabelNodeTSType): BabelNodeTSOptionalType;
declare export function tsRestType(typeAnnotation: BabelNodeTSType): BabelNodeTSRestType;
declare export function tsNamedTupleMember(label: BabelNodeIdentifier, elementType: BabelNodeTSType, optional?: boolean): BabelNodeTSNamedTupleMember;
declare export function tsUnionType(types: Array<BabelNodeTSType>): BabelNodeTSUnionType;
declare export function tsIntersectionType(types: Array<BabelNodeTSType>): BabelNodeTSIntersectionType;
declare export function tsConditionalType(checkType: BabelNodeTSType, extendsType: BabelNodeTSType, trueType: BabelNodeTSType, falseType: BabelNodeTSType): BabelNodeTSConditionalType;
declare export function tsInferType(typeParameter: BabelNodeTSTypeParameter): BabelNodeTSInferType;
declare export function tsParenthesizedType(typeAnnotation: BabelNodeTSType): BabelNodeTSParenthesizedType;
declare export function tsTypeOperator(typeAnnotation: BabelNodeTSType, operator?: string): BabelNodeTSTypeOperator;
declare export function tsIndexedAccessType(objectType: BabelNodeTSType, indexType: BabelNodeTSType): BabelNodeTSIndexedAccessType;
declare export function tsMappedType(typeParameter: BabelNodeTSTypeParameter, typeAnnotation?: BabelNodeTSType, nameType?: BabelNodeTSType): BabelNodeTSMappedType;
declare export function tsTemplateLiteralType(quasis: Array<BabelNodeTemplateElement>, types: Array<BabelNodeTSType>): BabelNodeTSTemplateLiteralType;
declare export function tsLiteralType(literal: BabelNodeNumericLiteral | BabelNodeStringLiteral | BabelNodeBooleanLiteral | BabelNodeBigIntLiteral | BabelNodeTemplateLiteral | BabelNodeUnaryExpression): BabelNodeTSLiteralType;
declare export function tsExpressionWithTypeArguments(expression: BabelNodeTSEntityName, typeParameters?: BabelNodeTSTypeParameterInstantiation): BabelNodeTSExpressionWithTypeArguments;
declare export function tsInterfaceDeclaration(id: BabelNodeIdentifier, typeParameters?: BabelNodeTSTypeParameterDeclaration, _extends?: Array<BabelNodeTSExpressionWithTypeArguments>, body: BabelNodeTSInterfaceBody): BabelNodeTSInterfaceDeclaration;
declare export function tsInterfaceBody(body: Array<BabelNodeTSTypeElement>): BabelNodeTSInterfaceBody;
declare export function tsTypeAliasDeclaration(id: BabelNodeIdentifier, typeParameters?: BabelNodeTSTypeParameterDeclaration, typeAnnotation: BabelNodeTSType): BabelNodeTSTypeAliasDeclaration;
declare export function tsInstantiationExpression(expression: BabelNodeExpression, typeParameters?: BabelNodeTSTypeParameterInstantiation): BabelNodeTSInstantiationExpression;
declare export function tsAsExpression(expression: BabelNodeExpression, typeAnnotation: BabelNodeTSType): BabelNodeTSAsExpression;
declare export function tsSatisfiesExpression(expression: BabelNodeExpression, typeAnnotation: BabelNodeTSType): BabelNodeTSSatisfiesExpression;
declare export function tsTypeAssertion(typeAnnotation: BabelNodeTSType, expression: BabelNodeExpression): BabelNodeTSTypeAssertion;
declare export function tsEnumBody(members: Array<BabelNodeTSEnumMember>): BabelNodeTSEnumBody;
declare export function tsEnumDeclaration(id: BabelNodeIdentifier, members: Array<BabelNodeTSEnumMember>): BabelNodeTSEnumDeclaration;
declare export function tsEnumMember(id: BabelNodeIdentifier | BabelNodeStringLiteral, initializer?: BabelNodeExpression): BabelNodeTSEnumMember;
declare export function tsModuleDeclaration(id: BabelNodeIdentifier | BabelNodeStringLiteral, body: BabelNodeTSModuleBlock | BabelNodeTSModuleDeclaration): BabelNodeTSModuleDeclaration;
declare export function tsModuleBlock(body: Array<BabelNodeStatement>): BabelNodeTSModuleBlock;
declare export function tsImportType(argument: BabelNodeStringLiteral, qualifier?: BabelNodeTSEntityName, typeParameters?: BabelNodeTSTypeParameterInstantiation): BabelNodeTSImportType;
declare export function tsImportEqualsDeclaration(id: BabelNodeIdentifier, moduleReference: BabelNodeTSEntityName | BabelNodeTSExternalModuleReference): BabelNodeTSImportEqualsDeclaration;
declare export function tsExternalModuleReference(expression: BabelNodeStringLiteral): BabelNodeTSExternalModuleReference;
declare export function tsNonNullExpression(expression: BabelNodeExpression): BabelNodeTSNonNullExpression;
declare export function tsExportAssignment(expression: BabelNodeExpression): BabelNodeTSExportAssignment;
declare export function tsNamespaceExportDeclaration(id: BabelNodeIdentifier): BabelNodeTSNamespaceExportDeclaration;
declare export function tsTypeAnnotation(typeAnnotation: BabelNodeTSType): BabelNodeTSTypeAnnotation;
declare export function tsTypeParameterInstantiation(params: Array<BabelNodeTSType>): BabelNodeTSTypeParameterInstantiation;
declare export function tsTypeParameterDeclaration(params: Array<BabelNodeTSTypeParameter>): BabelNodeTSTypeParameterDeclaration;
declare export function tsTypeParameter(constraint?: BabelNodeTSType, _default?: BabelNodeTSType, name: string): BabelNodeTSTypeParameter;
declare export function isArrayExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeArrayExpression)
declare export function assertArrayExpression(node: ?Object, opts?: ?Object): void
declare export function isAssignmentExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeAssignmentExpression)
declare export function assertAssignmentExpression(node: ?Object, opts?: ?Object): void
declare export function isBinaryExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeBinaryExpression)
declare export function assertBinaryExpression(node: ?Object, opts?: ?Object): void
declare export function isInterpreterDirective(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeInterpreterDirective)
declare export function assertInterpreterDirective(node: ?Object, opts?: ?Object): void
declare export function isDirective(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDirective)
declare export function assertDirective(node: ?Object, opts?: ?Object): void
declare export function isDirectiveLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDirectiveLiteral)
declare export function assertDirectiveLiteral(node: ?Object, opts?: ?Object): void
declare export function isBlockStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeBlockStatement)
declare export function assertBlockStatement(node: ?Object, opts?: ?Object): void
declare export function isBreakStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeBreakStatement)
declare export function assertBreakStatement(node: ?Object, opts?: ?Object): void
declare export function isCallExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeCallExpression)
declare export function assertCallExpression(node: ?Object, opts?: ?Object): void
declare export function isCatchClause(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeCatchClause)
declare export function assertCatchClause(node: ?Object, opts?: ?Object): void
declare export function isConditionalExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeConditionalExpression)
declare export function assertConditionalExpression(node: ?Object, opts?: ?Object): void
declare export function isContinueStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeContinueStatement)
declare export function assertContinueStatement(node: ?Object, opts?: ?Object): void
declare export function isDebuggerStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDebuggerStatement)
declare export function assertDebuggerStatement(node: ?Object, opts?: ?Object): void
declare export function isDoWhileStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDoWhileStatement)
declare export function assertDoWhileStatement(node: ?Object, opts?: ?Object): void
declare export function isEmptyStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEmptyStatement)
declare export function assertEmptyStatement(node: ?Object, opts?: ?Object): void
declare export function isExpressionStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExpressionStatement)
declare export function assertExpressionStatement(node: ?Object, opts?: ?Object): void
declare export function isFile(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeFile)
declare export function assertFile(node: ?Object, opts?: ?Object): void
declare export function isForInStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeForInStatement)
declare export function assertForInStatement(node: ?Object, opts?: ?Object): void
declare export function isForStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeForStatement)
declare export function assertForStatement(node: ?Object, opts?: ?Object): void
declare export function isFunctionDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeFunctionDeclaration)
declare export function assertFunctionDeclaration(node: ?Object, opts?: ?Object): void
declare export function isFunctionExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeFunctionExpression)
declare export function assertFunctionExpression(node: ?Object, opts?: ?Object): void
declare export function isIdentifier(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeIdentifier)
declare export function assertIdentifier(node: ?Object, opts?: ?Object): void
declare export function isIfStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeIfStatement)
declare export function assertIfStatement(node: ?Object, opts?: ?Object): void
declare export function isLabeledStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeLabeledStatement)
declare export function assertLabeledStatement(node: ?Object, opts?: ?Object): void
declare export function isStringLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeStringLiteral)
declare export function assertStringLiteral(node: ?Object, opts?: ?Object): void
declare export function isNumericLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNumericLiteral)
declare export function assertNumericLiteral(node: ?Object, opts?: ?Object): void
declare export function isNullLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNullLiteral)
declare export function assertNullLiteral(node: ?Object, opts?: ?Object): void
declare export function isBooleanLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeBooleanLiteral)
declare export function assertBooleanLiteral(node: ?Object, opts?: ?Object): void
declare export function isRegExpLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeRegExpLiteral)
declare export function assertRegExpLiteral(node: ?Object, opts?: ?Object): void
declare export function isLogicalExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeLogicalExpression)
declare export function assertLogicalExpression(node: ?Object, opts?: ?Object): void
declare export function isMemberExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeMemberExpression)
declare export function assertMemberExpression(node: ?Object, opts?: ?Object): void
declare export function isNewExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNewExpression)
declare export function assertNewExpression(node: ?Object, opts?: ?Object): void
declare export function isProgram(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeProgram)
declare export function assertProgram(node: ?Object, opts?: ?Object): void
declare export function isObjectExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectExpression)
declare export function assertObjectExpression(node: ?Object, opts?: ?Object): void
declare export function isObjectMethod(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectMethod)
declare export function assertObjectMethod(node: ?Object, opts?: ?Object): void
declare export function isObjectProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectProperty)
declare export function assertObjectProperty(node: ?Object, opts?: ?Object): void
declare export function isRestElement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeRestElement)
declare export function assertRestElement(node: ?Object, opts?: ?Object): void
declare export function isReturnStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeReturnStatement)
declare export function assertReturnStatement(node: ?Object, opts?: ?Object): void
declare export function isSequenceExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeSequenceExpression)
declare export function assertSequenceExpression(node: ?Object, opts?: ?Object): void
declare export function isParenthesizedExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeParenthesizedExpression)
declare export function assertParenthesizedExpression(node: ?Object, opts?: ?Object): void
declare export function isSwitchCase(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeSwitchCase)
declare export function assertSwitchCase(node: ?Object, opts?: ?Object): void
declare export function isSwitchStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeSwitchStatement)
declare export function assertSwitchStatement(node: ?Object, opts?: ?Object): void
declare export function isThisExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeThisExpression)
declare export function assertThisExpression(node: ?Object, opts?: ?Object): void
declare export function isThrowStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeThrowStatement)
declare export function assertThrowStatement(node: ?Object, opts?: ?Object): void
declare export function isTryStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTryStatement)
declare export function assertTryStatement(node: ?Object, opts?: ?Object): void
declare export function isUnaryExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeUnaryExpression)
declare export function assertUnaryExpression(node: ?Object, opts?: ?Object): void
declare export function isUpdateExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeUpdateExpression)
declare export function assertUpdateExpression(node: ?Object, opts?: ?Object): void
declare export function isVariableDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeVariableDeclaration)
declare export function assertVariableDeclaration(node: ?Object, opts?: ?Object): void
declare export function isVariableDeclarator(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeVariableDeclarator)
declare export function assertVariableDeclarator(node: ?Object, opts?: ?Object): void
declare export function isWhileStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeWhileStatement)
declare export function assertWhileStatement(node: ?Object, opts?: ?Object): void
declare export function isWithStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeWithStatement)
declare export function assertWithStatement(node: ?Object, opts?: ?Object): void
declare export function isAssignmentPattern(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeAssignmentPattern)
declare export function assertAssignmentPattern(node: ?Object, opts?: ?Object): void
declare export function isArrayPattern(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeArrayPattern)
declare export function assertArrayPattern(node: ?Object, opts?: ?Object): void
declare export function isArrowFunctionExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeArrowFunctionExpression)
declare export function assertArrowFunctionExpression(node: ?Object, opts?: ?Object): void
declare export function isClassBody(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassBody)
declare export function assertClassBody(node: ?Object, opts?: ?Object): void
declare export function isClassExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassExpression)
declare export function assertClassExpression(node: ?Object, opts?: ?Object): void
declare export function isClassDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassDeclaration)
declare export function assertClassDeclaration(node: ?Object, opts?: ?Object): void
declare export function isExportAllDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExportAllDeclaration)
declare export function assertExportAllDeclaration(node: ?Object, opts?: ?Object): void
declare export function isExportDefaultDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExportDefaultDeclaration)
declare export function assertExportDefaultDeclaration(node: ?Object, opts?: ?Object): void
declare export function isExportNamedDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExportNamedDeclaration)
declare export function assertExportNamedDeclaration(node: ?Object, opts?: ?Object): void
declare export function isExportSpecifier(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExportSpecifier)
declare export function assertExportSpecifier(node: ?Object, opts?: ?Object): void
declare export function isForOfStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeForOfStatement)
declare export function assertForOfStatement(node: ?Object, opts?: ?Object): void
declare export function isImportDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeImportDeclaration)
declare export function assertImportDeclaration(node: ?Object, opts?: ?Object): void
declare export function isImportDefaultSpecifier(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeImportDefaultSpecifier)
declare export function assertImportDefaultSpecifier(node: ?Object, opts?: ?Object): void
declare export function isImportNamespaceSpecifier(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeImportNamespaceSpecifier)
declare export function assertImportNamespaceSpecifier(node: ?Object, opts?: ?Object): void
declare export function isImportSpecifier(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeImportSpecifier)
declare export function assertImportSpecifier(node: ?Object, opts?: ?Object): void
declare export function isImportExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeImportExpression)
declare export function assertImportExpression(node: ?Object, opts?: ?Object): void
declare export function isMetaProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeMetaProperty)
declare export function assertMetaProperty(node: ?Object, opts?: ?Object): void
declare export function isClassMethod(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassMethod)
declare export function assertClassMethod(node: ?Object, opts?: ?Object): void
declare export function isObjectPattern(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectPattern)
declare export function assertObjectPattern(node: ?Object, opts?: ?Object): void
declare export function isSpreadElement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeSpreadElement)
declare export function assertSpreadElement(node: ?Object, opts?: ?Object): void
declare export function isSuper(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeSuper)
declare export function assertSuper(node: ?Object, opts?: ?Object): void
declare export function isTaggedTemplateExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTaggedTemplateExpression)
declare export function assertTaggedTemplateExpression(node: ?Object, opts?: ?Object): void
declare export function isTemplateElement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTemplateElement)
declare export function assertTemplateElement(node: ?Object, opts?: ?Object): void
declare export function isTemplateLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTemplateLiteral)
declare export function assertTemplateLiteral(node: ?Object, opts?: ?Object): void
declare export function isYieldExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeYieldExpression)
declare export function assertYieldExpression(node: ?Object, opts?: ?Object): void
declare export function isAwaitExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeAwaitExpression)
declare export function assertAwaitExpression(node: ?Object, opts?: ?Object): void
declare export function isImport(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeImport)
declare export function assertImport(node: ?Object, opts?: ?Object): void
declare export function isBigIntLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeBigIntLiteral)
declare export function assertBigIntLiteral(node: ?Object, opts?: ?Object): void
declare export function isExportNamespaceSpecifier(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExportNamespaceSpecifier)
declare export function assertExportNamespaceSpecifier(node: ?Object, opts?: ?Object): void
declare export function isOptionalMemberExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeOptionalMemberExpression)
declare export function assertOptionalMemberExpression(node: ?Object, opts?: ?Object): void
declare export function isOptionalCallExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeOptionalCallExpression)
declare export function assertOptionalCallExpression(node: ?Object, opts?: ?Object): void
declare export function isClassProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassProperty)
declare export function assertClassProperty(node: ?Object, opts?: ?Object): void
declare export function isClassAccessorProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassAccessorProperty)
declare export function assertClassAccessorProperty(node: ?Object, opts?: ?Object): void
declare export function isClassPrivateProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassPrivateProperty)
declare export function assertClassPrivateProperty(node: ?Object, opts?: ?Object): void
declare export function isClassPrivateMethod(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassPrivateMethod)
declare export function assertClassPrivateMethod(node: ?Object, opts?: ?Object): void
declare export function isPrivateName(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodePrivateName)
declare export function assertPrivateName(node: ?Object, opts?: ?Object): void
declare export function isStaticBlock(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeStaticBlock)
declare export function assertStaticBlock(node: ?Object, opts?: ?Object): void
declare export function isImportAttribute(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeImportAttribute)
declare export function assertImportAttribute(node: ?Object, opts?: ?Object): void
declare export function isAnyTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeAnyTypeAnnotation)
declare export function assertAnyTypeAnnotation(node: ?Object, opts?: ?Object): void
declare export function isArrayTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeArrayTypeAnnotation)
declare export function assertArrayTypeAnnotation(node: ?Object, opts?: ?Object): void
declare export function isBooleanTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeBooleanTypeAnnotation)
declare export function assertBooleanTypeAnnotation(node: ?Object, opts?: ?Object): void
declare export function isBooleanLiteralTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeBooleanLiteralTypeAnnotation)
declare export function assertBooleanLiteralTypeAnnotation(node: ?Object, opts?: ?Object): void
declare export function isNullLiteralTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNullLiteralTypeAnnotation)
declare export function assertNullLiteralTypeAnnotation(node: ?Object, opts?: ?Object): void
declare export function isClassImplements(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassImplements)
declare export function assertClassImplements(node: ?Object, opts?: ?Object): void
declare export function isDeclareClass(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareClass)
declare export function assertDeclareClass(node: ?Object, opts?: ?Object): void
declare export function isDeclareFunction(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareFunction)
declare export function assertDeclareFunction(node: ?Object, opts?: ?Object): void
declare export function isDeclareInterface(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareInterface)
declare export function assertDeclareInterface(node: ?Object, opts?: ?Object): void
declare export function isDeclareModule(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareModule)
declare export function assertDeclareModule(node: ?Object, opts?: ?Object): void
declare export function isDeclareModuleExports(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareModuleExports)
declare export function assertDeclareModuleExports(node: ?Object, opts?: ?Object): void
declare export function isDeclareTypeAlias(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareTypeAlias)
declare export function assertDeclareTypeAlias(node: ?Object, opts?: ?Object): void
declare export function isDeclareOpaqueType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareOpaqueType)
declare export function assertDeclareOpaqueType(node: ?Object, opts?: ?Object): void
declare export function isDeclareVariable(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareVariable)
declare export function assertDeclareVariable(node: ?Object, opts?: ?Object): void
declare export function isDeclareExportDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareExportDeclaration)
declare export function assertDeclareExportDeclaration(node: ?Object, opts?: ?Object): void
declare export function isDeclareExportAllDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareExportAllDeclaration)
declare export function assertDeclareExportAllDeclaration(node: ?Object, opts?: ?Object): void
declare export function isDeclaredPredicate(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclaredPredicate)
declare export function assertDeclaredPredicate(node: ?Object, opts?: ?Object): void
declare export function isExistsTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExistsTypeAnnotation)
declare export function assertExistsTypeAnnotation(node: ?Object, opts?: ?Object): void
declare export function isFunctionTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeFunctionTypeAnnotation)
declare export function assertFunctionTypeAnnotation(node: ?Object, opts?: ?Object): void
declare export function isFunctionTypeParam(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeFunctionTypeParam)
declare export function assertFunctionTypeParam(node: ?Object, opts?: ?Object): void
declare export function isGenericTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeGenericTypeAnnotation)
declare export function assertGenericTypeAnnotation(node: ?Object, opts?: ?Object): void
declare export function isInferredPredicate(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeInferredPredicate)
declare export function assertInferredPredicate(node: ?Object, opts?: ?Object): void
declare export function isInterfaceExtends(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeInterfaceExtends)
declare export function assertInterfaceExtends(node: ?Object, opts?: ?Object): void
declare export function isInterfaceDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeInterfaceDeclaration)
declare export function assertInterfaceDeclaration(node: ?Object, opts?: ?Object): void
declare export function isInterfaceTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeInterfaceTypeAnnotation)
declare export function assertInterfaceTypeAnnotation(node: ?Object, opts?: ?Object): void
declare export function isIntersectionTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeIntersectionTypeAnnotation)
declare export function assertIntersectionTypeAnnotation(node: ?Object, opts?: ?Object): void
declare export function isMixedTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeMixedTypeAnnotation)
declare export function assertMixedTypeAnnotation(node: ?Object, opts?: ?Object): void
declare export function isEmptyTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEmptyTypeAnnotation)
declare export function assertEmptyTypeAnnotation(node: ?Object, opts?: ?Object): void
declare export function isNullableTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNullableTypeAnnotation)
declare export function assertNullableTypeAnnotation(node: ?Object, opts?: ?Object): void
declare export function isNumberLiteralTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNumberLiteralTypeAnnotation)
declare export function assertNumberLiteralTypeAnnotation(node: ?Object, opts?: ?Object): void
declare export function isNumberTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNumberTypeAnnotation)
declare export function assertNumberTypeAnnotation(node: ?Object, opts?: ?Object): void
declare export function isObjectTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectTypeAnnotation)
declare export function assertObjectTypeAnnotation(node: ?Object, opts?: ?Object): void
declare export function isObjectTypeInternalSlot(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectTypeInternalSlot)
declare export function assertObjectTypeInternalSlot(node: ?Object, opts?: ?Object): void
declare export function isObjectTypeCallProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectTypeCallProperty)
declare export function assertObjectTypeCallProperty(node: ?Object, opts?: ?Object): void
declare export function isObjectTypeIndexer(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectTypeIndexer)
declare export function assertObjectTypeIndexer(node: ?Object, opts?: ?Object): void
declare export function isObjectTypeProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectTypeProperty)
declare export function assertObjectTypeProperty(node: ?Object, opts?: ?Object): void
declare export function isObjectTypeSpreadProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectTypeSpreadProperty)
declare export function assertObjectTypeSpreadProperty(node: ?Object, opts?: ?Object): void
declare export function isOpaqueType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeOpaqueType)
declare export function assertOpaqueType(node: ?Object, opts?: ?Object): void
declare export function isQualifiedTypeIdentifier(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeQualifiedTypeIdentifier)
declare export function assertQualifiedTypeIdentifier(node: ?Object, opts?: ?Object): void
declare export function isStringLiteralTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeStringLiteralTypeAnnotation)
declare export function assertStringLiteralTypeAnnotation(node: ?Object, opts?: ?Object): void
declare export function isStringTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeStringTypeAnnotation)
declare export function assertStringTypeAnnotation(node: ?Object, opts?: ?Object): void
declare export function isSymbolTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeSymbolTypeAnnotation)
declare export function assertSymbolTypeAnnotation(node: ?Object, opts?: ?Object): void
declare export function isThisTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeThisTypeAnnotation)
declare export function assertThisTypeAnnotation(node: ?Object, opts?: ?Object): void
declare export function isTupleTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTupleTypeAnnotation)
declare export function assertTupleTypeAnnotation(node: ?Object, opts?: ?Object): void
declare export function isTypeofTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTypeofTypeAnnotation)
declare export function assertTypeofTypeAnnotation(node: ?Object, opts?: ?Object): void
declare export function isTypeAlias(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTypeAlias)
declare export function assertTypeAlias(node: ?Object, opts?: ?Object): void
declare export function isTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTypeAnnotation)
declare export function assertTypeAnnotation(node: ?Object, opts?: ?Object): void
declare export function isTypeCastExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTypeCastExpression)
declare export function assertTypeCastExpression(node: ?Object, opts?: ?Object): void
declare export function isTypeParameter(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTypeParameter)
declare export function assertTypeParameter(node: ?Object, opts?: ?Object): void
declare export function isTypeParameterDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTypeParameterDeclaration)
declare export function assertTypeParameterDeclaration(node: ?Object, opts?: ?Object): void
declare export function isTypeParameterInstantiation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTypeParameterInstantiation)
declare export function assertTypeParameterInstantiation(node: ?Object, opts?: ?Object): void
declare export function isUnionTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeUnionTypeAnnotation)
declare export function assertUnionTypeAnnotation(node: ?Object, opts?: ?Object): void
declare export function isVariance(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeVariance)
declare export function assertVariance(node: ?Object, opts?: ?Object): void
declare export function isVoidTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeVoidTypeAnnotation)
declare export function assertVoidTypeAnnotation(node: ?Object, opts?: ?Object): void
declare export function isEnumDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEnumDeclaration)
declare export function assertEnumDeclaration(node: ?Object, opts?: ?Object): void
declare export function isEnumBooleanBody(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEnumBooleanBody)
declare export function assertEnumBooleanBody(node: ?Object, opts?: ?Object): void
declare export function isEnumNumberBody(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEnumNumberBody)
declare export function assertEnumNumberBody(node: ?Object, opts?: ?Object): void
declare export function isEnumStringBody(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEnumStringBody)
declare export function assertEnumStringBody(node: ?Object, opts?: ?Object): void
declare export function isEnumSymbolBody(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEnumSymbolBody)
declare export function assertEnumSymbolBody(node: ?Object, opts?: ?Object): void
declare export function isEnumBooleanMember(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEnumBooleanMember)
declare export function assertEnumBooleanMember(node: ?Object, opts?: ?Object): void
declare export function isEnumNumberMember(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEnumNumberMember)
declare export function assertEnumNumberMember(node: ?Object, opts?: ?Object): void
declare export function isEnumStringMember(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEnumStringMember)
declare export function assertEnumStringMember(node: ?Object, opts?: ?Object): void
declare export function isEnumDefaultedMember(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEnumDefaultedMember)
declare export function assertEnumDefaultedMember(node: ?Object, opts?: ?Object): void
declare export function isIndexedAccessType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeIndexedAccessType)
declare export function assertIndexedAccessType(node: ?Object, opts?: ?Object): void
declare export function isOptionalIndexedAccessType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeOptionalIndexedAccessType)
declare export function assertOptionalIndexedAccessType(node: ?Object, opts?: ?Object): void
declare export function isJSXAttribute(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXAttribute)
declare export function assertJSXAttribute(node: ?Object, opts?: ?Object): void
declare export function isJSXClosingElement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXClosingElement)
declare export function assertJSXClosingElement(node: ?Object, opts?: ?Object): void
declare export function isJSXElement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXElement)
declare export function assertJSXElement(node: ?Object, opts?: ?Object): void
declare export function isJSXEmptyExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXEmptyExpression)
declare export function assertJSXEmptyExpression(node: ?Object, opts?: ?Object): void
declare export function isJSXExpressionContainer(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXExpressionContainer)
declare export function assertJSXExpressionContainer(node: ?Object, opts?: ?Object): void
declare export function isJSXSpreadChild(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXSpreadChild)
declare export function assertJSXSpreadChild(node: ?Object, opts?: ?Object): void
declare export function isJSXIdentifier(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXIdentifier)
declare export function assertJSXIdentifier(node: ?Object, opts?: ?Object): void
declare export function isJSXMemberExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXMemberExpression)
declare export function assertJSXMemberExpression(node: ?Object, opts?: ?Object): void
declare export function isJSXNamespacedName(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXNamespacedName)
declare export function assertJSXNamespacedName(node: ?Object, opts?: ?Object): void
declare export function isJSXOpeningElement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXOpeningElement)
declare export function assertJSXOpeningElement(node: ?Object, opts?: ?Object): void
declare export function isJSXSpreadAttribute(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXSpreadAttribute)
declare export function assertJSXSpreadAttribute(node: ?Object, opts?: ?Object): void
declare export function isJSXText(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXText)
declare export function assertJSXText(node: ?Object, opts?: ?Object): void
declare export function isJSXFragment(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXFragment)
declare export function assertJSXFragment(node: ?Object, opts?: ?Object): void
declare export function isJSXOpeningFragment(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXOpeningFragment)
declare export function assertJSXOpeningFragment(node: ?Object, opts?: ?Object): void
declare export function isJSXClosingFragment(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXClosingFragment)
declare export function assertJSXClosingFragment(node: ?Object, opts?: ?Object): void
declare export function isNoop(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNoop)
declare export function assertNoop(node: ?Object, opts?: ?Object): void
declare export function isPlaceholder(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodePlaceholder)
declare export function assertPlaceholder(node: ?Object, opts?: ?Object): void
declare export function isV8IntrinsicIdentifier(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeV8IntrinsicIdentifier)
declare export function assertV8IntrinsicIdentifier(node: ?Object, opts?: ?Object): void
declare export function isArgumentPlaceholder(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeArgumentPlaceholder)
declare export function assertArgumentPlaceholder(node: ?Object, opts?: ?Object): void
declare export function isBindExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeBindExpression)
declare export function assertBindExpression(node: ?Object, opts?: ?Object): void
declare export function isDecorator(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDecorator)
declare export function assertDecorator(node: ?Object, opts?: ?Object): void
declare export function isDoExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDoExpression)
declare export function assertDoExpression(node: ?Object, opts?: ?Object): void
declare export function isExportDefaultSpecifier(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExportDefaultSpecifier)
declare export function assertExportDefaultSpecifier(node: ?Object, opts?: ?Object): void
declare export function isRecordExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeRecordExpression)
declare export function assertRecordExpression(node: ?Object, opts?: ?Object): void
declare export function isTupleExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTupleExpression)
declare export function assertTupleExpression(node: ?Object, opts?: ?Object): void
declare export function isDecimalLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDecimalLiteral)
declare export function assertDecimalLiteral(node: ?Object, opts?: ?Object): void
declare export function isModuleExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeModuleExpression)
declare export function assertModuleExpression(node: ?Object, opts?: ?Object): void
declare export function isTopicReference(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTopicReference)
declare export function assertTopicReference(node: ?Object, opts?: ?Object): void
declare export function isPipelineTopicExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodePipelineTopicExpression)
declare export function assertPipelineTopicExpression(node: ?Object, opts?: ?Object): void
declare export function isPipelineBareFunction(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodePipelineBareFunction)
declare export function assertPipelineBareFunction(node: ?Object, opts?: ?Object): void
declare export function isPipelinePrimaryTopicReference(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodePipelinePrimaryTopicReference)
declare export function assertPipelinePrimaryTopicReference(node: ?Object, opts?: ?Object): void
declare export function isVoidPattern(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeVoidPattern)
declare export function assertVoidPattern(node: ?Object, opts?: ?Object): void
declare export function isTSParameterProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSParameterProperty)
declare export function assertTSParameterProperty(node: ?Object, opts?: ?Object): void
declare export function isTSDeclareFunction(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSDeclareFunction)
declare export function assertTSDeclareFunction(node: ?Object, opts?: ?Object): void
declare export function isTSDeclareMethod(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSDeclareMethod)
declare export function assertTSDeclareMethod(node: ?Object, opts?: ?Object): void
declare export function isTSQualifiedName(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSQualifiedName)
declare export function assertTSQualifiedName(node: ?Object, opts?: ?Object): void
declare export function isTSCallSignatureDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSCallSignatureDeclaration)
declare export function assertTSCallSignatureDeclaration(node: ?Object, opts?: ?Object): void
declare export function isTSConstructSignatureDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSConstructSignatureDeclaration)
declare export function assertTSConstructSignatureDeclaration(node: ?Object, opts?: ?Object): void
declare export function isTSPropertySignature(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSPropertySignature)
declare export function assertTSPropertySignature(node: ?Object, opts?: ?Object): void
declare export function isTSMethodSignature(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSMethodSignature)
declare export function assertTSMethodSignature(node: ?Object, opts?: ?Object): void
declare export function isTSIndexSignature(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSIndexSignature)
declare export function assertTSIndexSignature(node: ?Object, opts?: ?Object): void
declare export function isTSAnyKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSAnyKeyword)
declare export function assertTSAnyKeyword(node: ?Object, opts?: ?Object): void
declare export function isTSBooleanKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSBooleanKeyword)
declare export function assertTSBooleanKeyword(node: ?Object, opts?: ?Object): void
declare export function isTSBigIntKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSBigIntKeyword)
declare export function assertTSBigIntKeyword(node: ?Object, opts?: ?Object): void
declare export function isTSIntrinsicKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSIntrinsicKeyword)
declare export function assertTSIntrinsicKeyword(node: ?Object, opts?: ?Object): void
declare export function isTSNeverKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSNeverKeyword)
declare export function assertTSNeverKeyword(node: ?Object, opts?: ?Object): void
declare export function isTSNullKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSNullKeyword)
declare export function assertTSNullKeyword(node: ?Object, opts?: ?Object): void
declare export function isTSNumberKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSNumberKeyword)
declare export function assertTSNumberKeyword(node: ?Object, opts?: ?Object): void
declare export function isTSObjectKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSObjectKeyword)
declare export function assertTSObjectKeyword(node: ?Object, opts?: ?Object): void
declare export function isTSStringKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSStringKeyword)
declare export function assertTSStringKeyword(node: ?Object, opts?: ?Object): void
declare export function isTSSymbolKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSSymbolKeyword)
declare export function assertTSSymbolKeyword(node: ?Object, opts?: ?Object): void
declare export function isTSUndefinedKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSUndefinedKeyword)
declare export function assertTSUndefinedKeyword(node: ?Object, opts?: ?Object): void
declare export function isTSUnknownKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSUnknownKeyword)
declare export function assertTSUnknownKeyword(node: ?Object, opts?: ?Object): void
declare export function isTSVoidKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSVoidKeyword)
declare export function assertTSVoidKeyword(node: ?Object, opts?: ?Object): void
declare export function isTSThisType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSThisType)
declare export function assertTSThisType(node: ?Object, opts?: ?Object): void
declare export function isTSFunctionType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSFunctionType)
declare export function assertTSFunctionType(node: ?Object, opts?: ?Object): void
declare export function isTSConstructorType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSConstructorType)
declare export function assertTSConstructorType(node: ?Object, opts?: ?Object): void
declare export function isTSTypeReference(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeReference)
declare export function assertTSTypeReference(node: ?Object, opts?: ?Object): void
declare export function isTSTypePredicate(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypePredicate)
declare export function assertTSTypePredicate(node: ?Object, opts?: ?Object): void
declare export function isTSTypeQuery(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeQuery)
declare export function assertTSTypeQuery(node: ?Object, opts?: ?Object): void
declare export function isTSTypeLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeLiteral)
declare export function assertTSTypeLiteral(node: ?Object, opts?: ?Object): void
declare export function isTSArrayType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSArrayType)
declare export function assertTSArrayType(node: ?Object, opts?: ?Object): void
declare export function isTSTupleType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTupleType)
declare export function assertTSTupleType(node: ?Object, opts?: ?Object): void
declare export function isTSOptionalType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSOptionalType)
declare export function assertTSOptionalType(node: ?Object, opts?: ?Object): void
declare export function isTSRestType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSRestType)
declare export function assertTSRestType(node: ?Object, opts?: ?Object): void
declare export function isTSNamedTupleMember(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSNamedTupleMember)
declare export function assertTSNamedTupleMember(node: ?Object, opts?: ?Object): void
declare export function isTSUnionType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSUnionType)
declare export function assertTSUnionType(node: ?Object, opts?: ?Object): void
declare export function isTSIntersectionType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSIntersectionType)
declare export function assertTSIntersectionType(node: ?Object, opts?: ?Object): void
declare export function isTSConditionalType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSConditionalType)
declare export function assertTSConditionalType(node: ?Object, opts?: ?Object): void
declare export function isTSInferType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSInferType)
declare export function assertTSInferType(node: ?Object, opts?: ?Object): void
declare export function isTSParenthesizedType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSParenthesizedType)
declare export function assertTSParenthesizedType(node: ?Object, opts?: ?Object): void
declare export function isTSTypeOperator(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeOperator)
declare export function assertTSTypeOperator(node: ?Object, opts?: ?Object): void
declare export function isTSIndexedAccessType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSIndexedAccessType)
declare export function assertTSIndexedAccessType(node: ?Object, opts?: ?Object): void
declare export function isTSMappedType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSMappedType)
declare export function assertTSMappedType(node: ?Object, opts?: ?Object): void
declare export function isTSTemplateLiteralType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTemplateLiteralType)
declare export function assertTSTemplateLiteralType(node: ?Object, opts?: ?Object): void
declare export function isTSLiteralType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSLiteralType)
declare export function assertTSLiteralType(node: ?Object, opts?: ?Object): void
declare export function isTSExpressionWithTypeArguments(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSExpressionWithTypeArguments)
declare export function assertTSExpressionWithTypeArguments(node: ?Object, opts?: ?Object): void
declare export function isTSInterfaceDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSInterfaceDeclaration)
declare export function assertTSInterfaceDeclaration(node: ?Object, opts?: ?Object): void
declare export function isTSInterfaceBody(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSInterfaceBody)
declare export function assertTSInterfaceBody(node: ?Object, opts?: ?Object): void
declare export function isTSTypeAliasDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeAliasDeclaration)
declare export function assertTSTypeAliasDeclaration(node: ?Object, opts?: ?Object): void
declare export function isTSInstantiationExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSInstantiationExpression)
declare export function assertTSInstantiationExpression(node: ?Object, opts?: ?Object): void
declare export function isTSAsExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSAsExpression)
declare export function assertTSAsExpression(node: ?Object, opts?: ?Object): void
declare export function isTSSatisfiesExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSSatisfiesExpression)
declare export function assertTSSatisfiesExpression(node: ?Object, opts?: ?Object): void
declare export function isTSTypeAssertion(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeAssertion)
declare export function assertTSTypeAssertion(node: ?Object, opts?: ?Object): void
declare export function isTSEnumBody(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSEnumBody)
declare export function assertTSEnumBody(node: ?Object, opts?: ?Object): void
declare export function isTSEnumDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSEnumDeclaration)
declare export function assertTSEnumDeclaration(node: ?Object, opts?: ?Object): void
declare export function isTSEnumMember(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSEnumMember)
declare export function assertTSEnumMember(node: ?Object, opts?: ?Object): void
declare export function isTSModuleDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSModuleDeclaration)
declare export function assertTSModuleDeclaration(node: ?Object, opts?: ?Object): void
declare export function isTSModuleBlock(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSModuleBlock)
declare export function assertTSModuleBlock(node: ?Object, opts?: ?Object): void
declare export function isTSImportType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSImportType)
declare export function assertTSImportType(node: ?Object, opts?: ?Object): void
declare export function isTSImportEqualsDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSImportEqualsDeclaration)
declare export function assertTSImportEqualsDeclaration(node: ?Object, opts?: ?Object): void
declare export function isTSExternalModuleReference(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSExternalModuleReference)
declare export function assertTSExternalModuleReference(node: ?Object, opts?: ?Object): void
declare export function isTSNonNullExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSNonNullExpression)
declare export function assertTSNonNullExpression(node: ?Object, opts?: ?Object): void
declare export function isTSExportAssignment(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSExportAssignment)
declare export function assertTSExportAssignment(node: ?Object, opts?: ?Object): void
declare export function isTSNamespaceExportDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSNamespaceExportDeclaration)
declare export function assertTSNamespaceExportDeclaration(node: ?Object, opts?: ?Object): void
declare export function isTSTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeAnnotation)
declare export function assertTSTypeAnnotation(node: ?Object, opts?: ?Object): void
declare export function isTSTypeParameterInstantiation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeParameterInstantiation)
declare export function assertTSTypeParameterInstantiation(node: ?Object, opts?: ?Object): void
declare export function isTSTypeParameterDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeParameterDeclaration)
declare export function assertTSTypeParameterDeclaration(node: ?Object, opts?: ?Object): void
declare export function isTSTypeParameter(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeParameter)
declare export function assertTSTypeParameter(node: ?Object, opts?: ?Object): void
declare export function isStandardized(node: ?Object, opts?: ?Object): boolean
declare export function assertStandardized(node: ?Object, opts?: ?Object): void
declare export function isExpression(node: ?Object, opts?: ?Object): boolean
declare export function assertExpression(node: ?Object, opts?: ?Object): void
declare export function isBinary(node: ?Object, opts?: ?Object): boolean
declare export function assertBinary(node: ?Object, opts?: ?Object): void
declare export function isScopable(node: ?Object, opts?: ?Object): boolean
declare export function assertScopable(node: ?Object, opts?: ?Object): void
declare export function isBlockParent(node: ?Object, opts?: ?Object): boolean
declare export function assertBlockParent(node: ?Object, opts?: ?Object): void
declare export function isBlock(node: ?Object, opts?: ?Object): boolean
declare export function assertBlock(node: ?Object, opts?: ?Object): void
declare export function isStatement(node: ?Object, opts?: ?Object): boolean
declare export function assertStatement(node: ?Object, opts?: ?Object): void
declare export function isTerminatorless(node: ?Object, opts?: ?Object): boolean
declare export function assertTerminatorless(node: ?Object, opts?: ?Object): void
declare export function isCompletionStatement(node: ?Object, opts?: ?Object): boolean
declare export function assertCompletionStatement(node: ?Object, opts?: ?Object): void
declare export function isConditional(node: ?Object, opts?: ?Object): boolean
declare export function assertConditional(node: ?Object, opts?: ?Object): void
declare export function isLoop(node: ?Object, opts?: ?Object): boolean
declare export function assertLoop(node: ?Object, opts?: ?Object): void
declare export function isWhile(node: ?Object, opts?: ?Object): boolean
declare export function assertWhile(node: ?Object, opts?: ?Object): void
declare export function isExpressionWrapper(node: ?Object, opts?: ?Object): boolean
declare export function assertExpressionWrapper(node: ?Object, opts?: ?Object): void
declare export function isFor(node: ?Object, opts?: ?Object): boolean
declare export function assertFor(node: ?Object, opts?: ?Object): void
declare export function isForXStatement(node: ?Object, opts?: ?Object): boolean
declare export function assertForXStatement(node: ?Object, opts?: ?Object): void
declare export function isFunction(node: ?Object, opts?: ?Object): boolean
declare export function assertFunction(node: ?Object, opts?: ?Object): void
declare export function isFunctionParent(node: ?Object, opts?: ?Object): boolean
declare export function assertFunctionParent(node: ?Object, opts?: ?Object): void
declare export function isPureish(node: ?Object, opts?: ?Object): boolean
declare export function assertPureish(node: ?Object, opts?: ?Object): void
declare export function isDeclaration(node: ?Object, opts?: ?Object): boolean
declare export function assertDeclaration(node: ?Object, opts?: ?Object): void
declare export function isFunctionParameter(node: ?Object, opts?: ?Object): boolean
declare export function assertFunctionParameter(node: ?Object, opts?: ?Object): void
declare export function isPatternLike(node: ?Object, opts?: ?Object): boolean
declare export function assertPatternLike(node: ?Object, opts?: ?Object): void
declare export function isLVal(node: ?Object, opts?: ?Object): boolean
declare export function assertLVal(node: ?Object, opts?: ?Object): void
declare export function isTSEntityName(node: ?Object, opts?: ?Object): boolean
declare export function assertTSEntityName(node: ?Object, opts?: ?Object): void
declare export function isLiteral(node: ?Object, opts?: ?Object): boolean
declare export function assertLiteral(node: ?Object, opts?: ?Object): void
declare export function isImmutable(node: ?Object, opts?: ?Object): boolean
declare export function assertImmutable(node: ?Object, opts?: ?Object): void
declare export function isUserWhitespacable(node: ?Object, opts?: ?Object): boolean
declare export function assertUserWhitespacable(node: ?Object, opts?: ?Object): void
declare export function isMethod(node: ?Object, opts?: ?Object): boolean
declare export function assertMethod(node: ?Object, opts?: ?Object): void
declare export function isObjectMember(node: ?Object, opts?: ?Object): boolean
declare export function assertObjectMember(node: ?Object, opts?: ?Object): void
declare export function isProperty(node: ?Object, opts?: ?Object): boolean
declare export function assertProperty(node: ?Object, opts?: ?Object): void
declare export function isUnaryLike(node: ?Object, opts?: ?Object): boolean
declare export function assertUnaryLike(node: ?Object, opts?: ?Object): void
declare export function isPattern(node: ?Object, opts?: ?Object): boolean
declare export function assertPattern(node: ?Object, opts?: ?Object): void
declare export function isClass(node: ?Object, opts?: ?Object): boolean
declare export function assertClass(node: ?Object, opts?: ?Object): void
declare export function isImportOrExportDeclaration(node: ?Object, opts?: ?Object): boolean
declare export function assertImportOrExportDeclaration(node: ?Object, opts?: ?Object): void
declare export function isExportDeclaration(node: ?Object, opts?: ?Object): boolean
declare export function assertExportDeclaration(node: ?Object, opts?: ?Object): void
declare export function isModuleSpecifier(node: ?Object, opts?: ?Object): boolean
declare export function assertModuleSpecifier(node: ?Object, opts?: ?Object): void
declare export function isAccessor(node: ?Object, opts?: ?Object): boolean
declare export function assertAccessor(node: ?Object, opts?: ?Object): void
declare export function isPrivate(node: ?Object, opts?: ?Object): boolean
declare export function assertPrivate(node: ?Object, opts?: ?Object): void
declare export function isFlow(node: ?Object, opts?: ?Object): boolean
declare export function assertFlow(node: ?Object, opts?: ?Object): void
declare export function isFlowType(node: ?Object, opts?: ?Object): boolean
declare export function assertFlowType(node: ?Object, opts?: ?Object): void
declare export function isFlowBaseAnnotation(node: ?Object, opts?: ?Object): boolean
declare export function assertFlowBaseAnnotation(node: ?Object, opts?: ?Object): void
declare export function isFlowDeclaration(node: ?Object, opts?: ?Object): boolean
declare export function assertFlowDeclaration(node: ?Object, opts?: ?Object): void
declare export function isFlowPredicate(node: ?Object, opts?: ?Object): boolean
declare export function assertFlowPredicate(node: ?Object, opts?: ?Object): void
declare export function isEnumBody(node: ?Object, opts?: ?Object): boolean
declare export function assertEnumBody(node: ?Object, opts?: ?Object): void
declare export function isEnumMember(node: ?Object, opts?: ?Object): boolean
declare export function assertEnumMember(node: ?Object, opts?: ?Object): void
declare export function isJSX(node: ?Object, opts?: ?Object): boolean
declare export function assertJSX(node: ?Object, opts?: ?Object): void
declare export function isMiscellaneous(node: ?Object, opts?: ?Object): boolean
declare export function assertMiscellaneous(node: ?Object, opts?: ?Object): void
declare export function isTypeScript(node: ?Object, opts?: ?Object): boolean
declare export function assertTypeScript(node: ?Object, opts?: ?Object): void
declare export function isTSTypeElement(node: ?Object, opts?: ?Object): boolean
declare export function assertTSTypeElement(node: ?Object, opts?: ?Object): void
declare export function isTSType(node: ?Object, opts?: ?Object): boolean
declare export function assertTSType(node: ?Object, opts?: ?Object): void
declare export function isTSBaseType(node: ?Object, opts?: ?Object): boolean
declare export function assertTSBaseType(node: ?Object, opts?: ?Object): void
declare export function isModuleDeclaration(node: ?Object, opts?: ?Object): boolean
declare export function assertModuleDeclaration(node: ?Object, opts?: ?Object): void
declare export function isNumberLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNumericLiteral)
declare export function assertNumberLiteral(node: ?Object, opts?: ?Object): void
declare export function isRegexLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeRegExpLiteral)
declare export function assertRegexLiteral(node: ?Object, opts?: ?Object): void
declare export function isRestProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeRestElement)
declare export function assertRestProperty(node: ?Object, opts?: ?Object): void
declare export function isSpreadProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeSpreadElement)
declare export function assertSpreadProperty(node: ?Object, opts?: ?Object): void
declare export var VISITOR_KEYS: { [type: string]: string[] }
declare export function assertNode(obj: any): void
declare export function createTypeAnnotationBasedOnTypeof(type: 'string' | 'number' | 'undefined' | 'boolean' | 'function' | 'object' | 'symbol'): BabelNodeTypeAnnotation
declare export function createUnionTypeAnnotation(types: Array<BabelNodeFlowType>): BabelNodeUnionTypeAnnotation
declare export function createFlowUnionType(types: Array<BabelNodeFlowType>): BabelNodeUnionTypeAnnotation
declare export function buildChildren(node: { children: Array<BabelNodeJSXText | BabelNodeJSXExpressionContainer | BabelNodeJSXSpreadChild | BabelNodeJSXElement | BabelNodeJSXFragment | BabelNodeJSXEmptyExpression> }): Array<BabelNodeJSXText | BabelNodeJSXExpressionContainer | BabelNodeJSXSpreadChild | BabelNodeJSXElement | BabelNodeJSXFragment>
declare export function clone<T>(n: T): T;
declare export function cloneDeep<T>(n: T): T;
declare export function cloneDeepWithoutLoc<T>(n: T): T;
declare export function cloneNode<T>(n: T, deep?: boolean, withoutLoc?: boolean): T;
declare export function cloneWithoutLoc<T>(n: T): T;
declare type CommentTypeShorthand = 'leading' | 'inner' | 'trailing'
declare export function addComment<T: BabelNode>(node: T, type: CommentTypeShorthand, content: string, line?: boolean): T
declare export function addComments<T: BabelNode>(node: T, type: CommentTypeShorthand, comments: Array<Comment>): T
declare export function inheritInnerComments(node: BabelNode, parent: BabelNode): void
declare export function inheritLeadingComments(node: BabelNode, parent: BabelNode): void
declare export function inheritsComments<T: BabelNode>(node: T, parent: BabelNode): void
declare export function inheritTrailingComments(node: BabelNode, parent: BabelNode): void
declare export function removeComments<T: BabelNode>(node: T): T
declare export function ensureBlock(node: BabelNode, key: string): BabelNodeBlockStatement
declare export function toBindingIdentifierName(name?: ?string): string
declare export function toBlock(node: BabelNodeStatement | BabelNodeExpression, parent?: BabelNodeFunction | null): BabelNodeBlockStatement
declare export function toComputedKey(node: BabelNodeMethod | BabelNodeProperty, key?: BabelNodeExpression | BabelNodeIdentifier): BabelNodeExpression
declare export function toExpression(node: BabelNodeExpressionStatement | BabelNodeExpression | BabelNodeClass | BabelNodeFunction): BabelNodeExpression
declare export function toIdentifier(name?: ?string): string
declare export function toKeyAlias(node: BabelNodeMethod | BabelNodeProperty, key?: BabelNode): string
declare export function toStatement(node: BabelNodeStatement | BabelNodeClass | BabelNodeFunction | BabelNodeAssignmentExpression, ignore?: boolean): BabelNodeStatement | void
declare export function valueToNode(value: any): BabelNodeExpression
declare export function removeTypeDuplicates(types: Array<BabelNodeFlowType>): Array<BabelNodeFlowType>
declare export function appendToMemberExpression(member: BabelNodeMemberExpression, append: BabelNode, computed?: boolean): BabelNodeMemberExpression
declare export function inherits<T: BabelNode>(child: T, parent: BabelNode | null | void): T
declare export function prependToMemberExpression(member: BabelNodeMemberExpression, prepend: BabelNodeExpression): BabelNodeMemberExpression
declare export function removeProperties<T>(n: T, opts: ?{}): void;
declare export function removePropertiesDeep<T>(n: T, opts: ?{}): T;
declare export var getBindingIdentifiers: {
(node: BabelNode, duplicates?: boolean, outerOnly?: boolean): { [key: string]: BabelNodeIdentifier | Array<BabelNodeIdentifier> },
keys: { [type: string]: string[] }
}
declare export function getOuterBindingIdentifiers(node: BabelNode, duplicates?: boolean): { [key: string]: BabelNodeIdentifier | Array<BabelNodeIdentifier> }
declare type TraversalAncestors = Array<{
node: BabelNode,
key: string,
index?: number,
}>;
declare type TraversalHandler<T> = (BabelNode, TraversalAncestors, T) => void;
declare type TraversalHandlers<T> = {
enter?: TraversalHandler<T>,
exit?: TraversalHandler<T>,
};
declare export function traverse<T>(n: BabelNode, TraversalHandler<T> | TraversalHandlers<T>, state?: T): void;
declare export function traverseFast<T>(n: BabelNode, h: TraversalHandler<T>, state?: T): void;
declare export function shallowEqual(actual: Object, expected: Object): boolean
declare export function buildMatchMemberExpression(match: string, allowPartial?: boolean): (?BabelNode) => boolean
declare export function is(type: string, n: BabelNode, opts: Object): boolean;
declare export function isBinding(node: BabelNode, parent: BabelNode, grandparent?: BabelNode): boolean
declare export function isBlockScoped(node: BabelNode): boolean
declare export function isImmutable(node: BabelNode): boolean
declare export function isLet(node: BabelNode): boolean
declare export function isNode(node: ?Object): boolean
declare export function isNodesEquivalent(a: any, b: any): boolean
declare export function isPlaceholderType(placeholderType: string, targetType: string): boolean
declare export function isReferenced(node: BabelNode, parent: BabelNode, grandparent?: BabelNode): boolean
declare export function isScope(node: BabelNode, parent: BabelNode): boolean
declare export function isSpecifierDefault(specifier: BabelNodeModuleSpecifier): boolean
declare export function isType(nodetype: ?string, targetType: string): boolean
declare export function isValidES3Identifier(name: string): boolean
declare export function isValidES3Identifier(name: string): boolean
declare export function isValidIdentifier(name: string): boolean
declare export function isVar(node: BabelNode): boolean
declare export function matchesPattern(node: ?BabelNode, match: string | Array<string>, allowPartial?: boolean): boolean
declare export function validate(n: BabelNode, key: string, value: mixed): void;
}
\ No newline at end of file
node_modules/@babel/types/lib/index.js.map 0 → 100644
View file @ 956c501c
{"version":3,"names":["_isReactComponent","require","_isCompatTag","_buildChildren","_assertNode","_index","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_createTypeAnnotationBasedOnTypeof","_createFlowUnionType","_createTSUnionType","_productions","_index2","_cloneNode","_clone","_cloneDeep","_cloneDeepWithoutLoc","_cloneWithoutLoc","_addComment","_addComments","_inheritInnerComments","_inheritLeadingComments","_inheritsComments","_inheritTrailingComments","_removeComments","_index3","_index4","_ensureBlock","_toBindingIdentifierName","_toBlock","_toComputedKey","_toExpression","_toIdentifier","_toKeyAlias","_toStatement","_valueToNode","_index5","_appendToMemberExpression","_inherits","_prependToMemberExpression","_removeProperties","_removePropertiesDeep","_removeTypeDuplicates","_getAssignmentIdentifiers","_getBindingIdentifiers","_getOuterBindingIdentifiers","_getFunctionName","_traverse","_traverseFast","_shallowEqual","_is","_isBinding","_isBlockScoped","_isImmutable","_isLet","_isNode","_isNodesEquivalent","_isPlaceholderType","_isReferenced","_isScope","_isSpecifierDefault","_isType","_isValidES3Identifier","_isValidIdentifier","_isVar","_matchesPattern","_validate","_buildMatchMemberExpression","_index6","_deprecationWarning","_toSequenceExpression","react","isReactComponent","isCompatTag","buildChildren","toSequenceExpression","process","env","BABEL_TYPES_8_BREAKING","console","warn"],"sources":["../src/index.ts"],"sourcesContent":["import isReactComponent from \"./validators/react/isReactComponent.ts\";\nimport isCompatTag from \"./validators/react/isCompatTag.ts\";\nimport buildChildren from \"./builders/react/buildChildren.ts\";\n\n// asserts\nexport { default as assertNode } from \"./asserts/assertNode.ts\";\nexport * from \"./asserts/generated/index.ts\";\n\n// builders\nexport { default as createTypeAnnotationBasedOnTypeof } from \"./builders/flow/createTypeAnnotationBasedOnTypeof.ts\";\n/** @deprecated use createFlowUnionType instead */\nexport { default as createUnionTypeAnnotation } from \"./builders/flow/createFlowUnionType.ts\";\nexport { default as createFlowUnionType } from \"./builders/flow/createFlowUnionType.ts\";\nexport { default as createTSUnionType } from \"./builders/typescript/createTSUnionType.ts\";\nexport * from \"./builders/productions.ts\";\nexport * from \"./builders/generated/index.ts\"; // includes AST types\n\n// clone\nexport { default as cloneNode } from \"./clone/cloneNode.ts\";\nexport { default as clone } from \"./clone/clone.ts\";\nexport { default as cloneDeep } from \"./clone/cloneDeep.ts\";\nexport { default as cloneDeepWithoutLoc } from \"./clone/cloneDeepWithoutLoc.ts\";\nexport { default as cloneWithoutLoc } from \"./clone/cloneWithoutLoc.ts\";\n\n// comments\nexport { default as addComment } from \"./comments/addComment.ts\";\nexport { default as addComments } from \"./comments/addComments.ts\";\nexport { default as inheritInnerComments } from \"./comments/inheritInnerComments.ts\";\nexport { default as inheritLeadingComments } from \"./comments/inheritLeadingComments.ts\";\nexport { default as inheritsComments } from \"./comments/inheritsComments.ts\";\nexport { default as inheritTrailingComments } from \"./comments/inheritTrailingComments.ts\";\nexport { default as removeComments } from \"./comments/removeComments.ts\";\n\n// constants\nexport * from \"./constants/generated/index.ts\";\nexport * from \"./constants/index.ts\";\n\n// converters\nexport { default as ensureBlock } from \"./converters/ensureBlock.ts\";\nexport { default as toBindingIdentifierName } from \"./converters/toBindingIdentifierName.ts\";\nexport { default as toBlock } from \"./converters/toBlock.ts\";\nexport { default as toComputedKey } from \"./converters/toComputedKey.ts\";\nexport { default as toExpression } from \"./converters/toExpression.ts\";\nexport { default as toIdentifier } from \"./converters/toIdentifier.ts\";\nexport { default as toKeyAlias } from \"./converters/toKeyAlias.ts\";\nexport { default as toStatement } from \"./converters/toStatement.ts\";\nexport { default as valueToNode } from \"./converters/valueToNode.ts\";\n\n// definitions\nexport * from \"./definitions/index.ts\";\n\n// modifications\nexport { default as appendToMemberExpression } from \"./modifications/appendToMemberExpression.ts\";\nexport { default as inherits } from \"./modifications/inherits.ts\";\nexport { default as prependToMemberExpression } from \"./modifications/prependToMemberExpression.ts\";\nexport {\n default as removeProperties,\n type Options as RemovePropertiesOptions,\n} from \"./modifications/removeProperties.ts\";\nexport { default as removePropertiesDeep } from \"./modifications/removePropertiesDeep.ts\";\nexport { default as removeTypeDuplicates } from \"./modifications/flow/removeTypeDuplicates.ts\";\n\n// retrievers\nexport { default as getAssignmentIdentifiers } from \"./retrievers/getAssignmentIdentifiers.ts\";\nexport { default as getBindingIdentifiers } from \"./retrievers/getBindingIdentifiers.ts\";\nexport { default as getOuterBindingIdentifiers } from \"./retrievers/getOuterBindingIdentifiers.ts\";\nexport { default as getFunctionName } from \"./retrievers/getFunctionName.ts\";\n\n// traverse\nexport { default as traverse } from \"./traverse/traverse.ts\";\nexport * from \"./traverse/traverse.ts\";\nexport { default as traverseFast } from \"./traverse/traverseFast.ts\";\n\n// utils\nexport { default as shallowEqual } from \"./utils/shallowEqual.ts\";\n\n// validators\nexport { default as is } from \"./validators/is.ts\";\nexport { default as isBinding } from \"./validators/isBinding.ts\";\nexport { default as isBlockScoped } from \"./validators/isBlockScoped.ts\";\nexport { default as isImmutable } from \"./validators/isImmutable.ts\";\nexport { default as isLet } from \"./validators/isLet.ts\";\nexport { default as isNode } from \"./validators/isNode.ts\";\nexport { default as isNodesEquivalent } from \"./validators/isNodesEquivalent.ts\";\nexport { default as isPlaceholderType } from \"./validators/isPlaceholderType.ts\";\nexport { default as isReferenced } from \"./validators/isReferenced.ts\";\nexport { default as isScope } from \"./validators/isScope.ts\";\nexport { default as isSpecifierDefault } from \"./validators/isSpecifierDefault.ts\";\nexport { default as isType } from \"./validators/isType.ts\";\nexport { default as isValidES3Identifier } from \"./validators/isValidES3Identifier.ts\";\nexport { default as isValidIdentifier } from \"./validators/isValidIdentifier.ts\";\nexport { default as isVar } from \"./validators/isVar.ts\";\nexport { default as matchesPattern } from \"./validators/matchesPattern.ts\";\nexport { default as validate } from \"./validators/validate.ts\";\nexport { default as buildMatchMemberExpression } from \"./validators/buildMatchMemberExpression.ts\";\nexport * from \"./validators/generated/index.ts\";\n\n// react\nexport const react = {\n isReactComponent,\n isCompatTag,\n buildChildren,\n};\n\n// this is used by @babel/traverse to warn about deprecated visitors\nexport { default as __internal__deprecationWarning } from \"./utils/deprecationWarning.ts\";\n\nimport toSequenceExpression from \"./converters/toSequenceExpression.ts\" with { if: \"!process.env.BABEL_8_BREAKING && !USE_ESM && !IS_STANDALONE\" };\nif (!process.env.BABEL_8_BREAKING && !USE_ESM && !IS_STANDALONE) {\n // eslint-disable-next-line no-restricted-globals\n exports.toSequenceExpression = toSequenceExpression;\n}\n\nif (!process.env.BABEL_8_BREAKING && process.env.BABEL_TYPES_8_BREAKING) {\n console.warn(\n \"BABEL_TYPES_8_BREAKING is not supported anymore. Use the latest Babel 8.0.0 pre-release instead!\",\n );\n}\n"],"mappings":"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","ignoreList":[]}
\ No newline at end of file
node_modules/@babel/types/lib/modifications/appendToMemberExpression.js 0 → 100644
View file @ 956c501c
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = appendToMemberExpression;
var _index = require("../builders/generated/index.js");
function appendToMemberExpression(member, append, computed = false) {
member.object = (0, _index.memberExpression)(member.object, member.property, member.computed);
member.property = append;
member.computed = !!computed;
return member;
}
//# sourceMappingURL=appendToMemberExpression.js.map
node_modules/@babel/types/lib/modifications/appendToMemberExpression.js.map 0 → 100644
View file @ 956c501c
{"version":3,"names":["_index","require","appendToMemberExpression","member","append","computed","object","memberExpression","property"],"sources":["../../src/modifications/appendToMemberExpression.ts"],"sourcesContent":["import { memberExpression } from \"../builders/generated/index.ts\";\nimport type * as t from \"../index.ts\";\n\n/**\n * Append a node to a member expression.\n */\nexport default function appendToMemberExpression(\n member: t.MemberExpression,\n append: t.MemberExpression[\"property\"],\n computed: boolean = false,\n): t.MemberExpression {\n member.object = memberExpression(\n member.object,\n member.property,\n member.computed,\n );\n member.property = append;\n member.computed = !!computed;\n\n return member;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAMe,SAASC,wBAAwBA,CAC9CC,MAA0B,EAC1BC,MAAsC,EACtCC,QAAiB,GAAG,KAAK,EACL;EACpBF,MAAM,CAACG,MAAM,GAAG,IAAAC,uBAAgB,EAC9BJ,MAAM,CAACG,MAAM,EACbH,MAAM,CAACK,QAAQ,EACfL,MAAM,CAACE,QACT,CAAC;EACDF,MAAM,CAACK,QAAQ,GAAGJ,MAAM;EACxBD,MAAM,CAACE,QAAQ,GAAG,CAAC,CAACA,QAAQ;EAE5B,OAAOF,MAAM;AACf","ignoreList":[]}
\ No newline at end of file
node_modules/@babel/types/lib/modifications/flow/removeTypeDuplicates.js 0 → 100644
View file @ 956c501c
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = removeTypeDuplicates;
var _index = require("../../validators/generated/index.js");
function getQualifiedName(node) {
return (0, _index.isIdentifier)(node) ? node.name : `${node.id.name}.${getQualifiedName(node.qualification)}`;
}
function removeTypeDuplicates(nodesIn) {
const nodes = Array.from(nodesIn);
const generics = new Map();
const bases = new Map();
const typeGroups = new Set();
const types = [];
for (let i = 0; i < nodes.length; i++) {
const node = nodes[i];
if (!node) continue;
if (types.includes(node)) {
continue;
}
if ((0, _index.isAnyTypeAnnotation)(node)) {
return [node];
}
if ((0, _index.isFlowBaseAnnotation)(node)) {
bases.set(node.type, node);
continue;
}
if ((0, _index.isUnionTypeAnnotation)(node)) {
if (!typeGroups.has(node.types)) {
nodes.push(...node.types);
typeGroups.add(node.types);
}
continue;
}
if ((0, _index.isGenericTypeAnnotation)(node)) {
const name = getQualifiedName(node.id);
if (generics.has(name)) {
let existing = generics.get(name);
if (existing.typeParameters) {
if (node.typeParameters) {
existing.typeParameters.params.push(...node.typeParameters.params);
existing.typeParameters.params = removeTypeDuplicates(existing.typeParameters.params);
}
} else {
existing = node.typeParameters;
}
} else {
generics.set(name, node);
}
continue;
}
types.push(node);
}
for (const [, baseType] of bases) {
types.push(baseType);
}
for (const [, genericName] of generics) {
types.push(genericName);
}
return types;
}
//# sourceMappingURL=removeTypeDuplicates.js.map
node_modules/@babel/types/lib/modifications/flow/removeTypeDuplicates.js.map 0 → 100644
View file @ 956c501c
{"version":3,"names":["_index","require","getQualifiedName","node","isIdentifier","name","id","qualification","removeTypeDuplicates","nodesIn","nodes","Array","from","generics","Map","bases","typeGroups","Set","types","i","length","includes","isAnyTypeAnnotation","isFlowBaseAnnotation","set","type","isUnionTypeAnnotation","has","push","add","isGenericTypeAnnotation","existing","get","typeParameters","params","baseType","genericName"],"sources":["../../../src/modifications/flow/removeTypeDuplicates.ts"],"sourcesContent":["import {\n isAnyTypeAnnotation,\n isGenericTypeAnnotation,\n isUnionTypeAnnotation,\n isFlowBaseAnnotation,\n isIdentifier,\n} from \"../../validators/generated/index.ts\";\nimport type * as t from \"../../index.ts\";\n\nfunction getQualifiedName(node: t.GenericTypeAnnotation[\"id\"]): string {\n return isIdentifier(node)\n ? node.name\n : `${node.id.name}.${getQualifiedName(node.qualification)}`;\n}\n\n/**\n * Dedupe type annotations.\n */\nexport default function removeTypeDuplicates(\n nodesIn: ReadonlyArray<t.FlowType | false | null | undefined>,\n): t.FlowType[] {\n const nodes = Array.from(nodesIn);\n\n const generics = new Map<string, t.GenericTypeAnnotation>();\n const bases = new Map<t.FlowBaseAnnotation[\"type\"], t.FlowBaseAnnotation>();\n\n // store union type groups to circular references\n const typeGroups = new Set<t.FlowType[]>();\n\n const types: t.FlowType[] = [];\n\n for (let i = 0; i < nodes.length; i++) {\n const node = nodes[i];\n if (!node) continue;\n\n // detect duplicates\n if (types.includes(node)) {\n continue;\n }\n\n // this type matches anything\n if (isAnyTypeAnnotation(node)) {\n return [node];\n }\n\n if (isFlowBaseAnnotation(node)) {\n bases.set(node.type, node);\n continue;\n }\n\n if (isUnionTypeAnnotation(node)) {\n if (!typeGroups.has(node.types)) {\n nodes.push(...node.types);\n typeGroups.add(node.types);\n }\n continue;\n }\n\n // find a matching generic type and merge and deduplicate the type parameters\n if (isGenericTypeAnnotation(node)) {\n const name = getQualifiedName(node.id);\n\n if (generics.has(name)) {\n let existing: t.Flow = generics.get(name);\n if (existing.typeParameters) {\n if (node.typeParameters) {\n existing.typeParameters.params.push(...node.typeParameters.params);\n existing.typeParameters.params = removeTypeDuplicates(\n existing.typeParameters.params,\n );\n }\n } else {\n existing = node.typeParameters;\n }\n } else {\n generics.set(name, node);\n }\n\n continue;\n }\n\n types.push(node);\n }\n\n // add back in bases\n for (const [, baseType] of bases) {\n types.push(baseType);\n }\n\n // add back in generics\n for (const [, genericName] of generics) {\n types.push(genericName);\n }\n\n return types;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AASA,SAASC,gBAAgBA,CAACC,IAAmC,EAAU;EACrE,OAAO,IAAAC,mBAAY,EAACD,IAAI,CAAC,GACrBA,IAAI,CAACE,IAAI,GACT,GAAGF,IAAI,CAACG,EAAE,CAACD,IAAI,IAAIH,gBAAgB,CAACC,IAAI,CAACI,aAAa,CAAC,EAAE;AAC/D;AAKe,SAASC,oBAAoBA,CAC1CC,OAA6D,EAC/C;EACd,MAAMC,KAAK,GAAGC,KAAK,CAACC,IAAI,CAACH,OAAO,CAAC;EAEjC,MAAMI,QAAQ,GAAG,IAAIC,GAAG,CAAkC,CAAC;EAC3D,MAAMC,KAAK,GAAG,IAAID,GAAG,CAAqD,CAAC;EAG3E,MAAME,UAAU,GAAG,IAAIC,GAAG,CAAe,CAAC;EAE1C,MAAMC,KAAmB,GAAG,EAAE;EAE9B,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGT,KAAK,CAACU,MAAM,EAAED,CAAC,EAAE,EAAE;IACrC,MAAMhB,IAAI,GAAGO,KAAK,CAACS,CAAC,CAAC;IACrB,IAAI,CAAChB,IAAI,EAAE;IAGX,IAAIe,KAAK,CAACG,QAAQ,CAAClB,IAAI,CAAC,EAAE;MACxB;IACF;IAGA,IAAI,IAAAmB,0BAAmB,EAACnB,IAAI,CAAC,EAAE;MAC7B,OAAO,CAACA,IAAI,CAAC;IACf;IAEA,IAAI,IAAAoB,2BAAoB,EAACpB,IAAI,CAAC,EAAE;MAC9BY,KAAK,CAACS,GAAG,CAACrB,IAAI,CAACsB,IAAI,EAAEtB,IAAI,CAAC;MAC1B;IACF;IAEA,IAAI,IAAAuB,4BAAqB,EAACvB,IAAI,CAAC,EAAE;MAC/B,IAAI,CAACa,UAAU,CAACW,GAAG,CAACxB,IAAI,CAACe,KAAK,CAAC,EAAE;QAC/BR,KAAK,CAACkB,IAAI,CAAC,GAAGzB,IAAI,CAACe,KAAK,CAAC;QACzBF,UAAU,CAACa,GAAG,CAAC1B,IAAI,CAACe,KAAK,CAAC;MAC5B;MACA;IACF;IAGA,IAAI,IAAAY,8BAAuB,EAAC3B,IAAI,CAAC,EAAE;MACjC,MAAME,IAAI,GAAGH,gBAAgB,CAACC,IAAI,CAACG,EAAE,CAAC;MAEtC,IAAIO,QAAQ,CAACc,GAAG,CAACtB,IAAI,CAAC,EAAE;QACtB,IAAI0B,QAAgB,GAAGlB,QAAQ,CAACmB,GAAG,CAAC3B,IAAI,CAAC;QACzC,IAAI0B,QAAQ,CAACE,cAAc,EAAE;UAC3B,IAAI9B,IAAI,CAAC8B,cAAc,EAAE;YACvBF,QAAQ,CAACE,cAAc,CAACC,MAAM,CAACN,IAAI,CAAC,GAAGzB,IAAI,CAAC8B,cAAc,CAACC,MAAM,CAAC;YAClEH,QAAQ,CAACE,cAAc,CAACC,MAAM,GAAG1B,oBAAoB,CACnDuB,QAAQ,CAACE,cAAc,CAACC,MAC1B,CAAC;UACH;QACF,CAAC,MAAM;UACLH,QAAQ,GAAG5B,IAAI,CAAC8B,cAAc;QAChC;MACF,CAAC,MAAM;QACLpB,QAAQ,CAACW,GAAG,CAACnB,IAAI,EAAEF,IAAI,CAAC;MAC1B;MAEA;IACF;IAEAe,KAAK,CAACU,IAAI,CAACzB,IAAI,CAAC;EAClB;EAGA,KAAK,MAAM,GAAGgC,QAAQ,CAAC,IAAIpB,KAAK,EAAE;IAChCG,KAAK,CAACU,IAAI,CAACO,QAAQ,CAAC;EACtB;EAGA,KAAK,MAAM,GAAGC,WAAW,CAAC,IAAIvB,QAAQ,EAAE;IACtCK,KAAK,CAACU,IAAI,CAACQ,WAAW,CAAC;EACzB;EAEA,OAAOlB,KAAK;AACd","ignoreList":[]}
\ No newline at end of file
node_modules/@babel/types/lib/modifications/inherits.js 0 → 100644
View file @ 956c501c
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = inherits;
var _index = require("../constants/index.js");
var _inheritsComments = require("../comments/inheritsComments.js");
function inherits(child, parent) {
if (!child || !parent) return child;
for (const key of _index.INHERIT_KEYS.optional) {
if (child[key] == null) {
child[key] = parent[key];
}
}
for (const key of Object.keys(parent)) {
if (key[0] === "_" && key !== "__clone") {
child[key] = parent[key];
}
}
for (const key of _index.INHERIT_KEYS.force) {
child[key] = parent[key];
}
(0, _inheritsComments.default)(child, parent);
return child;
}
//# sourceMappingURL=inherits.js.map
node_modules/@babel/types/lib/modifications/inherits.js.map 0 → 100644
View file @ 956c501c
{"version":3,"names":["_index","require","_inheritsComments","inherits","child","parent","key","INHERIT_KEYS","optional","Object","keys","force","inheritsComments"],"sources":["../../src/modifications/inherits.ts"],"sourcesContent":["import { INHERIT_KEYS } from \"../constants/index.ts\";\nimport inheritsComments from \"../comments/inheritsComments.ts\";\nimport type * as t from \"../index.ts\";\n\n/**\n * Inherit all contextual properties from `parent` node to `child` node.\n */\nexport default function inherits<T extends t.Node | null | undefined>(\n child: T,\n parent: t.Node | null | undefined,\n): T {\n if (!child || !parent) return child;\n\n // optionally inherit specific properties if not null\n for (const key of INHERIT_KEYS.optional) {\n // @ts-expect-error Fixme: refine parent types\n if (child[key] == null) {\n // @ts-expect-error Fixme: refine parent types\n child[key] = parent[key];\n }\n }\n\n // force inherit \"private\" properties\n for (const key of Object.keys(parent)) {\n if (key[0] === \"_\" && key !== \"__clone\") {\n // @ts-expect-error Fixme: refine parent types\n child[key] = parent[key];\n }\n }\n\n // force inherit select properties\n for (const key of INHERIT_KEYS.force) {\n // @ts-expect-error Fixme: refine parent types\n child[key] = parent[key];\n }\n\n inheritsComments(child, parent);\n\n return child;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,iBAAA,GAAAD,OAAA;AAMe,SAASE,QAAQA,CAC9BC,KAAQ,EACRC,MAAiC,EAC9B;EACH,IAAI,CAACD,KAAK,IAAI,CAACC,MAAM,EAAE,OAAOD,KAAK;EAGnC,KAAK,MAAME,GAAG,IAAIC,mBAAY,CAACC,QAAQ,EAAE;IAEvC,IAAIJ,KAAK,CAACE,GAAG,CAAC,IAAI,IAAI,EAAE;MAEtBF,KAAK,CAACE,GAAG,CAAC,GAAGD,MAAM,CAACC,GAAG,CAAC;IAC1B;EACF;EAGA,KAAK,MAAMA,GAAG,IAAIG,MAAM,CAACC,IAAI,CAACL,MAAM,CAAC,EAAE;IACrC,IAAIC,GAAG,CAAC,CAAC,CAAC,KAAK,GAAG,IAAIA,GAAG,KAAK,SAAS,EAAE;MAEvCF,KAAK,CAACE,GAAG,CAAC,GAAGD,MAAM,CAACC,GAAG,CAAC;IAC1B;EACF;EAGA,KAAK,MAAMA,GAAG,IAAIC,mBAAY,CAACI,KAAK,EAAE;IAEpCP,KAAK,CAACE,GAAG,CAAC,GAAGD,MAAM,CAACC,GAAG,CAAC;EAC1B;EAEA,IAAAM,yBAAgB,EAACR,KAAK,EAAEC,MAAM,CAAC;EAE/B,OAAOD,KAAK;AACd","ignoreList":[]}
\ No newline at end of file
node_modules/@babel/types/lib/modifications/prependToMemberExpression.js 0 → 100644
View file @ 956c501c
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = prependToMemberExpression;
var _index = require("../builders/generated/index.js");
var _index2 = require("../index.js");
function prependToMemberExpression(member, prepend) {
if ((0, _index2.isSuper)(member.object)) {
throw new Error("Cannot prepend node to super property access (`super.foo`).");
}
member.object = (0, _index.memberExpression)(prepend, member.object);
return member;
}
//# sourceMappingURL=prependToMemberExpression.js.map
node_modules/@babel/types/lib/modifications/prependToMemberExpression.js.map 0 → 100644
View file @ 956c501c
{"version":3,"names":["_index","require","_index2","prependToMemberExpression","member","prepend","isSuper","object","Error","memberExpression"],"sources":["../../src/modifications/prependToMemberExpression.ts"],"sourcesContent":["import { memberExpression } from \"../builders/generated/index.ts\";\nimport { isSuper } from \"../index.ts\";\nimport type * as t from \"../index.ts\";\n\n/**\n * Prepend a node to a member expression.\n */\nexport default function prependToMemberExpression<\n T extends Pick<t.MemberExpression, \"object\" | \"property\">,\n>(member: T, prepend: t.MemberExpression[\"object\"]): T {\n if (isSuper(member.object)) {\n throw new Error(\n \"Cannot prepend node to super property access (`super.foo`).\",\n );\n }\n member.object = memberExpression(prepend, member.object);\n\n return member;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AAMe,SAASE,yBAAyBA,CAE/CC,MAAS,EAAEC,OAAqC,EAAK;EACrD,IAAI,IAAAC,eAAO,EAACF,MAAM,CAACG,MAAM,CAAC,EAAE;IAC1B,MAAM,IAAIC,KAAK,CACb,6DACF,CAAC;EACH;EACAJ,MAAM,CAACG,MAAM,GAAG,IAAAE,uBAAgB,EAACJ,OAAO,EAAED,MAAM,CAACG,MAAM,CAAC;EAExD,OAAOH,MAAM;AACf","ignoreList":[]}
\ No newline at end of file
node_modules/@babel/types/lib/modifications/removeProperties.js 0 → 100644
View file @ 956c501c
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = removeProperties;
var _index = require("../constants/index.js");
const CLEAR_KEYS = ["tokens", "start", "end", "loc", "raw", "rawValue"];
const CLEAR_KEYS_PLUS_COMMENTS = [..._index.COMMENT_KEYS, "comments", ...CLEAR_KEYS];
function removeProperties(node, opts = {}) {
const map = opts.preserveComments ? CLEAR_KEYS : CLEAR_KEYS_PLUS_COMMENTS;
for (const key of map) {
if (node[key] != null) node[key] = undefined;
}
for (const key of Object.keys(node)) {
if (key[0] === "_" && node[key] != null) node[key] = undefined;
}
const symbols = Object.getOwnPropertySymbols(node);
for (const sym of symbols) {
node[sym] = null;
}
}
//# sourceMappingURL=removeProperties.js.map
node_modules/@babel/types/lib/modifications/removeProperties.js.map 0 → 100644
View file @ 956c501c
{"version":3,"names":["_index","require","CLEAR_KEYS","CLEAR_KEYS_PLUS_COMMENTS","COMMENT_KEYS","removeProperties","node","opts","map","preserveComments","key","undefined","Object","keys","symbols","getOwnPropertySymbols","sym"],"sources":["../../src/modifications/removeProperties.ts"],"sourcesContent":["import { COMMENT_KEYS } from \"../constants/index.ts\";\nimport type * as t from \"../index.ts\";\n\nconst CLEAR_KEYS = [\n \"tokens\", // only exist in t.File\n \"start\",\n \"end\",\n \"loc\",\n // Fixme: should be extra.raw / extra.rawValue?\n \"raw\",\n \"rawValue\",\n] as const;\n\nconst CLEAR_KEYS_PLUS_COMMENTS = [\n ...COMMENT_KEYS,\n \"comments\",\n ...CLEAR_KEYS,\n] as const;\n\nexport type Options = { preserveComments?: boolean };\n/**\n * Remove all of the _* properties from a node along with the additional metadata\n * properties like location data and raw token data.\n */\nexport default function removeProperties(\n node: t.Node,\n opts: Options = {},\n): void {\n const map = opts.preserveComments ? CLEAR_KEYS : CLEAR_KEYS_PLUS_COMMENTS;\n for (const key of map) {\n // @ts-expect-error tokens only exist in t.File\n if (node[key] != null) node[key] = undefined;\n }\n\n for (const key of Object.keys(node)) {\n // @ts-expect-error string can not index node\n if (key[0] === \"_\" && node[key] != null) node[key] = undefined;\n }\n\n const symbols: Array<symbol> = Object.getOwnPropertySymbols(node);\n for (const sym of symbols) {\n // @ts-expect-error Fixme: document symbol properties\n node[sym] = null;\n }\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAGA,MAAMC,UAAU,GAAG,CACjB,QAAQ,EACR,OAAO,EACP,KAAK,EACL,KAAK,EAEL,KAAK,EACL,UAAU,CACF;AAEV,MAAMC,wBAAwB,GAAG,CAC/B,GAAGC,mBAAY,EACf,UAAU,EACV,GAAGF,UAAU,CACL;AAOK,SAASG,gBAAgBA,CACtCC,IAAY,EACZC,IAAa,GAAG,CAAC,CAAC,EACZ;EACN,MAAMC,GAAG,GAAGD,IAAI,CAACE,gBAAgB,GAAGP,UAAU,GAAGC,wBAAwB;EACzE,KAAK,MAAMO,GAAG,IAAIF,GAAG,EAAE;IAErB,IAAIF,IAAI,CAACI,GAAG,CAAC,IAAI,IAAI,EAAEJ,IAAI,CAACI,GAAG,CAAC,GAAGC,SAAS;EAC9C;EAEA,KAAK,MAAMD,GAAG,IAAIE,MAAM,CAACC,IAAI,CAACP,IAAI,CAAC,EAAE;IAEnC,IAAII,GAAG,CAAC,CAAC,CAAC,KAAK,GAAG,IAAIJ,IAAI,CAACI,GAAG,CAAC,IAAI,IAAI,EAAEJ,IAAI,CAACI,GAAG,CAAC,GAAGC,SAAS;EAChE;EAEA,MAAMG,OAAsB,GAAGF,MAAM,CAACG,qBAAqB,CAACT,IAAI,CAAC;EACjE,KAAK,MAAMU,GAAG,IAAIF,OAAO,EAAE;IAEzBR,IAAI,CAACU,GAAG,CAAC,GAAG,IAAI;EAClB;AACF","ignoreList":[]}
\ No newline at end of file
node_modules/@babel/types/lib/modifications/removePropertiesDeep.js 0 → 100644
View file @ 956c501c
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = removePropertiesDeep;
var _traverseFast = require("../traverse/traverseFast.js");
var _removeProperties = require("./removeProperties.js");
function removePropertiesDeep(tree, opts) {
(0, _traverseFast.default)(tree, _removeProperties.default, opts);
return tree;
}
//# sourceMappingURL=removePropertiesDeep.js.map
node_modules/@babel/types/lib/modifications/removePropertiesDeep.js.map 0 → 100644
View file @ 956c501c
{"version":3,"names":["_traverseFast","require","_removeProperties","removePropertiesDeep","tree","opts","traverseFast","removeProperties"],"sources":["../../src/modifications/removePropertiesDeep.ts"],"sourcesContent":["import traverseFast from \"../traverse/traverseFast.ts\";\nimport removeProperties from \"./removeProperties.ts\";\nimport type * as t from \"../index.ts\";\n\nexport default function removePropertiesDeep<T extends t.Node>(\n tree: T,\n opts?: { preserveComments: boolean } | null,\n): T {\n traverseFast(tree, removeProperties, opts);\n\n return tree;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,aAAA,GAAAC,OAAA;AACA,IAAAC,iBAAA,GAAAD,OAAA;AAGe,SAASE,oBAAoBA,CAC1CC,IAAO,EACPC,IAA2C,EACxC;EACH,IAAAC,qBAAY,EAACF,IAAI,EAAEG,yBAAgB,EAAEF,IAAI,CAAC;EAE1C,OAAOD,IAAI;AACb","ignoreList":[]}
\ No newline at end of file
node_modules/@babel/types/lib/modifications/typescript/removeTypeDuplicates.js 0 → 100644
View file @ 956c501c
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = removeTypeDuplicates;
var _index = require("../../validators/generated/index.js");
function getQualifiedName(node) {
return (0, _index.isIdentifier)(node) ? node.name : (0, _index.isThisExpression)(node) ? "this" : `${node.right.name}.${getQualifiedName(node.left)}`;
}
function removeTypeDuplicates(nodesIn) {
const nodes = Array.from(nodesIn);
const generics = new Map();
const bases = new Map();
const typeGroups = new Set();
const types = [];
for (let i = 0; i < nodes.length; i++) {
const node = nodes[i];
if (!node) continue;
if (types.includes(node)) {
continue;
}
if ((0, _index.isTSAnyKeyword)(node)) {
return [node];
}
if ((0, _index.isTSBaseType)(node)) {
bases.set(node.type, node);
continue;
}
if ((0, _index.isTSUnionType)(node)) {
if (!typeGroups.has(node.types)) {
nodes.push(...node.types);
typeGroups.add(node.types);
}
continue;
}
const typeArgumentsKey = "typeParameters";
if ((0, _index.isTSTypeReference)(node) && node[typeArgumentsKey]) {
const typeArguments = node[typeArgumentsKey];
const name = getQualifiedName(node.typeName);
if (generics.has(name)) {
let existing = generics.get(name);
const existingTypeArguments = existing[typeArgumentsKey];
if (existingTypeArguments) {
existingTypeArguments.params.push(...typeArguments.params);
existingTypeArguments.params = removeTypeDuplicates(existingTypeArguments.params);
} else {
existing = typeArguments;
}
} else {
generics.set(name, node);
}
continue;
}
types.push(node);
}
for (const [, baseType] of bases) {
types.push(baseType);
}
for (const [, genericName] of generics) {
types.push(genericName);
}
return types;
}
//# sourceMappingURL=removeTypeDuplicates.js.map
node_modules/@babel/types/lib/modifications/typescript/removeTypeDuplicates.js.map 0 → 100644
View file @ 956c501c
{"version":3,"names":["_index","require","getQualifiedName","node","isIdentifier","name","isThisExpression","right","left","removeTypeDuplicates","nodesIn","nodes","Array","from","generics","Map","bases","typeGroups","Set","types","i","length","includes","isTSAnyKeyword","isTSBaseType","set","type","isTSUnionType","has","push","add","typeArgumentsKey","isTSTypeReference","typeArguments","typeName","existing","get","existingTypeArguments","params","baseType","genericName"],"sources":["../../../src/modifications/typescript/removeTypeDuplicates.ts"],"sourcesContent":["import {\n isIdentifier,\n isThisExpression,\n isTSAnyKeyword,\n isTSTypeReference,\n isTSUnionType,\n isTSBaseType,\n} from \"../../validators/generated/index.ts\";\nimport type * as t from \"../../index.ts\";\n\nfunction getQualifiedName(node: t.TSTypeReference[\"typeName\"]): string {\n return isIdentifier(node)\n ? node.name\n : isThisExpression(node)\n ? \"this\"\n : `${node.right.name}.${getQualifiedName(node.left)}`;\n}\n\n/**\n * Dedupe type annotations.\n */\nexport default function removeTypeDuplicates(\n nodesIn: ReadonlyArray<t.TSType>,\n): Array<t.TSType> {\n const nodes = Array.from(nodesIn);\n\n const generics = new Map<string, t.TSTypeReference>();\n const bases = new Map<t.TSBaseType[\"type\"], t.TSBaseType>();\n\n // store union type groups to circular references\n const typeGroups = new Set<t.TSType[]>();\n\n const types: t.TSType[] = [];\n\n for (let i = 0; i < nodes.length; i++) {\n const node = nodes[i];\n if (!node) continue;\n\n // detect duplicates\n if (types.includes(node)) {\n continue;\n }\n\n // this type matches anything\n if (isTSAnyKeyword(node)) {\n return [node];\n }\n\n // Analogue of FlowBaseAnnotation\n if (isTSBaseType(node)) {\n bases.set(node.type, node);\n continue;\n }\n\n if (isTSUnionType(node)) {\n if (!typeGroups.has(node.types)) {\n nodes.push(...node.types);\n typeGroups.add(node.types);\n }\n continue;\n }\n\n // todo: support merging tuples: number[]\n const typeArgumentsKey = process.env.BABEL_8_BREAKING\n ? \"typeArguments\"\n : \"typeParameters\";\n // @ts-ignore(Babel 7 vs Babel 8) Babel 8 AST\n if (isTSTypeReference(node) && node[typeArgumentsKey]) {\n // @ts-ignore(Babel 7 vs Babel 8) Babel 8 AST\n const typeArguments = node[typeArgumentsKey];\n const name = getQualifiedName(node.typeName);\n\n if (generics.has(name)) {\n let existing: t.TypeScript = generics.get(name);\n // @ts-ignore(Babel 7 vs Babel 8) Babel 8 AST\n const existingTypeArguments = existing[typeArgumentsKey];\n if (existingTypeArguments) {\n existingTypeArguments.params.push(...typeArguments.params);\n existingTypeArguments.params = removeTypeDuplicates(\n existingTypeArguments.params,\n );\n } else {\n existing = typeArguments;\n }\n } else {\n generics.set(name, node);\n }\n\n continue;\n }\n\n types.push(node);\n }\n\n // add back in bases\n for (const [, baseType] of bases) {\n types.push(baseType);\n }\n\n // add back in generics\n for (const [, genericName] of generics) {\n types.push(genericName);\n }\n\n return types;\n}\n"],"mappings":"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","ignoreList":[]}
\ No newline at end of file
node_modules/@babel/types/lib/retrievers/getAssignmentIdentifiers.js 0 → 100644
View file @ 956c501c
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = getAssignmentIdentifiers;
function getAssignmentIdentifiers(node) {
const search = [].concat(node);
const ids = Object.create(null);
while (search.length) {
const id = search.pop();
if (!id) continue;
switch (id.type) {
case "ArrayPattern":
search.push(...id.elements);
break;
case "AssignmentExpression":
case "AssignmentPattern":
case "ForInStatement":
case "ForOfStatement":
search.push(id.left);
break;
case "ObjectPattern":
search.push(...id.properties);
break;
case "ObjectProperty":
search.push(id.value);
break;
case "RestElement":
case "UpdateExpression":
search.push(id.argument);
break;
case "UnaryExpression":
if (id.operator === "delete") {
search.push(id.argument);
}
break;
case "Identifier":
ids[id.name] = id;
break;
default:
break;
}
}
return ids;
}
//# sourceMappingURL=getAssignmentIdentifiers.js.map
node_modules/@babel/types/lib/retrievers/getAssignmentIdentifiers.js.map 0 → 100644
View file @ 956c501c
{"version":3,"names":["getAssignmentIdentifiers","node","search","concat","ids","Object","create","length","id","pop","type","push","elements","left","properties","value","argument","operator","name"],"sources":["../../src/retrievers/getAssignmentIdentifiers.ts"],"sourcesContent":["import type * as t from \"../index.ts\";\n\n/**\n * For the given node, generate a map from assignment id names to the identifier node.\n * Unlike getBindingIdentifiers, this function does not handle declarations and imports.\n * @param node the assignment expression or forXstatement\n * @returns an object map\n * @see getBindingIdentifiers\n */\nexport default function getAssignmentIdentifiers(\n node: t.Node | t.Node[],\n): Record<string, t.Identifier> {\n // null represents holes in an array pattern\n const search: (t.Node | null)[] = [].concat(node);\n const ids = Object.create(null);\n\n while (search.length) {\n const id = search.pop();\n if (!id) continue;\n\n switch (id.type) {\n case \"ArrayPattern\":\n search.push(...id.elements);\n break;\n\n case \"AssignmentExpression\":\n case \"AssignmentPattern\":\n case \"ForInStatement\":\n case \"ForOfStatement\":\n search.push(id.left);\n break;\n\n case \"ObjectPattern\":\n search.push(...id.properties);\n break;\n\n case \"ObjectProperty\":\n search.push(id.value);\n break;\n\n case \"RestElement\":\n case \"UpdateExpression\":\n search.push(id.argument);\n break;\n\n case \"UnaryExpression\":\n if (id.operator === \"delete\") {\n search.push(id.argument);\n }\n break;\n\n case \"Identifier\":\n ids[id.name] = id;\n break;\n\n default:\n break;\n }\n }\n\n return ids;\n}\n"],"mappings":";;;;;;AASe,SAASA,wBAAwBA,CAC9CC,IAAuB,EACO;EAE9B,MAAMC,MAAyB,GAAG,EAAE,CAACC,MAAM,CAACF,IAAI,CAAC;EACjD,MAAMG,GAAG,GAAGC,MAAM,CAACC,MAAM,CAAC,IAAI,CAAC;EAE/B,OAAOJ,MAAM,CAACK,MAAM,EAAE;IACpB,MAAMC,EAAE,GAAGN,MAAM,CAACO,GAAG,CAAC,CAAC;IACvB,IAAI,CAACD,EAAE,EAAE;IAET,QAAQA,EAAE,CAACE,IAAI;MACb,KAAK,cAAc;QACjBR,MAAM,CAACS,IAAI,CAAC,GAAGH,EAAE,CAACI,QAAQ,CAAC;QAC3B;MAEF,KAAK,sBAAsB;MAC3B,KAAK,mBAAmB;MACxB,KAAK,gBAAgB;MACrB,KAAK,gBAAgB;QACnBV,MAAM,CAACS,IAAI,CAACH,EAAE,CAACK,IAAI,CAAC;QACpB;MAEF,KAAK,eAAe;QAClBX,MAAM,CAACS,IAAI,CAAC,GAAGH,EAAE,CAACM,UAAU,CAAC;QAC7B;MAEF,KAAK,gBAAgB;QACnBZ,MAAM,CAACS,IAAI,CAACH,EAAE,CAACO,KAAK,CAAC;QACrB;MAEF,KAAK,aAAa;MAClB,KAAK,kBAAkB;QACrBb,MAAM,CAACS,IAAI,CAACH,EAAE,CAACQ,QAAQ,CAAC;QACxB;MAEF,KAAK,iBAAiB;QACpB,IAAIR,EAAE,CAACS,QAAQ,KAAK,QAAQ,EAAE;UAC5Bf,MAAM,CAACS,IAAI,CAACH,EAAE,CAACQ,QAAQ,CAAC;QAC1B;QACA;MAEF,KAAK,YAAY;QACfZ,GAAG,CAACI,EAAE,CAACU,IAAI,CAAC,GAAGV,EAAE;QACjB;MAEF;QACE;IACJ;EACF;EAEA,OAAOJ,GAAG;AACZ","ignoreList":[]}
\ No newline at end of file
node_modules/@babel/types/lib/retrievers/getBindingIdentifiers.js 0 → 100644
View file @ 956c501c
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = getBindingIdentifiers;
var _index = require("../validators/generated/index.js");
function getBindingIdentifiers(node, duplicates, outerOnly, newBindingsOnly) {
const search = [].concat(node);
const ids = Object.create(null);
while (search.length) {
const id = search.shift();
if (!id) continue;
if (newBindingsOnly && ((0, _index.isAssignmentExpression)(id) || (0, _index.isUnaryExpression)(id) || (0, _index.isUpdateExpression)(id))) {
continue;
}
if ((0, _index.isIdentifier)(id)) {
if (duplicates) {
const _ids = ids[id.name] = ids[id.name] || [];
_ids.push(id);
} else {
ids[id.name] = id;
}
continue;
}
if ((0, _index.isExportDeclaration)(id) && !(0, _index.isExportAllDeclaration)(id)) {
if ((0, _index.isDeclaration)(id.declaration)) {
search.push(id.declaration);
}
continue;
}
if (outerOnly) {
if ((0, _index.isFunctionDeclaration)(id)) {
search.push(id.id);
continue;
}
if ((0, _index.isFunctionExpression)(id)) {
continue;
}
}
const keys = getBindingIdentifiers.keys[id.type];
if (keys) {
for (let i = 0; i < keys.length; i++) {
const key = keys[i];
const nodes = id[key];
if (nodes) {
if (Array.isArray(nodes)) {
search.push(...nodes);
} else {
search.push(nodes);
}
}
}
}
}
return ids;
}
const keys = {
DeclareClass: ["id"],
DeclareFunction: ["id"],
DeclareModule: ["id"],
DeclareVariable: ["id"],
DeclareInterface: ["id"],
DeclareTypeAlias: ["id"],
DeclareOpaqueType: ["id"],
InterfaceDeclaration: ["id"],
TypeAlias: ["id"],
OpaqueType: ["id"],
CatchClause: ["param"],
LabeledStatement: ["label"],
UnaryExpression: ["argument"],
AssignmentExpression: ["left"],
ImportSpecifier: ["local"],
ImportNamespaceSpecifier: ["local"],
ImportDefaultSpecifier: ["local"],
ImportDeclaration: ["specifiers"],
TSImportEqualsDeclaration: ["id"],
ExportSpecifier: ["exported"],
ExportNamespaceSpecifier: ["exported"],
ExportDefaultSpecifier: ["exported"],
FunctionDeclaration: ["id", "params"],
FunctionExpression: ["id", "params"],
ArrowFunctionExpression: ["params"],
ObjectMethod: ["params"],
ClassMethod: ["params"],
ClassPrivateMethod: ["params"],
ForInStatement: ["left"],
ForOfStatement: ["left"],
ClassDeclaration: ["id"],
ClassExpression: ["id"],
RestElement: ["argument"],
UpdateExpression: ["argument"],
ObjectProperty: ["value"],
AssignmentPattern: ["left"],
ArrayPattern: ["elements"],
ObjectPattern: ["properties"],
VariableDeclaration: ["declarations"],
VariableDeclarator: ["id"]
};
getBindingIdentifiers.keys = keys;
//# sourceMappingURL=getBindingIdentifiers.js.map
node_modules/@babel/types/lib/retrievers/getBindingIdentifiers.js.map 0 → 100644
View file @ 956c501c
{"version":3,"names":["_index","require","getBindingIdentifiers","node","duplicates","outerOnly","newBindingsOnly","search","concat","ids","Object","create","length","id","shift","isAssignmentExpression","isUnaryExpression","isUpdateExpression","isIdentifier","_ids","name","push","isExportDeclaration","isExportAllDeclaration","isDeclaration","declaration","isFunctionDeclaration","isFunctionExpression","keys","type","i","key","nodes","Array","isArray","DeclareClass","DeclareFunction","DeclareModule","DeclareVariable","DeclareInterface","DeclareTypeAlias","DeclareOpaqueType","InterfaceDeclaration","TypeAlias","OpaqueType","CatchClause","LabeledStatement","UnaryExpression","AssignmentExpression","ImportSpecifier","ImportNamespaceSpecifier","ImportDefaultSpecifier","ImportDeclaration","TSImportEqualsDeclaration","ExportSpecifier","ExportNamespaceSpecifier","ExportDefaultSpecifier","FunctionDeclaration","FunctionExpression","ArrowFunctionExpression","ObjectMethod","ClassMethod","ClassPrivateMethod","ForInStatement","ForOfStatement","ClassDeclaration","ClassExpression","RestElement","UpdateExpression","ObjectProperty","AssignmentPattern","ArrayPattern","ObjectPattern","VariableDeclaration","VariableDeclarator"],"sources":["../../src/retrievers/getBindingIdentifiers.ts"],"sourcesContent":["import {\n isExportDeclaration,\n isIdentifier,\n isClassExpression,\n isDeclaration,\n isFunctionDeclaration,\n isFunctionExpression,\n isExportAllDeclaration,\n isAssignmentExpression,\n isUnaryExpression,\n isUpdateExpression,\n} from \"../validators/generated/index.ts\";\nimport type * as t from \"../index.ts\";\n\nexport { getBindingIdentifiers as default };\n\nfunction getBindingIdentifiers(\n node: t.Node,\n duplicates: true,\n outerOnly?: boolean,\n newBindingsOnly?: boolean,\n): Record<string, Array<t.Identifier>>;\n\nfunction getBindingIdentifiers(\n node: t.Node,\n duplicates?: false,\n outerOnly?: boolean,\n newBindingsOnly?: boolean,\n): Record<string, t.Identifier>;\n\nfunction getBindingIdentifiers(\n node: t.Node,\n duplicates?: boolean,\n outerOnly?: boolean,\n newBindingsOnly?: boolean,\n): Record<string, t.Identifier> | Record<string, Array<t.Identifier>>;\n\n/**\n * Return a list of binding identifiers associated with the input `node`.\n */\nfunction getBindingIdentifiers(\n node: t.Node,\n duplicates?: boolean,\n outerOnly?: boolean,\n newBindingsOnly?: boolean,\n): Record<string, t.Identifier> | Record<string, Array<t.Identifier>> {\n const search: t.Node[] = [].concat(node);\n const ids = Object.create(null);\n\n while (search.length) {\n const id = search.shift();\n if (!id) continue;\n\n if (\n newBindingsOnly &&\n // These nodes do not introduce _new_ bindings, but they are included\n // in getBindingIdentifiers.keys for backwards compatibility.\n // TODO(@nicolo-ribaudo): Check if we can remove them from .keys in a\n // backward-compatible way, and if not what we need to do to remove them\n // in Babel 8.\n (isAssignmentExpression(id) ||\n isUnaryExpression(id) ||\n isUpdateExpression(id))\n ) {\n continue;\n }\n\n if (isIdentifier(id)) {\n if (duplicates) {\n const _ids = (ids[id.name] = ids[id.name] || []);\n _ids.push(id);\n } else {\n ids[id.name] = id;\n }\n continue;\n }\n\n if (isExportDeclaration(id) && !isExportAllDeclaration(id)) {\n if (isDeclaration(id.declaration)) {\n search.push(id.declaration);\n }\n continue;\n }\n\n if (outerOnly) {\n if (isFunctionDeclaration(id)) {\n search.push(id.id);\n continue;\n }\n\n if (\n isFunctionExpression(id) ||\n (process.env.BABEL_8_BREAKING && isClassExpression(id))\n ) {\n continue;\n }\n }\n\n const keys = getBindingIdentifiers.keys[id.type];\n\n if (keys) {\n for (let i = 0; i < keys.length; i++) {\n const key = keys[i];\n const nodes =\n // @ts-expect-error key must present in id\n id[key] as t.Node[] | t.Node | undefined | null;\n if (nodes) {\n if (Array.isArray(nodes)) {\n search.push(...nodes);\n } else {\n search.push(nodes);\n }\n }\n }\n }\n }\n return ids;\n}\n\n/**\n * Mapping of types to their identifier keys.\n */\ntype KeysMap = {\n [N in t.Node as N[\"type\"]]?: (keyof N)[];\n};\n\nconst keys: KeysMap = {\n DeclareClass: [\"id\"],\n DeclareFunction: [\"id\"],\n DeclareModule: [\"id\"],\n DeclareVariable: [\"id\"],\n DeclareInterface: [\"id\"],\n DeclareTypeAlias: [\"id\"],\n DeclareOpaqueType: [\"id\"],\n InterfaceDeclaration: [\"id\"],\n TypeAlias: [\"id\"],\n OpaqueType: [\"id\"],\n\n CatchClause: [\"param\"],\n LabeledStatement: [\"label\"],\n UnaryExpression: [\"argument\"],\n AssignmentExpression: [\"left\"],\n\n ImportSpecifier: [\"local\"],\n ImportNamespaceSpecifier: [\"local\"],\n ImportDefaultSpecifier: [\"local\"],\n ImportDeclaration: [\"specifiers\"],\n TSImportEqualsDeclaration: [\"id\"],\n\n ExportSpecifier: [\"exported\"],\n ExportNamespaceSpecifier: [\"exported\"],\n ExportDefaultSpecifier: [\"exported\"],\n\n FunctionDeclaration: [\"id\", \"params\"],\n FunctionExpression: [\"id\", \"params\"],\n ArrowFunctionExpression: [\"params\"],\n ObjectMethod: [\"params\"],\n ClassMethod: [\"params\"],\n ClassPrivateMethod: [\"params\"],\n\n ForInStatement: [\"left\"],\n ForOfStatement: [\"left\"],\n\n ClassDeclaration: [\"id\"],\n ClassExpression: [\"id\"],\n\n RestElement: [\"argument\"],\n UpdateExpression: [\"argument\"],\n\n ObjectProperty: [\"value\"],\n\n AssignmentPattern: [\"left\"],\n ArrayPattern: [\"elements\"],\n ObjectPattern: [\"properties\"],\n\n VariableDeclaration: [\"declarations\"],\n VariableDeclarator: [\"id\"],\n};\n\ngetBindingIdentifiers.keys = keys;\n"],"mappings":"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","ignoreList":[]}
\ No newline at end of file
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment