@types/babel__traverse

Version 7.20.6
Published 3 months ago
84.1 kB
1 dependency
MIT license

Install

npm i @types/babel__traverse

yarn add @types/babel__traverse

pnpm add @types/babel__traverse

Overview

TypeScript definitions for @babel/traverse

Index

Variables

variable traverse

const traverse: {
    <S>(
        parent: Node,
        opts: TraverseOptions<S>,
        scope: Scope | undefined,
        state: S,
        parentPath?: NodePath
    ): void;
    (
        parent: Node,
        opts?: TraverseOptions,
        scope?: Scope,
        state?: any,
        parentPath?: NodePath
    ): void;
    visitors: typeof visitors;
    verify: typeof visitors.verify;
    explode: typeof visitors.explode;
    cheap: (node: Node, enter: (node: Node) => void) => void;
    node: (
        node: Node,
        opts: TraverseOptions,
        scope?: Scope,
        state?: any,
        path?: NodePath,
        skipKeys?: Record<string, boolean>
    ) => void;
    clearNode: (node: Node, opts?: RemovePropertiesOptions) => void;
    removeProperties: (tree: Node, opts?: RemovePropertiesOptions) => Node;
    hasType: (tree: Node, type: Node, denylistTypes?: string[]) => boolean;
    cache: typeof cache;
};

Classes

class Binding

class Binding {}

This class is responsible for a binding inside of a scope.
It tracks the following:
* Node path. * Amount of times referenced by other nodes. * Paths to nodes that reassign or modify this binding. * The kind of binding. (Is it a parameter, declaration etc)

constructor

constructor(opts: {
    identifier: t.Identifier;
    scope: Scope;
    path: NodePath;
    kind: BindingKind;
});

property constant

constant: boolean;

property constantViolations

constantViolations: NodePath<Node>[];

property hasDeoptedValue

hasDeoptedValue: boolean;

property hasValue

hasValue: boolean;

property identifier

identifier: t.Identifier;

property kind

kind: BindingKind;

property path

path: NodePath<Node>;

property referenced

referenced: boolean;

property referencePaths

referencePaths: NodePath<Node>[];

property references

references: number;

property scope

scope: Scope;

property value

value: any;

method clearValue

clearValue: () => void;

method deopValue

deopValue: () => void;

method dereference

dereference: () => void;

Decrement the amount of references to this binding.

method reassign

reassign: (path: NodePath) => void;

method reference

reference: (path: NodePath) => void;

Increment the amount of references to this binding.

method setValue

setValue: (value: any) => void;

class Hub

class Hub implements HubInterface {}

constructor

constructor();

method addHelper

addHelper: (name: string) => any;

method buildError

buildError: (node: Node, msg: string, Error?: ErrorConstructor) => Error;

method getCode

getCode: () => string | undefined;

method getScope

getScope: () => Scope | undefined;

class NodePath

class NodePath<T = Node> {}

constructor

constructor(hub: HubInterface, parent: Node);

property container

container: any;

property context

context: TraversalContext<unknown>;

property contexts

contexts: TraversalContext<unknown>[];

property data

data: Record<string | symbol, unknown>;

property hub

hub: Hub;

property inList

inList: boolean;

property key

key: string | number;

property listKey

listKey: string;

property node

node: {};

property opts

opts: any;

property parent

parent: Node;

property parentKey

parentKey: string;

property parentPath

parentPath: NodePath<Node>;

property removed

removed: boolean;

property scope

scope: Scope;

property shouldSkip

shouldSkip: boolean;

property shouldStop

shouldStop: boolean;

property skipKeys

skipKeys: Record<string, boolean>;

property state

state: any;

property type

type: {};

property typeAnnotation

typeAnnotation: {};

method addComment

addComment: (
    type: t.CommentTypeShorthand,
    content: string,
    line?: boolean
) => void;

method addComments

addComments: (type: t.CommentTypeShorthand, comments: t.Comment[]) => void;

Give node comments of the specified type.

method arrowFunctionToExpression

arrowFunctionToExpression: ({
    allowInsertArrow,
    allowInsertArrowWithRest,
    specCompliant,
    noNewArrows,
}?: {
    allowInsertArrow?: boolean;
    allowInsertArrowWithRest?: boolean;
    specCompliant?: boolean;
    noNewArrows?: boolean;
}) => NodePath<
    Exclude<t.Function, t.Method | t.ArrowFunctionExpression> | t.CallExpression
>;

Convert a given arrow function into a normal ES5 function expression.

method arrowFunctionToShadowed

arrowFunctionToShadowed: () => void;

Deprecated
Use arrowFunctionToExpression

method assertAccessor

assertAccessor: (opts?: object) => asserts this is NodePath<t.Accessor>;

method assertAnyTypeAnnotation

assertAnyTypeAnnotation: (
    opts?: object
) => asserts this is NodePath<t.AnyTypeAnnotation>;

method assertArgumentPlaceholder

assertArgumentPlaceholder: (
    opts?: object
) => asserts this is NodePath<t.ArgumentPlaceholder>;

method assertArrayExpression

assertArrayExpression: (
    opts?: object
) => asserts this is NodePath<t.ArrayExpression>;

method assertArrayPattern

assertArrayPattern: (opts?: object) => asserts this is NodePath<t.ArrayPattern>;

method assertArrayTypeAnnotation

assertArrayTypeAnnotation: (
    opts?: object
) => asserts this is NodePath<t.ArrayTypeAnnotation>;

method assertArrowFunctionExpression

assertArrowFunctionExpression: (
    opts?: object
) => asserts this is NodePath<t.ArrowFunctionExpression>;

method assertAssignmentExpression

assertAssignmentExpression: (
    opts?: object
) => asserts this is NodePath<t.AssignmentExpression>;

method assertAssignmentPattern

assertAssignmentPattern: (
    opts?: object
) => asserts this is NodePath<t.AssignmentPattern>;

method assertAwaitExpression

assertAwaitExpression: (
    opts?: object
) => asserts this is NodePath<t.AwaitExpression>;

method assertBigIntLiteral

assertBigIntLiteral: (
    opts?: object
) => asserts this is NodePath<t.BigIntLiteral>;

method assertBinary

assertBinary: (opts?: object) => asserts this is NodePath<t.Binary>;

method assertBinaryExpression

assertBinaryExpression: (
    opts?: object
) => asserts this is NodePath<t.BinaryExpression>;

method assertBindExpression

assertBindExpression: (
    opts?: object
) => asserts this is NodePath<t.BindExpression>;

method assertBlock

assertBlock: (opts?: object) => asserts this is NodePath<t.Block>;

method assertBlockParent

assertBlockParent: (opts?: object) => asserts this is NodePath<t.BlockParent>;

method assertBlockStatement

assertBlockStatement: (
    opts?: object
) => asserts this is NodePath<t.BlockStatement>;

method assertBooleanLiteral

assertBooleanLiteral: (
    opts?: object
) => asserts this is NodePath<t.BooleanLiteral>;

method assertBooleanLiteralTypeAnnotation

assertBooleanLiteralTypeAnnotation: (
    opts?: object
) => asserts this is NodePath<t.BooleanLiteralTypeAnnotation>;

method assertBooleanTypeAnnotation

assertBooleanTypeAnnotation: (
    opts?: object
) => asserts this is NodePath<t.BooleanTypeAnnotation>;

method assertBreakStatement

assertBreakStatement: (
    opts?: object
) => asserts this is NodePath<t.BreakStatement>;

method assertCallExpression

assertCallExpression: (
    opts?: object
) => asserts this is NodePath<t.CallExpression>;

method assertCatchClause

assertCatchClause: (opts?: object) => asserts this is NodePath<t.CatchClause>;

method assertClass

assertClass: (opts?: object) => asserts this is NodePath<t.Class>;

method assertClassAccessorProperty

assertClassAccessorProperty: (
    opts?: object
) => asserts this is NodePath<t.ClassAccessorProperty>;

method assertClassBody

assertClassBody: (opts?: object) => asserts this is NodePath<t.ClassBody>;

method assertClassDeclaration

assertClassDeclaration: (
    opts?: object
) => asserts this is NodePath<t.ClassDeclaration>;

method assertClassExpression

assertClassExpression: (
    opts?: object
) => asserts this is NodePath<t.ClassExpression>;

method assertClassImplements

assertClassImplements: (
    opts?: object
) => asserts this is NodePath<t.ClassImplements>;

method assertClassMethod

assertClassMethod: (opts?: object) => asserts this is NodePath<t.ClassMethod>;

method assertClassPrivateMethod

assertClassPrivateMethod: (
    opts?: object
) => asserts this is NodePath<t.ClassPrivateMethod>;

method assertClassPrivateProperty

assertClassPrivateProperty: (
    opts?: object
) => asserts this is NodePath<t.ClassPrivateProperty>;

method assertClassProperty

assertClassProperty: (
    opts?: object
) => asserts this is NodePath<t.ClassProperty>;

method assertCompletionStatement

assertCompletionStatement: (
    opts?: object
) => asserts this is NodePath<t.CompletionStatement>;

method assertConditional

assertConditional: (opts?: object) => asserts this is NodePath<t.Conditional>;

method assertConditionalExpression

assertConditionalExpression: (
    opts?: object
) => asserts this is NodePath<t.ConditionalExpression>;

method assertContinueStatement

assertContinueStatement: (
    opts?: object
) => asserts this is NodePath<t.ContinueStatement>;

method assertDebuggerStatement

assertDebuggerStatement: (
    opts?: object
) => asserts this is NodePath<t.DebuggerStatement>;

method assertDecimalLiteral

assertDecimalLiteral: (
    opts?: object
) => asserts this is NodePath<t.DecimalLiteral>;

method assertDeclaration

assertDeclaration: (opts?: object) => asserts this is NodePath<t.Declaration>;

method assertDeclareClass

assertDeclareClass: (opts?: object) => asserts this is NodePath<t.DeclareClass>;

method assertDeclaredPredicate

assertDeclaredPredicate: (
    opts?: object
) => asserts this is NodePath<t.DeclaredPredicate>;

method assertDeclareExportAllDeclaration

assertDeclareExportAllDeclaration: (
    opts?: object
) => asserts this is NodePath<t.DeclareExportAllDeclaration>;

method assertDeclareExportDeclaration

assertDeclareExportDeclaration: (
    opts?: object
) => asserts this is NodePath<t.DeclareExportDeclaration>;

method assertDeclareFunction

assertDeclareFunction: (
    opts?: object
) => asserts this is NodePath<t.DeclareFunction>;

method assertDeclareInterface

assertDeclareInterface: (
    opts?: object
) => asserts this is NodePath<t.DeclareInterface>;

method assertDeclareModule

assertDeclareModule: (
    opts?: object
) => asserts this is NodePath<t.DeclareModule>;

method assertDeclareModuleExports

assertDeclareModuleExports: (
    opts?: object
) => asserts this is NodePath<t.DeclareModuleExports>;

method assertDeclareOpaqueType

assertDeclareOpaqueType: (
    opts?: object
) => asserts this is NodePath<t.DeclareOpaqueType>;

method assertDeclareTypeAlias

assertDeclareTypeAlias: (
    opts?: object
) => asserts this is NodePath<t.DeclareTypeAlias>;

method assertDeclareVariable

assertDeclareVariable: (
    opts?: object
) => asserts this is NodePath<t.DeclareVariable>;

method assertDecorator

assertDecorator: (opts?: object) => asserts this is NodePath<t.Decorator>;

method assertDirective

assertDirective: (opts?: object) => asserts this is NodePath<t.Directive>;

method assertDirectiveLiteral

assertDirectiveLiteral: (
    opts?: object
) => asserts this is NodePath<t.DirectiveLiteral>;

method assertDoExpression

assertDoExpression: (opts?: object) => asserts this is NodePath<t.DoExpression>;

method assertDoWhileStatement

assertDoWhileStatement: (
    opts?: object
) => asserts this is NodePath<t.DoWhileStatement>;

method assertEmptyStatement

assertEmptyStatement: (
    opts?: object
) => asserts this is NodePath<t.EmptyStatement>;

method assertEmptyTypeAnnotation

assertEmptyTypeAnnotation: (
    opts?: object
) => asserts this is NodePath<t.EmptyTypeAnnotation>;

method assertEnumBody

assertEnumBody: (opts?: object) => asserts this is NodePath<t.EnumBody>;

method assertEnumBooleanBody

assertEnumBooleanBody: (
    opts?: object
) => asserts this is NodePath<t.EnumBooleanBody>;

method assertEnumBooleanMember

assertEnumBooleanMember: (
    opts?: object
) => asserts this is NodePath<t.EnumBooleanMember>;

method assertEnumDeclaration

assertEnumDeclaration: (
    opts?: object
) => asserts this is NodePath<t.EnumDeclaration>;

method assertEnumDefaultedMember

assertEnumDefaultedMember: (
    opts?: object
) => asserts this is NodePath<t.EnumDefaultedMember>;

method assertEnumMember

assertEnumMember: (opts?: object) => asserts this is NodePath<t.EnumMember>;

method assertEnumNumberBody

assertEnumNumberBody: (
    opts?: object
) => asserts this is NodePath<t.EnumNumberBody>;

method assertEnumNumberMember

assertEnumNumberMember: (
    opts?: object
) => asserts this is NodePath<t.EnumNumberMember>;

method assertEnumStringBody

assertEnumStringBody: (
    opts?: object
) => asserts this is NodePath<t.EnumStringBody>;

method assertEnumStringMember

assertEnumStringMember: (
    opts?: object
) => asserts this is NodePath<t.EnumStringMember>;

method assertEnumSymbolBody

assertEnumSymbolBody: (
    opts?: object
) => asserts this is NodePath<t.EnumSymbolBody>;

method assertExistsTypeAnnotation

assertExistsTypeAnnotation: (
    opts?: object
) => asserts this is NodePath<t.ExistsTypeAnnotation>;

method assertExportAllDeclaration

assertExportAllDeclaration: (
    opts?: object
) => asserts this is NodePath<t.ExportAllDeclaration>;

method assertExportDeclaration

assertExportDeclaration: (
    opts?: object
) => asserts this is NodePath<t.ExportDeclaration>;

method assertExportDefaultDeclaration

assertExportDefaultDeclaration: (
    opts?: object
) => asserts this is NodePath<t.ExportDefaultDeclaration>;

method assertExportDefaultSpecifier

assertExportDefaultSpecifier: (
    opts?: object
) => asserts this is NodePath<t.ExportDefaultSpecifier>;

method assertExportNamedDeclaration

assertExportNamedDeclaration: (
    opts?: object
) => asserts this is NodePath<t.ExportNamedDeclaration>;

method assertExportNamespaceSpecifier

assertExportNamespaceSpecifier: (
    opts?: object
) => asserts this is NodePath<t.ExportNamespaceSpecifier>;

method assertExportSpecifier

assertExportSpecifier: (
    opts?: object
) => asserts this is NodePath<t.ExportSpecifier>;

method assertExpression

assertExpression: (opts?: object) => asserts this is NodePath<t.Expression>;

method assertExpressionStatement

assertExpressionStatement: (
    opts?: object
) => asserts this is NodePath<t.ExpressionStatement>;

method assertExpressionWrapper

assertExpressionWrapper: (
    opts?: object
) => asserts this is NodePath<t.ExpressionWrapper>;

method assertFile

assertFile: (opts?: object) => asserts this is NodePath<t.File>;

method assertFlow

assertFlow: (opts?: object) => asserts this is NodePath<t.Flow>;

method assertFlowBaseAnnotation

assertFlowBaseAnnotation: (
    opts?: object
) => asserts this is NodePath<t.FlowBaseAnnotation>;

method assertFlowDeclaration

assertFlowDeclaration: (
    opts?: object
) => asserts this is NodePath<t.FlowDeclaration>;

method assertFlowPredicate

assertFlowPredicate: (
    opts?: object
) => asserts this is NodePath<t.FlowPredicate>;

method assertFlowType

assertFlowType: (opts?: object) => asserts this is NodePath<t.FlowType>;

method assertFor

assertFor: (opts?: object) => asserts this is NodePath<t.For>;

method assertForInStatement

assertForInStatement: (
    opts?: object
) => asserts this is NodePath<t.ForInStatement>;

method assertForOfStatement

assertForOfStatement: (
    opts?: object
) => asserts this is NodePath<t.ForOfStatement>;

method assertForStatement

assertForStatement: (opts?: object) => asserts this is NodePath<t.ForStatement>;

method assertForXStatement

assertForXStatement: (
    opts?: object
) => asserts this is NodePath<t.ForXStatement>;

method assertFunction

assertFunction: (opts?: object) => asserts this is NodePath<t.Function>;

method assertFunctionDeclaration

assertFunctionDeclaration: (
    opts?: object
) => asserts this is NodePath<t.FunctionDeclaration>;

method assertFunctionExpression

assertFunctionExpression: (
    opts?: object
) => asserts this is NodePath<t.FunctionExpression>;

method assertFunctionParent

assertFunctionParent: (
    opts?: object
) => asserts this is NodePath<t.FunctionParent>;

method assertFunctionTypeAnnotation

assertFunctionTypeAnnotation: (
    opts?: object
) => asserts this is NodePath<t.FunctionTypeAnnotation>;

method assertFunctionTypeParam

assertFunctionTypeParam: (
    opts?: object
) => asserts this is NodePath<t.FunctionTypeParam>;

method assertGenericTypeAnnotation

assertGenericTypeAnnotation: (
    opts?: object
) => asserts this is NodePath<t.GenericTypeAnnotation>;

method assertIdentifier

assertIdentifier: (opts?: object) => asserts this is NodePath<t.Identifier>;

method assertIfStatement

assertIfStatement: (opts?: object) => asserts this is NodePath<t.IfStatement>;

method assertImmutable

assertImmutable: (opts?: object) => asserts this is NodePath<t.Immutable>;

method assertImport

assertImport: (opts?: object) => asserts this is NodePath<t.Import>;

method assertImportAttribute

assertImportAttribute: (
    opts?: object
) => asserts this is NodePath<t.ImportAttribute>;

method assertImportDeclaration

assertImportDeclaration: (
    opts?: object
) => asserts this is NodePath<t.ImportDeclaration>;

method assertImportDefaultSpecifier

assertImportDefaultSpecifier: (
    opts?: object
) => asserts this is NodePath<t.ImportDefaultSpecifier>;

method assertImportNamespaceSpecifier

assertImportNamespaceSpecifier: (
    opts?: object
) => asserts this is NodePath<t.ImportNamespaceSpecifier>;

method assertImportSpecifier

assertImportSpecifier: (
    opts?: object
) => asserts this is NodePath<t.ImportSpecifier>;

method assertIndexedAccessType

assertIndexedAccessType: (
    opts?: object
) => asserts this is NodePath<t.IndexedAccessType>;

method assertInferredPredicate

assertInferredPredicate: (
    opts?: object
) => asserts this is NodePath<t.InferredPredicate>;

method assertInterfaceDeclaration

assertInterfaceDeclaration: (
    opts?: object
) => asserts this is NodePath<t.InterfaceDeclaration>;

method assertInterfaceExtends

assertInterfaceExtends: (
    opts?: object
) => asserts this is NodePath<t.InterfaceExtends>;

method assertInterfaceTypeAnnotation

assertInterfaceTypeAnnotation: (
    opts?: object
) => asserts this is NodePath<t.InterfaceTypeAnnotation>;

method assertInterpreterDirective

assertInterpreterDirective: (
    opts?: object
) => asserts this is NodePath<t.InterpreterDirective>;

method assertIntersectionTypeAnnotation

assertIntersectionTypeAnnotation: (
    opts?: object
) => asserts this is NodePath<t.IntersectionTypeAnnotation>;

method assertJSX

assertJSX: (opts?: object) => asserts this is NodePath<t.JSX>;

method assertJSXAttribute

assertJSXAttribute: (opts?: object) => asserts this is NodePath<t.JSXAttribute>;

method assertJSXClosingElement

assertJSXClosingElement: (
    opts?: object
) => asserts this is NodePath<t.JSXClosingElement>;

method assertJSXClosingFragment

assertJSXClosingFragment: (
    opts?: object
) => asserts this is NodePath<t.JSXClosingFragment>;

method assertJSXElement

assertJSXElement: (opts?: object) => asserts this is NodePath<t.JSXElement>;

method assertJSXEmptyExpression

assertJSXEmptyExpression: (
    opts?: object
) => asserts this is NodePath<t.JSXEmptyExpression>;

method assertJSXExpressionContainer

assertJSXExpressionContainer: (
    opts?: object
) => asserts this is NodePath<t.JSXExpressionContainer>;

method assertJSXFragment

assertJSXFragment: (opts?: object) => asserts this is NodePath<t.JSXFragment>;

method assertJSXIdentifier

assertJSXIdentifier: (
    opts?: object
) => asserts this is NodePath<t.JSXIdentifier>;

method assertJSXMemberExpression

assertJSXMemberExpression: (
    opts?: object
) => asserts this is NodePath<t.JSXMemberExpression>;

method assertJSXNamespacedName

assertJSXNamespacedName: (
    opts?: object
) => asserts this is NodePath<t.JSXNamespacedName>;

method assertJSXOpeningElement

assertJSXOpeningElement: (
    opts?: object
) => asserts this is NodePath<t.JSXOpeningElement>;

method assertJSXOpeningFragment

assertJSXOpeningFragment: (
    opts?: object
) => asserts this is NodePath<t.JSXOpeningFragment>;

method assertJSXSpreadAttribute

assertJSXSpreadAttribute: (
    opts?: object
) => asserts this is NodePath<t.JSXSpreadAttribute>;

method assertJSXSpreadChild

assertJSXSpreadChild: (
    opts?: object
) => asserts this is NodePath<t.JSXSpreadChild>;

method assertJSXText

assertJSXText: (opts?: object) => asserts this is NodePath<t.JSXText>;

method assertLabeledStatement

assertLabeledStatement: (
    opts?: object
) => asserts this is NodePath<t.LabeledStatement>;

method assertLiteral

assertLiteral: (opts?: object) => asserts this is NodePath<t.Literal>;

method assertLogicalExpression

assertLogicalExpression: (
    opts?: object
) => asserts this is NodePath<t.LogicalExpression>;

method assertLoop

assertLoop: (opts?: object) => asserts this is NodePath<t.Loop>;

method assertLVal

assertLVal: (opts?: object) => asserts this is NodePath<t.LVal>;

method assertMemberExpression

assertMemberExpression: (
    opts?: object
) => asserts this is NodePath<t.MemberExpression>;

method assertMetaProperty

assertMetaProperty: (opts?: object) => asserts this is NodePath<t.MetaProperty>;

method assertMethod

assertMethod: (opts?: object) => asserts this is NodePath<t.Method>;

method assertMiscellaneous

assertMiscellaneous: (
    opts?: object
) => asserts this is NodePath<t.Miscellaneous>;

method assertMixedTypeAnnotation

assertMixedTypeAnnotation: (
    opts?: object
) => asserts this is NodePath<t.MixedTypeAnnotation>;

method assertModuleDeclaration

assertModuleDeclaration: (
    opts?: object
) => asserts this is NodePath<t.ModuleDeclaration>;

method assertModuleExpression

assertModuleExpression: (
    opts?: object
) => asserts this is NodePath<t.ModuleExpression>;

method assertModuleSpecifier

assertModuleSpecifier: (
    opts?: object
) => asserts this is NodePath<t.ModuleSpecifier>;

method assertNewExpression

assertNewExpression: (
    opts?: object
) => asserts this is NodePath<t.NewExpression>;

method assertNoop

assertNoop: (opts?: object) => asserts this is NodePath<t.Noop>;

method assertNullableTypeAnnotation

assertNullableTypeAnnotation: (
    opts?: object
) => asserts this is NodePath<t.NullableTypeAnnotation>;

method assertNullLiteral

assertNullLiteral: (opts?: object) => asserts this is NodePath<t.NullLiteral>;

method assertNullLiteralTypeAnnotation

assertNullLiteralTypeAnnotation: (
    opts?: object
) => asserts this is NodePath<t.NullLiteralTypeAnnotation>;

method assertNumberLiteral

assertNumberLiteral: (
    opts?: object
) => asserts this is NodePath<t.NumberLiteral>;

Deprecated
Use assertNumericLiteral

method assertNumberLiteralTypeAnnotation

assertNumberLiteralTypeAnnotation: (
    opts?: object
) => asserts this is NodePath<t.NumberLiteralTypeAnnotation>;

method assertNumberTypeAnnotation

assertNumberTypeAnnotation: (
    opts?: object
) => asserts this is NodePath<t.NumberTypeAnnotation>;

method assertNumericLiteral

assertNumericLiteral: (
    opts?: object
) => asserts this is NodePath<t.NumericLiteral>;

method assertObjectExpression

assertObjectExpression: (
    opts?: object
) => asserts this is NodePath<t.ObjectExpression>;

method assertObjectMember

assertObjectMember: (opts?: object) => asserts this is NodePath<t.ObjectMember>;

method assertObjectMethod

assertObjectMethod: (opts?: object) => asserts this is NodePath<t.ObjectMethod>;

method assertObjectPattern

assertObjectPattern: (
    opts?: object
) => asserts this is NodePath<t.ObjectPattern>;

method assertObjectProperty

assertObjectProperty: (
    opts?: object
) => asserts this is NodePath<t.ObjectProperty>;

method assertObjectTypeAnnotation

assertObjectTypeAnnotation: (
    opts?: object
) => asserts this is NodePath<t.ObjectTypeAnnotation>;

method assertObjectTypeCallProperty

assertObjectTypeCallProperty: (
    opts?: object
) => asserts this is NodePath<t.ObjectTypeCallProperty>;

method assertObjectTypeIndexer

assertObjectTypeIndexer: (
    opts?: object
) => asserts this is NodePath<t.ObjectTypeIndexer>;

method assertObjectTypeInternalSlot

assertObjectTypeInternalSlot: (
    opts?: object
) => asserts this is NodePath<t.ObjectTypeInternalSlot>;

method assertObjectTypeProperty

assertObjectTypeProperty: (
    opts?: object
) => asserts this is NodePath<t.ObjectTypeProperty>;

method assertObjectTypeSpreadProperty

assertObjectTypeSpreadProperty: (
    opts?: object
) => asserts this is NodePath<t.ObjectTypeSpreadProperty>;

method assertOpaqueType

assertOpaqueType: (opts?: object) => asserts this is NodePath<t.OpaqueType>;

method assertOptionalCallExpression

assertOptionalCallExpression: (
    opts?: object
) => asserts this is NodePath<t.OptionalCallExpression>;

method assertOptionalIndexedAccessType

assertOptionalIndexedAccessType: (
    opts?: object
) => asserts this is NodePath<t.OptionalIndexedAccessType>;

method assertOptionalMemberExpression

assertOptionalMemberExpression: (
    opts?: object
) => asserts this is NodePath<t.OptionalMemberExpression>;

method assertParenthesizedExpression

assertParenthesizedExpression: (
    opts?: object
) => asserts this is NodePath<t.ParenthesizedExpression>;

method assertPattern

assertPattern: (opts?: object) => asserts this is NodePath<t.Pattern>;

method assertPatternLike

assertPatternLike: (opts?: object) => asserts this is NodePath<t.PatternLike>;

method assertPipelineBareFunction

assertPipelineBareFunction: (
    opts?: object
) => asserts this is NodePath<t.PipelineBareFunction>;

method assertPipelinePrimaryTopicReference

assertPipelinePrimaryTopicReference: (
    opts?: object
) => asserts this is NodePath<t.PipelinePrimaryTopicReference>;

method assertPipelineTopicExpression

assertPipelineTopicExpression: (
    opts?: object
) => asserts this is NodePath<t.PipelineTopicExpression>;

method assertPlaceholder

assertPlaceholder: (opts?: object) => asserts this is NodePath<t.Placeholder>;

method assertPrivate

assertPrivate: (opts?: object) => asserts this is NodePath<t.Private>;

method assertPrivateName

assertPrivateName: (opts?: object) => asserts this is NodePath<t.PrivateName>;

method assertProgram

assertProgram: (opts?: object) => asserts this is NodePath<t.Program>;

method assertProperty

assertProperty: (opts?: object) => asserts this is NodePath<t.Property>;

method assertPureish

assertPureish: (opts?: object) => asserts this is NodePath<t.Pureish>;

method assertQualifiedTypeIdentifier

assertQualifiedTypeIdentifier: (
    opts?: object
) => asserts this is NodePath<t.QualifiedTypeIdentifier>;

method assertRecordExpression

assertRecordExpression: (
    opts?: object
) => asserts this is NodePath<t.RecordExpression>;

method assertRegexLiteral

assertRegexLiteral: (opts?: object) => asserts this is NodePath<t.RegexLiteral>;

Deprecated
Use assertRegExpLiteral

method assertRegExpLiteral

assertRegExpLiteral: (
    opts?: object
) => asserts this is NodePath<t.RegExpLiteral>;

method assertRestElement

assertRestElement: (opts?: object) => asserts this is NodePath<t.RestElement>;

method assertRestProperty

assertRestProperty: (opts?: object) => asserts this is NodePath<t.RestProperty>;

Deprecated
Use assertRestElement

method assertReturnStatement

assertReturnStatement: (
    opts?: object
) => asserts this is NodePath<t.ReturnStatement>;

method assertScopable

assertScopable: (opts?: object) => asserts this is NodePath<t.Scopable>;

method assertSequenceExpression

assertSequenceExpression: (
    opts?: object
) => asserts this is NodePath<t.SequenceExpression>;

method assertSpreadElement

assertSpreadElement: (
    opts?: object
) => asserts this is NodePath<t.SpreadElement>;

method assertSpreadProperty

assertSpreadProperty: (
    opts?: object
) => asserts this is NodePath<t.SpreadProperty>;

Deprecated
Use assertSpreadElement

method assertStandardized

assertStandardized: (opts?: object) => asserts this is NodePath<t.Standardized>;

method assertStatement

assertStatement: (opts?: object) => asserts this is NodePath<t.Statement>;

method assertStaticBlock

assertStaticBlock: (opts?: object) => asserts this is NodePath<t.StaticBlock>;

method assertStringLiteral

assertStringLiteral: (
    opts?: object
) => asserts this is NodePath<t.StringLiteral>;

method assertStringLiteralTypeAnnotation

assertStringLiteralTypeAnnotation: (
    opts?: object
) => asserts this is NodePath<t.StringLiteralTypeAnnotation>;

method assertStringTypeAnnotation

assertStringTypeAnnotation: (
    opts?: object
) => asserts this is NodePath<t.StringTypeAnnotation>;

method assertSuper

assertSuper: (opts?: object) => asserts this is NodePath<t.Super>;

method assertSwitchCase

assertSwitchCase: (opts?: object) => asserts this is NodePath<t.SwitchCase>;

method assertSwitchStatement

assertSwitchStatement: (
    opts?: object
) => asserts this is NodePath<t.SwitchStatement>;

method assertSymbolTypeAnnotation

assertSymbolTypeAnnotation: (
    opts?: object
) => asserts this is NodePath<t.SymbolTypeAnnotation>;

method assertTaggedTemplateExpression

assertTaggedTemplateExpression: (
    opts?: object
) => asserts this is NodePath<t.TaggedTemplateExpression>;

method assertTemplateElement

assertTemplateElement: (
    opts?: object
) => asserts this is NodePath<t.TemplateElement>;

method assertTemplateLiteral

assertTemplateLiteral: (
    opts?: object
) => asserts this is NodePath<t.TemplateLiteral>;

method assertTerminatorless

assertTerminatorless: (
    opts?: object
) => asserts this is NodePath<t.Terminatorless>;

method assertThisExpression

assertThisExpression: (
    opts?: object
) => asserts this is NodePath<t.ThisExpression>;

method assertThisTypeAnnotation

assertThisTypeAnnotation: (
    opts?: object
) => asserts this is NodePath<t.ThisTypeAnnotation>;

method assertThrowStatement

assertThrowStatement: (
    opts?: object
) => asserts this is NodePath<t.ThrowStatement>;

method assertTopicReference

assertTopicReference: (
    opts?: object
) => asserts this is NodePath<t.TopicReference>;

method assertTryStatement

assertTryStatement: (opts?: object) => asserts this is NodePath<t.TryStatement>;

method assertTSAnyKeyword

assertTSAnyKeyword: (opts?: object) => asserts this is NodePath<t.TSAnyKeyword>;

method assertTSArrayType

assertTSArrayType: (opts?: object) => asserts this is NodePath<t.TSArrayType>;

method assertTSAsExpression

assertTSAsExpression: (
    opts?: object
) => asserts this is NodePath<t.TSAsExpression>;

method assertTSBaseType

assertTSBaseType: (opts?: object) => asserts this is NodePath<t.TSBaseType>;

method assertTSBigIntKeyword

assertTSBigIntKeyword: (
    opts?: object
) => asserts this is NodePath<t.TSBigIntKeyword>;

method assertTSBooleanKeyword

assertTSBooleanKeyword: (
    opts?: object
) => asserts this is NodePath<t.TSBooleanKeyword>;

method assertTSCallSignatureDeclaration

assertTSCallSignatureDeclaration: (
    opts?: object
) => asserts this is NodePath<t.TSCallSignatureDeclaration>;

method assertTSConditionalType

assertTSConditionalType: (
    opts?: object
) => asserts this is NodePath<t.TSConditionalType>;

method assertTSConstructorType

assertTSConstructorType: (
    opts?: object
) => asserts this is NodePath<t.TSConstructorType>;

method assertTSConstructSignatureDeclaration

assertTSConstructSignatureDeclaration: (
    opts?: object
) => asserts this is NodePath<t.TSConstructSignatureDeclaration>;

method assertTSDeclareFunction

assertTSDeclareFunction: (
    opts?: object
) => asserts this is NodePath<t.TSDeclareFunction>;

method assertTSDeclareMethod

assertTSDeclareMethod: (
    opts?: object
) => asserts this is NodePath<t.TSDeclareMethod>;

method assertTSEntityName

assertTSEntityName: (opts?: object) => asserts this is NodePath<t.TSEntityName>;

method assertTSEnumDeclaration

assertTSEnumDeclaration: (
    opts?: object
) => asserts this is NodePath<t.TSEnumDeclaration>;

method assertTSEnumMember

assertTSEnumMember: (opts?: object) => asserts this is NodePath<t.TSEnumMember>;

method assertTSExportAssignment

assertTSExportAssignment: (
    opts?: object
) => asserts this is NodePath<t.TSExportAssignment>;

method assertTSExpressionWithTypeArguments

assertTSExpressionWithTypeArguments: (
    opts?: object
) => asserts this is NodePath<t.TSExpressionWithTypeArguments>;

method assertTSExternalModuleReference

assertTSExternalModuleReference: (
    opts?: object
) => asserts this is NodePath<t.TSExternalModuleReference>;

method assertTSFunctionType

assertTSFunctionType: (
    opts?: object
) => asserts this is NodePath<t.TSFunctionType>;

method assertTSImportEqualsDeclaration

assertTSImportEqualsDeclaration: (
    opts?: object
) => asserts this is NodePath<t.TSImportEqualsDeclaration>;

method assertTSImportType

assertTSImportType: (opts?: object) => asserts this is NodePath<t.TSImportType>;

method assertTSIndexedAccessType

assertTSIndexedAccessType: (
    opts?: object
) => asserts this is NodePath<t.TSIndexedAccessType>;

method assertTSIndexSignature

assertTSIndexSignature: (
    opts?: object
) => asserts this is NodePath<t.TSIndexSignature>;

method assertTSInferType

assertTSInferType: (opts?: object) => asserts this is NodePath<t.TSInferType>;

method assertTSInstantiationExpression

assertTSInstantiationExpression: (
    opts?: object
) => asserts this is NodePath<t.TSInstantiationExpression>;

method assertTSInterfaceBody

assertTSInterfaceBody: (
    opts?: object
) => asserts this is NodePath<t.TSInterfaceBody>;

method assertTSInterfaceDeclaration

assertTSInterfaceDeclaration: (
    opts?: object
) => asserts this is NodePath<t.TSInterfaceDeclaration>;

method assertTSIntersectionType

assertTSIntersectionType: (
    opts?: object
) => asserts this is NodePath<t.TSIntersectionType>;

method assertTSIntrinsicKeyword

assertTSIntrinsicKeyword: (
    opts?: object
) => asserts this is NodePath<t.TSIntrinsicKeyword>;

method assertTSLiteralType

assertTSLiteralType: (
    opts?: object
) => asserts this is NodePath<t.TSLiteralType>;

method assertTSMappedType

assertTSMappedType: (opts?: object) => asserts this is NodePath<t.TSMappedType>;

method assertTSMethodSignature

assertTSMethodSignature: (
    opts?: object
) => asserts this is NodePath<t.TSMethodSignature>;

method assertTSModuleBlock

assertTSModuleBlock: (
    opts?: object
) => asserts this is NodePath<t.TSModuleBlock>;

method assertTSModuleDeclaration

assertTSModuleDeclaration: (
    opts?: object
) => asserts this is NodePath<t.TSModuleDeclaration>;

method assertTSNamedTupleMember

assertTSNamedTupleMember: (
    opts?: object
) => asserts this is NodePath<t.TSNamedTupleMember>;

method assertTSNamespaceExportDeclaration

assertTSNamespaceExportDeclaration: (
    opts?: object
) => asserts this is NodePath<t.TSNamespaceExportDeclaration>;

method assertTSNeverKeyword

assertTSNeverKeyword: (
    opts?: object
) => asserts this is NodePath<t.TSNeverKeyword>;

method assertTSNonNullExpression

assertTSNonNullExpression: (
    opts?: object
) => asserts this is NodePath<t.TSNonNullExpression>;

method assertTSNullKeyword

assertTSNullKeyword: (
    opts?: object
) => asserts this is NodePath<t.TSNullKeyword>;

method assertTSNumberKeyword

assertTSNumberKeyword: (
    opts?: object
) => asserts this is NodePath<t.TSNumberKeyword>;

method assertTSObjectKeyword

assertTSObjectKeyword: (
    opts?: object
) => asserts this is NodePath<t.TSObjectKeyword>;

method assertTSOptionalType

assertTSOptionalType: (
    opts?: object
) => asserts this is NodePath<t.TSOptionalType>;

method assertTSParameterProperty

assertTSParameterProperty: (
    opts?: object
) => asserts this is NodePath<t.TSParameterProperty>;

method assertTSParenthesizedType

assertTSParenthesizedType: (
    opts?: object
) => asserts this is NodePath<t.TSParenthesizedType>;

method assertTSPropertySignature

assertTSPropertySignature: (
    opts?: object
) => asserts this is NodePath<t.TSPropertySignature>;

method assertTSQualifiedName

assertTSQualifiedName: (
    opts?: object
) => asserts this is NodePath<t.TSQualifiedName>;

method assertTSRestType

assertTSRestType: (opts?: object) => asserts this is NodePath<t.TSRestType>;

method assertTSSatisfiesExpression

assertTSSatisfiesExpression: (
    opts?: object
) => asserts this is NodePath<t.TSSatisfiesExpression>;

method assertTSStringKeyword

assertTSStringKeyword: (
    opts?: object
) => asserts this is NodePath<t.TSStringKeyword>;

method assertTSSymbolKeyword

assertTSSymbolKeyword: (
    opts?: object
) => asserts this is NodePath<t.TSSymbolKeyword>;

method assertTSThisType

assertTSThisType: (opts?: object) => asserts this is NodePath<t.TSThisType>;

method assertTSTupleType

assertTSTupleType: (opts?: object) => asserts this is NodePath<t.TSTupleType>;

method assertTSType

assertTSType: (opts?: object) => asserts this is NodePath<t.TSType>;

method assertTSTypeAliasDeclaration

assertTSTypeAliasDeclaration: (
    opts?: object
) => asserts this is NodePath<t.TSTypeAliasDeclaration>;

method assertTSTypeAnnotation

assertTSTypeAnnotation: (
    opts?: object
) => asserts this is NodePath<t.TSTypeAnnotation>;

method assertTSTypeAssertion

assertTSTypeAssertion: (
    opts?: object
) => asserts this is NodePath<t.TSTypeAssertion>;

method assertTSTypeElement

assertTSTypeElement: (
    opts?: object
) => asserts this is NodePath<t.TSTypeElement>;

method assertTSTypeLiteral

assertTSTypeLiteral: (
    opts?: object
) => asserts this is NodePath<t.TSTypeLiteral>;

method assertTSTypeOperator

assertTSTypeOperator: (
    opts?: object
) => asserts this is NodePath<t.TSTypeOperator>;

method assertTSTypeParameter

assertTSTypeParameter: (
    opts?: object
) => asserts this is NodePath<t.TSTypeParameter>;

method assertTSTypeParameterDeclaration

assertTSTypeParameterDeclaration: (
    opts?: object
) => asserts this is NodePath<t.TSTypeParameterDeclaration>;

method assertTSTypeParameterInstantiation

assertTSTypeParameterInstantiation: (
    opts?: object
) => asserts this is NodePath<t.TSTypeParameterInstantiation>;

method assertTSTypePredicate

assertTSTypePredicate: (
    opts?: object
) => asserts this is NodePath<t.TSTypePredicate>;

method assertTSTypeQuery

assertTSTypeQuery: (opts?: object) => asserts this is NodePath<t.TSTypeQuery>;

method assertTSTypeReference

assertTSTypeReference: (
    opts?: object
) => asserts this is NodePath<t.TSTypeReference>;

method assertTSUndefinedKeyword

assertTSUndefinedKeyword: (
    opts?: object
) => asserts this is NodePath<t.TSUndefinedKeyword>;

method assertTSUnionType

assertTSUnionType: (opts?: object) => asserts this is NodePath<t.TSUnionType>;

method assertTSUnknownKeyword

assertTSUnknownKeyword: (
    opts?: object
) => asserts this is NodePath<t.TSUnknownKeyword>;

method assertTSVoidKeyword

assertTSVoidKeyword: (
    opts?: object
) => asserts this is NodePath<t.TSVoidKeyword>;

method assertTupleExpression

assertTupleExpression: (
    opts?: object
) => asserts this is NodePath<t.TupleExpression>;

method assertTupleTypeAnnotation

assertTupleTypeAnnotation: (
    opts?: object
) => asserts this is NodePath<t.TupleTypeAnnotation>;

method assertTypeAlias

assertTypeAlias: (opts?: object) => asserts this is NodePath<t.TypeAlias>;

method assertTypeAnnotation

assertTypeAnnotation: (
    opts?: object
) => asserts this is NodePath<t.TypeAnnotation>;

method assertTypeCastExpression

assertTypeCastExpression: (
    opts?: object
) => asserts this is NodePath<t.TypeCastExpression>;

method assertTypeofTypeAnnotation

assertTypeofTypeAnnotation: (
    opts?: object
) => asserts this is NodePath<t.TypeofTypeAnnotation>;

method assertTypeParameter

assertTypeParameter: (
    opts?: object
) => asserts this is NodePath<t.TypeParameter>;

method assertTypeParameterDeclaration

assertTypeParameterDeclaration: (
    opts?: object
) => asserts this is NodePath<t.TypeParameterDeclaration>;

method assertTypeParameterInstantiation

assertTypeParameterInstantiation: (
    opts?: object
) => asserts this is NodePath<t.TypeParameterInstantiation>;

method assertTypeScript

assertTypeScript: (opts?: object) => asserts this is NodePath<t.TypeScript>;

method assertUnaryExpression

assertUnaryExpression: (
    opts?: object
) => asserts this is NodePath<t.UnaryExpression>;

method assertUnaryLike

assertUnaryLike: (opts?: object) => asserts this is NodePath<t.UnaryLike>;

method assertUnionTypeAnnotation

assertUnionTypeAnnotation: (
    opts?: object
) => asserts this is NodePath<t.UnionTypeAnnotation>;

method assertUpdateExpression

assertUpdateExpression: (
    opts?: object
) => asserts this is NodePath<t.UpdateExpression>;

method assertUserWhitespacable

assertUserWhitespacable: (
    opts?: object
) => asserts this is NodePath<t.UserWhitespacable>;

method assertV8IntrinsicIdentifier

assertV8IntrinsicIdentifier: (
    opts?: object
) => asserts this is NodePath<t.V8IntrinsicIdentifier>;

method assertVariableDeclaration

assertVariableDeclaration: (
    opts?: object
) => asserts this is NodePath<t.VariableDeclaration>;

method assertVariableDeclarator

assertVariableDeclarator: (
    opts?: object
) => asserts this is NodePath<t.VariableDeclarator>;

method assertVariance

assertVariance: (opts?: object) => asserts this is NodePath<t.Variance>;

method assertVoidTypeAnnotation

assertVoidTypeAnnotation: (
    opts?: object
) => asserts this is NodePath<t.VoidTypeAnnotation>;

method assertWhile

assertWhile: (opts?: object) => asserts this is NodePath<t.While>;

method assertWhileStatement

assertWhileStatement: (
    opts?: object
) => asserts this is NodePath<t.WhileStatement>;

method assertWithStatement

assertWithStatement: (
    opts?: object
) => asserts this is NodePath<t.WithStatement>;

method assertYieldExpression

assertYieldExpression: (
    opts?: object
) => asserts this is NodePath<t.YieldExpression>;

method baseTypeStrictlyMatches

baseTypeStrictlyMatches: (rightArg: NodePath) => boolean;

method buildCodeFrameError

buildCodeFrameError: (msg: string, Error?: ErrorConstructor) => Error;

method call

call: (key: string) => boolean;

method canHaveVariableDeclarationOrExpression

canHaveVariableDeclarationOrExpression: () => boolean;

This checks whether or not we're in one of the following positions:
for (KEY in right); for (KEY;;);
This is because these spots allow VariableDeclarations AND normal expressions so we need to tell the path replacement that it's ok to replace this with an expression.

method canSwapBetweenExpressionAndStatement

canSwapBetweenExpressionAndStatement: (replacement: Node) => boolean;

This checks whether we are swapping an arrow function's body between an expression and a block statement (or vice versa).
This is because arrow functions may implicitly return an expression, which is the same as containing a block statement.

method couldBeBaseType

couldBeBaseType: (name: string) => boolean;

method debug

debug: (buildMessage: () => string) => void;

method ensureBlock

ensureBlock: (
    this: NodePath<
        | t.Loop
        | t.WithStatement
        | t.Function
        | t.LabeledStatement
        | t.CatchClause
    >
) => asserts this is NodePath<T & { body: t.BlockStatement }>;

method equals

equals: (key: string, value: any) => boolean;

Check whether the path node key strict equals value.

method evaluate

evaluate: () => { confident: boolean; value: any; deopt?: NodePath };

Walk the input node and statically evaluate it.
Returns an object in the form { confident, value, deopt }. confident indicates whether or not we had to drop out of evaluating the expression because of hitting an unknown node that we couldn't confidently find the value of, in which case deopt is the path of said node.
Example:
t.evaluate(parse("5 + 5")) // { confident: true, value: 10 } t.evaluate(parse("!true")) // { confident: true, value: false } t.evaluate(parse("foo + foo")) // { confident: false, value: undefined, deopt: NodePath }

method evaluateTruthy

evaluateTruthy: () => boolean | undefined;

Walk the input node and statically evaluate if it's truthy.
Returning true when we're sure that the expression will evaluate to a truthy value, false if we're sure that it will evaluate to a falsy value and undefined if we aren't sure. Because of this please do not rely on coercion when using this method and check with === if it's false.

method find

find: (callback: (path: NodePath) => boolean) => NodePath | null;

Starting at current NodePath and going up the tree, return the first NodePath that causes the provided callback to return a truthy value, or null if the callback never returns a truthy value.

method findParent

findParent: (callback: (path: NodePath) => boolean) => NodePath | null;

Starting at the parent path of the current NodePath and going up the tree, return the first NodePath that causes the provided callback to return a truthy value, or null if the callback never returns a truthy value.

method get

static get: {
    <C extends Node, K extends keyof C>(opts: {
        hub?: HubInterface;
        parentPath: NodePath | null;
        parent: Node;
        container: C;
        key: K;
    }): NodePath<C[K]>;
    <C extends Node, L extends NodeKeyOfArrays<C>>(opts: {
        hub?: HubInterface;
        parentPath: NodePath<Node>;
        parent: Node;
        container: C;
        listKey: L;
        key: number;
    }): C[L] extends any[] ? NodePath<C[L][number]> : never;
};

method getAllNextSiblings

getAllNextSiblings: () => NodePath[];

method getAllPrevSiblings

getAllPrevSiblings: () => NodePath[];

method getAncestry

getAncestry: () => [this, ...NodePath[]];

Build an array of node paths containing the entire ancestry of the current node path.
NOTE: The current node path is included in this.

method getBindingIdentifierPaths

getBindingIdentifierPaths: {
    (duplicates: true, outerOnly?: boolean): Record<
        string,
        Array<NodePath<t.Identifier>>
    >;
    (duplicates?: false, outerOnly?: boolean): Record<
        string,
        NodePath<t.Identifier>
    >;
    (duplicates?: boolean, outerOnly?: boolean): Record<
        string,
        NodePath<t.Identifier> | NodePath<t.Identifier>[]
    >;
};

method getBindingIdentifiers

getBindingIdentifiers: {
    (duplicates: true): Record<string, t.Identifier[]>;
    (duplicates?: false): Record<string, t.Identifier>;
    (duplicates?: boolean): Record<string, any>;
};

method getCompletionRecords

getCompletionRecords: () => NodePath[];

method getData

getData: (key: string | symbol, def?: any) => any;

method getDeepestCommonAncestorFrom

getDeepestCommonAncestorFrom: (
    paths: NodePath[],
    filter?: (deepest: Node, i: number, ancestries: NodePath[][]) => NodePath
) => NodePath;

Get the earliest path in the tree where the provided paths intersect.

method getEarliestCommonAncestorFrom

getEarliestCommonAncestorFrom: (paths: NodePath[]) => NodePath;

Get the deepest common ancestor and then from it, get the earliest relationship path to that ancestor.
Earliest is defined as being "before" all the other nodes in terms of list container position and visiting key.

method getFunctionParent

getFunctionParent: () => NodePath<t.Function> | null;

Get the parent function of the current path.

method getNextSibling

getNextSibling: () => NodePath;

method getOpposite

getOpposite: () => NodePath | null;

method getOuterBindingIdentifierPaths

getOuterBindingIdentifierPaths: {
    (duplicates: true): Record<string, Array<NodePath<t.Identifier>>>;
    (duplicates?: false): Record<string, NodePath<t.Identifier>>;
    (duplicates?: boolean, outerOnly?: boolean): Record<
        string,
        NodePath<t.Identifier> | NodePath<t.Identifier>[]
    >;
};

method getOuterBindingIdentifiers

getOuterBindingIdentifiers: {
    (duplicates: true): Record<string, t.Identifier[]>;
    (duplicates?: false): Record<string, t.Identifier>;
    (duplicates?: boolean): Record<string, any>;
};

method getPathLocation

getPathLocation: () => string;

method getPrevSibling

getPrevSibling: () => NodePath;

method getScope

getScope: (scope: Scope) => Scope;

method getSibling

getSibling: (key: string | number) => NodePath;

method getSource

getSource: () => string;

Get the source code associated with this node.

method getStatementParent

getStatementParent: () => NodePath<t.Statement> | null;

Walk up the tree until we hit a parent node path in a list.

method getTypeAnnotation

getTypeAnnotation: () => t.FlowType | t.TSType;

Infer the type of the current NodePath.

method has

has: (key: string) => boolean;

Check whether we have the input key. If the key references an array then we check if the array has any items, otherwise we just check if it's falsy.

method hasNode

hasNode: () => this is NodePath<Exclude<T, null>>;

method hoist

hoist: (scope: Scope) => void;

Hoist the current node to the highest scope possible and return a UID referencing it.

method insertAfter

insertAfter: <Nodes extends unknown>(nodes: Nodes) => NodePaths<Nodes>;

Insert the provided nodes after the current one. When inserting nodes after an expression, ensure that the completion record is correct by pushing the current node.

method insertBefore

insertBefore: <Nodes extends unknown>(nodes: Nodes) => NodePaths<Nodes>;

Insert the provided nodes before the current one.

method inType

inType: (...candidateTypes: string[]) => boolean;

method is

is: (key: string) => boolean;

Alias of has.

method isAccessor

isAccessor: (opts?: object) => this is NodePath<t.Accessor>;

method isAncestor

isAncestor: (maybeDescendant: NodePath) => boolean;

A helper to find if this path is an ancestor of maybeDescendant

method isAnyTypeAnnotation

isAnyTypeAnnotation: (opts?: object) => this is NodePath<t.AnyTypeAnnotation>;

method isArgumentPlaceholder

isArgumentPlaceholder: (
    opts?: object
) => this is NodePath<t.ArgumentPlaceholder>;

method isArrayExpression

isArrayExpression: (opts?: object) => this is NodePath<t.ArrayExpression>;

method isArrayPattern

isArrayPattern: (opts?: object) => this is NodePath<t.ArrayPattern>;

method isArrayTypeAnnotation

isArrayTypeAnnotation: (
    opts?: object
) => this is NodePath<t.ArrayTypeAnnotation>;

method isArrowFunctionExpression

isArrowFunctionExpression: (
    opts?: object
) => this is NodePath<t.ArrowFunctionExpression>;

method isAssignmentExpression

isAssignmentExpression: (
    opts?: object
) => this is NodePath<t.AssignmentExpression>;

method isAssignmentPattern

isAssignmentPattern: (opts?: object) => this is NodePath<t.AssignmentPattern>;

method isAwaitExpression

isAwaitExpression: (opts?: object) => this is NodePath<t.AwaitExpression>;

method isBaseType

isBaseType: (baseName: string, soft?: boolean) => boolean;

method isBigIntLiteral

isBigIntLiteral: (opts?: object) => this is NodePath<t.BigIntLiteral>;

method isBinary

isBinary: (opts?: object) => this is NodePath<t.Binary>;

method isBinaryExpression

isBinaryExpression: (opts?: object) => this is NodePath<t.BinaryExpression>;

method isBindExpression

isBindExpression: (opts?: object) => this is NodePath<t.BindExpression>;

method isBindingIdentifier

isBindingIdentifier: (opts?: object) => this is NodePath<t.Identifier>;

method isBlacklisted

isBlacklisted: () => boolean;

Deprecated
will be removed in Babel 8

method isBlock

isBlock: (opts?: object) => this is NodePath<t.Block>;

method isBlockParent

isBlockParent: (opts?: object) => this is NodePath<t.BlockParent>;

method isBlockScoped

isBlockScoped: (opts?: object) => this is NodePath<any>;

method isBlockStatement

isBlockStatement: (opts?: object) => this is NodePath<t.BlockStatement>;

method isBooleanLiteral

isBooleanLiteral: (opts?: object) => this is NodePath<t.BooleanLiteral>;

method isBooleanLiteralTypeAnnotation

isBooleanLiteralTypeAnnotation: (
    opts?: object
) => this is NodePath<t.BooleanLiteralTypeAnnotation>;

method isBooleanTypeAnnotation

isBooleanTypeAnnotation: (
    opts?: object
) => this is NodePath<t.BooleanTypeAnnotation>;

method isBreakStatement

isBreakStatement: (opts?: object) => this is NodePath<t.BreakStatement>;

method isCallExpression

isCallExpression: (opts?: object) => this is NodePath<t.CallExpression>;

method isCatchClause

isCatchClause: (opts?: object) => this is NodePath<t.CatchClause>;

method isClass

isClass: (opts?: object) => this is NodePath<t.Class>;

method isClassAccessorProperty

isClassAccessorProperty: (
    opts?: object
) => this is NodePath<t.ClassAccessorProperty>;

method isClassBody

isClassBody: (opts?: object) => this is NodePath<t.ClassBody>;

method isClassDeclaration

isClassDeclaration: (opts?: object) => this is NodePath<t.ClassDeclaration>;

method isClassExpression

isClassExpression: (opts?: object) => this is NodePath<t.ClassExpression>;

method isClassImplements

isClassImplements: (opts?: object) =>

@types/babel__traverse

Install

Overview

Index

Variables

Classes

Interfaces

Type Aliases

Namespaces

Variables

variable traverse

Classes

class Binding

constructor

property constant

property constantViolations

property hasDeoptedValue

property hasValue

property identifier

property kind

property path

property referenced

property referencePaths

property references

property scope

property value

method clearValue

method deopValue

method dereference

method reassign

method reference

method setValue

class Hub

constructor

method addHelper

method buildError

method getCode

method getScope

class NodePath

constructor

property container

property context

property contexts

property data

property hub

property inList

property key

property listKey

property node

property opts

property parent

property parentKey

property parentPath

property removed

property scope

property shouldSkip

property shouldStop

property skipKeys

property state

property type

property typeAnnotation

method addComment

method addComments

method arrowFunctionToExpression

method arrowFunctionToShadowed

Deprecated

method assertAccessor

method assertAnyTypeAnnotation

method assertArgumentPlaceholder

method assertArrayExpression

method assertArrayPattern

method assertArrayTypeAnnotation

method assertArrowFunctionExpression

method assertAssignmentExpression

method assertAssignmentPattern

method assertAwaitExpression

method assertBigIntLiteral

method assertBinary

method assertBinaryExpression

method assertBindExpression