@babel/traverse 8.0.0-alpha.8 → 8.0.0-alpha.9
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/lib/index.d.ts +3588 -0
- package/lib/index.js +161 -213
- package/lib/index.js.map +1 -1
- package/package.json +16 -13
package/lib/index.d.ts
ADDED
|
@@ -0,0 +1,3588 @@
|
|
|
1
|
+
import * as t from '@babel/types';
|
|
2
|
+
import { Node, RemovePropertiesOptions } from '@babel/types';
|
|
3
|
+
|
|
4
|
+
type BindingKind = "var" | "let" | "const" | "module" | "hoisted" | "param" | "local" | "unknown";
|
|
5
|
+
/**
|
|
6
|
+
* This class is responsible for a binding inside of a scope.
|
|
7
|
+
*
|
|
8
|
+
* It tracks the following:
|
|
9
|
+
*
|
|
10
|
+
* * Node path.
|
|
11
|
+
* * Amount of times referenced by other nodes.
|
|
12
|
+
* * Paths to nodes that reassign or modify this binding.
|
|
13
|
+
* * The kind of binding. (Is it a parameter, declaration etc)
|
|
14
|
+
*/
|
|
15
|
+
declare class Binding {
|
|
16
|
+
identifier: t.Identifier;
|
|
17
|
+
scope: Scope;
|
|
18
|
+
path: NodePath_Final;
|
|
19
|
+
kind: BindingKind;
|
|
20
|
+
constructor({ identifier, scope, path, kind, }: {
|
|
21
|
+
identifier: t.Identifier;
|
|
22
|
+
scope: Scope;
|
|
23
|
+
path: NodePath_Final;
|
|
24
|
+
kind: BindingKind;
|
|
25
|
+
});
|
|
26
|
+
constantViolations: Array<NodePath_Final>;
|
|
27
|
+
constant: boolean;
|
|
28
|
+
referencePaths: Array<NodePath_Final>;
|
|
29
|
+
referenced: boolean;
|
|
30
|
+
references: number;
|
|
31
|
+
hasDeoptedValue: boolean;
|
|
32
|
+
hasValue: boolean;
|
|
33
|
+
value: any;
|
|
34
|
+
deoptValue(): void;
|
|
35
|
+
setValue(value: any): void;
|
|
36
|
+
clearValue(): void;
|
|
37
|
+
/**
|
|
38
|
+
* Register a constant violation with the provided `path`.
|
|
39
|
+
*/
|
|
40
|
+
reassign(path: NodePath_Final): void;
|
|
41
|
+
/**
|
|
42
|
+
* Increment the amount of references to this binding.
|
|
43
|
+
*/
|
|
44
|
+
reference(path: NodePath_Final): void;
|
|
45
|
+
/**
|
|
46
|
+
* Decrement the amount of references to this binding.
|
|
47
|
+
*/
|
|
48
|
+
dereference(): void;
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
type _Binding = Binding;
|
|
52
|
+
declare class Scope {
|
|
53
|
+
uid: number;
|
|
54
|
+
path: NodePath_Final;
|
|
55
|
+
block: t.Pattern | t.Scopable;
|
|
56
|
+
labels: Map<any, any>;
|
|
57
|
+
inited: boolean;
|
|
58
|
+
bindings: {
|
|
59
|
+
[name: string]: Binding;
|
|
60
|
+
};
|
|
61
|
+
references: {
|
|
62
|
+
[name: string]: true;
|
|
63
|
+
};
|
|
64
|
+
globals: {
|
|
65
|
+
[name: string]: t.Identifier | t.JSXIdentifier;
|
|
66
|
+
};
|
|
67
|
+
uids: {
|
|
68
|
+
[name: string]: boolean;
|
|
69
|
+
};
|
|
70
|
+
data: {
|
|
71
|
+
[key: string | symbol]: unknown;
|
|
72
|
+
};
|
|
73
|
+
crawling: boolean;
|
|
74
|
+
/**
|
|
75
|
+
* This searches the current "scope" and collects all references/bindings
|
|
76
|
+
* within.
|
|
77
|
+
*/
|
|
78
|
+
constructor(path: NodePath_Final<t.Pattern | t.Scopable>);
|
|
79
|
+
/**
|
|
80
|
+
* Globals.
|
|
81
|
+
*/
|
|
82
|
+
static globals: string[];
|
|
83
|
+
/**
|
|
84
|
+
* Variables available in current context.
|
|
85
|
+
*/
|
|
86
|
+
static contextVariables: string[];
|
|
87
|
+
get parent(): Scope;
|
|
88
|
+
get parentBlock(): t.Node;
|
|
89
|
+
get hub(): HubInterface;
|
|
90
|
+
traverse<S>(node: t.Node | t.Node[], opts: TraverseOptions<S>, state: S): void;
|
|
91
|
+
traverse(node: t.Node | t.Node[], opts?: TraverseOptions, state?: any): void;
|
|
92
|
+
/**
|
|
93
|
+
* Generate a unique identifier and add it to the current scope.
|
|
94
|
+
*/
|
|
95
|
+
generateDeclaredUidIdentifier(name?: string): t.Identifier;
|
|
96
|
+
/**
|
|
97
|
+
* Generate a unique identifier.
|
|
98
|
+
*/
|
|
99
|
+
generateUidIdentifier(name?: string): t.Identifier;
|
|
100
|
+
/**
|
|
101
|
+
* Generate a unique `_id1` binding.
|
|
102
|
+
*/
|
|
103
|
+
generateUid(name?: string): string;
|
|
104
|
+
/**
|
|
105
|
+
* Generate an `_id1`.
|
|
106
|
+
*/
|
|
107
|
+
_generateUid(name: string, i: number): string;
|
|
108
|
+
generateUidBasedOnNode(node: t.Node, defaultName?: string): string;
|
|
109
|
+
/**
|
|
110
|
+
* Generate a unique identifier based on a node.
|
|
111
|
+
*/
|
|
112
|
+
generateUidIdentifierBasedOnNode(node: t.Node, defaultName?: string): t.Identifier;
|
|
113
|
+
/**
|
|
114
|
+
* Determine whether evaluating the specific input `node` is a consequenceless reference. ie.
|
|
115
|
+
* evaluating it won't result in potentially arbitrary code from being ran. The following are
|
|
116
|
+
* allowed and determined not to cause side effects:
|
|
117
|
+
*
|
|
118
|
+
* - `this` expressions
|
|
119
|
+
* - `super` expressions
|
|
120
|
+
* - Bound identifiers
|
|
121
|
+
*/
|
|
122
|
+
isStatic(node: t.Node): boolean;
|
|
123
|
+
/**
|
|
124
|
+
* Possibly generate a memoised identifier if it is not static and has consequences.
|
|
125
|
+
*/
|
|
126
|
+
maybeGenerateMemoised(node: t.Node, dontPush?: boolean): t.Identifier;
|
|
127
|
+
checkBlockScopedCollisions(local: Binding, kind: BindingKind, name: string, id: any): void;
|
|
128
|
+
rename(oldName: string, newName?: string): void;
|
|
129
|
+
/** @deprecated Not used in our codebase */
|
|
130
|
+
_renameFromMap(map: Record<string | symbol, unknown>, oldName: string | symbol, newName: string | symbol, value: unknown): void;
|
|
131
|
+
dump(): void;
|
|
132
|
+
toArray(node: t.Node, i?: number | boolean, arrayLikeIsIterable?: boolean | void): t.ArrayExpression | t.CallExpression | t.Identifier;
|
|
133
|
+
hasLabel(name: string): boolean;
|
|
134
|
+
getLabel(name: string): any;
|
|
135
|
+
registerLabel(path: NodePath_Final<t.LabeledStatement>): void;
|
|
136
|
+
registerDeclaration(path: NodePath_Final): void;
|
|
137
|
+
buildUndefinedNode(): t.UnaryExpression;
|
|
138
|
+
registerConstantViolation(path: NodePath_Final): void;
|
|
139
|
+
registerBinding(kind: Binding["kind"], path: NodePath_Final, bindingPath?: NodePath_Final): void;
|
|
140
|
+
addGlobal(node: t.Identifier | t.JSXIdentifier): void;
|
|
141
|
+
hasUid(name: string): boolean;
|
|
142
|
+
hasGlobal(name: string): boolean;
|
|
143
|
+
hasReference(name: string): boolean;
|
|
144
|
+
isPure(node: t.Node, constantsOnly?: boolean): boolean;
|
|
145
|
+
/**
|
|
146
|
+
* Set some arbitrary data on the current scope.
|
|
147
|
+
*/
|
|
148
|
+
setData(key: string | symbol, val: any): any;
|
|
149
|
+
/**
|
|
150
|
+
* Recursively walk up scope tree looking for the data `key`.
|
|
151
|
+
*/
|
|
152
|
+
getData(key: string | symbol): any;
|
|
153
|
+
/**
|
|
154
|
+
* Recursively walk up scope tree looking for the data `key` and if it exists,
|
|
155
|
+
* remove it.
|
|
156
|
+
*/
|
|
157
|
+
removeData(key: string): void;
|
|
158
|
+
init(): void;
|
|
159
|
+
crawl(): void;
|
|
160
|
+
push(opts: {
|
|
161
|
+
id: t.LVal;
|
|
162
|
+
init?: t.Expression;
|
|
163
|
+
unique?: boolean;
|
|
164
|
+
_blockHoist?: number | undefined;
|
|
165
|
+
kind?: "var" | "let" | "const";
|
|
166
|
+
}): void;
|
|
167
|
+
/**
|
|
168
|
+
* Walk up to the top of the scope tree and get the `Program`.
|
|
169
|
+
*/
|
|
170
|
+
getProgramParent(): Scope;
|
|
171
|
+
/**
|
|
172
|
+
* Walk up the scope tree until we hit either a Function or return null.
|
|
173
|
+
*/
|
|
174
|
+
getFunctionParent(): Scope | null;
|
|
175
|
+
/**
|
|
176
|
+
* Walk up the scope tree until we hit either a BlockStatement/Loop/Program/Function/Switch or reach the
|
|
177
|
+
* very top and hit Program.
|
|
178
|
+
*/
|
|
179
|
+
getBlockParent(): Scope;
|
|
180
|
+
/**
|
|
181
|
+
* Walk up from a pattern scope (function param initializer) until we hit a non-pattern scope,
|
|
182
|
+
* then returns its block parent
|
|
183
|
+
* @returns An ancestry scope whose path is a block parent
|
|
184
|
+
*/
|
|
185
|
+
getPatternParent(): Scope;
|
|
186
|
+
/**
|
|
187
|
+
* Walks the scope tree and gathers **all** bindings.
|
|
188
|
+
*/
|
|
189
|
+
getAllBindings(): Record<string, Binding>;
|
|
190
|
+
/**
|
|
191
|
+
* Walks the scope tree and gathers all declarations of `kind`.
|
|
192
|
+
*/
|
|
193
|
+
getAllBindingsOfKind(...kinds: string[]): Record<string, Binding>;
|
|
194
|
+
bindingIdentifierEquals(name: string, node: t.Node): boolean;
|
|
195
|
+
getBinding(name: string): Binding | undefined;
|
|
196
|
+
getOwnBinding(name: string): Binding | undefined;
|
|
197
|
+
getBindingIdentifier(name: string): t.Identifier;
|
|
198
|
+
getOwnBindingIdentifier(name: string): t.Identifier;
|
|
199
|
+
hasOwnBinding(name: string): boolean;
|
|
200
|
+
hasBinding(name: string, opts?: boolean | {
|
|
201
|
+
noGlobals?: boolean;
|
|
202
|
+
noUids?: boolean;
|
|
203
|
+
}): boolean;
|
|
204
|
+
parentHasBinding(name: string, opts?: {
|
|
205
|
+
noGlobals?: boolean;
|
|
206
|
+
noUids?: boolean;
|
|
207
|
+
}): boolean;
|
|
208
|
+
/**
|
|
209
|
+
* Move a binding of `name` to another `scope`.
|
|
210
|
+
*/
|
|
211
|
+
moveBindingTo(name: string, scope: Scope): void;
|
|
212
|
+
removeOwnBinding(name: string): void;
|
|
213
|
+
removeBinding(name: string): void;
|
|
214
|
+
}
|
|
215
|
+
declare namespace Scope {
|
|
216
|
+
type Binding = _Binding;
|
|
217
|
+
}
|
|
218
|
+
//# sourceMappingURL=index.d.ts.map
|
|
219
|
+
|
|
220
|
+
interface HubInterface {
|
|
221
|
+
getCode(): string | void;
|
|
222
|
+
getScope(): Scope | void;
|
|
223
|
+
addHelper(name: string): any;
|
|
224
|
+
buildError(node: Node, msg: string, Error: new () => Error): Error;
|
|
225
|
+
}
|
|
226
|
+
declare class Hub implements HubInterface {
|
|
227
|
+
getCode(): void;
|
|
228
|
+
getScope(): void;
|
|
229
|
+
addHelper(): void;
|
|
230
|
+
buildError(node: Node, msg: string, Error?: TypeErrorConstructor): Error;
|
|
231
|
+
}
|
|
232
|
+
|
|
233
|
+
declare class TraversalContext<S = unknown> {
|
|
234
|
+
constructor(scope: Scope, opts: ExplodedTraverseOptions<S>, state: S, parentPath: NodePath_Final);
|
|
235
|
+
parentPath: NodePath_Final;
|
|
236
|
+
scope: Scope;
|
|
237
|
+
state: S;
|
|
238
|
+
opts: ExplodedTraverseOptions<S>;
|
|
239
|
+
queue: Array<NodePath_Final> | null;
|
|
240
|
+
priorityQueue: Array<NodePath_Final> | null;
|
|
241
|
+
/**
|
|
242
|
+
* This method does a simple check to determine whether or not we really need to attempt
|
|
243
|
+
* visit a node. This will prevent us from constructing a NodePath.
|
|
244
|
+
*/
|
|
245
|
+
shouldVisit(node: t.Node): boolean;
|
|
246
|
+
create(node: t.Node, container: t.Node | t.Node[], key: string | number, listKey?: string): NodePath_Final;
|
|
247
|
+
maybeQueue(path: NodePath_Final, notPriority?: boolean): void;
|
|
248
|
+
visitMultiple(container: t.Node[], parent: t.Node, listKey: string): boolean;
|
|
249
|
+
visitSingle(node: t.Node, key: string): boolean;
|
|
250
|
+
visitQueue(queue: Array<NodePath_Final>): boolean;
|
|
251
|
+
visit(node: t.Node, key: string): boolean;
|
|
252
|
+
}
|
|
253
|
+
|
|
254
|
+
interface VirtualTypeAliases {
|
|
255
|
+
BindingIdentifier: t.Identifier;
|
|
256
|
+
BlockScoped: t.Node;
|
|
257
|
+
ExistentialTypeParam: t.ExistsTypeAnnotation;
|
|
258
|
+
Expression: t.Expression;
|
|
259
|
+
Flow: t.Flow | t.ImportDeclaration | t.ExportDeclaration | t.ImportSpecifier;
|
|
260
|
+
ForAwaitStatement: t.ForOfStatement;
|
|
261
|
+
Generated: t.Node;
|
|
262
|
+
NumericLiteralTypeAnnotation: t.NumberLiteralTypeAnnotation;
|
|
263
|
+
Pure: t.Node;
|
|
264
|
+
Referenced: t.Node;
|
|
265
|
+
ReferencedIdentifier: t.Identifier | t.JSXIdentifier;
|
|
266
|
+
ReferencedMemberExpression: t.MemberExpression;
|
|
267
|
+
RestProperty: t.RestElement;
|
|
268
|
+
Scope: t.Scopable | t.Pattern;
|
|
269
|
+
SpreadProperty: t.RestElement;
|
|
270
|
+
Statement: t.Statement;
|
|
271
|
+
User: t.Node;
|
|
272
|
+
Var: t.VariableDeclaration;
|
|
273
|
+
}
|
|
274
|
+
|
|
275
|
+
/*
|
|
276
|
+
* This file is auto-generated! Do not modify it directly.
|
|
277
|
+
* To re-generate run 'make build'
|
|
278
|
+
*/
|
|
279
|
+
|
|
280
|
+
|
|
281
|
+
interface ExplVisitorBase<S> {
|
|
282
|
+
AnyTypeAnnotation?: ExplVisitNode<S, t.AnyTypeAnnotation>;
|
|
283
|
+
ArgumentPlaceholder?: ExplVisitNode<S, t.ArgumentPlaceholder>;
|
|
284
|
+
ArrayExpression?: ExplVisitNode<S, t.ArrayExpression>;
|
|
285
|
+
ArrayPattern?: ExplVisitNode<S, t.ArrayPattern>;
|
|
286
|
+
ArrayTypeAnnotation?: ExplVisitNode<S, t.ArrayTypeAnnotation>;
|
|
287
|
+
ArrowFunctionExpression?: ExplVisitNode<S, t.ArrowFunctionExpression>;
|
|
288
|
+
AssignmentExpression?: ExplVisitNode<S, t.AssignmentExpression>;
|
|
289
|
+
AssignmentPattern?: ExplVisitNode<S, t.AssignmentPattern>;
|
|
290
|
+
AwaitExpression?: ExplVisitNode<S, t.AwaitExpression>;
|
|
291
|
+
BigIntLiteral?: ExplVisitNode<S, t.BigIntLiteral>;
|
|
292
|
+
BinaryExpression?: ExplVisitNode<S, t.BinaryExpression>;
|
|
293
|
+
BindExpression?: ExplVisitNode<S, t.BindExpression>;
|
|
294
|
+
BlockStatement?: ExplVisitNode<S, t.BlockStatement>;
|
|
295
|
+
BooleanLiteral?: ExplVisitNode<S, t.BooleanLiteral>;
|
|
296
|
+
BooleanLiteralTypeAnnotation?: ExplVisitNode<
|
|
297
|
+
S,
|
|
298
|
+
t.BooleanLiteralTypeAnnotation
|
|
299
|
+
>;
|
|
300
|
+
BooleanTypeAnnotation?: ExplVisitNode<S, t.BooleanTypeAnnotation>;
|
|
301
|
+
BreakStatement?: ExplVisitNode<S, t.BreakStatement>;
|
|
302
|
+
CallExpression?: ExplVisitNode<S, t.CallExpression>;
|
|
303
|
+
CatchClause?: ExplVisitNode<S, t.CatchClause>;
|
|
304
|
+
ClassAccessorProperty?: ExplVisitNode<S, t.ClassAccessorProperty>;
|
|
305
|
+
ClassBody?: ExplVisitNode<S, t.ClassBody>;
|
|
306
|
+
ClassDeclaration?: ExplVisitNode<S, t.ClassDeclaration>;
|
|
307
|
+
ClassExpression?: ExplVisitNode<S, t.ClassExpression>;
|
|
308
|
+
ClassImplements?: ExplVisitNode<S, t.ClassImplements>;
|
|
309
|
+
ClassMethod?: ExplVisitNode<S, t.ClassMethod>;
|
|
310
|
+
ClassPrivateMethod?: ExplVisitNode<S, t.ClassPrivateMethod>;
|
|
311
|
+
ClassPrivateProperty?: ExplVisitNode<S, t.ClassPrivateProperty>;
|
|
312
|
+
ClassProperty?: ExplVisitNode<S, t.ClassProperty>;
|
|
313
|
+
ConditionalExpression?: ExplVisitNode<S, t.ConditionalExpression>;
|
|
314
|
+
ContinueStatement?: ExplVisitNode<S, t.ContinueStatement>;
|
|
315
|
+
DebuggerStatement?: ExplVisitNode<S, t.DebuggerStatement>;
|
|
316
|
+
DecimalLiteral?: ExplVisitNode<S, t.DecimalLiteral>;
|
|
317
|
+
DeclareClass?: ExplVisitNode<S, t.DeclareClass>;
|
|
318
|
+
DeclareExportAllDeclaration?: ExplVisitNode<S, t.DeclareExportAllDeclaration>;
|
|
319
|
+
DeclareExportDeclaration?: ExplVisitNode<S, t.DeclareExportDeclaration>;
|
|
320
|
+
DeclareFunction?: ExplVisitNode<S, t.DeclareFunction>;
|
|
321
|
+
DeclareInterface?: ExplVisitNode<S, t.DeclareInterface>;
|
|
322
|
+
DeclareModule?: ExplVisitNode<S, t.DeclareModule>;
|
|
323
|
+
DeclareModuleExports?: ExplVisitNode<S, t.DeclareModuleExports>;
|
|
324
|
+
DeclareOpaqueType?: ExplVisitNode<S, t.DeclareOpaqueType>;
|
|
325
|
+
DeclareTypeAlias?: ExplVisitNode<S, t.DeclareTypeAlias>;
|
|
326
|
+
DeclareVariable?: ExplVisitNode<S, t.DeclareVariable>;
|
|
327
|
+
DeclaredPredicate?: ExplVisitNode<S, t.DeclaredPredicate>;
|
|
328
|
+
Decorator?: ExplVisitNode<S, t.Decorator>;
|
|
329
|
+
Directive?: ExplVisitNode<S, t.Directive>;
|
|
330
|
+
DirectiveLiteral?: ExplVisitNode<S, t.DirectiveLiteral>;
|
|
331
|
+
DoExpression?: ExplVisitNode<S, t.DoExpression>;
|
|
332
|
+
DoWhileStatement?: ExplVisitNode<S, t.DoWhileStatement>;
|
|
333
|
+
EmptyStatement?: ExplVisitNode<S, t.EmptyStatement>;
|
|
334
|
+
EmptyTypeAnnotation?: ExplVisitNode<S, t.EmptyTypeAnnotation>;
|
|
335
|
+
EnumBooleanBody?: ExplVisitNode<S, t.EnumBooleanBody>;
|
|
336
|
+
EnumBooleanMember?: ExplVisitNode<S, t.EnumBooleanMember>;
|
|
337
|
+
EnumDeclaration?: ExplVisitNode<S, t.EnumDeclaration>;
|
|
338
|
+
EnumDefaultedMember?: ExplVisitNode<S, t.EnumDefaultedMember>;
|
|
339
|
+
EnumNumberBody?: ExplVisitNode<S, t.EnumNumberBody>;
|
|
340
|
+
EnumNumberMember?: ExplVisitNode<S, t.EnumNumberMember>;
|
|
341
|
+
EnumStringBody?: ExplVisitNode<S, t.EnumStringBody>;
|
|
342
|
+
EnumStringMember?: ExplVisitNode<S, t.EnumStringMember>;
|
|
343
|
+
EnumSymbolBody?: ExplVisitNode<S, t.EnumSymbolBody>;
|
|
344
|
+
ExistsTypeAnnotation?: ExplVisitNode<S, t.ExistsTypeAnnotation>;
|
|
345
|
+
ExportAllDeclaration?: ExplVisitNode<S, t.ExportAllDeclaration>;
|
|
346
|
+
ExportDefaultDeclaration?: ExplVisitNode<S, t.ExportDefaultDeclaration>;
|
|
347
|
+
ExportDefaultSpecifier?: ExplVisitNode<S, t.ExportDefaultSpecifier>;
|
|
348
|
+
ExportNamedDeclaration?: ExplVisitNode<S, t.ExportNamedDeclaration>;
|
|
349
|
+
ExportNamespaceSpecifier?: ExplVisitNode<S, t.ExportNamespaceSpecifier>;
|
|
350
|
+
ExportSpecifier?: ExplVisitNode<S, t.ExportSpecifier>;
|
|
351
|
+
ExpressionStatement?: ExplVisitNode<S, t.ExpressionStatement>;
|
|
352
|
+
File?: ExplVisitNode<S, t.File>;
|
|
353
|
+
ForInStatement?: ExplVisitNode<S, t.ForInStatement>;
|
|
354
|
+
ForOfStatement?: ExplVisitNode<S, t.ForOfStatement>;
|
|
355
|
+
ForStatement?: ExplVisitNode<S, t.ForStatement>;
|
|
356
|
+
FunctionDeclaration?: ExplVisitNode<S, t.FunctionDeclaration>;
|
|
357
|
+
FunctionExpression?: ExplVisitNode<S, t.FunctionExpression>;
|
|
358
|
+
FunctionTypeAnnotation?: ExplVisitNode<S, t.FunctionTypeAnnotation>;
|
|
359
|
+
FunctionTypeParam?: ExplVisitNode<S, t.FunctionTypeParam>;
|
|
360
|
+
GenericTypeAnnotation?: ExplVisitNode<S, t.GenericTypeAnnotation>;
|
|
361
|
+
Identifier?: ExplVisitNode<S, t.Identifier>;
|
|
362
|
+
IfStatement?: ExplVisitNode<S, t.IfStatement>;
|
|
363
|
+
Import?: ExplVisitNode<S, t.Import>;
|
|
364
|
+
ImportAttribute?: ExplVisitNode<S, t.ImportAttribute>;
|
|
365
|
+
ImportDeclaration?: ExplVisitNode<S, t.ImportDeclaration>;
|
|
366
|
+
ImportDefaultSpecifier?: ExplVisitNode<S, t.ImportDefaultSpecifier>;
|
|
367
|
+
ImportExpression?: ExplVisitNode<S, t.ImportExpression>;
|
|
368
|
+
ImportNamespaceSpecifier?: ExplVisitNode<S, t.ImportNamespaceSpecifier>;
|
|
369
|
+
ImportSpecifier?: ExplVisitNode<S, t.ImportSpecifier>;
|
|
370
|
+
IndexedAccessType?: ExplVisitNode<S, t.IndexedAccessType>;
|
|
371
|
+
InferredPredicate?: ExplVisitNode<S, t.InferredPredicate>;
|
|
372
|
+
InterfaceDeclaration?: ExplVisitNode<S, t.InterfaceDeclaration>;
|
|
373
|
+
InterfaceExtends?: ExplVisitNode<S, t.InterfaceExtends>;
|
|
374
|
+
InterfaceTypeAnnotation?: ExplVisitNode<S, t.InterfaceTypeAnnotation>;
|
|
375
|
+
InterpreterDirective?: ExplVisitNode<S, t.InterpreterDirective>;
|
|
376
|
+
IntersectionTypeAnnotation?: ExplVisitNode<S, t.IntersectionTypeAnnotation>;
|
|
377
|
+
JSXAttribute?: ExplVisitNode<S, t.JSXAttribute>;
|
|
378
|
+
JSXClosingElement?: ExplVisitNode<S, t.JSXClosingElement>;
|
|
379
|
+
JSXClosingFragment?: ExplVisitNode<S, t.JSXClosingFragment>;
|
|
380
|
+
JSXElement?: ExplVisitNode<S, t.JSXElement>;
|
|
381
|
+
JSXEmptyExpression?: ExplVisitNode<S, t.JSXEmptyExpression>;
|
|
382
|
+
JSXExpressionContainer?: ExplVisitNode<S, t.JSXExpressionContainer>;
|
|
383
|
+
JSXFragment?: ExplVisitNode<S, t.JSXFragment>;
|
|
384
|
+
JSXIdentifier?: ExplVisitNode<S, t.JSXIdentifier>;
|
|
385
|
+
JSXMemberExpression?: ExplVisitNode<S, t.JSXMemberExpression>;
|
|
386
|
+
JSXNamespacedName?: ExplVisitNode<S, t.JSXNamespacedName>;
|
|
387
|
+
JSXOpeningElement?: ExplVisitNode<S, t.JSXOpeningElement>;
|
|
388
|
+
JSXOpeningFragment?: ExplVisitNode<S, t.JSXOpeningFragment>;
|
|
389
|
+
JSXSpreadAttribute?: ExplVisitNode<S, t.JSXSpreadAttribute>;
|
|
390
|
+
JSXSpreadChild?: ExplVisitNode<S, t.JSXSpreadChild>;
|
|
391
|
+
JSXText?: ExplVisitNode<S, t.JSXText>;
|
|
392
|
+
LabeledStatement?: ExplVisitNode<S, t.LabeledStatement>;
|
|
393
|
+
LogicalExpression?: ExplVisitNode<S, t.LogicalExpression>;
|
|
394
|
+
MemberExpression?: ExplVisitNode<S, t.MemberExpression>;
|
|
395
|
+
MetaProperty?: ExplVisitNode<S, t.MetaProperty>;
|
|
396
|
+
MixedTypeAnnotation?: ExplVisitNode<S, t.MixedTypeAnnotation>;
|
|
397
|
+
ModuleExpression?: ExplVisitNode<S, t.ModuleExpression>;
|
|
398
|
+
NewExpression?: ExplVisitNode<S, t.NewExpression>;
|
|
399
|
+
NullLiteral?: ExplVisitNode<S, t.NullLiteral>;
|
|
400
|
+
NullLiteralTypeAnnotation?: ExplVisitNode<S, t.NullLiteralTypeAnnotation>;
|
|
401
|
+
NullableTypeAnnotation?: ExplVisitNode<S, t.NullableTypeAnnotation>;
|
|
402
|
+
NumberLiteral?: ExplVisitNode<S, t.NumberLiteral>;
|
|
403
|
+
NumberLiteralTypeAnnotation?: ExplVisitNode<S, t.NumberLiteralTypeAnnotation>;
|
|
404
|
+
NumberTypeAnnotation?: ExplVisitNode<S, t.NumberTypeAnnotation>;
|
|
405
|
+
NumericLiteral?: ExplVisitNode<S, t.NumericLiteral>;
|
|
406
|
+
ObjectExpression?: ExplVisitNode<S, t.ObjectExpression>;
|
|
407
|
+
ObjectMethod?: ExplVisitNode<S, t.ObjectMethod>;
|
|
408
|
+
ObjectPattern?: ExplVisitNode<S, t.ObjectPattern>;
|
|
409
|
+
ObjectProperty?: ExplVisitNode<S, t.ObjectProperty>;
|
|
410
|
+
ObjectTypeAnnotation?: ExplVisitNode<S, t.ObjectTypeAnnotation>;
|
|
411
|
+
ObjectTypeCallProperty?: ExplVisitNode<S, t.ObjectTypeCallProperty>;
|
|
412
|
+
ObjectTypeIndexer?: ExplVisitNode<S, t.ObjectTypeIndexer>;
|
|
413
|
+
ObjectTypeInternalSlot?: ExplVisitNode<S, t.ObjectTypeInternalSlot>;
|
|
414
|
+
ObjectTypeProperty?: ExplVisitNode<S, t.ObjectTypeProperty>;
|
|
415
|
+
ObjectTypeSpreadProperty?: ExplVisitNode<S, t.ObjectTypeSpreadProperty>;
|
|
416
|
+
OpaqueType?: ExplVisitNode<S, t.OpaqueType>;
|
|
417
|
+
OptionalCallExpression?: ExplVisitNode<S, t.OptionalCallExpression>;
|
|
418
|
+
OptionalIndexedAccessType?: ExplVisitNode<S, t.OptionalIndexedAccessType>;
|
|
419
|
+
OptionalMemberExpression?: ExplVisitNode<S, t.OptionalMemberExpression>;
|
|
420
|
+
ParenthesizedExpression?: ExplVisitNode<S, t.ParenthesizedExpression>;
|
|
421
|
+
PipelineBareFunction?: ExplVisitNode<S, t.PipelineBareFunction>;
|
|
422
|
+
PipelinePrimaryTopicReference?: ExplVisitNode<
|
|
423
|
+
S,
|
|
424
|
+
t.PipelinePrimaryTopicReference
|
|
425
|
+
>;
|
|
426
|
+
PipelineTopicExpression?: ExplVisitNode<S, t.PipelineTopicExpression>;
|
|
427
|
+
Placeholder?: ExplVisitNode<S, t.Placeholder>;
|
|
428
|
+
PrivateName?: ExplVisitNode<S, t.PrivateName>;
|
|
429
|
+
Program?: ExplVisitNode<S, t.Program>;
|
|
430
|
+
QualifiedTypeIdentifier?: ExplVisitNode<S, t.QualifiedTypeIdentifier>;
|
|
431
|
+
RecordExpression?: ExplVisitNode<S, t.RecordExpression>;
|
|
432
|
+
RegExpLiteral?: ExplVisitNode<S, t.RegExpLiteral>;
|
|
433
|
+
RegexLiteral?: ExplVisitNode<S, t.RegexLiteral>;
|
|
434
|
+
RestElement?: ExplVisitNode<S, t.RestElement>;
|
|
435
|
+
RestProperty?: ExplVisitNode<S, t.RestProperty>;
|
|
436
|
+
ReturnStatement?: ExplVisitNode<S, t.ReturnStatement>;
|
|
437
|
+
SequenceExpression?: ExplVisitNode<S, t.SequenceExpression>;
|
|
438
|
+
SpreadElement?: ExplVisitNode<S, t.SpreadElement>;
|
|
439
|
+
SpreadProperty?: ExplVisitNode<S, t.SpreadProperty>;
|
|
440
|
+
StaticBlock?: ExplVisitNode<S, t.StaticBlock>;
|
|
441
|
+
StringLiteral?: ExplVisitNode<S, t.StringLiteral>;
|
|
442
|
+
StringLiteralTypeAnnotation?: ExplVisitNode<S, t.StringLiteralTypeAnnotation>;
|
|
443
|
+
StringTypeAnnotation?: ExplVisitNode<S, t.StringTypeAnnotation>;
|
|
444
|
+
Super?: ExplVisitNode<S, t.Super>;
|
|
445
|
+
SwitchCase?: ExplVisitNode<S, t.SwitchCase>;
|
|
446
|
+
SwitchStatement?: ExplVisitNode<S, t.SwitchStatement>;
|
|
447
|
+
SymbolTypeAnnotation?: ExplVisitNode<S, t.SymbolTypeAnnotation>;
|
|
448
|
+
TSAnyKeyword?: ExplVisitNode<S, t.TSAnyKeyword>;
|
|
449
|
+
TSArrayType?: ExplVisitNode<S, t.TSArrayType>;
|
|
450
|
+
TSAsExpression?: ExplVisitNode<S, t.TSAsExpression>;
|
|
451
|
+
TSBigIntKeyword?: ExplVisitNode<S, t.TSBigIntKeyword>;
|
|
452
|
+
TSBooleanKeyword?: ExplVisitNode<S, t.TSBooleanKeyword>;
|
|
453
|
+
TSCallSignatureDeclaration?: ExplVisitNode<S, t.TSCallSignatureDeclaration>;
|
|
454
|
+
TSConditionalType?: ExplVisitNode<S, t.TSConditionalType>;
|
|
455
|
+
TSConstructSignatureDeclaration?: ExplVisitNode<
|
|
456
|
+
S,
|
|
457
|
+
t.TSConstructSignatureDeclaration
|
|
458
|
+
>;
|
|
459
|
+
TSConstructorType?: ExplVisitNode<S, t.TSConstructorType>;
|
|
460
|
+
TSDeclareFunction?: ExplVisitNode<S, t.TSDeclareFunction>;
|
|
461
|
+
TSDeclareMethod?: ExplVisitNode<S, t.TSDeclareMethod>;
|
|
462
|
+
TSEnumDeclaration?: ExplVisitNode<S, t.TSEnumDeclaration>;
|
|
463
|
+
TSEnumMember?: ExplVisitNode<S, t.TSEnumMember>;
|
|
464
|
+
TSExportAssignment?: ExplVisitNode<S, t.TSExportAssignment>;
|
|
465
|
+
TSExpressionWithTypeArguments?: ExplVisitNode<
|
|
466
|
+
S,
|
|
467
|
+
t.TSExpressionWithTypeArguments
|
|
468
|
+
>;
|
|
469
|
+
TSExternalModuleReference?: ExplVisitNode<S, t.TSExternalModuleReference>;
|
|
470
|
+
TSFunctionType?: ExplVisitNode<S, t.TSFunctionType>;
|
|
471
|
+
TSImportEqualsDeclaration?: ExplVisitNode<S, t.TSImportEqualsDeclaration>;
|
|
472
|
+
TSImportType?: ExplVisitNode<S, t.TSImportType>;
|
|
473
|
+
TSIndexSignature?: ExplVisitNode<S, t.TSIndexSignature>;
|
|
474
|
+
TSIndexedAccessType?: ExplVisitNode<S, t.TSIndexedAccessType>;
|
|
475
|
+
TSInferType?: ExplVisitNode<S, t.TSInferType>;
|
|
476
|
+
TSInstantiationExpression?: ExplVisitNode<S, t.TSInstantiationExpression>;
|
|
477
|
+
TSInterfaceBody?: ExplVisitNode<S, t.TSInterfaceBody>;
|
|
478
|
+
TSInterfaceDeclaration?: ExplVisitNode<S, t.TSInterfaceDeclaration>;
|
|
479
|
+
TSIntersectionType?: ExplVisitNode<S, t.TSIntersectionType>;
|
|
480
|
+
TSIntrinsicKeyword?: ExplVisitNode<S, t.TSIntrinsicKeyword>;
|
|
481
|
+
TSLiteralType?: ExplVisitNode<S, t.TSLiteralType>;
|
|
482
|
+
TSMappedType?: ExplVisitNode<S, t.TSMappedType>;
|
|
483
|
+
TSMethodSignature?: ExplVisitNode<S, t.TSMethodSignature>;
|
|
484
|
+
TSModuleBlock?: ExplVisitNode<S, t.TSModuleBlock>;
|
|
485
|
+
TSModuleDeclaration?: ExplVisitNode<S, t.TSModuleDeclaration>;
|
|
486
|
+
TSNamedTupleMember?: ExplVisitNode<S, t.TSNamedTupleMember>;
|
|
487
|
+
TSNamespaceExportDeclaration?: ExplVisitNode<
|
|
488
|
+
S,
|
|
489
|
+
t.TSNamespaceExportDeclaration
|
|
490
|
+
>;
|
|
491
|
+
TSNeverKeyword?: ExplVisitNode<S, t.TSNeverKeyword>;
|
|
492
|
+
TSNonNullExpression?: ExplVisitNode<S, t.TSNonNullExpression>;
|
|
493
|
+
TSNullKeyword?: ExplVisitNode<S, t.TSNullKeyword>;
|
|
494
|
+
TSNumberKeyword?: ExplVisitNode<S, t.TSNumberKeyword>;
|
|
495
|
+
TSObjectKeyword?: ExplVisitNode<S, t.TSObjectKeyword>;
|
|
496
|
+
TSOptionalType?: ExplVisitNode<S, t.TSOptionalType>;
|
|
497
|
+
TSParameterProperty?: ExplVisitNode<S, t.TSParameterProperty>;
|
|
498
|
+
TSParenthesizedType?: ExplVisitNode<S, t.TSParenthesizedType>;
|
|
499
|
+
TSPropertySignature?: ExplVisitNode<S, t.TSPropertySignature>;
|
|
500
|
+
TSQualifiedName?: ExplVisitNode<S, t.TSQualifiedName>;
|
|
501
|
+
TSRestType?: ExplVisitNode<S, t.TSRestType>;
|
|
502
|
+
TSSatisfiesExpression?: ExplVisitNode<S, t.TSSatisfiesExpression>;
|
|
503
|
+
TSStringKeyword?: ExplVisitNode<S, t.TSStringKeyword>;
|
|
504
|
+
TSSymbolKeyword?: ExplVisitNode<S, t.TSSymbolKeyword>;
|
|
505
|
+
TSThisType?: ExplVisitNode<S, t.TSThisType>;
|
|
506
|
+
TSTupleType?: ExplVisitNode<S, t.TSTupleType>;
|
|
507
|
+
TSTypeAliasDeclaration?: ExplVisitNode<S, t.TSTypeAliasDeclaration>;
|
|
508
|
+
TSTypeAnnotation?: ExplVisitNode<S, t.TSTypeAnnotation>;
|
|
509
|
+
TSTypeAssertion?: ExplVisitNode<S, t.TSTypeAssertion>;
|
|
510
|
+
TSTypeLiteral?: ExplVisitNode<S, t.TSTypeLiteral>;
|
|
511
|
+
TSTypeOperator?: ExplVisitNode<S, t.TSTypeOperator>;
|
|
512
|
+
TSTypeParameter?: ExplVisitNode<S, t.TSTypeParameter>;
|
|
513
|
+
TSTypeParameterDeclaration?: ExplVisitNode<S, t.TSTypeParameterDeclaration>;
|
|
514
|
+
TSTypeParameterInstantiation?: ExplVisitNode<
|
|
515
|
+
S,
|
|
516
|
+
t.TSTypeParameterInstantiation
|
|
517
|
+
>;
|
|
518
|
+
TSTypePredicate?: ExplVisitNode<S, t.TSTypePredicate>;
|
|
519
|
+
TSTypeQuery?: ExplVisitNode<S, t.TSTypeQuery>;
|
|
520
|
+
TSTypeReference?: ExplVisitNode<S, t.TSTypeReference>;
|
|
521
|
+
TSUndefinedKeyword?: ExplVisitNode<S, t.TSUndefinedKeyword>;
|
|
522
|
+
TSUnionType?: ExplVisitNode<S, t.TSUnionType>;
|
|
523
|
+
TSUnknownKeyword?: ExplVisitNode<S, t.TSUnknownKeyword>;
|
|
524
|
+
TSVoidKeyword?: ExplVisitNode<S, t.TSVoidKeyword>;
|
|
525
|
+
TaggedTemplateExpression?: ExplVisitNode<S, t.TaggedTemplateExpression>;
|
|
526
|
+
TemplateElement?: ExplVisitNode<S, t.TemplateElement>;
|
|
527
|
+
TemplateLiteral?: ExplVisitNode<S, t.TemplateLiteral>;
|
|
528
|
+
ThisExpression?: ExplVisitNode<S, t.ThisExpression>;
|
|
529
|
+
ThisTypeAnnotation?: ExplVisitNode<S, t.ThisTypeAnnotation>;
|
|
530
|
+
ThrowStatement?: ExplVisitNode<S, t.ThrowStatement>;
|
|
531
|
+
TopicReference?: ExplVisitNode<S, t.TopicReference>;
|
|
532
|
+
TryStatement?: ExplVisitNode<S, t.TryStatement>;
|
|
533
|
+
TupleExpression?: ExplVisitNode<S, t.TupleExpression>;
|
|
534
|
+
TupleTypeAnnotation?: ExplVisitNode<S, t.TupleTypeAnnotation>;
|
|
535
|
+
TypeAlias?: ExplVisitNode<S, t.TypeAlias>;
|
|
536
|
+
TypeAnnotation?: ExplVisitNode<S, t.TypeAnnotation>;
|
|
537
|
+
TypeCastExpression?: ExplVisitNode<S, t.TypeCastExpression>;
|
|
538
|
+
TypeParameter?: ExplVisitNode<S, t.TypeParameter>;
|
|
539
|
+
TypeParameterDeclaration?: ExplVisitNode<S, t.TypeParameterDeclaration>;
|
|
540
|
+
TypeParameterInstantiation?: ExplVisitNode<S, t.TypeParameterInstantiation>;
|
|
541
|
+
TypeofTypeAnnotation?: ExplVisitNode<S, t.TypeofTypeAnnotation>;
|
|
542
|
+
UnaryExpression?: ExplVisitNode<S, t.UnaryExpression>;
|
|
543
|
+
UnionTypeAnnotation?: ExplVisitNode<S, t.UnionTypeAnnotation>;
|
|
544
|
+
UpdateExpression?: ExplVisitNode<S, t.UpdateExpression>;
|
|
545
|
+
V8IntrinsicIdentifier?: ExplVisitNode<S, t.V8IntrinsicIdentifier>;
|
|
546
|
+
VariableDeclaration?: ExplVisitNode<S, t.VariableDeclaration>;
|
|
547
|
+
VariableDeclarator?: ExplVisitNode<S, t.VariableDeclarator>;
|
|
548
|
+
Variance?: ExplVisitNode<S, t.Variance>;
|
|
549
|
+
VoidTypeAnnotation?: ExplVisitNode<S, t.VoidTypeAnnotation>;
|
|
550
|
+
WhileStatement?: ExplVisitNode<S, t.WhileStatement>;
|
|
551
|
+
WithStatement?: ExplVisitNode<S, t.WithStatement>;
|
|
552
|
+
YieldExpression?: ExplVisitNode<S, t.YieldExpression>;
|
|
553
|
+
}
|
|
554
|
+
|
|
555
|
+
interface VisitorBaseNodes<S> {
|
|
556
|
+
AnyTypeAnnotation?: VisitNode<S, t.AnyTypeAnnotation>;
|
|
557
|
+
ArgumentPlaceholder?: VisitNode<S, t.ArgumentPlaceholder>;
|
|
558
|
+
ArrayExpression?: VisitNode<S, t.ArrayExpression>;
|
|
559
|
+
ArrayPattern?: VisitNode<S, t.ArrayPattern>;
|
|
560
|
+
ArrayTypeAnnotation?: VisitNode<S, t.ArrayTypeAnnotation>;
|
|
561
|
+
ArrowFunctionExpression?: VisitNode<S, t.ArrowFunctionExpression>;
|
|
562
|
+
AssignmentExpression?: VisitNode<S, t.AssignmentExpression>;
|
|
563
|
+
AssignmentPattern?: VisitNode<S, t.AssignmentPattern>;
|
|
564
|
+
AwaitExpression?: VisitNode<S, t.AwaitExpression>;
|
|
565
|
+
BigIntLiteral?: VisitNode<S, t.BigIntLiteral>;
|
|
566
|
+
BinaryExpression?: VisitNode<S, t.BinaryExpression>;
|
|
567
|
+
BindExpression?: VisitNode<S, t.BindExpression>;
|
|
568
|
+
BlockStatement?: VisitNode<S, t.BlockStatement>;
|
|
569
|
+
BooleanLiteral?: VisitNode<S, t.BooleanLiteral>;
|
|
570
|
+
BooleanLiteralTypeAnnotation?: VisitNode<S, t.BooleanLiteralTypeAnnotation>;
|
|
571
|
+
BooleanTypeAnnotation?: VisitNode<S, t.BooleanTypeAnnotation>;
|
|
572
|
+
BreakStatement?: VisitNode<S, t.BreakStatement>;
|
|
573
|
+
CallExpression?: VisitNode<S, t.CallExpression>;
|
|
574
|
+
CatchClause?: VisitNode<S, t.CatchClause>;
|
|
575
|
+
ClassAccessorProperty?: VisitNode<S, t.ClassAccessorProperty>;
|
|
576
|
+
ClassBody?: VisitNode<S, t.ClassBody>;
|
|
577
|
+
ClassDeclaration?: VisitNode<S, t.ClassDeclaration>;
|
|
578
|
+
ClassExpression?: VisitNode<S, t.ClassExpression>;
|
|
579
|
+
ClassImplements?: VisitNode<S, t.ClassImplements>;
|
|
580
|
+
ClassMethod?: VisitNode<S, t.ClassMethod>;
|
|
581
|
+
ClassPrivateMethod?: VisitNode<S, t.ClassPrivateMethod>;
|
|
582
|
+
ClassPrivateProperty?: VisitNode<S, t.ClassPrivateProperty>;
|
|
583
|
+
ClassProperty?: VisitNode<S, t.ClassProperty>;
|
|
584
|
+
ConditionalExpression?: VisitNode<S, t.ConditionalExpression>;
|
|
585
|
+
ContinueStatement?: VisitNode<S, t.ContinueStatement>;
|
|
586
|
+
DebuggerStatement?: VisitNode<S, t.DebuggerStatement>;
|
|
587
|
+
DecimalLiteral?: VisitNode<S, t.DecimalLiteral>;
|
|
588
|
+
DeclareClass?: VisitNode<S, t.DeclareClass>;
|
|
589
|
+
DeclareExportAllDeclaration?: VisitNode<S, t.DeclareExportAllDeclaration>;
|
|
590
|
+
DeclareExportDeclaration?: VisitNode<S, t.DeclareExportDeclaration>;
|
|
591
|
+
DeclareFunction?: VisitNode<S, t.DeclareFunction>;
|
|
592
|
+
DeclareInterface?: VisitNode<S, t.DeclareInterface>;
|
|
593
|
+
DeclareModule?: VisitNode<S, t.DeclareModule>;
|
|
594
|
+
DeclareModuleExports?: VisitNode<S, t.DeclareModuleExports>;
|
|
595
|
+
DeclareOpaqueType?: VisitNode<S, t.DeclareOpaqueType>;
|
|
596
|
+
DeclareTypeAlias?: VisitNode<S, t.DeclareTypeAlias>;
|
|
597
|
+
DeclareVariable?: VisitNode<S, t.DeclareVariable>;
|
|
598
|
+
DeclaredPredicate?: VisitNode<S, t.DeclaredPredicate>;
|
|
599
|
+
Decorator?: VisitNode<S, t.Decorator>;
|
|
600
|
+
Directive?: VisitNode<S, t.Directive>;
|
|
601
|
+
DirectiveLiteral?: VisitNode<S, t.DirectiveLiteral>;
|
|
602
|
+
DoExpression?: VisitNode<S, t.DoExpression>;
|
|
603
|
+
DoWhileStatement?: VisitNode<S, t.DoWhileStatement>;
|
|
604
|
+
EmptyStatement?: VisitNode<S, t.EmptyStatement>;
|
|
605
|
+
EmptyTypeAnnotation?: VisitNode<S, t.EmptyTypeAnnotation>;
|
|
606
|
+
EnumBooleanBody?: VisitNode<S, t.EnumBooleanBody>;
|
|
607
|
+
EnumBooleanMember?: VisitNode<S, t.EnumBooleanMember>;
|
|
608
|
+
EnumDeclaration?: VisitNode<S, t.EnumDeclaration>;
|
|
609
|
+
EnumDefaultedMember?: VisitNode<S, t.EnumDefaultedMember>;
|
|
610
|
+
EnumNumberBody?: VisitNode<S, t.EnumNumberBody>;
|
|
611
|
+
EnumNumberMember?: VisitNode<S, t.EnumNumberMember>;
|
|
612
|
+
EnumStringBody?: VisitNode<S, t.EnumStringBody>;
|
|
613
|
+
EnumStringMember?: VisitNode<S, t.EnumStringMember>;
|
|
614
|
+
EnumSymbolBody?: VisitNode<S, t.EnumSymbolBody>;
|
|
615
|
+
ExistsTypeAnnotation?: VisitNode<S, t.ExistsTypeAnnotation>;
|
|
616
|
+
ExportAllDeclaration?: VisitNode<S, t.ExportAllDeclaration>;
|
|
617
|
+
ExportDefaultDeclaration?: VisitNode<S, t.ExportDefaultDeclaration>;
|
|
618
|
+
ExportDefaultSpecifier?: VisitNode<S, t.ExportDefaultSpecifier>;
|
|
619
|
+
ExportNamedDeclaration?: VisitNode<S, t.ExportNamedDeclaration>;
|
|
620
|
+
ExportNamespaceSpecifier?: VisitNode<S, t.ExportNamespaceSpecifier>;
|
|
621
|
+
ExportSpecifier?: VisitNode<S, t.ExportSpecifier>;
|
|
622
|
+
ExpressionStatement?: VisitNode<S, t.ExpressionStatement>;
|
|
623
|
+
File?: VisitNode<S, t.File>;
|
|
624
|
+
ForInStatement?: VisitNode<S, t.ForInStatement>;
|
|
625
|
+
ForOfStatement?: VisitNode<S, t.ForOfStatement>;
|
|
626
|
+
ForStatement?: VisitNode<S, t.ForStatement>;
|
|
627
|
+
FunctionDeclaration?: VisitNode<S, t.FunctionDeclaration>;
|
|
628
|
+
FunctionExpression?: VisitNode<S, t.FunctionExpression>;
|
|
629
|
+
FunctionTypeAnnotation?: VisitNode<S, t.FunctionTypeAnnotation>;
|
|
630
|
+
FunctionTypeParam?: VisitNode<S, t.FunctionTypeParam>;
|
|
631
|
+
GenericTypeAnnotation?: VisitNode<S, t.GenericTypeAnnotation>;
|
|
632
|
+
Identifier?: VisitNode<S, t.Identifier>;
|
|
633
|
+
IfStatement?: VisitNode<S, t.IfStatement>;
|
|
634
|
+
Import?: VisitNode<S, t.Import>;
|
|
635
|
+
ImportAttribute?: VisitNode<S, t.ImportAttribute>;
|
|
636
|
+
ImportDeclaration?: VisitNode<S, t.ImportDeclaration>;
|
|
637
|
+
ImportDefaultSpecifier?: VisitNode<S, t.ImportDefaultSpecifier>;
|
|
638
|
+
ImportExpression?: VisitNode<S, t.ImportExpression>;
|
|
639
|
+
ImportNamespaceSpecifier?: VisitNode<S, t.ImportNamespaceSpecifier>;
|
|
640
|
+
ImportSpecifier?: VisitNode<S, t.ImportSpecifier>;
|
|
641
|
+
IndexedAccessType?: VisitNode<S, t.IndexedAccessType>;
|
|
642
|
+
InferredPredicate?: VisitNode<S, t.InferredPredicate>;
|
|
643
|
+
InterfaceDeclaration?: VisitNode<S, t.InterfaceDeclaration>;
|
|
644
|
+
InterfaceExtends?: VisitNode<S, t.InterfaceExtends>;
|
|
645
|
+
InterfaceTypeAnnotation?: VisitNode<S, t.InterfaceTypeAnnotation>;
|
|
646
|
+
InterpreterDirective?: VisitNode<S, t.InterpreterDirective>;
|
|
647
|
+
IntersectionTypeAnnotation?: VisitNode<S, t.IntersectionTypeAnnotation>;
|
|
648
|
+
JSXAttribute?: VisitNode<S, t.JSXAttribute>;
|
|
649
|
+
JSXClosingElement?: VisitNode<S, t.JSXClosingElement>;
|
|
650
|
+
JSXClosingFragment?: VisitNode<S, t.JSXClosingFragment>;
|
|
651
|
+
JSXElement?: VisitNode<S, t.JSXElement>;
|
|
652
|
+
JSXEmptyExpression?: VisitNode<S, t.JSXEmptyExpression>;
|
|
653
|
+
JSXExpressionContainer?: VisitNode<S, t.JSXExpressionContainer>;
|
|
654
|
+
JSXFragment?: VisitNode<S, t.JSXFragment>;
|
|
655
|
+
JSXIdentifier?: VisitNode<S, t.JSXIdentifier>;
|
|
656
|
+
JSXMemberExpression?: VisitNode<S, t.JSXMemberExpression>;
|
|
657
|
+
JSXNamespacedName?: VisitNode<S, t.JSXNamespacedName>;
|
|
658
|
+
JSXOpeningElement?: VisitNode<S, t.JSXOpeningElement>;
|
|
659
|
+
JSXOpeningFragment?: VisitNode<S, t.JSXOpeningFragment>;
|
|
660
|
+
JSXSpreadAttribute?: VisitNode<S, t.JSXSpreadAttribute>;
|
|
661
|
+
JSXSpreadChild?: VisitNode<S, t.JSXSpreadChild>;
|
|
662
|
+
JSXText?: VisitNode<S, t.JSXText>;
|
|
663
|
+
LabeledStatement?: VisitNode<S, t.LabeledStatement>;
|
|
664
|
+
LogicalExpression?: VisitNode<S, t.LogicalExpression>;
|
|
665
|
+
MemberExpression?: VisitNode<S, t.MemberExpression>;
|
|
666
|
+
MetaProperty?: VisitNode<S, t.MetaProperty>;
|
|
667
|
+
MixedTypeAnnotation?: VisitNode<S, t.MixedTypeAnnotation>;
|
|
668
|
+
ModuleExpression?: VisitNode<S, t.ModuleExpression>;
|
|
669
|
+
NewExpression?: VisitNode<S, t.NewExpression>;
|
|
670
|
+
NullLiteral?: VisitNode<S, t.NullLiteral>;
|
|
671
|
+
NullLiteralTypeAnnotation?: VisitNode<S, t.NullLiteralTypeAnnotation>;
|
|
672
|
+
NullableTypeAnnotation?: VisitNode<S, t.NullableTypeAnnotation>;
|
|
673
|
+
NumberLiteral?: VisitNode<S, t.NumberLiteral>;
|
|
674
|
+
NumberLiteralTypeAnnotation?: VisitNode<S, t.NumberLiteralTypeAnnotation>;
|
|
675
|
+
NumberTypeAnnotation?: VisitNode<S, t.NumberTypeAnnotation>;
|
|
676
|
+
NumericLiteral?: VisitNode<S, t.NumericLiteral>;
|
|
677
|
+
ObjectExpression?: VisitNode<S, t.ObjectExpression>;
|
|
678
|
+
ObjectMethod?: VisitNode<S, t.ObjectMethod>;
|
|
679
|
+
ObjectPattern?: VisitNode<S, t.ObjectPattern>;
|
|
680
|
+
ObjectProperty?: VisitNode<S, t.ObjectProperty>;
|
|
681
|
+
ObjectTypeAnnotation?: VisitNode<S, t.ObjectTypeAnnotation>;
|
|
682
|
+
ObjectTypeCallProperty?: VisitNode<S, t.ObjectTypeCallProperty>;
|
|
683
|
+
ObjectTypeIndexer?: VisitNode<S, t.ObjectTypeIndexer>;
|
|
684
|
+
ObjectTypeInternalSlot?: VisitNode<S, t.ObjectTypeInternalSlot>;
|
|
685
|
+
ObjectTypeProperty?: VisitNode<S, t.ObjectTypeProperty>;
|
|
686
|
+
ObjectTypeSpreadProperty?: VisitNode<S, t.ObjectTypeSpreadProperty>;
|
|
687
|
+
OpaqueType?: VisitNode<S, t.OpaqueType>;
|
|
688
|
+
OptionalCallExpression?: VisitNode<S, t.OptionalCallExpression>;
|
|
689
|
+
OptionalIndexedAccessType?: VisitNode<S, t.OptionalIndexedAccessType>;
|
|
690
|
+
OptionalMemberExpression?: VisitNode<S, t.OptionalMemberExpression>;
|
|
691
|
+
ParenthesizedExpression?: VisitNode<S, t.ParenthesizedExpression>;
|
|
692
|
+
PipelineBareFunction?: VisitNode<S, t.PipelineBareFunction>;
|
|
693
|
+
PipelinePrimaryTopicReference?: VisitNode<S, t.PipelinePrimaryTopicReference>;
|
|
694
|
+
PipelineTopicExpression?: VisitNode<S, t.PipelineTopicExpression>;
|
|
695
|
+
Placeholder?: VisitNode<S, t.Placeholder>;
|
|
696
|
+
PrivateName?: VisitNode<S, t.PrivateName>;
|
|
697
|
+
Program?: VisitNode<S, t.Program>;
|
|
698
|
+
QualifiedTypeIdentifier?: VisitNode<S, t.QualifiedTypeIdentifier>;
|
|
699
|
+
RecordExpression?: VisitNode<S, t.RecordExpression>;
|
|
700
|
+
RegExpLiteral?: VisitNode<S, t.RegExpLiteral>;
|
|
701
|
+
RegexLiteral?: VisitNode<S, t.RegexLiteral>;
|
|
702
|
+
RestElement?: VisitNode<S, t.RestElement>;
|
|
703
|
+
RestProperty?: VisitNode<S, t.RestProperty>;
|
|
704
|
+
ReturnStatement?: VisitNode<S, t.ReturnStatement>;
|
|
705
|
+
SequenceExpression?: VisitNode<S, t.SequenceExpression>;
|
|
706
|
+
SpreadElement?: VisitNode<S, t.SpreadElement>;
|
|
707
|
+
SpreadProperty?: VisitNode<S, t.SpreadProperty>;
|
|
708
|
+
StaticBlock?: VisitNode<S, t.StaticBlock>;
|
|
709
|
+
StringLiteral?: VisitNode<S, t.StringLiteral>;
|
|
710
|
+
StringLiteralTypeAnnotation?: VisitNode<S, t.StringLiteralTypeAnnotation>;
|
|
711
|
+
StringTypeAnnotation?: VisitNode<S, t.StringTypeAnnotation>;
|
|
712
|
+
Super?: VisitNode<S, t.Super>;
|
|
713
|
+
SwitchCase?: VisitNode<S, t.SwitchCase>;
|
|
714
|
+
SwitchStatement?: VisitNode<S, t.SwitchStatement>;
|
|
715
|
+
SymbolTypeAnnotation?: VisitNode<S, t.SymbolTypeAnnotation>;
|
|
716
|
+
TSAnyKeyword?: VisitNode<S, t.TSAnyKeyword>;
|
|
717
|
+
TSArrayType?: VisitNode<S, t.TSArrayType>;
|
|
718
|
+
TSAsExpression?: VisitNode<S, t.TSAsExpression>;
|
|
719
|
+
TSBigIntKeyword?: VisitNode<S, t.TSBigIntKeyword>;
|
|
720
|
+
TSBooleanKeyword?: VisitNode<S, t.TSBooleanKeyword>;
|
|
721
|
+
TSCallSignatureDeclaration?: VisitNode<S, t.TSCallSignatureDeclaration>;
|
|
722
|
+
TSConditionalType?: VisitNode<S, t.TSConditionalType>;
|
|
723
|
+
TSConstructSignatureDeclaration?: VisitNode<
|
|
724
|
+
S,
|
|
725
|
+
t.TSConstructSignatureDeclaration
|
|
726
|
+
>;
|
|
727
|
+
TSConstructorType?: VisitNode<S, t.TSConstructorType>;
|
|
728
|
+
TSDeclareFunction?: VisitNode<S, t.TSDeclareFunction>;
|
|
729
|
+
TSDeclareMethod?: VisitNode<S, t.TSDeclareMethod>;
|
|
730
|
+
TSEnumDeclaration?: VisitNode<S, t.TSEnumDeclaration>;
|
|
731
|
+
TSEnumMember?: VisitNode<S, t.TSEnumMember>;
|
|
732
|
+
TSExportAssignment?: VisitNode<S, t.TSExportAssignment>;
|
|
733
|
+
TSExpressionWithTypeArguments?: VisitNode<S, t.TSExpressionWithTypeArguments>;
|
|
734
|
+
TSExternalModuleReference?: VisitNode<S, t.TSExternalModuleReference>;
|
|
735
|
+
TSFunctionType?: VisitNode<S, t.TSFunctionType>;
|
|
736
|
+
TSImportEqualsDeclaration?: VisitNode<S, t.TSImportEqualsDeclaration>;
|
|
737
|
+
TSImportType?: VisitNode<S, t.TSImportType>;
|
|
738
|
+
TSIndexSignature?: VisitNode<S, t.TSIndexSignature>;
|
|
739
|
+
TSIndexedAccessType?: VisitNode<S, t.TSIndexedAccessType>;
|
|
740
|
+
TSInferType?: VisitNode<S, t.TSInferType>;
|
|
741
|
+
TSInstantiationExpression?: VisitNode<S, t.TSInstantiationExpression>;
|
|
742
|
+
TSInterfaceBody?: VisitNode<S, t.TSInterfaceBody>;
|
|
743
|
+
TSInterfaceDeclaration?: VisitNode<S, t.TSInterfaceDeclaration>;
|
|
744
|
+
TSIntersectionType?: VisitNode<S, t.TSIntersectionType>;
|
|
745
|
+
TSIntrinsicKeyword?: VisitNode<S, t.TSIntrinsicKeyword>;
|
|
746
|
+
TSLiteralType?: VisitNode<S, t.TSLiteralType>;
|
|
747
|
+
TSMappedType?: VisitNode<S, t.TSMappedType>;
|
|
748
|
+
TSMethodSignature?: VisitNode<S, t.TSMethodSignature>;
|
|
749
|
+
TSModuleBlock?: VisitNode<S, t.TSModuleBlock>;
|
|
750
|
+
TSModuleDeclaration?: VisitNode<S, t.TSModuleDeclaration>;
|
|
751
|
+
TSNamedTupleMember?: VisitNode<S, t.TSNamedTupleMember>;
|
|
752
|
+
TSNamespaceExportDeclaration?: VisitNode<S, t.TSNamespaceExportDeclaration>;
|
|
753
|
+
TSNeverKeyword?: VisitNode<S, t.TSNeverKeyword>;
|
|
754
|
+
TSNonNullExpression?: VisitNode<S, t.TSNonNullExpression>;
|
|
755
|
+
TSNullKeyword?: VisitNode<S, t.TSNullKeyword>;
|
|
756
|
+
TSNumberKeyword?: VisitNode<S, t.TSNumberKeyword>;
|
|
757
|
+
TSObjectKeyword?: VisitNode<S, t.TSObjectKeyword>;
|
|
758
|
+
TSOptionalType?: VisitNode<S, t.TSOptionalType>;
|
|
759
|
+
TSParameterProperty?: VisitNode<S, t.TSParameterProperty>;
|
|
760
|
+
TSParenthesizedType?: VisitNode<S, t.TSParenthesizedType>;
|
|
761
|
+
TSPropertySignature?: VisitNode<S, t.TSPropertySignature>;
|
|
762
|
+
TSQualifiedName?: VisitNode<S, t.TSQualifiedName>;
|
|
763
|
+
TSRestType?: VisitNode<S, t.TSRestType>;
|
|
764
|
+
TSSatisfiesExpression?: VisitNode<S, t.TSSatisfiesExpression>;
|
|
765
|
+
TSStringKeyword?: VisitNode<S, t.TSStringKeyword>;
|
|
766
|
+
TSSymbolKeyword?: VisitNode<S, t.TSSymbolKeyword>;
|
|
767
|
+
TSThisType?: VisitNode<S, t.TSThisType>;
|
|
768
|
+
TSTupleType?: VisitNode<S, t.TSTupleType>;
|
|
769
|
+
TSTypeAliasDeclaration?: VisitNode<S, t.TSTypeAliasDeclaration>;
|
|
770
|
+
TSTypeAnnotation?: VisitNode<S, t.TSTypeAnnotation>;
|
|
771
|
+
TSTypeAssertion?: VisitNode<S, t.TSTypeAssertion>;
|
|
772
|
+
TSTypeLiteral?: VisitNode<S, t.TSTypeLiteral>;
|
|
773
|
+
TSTypeOperator?: VisitNode<S, t.TSTypeOperator>;
|
|
774
|
+
TSTypeParameter?: VisitNode<S, t.TSTypeParameter>;
|
|
775
|
+
TSTypeParameterDeclaration?: VisitNode<S, t.TSTypeParameterDeclaration>;
|
|
776
|
+
TSTypeParameterInstantiation?: VisitNode<S, t.TSTypeParameterInstantiation>;
|
|
777
|
+
TSTypePredicate?: VisitNode<S, t.TSTypePredicate>;
|
|
778
|
+
TSTypeQuery?: VisitNode<S, t.TSTypeQuery>;
|
|
779
|
+
TSTypeReference?: VisitNode<S, t.TSTypeReference>;
|
|
780
|
+
TSUndefinedKeyword?: VisitNode<S, t.TSUndefinedKeyword>;
|
|
781
|
+
TSUnionType?: VisitNode<S, t.TSUnionType>;
|
|
782
|
+
TSUnknownKeyword?: VisitNode<S, t.TSUnknownKeyword>;
|
|
783
|
+
TSVoidKeyword?: VisitNode<S, t.TSVoidKeyword>;
|
|
784
|
+
TaggedTemplateExpression?: VisitNode<S, t.TaggedTemplateExpression>;
|
|
785
|
+
TemplateElement?: VisitNode<S, t.TemplateElement>;
|
|
786
|
+
TemplateLiteral?: VisitNode<S, t.TemplateLiteral>;
|
|
787
|
+
ThisExpression?: VisitNode<S, t.ThisExpression>;
|
|
788
|
+
ThisTypeAnnotation?: VisitNode<S, t.ThisTypeAnnotation>;
|
|
789
|
+
ThrowStatement?: VisitNode<S, t.ThrowStatement>;
|
|
790
|
+
TopicReference?: VisitNode<S, t.TopicReference>;
|
|
791
|
+
TryStatement?: VisitNode<S, t.TryStatement>;
|
|
792
|
+
TupleExpression?: VisitNode<S, t.TupleExpression>;
|
|
793
|
+
TupleTypeAnnotation?: VisitNode<S, t.TupleTypeAnnotation>;
|
|
794
|
+
TypeAlias?: VisitNode<S, t.TypeAlias>;
|
|
795
|
+
TypeAnnotation?: VisitNode<S, t.TypeAnnotation>;
|
|
796
|
+
TypeCastExpression?: VisitNode<S, t.TypeCastExpression>;
|
|
797
|
+
TypeParameter?: VisitNode<S, t.TypeParameter>;
|
|
798
|
+
TypeParameterDeclaration?: VisitNode<S, t.TypeParameterDeclaration>;
|
|
799
|
+
TypeParameterInstantiation?: VisitNode<S, t.TypeParameterInstantiation>;
|
|
800
|
+
TypeofTypeAnnotation?: VisitNode<S, t.TypeofTypeAnnotation>;
|
|
801
|
+
UnaryExpression?: VisitNode<S, t.UnaryExpression>;
|
|
802
|
+
UnionTypeAnnotation?: VisitNode<S, t.UnionTypeAnnotation>;
|
|
803
|
+
UpdateExpression?: VisitNode<S, t.UpdateExpression>;
|
|
804
|
+
V8IntrinsicIdentifier?: VisitNode<S, t.V8IntrinsicIdentifier>;
|
|
805
|
+
VariableDeclaration?: VisitNode<S, t.VariableDeclaration>;
|
|
806
|
+
VariableDeclarator?: VisitNode<S, t.VariableDeclarator>;
|
|
807
|
+
Variance?: VisitNode<S, t.Variance>;
|
|
808
|
+
VoidTypeAnnotation?: VisitNode<S, t.VoidTypeAnnotation>;
|
|
809
|
+
WhileStatement?: VisitNode<S, t.WhileStatement>;
|
|
810
|
+
WithStatement?: VisitNode<S, t.WithStatement>;
|
|
811
|
+
YieldExpression?: VisitNode<S, t.YieldExpression>;
|
|
812
|
+
}
|
|
813
|
+
|
|
814
|
+
interface VisitorBaseAliases<S> {
|
|
815
|
+
Accessor?: VisitNode<S, t.Accessor>;
|
|
816
|
+
Binary?: VisitNode<S, t.Binary>;
|
|
817
|
+
Block?: VisitNode<S, t.Block>;
|
|
818
|
+
BlockParent?: VisitNode<S, t.BlockParent>;
|
|
819
|
+
Class?: VisitNode<S, t.Class>;
|
|
820
|
+
CompletionStatement?: VisitNode<S, t.CompletionStatement>;
|
|
821
|
+
Conditional?: VisitNode<S, t.Conditional>;
|
|
822
|
+
Declaration?: VisitNode<S, t.Declaration>;
|
|
823
|
+
EnumBody?: VisitNode<S, t.EnumBody>;
|
|
824
|
+
EnumMember?: VisitNode<S, t.EnumMember>;
|
|
825
|
+
ExportDeclaration?: VisitNode<S, t.ExportDeclaration>;
|
|
826
|
+
Expression?: VisitNode<S, t.Expression>;
|
|
827
|
+
ExpressionWrapper?: VisitNode<S, t.ExpressionWrapper>;
|
|
828
|
+
Flow?: VisitNode<S, t.Flow>;
|
|
829
|
+
FlowBaseAnnotation?: VisitNode<S, t.FlowBaseAnnotation>;
|
|
830
|
+
FlowDeclaration?: VisitNode<S, t.FlowDeclaration>;
|
|
831
|
+
FlowPredicate?: VisitNode<S, t.FlowPredicate>;
|
|
832
|
+
FlowType?: VisitNode<S, t.FlowType>;
|
|
833
|
+
For?: VisitNode<S, t.For>;
|
|
834
|
+
ForXStatement?: VisitNode<S, t.ForXStatement>;
|
|
835
|
+
Function?: VisitNode<S, t.Function>;
|
|
836
|
+
FunctionParent?: VisitNode<S, t.FunctionParent>;
|
|
837
|
+
Immutable?: VisitNode<S, t.Immutable>;
|
|
838
|
+
ImportOrExportDeclaration?: VisitNode<S, t.ImportOrExportDeclaration>;
|
|
839
|
+
JSX?: VisitNode<S, t.JSX>;
|
|
840
|
+
LVal?: VisitNode<S, t.LVal>;
|
|
841
|
+
Literal?: VisitNode<S, t.Literal>;
|
|
842
|
+
Loop?: VisitNode<S, t.Loop>;
|
|
843
|
+
Method?: VisitNode<S, t.Method>;
|
|
844
|
+
Miscellaneous?: VisitNode<S, t.Miscellaneous>;
|
|
845
|
+
ModuleDeclaration?: VisitNode<S, t.ModuleDeclaration>;
|
|
846
|
+
ModuleSpecifier?: VisitNode<S, t.ModuleSpecifier>;
|
|
847
|
+
ObjectMember?: VisitNode<S, t.ObjectMember>;
|
|
848
|
+
Pattern?: VisitNode<S, t.Pattern>;
|
|
849
|
+
PatternLike?: VisitNode<S, t.PatternLike>;
|
|
850
|
+
Private?: VisitNode<S, t.Private>;
|
|
851
|
+
Property?: VisitNode<S, t.Property>;
|
|
852
|
+
Pureish?: VisitNode<S, t.Pureish>;
|
|
853
|
+
Scopable?: VisitNode<S, t.Scopable>;
|
|
854
|
+
Standardized?: VisitNode<S, t.Standardized>;
|
|
855
|
+
Statement?: VisitNode<S, t.Statement>;
|
|
856
|
+
TSBaseType?: VisitNode<S, t.TSBaseType>;
|
|
857
|
+
TSEntityName?: VisitNode<S, t.TSEntityName>;
|
|
858
|
+
TSType?: VisitNode<S, t.TSType>;
|
|
859
|
+
TSTypeElement?: VisitNode<S, t.TSTypeElement>;
|
|
860
|
+
Terminatorless?: VisitNode<S, t.Terminatorless>;
|
|
861
|
+
TypeScript?: VisitNode<S, t.TypeScript>;
|
|
862
|
+
UnaryLike?: VisitNode<S, t.UnaryLike>;
|
|
863
|
+
UserWhitespacable?: VisitNode<S, t.UserWhitespacable>;
|
|
864
|
+
While?: VisitNode<S, t.While>;
|
|
865
|
+
}
|
|
866
|
+
|
|
867
|
+
type VisitPhase = "enter" | "exit";
|
|
868
|
+
interface VisitNodeObject<S, P extends t.Node> {
|
|
869
|
+
enter?: VisitNodeFunction<S, P>;
|
|
870
|
+
exit?: VisitNodeFunction<S, P>;
|
|
871
|
+
}
|
|
872
|
+
interface ExplVisitNode<S, P extends t.Node> {
|
|
873
|
+
enter?: VisitNodeFunction<S, P>[];
|
|
874
|
+
exit?: VisitNodeFunction<S, P>[];
|
|
875
|
+
}
|
|
876
|
+
interface ExplodedVisitor<S = unknown> extends ExplVisitorBase<S>, ExplVisitNode<S, t.Node> {
|
|
877
|
+
_exploded: true;
|
|
878
|
+
_verified: true;
|
|
879
|
+
}
|
|
880
|
+
interface VisitorVirtualAliases<S> {
|
|
881
|
+
BindingIdentifier?: VisitNode<S, VirtualTypeAliases["BindingIdentifier"]>;
|
|
882
|
+
BlockScoped?: VisitNode<S, VirtualTypeAliases["BlockScoped"]>;
|
|
883
|
+
ExistentialTypeParam?: VisitNode<S, VirtualTypeAliases["ExistentialTypeParam"]>;
|
|
884
|
+
Expression?: VisitNode<S, VirtualTypeAliases["Expression"]>;
|
|
885
|
+
ForAwaitStatement?: VisitNode<S, VirtualTypeAliases["ForAwaitStatement"]>;
|
|
886
|
+
Generated?: VisitNode<S, VirtualTypeAliases["Generated"]>;
|
|
887
|
+
NumericLiteralTypeAnnotation?: VisitNode<S, VirtualTypeAliases["NumericLiteralTypeAnnotation"]>;
|
|
888
|
+
Pure?: VisitNode<S, VirtualTypeAliases["Pure"]>;
|
|
889
|
+
Referenced?: VisitNode<S, VirtualTypeAliases["Referenced"]>;
|
|
890
|
+
ReferencedIdentifier?: VisitNode<S, VirtualTypeAliases["ReferencedIdentifier"]>;
|
|
891
|
+
ReferencedMemberExpression?: VisitNode<S, VirtualTypeAliases["ReferencedMemberExpression"]>;
|
|
892
|
+
Scope?: VisitNode<S, VirtualTypeAliases["Scope"]>;
|
|
893
|
+
Statement?: VisitNode<S, VirtualTypeAliases["Statement"]>;
|
|
894
|
+
User?: VisitNode<S, VirtualTypeAliases["User"]>;
|
|
895
|
+
Var?: VisitNode<S, VirtualTypeAliases["Var"]>;
|
|
896
|
+
}
|
|
897
|
+
interface VisitorBase<S> extends VisitNodeObject<S, t.Node>, VisitorBaseNodes<S>, VisitorBaseAliases<S>, VisitorVirtualAliases<S> {
|
|
898
|
+
[k: `${string}|${string}`]: VisitNode<S, t.Node>;
|
|
899
|
+
}
|
|
900
|
+
type Visitor<S = unknown> = VisitorBase<S> | ExplodedVisitor<S>;
|
|
901
|
+
type VisitNode<S, P extends t.Node> = VisitNodeFunction<S, P> | VisitNodeObject<S, P>;
|
|
902
|
+
type VisitNodeFunction<S, P extends t.Node> = (this: S, path: NodePath_Final<P>, state: S) => void;
|
|
903
|
+
|
|
904
|
+
/**
|
|
905
|
+
* Starting at the parent path of the current `NodePath` and going up the
|
|
906
|
+
* tree, return the first `NodePath` that causes the provided `callback`
|
|
907
|
+
* to return a truthy value, or `null` if the `callback` never returns a
|
|
908
|
+
* truthy value.
|
|
909
|
+
*/
|
|
910
|
+
declare function findParent(this: NodePath_Final, callback: (path: NodePath_Final) => boolean): NodePath_Final | null;
|
|
911
|
+
/**
|
|
912
|
+
* Starting at current `NodePath` and going up the tree, return the first
|
|
913
|
+
* `NodePath` that causes the provided `callback` to return a truthy value,
|
|
914
|
+
* or `null` if the `callback` never returns a truthy value.
|
|
915
|
+
*/
|
|
916
|
+
declare function find(this: NodePath_Final, callback: (path: NodePath_Final) => boolean): NodePath_Final | null;
|
|
917
|
+
/**
|
|
918
|
+
* Get the parent function of the current path.
|
|
919
|
+
*/
|
|
920
|
+
declare function getFunctionParent(this: NodePath_Final): NodePath_Final<t.Function> | null;
|
|
921
|
+
/**
|
|
922
|
+
* Walk up the tree until we hit a parent node path in a list.
|
|
923
|
+
*/
|
|
924
|
+
declare function getStatementParent(this: NodePath_Final): NodePath_Final<t.Statement>;
|
|
925
|
+
/**
|
|
926
|
+
* Get the deepest common ancestor and then from it, get the earliest relationship path
|
|
927
|
+
* to that ancestor.
|
|
928
|
+
*
|
|
929
|
+
* Earliest is defined as being "before" all the other nodes in terms of list container
|
|
930
|
+
* position and visiting key.
|
|
931
|
+
*/
|
|
932
|
+
declare function getEarliestCommonAncestorFrom(this: NodePath_Final, paths: Array<NodePath_Final>): NodePath_Final;
|
|
933
|
+
/**
|
|
934
|
+
* Get the earliest path in the tree where the provided `paths` intersect.
|
|
935
|
+
*
|
|
936
|
+
* TODO: Possible optimisation target.
|
|
937
|
+
*/
|
|
938
|
+
declare function getDeepestCommonAncestorFrom(this: NodePath_Final, paths: Array<NodePath_Final>, filter?: (deepest: NodePath_Final, i: number, ancestries: NodePath_Final[][]) => NodePath_Final): NodePath_Final;
|
|
939
|
+
/**
|
|
940
|
+
* Build an array of node paths containing the entire ancestry of the current node path.
|
|
941
|
+
*
|
|
942
|
+
* NOTE: The current node path is included in this.
|
|
943
|
+
*/
|
|
944
|
+
declare function getAncestry(this: NodePath_Final): Array<NodePath_Final>;
|
|
945
|
+
/**
|
|
946
|
+
* A helper to find if `this` path is an ancestor of @param maybeDescendant
|
|
947
|
+
*/
|
|
948
|
+
declare function isAncestor(this: NodePath_Final, maybeDescendant: NodePath_Final): boolean;
|
|
949
|
+
/**
|
|
950
|
+
* A helper to find if `this` path is a descendant of @param maybeAncestor
|
|
951
|
+
*/
|
|
952
|
+
declare function isDescendant(this: NodePath_Final, maybeAncestor: NodePath_Final): boolean;
|
|
953
|
+
declare function inType(this: NodePath_Final, ...candidateTypes: string[]): boolean;
|
|
954
|
+
|
|
955
|
+
/**
|
|
956
|
+
* Infer the type of the current `NodePath`.
|
|
957
|
+
*/
|
|
958
|
+
declare function getTypeAnnotation(this: NodePath_Final): t.FlowType | t.TSType;
|
|
959
|
+
/**
|
|
960
|
+
* todo: split up this method
|
|
961
|
+
*/
|
|
962
|
+
declare function _getTypeAnnotation(this: NodePath_Final): any;
|
|
963
|
+
declare function isBaseType(this: NodePath_Final, baseName: string, soft?: boolean): boolean;
|
|
964
|
+
declare function couldBeBaseType(this: NodePath_Final, name: string): boolean;
|
|
965
|
+
declare function baseTypeStrictlyMatches(this: NodePath_Final, rightArg: NodePath_Final): boolean;
|
|
966
|
+
declare function isGenericType(this: NodePath_Final, genericName: string): boolean;
|
|
967
|
+
|
|
968
|
+
/**
|
|
969
|
+
* Replace a node with an array of multiple. This method performs the following steps:
|
|
970
|
+
*
|
|
971
|
+
* - Inherit the comments of first provided node with that of the current node.
|
|
972
|
+
* - Insert the provided nodes after the current node.
|
|
973
|
+
* - Remove the current node.
|
|
974
|
+
*/
|
|
975
|
+
declare function replaceWithMultiple(this: NodePath_Final, nodes: t.Node | t.Node[]): NodePath_Final[];
|
|
976
|
+
/**
|
|
977
|
+
* Parse a string as an expression and replace the current node with the result.
|
|
978
|
+
*
|
|
979
|
+
* NOTE: This is typically not a good idea to use. Building source strings when
|
|
980
|
+
* transforming ASTs is an antipattern and SHOULD NOT be encouraged. Even if it's
|
|
981
|
+
* easier to use, your transforms will be extremely brittle.
|
|
982
|
+
*/
|
|
983
|
+
declare function replaceWithSourceString(this: NodePath_Final, replacement: string): [NodePath<t.ArrayExpression> | NodePath<t.ArrowFunctionExpression> | NodePath<t.AssignmentExpression> | NodePath<t.AwaitExpression> | NodePath<t.BigIntLiteral> | NodePath<t.BinaryExpression> | NodePath<t.BindExpression> | NodePath<t.BooleanLiteral> | NodePath<t.CallExpression> | NodePath<t.ClassExpression> | NodePath<t.ConditionalExpression> | NodePath<t.DecimalLiteral> | NodePath<t.DoExpression> | NodePath<t.FunctionExpression> | NodePath<t.Identifier> | NodePath<t.Import> | NodePath<t.ImportExpression> | NodePath<t.JSXElement> | NodePath<t.JSXFragment> | NodePath<t.LogicalExpression> | NodePath<t.MemberExpression> | NodePath<t.MetaProperty> | NodePath<t.ModuleExpression> | NodePath<t.NewExpression> | NodePath<t.NullLiteral> | NodePath<t.NumericLiteral> | NodePath<t.ObjectExpression> | NodePath<t.OptionalCallExpression> | NodePath<t.OptionalMemberExpression> | NodePath<t.ParenthesizedExpression> | NodePath<t.PipelineBareFunction> | NodePath<t.PipelinePrimaryTopicReference> | NodePath<t.PipelineTopicExpression> | NodePath<t.RecordExpression> | NodePath<t.RegExpLiteral> | NodePath<t.SequenceExpression> | NodePath<t.StringLiteral> | NodePath<t.TSAsExpression> | NodePath<t.TSInstantiationExpression> | NodePath<t.TSNonNullExpression> | NodePath<t.TSSatisfiesExpression> | NodePath<t.TSTypeAssertion> | NodePath<t.TaggedTemplateExpression> | NodePath<t.TemplateLiteral> | NodePath<t.ThisExpression> | NodePath<t.TopicReference> | NodePath<t.TupleExpression> | NodePath<t.TypeCastExpression> | NodePath<t.UnaryExpression> | NodePath<t.UpdateExpression> | NodePath<t.YieldExpression>];
|
|
984
|
+
/**
|
|
985
|
+
* Replace the current node with another.
|
|
986
|
+
*/
|
|
987
|
+
declare function replaceWith<R extends t.Node>(this: NodePath_Final, replacementPath: R): [NodePath_Final<R>];
|
|
988
|
+
declare function replaceWith<R extends NodePath_Final>(this: NodePath_Final, replacementPath: R): [R];
|
|
989
|
+
/**
|
|
990
|
+
* Description
|
|
991
|
+
*/
|
|
992
|
+
declare function _replaceWith(this: NodePath_Final, node: t.Node): void;
|
|
993
|
+
/**
|
|
994
|
+
* This method takes an array of statements nodes and then explodes it
|
|
995
|
+
* into expressions. This method retains completion records which is
|
|
996
|
+
* extremely important to retain original semantics.
|
|
997
|
+
*/
|
|
998
|
+
declare function replaceExpressionWithStatements(this: NodePath_Final, nodes: Array<t.Statement>): (NodePath<t.ArrayExpression> | NodePath<t.ArrowFunctionExpression> | NodePath<t.AssignmentExpression> | NodePath<t.AwaitExpression> | NodePath<t.BigIntLiteral> | NodePath<t.BinaryExpression> | NodePath<t.BindExpression> | NodePath<t.BooleanLiteral> | NodePath<t.CallExpression> | NodePath<t.ClassExpression> | NodePath<t.ConditionalExpression> | NodePath<t.DecimalLiteral> | NodePath<t.DoExpression> | NodePath<t.FunctionExpression> | NodePath<t.Identifier> | NodePath<t.Import> | NodePath<t.ImportExpression> | NodePath<t.JSXElement> | NodePath<t.JSXFragment> | NodePath<t.LogicalExpression> | NodePath<t.MemberExpression> | NodePath<t.MetaProperty> | NodePath<t.ModuleExpression> | NodePath<t.NewExpression> | NodePath<t.NullLiteral> | NodePath<t.NumericLiteral> | NodePath<t.ObjectExpression> | NodePath<t.OptionalCallExpression> | NodePath<t.OptionalMemberExpression> | NodePath<t.ParenthesizedExpression> | NodePath<t.PipelineBareFunction> | NodePath<t.PipelinePrimaryTopicReference> | NodePath<t.PipelineTopicExpression> | NodePath<t.RecordExpression> | NodePath<t.RegExpLiteral> | NodePath<t.SequenceExpression> | NodePath<t.StringLiteral> | NodePath<t.TSAnyKeyword> | NodePath<t.TSArrayType> | NodePath<t.TSAsExpression> | NodePath<t.TSBigIntKeyword> | NodePath<t.TSBooleanKeyword> | NodePath<t.TSConditionalType> | NodePath<t.TSConstructorType> | NodePath<t.TSExpressionWithTypeArguments> | NodePath<t.TSFunctionType> | NodePath<t.TSImportType> | NodePath<t.TSIndexedAccessType> | NodePath<t.TSInferType> | NodePath<t.TSInstantiationExpression> | NodePath<t.TSIntersectionType> | NodePath<t.TSIntrinsicKeyword> | NodePath<t.TSLiteralType> | NodePath<t.TSMappedType> | NodePath<t.TSNeverKeyword> | NodePath<t.TSNonNullExpression> | NodePath<t.TSNullKeyword> | NodePath<t.TSNumberKeyword> | NodePath<t.TSObjectKeyword> | NodePath<t.TSOptionalType> | NodePath<t.TSParenthesizedType> | NodePath<t.TSRestType> | NodePath<t.TSSatisfiesExpression> | NodePath<t.TSStringKeyword> | NodePath<t.TSSymbolKeyword> | NodePath<t.TSThisType> | NodePath<t.TSTupleType> | NodePath<t.TSTypeAssertion> | NodePath<t.TSTypeLiteral> | NodePath<t.TSTypeOperator> | NodePath<t.TSTypePredicate> | NodePath<t.TSTypeQuery> | NodePath<t.TSTypeReference> | NodePath<t.TSUndefinedKeyword> | NodePath<t.TSUnionType> | NodePath<t.TSUnknownKeyword> | NodePath<t.TSVoidKeyword> | NodePath<t.TaggedTemplateExpression> | NodePath<t.TemplateLiteral> | NodePath<t.ThisExpression> | NodePath<t.TopicReference> | NodePath<t.TupleExpression> | NodePath<t.TypeCastExpression> | NodePath<t.UnaryExpression> | NodePath<t.UpdateExpression> | NodePath<t.YieldExpression>)[] | (NodePath<t.BlockStatement> | NodePath<t.BreakStatement> | NodePath<t.ClassDeclaration> | NodePath<t.ContinueStatement> | NodePath<t.DebuggerStatement> | NodePath<t.DeclareClass> | NodePath<t.DeclareExportAllDeclaration> | NodePath<t.DeclareExportDeclaration> | NodePath<t.DeclareFunction> | NodePath<t.DeclareInterface> | NodePath<t.DeclareModule> | NodePath<t.DeclareModuleExports> | NodePath<t.DeclareOpaqueType> | NodePath<t.DeclareTypeAlias> | NodePath<t.DeclareVariable> | NodePath<t.DoWhileStatement> | NodePath<t.EmptyStatement> | NodePath<t.EnumDeclaration> | NodePath<t.ExportAllDeclaration> | NodePath<t.ExportDefaultDeclaration> | NodePath<t.ExportNamedDeclaration> | NodePath<t.ExpressionStatement> | NodePath<t.ForInStatement> | NodePath<t.ForOfStatement> | NodePath<t.ForStatement> | NodePath<t.FunctionDeclaration> | NodePath<t.IfStatement> | NodePath<t.ImportDeclaration> | NodePath<t.InterfaceDeclaration> | NodePath<t.LabeledStatement> | NodePath<t.OpaqueType> | NodePath<t.ReturnStatement> | NodePath<t.SwitchStatement> | NodePath<t.TSDeclareFunction> | NodePath<t.TSEnumDeclaration> | NodePath<t.TSExportAssignment> | NodePath<t.TSImportEqualsDeclaration> | NodePath<t.TSInterfaceDeclaration> | NodePath<t.TSModuleDeclaration> | NodePath<t.TSNamespaceExportDeclaration> | NodePath<t.TSTypeAliasDeclaration> | NodePath<t.ThrowStatement> | NodePath<t.TryStatement> | NodePath<t.TypeAlias> | NodePath<t.VariableDeclaration> | NodePath<t.WhileStatement> | NodePath<t.WithStatement>)[];
|
|
999
|
+
declare function replaceInline(this: NodePath_Final, nodes: t.Node | Array<t.Node>): NodePath_Final[];
|
|
1000
|
+
|
|
1001
|
+
/**
|
|
1002
|
+
* Walk the input `node` and statically evaluate if it's truthy.
|
|
1003
|
+
*
|
|
1004
|
+
* Returning `true` when we're sure that the expression will evaluate to a
|
|
1005
|
+
* truthy value, `false` if we're sure that it will evaluate to a falsy
|
|
1006
|
+
* value and `undefined` if we aren't sure. Because of this please do not
|
|
1007
|
+
* rely on coercion when using this method and check with === if it's false.
|
|
1008
|
+
*
|
|
1009
|
+
* For example do:
|
|
1010
|
+
*
|
|
1011
|
+
* if (t.evaluateTruthy(node) === false) falsyLogic();
|
|
1012
|
+
*
|
|
1013
|
+
* **AND NOT**
|
|
1014
|
+
*
|
|
1015
|
+
* if (!t.evaluateTruthy(node)) falsyLogic();
|
|
1016
|
+
*
|
|
1017
|
+
*/
|
|
1018
|
+
declare function evaluateTruthy(this: NodePath_Final): boolean;
|
|
1019
|
+
/**
|
|
1020
|
+
* Walk the input `node` and statically evaluate it.
|
|
1021
|
+
*
|
|
1022
|
+
* Returns an object in the form `{ confident, value, deopt }`. `confident`
|
|
1023
|
+
* indicates whether or not we had to drop out of evaluating the expression
|
|
1024
|
+
* because of hitting an unknown node that we couldn't confidently find the
|
|
1025
|
+
* value of, in which case `deopt` is the path of said node.
|
|
1026
|
+
*
|
|
1027
|
+
* Example:
|
|
1028
|
+
*
|
|
1029
|
+
* t.evaluate(parse("5 + 5")) // { confident: true, value: 10 }
|
|
1030
|
+
* t.evaluate(parse("!true")) // { confident: true, value: false }
|
|
1031
|
+
* t.evaluate(parse("foo + foo")) // { confident: false, value: undefined, deopt: NodePath }
|
|
1032
|
+
*
|
|
1033
|
+
*/
|
|
1034
|
+
declare function evaluate(this: NodePath_Final): {
|
|
1035
|
+
confident: boolean;
|
|
1036
|
+
value: any;
|
|
1037
|
+
deopt?: NodePath_Final;
|
|
1038
|
+
};
|
|
1039
|
+
|
|
1040
|
+
declare function toComputedKey(this: NodePath_Final): t.PrivateName | t.Expression;
|
|
1041
|
+
declare function ensureBlock(this: NodePath_Final<t.Loop | t.WithStatement | t.Function | t.LabeledStatement | t.CatchClause>): void;
|
|
1042
|
+
/**
|
|
1043
|
+
* Given an arbitrary function, process its content as if it were an arrow function, moving references
|
|
1044
|
+
* to "this", "arguments", "super", and such into the function's parent scope. This method is useful if
|
|
1045
|
+
* you have wrapped some set of items in an IIFE or other function, but want "this", "arguments", and super"
|
|
1046
|
+
* to continue behaving as expected.
|
|
1047
|
+
*/
|
|
1048
|
+
declare function unwrapFunctionEnvironment(this: NodePath_Final): void;
|
|
1049
|
+
/**
|
|
1050
|
+
* Convert a given arrow function into a normal ES5 function expression.
|
|
1051
|
+
*/
|
|
1052
|
+
declare function arrowFunctionToExpression(this: NodePath_Final<t.ArrowFunctionExpression>, { allowInsertArrow, allowInsertArrowWithRest, noNewArrows, }?: {
|
|
1053
|
+
allowInsertArrow?: boolean | void;
|
|
1054
|
+
allowInsertArrowWithRest?: boolean | void;
|
|
1055
|
+
noNewArrows?: boolean;
|
|
1056
|
+
}): NodePath_Final<Exclude<t.Function, t.Method | t.ArrowFunctionExpression> | t.CallExpression>;
|
|
1057
|
+
|
|
1058
|
+
/**
|
|
1059
|
+
* Match the current node if it matches the provided `pattern`.
|
|
1060
|
+
*
|
|
1061
|
+
* For example, given the match `React.createClass` it would match the
|
|
1062
|
+
* parsed nodes of `React.createClass` and `React["createClass"]`.
|
|
1063
|
+
*/
|
|
1064
|
+
declare function matchesPattern(this: NodePath_Final, pattern: string, allowPartial?: boolean): boolean;
|
|
1065
|
+
/**
|
|
1066
|
+
* Check whether we have the input `key`. If the `key` references an array then we check
|
|
1067
|
+
* if the array has any items, otherwise we just check if it's falsy.
|
|
1068
|
+
*/
|
|
1069
|
+
declare function has<N extends t.Node>(this: NodePath_Final<N>, key: keyof N): boolean;
|
|
1070
|
+
/**
|
|
1071
|
+
* Description
|
|
1072
|
+
*/
|
|
1073
|
+
declare function isStatic(this: NodePath_Final): boolean;
|
|
1074
|
+
/**
|
|
1075
|
+
* Opposite of `has`.
|
|
1076
|
+
*/
|
|
1077
|
+
declare function isnt<N extends t.Node>(this: NodePath_Final<N>, key: keyof N): boolean;
|
|
1078
|
+
/**
|
|
1079
|
+
* Check whether the path node `key` strict equals `value`.
|
|
1080
|
+
*/
|
|
1081
|
+
declare function equals<N extends t.Node>(this: NodePath_Final<N>, key: keyof N, value: any): boolean;
|
|
1082
|
+
/**
|
|
1083
|
+
* Check the type against our stored internal type of the node. This is handy when a node has
|
|
1084
|
+
* been removed yet we still internally know the type and need it to calculate node replacement.
|
|
1085
|
+
*/
|
|
1086
|
+
declare function isNodeType(this: NodePath_Final, type: string): boolean;
|
|
1087
|
+
/**
|
|
1088
|
+
* This checks whether or not we're in one of the following positions:
|
|
1089
|
+
*
|
|
1090
|
+
* for (KEY in right);
|
|
1091
|
+
* for (KEY;;);
|
|
1092
|
+
*
|
|
1093
|
+
* This is because these spots allow VariableDeclarations AND normal expressions so we need
|
|
1094
|
+
* to tell the path replacement that it's ok to replace this with an expression.
|
|
1095
|
+
*/
|
|
1096
|
+
declare function canHaveVariableDeclarationOrExpression(this: NodePath_Final): boolean;
|
|
1097
|
+
/**
|
|
1098
|
+
* This checks whether we are swapping an arrow function's body between an
|
|
1099
|
+
* expression and a block statement (or vice versa).
|
|
1100
|
+
*
|
|
1101
|
+
* This is because arrow functions may implicitly return an expression, which
|
|
1102
|
+
* is the same as containing a block statement.
|
|
1103
|
+
*/
|
|
1104
|
+
declare function canSwapBetweenExpressionAndStatement(this: NodePath_Final, replacement: t.Node): boolean;
|
|
1105
|
+
/**
|
|
1106
|
+
* Check whether the current path references a completion record
|
|
1107
|
+
*/
|
|
1108
|
+
declare function isCompletionRecord(this: NodePath_Final, allowInsideFunction?: boolean): boolean;
|
|
1109
|
+
/**
|
|
1110
|
+
* Check whether or not the current `key` allows either a single statement or block statement
|
|
1111
|
+
* so we can explode it if necessary.
|
|
1112
|
+
*/
|
|
1113
|
+
declare function isStatementOrBlock(this: NodePath_Final): boolean;
|
|
1114
|
+
/**
|
|
1115
|
+
* Check if the currently assigned path references the `importName` of `moduleSource`.
|
|
1116
|
+
*/
|
|
1117
|
+
declare function referencesImport(this: NodePath_Final, moduleSource: string, importName: string): boolean;
|
|
1118
|
+
/**
|
|
1119
|
+
* Get the source code associated with this node.
|
|
1120
|
+
*/
|
|
1121
|
+
declare function getSource(this: NodePath_Final): string;
|
|
1122
|
+
declare function willIMaybeExecuteBefore(this: NodePath_Final, target: NodePath_Final): boolean;
|
|
1123
|
+
type RelativeExecutionStatus = "before" | "after" | "unknown";
|
|
1124
|
+
/**
|
|
1125
|
+
* Given a `target` check the execution status of it relative to the current path.
|
|
1126
|
+
*
|
|
1127
|
+
* "Execution status" simply refers to where or not we **think** this will execute
|
|
1128
|
+
* before or after the input `target` element.
|
|
1129
|
+
*/
|
|
1130
|
+
declare function _guessExecutionStatusRelativeTo(this: NodePath_Final, target: NodePath_Final): RelativeExecutionStatus;
|
|
1131
|
+
/**
|
|
1132
|
+
* Resolve a "pointer" `NodePath` to it's absolute path.
|
|
1133
|
+
*/
|
|
1134
|
+
declare function resolve(this: NodePath_Final, dangerous?: boolean, resolved?: NodePath_Final[]): NodePath_Final;
|
|
1135
|
+
declare function _resolve(this: NodePath_Final, dangerous?: boolean, resolved?: NodePath_Final[]): NodePath_Final | undefined | null;
|
|
1136
|
+
declare function isConstantExpression(this: NodePath_Final): boolean;
|
|
1137
|
+
declare function isInStrictMode(this: NodePath_Final): boolean;
|
|
1138
|
+
|
|
1139
|
+
declare function call(this: NodePath_Final, key: VisitPhase): boolean;
|
|
1140
|
+
declare function _call(this: NodePath_Final, fns?: Array<Function>): boolean;
|
|
1141
|
+
declare function isDenylisted(this: NodePath_Final): boolean;
|
|
1142
|
+
|
|
1143
|
+
declare function visit(this: NodePath_Final): boolean;
|
|
1144
|
+
declare function skip(this: NodePath_Final): void;
|
|
1145
|
+
declare function skipKey(this: NodePath_Final, key: string): void;
|
|
1146
|
+
declare function stop(this: NodePath_Final): void;
|
|
1147
|
+
declare function setScope(this: NodePath_Final): void;
|
|
1148
|
+
declare function setContext<S = unknown>(this: NodePath_Final, context?: TraversalContext<S>): NodePath_Final;
|
|
1149
|
+
/**
|
|
1150
|
+
* Here we resync the node paths `key` and `container`. If they've changed according
|
|
1151
|
+
* to what we have stored internally then we attempt to resync by crawling and looking
|
|
1152
|
+
* for the new values.
|
|
1153
|
+
*/
|
|
1154
|
+
declare function resync(this: NodePath_Final): void;
|
|
1155
|
+
declare function _resyncParent(this: NodePath_Final): void;
|
|
1156
|
+
declare function _resyncKey(this: NodePath_Final): void;
|
|
1157
|
+
declare function _resyncList(this: NodePath_Final): void;
|
|
1158
|
+
declare function _resyncRemoved(this: NodePath_Final): void;
|
|
1159
|
+
declare function popContext(this: NodePath_Final): void;
|
|
1160
|
+
declare function pushContext(this: NodePath_Final, context: TraversalContext): void;
|
|
1161
|
+
declare function setup(this: NodePath_Final, parentPath: NodePath_Final | undefined, container: t.Node | t.Node[], listKey: string, key: string | number): void;
|
|
1162
|
+
declare function setKey(this: NodePath_Final, key: string | number): void;
|
|
1163
|
+
declare function requeue(this: NodePath_Final, pathToQueue?: NodePath_Final): void;
|
|
1164
|
+
declare function _getQueueContexts(this: NodePath_Final): TraversalContext<unknown>[];
|
|
1165
|
+
|
|
1166
|
+
declare function remove(this: NodePath_Final): void;
|
|
1167
|
+
declare function _removeFromScope(this: NodePath_Final): void;
|
|
1168
|
+
declare function _callRemovalHooks(this: NodePath_Final): boolean;
|
|
1169
|
+
declare function _remove(this: NodePath_Final): void;
|
|
1170
|
+
declare function _markRemoved(this: NodePath_Final): void;
|
|
1171
|
+
declare function _assertUnremoved(this: NodePath_Final): void;
|
|
1172
|
+
|
|
1173
|
+
/**
|
|
1174
|
+
* Insert the provided nodes before the current one.
|
|
1175
|
+
*/
|
|
1176
|
+
declare function insertBefore(this: NodePath_Final, nodes_: t.Node | t.Node[]): NodePath_Final[];
|
|
1177
|
+
declare function _containerInsert<N extends t.Node>(this: NodePath_Final, from: number, nodes: N[]): NodePath_Final<N>[];
|
|
1178
|
+
declare function _containerInsertBefore<N extends t.Node>(this: NodePath_Final, nodes: N[]): NodePath_Final<N>[];
|
|
1179
|
+
declare function _containerInsertAfter<N extends t.Node>(this: NodePath_Final, nodes: N[]): NodePath_Final<N>[];
|
|
1180
|
+
/**
|
|
1181
|
+
* Insert the provided nodes after the current one. When inserting nodes after an
|
|
1182
|
+
* expression, ensure that the completion record is correct by pushing the current node.
|
|
1183
|
+
*/
|
|
1184
|
+
declare function insertAfter(this: NodePath_Final, nodes_: t.Node | t.Node[]): NodePath_Final[];
|
|
1185
|
+
/**
|
|
1186
|
+
* Update all sibling node paths after `fromIndex` by `incrementBy`.
|
|
1187
|
+
*/
|
|
1188
|
+
declare function updateSiblingKeys(this: NodePath_Final, fromIndex: number, incrementBy: number): void;
|
|
1189
|
+
declare function _verifyNodeList<N extends t.Node>(this: NodePath_Final, nodes: N | N[]): N[];
|
|
1190
|
+
declare function unshiftContainer<N extends t.Node, K extends keyof N & string>(this: NodePath_Final<N>, listKey: K, nodes: N[K] extends (infer E)[] ? E | E[] : never): (NodePath<t.AnyTypeAnnotation> | NodePath<t.ArgumentPlaceholder> | NodePath<t.ArrayExpression> | NodePath<t.ArrayPattern> | NodePath<t.ArrayTypeAnnotation> | NodePath<t.ArrowFunctionExpression> | NodePath<t.AssignmentExpression> | NodePath<t.AssignmentPattern> | NodePath<t.AwaitExpression> | NodePath<t.BigIntLiteral> | NodePath<t.BinaryExpression> | NodePath<t.BindExpression> | NodePath<t.BlockStatement> | NodePath<t.BooleanLiteral> | NodePath<t.BooleanLiteralTypeAnnotation> | NodePath<t.BooleanTypeAnnotation> | NodePath<t.BreakStatement> | NodePath<t.CallExpression> | NodePath<t.CatchClause> | NodePath<t.ClassAccessorProperty> | NodePath<t.ClassBody> | NodePath<t.ClassDeclaration> | NodePath<t.ClassExpression> | NodePath<t.ClassImplements> | NodePath<t.ClassMethod> | NodePath<t.ClassPrivateMethod> | NodePath<t.ClassPrivateProperty> | NodePath<t.ClassProperty> | NodePath<t.ConditionalExpression> | NodePath<t.ContinueStatement> | NodePath<t.DebuggerStatement> | NodePath<t.DecimalLiteral> | NodePath<t.DeclareClass> | NodePath<t.DeclareExportAllDeclaration> | NodePath<t.DeclareExportDeclaration> | NodePath<t.DeclareFunction> | NodePath<t.DeclareInterface> | NodePath<t.DeclareModule> | NodePath<t.DeclareModuleExports> | NodePath<t.DeclareOpaqueType> | NodePath<t.DeclareTypeAlias> | NodePath<t.DeclareVariable> | NodePath<t.DeclaredPredicate> | NodePath<t.Decorator> | NodePath<t.Directive> | NodePath<t.DirectiveLiteral> | NodePath<t.DoExpression> | NodePath<t.DoWhileStatement> | NodePath<t.EmptyStatement> | NodePath<t.EmptyTypeAnnotation> | NodePath<t.EnumBooleanBody> | NodePath<t.EnumBooleanMember> | NodePath<t.EnumDeclaration> | NodePath<t.EnumDefaultedMember> | NodePath<t.EnumNumberBody> | NodePath<t.EnumNumberMember> | NodePath<t.EnumStringBody> | NodePath<t.EnumStringMember> | NodePath<t.EnumSymbolBody> | NodePath<t.ExistsTypeAnnotation> | NodePath<t.ExportAllDeclaration> | NodePath<t.ExportDefaultDeclaration> | NodePath<t.ExportDefaultSpecifier> | NodePath<t.ExportNamedDeclaration> | NodePath<t.ExportNamespaceSpecifier> | NodePath<t.ExportSpecifier> | NodePath<t.ExpressionStatement> | NodePath<t.File> | NodePath<t.ForInStatement> | NodePath<t.ForOfStatement> | NodePath<t.ForStatement> | NodePath<t.FunctionDeclaration> | NodePath<t.FunctionExpression> | NodePath<t.FunctionTypeAnnotation> | NodePath<t.FunctionTypeParam> | NodePath<t.GenericTypeAnnotation> | NodePath<t.Identifier> | NodePath<t.IfStatement> | NodePath<t.Import> | NodePath<t.ImportAttribute> | NodePath<t.ImportDeclaration> | NodePath<t.ImportDefaultSpecifier> | NodePath<t.ImportExpression> | NodePath<t.ImportNamespaceSpecifier> | NodePath<t.ImportSpecifier> | NodePath<t.IndexedAccessType> | NodePath<t.InferredPredicate> | NodePath<t.InterfaceDeclaration> | NodePath<t.InterfaceExtends> | NodePath<t.InterfaceTypeAnnotation> | NodePath<t.InterpreterDirective> | NodePath<t.IntersectionTypeAnnotation> | NodePath<t.JSXAttribute> | NodePath<t.JSXClosingElement> | NodePath<t.JSXClosingFragment> | NodePath<t.JSXElement> | NodePath<t.JSXEmptyExpression> | NodePath<t.JSXExpressionContainer> | NodePath<t.JSXFragment> | NodePath<t.JSXIdentifier> | NodePath<t.JSXMemberExpression> | NodePath<t.JSXNamespacedName> | NodePath<t.JSXOpeningElement> | NodePath<t.JSXOpeningFragment> | NodePath<t.JSXSpreadAttribute> | NodePath<t.JSXSpreadChild> | NodePath<t.JSXText> | NodePath<t.LabeledStatement> | NodePath<t.LogicalExpression> | NodePath<t.MemberExpression> | NodePath<t.MetaProperty> | NodePath<t.MixedTypeAnnotation> | NodePath<t.ModuleExpression> | NodePath<t.NewExpression> | NodePath<t.NullLiteral> | NodePath<t.NullLiteralTypeAnnotation> | NodePath<t.NullableTypeAnnotation> | NodePath<t.NumberLiteral> | NodePath<t.NumberLiteralTypeAnnotation> | NodePath<t.NumberTypeAnnotation> | NodePath<t.NumericLiteral> | NodePath<t.ObjectExpression> | NodePath<t.ObjectMethod> | NodePath<t.ObjectPattern> | NodePath<t.ObjectProperty> | NodePath<t.ObjectTypeAnnotation> | NodePath<t.ObjectTypeCallProperty> | NodePath<t.ObjectTypeIndexer> | NodePath<t.ObjectTypeInternalSlot> | NodePath<t.ObjectTypeProperty> | NodePath<t.ObjectTypeSpreadProperty> | NodePath<t.OpaqueType> | NodePath<t.OptionalCallExpression> | NodePath<t.OptionalIndexedAccessType> | NodePath<t.OptionalMemberExpression> | NodePath<t.ParenthesizedExpression> | NodePath<t.PipelineBareFunction> | NodePath<t.PipelinePrimaryTopicReference> | NodePath<t.PipelineTopicExpression> | NodePath<t.Placeholder> | NodePath<t.PrivateName> | NodePath<t.Program> | NodePath<t.QualifiedTypeIdentifier> | NodePath<t.RecordExpression> | NodePath<t.RegExpLiteral> | NodePath<t.RegexLiteral> | NodePath<t.RestElement> | NodePath<t.RestProperty> | NodePath<t.ReturnStatement> | NodePath<t.SequenceExpression> | NodePath<t.SpreadElement> | NodePath<t.SpreadProperty> | NodePath<t.StaticBlock> | NodePath<t.StringLiteral> | NodePath<t.StringLiteralTypeAnnotation> | NodePath<t.StringTypeAnnotation> | NodePath<t.Super> | NodePath<t.SwitchCase> | NodePath<t.SwitchStatement> | NodePath<t.SymbolTypeAnnotation> | NodePath<t.TSAnyKeyword> | NodePath<t.TSArrayType> | NodePath<t.TSAsExpression> | NodePath<t.TSBigIntKeyword> | NodePath<t.TSBooleanKeyword> | NodePath<t.TSCallSignatureDeclaration> | NodePath<t.TSConditionalType> | NodePath<t.TSConstructSignatureDeclaration> | NodePath<t.TSConstructorType> | NodePath<t.TSDeclareFunction> | NodePath<t.TSDeclareMethod> | NodePath<t.TSEnumDeclaration> | NodePath<t.TSEnumMember> | NodePath<t.TSExportAssignment> | NodePath<t.TSExpressionWithTypeArguments> | NodePath<t.TSExternalModuleReference> | NodePath<t.TSFunctionType> | NodePath<t.TSImportEqualsDeclaration> | NodePath<t.TSImportType> | NodePath<t.TSIndexSignature> | NodePath<t.TSIndexedAccessType> | NodePath<t.TSInferType> | NodePath<t.TSInstantiationExpression> | NodePath<t.TSInterfaceBody> | NodePath<t.TSInterfaceDeclaration> | NodePath<t.TSIntersectionType> | NodePath<t.TSIntrinsicKeyword> | NodePath<t.TSLiteralType> | NodePath<t.TSMappedType> | NodePath<t.TSMethodSignature> | NodePath<t.TSModuleBlock> | NodePath<t.TSModuleDeclaration> | NodePath<t.TSNamedTupleMember> | NodePath<t.TSNamespaceExportDeclaration> | NodePath<t.TSNeverKeyword> | NodePath<t.TSNonNullExpression> | NodePath<t.TSNullKeyword> | NodePath<t.TSNumberKeyword> | NodePath<t.TSObjectKeyword> | NodePath<t.TSOptionalType> | NodePath<t.TSParameterProperty> | NodePath<t.TSParenthesizedType> | NodePath<t.TSPropertySignature> | NodePath<t.TSQualifiedName> | NodePath<t.TSRestType> | NodePath<t.TSSatisfiesExpression> | NodePath<t.TSStringKeyword> | NodePath<t.TSSymbolKeyword> | NodePath<t.TSThisType> | NodePath<t.TSTupleType> | NodePath<t.TSTypeAliasDeclaration> | NodePath<t.TSTypeAnnotation> | NodePath<t.TSTypeAssertion> | NodePath<t.TSTypeLiteral> | NodePath<t.TSTypeOperator> | NodePath<t.TSTypeParameter> | NodePath<t.TSTypeParameterDeclaration> | NodePath<t.TSTypeParameterInstantiation> | NodePath<t.TSTypePredicate> | NodePath<t.TSTypeQuery> | NodePath<t.TSTypeReference> | NodePath<t.TSUndefinedKeyword> | NodePath<t.TSUnionType> | NodePath<t.TSUnknownKeyword> | NodePath<t.TSVoidKeyword> | NodePath<t.TaggedTemplateExpression> | NodePath<t.TemplateElement> | NodePath<t.TemplateLiteral> | NodePath<t.ThisExpression> | NodePath<t.ThisTypeAnnotation> | NodePath<t.ThrowStatement> | NodePath<t.TopicReference> | NodePath<t.TryStatement> | NodePath<t.TupleExpression> | NodePath<t.TupleTypeAnnotation> | NodePath<t.TypeAlias> | NodePath<t.TypeAnnotation> | NodePath<t.TypeCastExpression> | NodePath<t.TypeParameter> | NodePath<t.TypeParameterDeclaration> | NodePath<t.TypeParameterInstantiation> | NodePath<t.TypeofTypeAnnotation> | NodePath<t.UnaryExpression> | NodePath<t.UnionTypeAnnotation> | NodePath<t.UpdateExpression> | NodePath<t.V8IntrinsicIdentifier> | NodePath<t.VariableDeclaration> | NodePath<t.VariableDeclarator> | NodePath<t.Variance> | NodePath<t.VoidTypeAnnotation> | NodePath<t.WhileStatement> | NodePath<t.WithStatement> | NodePath<t.YieldExpression>)[];
|
|
1191
|
+
declare function pushContainer<P extends NodePath_Final, K extends string & keyof P["node"]>(this: P, listKey: K, nodes: P["node"][K] extends (infer E)[] ? E | E[] : never): NodePath_Final[];
|
|
1192
|
+
/**
|
|
1193
|
+
* Hoist the current node to the highest scope possible and return a UID
|
|
1194
|
+
* referencing it.
|
|
1195
|
+
*/
|
|
1196
|
+
declare function hoist<T extends t.Node>(this: NodePath_Final<T>, scope?: Scope): NodePath_Final<t.Expression>;
|
|
1197
|
+
|
|
1198
|
+
declare function getOpposite(this: NodePath_Final): NodePath_Final | null;
|
|
1199
|
+
/**
|
|
1200
|
+
* Retrieve the completion records of a given path.
|
|
1201
|
+
* Note: to ensure proper support on `break` statement, this method
|
|
1202
|
+
* will manipulate the AST around the break statement. Do not call the method
|
|
1203
|
+
* twice for the same path.
|
|
1204
|
+
*
|
|
1205
|
+
* @export
|
|
1206
|
+
* @param {NodePath} this
|
|
1207
|
+
* @returns {NodePath[]} Completion records
|
|
1208
|
+
*/
|
|
1209
|
+
declare function getCompletionRecords(this: NodePath_Final): NodePath_Final[];
|
|
1210
|
+
declare function getSibling(this: NodePath_Final, key: string | number): NodePath_Final;
|
|
1211
|
+
declare function getPrevSibling(this: NodePath_Final): NodePath_Final;
|
|
1212
|
+
declare function getNextSibling(this: NodePath_Final): NodePath_Final;
|
|
1213
|
+
declare function getAllNextSiblings(this: NodePath_Final): NodePath_Final[];
|
|
1214
|
+
declare function getAllPrevSiblings(this: NodePath_Final): NodePath_Final[];
|
|
1215
|
+
type MaybeToIndex<T extends string> = T extends `${bigint}` ? number : T;
|
|
1216
|
+
type Pattern<Obj extends string, Prop extends string> = `${Obj}.${Prop}`;
|
|
1217
|
+
type Split<P extends string> = P extends Pattern<infer O, infer U> ? [MaybeToIndex<O>, ...Split<U>] : [MaybeToIndex<P>];
|
|
1218
|
+
type Trav<Node extends t.Node | t.Node[], Path extends unknown[]> = Path extends [infer K, ...infer R] ? K extends keyof Node ? Node[K] extends t.Node | t.Node[] ? R extends [] ? Node[K] : Trav<Node[K], R> : never : never : never;
|
|
1219
|
+
type ToNodePath<T> = T extends Array<t.Node | null | undefined> ? Array<NodePath_Final<T[number]>> : T extends t.Node | null | undefined ? NodePath_Final<T> : never;
|
|
1220
|
+
declare function get<T extends NodePath_Final, K extends keyof T["node"]>(this: T, key: K, context?: boolean | TraversalContext): T extends any ? T["node"][K] extends Array<t.Node | null | undefined> ? Array<NodePath_Final<T["node"][K][number]>> : T["node"][K] extends t.Node | null | undefined ? NodePath_Final<T["node"][K]> : never : never;
|
|
1221
|
+
declare function get<T extends NodePath_Final, K extends string>(this: T, key: K, context?: boolean | TraversalContext): T extends any ? ToNodePath<Trav<T["node"], Split<K>>> : never;
|
|
1222
|
+
declare function get(this: NodePath_Final, key: string, context?: true | TraversalContext): NodePath_Final | NodePath_Final[];
|
|
1223
|
+
|
|
1224
|
+
declare function _getKey<T extends t.Node>(this: NodePath_Final<T>, key: keyof T & string, context?: TraversalContext): NodePath_Final | NodePath_Final[];
|
|
1225
|
+
declare function _getPattern(this: NodePath_Final, parts: string[], context?: TraversalContext): NodePath_Final | NodePath_Final[];
|
|
1226
|
+
declare function getBindingIdentifiers(duplicates: true): Record<string, t.Identifier[]>;
|
|
1227
|
+
declare function getBindingIdentifiers(duplicates?: false): Record<string, t.Identifier>;
|
|
1228
|
+
declare function getBindingIdentifiers(duplicates: boolean): Record<string, t.Identifier[] | t.Identifier>;
|
|
1229
|
+
|
|
1230
|
+
declare function getOuterBindingIdentifiers(duplicates: true): Record<string, t.Identifier[]>;
|
|
1231
|
+
declare function getOuterBindingIdentifiers(duplicates?: false): Record<string, t.Identifier>;
|
|
1232
|
+
declare function getOuterBindingIdentifiers(duplicates: boolean): Record<string, t.Identifier[] | t.Identifier>;
|
|
1233
|
+
|
|
1234
|
+
declare function getBindingIdentifierPaths(duplicates: true, outerOnly?: boolean): Record<string, NodePath_Final<t.Identifier>[]>;
|
|
1235
|
+
declare function getBindingIdentifierPaths(duplicates: false, outerOnly?: boolean): Record<string, NodePath_Final<t.Identifier>>;
|
|
1236
|
+
declare function getBindingIdentifierPaths(duplicates?: boolean, outerOnly?: boolean): Record<string, NodePath_Final<t.Identifier> | NodePath_Final<t.Identifier>[]>;
|
|
1237
|
+
|
|
1238
|
+
declare function getOuterBindingIdentifierPaths(duplicates: true): Record<string, NodePath_Final<t.Identifier>[]>;
|
|
1239
|
+
declare function getOuterBindingIdentifierPaths(duplicates?: false): Record<string, NodePath_Final<t.Identifier>>;
|
|
1240
|
+
declare function getOuterBindingIdentifierPaths(duplicates?: boolean): Record<string, NodePath_Final<t.Identifier> | NodePath_Final<t.Identifier>[]>;
|
|
1241
|
+
|
|
1242
|
+
/**
|
|
1243
|
+
* Share comments amongst siblings.
|
|
1244
|
+
*/
|
|
1245
|
+
declare function shareCommentsWithSiblings(this: NodePath_Final): void;
|
|
1246
|
+
declare function addComment(this: NodePath_Final, type: t.CommentTypeShorthand, content: string, line?: boolean): void;
|
|
1247
|
+
/**
|
|
1248
|
+
* Give node `comments` of the specified `type`.
|
|
1249
|
+
*/
|
|
1250
|
+
declare function addComments(this: NodePath_Final, type: t.CommentTypeShorthand, comments: t.Comment[]): void;
|
|
1251
|
+
|
|
1252
|
+
/*
|
|
1253
|
+
* This file is auto-generated! Do not modify it directly.
|
|
1254
|
+
* To re-generate run 'make build'
|
|
1255
|
+
*/
|
|
1256
|
+
|
|
1257
|
+
|
|
1258
|
+
type Opts$2<Obj> = Partial<{
|
|
1259
|
+
[Prop in keyof Obj]: Obj[Prop] extends t.Node
|
|
1260
|
+
? t.Node
|
|
1261
|
+
: Obj[Prop] extends t.Node[]
|
|
1262
|
+
? t.Node[]
|
|
1263
|
+
: Obj[Prop];
|
|
1264
|
+
}>;
|
|
1265
|
+
|
|
1266
|
+
interface NodePathAssertions {
|
|
1267
|
+
assertAccessor(opts?: Opts$2<t.Accessor>): asserts this is NodePath_Final<t.Accessor>;
|
|
1268
|
+
assertAnyTypeAnnotation(
|
|
1269
|
+
opts?: Opts$2<t.AnyTypeAnnotation>,
|
|
1270
|
+
): asserts this is NodePath_Final<t.AnyTypeAnnotation>;
|
|
1271
|
+
assertArgumentPlaceholder(
|
|
1272
|
+
opts?: Opts$2<t.ArgumentPlaceholder>,
|
|
1273
|
+
): asserts this is NodePath_Final<t.ArgumentPlaceholder>;
|
|
1274
|
+
assertArrayExpression(
|
|
1275
|
+
opts?: Opts$2<t.ArrayExpression>,
|
|
1276
|
+
): asserts this is NodePath_Final<t.ArrayExpression>;
|
|
1277
|
+
assertArrayPattern(
|
|
1278
|
+
opts?: Opts$2<t.ArrayPattern>,
|
|
1279
|
+
): asserts this is NodePath_Final<t.ArrayPattern>;
|
|
1280
|
+
assertArrayTypeAnnotation(
|
|
1281
|
+
opts?: Opts$2<t.ArrayTypeAnnotation>,
|
|
1282
|
+
): asserts this is NodePath_Final<t.ArrayTypeAnnotation>;
|
|
1283
|
+
assertArrowFunctionExpression(
|
|
1284
|
+
opts?: Opts$2<t.ArrowFunctionExpression>,
|
|
1285
|
+
): asserts this is NodePath_Final<t.ArrowFunctionExpression>;
|
|
1286
|
+
assertAssignmentExpression(
|
|
1287
|
+
opts?: Opts$2<t.AssignmentExpression>,
|
|
1288
|
+
): asserts this is NodePath_Final<t.AssignmentExpression>;
|
|
1289
|
+
assertAssignmentPattern(
|
|
1290
|
+
opts?: Opts$2<t.AssignmentPattern>,
|
|
1291
|
+
): asserts this is NodePath_Final<t.AssignmentPattern>;
|
|
1292
|
+
assertAwaitExpression(
|
|
1293
|
+
opts?: Opts$2<t.AwaitExpression>,
|
|
1294
|
+
): asserts this is NodePath_Final<t.AwaitExpression>;
|
|
1295
|
+
assertBigIntLiteral(
|
|
1296
|
+
opts?: Opts$2<t.BigIntLiteral>,
|
|
1297
|
+
): asserts this is NodePath_Final<t.BigIntLiteral>;
|
|
1298
|
+
assertBinary(opts?: Opts$2<t.Binary>): asserts this is NodePath_Final<t.Binary>;
|
|
1299
|
+
assertBinaryExpression(
|
|
1300
|
+
opts?: Opts$2<t.BinaryExpression>,
|
|
1301
|
+
): asserts this is NodePath_Final<t.BinaryExpression>;
|
|
1302
|
+
assertBindExpression(
|
|
1303
|
+
opts?: Opts$2<t.BindExpression>,
|
|
1304
|
+
): asserts this is NodePath_Final<t.BindExpression>;
|
|
1305
|
+
assertBlock(opts?: Opts$2<t.Block>): asserts this is NodePath_Final<t.Block>;
|
|
1306
|
+
assertBlockParent(
|
|
1307
|
+
opts?: Opts$2<t.BlockParent>,
|
|
1308
|
+
): asserts this is NodePath_Final<t.BlockParent>;
|
|
1309
|
+
assertBlockStatement(
|
|
1310
|
+
opts?: Opts$2<t.BlockStatement>,
|
|
1311
|
+
): asserts this is NodePath_Final<t.BlockStatement>;
|
|
1312
|
+
assertBooleanLiteral(
|
|
1313
|
+
opts?: Opts$2<t.BooleanLiteral>,
|
|
1314
|
+
): asserts this is NodePath_Final<t.BooleanLiteral>;
|
|
1315
|
+
assertBooleanLiteralTypeAnnotation(
|
|
1316
|
+
opts?: Opts$2<t.BooleanLiteralTypeAnnotation>,
|
|
1317
|
+
): asserts this is NodePath_Final<t.BooleanLiteralTypeAnnotation>;
|
|
1318
|
+
assertBooleanTypeAnnotation(
|
|
1319
|
+
opts?: Opts$2<t.BooleanTypeAnnotation>,
|
|
1320
|
+
): asserts this is NodePath_Final<t.BooleanTypeAnnotation>;
|
|
1321
|
+
assertBreakStatement(
|
|
1322
|
+
opts?: Opts$2<t.BreakStatement>,
|
|
1323
|
+
): asserts this is NodePath_Final<t.BreakStatement>;
|
|
1324
|
+
assertCallExpression(
|
|
1325
|
+
opts?: Opts$2<t.CallExpression>,
|
|
1326
|
+
): asserts this is NodePath_Final<t.CallExpression>;
|
|
1327
|
+
assertCatchClause(
|
|
1328
|
+
opts?: Opts$2<t.CatchClause>,
|
|
1329
|
+
): asserts this is NodePath_Final<t.CatchClause>;
|
|
1330
|
+
assertClass(opts?: Opts$2<t.Class>): asserts this is NodePath_Final<t.Class>;
|
|
1331
|
+
assertClassAccessorProperty(
|
|
1332
|
+
opts?: Opts$2<t.ClassAccessorProperty>,
|
|
1333
|
+
): asserts this is NodePath_Final<t.ClassAccessorProperty>;
|
|
1334
|
+
assertClassBody(
|
|
1335
|
+
opts?: Opts$2<t.ClassBody>,
|
|
1336
|
+
): asserts this is NodePath_Final<t.ClassBody>;
|
|
1337
|
+
assertClassDeclaration(
|
|
1338
|
+
opts?: Opts$2<t.ClassDeclaration>,
|
|
1339
|
+
): asserts this is NodePath_Final<t.ClassDeclaration>;
|
|
1340
|
+
assertClassExpression(
|
|
1341
|
+
opts?: Opts$2<t.ClassExpression>,
|
|
1342
|
+
): asserts this is NodePath_Final<t.ClassExpression>;
|
|
1343
|
+
assertClassImplements(
|
|
1344
|
+
opts?: Opts$2<t.ClassImplements>,
|
|
1345
|
+
): asserts this is NodePath_Final<t.ClassImplements>;
|
|
1346
|
+
assertClassMethod(
|
|
1347
|
+
opts?: Opts$2<t.ClassMethod>,
|
|
1348
|
+
): asserts this is NodePath_Final<t.ClassMethod>;
|
|
1349
|
+
assertClassPrivateMethod(
|
|
1350
|
+
opts?: Opts$2<t.ClassPrivateMethod>,
|
|
1351
|
+
): asserts this is NodePath_Final<t.ClassPrivateMethod>;
|
|
1352
|
+
assertClassPrivateProperty(
|
|
1353
|
+
opts?: Opts$2<t.ClassPrivateProperty>,
|
|
1354
|
+
): asserts this is NodePath_Final<t.ClassPrivateProperty>;
|
|
1355
|
+
assertClassProperty(
|
|
1356
|
+
opts?: Opts$2<t.ClassProperty>,
|
|
1357
|
+
): asserts this is NodePath_Final<t.ClassProperty>;
|
|
1358
|
+
assertCompletionStatement(
|
|
1359
|
+
opts?: Opts$2<t.CompletionStatement>,
|
|
1360
|
+
): asserts this is NodePath_Final<t.CompletionStatement>;
|
|
1361
|
+
assertConditional(
|
|
1362
|
+
opts?: Opts$2<t.Conditional>,
|
|
1363
|
+
): asserts this is NodePath_Final<t.Conditional>;
|
|
1364
|
+
assertConditionalExpression(
|
|
1365
|
+
opts?: Opts$2<t.ConditionalExpression>,
|
|
1366
|
+
): asserts this is NodePath_Final<t.ConditionalExpression>;
|
|
1367
|
+
assertContinueStatement(
|
|
1368
|
+
opts?: Opts$2<t.ContinueStatement>,
|
|
1369
|
+
): asserts this is NodePath_Final<t.ContinueStatement>;
|
|
1370
|
+
assertDebuggerStatement(
|
|
1371
|
+
opts?: Opts$2<t.DebuggerStatement>,
|
|
1372
|
+
): asserts this is NodePath_Final<t.DebuggerStatement>;
|
|
1373
|
+
assertDecimalLiteral(
|
|
1374
|
+
opts?: Opts$2<t.DecimalLiteral>,
|
|
1375
|
+
): asserts this is NodePath_Final<t.DecimalLiteral>;
|
|
1376
|
+
assertDeclaration(
|
|
1377
|
+
opts?: Opts$2<t.Declaration>,
|
|
1378
|
+
): asserts this is NodePath_Final<t.Declaration>;
|
|
1379
|
+
assertDeclareClass(
|
|
1380
|
+
opts?: Opts$2<t.DeclareClass>,
|
|
1381
|
+
): asserts this is NodePath_Final<t.DeclareClass>;
|
|
1382
|
+
assertDeclareExportAllDeclaration(
|
|
1383
|
+
opts?: Opts$2<t.DeclareExportAllDeclaration>,
|
|
1384
|
+
): asserts this is NodePath_Final<t.DeclareExportAllDeclaration>;
|
|
1385
|
+
assertDeclareExportDeclaration(
|
|
1386
|
+
opts?: Opts$2<t.DeclareExportDeclaration>,
|
|
1387
|
+
): asserts this is NodePath_Final<t.DeclareExportDeclaration>;
|
|
1388
|
+
assertDeclareFunction(
|
|
1389
|
+
opts?: Opts$2<t.DeclareFunction>,
|
|
1390
|
+
): asserts this is NodePath_Final<t.DeclareFunction>;
|
|
1391
|
+
assertDeclareInterface(
|
|
1392
|
+
opts?: Opts$2<t.DeclareInterface>,
|
|
1393
|
+
): asserts this is NodePath_Final<t.DeclareInterface>;
|
|
1394
|
+
assertDeclareModule(
|
|
1395
|
+
opts?: Opts$2<t.DeclareModule>,
|
|
1396
|
+
): asserts this is NodePath_Final<t.DeclareModule>;
|
|
1397
|
+
assertDeclareModuleExports(
|
|
1398
|
+
opts?: Opts$2<t.DeclareModuleExports>,
|
|
1399
|
+
): asserts this is NodePath_Final<t.DeclareModuleExports>;
|
|
1400
|
+
assertDeclareOpaqueType(
|
|
1401
|
+
opts?: Opts$2<t.DeclareOpaqueType>,
|
|
1402
|
+
): asserts this is NodePath_Final<t.DeclareOpaqueType>;
|
|
1403
|
+
assertDeclareTypeAlias(
|
|
1404
|
+
opts?: Opts$2<t.DeclareTypeAlias>,
|
|
1405
|
+
): asserts this is NodePath_Final<t.DeclareTypeAlias>;
|
|
1406
|
+
assertDeclareVariable(
|
|
1407
|
+
opts?: Opts$2<t.DeclareVariable>,
|
|
1408
|
+
): asserts this is NodePath_Final<t.DeclareVariable>;
|
|
1409
|
+
assertDeclaredPredicate(
|
|
1410
|
+
opts?: Opts$2<t.DeclaredPredicate>,
|
|
1411
|
+
): asserts this is NodePath_Final<t.DeclaredPredicate>;
|
|
1412
|
+
assertDecorator(
|
|
1413
|
+
opts?: Opts$2<t.Decorator>,
|
|
1414
|
+
): asserts this is NodePath_Final<t.Decorator>;
|
|
1415
|
+
assertDirective(
|
|
1416
|
+
opts?: Opts$2<t.Directive>,
|
|
1417
|
+
): asserts this is NodePath_Final<t.Directive>;
|
|
1418
|
+
assertDirectiveLiteral(
|
|
1419
|
+
opts?: Opts$2<t.DirectiveLiteral>,
|
|
1420
|
+
): asserts this is NodePath_Final<t.DirectiveLiteral>;
|
|
1421
|
+
assertDoExpression(
|
|
1422
|
+
opts?: Opts$2<t.DoExpression>,
|
|
1423
|
+
): asserts this is NodePath_Final<t.DoExpression>;
|
|
1424
|
+
assertDoWhileStatement(
|
|
1425
|
+
opts?: Opts$2<t.DoWhileStatement>,
|
|
1426
|
+
): asserts this is NodePath_Final<t.DoWhileStatement>;
|
|
1427
|
+
assertEmptyStatement(
|
|
1428
|
+
opts?: Opts$2<t.EmptyStatement>,
|
|
1429
|
+
): asserts this is NodePath_Final<t.EmptyStatement>;
|
|
1430
|
+
assertEmptyTypeAnnotation(
|
|
1431
|
+
opts?: Opts$2<t.EmptyTypeAnnotation>,
|
|
1432
|
+
): asserts this is NodePath_Final<t.EmptyTypeAnnotation>;
|
|
1433
|
+
assertEnumBody(opts?: Opts$2<t.EnumBody>): asserts this is NodePath_Final<t.EnumBody>;
|
|
1434
|
+
assertEnumBooleanBody(
|
|
1435
|
+
opts?: Opts$2<t.EnumBooleanBody>,
|
|
1436
|
+
): asserts this is NodePath_Final<t.EnumBooleanBody>;
|
|
1437
|
+
assertEnumBooleanMember(
|
|
1438
|
+
opts?: Opts$2<t.EnumBooleanMember>,
|
|
1439
|
+
): asserts this is NodePath_Final<t.EnumBooleanMember>;
|
|
1440
|
+
assertEnumDeclaration(
|
|
1441
|
+
opts?: Opts$2<t.EnumDeclaration>,
|
|
1442
|
+
): asserts this is NodePath_Final<t.EnumDeclaration>;
|
|
1443
|
+
assertEnumDefaultedMember(
|
|
1444
|
+
opts?: Opts$2<t.EnumDefaultedMember>,
|
|
1445
|
+
): asserts this is NodePath_Final<t.EnumDefaultedMember>;
|
|
1446
|
+
assertEnumMember(
|
|
1447
|
+
opts?: Opts$2<t.EnumMember>,
|
|
1448
|
+
): asserts this is NodePath_Final<t.EnumMember>;
|
|
1449
|
+
assertEnumNumberBody(
|
|
1450
|
+
opts?: Opts$2<t.EnumNumberBody>,
|
|
1451
|
+
): asserts this is NodePath_Final<t.EnumNumberBody>;
|
|
1452
|
+
assertEnumNumberMember(
|
|
1453
|
+
opts?: Opts$2<t.EnumNumberMember>,
|
|
1454
|
+
): asserts this is NodePath_Final<t.EnumNumberMember>;
|
|
1455
|
+
assertEnumStringBody(
|
|
1456
|
+
opts?: Opts$2<t.EnumStringBody>,
|
|
1457
|
+
): asserts this is NodePath_Final<t.EnumStringBody>;
|
|
1458
|
+
assertEnumStringMember(
|
|
1459
|
+
opts?: Opts$2<t.EnumStringMember>,
|
|
1460
|
+
): asserts this is NodePath_Final<t.EnumStringMember>;
|
|
1461
|
+
assertEnumSymbolBody(
|
|
1462
|
+
opts?: Opts$2<t.EnumSymbolBody>,
|
|
1463
|
+
): asserts this is NodePath_Final<t.EnumSymbolBody>;
|
|
1464
|
+
assertExistsTypeAnnotation(
|
|
1465
|
+
opts?: Opts$2<t.ExistsTypeAnnotation>,
|
|
1466
|
+
): asserts this is NodePath_Final<t.ExistsTypeAnnotation>;
|
|
1467
|
+
assertExportAllDeclaration(
|
|
1468
|
+
opts?: Opts$2<t.ExportAllDeclaration>,
|
|
1469
|
+
): asserts this is NodePath_Final<t.ExportAllDeclaration>;
|
|
1470
|
+
assertExportDeclaration(
|
|
1471
|
+
opts?: Opts$2<t.ExportDeclaration>,
|
|
1472
|
+
): asserts this is NodePath_Final<t.ExportDeclaration>;
|
|
1473
|
+
assertExportDefaultDeclaration(
|
|
1474
|
+
opts?: Opts$2<t.ExportDefaultDeclaration>,
|
|
1475
|
+
): asserts this is NodePath_Final<t.ExportDefaultDeclaration>;
|
|
1476
|
+
assertExportDefaultSpecifier(
|
|
1477
|
+
opts?: Opts$2<t.ExportDefaultSpecifier>,
|
|
1478
|
+
): asserts this is NodePath_Final<t.ExportDefaultSpecifier>;
|
|
1479
|
+
assertExportNamedDeclaration(
|
|
1480
|
+
opts?: Opts$2<t.ExportNamedDeclaration>,
|
|
1481
|
+
): asserts this is NodePath_Final<t.ExportNamedDeclaration>;
|
|
1482
|
+
assertExportNamespaceSpecifier(
|
|
1483
|
+
opts?: Opts$2<t.ExportNamespaceSpecifier>,
|
|
1484
|
+
): asserts this is NodePath_Final<t.ExportNamespaceSpecifier>;
|
|
1485
|
+
assertExportSpecifier(
|
|
1486
|
+
opts?: Opts$2<t.ExportSpecifier>,
|
|
1487
|
+
): asserts this is NodePath_Final<t.ExportSpecifier>;
|
|
1488
|
+
assertExpression(
|
|
1489
|
+
opts?: Opts$2<t.Expression>,
|
|
1490
|
+
): asserts this is NodePath_Final<t.Expression>;
|
|
1491
|
+
assertExpressionStatement(
|
|
1492
|
+
opts?: Opts$2<t.ExpressionStatement>,
|
|
1493
|
+
): asserts this is NodePath_Final<t.ExpressionStatement>;
|
|
1494
|
+
assertExpressionWrapper(
|
|
1495
|
+
opts?: Opts$2<t.ExpressionWrapper>,
|
|
1496
|
+
): asserts this is NodePath_Final<t.ExpressionWrapper>;
|
|
1497
|
+
assertFile(opts?: Opts$2<t.File>): asserts this is NodePath_Final<t.File>;
|
|
1498
|
+
assertFlow(opts?: Opts$2<t.Flow>): asserts this is NodePath_Final<t.Flow>;
|
|
1499
|
+
assertFlowBaseAnnotation(
|
|
1500
|
+
opts?: Opts$2<t.FlowBaseAnnotation>,
|
|
1501
|
+
): asserts this is NodePath_Final<t.FlowBaseAnnotation>;
|
|
1502
|
+
assertFlowDeclaration(
|
|
1503
|
+
opts?: Opts$2<t.FlowDeclaration>,
|
|
1504
|
+
): asserts this is NodePath_Final<t.FlowDeclaration>;
|
|
1505
|
+
assertFlowPredicate(
|
|
1506
|
+
opts?: Opts$2<t.FlowPredicate>,
|
|
1507
|
+
): asserts this is NodePath_Final<t.FlowPredicate>;
|
|
1508
|
+
assertFlowType(opts?: Opts$2<t.FlowType>): asserts this is NodePath_Final<t.FlowType>;
|
|
1509
|
+
assertFor(opts?: Opts$2<t.For>): asserts this is NodePath_Final<t.For>;
|
|
1510
|
+
assertForInStatement(
|
|
1511
|
+
opts?: Opts$2<t.ForInStatement>,
|
|
1512
|
+
): asserts this is NodePath_Final<t.ForInStatement>;
|
|
1513
|
+
assertForOfStatement(
|
|
1514
|
+
opts?: Opts$2<t.ForOfStatement>,
|
|
1515
|
+
): asserts this is NodePath_Final<t.ForOfStatement>;
|
|
1516
|
+
assertForStatement(
|
|
1517
|
+
opts?: Opts$2<t.ForStatement>,
|
|
1518
|
+
): asserts this is NodePath_Final<t.ForStatement>;
|
|
1519
|
+
assertForXStatement(
|
|
1520
|
+
opts?: Opts$2<t.ForXStatement>,
|
|
1521
|
+
): asserts this is NodePath_Final<t.ForXStatement>;
|
|
1522
|
+
assertFunction(opts?: Opts$2<t.Function>): asserts this is NodePath_Final<t.Function>;
|
|
1523
|
+
assertFunctionDeclaration(
|
|
1524
|
+
opts?: Opts$2<t.FunctionDeclaration>,
|
|
1525
|
+
): asserts this is NodePath_Final<t.FunctionDeclaration>;
|
|
1526
|
+
assertFunctionExpression(
|
|
1527
|
+
opts?: Opts$2<t.FunctionExpression>,
|
|
1528
|
+
): asserts this is NodePath_Final<t.FunctionExpression>;
|
|
1529
|
+
assertFunctionParent(
|
|
1530
|
+
opts?: Opts$2<t.FunctionParent>,
|
|
1531
|
+
): asserts this is NodePath_Final<t.FunctionParent>;
|
|
1532
|
+
assertFunctionTypeAnnotation(
|
|
1533
|
+
opts?: Opts$2<t.FunctionTypeAnnotation>,
|
|
1534
|
+
): asserts this is NodePath_Final<t.FunctionTypeAnnotation>;
|
|
1535
|
+
assertFunctionTypeParam(
|
|
1536
|
+
opts?: Opts$2<t.FunctionTypeParam>,
|
|
1537
|
+
): asserts this is NodePath_Final<t.FunctionTypeParam>;
|
|
1538
|
+
assertGenericTypeAnnotation(
|
|
1539
|
+
opts?: Opts$2<t.GenericTypeAnnotation>,
|
|
1540
|
+
): asserts this is NodePath_Final<t.GenericTypeAnnotation>;
|
|
1541
|
+
assertIdentifier(
|
|
1542
|
+
opts?: Opts$2<t.Identifier>,
|
|
1543
|
+
): asserts this is NodePath_Final<t.Identifier>;
|
|
1544
|
+
assertIfStatement(
|
|
1545
|
+
opts?: Opts$2<t.IfStatement>,
|
|
1546
|
+
): asserts this is NodePath_Final<t.IfStatement>;
|
|
1547
|
+
assertImmutable(
|
|
1548
|
+
opts?: Opts$2<t.Immutable>,
|
|
1549
|
+
): asserts this is NodePath_Final<t.Immutable>;
|
|
1550
|
+
assertImport(opts?: Opts$2<t.Import>): asserts this is NodePath_Final<t.Import>;
|
|
1551
|
+
assertImportAttribute(
|
|
1552
|
+
opts?: Opts$2<t.ImportAttribute>,
|
|
1553
|
+
): asserts this is NodePath_Final<t.ImportAttribute>;
|
|
1554
|
+
assertImportDeclaration(
|
|
1555
|
+
opts?: Opts$2<t.ImportDeclaration>,
|
|
1556
|
+
): asserts this is NodePath_Final<t.ImportDeclaration>;
|
|
1557
|
+
assertImportDefaultSpecifier(
|
|
1558
|
+
opts?: Opts$2<t.ImportDefaultSpecifier>,
|
|
1559
|
+
): asserts this is NodePath_Final<t.ImportDefaultSpecifier>;
|
|
1560
|
+
assertImportExpression(
|
|
1561
|
+
opts?: Opts$2<t.ImportExpression>,
|
|
1562
|
+
): asserts this is NodePath_Final<t.ImportExpression>;
|
|
1563
|
+
assertImportNamespaceSpecifier(
|
|
1564
|
+
opts?: Opts$2<t.ImportNamespaceSpecifier>,
|
|
1565
|
+
): asserts this is NodePath_Final<t.ImportNamespaceSpecifier>;
|
|
1566
|
+
assertImportOrExportDeclaration(
|
|
1567
|
+
opts?: Opts$2<t.ImportOrExportDeclaration>,
|
|
1568
|
+
): asserts this is NodePath_Final<t.ImportOrExportDeclaration>;
|
|
1569
|
+
assertImportSpecifier(
|
|
1570
|
+
opts?: Opts$2<t.ImportSpecifier>,
|
|
1571
|
+
): asserts this is NodePath_Final<t.ImportSpecifier>;
|
|
1572
|
+
assertIndexedAccessType(
|
|
1573
|
+
opts?: Opts$2<t.IndexedAccessType>,
|
|
1574
|
+
): asserts this is NodePath_Final<t.IndexedAccessType>;
|
|
1575
|
+
assertInferredPredicate(
|
|
1576
|
+
opts?: Opts$2<t.InferredPredicate>,
|
|
1577
|
+
): asserts this is NodePath_Final<t.InferredPredicate>;
|
|
1578
|
+
assertInterfaceDeclaration(
|
|
1579
|
+
opts?: Opts$2<t.InterfaceDeclaration>,
|
|
1580
|
+
): asserts this is NodePath_Final<t.InterfaceDeclaration>;
|
|
1581
|
+
assertInterfaceExtends(
|
|
1582
|
+
opts?: Opts$2<t.InterfaceExtends>,
|
|
1583
|
+
): asserts this is NodePath_Final<t.InterfaceExtends>;
|
|
1584
|
+
assertInterfaceTypeAnnotation(
|
|
1585
|
+
opts?: Opts$2<t.InterfaceTypeAnnotation>,
|
|
1586
|
+
): asserts this is NodePath_Final<t.InterfaceTypeAnnotation>;
|
|
1587
|
+
assertInterpreterDirective(
|
|
1588
|
+
opts?: Opts$2<t.InterpreterDirective>,
|
|
1589
|
+
): asserts this is NodePath_Final<t.InterpreterDirective>;
|
|
1590
|
+
assertIntersectionTypeAnnotation(
|
|
1591
|
+
opts?: Opts$2<t.IntersectionTypeAnnotation>,
|
|
1592
|
+
): asserts this is NodePath_Final<t.IntersectionTypeAnnotation>;
|
|
1593
|
+
assertJSX(opts?: Opts$2<t.JSX>): asserts this is NodePath_Final<t.JSX>;
|
|
1594
|
+
assertJSXAttribute(
|
|
1595
|
+
opts?: Opts$2<t.JSXAttribute>,
|
|
1596
|
+
): asserts this is NodePath_Final<t.JSXAttribute>;
|
|
1597
|
+
assertJSXClosingElement(
|
|
1598
|
+
opts?: Opts$2<t.JSXClosingElement>,
|
|
1599
|
+
): asserts this is NodePath_Final<t.JSXClosingElement>;
|
|
1600
|
+
assertJSXClosingFragment(
|
|
1601
|
+
opts?: Opts$2<t.JSXClosingFragment>,
|
|
1602
|
+
): asserts this is NodePath_Final<t.JSXClosingFragment>;
|
|
1603
|
+
assertJSXElement(
|
|
1604
|
+
opts?: Opts$2<t.JSXElement>,
|
|
1605
|
+
): asserts this is NodePath_Final<t.JSXElement>;
|
|
1606
|
+
assertJSXEmptyExpression(
|
|
1607
|
+
opts?: Opts$2<t.JSXEmptyExpression>,
|
|
1608
|
+
): asserts this is NodePath_Final<t.JSXEmptyExpression>;
|
|
1609
|
+
assertJSXExpressionContainer(
|
|
1610
|
+
opts?: Opts$2<t.JSXExpressionContainer>,
|
|
1611
|
+
): asserts this is NodePath_Final<t.JSXExpressionContainer>;
|
|
1612
|
+
assertJSXFragment(
|
|
1613
|
+
opts?: Opts$2<t.JSXFragment>,
|
|
1614
|
+
): asserts this is NodePath_Final<t.JSXFragment>;
|
|
1615
|
+
assertJSXIdentifier(
|
|
1616
|
+
opts?: Opts$2<t.JSXIdentifier>,
|
|
1617
|
+
): asserts this is NodePath_Final<t.JSXIdentifier>;
|
|
1618
|
+
assertJSXMemberExpression(
|
|
1619
|
+
opts?: Opts$2<t.JSXMemberExpression>,
|
|
1620
|
+
): asserts this is NodePath_Final<t.JSXMemberExpression>;
|
|
1621
|
+
assertJSXNamespacedName(
|
|
1622
|
+
opts?: Opts$2<t.JSXNamespacedName>,
|
|
1623
|
+
): asserts this is NodePath_Final<t.JSXNamespacedName>;
|
|
1624
|
+
assertJSXOpeningElement(
|
|
1625
|
+
opts?: Opts$2<t.JSXOpeningElement>,
|
|
1626
|
+
): asserts this is NodePath_Final<t.JSXOpeningElement>;
|
|
1627
|
+
assertJSXOpeningFragment(
|
|
1628
|
+
opts?: Opts$2<t.JSXOpeningFragment>,
|
|
1629
|
+
): asserts this is NodePath_Final<t.JSXOpeningFragment>;
|
|
1630
|
+
assertJSXSpreadAttribute(
|
|
1631
|
+
opts?: Opts$2<t.JSXSpreadAttribute>,
|
|
1632
|
+
): asserts this is NodePath_Final<t.JSXSpreadAttribute>;
|
|
1633
|
+
assertJSXSpreadChild(
|
|
1634
|
+
opts?: Opts$2<t.JSXSpreadChild>,
|
|
1635
|
+
): asserts this is NodePath_Final<t.JSXSpreadChild>;
|
|
1636
|
+
assertJSXText(opts?: Opts$2<t.JSXText>): asserts this is NodePath_Final<t.JSXText>;
|
|
1637
|
+
assertLVal(opts?: Opts$2<t.LVal>): asserts this is NodePath_Final<t.LVal>;
|
|
1638
|
+
assertLabeledStatement(
|
|
1639
|
+
opts?: Opts$2<t.LabeledStatement>,
|
|
1640
|
+
): asserts this is NodePath_Final<t.LabeledStatement>;
|
|
1641
|
+
assertLiteral(opts?: Opts$2<t.Literal>): asserts this is NodePath_Final<t.Literal>;
|
|
1642
|
+
assertLogicalExpression(
|
|
1643
|
+
opts?: Opts$2<t.LogicalExpression>,
|
|
1644
|
+
): asserts this is NodePath_Final<t.LogicalExpression>;
|
|
1645
|
+
assertLoop(opts?: Opts$2<t.Loop>): asserts this is NodePath_Final<t.Loop>;
|
|
1646
|
+
assertMemberExpression(
|
|
1647
|
+
opts?: Opts$2<t.MemberExpression>,
|
|
1648
|
+
): asserts this is NodePath_Final<t.MemberExpression>;
|
|
1649
|
+
assertMetaProperty(
|
|
1650
|
+
opts?: Opts$2<t.MetaProperty>,
|
|
1651
|
+
): asserts this is NodePath_Final<t.MetaProperty>;
|
|
1652
|
+
assertMethod(opts?: Opts$2<t.Method>): asserts this is NodePath_Final<t.Method>;
|
|
1653
|
+
assertMiscellaneous(
|
|
1654
|
+
opts?: Opts$2<t.Miscellaneous>,
|
|
1655
|
+
): asserts this is NodePath_Final<t.Miscellaneous>;
|
|
1656
|
+
assertMixedTypeAnnotation(
|
|
1657
|
+
opts?: Opts$2<t.MixedTypeAnnotation>,
|
|
1658
|
+
): asserts this is NodePath_Final<t.MixedTypeAnnotation>;
|
|
1659
|
+
assertModuleDeclaration(
|
|
1660
|
+
opts?: Opts$2<t.ModuleDeclaration>,
|
|
1661
|
+
): asserts this is NodePath_Final<t.ModuleDeclaration>;
|
|
1662
|
+
assertModuleExpression(
|
|
1663
|
+
opts?: Opts$2<t.ModuleExpression>,
|
|
1664
|
+
): asserts this is NodePath_Final<t.ModuleExpression>;
|
|
1665
|
+
assertModuleSpecifier(
|
|
1666
|
+
opts?: Opts$2<t.ModuleSpecifier>,
|
|
1667
|
+
): asserts this is NodePath_Final<t.ModuleSpecifier>;
|
|
1668
|
+
assertNewExpression(
|
|
1669
|
+
opts?: Opts$2<t.NewExpression>,
|
|
1670
|
+
): asserts this is NodePath_Final<t.NewExpression>;
|
|
1671
|
+
assertNullLiteral(
|
|
1672
|
+
opts?: Opts$2<t.NullLiteral>,
|
|
1673
|
+
): asserts this is NodePath_Final<t.NullLiteral>;
|
|
1674
|
+
assertNullLiteralTypeAnnotation(
|
|
1675
|
+
opts?: Opts$2<t.NullLiteralTypeAnnotation>,
|
|
1676
|
+
): asserts this is NodePath_Final<t.NullLiteralTypeAnnotation>;
|
|
1677
|
+
assertNullableTypeAnnotation(
|
|
1678
|
+
opts?: Opts$2<t.NullableTypeAnnotation>,
|
|
1679
|
+
): asserts this is NodePath_Final<t.NullableTypeAnnotation>;
|
|
1680
|
+
assertNumberLiteral(
|
|
1681
|
+
opts?: Opts$2<t.NumberLiteral>,
|
|
1682
|
+
): asserts this is NodePath_Final<t.NumberLiteral>;
|
|
1683
|
+
assertNumberLiteralTypeAnnotation(
|
|
1684
|
+
opts?: Opts$2<t.NumberLiteralTypeAnnotation>,
|
|
1685
|
+
): asserts this is NodePath_Final<t.NumberLiteralTypeAnnotation>;
|
|
1686
|
+
assertNumberTypeAnnotation(
|
|
1687
|
+
opts?: Opts$2<t.NumberTypeAnnotation>,
|
|
1688
|
+
): asserts this is NodePath_Final<t.NumberTypeAnnotation>;
|
|
1689
|
+
assertNumericLiteral(
|
|
1690
|
+
opts?: Opts$2<t.NumericLiteral>,
|
|
1691
|
+
): asserts this is NodePath_Final<t.NumericLiteral>;
|
|
1692
|
+
assertObjectExpression(
|
|
1693
|
+
opts?: Opts$2<t.ObjectExpression>,
|
|
1694
|
+
): asserts this is NodePath_Final<t.ObjectExpression>;
|
|
1695
|
+
assertObjectMember(
|
|
1696
|
+
opts?: Opts$2<t.ObjectMember>,
|
|
1697
|
+
): asserts this is NodePath_Final<t.ObjectMember>;
|
|
1698
|
+
assertObjectMethod(
|
|
1699
|
+
opts?: Opts$2<t.ObjectMethod>,
|
|
1700
|
+
): asserts this is NodePath_Final<t.ObjectMethod>;
|
|
1701
|
+
assertObjectPattern(
|
|
1702
|
+
opts?: Opts$2<t.ObjectPattern>,
|
|
1703
|
+
): asserts this is NodePath_Final<t.ObjectPattern>;
|
|
1704
|
+
assertObjectProperty(
|
|
1705
|
+
opts?: Opts$2<t.ObjectProperty>,
|
|
1706
|
+
): asserts this is NodePath_Final<t.ObjectProperty>;
|
|
1707
|
+
assertObjectTypeAnnotation(
|
|
1708
|
+
opts?: Opts$2<t.ObjectTypeAnnotation>,
|
|
1709
|
+
): asserts this is NodePath_Final<t.ObjectTypeAnnotation>;
|
|
1710
|
+
assertObjectTypeCallProperty(
|
|
1711
|
+
opts?: Opts$2<t.ObjectTypeCallProperty>,
|
|
1712
|
+
): asserts this is NodePath_Final<t.ObjectTypeCallProperty>;
|
|
1713
|
+
assertObjectTypeIndexer(
|
|
1714
|
+
opts?: Opts$2<t.ObjectTypeIndexer>,
|
|
1715
|
+
): asserts this is NodePath_Final<t.ObjectTypeIndexer>;
|
|
1716
|
+
assertObjectTypeInternalSlot(
|
|
1717
|
+
opts?: Opts$2<t.ObjectTypeInternalSlot>,
|
|
1718
|
+
): asserts this is NodePath_Final<t.ObjectTypeInternalSlot>;
|
|
1719
|
+
assertObjectTypeProperty(
|
|
1720
|
+
opts?: Opts$2<t.ObjectTypeProperty>,
|
|
1721
|
+
): asserts this is NodePath_Final<t.ObjectTypeProperty>;
|
|
1722
|
+
assertObjectTypeSpreadProperty(
|
|
1723
|
+
opts?: Opts$2<t.ObjectTypeSpreadProperty>,
|
|
1724
|
+
): asserts this is NodePath_Final<t.ObjectTypeSpreadProperty>;
|
|
1725
|
+
assertOpaqueType(
|
|
1726
|
+
opts?: Opts$2<t.OpaqueType>,
|
|
1727
|
+
): asserts this is NodePath_Final<t.OpaqueType>;
|
|
1728
|
+
assertOptionalCallExpression(
|
|
1729
|
+
opts?: Opts$2<t.OptionalCallExpression>,
|
|
1730
|
+
): asserts this is NodePath_Final<t.OptionalCallExpression>;
|
|
1731
|
+
assertOptionalIndexedAccessType(
|
|
1732
|
+
opts?: Opts$2<t.OptionalIndexedAccessType>,
|
|
1733
|
+
): asserts this is NodePath_Final<t.OptionalIndexedAccessType>;
|
|
1734
|
+
assertOptionalMemberExpression(
|
|
1735
|
+
opts?: Opts$2<t.OptionalMemberExpression>,
|
|
1736
|
+
): asserts this is NodePath_Final<t.OptionalMemberExpression>;
|
|
1737
|
+
assertParenthesizedExpression(
|
|
1738
|
+
opts?: Opts$2<t.ParenthesizedExpression>,
|
|
1739
|
+
): asserts this is NodePath_Final<t.ParenthesizedExpression>;
|
|
1740
|
+
assertPattern(opts?: Opts$2<t.Pattern>): asserts this is NodePath_Final<t.Pattern>;
|
|
1741
|
+
assertPatternLike(
|
|
1742
|
+
opts?: Opts$2<t.PatternLike>,
|
|
1743
|
+
): asserts this is NodePath_Final<t.PatternLike>;
|
|
1744
|
+
assertPipelineBareFunction(
|
|
1745
|
+
opts?: Opts$2<t.PipelineBareFunction>,
|
|
1746
|
+
): asserts this is NodePath_Final<t.PipelineBareFunction>;
|
|
1747
|
+
assertPipelinePrimaryTopicReference(
|
|
1748
|
+
opts?: Opts$2<t.PipelinePrimaryTopicReference>,
|
|
1749
|
+
): asserts this is NodePath_Final<t.PipelinePrimaryTopicReference>;
|
|
1750
|
+
assertPipelineTopicExpression(
|
|
1751
|
+
opts?: Opts$2<t.PipelineTopicExpression>,
|
|
1752
|
+
): asserts this is NodePath_Final<t.PipelineTopicExpression>;
|
|
1753
|
+
assertPlaceholder(
|
|
1754
|
+
opts?: Opts$2<t.Placeholder>,
|
|
1755
|
+
): asserts this is NodePath_Final<t.Placeholder>;
|
|
1756
|
+
assertPrivate(opts?: Opts$2<t.Private>): asserts this is NodePath_Final<t.Private>;
|
|
1757
|
+
assertPrivateName(
|
|
1758
|
+
opts?: Opts$2<t.PrivateName>,
|
|
1759
|
+
): asserts this is NodePath_Final<t.PrivateName>;
|
|
1760
|
+
assertProgram(opts?: Opts$2<t.Program>): asserts this is NodePath_Final<t.Program>;
|
|
1761
|
+
assertProperty(opts?: Opts$2<t.Property>): asserts this is NodePath_Final<t.Property>;
|
|
1762
|
+
assertPureish(opts?: Opts$2<t.Pureish>): asserts this is NodePath_Final<t.Pureish>;
|
|
1763
|
+
assertQualifiedTypeIdentifier(
|
|
1764
|
+
opts?: Opts$2<t.QualifiedTypeIdentifier>,
|
|
1765
|
+
): asserts this is NodePath_Final<t.QualifiedTypeIdentifier>;
|
|
1766
|
+
assertRecordExpression(
|
|
1767
|
+
opts?: Opts$2<t.RecordExpression>,
|
|
1768
|
+
): asserts this is NodePath_Final<t.RecordExpression>;
|
|
1769
|
+
assertRegExpLiteral(
|
|
1770
|
+
opts?: Opts$2<t.RegExpLiteral>,
|
|
1771
|
+
): asserts this is NodePath_Final<t.RegExpLiteral>;
|
|
1772
|
+
assertRegexLiteral(
|
|
1773
|
+
opts?: Opts$2<t.RegexLiteral>,
|
|
1774
|
+
): asserts this is NodePath_Final<t.RegexLiteral>;
|
|
1775
|
+
assertRestElement(
|
|
1776
|
+
opts?: Opts$2<t.RestElement>,
|
|
1777
|
+
): asserts this is NodePath_Final<t.RestElement>;
|
|
1778
|
+
assertRestProperty(
|
|
1779
|
+
opts?: Opts$2<t.RestProperty>,
|
|
1780
|
+
): asserts this is NodePath_Final<t.RestProperty>;
|
|
1781
|
+
assertReturnStatement(
|
|
1782
|
+
opts?: Opts$2<t.ReturnStatement>,
|
|
1783
|
+
): asserts this is NodePath_Final<t.ReturnStatement>;
|
|
1784
|
+
assertScopable(opts?: Opts$2<t.Scopable>): asserts this is NodePath_Final<t.Scopable>;
|
|
1785
|
+
assertSequenceExpression(
|
|
1786
|
+
opts?: Opts$2<t.SequenceExpression>,
|
|
1787
|
+
): asserts this is NodePath_Final<t.SequenceExpression>;
|
|
1788
|
+
assertSpreadElement(
|
|
1789
|
+
opts?: Opts$2<t.SpreadElement>,
|
|
1790
|
+
): asserts this is NodePath_Final<t.SpreadElement>;
|
|
1791
|
+
assertSpreadProperty(
|
|
1792
|
+
opts?: Opts$2<t.SpreadProperty>,
|
|
1793
|
+
): asserts this is NodePath_Final<t.SpreadProperty>;
|
|
1794
|
+
assertStandardized(
|
|
1795
|
+
opts?: Opts$2<t.Standardized>,
|
|
1796
|
+
): asserts this is NodePath_Final<t.Standardized>;
|
|
1797
|
+
assertStatement(
|
|
1798
|
+
opts?: Opts$2<t.Statement>,
|
|
1799
|
+
): asserts this is NodePath_Final<t.Statement>;
|
|
1800
|
+
assertStaticBlock(
|
|
1801
|
+
opts?: Opts$2<t.StaticBlock>,
|
|
1802
|
+
): asserts this is NodePath_Final<t.StaticBlock>;
|
|
1803
|
+
assertStringLiteral(
|
|
1804
|
+
opts?: Opts$2<t.StringLiteral>,
|
|
1805
|
+
): asserts this is NodePath_Final<t.StringLiteral>;
|
|
1806
|
+
assertStringLiteralTypeAnnotation(
|
|
1807
|
+
opts?: Opts$2<t.StringLiteralTypeAnnotation>,
|
|
1808
|
+
): asserts this is NodePath_Final<t.StringLiteralTypeAnnotation>;
|
|
1809
|
+
assertStringTypeAnnotation(
|
|
1810
|
+
opts?: Opts$2<t.StringTypeAnnotation>,
|
|
1811
|
+
): asserts this is NodePath_Final<t.StringTypeAnnotation>;
|
|
1812
|
+
assertSuper(opts?: Opts$2<t.Super>): asserts this is NodePath_Final<t.Super>;
|
|
1813
|
+
assertSwitchCase(
|
|
1814
|
+
opts?: Opts$2<t.SwitchCase>,
|
|
1815
|
+
): asserts this is NodePath_Final<t.SwitchCase>;
|
|
1816
|
+
assertSwitchStatement(
|
|
1817
|
+
opts?: Opts$2<t.SwitchStatement>,
|
|
1818
|
+
): asserts this is NodePath_Final<t.SwitchStatement>;
|
|
1819
|
+
assertSymbolTypeAnnotation(
|
|
1820
|
+
opts?: Opts$2<t.SymbolTypeAnnotation>,
|
|
1821
|
+
): asserts this is NodePath_Final<t.SymbolTypeAnnotation>;
|
|
1822
|
+
assertTSAnyKeyword(
|
|
1823
|
+
opts?: Opts$2<t.TSAnyKeyword>,
|
|
1824
|
+
): asserts this is NodePath_Final<t.TSAnyKeyword>;
|
|
1825
|
+
assertTSArrayType(
|
|
1826
|
+
opts?: Opts$2<t.TSArrayType>,
|
|
1827
|
+
): asserts this is NodePath_Final<t.TSArrayType>;
|
|
1828
|
+
assertTSAsExpression(
|
|
1829
|
+
opts?: Opts$2<t.TSAsExpression>,
|
|
1830
|
+
): asserts this is NodePath_Final<t.TSAsExpression>;
|
|
1831
|
+
assertTSBaseType(
|
|
1832
|
+
opts?: Opts$2<t.TSBaseType>,
|
|
1833
|
+
): asserts this is NodePath_Final<t.TSBaseType>;
|
|
1834
|
+
assertTSBigIntKeyword(
|
|
1835
|
+
opts?: Opts$2<t.TSBigIntKeyword>,
|
|
1836
|
+
): asserts this is NodePath_Final<t.TSBigIntKeyword>;
|
|
1837
|
+
assertTSBooleanKeyword(
|
|
1838
|
+
opts?: Opts$2<t.TSBooleanKeyword>,
|
|
1839
|
+
): asserts this is NodePath_Final<t.TSBooleanKeyword>;
|
|
1840
|
+
assertTSCallSignatureDeclaration(
|
|
1841
|
+
opts?: Opts$2<t.TSCallSignatureDeclaration>,
|
|
1842
|
+
): asserts this is NodePath_Final<t.TSCallSignatureDeclaration>;
|
|
1843
|
+
assertTSConditionalType(
|
|
1844
|
+
opts?: Opts$2<t.TSConditionalType>,
|
|
1845
|
+
): asserts this is NodePath_Final<t.TSConditionalType>;
|
|
1846
|
+
assertTSConstructSignatureDeclaration(
|
|
1847
|
+
opts?: Opts$2<t.TSConstructSignatureDeclaration>,
|
|
1848
|
+
): asserts this is NodePath_Final<t.TSConstructSignatureDeclaration>;
|
|
1849
|
+
assertTSConstructorType(
|
|
1850
|
+
opts?: Opts$2<t.TSConstructorType>,
|
|
1851
|
+
): asserts this is NodePath_Final<t.TSConstructorType>;
|
|
1852
|
+
assertTSDeclareFunction(
|
|
1853
|
+
opts?: Opts$2<t.TSDeclareFunction>,
|
|
1854
|
+
): asserts this is NodePath_Final<t.TSDeclareFunction>;
|
|
1855
|
+
assertTSDeclareMethod(
|
|
1856
|
+
opts?: Opts$2<t.TSDeclareMethod>,
|
|
1857
|
+
): asserts this is NodePath_Final<t.TSDeclareMethod>;
|
|
1858
|
+
assertTSEntityName(
|
|
1859
|
+
opts?: Opts$2<t.TSEntityName>,
|
|
1860
|
+
): asserts this is NodePath_Final<t.TSEntityName>;
|
|
1861
|
+
assertTSEnumDeclaration(
|
|
1862
|
+
opts?: Opts$2<t.TSEnumDeclaration>,
|
|
1863
|
+
): asserts this is NodePath_Final<t.TSEnumDeclaration>;
|
|
1864
|
+
assertTSEnumMember(
|
|
1865
|
+
opts?: Opts$2<t.TSEnumMember>,
|
|
1866
|
+
): asserts this is NodePath_Final<t.TSEnumMember>;
|
|
1867
|
+
assertTSExportAssignment(
|
|
1868
|
+
opts?: Opts$2<t.TSExportAssignment>,
|
|
1869
|
+
): asserts this is NodePath_Final<t.TSExportAssignment>;
|
|
1870
|
+
assertTSExpressionWithTypeArguments(
|
|
1871
|
+
opts?: Opts$2<t.TSExpressionWithTypeArguments>,
|
|
1872
|
+
): asserts this is NodePath_Final<t.TSExpressionWithTypeArguments>;
|
|
1873
|
+
assertTSExternalModuleReference(
|
|
1874
|
+
opts?: Opts$2<t.TSExternalModuleReference>,
|
|
1875
|
+
): asserts this is NodePath_Final<t.TSExternalModuleReference>;
|
|
1876
|
+
assertTSFunctionType(
|
|
1877
|
+
opts?: Opts$2<t.TSFunctionType>,
|
|
1878
|
+
): asserts this is NodePath_Final<t.TSFunctionType>;
|
|
1879
|
+
assertTSImportEqualsDeclaration(
|
|
1880
|
+
opts?: Opts$2<t.TSImportEqualsDeclaration>,
|
|
1881
|
+
): asserts this is NodePath_Final<t.TSImportEqualsDeclaration>;
|
|
1882
|
+
assertTSImportType(
|
|
1883
|
+
opts?: Opts$2<t.TSImportType>,
|
|
1884
|
+
): asserts this is NodePath_Final<t.TSImportType>;
|
|
1885
|
+
assertTSIndexSignature(
|
|
1886
|
+
opts?: Opts$2<t.TSIndexSignature>,
|
|
1887
|
+
): asserts this is NodePath_Final<t.TSIndexSignature>;
|
|
1888
|
+
assertTSIndexedAccessType(
|
|
1889
|
+
opts?: Opts$2<t.TSIndexedAccessType>,
|
|
1890
|
+
): asserts this is NodePath_Final<t.TSIndexedAccessType>;
|
|
1891
|
+
assertTSInferType(
|
|
1892
|
+
opts?: Opts$2<t.TSInferType>,
|
|
1893
|
+
): asserts this is NodePath_Final<t.TSInferType>;
|
|
1894
|
+
assertTSInstantiationExpression(
|
|
1895
|
+
opts?: Opts$2<t.TSInstantiationExpression>,
|
|
1896
|
+
): asserts this is NodePath_Final<t.TSInstantiationExpression>;
|
|
1897
|
+
assertTSInterfaceBody(
|
|
1898
|
+
opts?: Opts$2<t.TSInterfaceBody>,
|
|
1899
|
+
): asserts this is NodePath_Final<t.TSInterfaceBody>;
|
|
1900
|
+
assertTSInterfaceDeclaration(
|
|
1901
|
+
opts?: Opts$2<t.TSInterfaceDeclaration>,
|
|
1902
|
+
): asserts this is NodePath_Final<t.TSInterfaceDeclaration>;
|
|
1903
|
+
assertTSIntersectionType(
|
|
1904
|
+
opts?: Opts$2<t.TSIntersectionType>,
|
|
1905
|
+
): asserts this is NodePath_Final<t.TSIntersectionType>;
|
|
1906
|
+
assertTSIntrinsicKeyword(
|
|
1907
|
+
opts?: Opts$2<t.TSIntrinsicKeyword>,
|
|
1908
|
+
): asserts this is NodePath_Final<t.TSIntrinsicKeyword>;
|
|
1909
|
+
assertTSLiteralType(
|
|
1910
|
+
opts?: Opts$2<t.TSLiteralType>,
|
|
1911
|
+
): asserts this is NodePath_Final<t.TSLiteralType>;
|
|
1912
|
+
assertTSMappedType(
|
|
1913
|
+
opts?: Opts$2<t.TSMappedType>,
|
|
1914
|
+
): asserts this is NodePath_Final<t.TSMappedType>;
|
|
1915
|
+
assertTSMethodSignature(
|
|
1916
|
+
opts?: Opts$2<t.TSMethodSignature>,
|
|
1917
|
+
): asserts this is NodePath_Final<t.TSMethodSignature>;
|
|
1918
|
+
assertTSModuleBlock(
|
|
1919
|
+
opts?: Opts$2<t.TSModuleBlock>,
|
|
1920
|
+
): asserts this is NodePath_Final<t.TSModuleBlock>;
|
|
1921
|
+
assertTSModuleDeclaration(
|
|
1922
|
+
opts?: Opts$2<t.TSModuleDeclaration>,
|
|
1923
|
+
): asserts this is NodePath_Final<t.TSModuleDeclaration>;
|
|
1924
|
+
assertTSNamedTupleMember(
|
|
1925
|
+
opts?: Opts$2<t.TSNamedTupleMember>,
|
|
1926
|
+
): asserts this is NodePath_Final<t.TSNamedTupleMember>;
|
|
1927
|
+
assertTSNamespaceExportDeclaration(
|
|
1928
|
+
opts?: Opts$2<t.TSNamespaceExportDeclaration>,
|
|
1929
|
+
): asserts this is NodePath_Final<t.TSNamespaceExportDeclaration>;
|
|
1930
|
+
assertTSNeverKeyword(
|
|
1931
|
+
opts?: Opts$2<t.TSNeverKeyword>,
|
|
1932
|
+
): asserts this is NodePath_Final<t.TSNeverKeyword>;
|
|
1933
|
+
assertTSNonNullExpression(
|
|
1934
|
+
opts?: Opts$2<t.TSNonNullExpression>,
|
|
1935
|
+
): asserts this is NodePath_Final<t.TSNonNullExpression>;
|
|
1936
|
+
assertTSNullKeyword(
|
|
1937
|
+
opts?: Opts$2<t.TSNullKeyword>,
|
|
1938
|
+
): asserts this is NodePath_Final<t.TSNullKeyword>;
|
|
1939
|
+
assertTSNumberKeyword(
|
|
1940
|
+
opts?: Opts$2<t.TSNumberKeyword>,
|
|
1941
|
+
): asserts this is NodePath_Final<t.TSNumberKeyword>;
|
|
1942
|
+
assertTSObjectKeyword(
|
|
1943
|
+
opts?: Opts$2<t.TSObjectKeyword>,
|
|
1944
|
+
): asserts this is NodePath_Final<t.TSObjectKeyword>;
|
|
1945
|
+
assertTSOptionalType(
|
|
1946
|
+
opts?: Opts$2<t.TSOptionalType>,
|
|
1947
|
+
): asserts this is NodePath_Final<t.TSOptionalType>;
|
|
1948
|
+
assertTSParameterProperty(
|
|
1949
|
+
opts?: Opts$2<t.TSParameterProperty>,
|
|
1950
|
+
): asserts this is NodePath_Final<t.TSParameterProperty>;
|
|
1951
|
+
assertTSParenthesizedType(
|
|
1952
|
+
opts?: Opts$2<t.TSParenthesizedType>,
|
|
1953
|
+
): asserts this is NodePath_Final<t.TSParenthesizedType>;
|
|
1954
|
+
assertTSPropertySignature(
|
|
1955
|
+
opts?: Opts$2<t.TSPropertySignature>,
|
|
1956
|
+
): asserts this is NodePath_Final<t.TSPropertySignature>;
|
|
1957
|
+
assertTSQualifiedName(
|
|
1958
|
+
opts?: Opts$2<t.TSQualifiedName>,
|
|
1959
|
+
): asserts this is NodePath_Final<t.TSQualifiedName>;
|
|
1960
|
+
assertTSRestType(
|
|
1961
|
+
opts?: Opts$2<t.TSRestType>,
|
|
1962
|
+
): asserts this is NodePath_Final<t.TSRestType>;
|
|
1963
|
+
assertTSSatisfiesExpression(
|
|
1964
|
+
opts?: Opts$2<t.TSSatisfiesExpression>,
|
|
1965
|
+
): asserts this is NodePath_Final<t.TSSatisfiesExpression>;
|
|
1966
|
+
assertTSStringKeyword(
|
|
1967
|
+
opts?: Opts$2<t.TSStringKeyword>,
|
|
1968
|
+
): asserts this is NodePath_Final<t.TSStringKeyword>;
|
|
1969
|
+
assertTSSymbolKeyword(
|
|
1970
|
+
opts?: Opts$2<t.TSSymbolKeyword>,
|
|
1971
|
+
): asserts this is NodePath_Final<t.TSSymbolKeyword>;
|
|
1972
|
+
assertTSThisType(
|
|
1973
|
+
opts?: Opts$2<t.TSThisType>,
|
|
1974
|
+
): asserts this is NodePath_Final<t.TSThisType>;
|
|
1975
|
+
assertTSTupleType(
|
|
1976
|
+
opts?: Opts$2<t.TSTupleType>,
|
|
1977
|
+
): asserts this is NodePath_Final<t.TSTupleType>;
|
|
1978
|
+
assertTSType(opts?: Opts$2<t.TSType>): asserts this is NodePath_Final<t.TSType>;
|
|
1979
|
+
assertTSTypeAliasDeclaration(
|
|
1980
|
+
opts?: Opts$2<t.TSTypeAliasDeclaration>,
|
|
1981
|
+
): asserts this is NodePath_Final<t.TSTypeAliasDeclaration>;
|
|
1982
|
+
assertTSTypeAnnotation(
|
|
1983
|
+
opts?: Opts$2<t.TSTypeAnnotation>,
|
|
1984
|
+
): asserts this is NodePath_Final<t.TSTypeAnnotation>;
|
|
1985
|
+
assertTSTypeAssertion(
|
|
1986
|
+
opts?: Opts$2<t.TSTypeAssertion>,
|
|
1987
|
+
): asserts this is NodePath_Final<t.TSTypeAssertion>;
|
|
1988
|
+
assertTSTypeElement(
|
|
1989
|
+
opts?: Opts$2<t.TSTypeElement>,
|
|
1990
|
+
): asserts this is NodePath_Final<t.TSTypeElement>;
|
|
1991
|
+
assertTSTypeLiteral(
|
|
1992
|
+
opts?: Opts$2<t.TSTypeLiteral>,
|
|
1993
|
+
): asserts this is NodePath_Final<t.TSTypeLiteral>;
|
|
1994
|
+
assertTSTypeOperator(
|
|
1995
|
+
opts?: Opts$2<t.TSTypeOperator>,
|
|
1996
|
+
): asserts this is NodePath_Final<t.TSTypeOperator>;
|
|
1997
|
+
assertTSTypeParameter(
|
|
1998
|
+
opts?: Opts$2<t.TSTypeParameter>,
|
|
1999
|
+
): asserts this is NodePath_Final<t.TSTypeParameter>;
|
|
2000
|
+
assertTSTypeParameterDeclaration(
|
|
2001
|
+
opts?: Opts$2<t.TSTypeParameterDeclaration>,
|
|
2002
|
+
): asserts this is NodePath_Final<t.TSTypeParameterDeclaration>;
|
|
2003
|
+
assertTSTypeParameterInstantiation(
|
|
2004
|
+
opts?: Opts$2<t.TSTypeParameterInstantiation>,
|
|
2005
|
+
): asserts this is NodePath_Final<t.TSTypeParameterInstantiation>;
|
|
2006
|
+
assertTSTypePredicate(
|
|
2007
|
+
opts?: Opts$2<t.TSTypePredicate>,
|
|
2008
|
+
): asserts this is NodePath_Final<t.TSTypePredicate>;
|
|
2009
|
+
assertTSTypeQuery(
|
|
2010
|
+
opts?: Opts$2<t.TSTypeQuery>,
|
|
2011
|
+
): asserts this is NodePath_Final<t.TSTypeQuery>;
|
|
2012
|
+
assertTSTypeReference(
|
|
2013
|
+
opts?: Opts$2<t.TSTypeReference>,
|
|
2014
|
+
): asserts this is NodePath_Final<t.TSTypeReference>;
|
|
2015
|
+
assertTSUndefinedKeyword(
|
|
2016
|
+
opts?: Opts$2<t.TSUndefinedKeyword>,
|
|
2017
|
+
): asserts this is NodePath_Final<t.TSUndefinedKeyword>;
|
|
2018
|
+
assertTSUnionType(
|
|
2019
|
+
opts?: Opts$2<t.TSUnionType>,
|
|
2020
|
+
): asserts this is NodePath_Final<t.TSUnionType>;
|
|
2021
|
+
assertTSUnknownKeyword(
|
|
2022
|
+
opts?: Opts$2<t.TSUnknownKeyword>,
|
|
2023
|
+
): asserts this is NodePath_Final<t.TSUnknownKeyword>;
|
|
2024
|
+
assertTSVoidKeyword(
|
|
2025
|
+
opts?: Opts$2<t.TSVoidKeyword>,
|
|
2026
|
+
): asserts this is NodePath_Final<t.TSVoidKeyword>;
|
|
2027
|
+
assertTaggedTemplateExpression(
|
|
2028
|
+
opts?: Opts$2<t.TaggedTemplateExpression>,
|
|
2029
|
+
): asserts this is NodePath_Final<t.TaggedTemplateExpression>;
|
|
2030
|
+
assertTemplateElement(
|
|
2031
|
+
opts?: Opts$2<t.TemplateElement>,
|
|
2032
|
+
): asserts this is NodePath_Final<t.TemplateElement>;
|
|
2033
|
+
assertTemplateLiteral(
|
|
2034
|
+
opts?: Opts$2<t.TemplateLiteral>,
|
|
2035
|
+
): asserts this is NodePath_Final<t.TemplateLiteral>;
|
|
2036
|
+
assertTerminatorless(
|
|
2037
|
+
opts?: Opts$2<t.Terminatorless>,
|
|
2038
|
+
): asserts this is NodePath_Final<t.Terminatorless>;
|
|
2039
|
+
assertThisExpression(
|
|
2040
|
+
opts?: Opts$2<t.ThisExpression>,
|
|
2041
|
+
): asserts this is NodePath_Final<t.ThisExpression>;
|
|
2042
|
+
assertThisTypeAnnotation(
|
|
2043
|
+
opts?: Opts$2<t.ThisTypeAnnotation>,
|
|
2044
|
+
): asserts this is NodePath_Final<t.ThisTypeAnnotation>;
|
|
2045
|
+
assertThrowStatement(
|
|
2046
|
+
opts?: Opts$2<t.ThrowStatement>,
|
|
2047
|
+
): asserts this is NodePath_Final<t.ThrowStatement>;
|
|
2048
|
+
assertTopicReference(
|
|
2049
|
+
opts?: Opts$2<t.TopicReference>,
|
|
2050
|
+
): asserts this is NodePath_Final<t.TopicReference>;
|
|
2051
|
+
assertTryStatement(
|
|
2052
|
+
opts?: Opts$2<t.TryStatement>,
|
|
2053
|
+
): asserts this is NodePath_Final<t.TryStatement>;
|
|
2054
|
+
assertTupleExpression(
|
|
2055
|
+
opts?: Opts$2<t.TupleExpression>,
|
|
2056
|
+
): asserts this is NodePath_Final<t.TupleExpression>;
|
|
2057
|
+
assertTupleTypeAnnotation(
|
|
2058
|
+
opts?: Opts$2<t.TupleTypeAnnotation>,
|
|
2059
|
+
): asserts this is NodePath_Final<t.TupleTypeAnnotation>;
|
|
2060
|
+
assertTypeAlias(
|
|
2061
|
+
opts?: Opts$2<t.TypeAlias>,
|
|
2062
|
+
): asserts this is NodePath_Final<t.TypeAlias>;
|
|
2063
|
+
assertTypeAnnotation(
|
|
2064
|
+
opts?: Opts$2<t.TypeAnnotation>,
|
|
2065
|
+
): asserts this is NodePath_Final<t.TypeAnnotation>;
|
|
2066
|
+
assertTypeCastExpression(
|
|
2067
|
+
opts?: Opts$2<t.TypeCastExpression>,
|
|
2068
|
+
): asserts this is NodePath_Final<t.TypeCastExpression>;
|
|
2069
|
+
assertTypeParameter(
|
|
2070
|
+
opts?: Opts$2<t.TypeParameter>,
|
|
2071
|
+
): asserts this is NodePath_Final<t.TypeParameter>;
|
|
2072
|
+
assertTypeParameterDeclaration(
|
|
2073
|
+
opts?: Opts$2<t.TypeParameterDeclaration>,
|
|
2074
|
+
): asserts this is NodePath_Final<t.TypeParameterDeclaration>;
|
|
2075
|
+
assertTypeParameterInstantiation(
|
|
2076
|
+
opts?: Opts$2<t.TypeParameterInstantiation>,
|
|
2077
|
+
): asserts this is NodePath_Final<t.TypeParameterInstantiation>;
|
|
2078
|
+
assertTypeScript(
|
|
2079
|
+
opts?: Opts$2<t.TypeScript>,
|
|
2080
|
+
): asserts this is NodePath_Final<t.TypeScript>;
|
|
2081
|
+
assertTypeofTypeAnnotation(
|
|
2082
|
+
opts?: Opts$2<t.TypeofTypeAnnotation>,
|
|
2083
|
+
): asserts this is NodePath_Final<t.TypeofTypeAnnotation>;
|
|
2084
|
+
assertUnaryExpression(
|
|
2085
|
+
opts?: Opts$2<t.UnaryExpression>,
|
|
2086
|
+
): asserts this is NodePath_Final<t.UnaryExpression>;
|
|
2087
|
+
assertUnaryLike(
|
|
2088
|
+
opts?: Opts$2<t.UnaryLike>,
|
|
2089
|
+
): asserts this is NodePath_Final<t.UnaryLike>;
|
|
2090
|
+
assertUnionTypeAnnotation(
|
|
2091
|
+
opts?: Opts$2<t.UnionTypeAnnotation>,
|
|
2092
|
+
): asserts this is NodePath_Final<t.UnionTypeAnnotation>;
|
|
2093
|
+
assertUpdateExpression(
|
|
2094
|
+
opts?: Opts$2<t.UpdateExpression>,
|
|
2095
|
+
): asserts this is NodePath_Final<t.UpdateExpression>;
|
|
2096
|
+
assertUserWhitespacable(
|
|
2097
|
+
opts?: Opts$2<t.UserWhitespacable>,
|
|
2098
|
+
): asserts this is NodePath_Final<t.UserWhitespacable>;
|
|
2099
|
+
assertV8IntrinsicIdentifier(
|
|
2100
|
+
opts?: Opts$2<t.V8IntrinsicIdentifier>,
|
|
2101
|
+
): asserts this is NodePath_Final<t.V8IntrinsicIdentifier>;
|
|
2102
|
+
assertVariableDeclaration(
|
|
2103
|
+
opts?: Opts$2<t.VariableDeclaration>,
|
|
2104
|
+
): asserts this is NodePath_Final<t.VariableDeclaration>;
|
|
2105
|
+
assertVariableDeclarator(
|
|
2106
|
+
opts?: Opts$2<t.VariableDeclarator>,
|
|
2107
|
+
): asserts this is NodePath_Final<t.VariableDeclarator>;
|
|
2108
|
+
assertVariance(opts?: Opts$2<t.Variance>): asserts this is NodePath_Final<t.Variance>;
|
|
2109
|
+
assertVoidTypeAnnotation(
|
|
2110
|
+
opts?: Opts$2<t.VoidTypeAnnotation>,
|
|
2111
|
+
): asserts this is NodePath_Final<t.VoidTypeAnnotation>;
|
|
2112
|
+
assertWhile(opts?: Opts$2<t.While>): asserts this is NodePath_Final<t.While>;
|
|
2113
|
+
assertWhileStatement(
|
|
2114
|
+
opts?: Opts$2<t.WhileStatement>,
|
|
2115
|
+
): asserts this is NodePath_Final<t.WhileStatement>;
|
|
2116
|
+
assertWithStatement(
|
|
2117
|
+
opts?: Opts$2<t.WithStatement>,
|
|
2118
|
+
): asserts this is NodePath_Final<t.WithStatement>;
|
|
2119
|
+
assertYieldExpression(
|
|
2120
|
+
opts?: Opts$2<t.YieldExpression>,
|
|
2121
|
+
): asserts this is NodePath_Final<t.YieldExpression>;
|
|
2122
|
+
}
|
|
2123
|
+
|
|
2124
|
+
type Opts$1<Obj> = Partial<{
|
|
2125
|
+
[Prop in keyof Obj]: Obj[Prop] extends t.Node ? t.Node : Obj[Prop] extends t.Node[] ? t.Node[] : Obj[Prop];
|
|
2126
|
+
}>;
|
|
2127
|
+
interface VirtualTypeNodePathValidators {
|
|
2128
|
+
isBindingIdentifier(this: NodePath_Final, opts?: Opts$1<VirtualTypeAliases["BindingIdentifier"]>): this is NodePath_Final<VirtualTypeAliases["BindingIdentifier"]>;
|
|
2129
|
+
isBlockScoped(opts?: Opts$1<VirtualTypeAliases["BlockScoped"]>): boolean;
|
|
2130
|
+
/**
|
|
2131
|
+
* @deprecated
|
|
2132
|
+
*/
|
|
2133
|
+
isExistentialTypeParam(this: NodePath_Final, opts?: Opts$1<VirtualTypeAliases["ExistentialTypeParam"]>): this is NodePath_Final<VirtualTypeAliases["ExistentialTypeParam"]>;
|
|
2134
|
+
isExpression(this: NodePath_Final, opts?: Opts$1<VirtualTypeAliases["Expression"]>): this is NodePath_Final<t.Expression>;
|
|
2135
|
+
isFlow(this: NodePath_Final, opts?: Opts$1<VirtualTypeAliases["Flow"]>): this is NodePath_Final<t.Flow>;
|
|
2136
|
+
isForAwaitStatement(this: NodePath_Final, opts?: Opts$1<VirtualTypeAliases["ForAwaitStatement"]>): this is NodePath_Final<VirtualTypeAliases["ForAwaitStatement"]>;
|
|
2137
|
+
isGenerated(opts?: VirtualTypeAliases["Generated"]): boolean;
|
|
2138
|
+
/**
|
|
2139
|
+
* @deprecated
|
|
2140
|
+
*/
|
|
2141
|
+
isNumericLiteralTypeAnnotation(opts?: VirtualTypeAliases["NumericLiteralTypeAnnotation"]): void;
|
|
2142
|
+
isPure(opts?: VirtualTypeAliases["Pure"]): boolean;
|
|
2143
|
+
isReferenced(opts?: VirtualTypeAliases["Referenced"]): boolean;
|
|
2144
|
+
isReferencedIdentifier(this: NodePath_Final, opts?: Opts$1<VirtualTypeAliases["ReferencedIdentifier"]>): this is NodePath_Final<VirtualTypeAliases["ReferencedIdentifier"]>;
|
|
2145
|
+
isReferencedMemberExpression(this: NodePath_Final, opts?: Opts$1<VirtualTypeAliases["ReferencedMemberExpression"]>): this is NodePath_Final<VirtualTypeAliases["ReferencedMemberExpression"]>;
|
|
2146
|
+
isRestProperty(this: NodePath_Final, opts?: Opts$1<VirtualTypeAliases["RestProperty"]>): this is NodePath_Final<t.RestProperty>;
|
|
2147
|
+
isScope(this: NodePath_Final, opts?: Opts$1<VirtualTypeAliases["Scope"]>): this is NodePath_Final<VirtualTypeAliases["Scope"]>;
|
|
2148
|
+
isSpreadProperty(this: NodePath_Final, opts?: Opts$1<VirtualTypeAliases["SpreadProperty"]>): this is NodePath_Final<t.SpreadProperty>;
|
|
2149
|
+
isStatement(this: NodePath_Final, opts?: Opts$1<VirtualTypeAliases["Statement"]>): this is NodePath_Final<t.Statement>;
|
|
2150
|
+
isUser(opts?: VirtualTypeAliases["User"]): boolean;
|
|
2151
|
+
isVar(this: NodePath_Final, opts?: Opts$1<VirtualTypeAliases["Var"]>): this is NodePath_Final<VirtualTypeAliases["Var"]>;
|
|
2152
|
+
}
|
|
2153
|
+
|
|
2154
|
+
/*
|
|
2155
|
+
* This file is auto-generated! Do not modify it directly.
|
|
2156
|
+
* To re-generate run 'make build'
|
|
2157
|
+
*/
|
|
2158
|
+
|
|
2159
|
+
|
|
2160
|
+
type Opts<Obj> = Partial<{
|
|
2161
|
+
[Prop in keyof Obj]: Obj[Prop] extends t.Node
|
|
2162
|
+
? t.Node
|
|
2163
|
+
: Obj[Prop] extends t.Node[]
|
|
2164
|
+
? t.Node[]
|
|
2165
|
+
: Obj[Prop];
|
|
2166
|
+
}>;
|
|
2167
|
+
|
|
2168
|
+
interface BaseNodePathValidators {
|
|
2169
|
+
isAccessor(
|
|
2170
|
+
this: NodePath_Final,
|
|
2171
|
+
opts?: Opts<t.Accessor>,
|
|
2172
|
+
): this is NodePath_Final<t.Accessor>;
|
|
2173
|
+
isAnyTypeAnnotation(
|
|
2174
|
+
this: NodePath_Final,
|
|
2175
|
+
opts?: Opts<t.AnyTypeAnnotation>,
|
|
2176
|
+
): this is NodePath_Final<t.AnyTypeAnnotation>;
|
|
2177
|
+
isArgumentPlaceholder(
|
|
2178
|
+
this: NodePath_Final,
|
|
2179
|
+
opts?: Opts<t.ArgumentPlaceholder>,
|
|
2180
|
+
): this is NodePath_Final<t.ArgumentPlaceholder>;
|
|
2181
|
+
isArrayExpression(
|
|
2182
|
+
this: NodePath_Final,
|
|
2183
|
+
opts?: Opts<t.ArrayExpression>,
|
|
2184
|
+
): this is NodePath_Final<t.ArrayExpression>;
|
|
2185
|
+
isArrayPattern(
|
|
2186
|
+
this: NodePath_Final,
|
|
2187
|
+
opts?: Opts<t.ArrayPattern>,
|
|
2188
|
+
): this is NodePath_Final<t.ArrayPattern>;
|
|
2189
|
+
isArrayTypeAnnotation(
|
|
2190
|
+
this: NodePath_Final,
|
|
2191
|
+
opts?: Opts<t.ArrayTypeAnnotation>,
|
|
2192
|
+
): this is NodePath_Final<t.ArrayTypeAnnotation>;
|
|
2193
|
+
isArrowFunctionExpression(
|
|
2194
|
+
this: NodePath_Final,
|
|
2195
|
+
opts?: Opts<t.ArrowFunctionExpression>,
|
|
2196
|
+
): this is NodePath_Final<t.ArrowFunctionExpression>;
|
|
2197
|
+
isAssignmentExpression(
|
|
2198
|
+
this: NodePath_Final,
|
|
2199
|
+
opts?: Opts<t.AssignmentExpression>,
|
|
2200
|
+
): this is NodePath_Final<t.AssignmentExpression>;
|
|
2201
|
+
isAssignmentPattern(
|
|
2202
|
+
this: NodePath_Final,
|
|
2203
|
+
opts?: Opts<t.AssignmentPattern>,
|
|
2204
|
+
): this is NodePath_Final<t.AssignmentPattern>;
|
|
2205
|
+
isAwaitExpression(
|
|
2206
|
+
this: NodePath_Final,
|
|
2207
|
+
opts?: Opts<t.AwaitExpression>,
|
|
2208
|
+
): this is NodePath_Final<t.AwaitExpression>;
|
|
2209
|
+
isBigIntLiteral(
|
|
2210
|
+
this: NodePath_Final,
|
|
2211
|
+
opts?: Opts<t.BigIntLiteral>,
|
|
2212
|
+
): this is NodePath_Final<t.BigIntLiteral>;
|
|
2213
|
+
isBinary(this: NodePath_Final, opts?: Opts<t.Binary>): this is NodePath_Final<t.Binary>;
|
|
2214
|
+
isBinaryExpression(
|
|
2215
|
+
this: NodePath_Final,
|
|
2216
|
+
opts?: Opts<t.BinaryExpression>,
|
|
2217
|
+
): this is NodePath_Final<t.BinaryExpression>;
|
|
2218
|
+
isBindExpression(
|
|
2219
|
+
this: NodePath_Final,
|
|
2220
|
+
opts?: Opts<t.BindExpression>,
|
|
2221
|
+
): this is NodePath_Final<t.BindExpression>;
|
|
2222
|
+
isBlock(this: NodePath_Final, opts?: Opts<t.Block>): this is NodePath_Final<t.Block>;
|
|
2223
|
+
isBlockParent(
|
|
2224
|
+
this: NodePath_Final,
|
|
2225
|
+
opts?: Opts<t.BlockParent>,
|
|
2226
|
+
): this is NodePath_Final<t.BlockParent>;
|
|
2227
|
+
isBlockStatement(
|
|
2228
|
+
this: NodePath_Final,
|
|
2229
|
+
opts?: Opts<t.BlockStatement>,
|
|
2230
|
+
): this is NodePath_Final<t.BlockStatement>;
|
|
2231
|
+
isBooleanLiteral(
|
|
2232
|
+
this: NodePath_Final,
|
|
2233
|
+
opts?: Opts<t.BooleanLiteral>,
|
|
2234
|
+
): this is NodePath_Final<t.BooleanLiteral>;
|
|
2235
|
+
isBooleanLiteralTypeAnnotation(
|
|
2236
|
+
this: NodePath_Final,
|
|
2237
|
+
opts?: Opts<t.BooleanLiteralTypeAnnotation>,
|
|
2238
|
+
): this is NodePath_Final<t.BooleanLiteralTypeAnnotation>;
|
|
2239
|
+
isBooleanTypeAnnotation(
|
|
2240
|
+
this: NodePath_Final,
|
|
2241
|
+
opts?: Opts<t.BooleanTypeAnnotation>,
|
|
2242
|
+
): this is NodePath_Final<t.BooleanTypeAnnotation>;
|
|
2243
|
+
isBreakStatement(
|
|
2244
|
+
this: NodePath_Final,
|
|
2245
|
+
opts?: Opts<t.BreakStatement>,
|
|
2246
|
+
): this is NodePath_Final<t.BreakStatement>;
|
|
2247
|
+
isCallExpression(
|
|
2248
|
+
this: NodePath_Final,
|
|
2249
|
+
opts?: Opts<t.CallExpression>,
|
|
2250
|
+
): this is NodePath_Final<t.CallExpression>;
|
|
2251
|
+
isCatchClause(
|
|
2252
|
+
this: NodePath_Final,
|
|
2253
|
+
opts?: Opts<t.CatchClause>,
|
|
2254
|
+
): this is NodePath_Final<t.CatchClause>;
|
|
2255
|
+
isClass(this: NodePath_Final, opts?: Opts<t.Class>): this is NodePath_Final<t.Class>;
|
|
2256
|
+
isClassAccessorProperty(
|
|
2257
|
+
this: NodePath_Final,
|
|
2258
|
+
opts?: Opts<t.ClassAccessorProperty>,
|
|
2259
|
+
): this is NodePath_Final<t.ClassAccessorProperty>;
|
|
2260
|
+
isClassBody(
|
|
2261
|
+
this: NodePath_Final,
|
|
2262
|
+
opts?: Opts<t.ClassBody>,
|
|
2263
|
+
): this is NodePath_Final<t.ClassBody>;
|
|
2264
|
+
isClassDeclaration(
|
|
2265
|
+
this: NodePath_Final,
|
|
2266
|
+
opts?: Opts<t.ClassDeclaration>,
|
|
2267
|
+
): this is NodePath_Final<t.ClassDeclaration>;
|
|
2268
|
+
isClassExpression(
|
|
2269
|
+
this: NodePath_Final,
|
|
2270
|
+
opts?: Opts<t.ClassExpression>,
|
|
2271
|
+
): this is NodePath_Final<t.ClassExpression>;
|
|
2272
|
+
isClassImplements(
|
|
2273
|
+
this: NodePath_Final,
|
|
2274
|
+
opts?: Opts<t.ClassImplements>,
|
|
2275
|
+
): this is NodePath_Final<t.ClassImplements>;
|
|
2276
|
+
isClassMethod(
|
|
2277
|
+
this: NodePath_Final,
|
|
2278
|
+
opts?: Opts<t.ClassMethod>,
|
|
2279
|
+
): this is NodePath_Final<t.ClassMethod>;
|
|
2280
|
+
isClassPrivateMethod(
|
|
2281
|
+
this: NodePath_Final,
|
|
2282
|
+
opts?: Opts<t.ClassPrivateMethod>,
|
|
2283
|
+
): this is NodePath_Final<t.ClassPrivateMethod>;
|
|
2284
|
+
isClassPrivateProperty(
|
|
2285
|
+
this: NodePath_Final,
|
|
2286
|
+
opts?: Opts<t.ClassPrivateProperty>,
|
|
2287
|
+
): this is NodePath_Final<t.ClassPrivateProperty>;
|
|
2288
|
+
isClassProperty(
|
|
2289
|
+
this: NodePath_Final,
|
|
2290
|
+
opts?: Opts<t.ClassProperty>,
|
|
2291
|
+
): this is NodePath_Final<t.ClassProperty>;
|
|
2292
|
+
isCompletionStatement(
|
|
2293
|
+
this: NodePath_Final,
|
|
2294
|
+
opts?: Opts<t.CompletionStatement>,
|
|
2295
|
+
): this is NodePath_Final<t.CompletionStatement>;
|
|
2296
|
+
isConditional(
|
|
2297
|
+
this: NodePath_Final,
|
|
2298
|
+
opts?: Opts<t.Conditional>,
|
|
2299
|
+
): this is NodePath_Final<t.Conditional>;
|
|
2300
|
+
isConditionalExpression(
|
|
2301
|
+
this: NodePath_Final,
|
|
2302
|
+
opts?: Opts<t.ConditionalExpression>,
|
|
2303
|
+
): this is NodePath_Final<t.ConditionalExpression>;
|
|
2304
|
+
isContinueStatement(
|
|
2305
|
+
this: NodePath_Final,
|
|
2306
|
+
opts?: Opts<t.ContinueStatement>,
|
|
2307
|
+
): this is NodePath_Final<t.ContinueStatement>;
|
|
2308
|
+
isDebuggerStatement(
|
|
2309
|
+
this: NodePath_Final,
|
|
2310
|
+
opts?: Opts<t.DebuggerStatement>,
|
|
2311
|
+
): this is NodePath_Final<t.DebuggerStatement>;
|
|
2312
|
+
isDecimalLiteral(
|
|
2313
|
+
this: NodePath_Final,
|
|
2314
|
+
opts?: Opts<t.DecimalLiteral>,
|
|
2315
|
+
): this is NodePath_Final<t.DecimalLiteral>;
|
|
2316
|
+
isDeclaration(
|
|
2317
|
+
this: NodePath_Final,
|
|
2318
|
+
opts?: Opts<t.Declaration>,
|
|
2319
|
+
): this is NodePath_Final<t.Declaration>;
|
|
2320
|
+
isDeclareClass(
|
|
2321
|
+
this: NodePath_Final,
|
|
2322
|
+
opts?: Opts<t.DeclareClass>,
|
|
2323
|
+
): this is NodePath_Final<t.DeclareClass>;
|
|
2324
|
+
isDeclareExportAllDeclaration(
|
|
2325
|
+
this: NodePath_Final,
|
|
2326
|
+
opts?: Opts<t.DeclareExportAllDeclaration>,
|
|
2327
|
+
): this is NodePath_Final<t.DeclareExportAllDeclaration>;
|
|
2328
|
+
isDeclareExportDeclaration(
|
|
2329
|
+
this: NodePath_Final,
|
|
2330
|
+
opts?: Opts<t.DeclareExportDeclaration>,
|
|
2331
|
+
): this is NodePath_Final<t.DeclareExportDeclaration>;
|
|
2332
|
+
isDeclareFunction(
|
|
2333
|
+
this: NodePath_Final,
|
|
2334
|
+
opts?: Opts<t.DeclareFunction>,
|
|
2335
|
+
): this is NodePath_Final<t.DeclareFunction>;
|
|
2336
|
+
isDeclareInterface(
|
|
2337
|
+
this: NodePath_Final,
|
|
2338
|
+
opts?: Opts<t.DeclareInterface>,
|
|
2339
|
+
): this is NodePath_Final<t.DeclareInterface>;
|
|
2340
|
+
isDeclareModule(
|
|
2341
|
+
this: NodePath_Final,
|
|
2342
|
+
opts?: Opts<t.DeclareModule>,
|
|
2343
|
+
): this is NodePath_Final<t.DeclareModule>;
|
|
2344
|
+
isDeclareModuleExports(
|
|
2345
|
+
this: NodePath_Final,
|
|
2346
|
+
opts?: Opts<t.DeclareModuleExports>,
|
|
2347
|
+
): this is NodePath_Final<t.DeclareModuleExports>;
|
|
2348
|
+
isDeclareOpaqueType(
|
|
2349
|
+
this: NodePath_Final,
|
|
2350
|
+
opts?: Opts<t.DeclareOpaqueType>,
|
|
2351
|
+
): this is NodePath_Final<t.DeclareOpaqueType>;
|
|
2352
|
+
isDeclareTypeAlias(
|
|
2353
|
+
this: NodePath_Final,
|
|
2354
|
+
opts?: Opts<t.DeclareTypeAlias>,
|
|
2355
|
+
): this is NodePath_Final<t.DeclareTypeAlias>;
|
|
2356
|
+
isDeclareVariable(
|
|
2357
|
+
this: NodePath_Final,
|
|
2358
|
+
opts?: Opts<t.DeclareVariable>,
|
|
2359
|
+
): this is NodePath_Final<t.DeclareVariable>;
|
|
2360
|
+
isDeclaredPredicate(
|
|
2361
|
+
this: NodePath_Final,
|
|
2362
|
+
opts?: Opts<t.DeclaredPredicate>,
|
|
2363
|
+
): this is NodePath_Final<t.DeclaredPredicate>;
|
|
2364
|
+
isDecorator(
|
|
2365
|
+
this: NodePath_Final,
|
|
2366
|
+
opts?: Opts<t.Decorator>,
|
|
2367
|
+
): this is NodePath_Final<t.Decorator>;
|
|
2368
|
+
isDirective(
|
|
2369
|
+
this: NodePath_Final,
|
|
2370
|
+
opts?: Opts<t.Directive>,
|
|
2371
|
+
): this is NodePath_Final<t.Directive>;
|
|
2372
|
+
isDirectiveLiteral(
|
|
2373
|
+
this: NodePath_Final,
|
|
2374
|
+
opts?: Opts<t.DirectiveLiteral>,
|
|
2375
|
+
): this is NodePath_Final<t.DirectiveLiteral>;
|
|
2376
|
+
isDoExpression(
|
|
2377
|
+
this: NodePath_Final,
|
|
2378
|
+
opts?: Opts<t.DoExpression>,
|
|
2379
|
+
): this is NodePath_Final<t.DoExpression>;
|
|
2380
|
+
isDoWhileStatement(
|
|
2381
|
+
this: NodePath_Final,
|
|
2382
|
+
opts?: Opts<t.DoWhileStatement>,
|
|
2383
|
+
): this is NodePath_Final<t.DoWhileStatement>;
|
|
2384
|
+
isEmptyStatement(
|
|
2385
|
+
this: NodePath_Final,
|
|
2386
|
+
opts?: Opts<t.EmptyStatement>,
|
|
2387
|
+
): this is NodePath_Final<t.EmptyStatement>;
|
|
2388
|
+
isEmptyTypeAnnotation(
|
|
2389
|
+
this: NodePath_Final,
|
|
2390
|
+
opts?: Opts<t.EmptyTypeAnnotation>,
|
|
2391
|
+
): this is NodePath_Final<t.EmptyTypeAnnotation>;
|
|
2392
|
+
isEnumBody(
|
|
2393
|
+
this: NodePath_Final,
|
|
2394
|
+
opts?: Opts<t.EnumBody>,
|
|
2395
|
+
): this is NodePath_Final<t.EnumBody>;
|
|
2396
|
+
isEnumBooleanBody(
|
|
2397
|
+
this: NodePath_Final,
|
|
2398
|
+
opts?: Opts<t.EnumBooleanBody>,
|
|
2399
|
+
): this is NodePath_Final<t.EnumBooleanBody>;
|
|
2400
|
+
isEnumBooleanMember(
|
|
2401
|
+
this: NodePath_Final,
|
|
2402
|
+
opts?: Opts<t.EnumBooleanMember>,
|
|
2403
|
+
): this is NodePath_Final<t.EnumBooleanMember>;
|
|
2404
|
+
isEnumDeclaration(
|
|
2405
|
+
this: NodePath_Final,
|
|
2406
|
+
opts?: Opts<t.EnumDeclaration>,
|
|
2407
|
+
): this is NodePath_Final<t.EnumDeclaration>;
|
|
2408
|
+
isEnumDefaultedMember(
|
|
2409
|
+
this: NodePath_Final,
|
|
2410
|
+
opts?: Opts<t.EnumDefaultedMember>,
|
|
2411
|
+
): this is NodePath_Final<t.EnumDefaultedMember>;
|
|
2412
|
+
isEnumMember(
|
|
2413
|
+
this: NodePath_Final,
|
|
2414
|
+
opts?: Opts<t.EnumMember>,
|
|
2415
|
+
): this is NodePath_Final<t.EnumMember>;
|
|
2416
|
+
isEnumNumberBody(
|
|
2417
|
+
this: NodePath_Final,
|
|
2418
|
+
opts?: Opts<t.EnumNumberBody>,
|
|
2419
|
+
): this is NodePath_Final<t.EnumNumberBody>;
|
|
2420
|
+
isEnumNumberMember(
|
|
2421
|
+
this: NodePath_Final,
|
|
2422
|
+
opts?: Opts<t.EnumNumberMember>,
|
|
2423
|
+
): this is NodePath_Final<t.EnumNumberMember>;
|
|
2424
|
+
isEnumStringBody(
|
|
2425
|
+
this: NodePath_Final,
|
|
2426
|
+
opts?: Opts<t.EnumStringBody>,
|
|
2427
|
+
): this is NodePath_Final<t.EnumStringBody>;
|
|
2428
|
+
isEnumStringMember(
|
|
2429
|
+
this: NodePath_Final,
|
|
2430
|
+
opts?: Opts<t.EnumStringMember>,
|
|
2431
|
+
): this is NodePath_Final<t.EnumStringMember>;
|
|
2432
|
+
isEnumSymbolBody(
|
|
2433
|
+
this: NodePath_Final,
|
|
2434
|
+
opts?: Opts<t.EnumSymbolBody>,
|
|
2435
|
+
): this is NodePath_Final<t.EnumSymbolBody>;
|
|
2436
|
+
isExistsTypeAnnotation(
|
|
2437
|
+
this: NodePath_Final,
|
|
2438
|
+
opts?: Opts<t.ExistsTypeAnnotation>,
|
|
2439
|
+
): this is NodePath_Final<t.ExistsTypeAnnotation>;
|
|
2440
|
+
isExportAllDeclaration(
|
|
2441
|
+
this: NodePath_Final,
|
|
2442
|
+
opts?: Opts<t.ExportAllDeclaration>,
|
|
2443
|
+
): this is NodePath_Final<t.ExportAllDeclaration>;
|
|
2444
|
+
isExportDeclaration(
|
|
2445
|
+
this: NodePath_Final,
|
|
2446
|
+
opts?: Opts<t.ExportDeclaration>,
|
|
2447
|
+
): this is NodePath_Final<t.ExportDeclaration>;
|
|
2448
|
+
isExportDefaultDeclaration(
|
|
2449
|
+
this: NodePath_Final,
|
|
2450
|
+
opts?: Opts<t.ExportDefaultDeclaration>,
|
|
2451
|
+
): this is NodePath_Final<t.ExportDefaultDeclaration>;
|
|
2452
|
+
isExportDefaultSpecifier(
|
|
2453
|
+
this: NodePath_Final,
|
|
2454
|
+
opts?: Opts<t.ExportDefaultSpecifier>,
|
|
2455
|
+
): this is NodePath_Final<t.ExportDefaultSpecifier>;
|
|
2456
|
+
isExportNamedDeclaration(
|
|
2457
|
+
this: NodePath_Final,
|
|
2458
|
+
opts?: Opts<t.ExportNamedDeclaration>,
|
|
2459
|
+
): this is NodePath_Final<t.ExportNamedDeclaration>;
|
|
2460
|
+
isExportNamespaceSpecifier(
|
|
2461
|
+
this: NodePath_Final,
|
|
2462
|
+
opts?: Opts<t.ExportNamespaceSpecifier>,
|
|
2463
|
+
): this is NodePath_Final<t.ExportNamespaceSpecifier>;
|
|
2464
|
+
isExportSpecifier(
|
|
2465
|
+
this: NodePath_Final,
|
|
2466
|
+
opts?: Opts<t.ExportSpecifier>,
|
|
2467
|
+
): this is NodePath_Final<t.ExportSpecifier>;
|
|
2468
|
+
isExpression(
|
|
2469
|
+
this: NodePath_Final,
|
|
2470
|
+
opts?: Opts<t.Expression>,
|
|
2471
|
+
): this is NodePath_Final<t.Expression>;
|
|
2472
|
+
isExpressionStatement(
|
|
2473
|
+
this: NodePath_Final,
|
|
2474
|
+
opts?: Opts<t.ExpressionStatement>,
|
|
2475
|
+
): this is NodePath_Final<t.ExpressionStatement>;
|
|
2476
|
+
isExpressionWrapper(
|
|
2477
|
+
this: NodePath_Final,
|
|
2478
|
+
opts?: Opts<t.ExpressionWrapper>,
|
|
2479
|
+
): this is NodePath_Final<t.ExpressionWrapper>;
|
|
2480
|
+
isFile(this: NodePath_Final, opts?: Opts<t.File>): this is NodePath_Final<t.File>;
|
|
2481
|
+
isFlow(this: NodePath_Final, opts?: Opts<t.Flow>): this is NodePath_Final<t.Flow>;
|
|
2482
|
+
isFlowBaseAnnotation(
|
|
2483
|
+
this: NodePath_Final,
|
|
2484
|
+
opts?: Opts<t.FlowBaseAnnotation>,
|
|
2485
|
+
): this is NodePath_Final<t.FlowBaseAnnotation>;
|
|
2486
|
+
isFlowDeclaration(
|
|
2487
|
+
this: NodePath_Final,
|
|
2488
|
+
opts?: Opts<t.FlowDeclaration>,
|
|
2489
|
+
): this is NodePath_Final<t.FlowDeclaration>;
|
|
2490
|
+
isFlowPredicate(
|
|
2491
|
+
this: NodePath_Final,
|
|
2492
|
+
opts?: Opts<t.FlowPredicate>,
|
|
2493
|
+
): this is NodePath_Final<t.FlowPredicate>;
|
|
2494
|
+
isFlowType(
|
|
2495
|
+
this: NodePath_Final,
|
|
2496
|
+
opts?: Opts<t.FlowType>,
|
|
2497
|
+
): this is NodePath_Final<t.FlowType>;
|
|
2498
|
+
isFor(this: NodePath_Final, opts?: Opts<t.For>): this is NodePath_Final<t.For>;
|
|
2499
|
+
isForInStatement(
|
|
2500
|
+
this: NodePath_Final,
|
|
2501
|
+
opts?: Opts<t.ForInStatement>,
|
|
2502
|
+
): this is NodePath_Final<t.ForInStatement>;
|
|
2503
|
+
isForOfStatement(
|
|
2504
|
+
this: NodePath_Final,
|
|
2505
|
+
opts?: Opts<t.ForOfStatement>,
|
|
2506
|
+
): this is NodePath_Final<t.ForOfStatement>;
|
|
2507
|
+
isForStatement(
|
|
2508
|
+
this: NodePath_Final,
|
|
2509
|
+
opts?: Opts<t.ForStatement>,
|
|
2510
|
+
): this is NodePath_Final<t.ForStatement>;
|
|
2511
|
+
isForXStatement(
|
|
2512
|
+
this: NodePath_Final,
|
|
2513
|
+
opts?: Opts<t.ForXStatement>,
|
|
2514
|
+
): this is NodePath_Final<t.ForXStatement>;
|
|
2515
|
+
isFunction(
|
|
2516
|
+
this: NodePath_Final,
|
|
2517
|
+
opts?: Opts<t.Function>,
|
|
2518
|
+
): this is NodePath_Final<t.Function>;
|
|
2519
|
+
isFunctionDeclaration(
|
|
2520
|
+
this: NodePath_Final,
|
|
2521
|
+
opts?: Opts<t.FunctionDeclaration>,
|
|
2522
|
+
): this is NodePath_Final<t.FunctionDeclaration>;
|
|
2523
|
+
isFunctionExpression(
|
|
2524
|
+
this: NodePath_Final,
|
|
2525
|
+
opts?: Opts<t.FunctionExpression>,
|
|
2526
|
+
): this is NodePath_Final<t.FunctionExpression>;
|
|
2527
|
+
isFunctionParent(
|
|
2528
|
+
this: NodePath_Final,
|
|
2529
|
+
opts?: Opts<t.FunctionParent>,
|
|
2530
|
+
): this is NodePath_Final<t.FunctionParent>;
|
|
2531
|
+
isFunctionTypeAnnotation(
|
|
2532
|
+
this: NodePath_Final,
|
|
2533
|
+
opts?: Opts<t.FunctionTypeAnnotation>,
|
|
2534
|
+
): this is NodePath_Final<t.FunctionTypeAnnotation>;
|
|
2535
|
+
isFunctionTypeParam(
|
|
2536
|
+
this: NodePath_Final,
|
|
2537
|
+
opts?: Opts<t.FunctionTypeParam>,
|
|
2538
|
+
): this is NodePath_Final<t.FunctionTypeParam>;
|
|
2539
|
+
isGenericTypeAnnotation(
|
|
2540
|
+
this: NodePath_Final,
|
|
2541
|
+
opts?: Opts<t.GenericTypeAnnotation>,
|
|
2542
|
+
): this is NodePath_Final<t.GenericTypeAnnotation>;
|
|
2543
|
+
isIdentifier(
|
|
2544
|
+
this: NodePath_Final,
|
|
2545
|
+
opts?: Opts<t.Identifier>,
|
|
2546
|
+
): this is NodePath_Final<t.Identifier>;
|
|
2547
|
+
isIfStatement(
|
|
2548
|
+
this: NodePath_Final,
|
|
2549
|
+
opts?: Opts<t.IfStatement>,
|
|
2550
|
+
): this is NodePath_Final<t.IfStatement>;
|
|
2551
|
+
isImmutable(
|
|
2552
|
+
this: NodePath_Final,
|
|
2553
|
+
opts?: Opts<t.Immutable>,
|
|
2554
|
+
): this is NodePath_Final<t.Immutable>;
|
|
2555
|
+
isImport(this: NodePath_Final, opts?: Opts<t.Import>): this is NodePath_Final<t.Import>;
|
|
2556
|
+
isImportAttribute(
|
|
2557
|
+
this: NodePath_Final,
|
|
2558
|
+
opts?: Opts<t.ImportAttribute>,
|
|
2559
|
+
): this is NodePath_Final<t.ImportAttribute>;
|
|
2560
|
+
isImportDeclaration(
|
|
2561
|
+
this: NodePath_Final,
|
|
2562
|
+
opts?: Opts<t.ImportDeclaration>,
|
|
2563
|
+
): this is NodePath_Final<t.ImportDeclaration>;
|
|
2564
|
+
isImportDefaultSpecifier(
|
|
2565
|
+
this: NodePath_Final,
|
|
2566
|
+
opts?: Opts<t.ImportDefaultSpecifier>,
|
|
2567
|
+
): this is NodePath_Final<t.ImportDefaultSpecifier>;
|
|
2568
|
+
isImportExpression(
|
|
2569
|
+
this: NodePath_Final,
|
|
2570
|
+
opts?: Opts<t.ImportExpression>,
|
|
2571
|
+
): this is NodePath_Final<t.ImportExpression>;
|
|
2572
|
+
isImportNamespaceSpecifier(
|
|
2573
|
+
this: NodePath_Final,
|
|
2574
|
+
opts?: Opts<t.ImportNamespaceSpecifier>,
|
|
2575
|
+
): this is NodePath_Final<t.ImportNamespaceSpecifier>;
|
|
2576
|
+
isImportOrExportDeclaration(
|
|
2577
|
+
this: NodePath_Final,
|
|
2578
|
+
opts?: Opts<t.ImportOrExportDeclaration>,
|
|
2579
|
+
): this is NodePath_Final<t.ImportOrExportDeclaration>;
|
|
2580
|
+
isImportSpecifier(
|
|
2581
|
+
this: NodePath_Final,
|
|
2582
|
+
opts?: Opts<t.ImportSpecifier>,
|
|
2583
|
+
): this is NodePath_Final<t.ImportSpecifier>;
|
|
2584
|
+
isIndexedAccessType(
|
|
2585
|
+
this: NodePath_Final,
|
|
2586
|
+
opts?: Opts<t.IndexedAccessType>,
|
|
2587
|
+
): this is NodePath_Final<t.IndexedAccessType>;
|
|
2588
|
+
isInferredPredicate(
|
|
2589
|
+
this: NodePath_Final,
|
|
2590
|
+
opts?: Opts<t.InferredPredicate>,
|
|
2591
|
+
): this is NodePath_Final<t.InferredPredicate>;
|
|
2592
|
+
isInterfaceDeclaration(
|
|
2593
|
+
this: NodePath_Final,
|
|
2594
|
+
opts?: Opts<t.InterfaceDeclaration>,
|
|
2595
|
+
): this is NodePath_Final<t.InterfaceDeclaration>;
|
|
2596
|
+
isInterfaceExtends(
|
|
2597
|
+
this: NodePath_Final,
|
|
2598
|
+
opts?: Opts<t.InterfaceExtends>,
|
|
2599
|
+
): this is NodePath_Final<t.InterfaceExtends>;
|
|
2600
|
+
isInterfaceTypeAnnotation(
|
|
2601
|
+
this: NodePath_Final,
|
|
2602
|
+
opts?: Opts<t.InterfaceTypeAnnotation>,
|
|
2603
|
+
): this is NodePath_Final<t.InterfaceTypeAnnotation>;
|
|
2604
|
+
isInterpreterDirective(
|
|
2605
|
+
this: NodePath_Final,
|
|
2606
|
+
opts?: Opts<t.InterpreterDirective>,
|
|
2607
|
+
): this is NodePath_Final<t.InterpreterDirective>;
|
|
2608
|
+
isIntersectionTypeAnnotation(
|
|
2609
|
+
this: NodePath_Final,
|
|
2610
|
+
opts?: Opts<t.IntersectionTypeAnnotation>,
|
|
2611
|
+
): this is NodePath_Final<t.IntersectionTypeAnnotation>;
|
|
2612
|
+
isJSX(this: NodePath_Final, opts?: Opts<t.JSX>): this is NodePath_Final<t.JSX>;
|
|
2613
|
+
isJSXAttribute(
|
|
2614
|
+
this: NodePath_Final,
|
|
2615
|
+
opts?: Opts<t.JSXAttribute>,
|
|
2616
|
+
): this is NodePath_Final<t.JSXAttribute>;
|
|
2617
|
+
isJSXClosingElement(
|
|
2618
|
+
this: NodePath_Final,
|
|
2619
|
+
opts?: Opts<t.JSXClosingElement>,
|
|
2620
|
+
): this is NodePath_Final<t.JSXClosingElement>;
|
|
2621
|
+
isJSXClosingFragment(
|
|
2622
|
+
this: NodePath_Final,
|
|
2623
|
+
opts?: Opts<t.JSXClosingFragment>,
|
|
2624
|
+
): this is NodePath_Final<t.JSXClosingFragment>;
|
|
2625
|
+
isJSXElement(
|
|
2626
|
+
this: NodePath_Final,
|
|
2627
|
+
opts?: Opts<t.JSXElement>,
|
|
2628
|
+
): this is NodePath_Final<t.JSXElement>;
|
|
2629
|
+
isJSXEmptyExpression(
|
|
2630
|
+
this: NodePath_Final,
|
|
2631
|
+
opts?: Opts<t.JSXEmptyExpression>,
|
|
2632
|
+
): this is NodePath_Final<t.JSXEmptyExpression>;
|
|
2633
|
+
isJSXExpressionContainer(
|
|
2634
|
+
this: NodePath_Final,
|
|
2635
|
+
opts?: Opts<t.JSXExpressionContainer>,
|
|
2636
|
+
): this is NodePath_Final<t.JSXExpressionContainer>;
|
|
2637
|
+
isJSXFragment(
|
|
2638
|
+
this: NodePath_Final,
|
|
2639
|
+
opts?: Opts<t.JSXFragment>,
|
|
2640
|
+
): this is NodePath_Final<t.JSXFragment>;
|
|
2641
|
+
isJSXIdentifier(
|
|
2642
|
+
this: NodePath_Final,
|
|
2643
|
+
opts?: Opts<t.JSXIdentifier>,
|
|
2644
|
+
): this is NodePath_Final<t.JSXIdentifier>;
|
|
2645
|
+
isJSXMemberExpression(
|
|
2646
|
+
this: NodePath_Final,
|
|
2647
|
+
opts?: Opts<t.JSXMemberExpression>,
|
|
2648
|
+
): this is NodePath_Final<t.JSXMemberExpression>;
|
|
2649
|
+
isJSXNamespacedName(
|
|
2650
|
+
this: NodePath_Final,
|
|
2651
|
+
opts?: Opts<t.JSXNamespacedName>,
|
|
2652
|
+
): this is NodePath_Final<t.JSXNamespacedName>;
|
|
2653
|
+
isJSXOpeningElement(
|
|
2654
|
+
this: NodePath_Final,
|
|
2655
|
+
opts?: Opts<t.JSXOpeningElement>,
|
|
2656
|
+
): this is NodePath_Final<t.JSXOpeningElement>;
|
|
2657
|
+
isJSXOpeningFragment(
|
|
2658
|
+
this: NodePath_Final,
|
|
2659
|
+
opts?: Opts<t.JSXOpeningFragment>,
|
|
2660
|
+
): this is NodePath_Final<t.JSXOpeningFragment>;
|
|
2661
|
+
isJSXSpreadAttribute(
|
|
2662
|
+
this: NodePath_Final,
|
|
2663
|
+
opts?: Opts<t.JSXSpreadAttribute>,
|
|
2664
|
+
): this is NodePath_Final<t.JSXSpreadAttribute>;
|
|
2665
|
+
isJSXSpreadChild(
|
|
2666
|
+
this: NodePath_Final,
|
|
2667
|
+
opts?: Opts<t.JSXSpreadChild>,
|
|
2668
|
+
): this is NodePath_Final<t.JSXSpreadChild>;
|
|
2669
|
+
isJSXText(
|
|
2670
|
+
this: NodePath_Final,
|
|
2671
|
+
opts?: Opts<t.JSXText>,
|
|
2672
|
+
): this is NodePath_Final<t.JSXText>;
|
|
2673
|
+
isLVal(this: NodePath_Final, opts?: Opts<t.LVal>): this is NodePath_Final<t.LVal>;
|
|
2674
|
+
isLabeledStatement(
|
|
2675
|
+
this: NodePath_Final,
|
|
2676
|
+
opts?: Opts<t.LabeledStatement>,
|
|
2677
|
+
): this is NodePath_Final<t.LabeledStatement>;
|
|
2678
|
+
isLiteral(
|
|
2679
|
+
this: NodePath_Final,
|
|
2680
|
+
opts?: Opts<t.Literal>,
|
|
2681
|
+
): this is NodePath_Final<t.Literal>;
|
|
2682
|
+
isLogicalExpression(
|
|
2683
|
+
this: NodePath_Final,
|
|
2684
|
+
opts?: Opts<t.LogicalExpression>,
|
|
2685
|
+
): this is NodePath_Final<t.LogicalExpression>;
|
|
2686
|
+
isLoop(this: NodePath_Final, opts?: Opts<t.Loop>): this is NodePath_Final<t.Loop>;
|
|
2687
|
+
isMemberExpression(
|
|
2688
|
+
this: NodePath_Final,
|
|
2689
|
+
opts?: Opts<t.MemberExpression>,
|
|
2690
|
+
): this is NodePath_Final<t.MemberExpression>;
|
|
2691
|
+
isMetaProperty(
|
|
2692
|
+
this: NodePath_Final,
|
|
2693
|
+
opts?: Opts<t.MetaProperty>,
|
|
2694
|
+
): this is NodePath_Final<t.MetaProperty>;
|
|
2695
|
+
isMethod(this: NodePath_Final, opts?: Opts<t.Method>): this is NodePath_Final<t.Method>;
|
|
2696
|
+
isMiscellaneous(
|
|
2697
|
+
this: NodePath_Final,
|
|
2698
|
+
opts?: Opts<t.Miscellaneous>,
|
|
2699
|
+
): this is NodePath_Final<t.Miscellaneous>;
|
|
2700
|
+
isMixedTypeAnnotation(
|
|
2701
|
+
this: NodePath_Final,
|
|
2702
|
+
opts?: Opts<t.MixedTypeAnnotation>,
|
|
2703
|
+
): this is NodePath_Final<t.MixedTypeAnnotation>;
|
|
2704
|
+
isModuleDeclaration(
|
|
2705
|
+
this: NodePath_Final,
|
|
2706
|
+
opts?: Opts<t.ModuleDeclaration>,
|
|
2707
|
+
): this is NodePath_Final<t.ModuleDeclaration>;
|
|
2708
|
+
isModuleExpression(
|
|
2709
|
+
this: NodePath_Final,
|
|
2710
|
+
opts?: Opts<t.ModuleExpression>,
|
|
2711
|
+
): this is NodePath_Final<t.ModuleExpression>;
|
|
2712
|
+
isModuleSpecifier(
|
|
2713
|
+
this: NodePath_Final,
|
|
2714
|
+
opts?: Opts<t.ModuleSpecifier>,
|
|
2715
|
+
): this is NodePath_Final<t.ModuleSpecifier>;
|
|
2716
|
+
isNewExpression(
|
|
2717
|
+
this: NodePath_Final,
|
|
2718
|
+
opts?: Opts<t.NewExpression>,
|
|
2719
|
+
): this is NodePath_Final<t.NewExpression>;
|
|
2720
|
+
isNullLiteral(
|
|
2721
|
+
this: NodePath_Final,
|
|
2722
|
+
opts?: Opts<t.NullLiteral>,
|
|
2723
|
+
): this is NodePath_Final<t.NullLiteral>;
|
|
2724
|
+
isNullLiteralTypeAnnotation(
|
|
2725
|
+
this: NodePath_Final,
|
|
2726
|
+
opts?: Opts<t.NullLiteralTypeAnnotation>,
|
|
2727
|
+
): this is NodePath_Final<t.NullLiteralTypeAnnotation>;
|
|
2728
|
+
isNullableTypeAnnotation(
|
|
2729
|
+
this: NodePath_Final,
|
|
2730
|
+
opts?: Opts<t.NullableTypeAnnotation>,
|
|
2731
|
+
): this is NodePath_Final<t.NullableTypeAnnotation>;
|
|
2732
|
+
isNumberLiteral(
|
|
2733
|
+
this: NodePath_Final,
|
|
2734
|
+
opts?: Opts<t.NumberLiteral>,
|
|
2735
|
+
): this is NodePath_Final<t.NumberLiteral>;
|
|
2736
|
+
isNumberLiteralTypeAnnotation(
|
|
2737
|
+
this: NodePath_Final,
|
|
2738
|
+
opts?: Opts<t.NumberLiteralTypeAnnotation>,
|
|
2739
|
+
): this is NodePath_Final<t.NumberLiteralTypeAnnotation>;
|
|
2740
|
+
isNumberTypeAnnotation(
|
|
2741
|
+
this: NodePath_Final,
|
|
2742
|
+
opts?: Opts<t.NumberTypeAnnotation>,
|
|
2743
|
+
): this is NodePath_Final<t.NumberTypeAnnotation>;
|
|
2744
|
+
isNumericLiteral(
|
|
2745
|
+
this: NodePath_Final,
|
|
2746
|
+
opts?: Opts<t.NumericLiteral>,
|
|
2747
|
+
): this is NodePath_Final<t.NumericLiteral>;
|
|
2748
|
+
isObjectExpression(
|
|
2749
|
+
this: NodePath_Final,
|
|
2750
|
+
opts?: Opts<t.ObjectExpression>,
|
|
2751
|
+
): this is NodePath_Final<t.ObjectExpression>;
|
|
2752
|
+
isObjectMember(
|
|
2753
|
+
this: NodePath_Final,
|
|
2754
|
+
opts?: Opts<t.ObjectMember>,
|
|
2755
|
+
): this is NodePath_Final<t.ObjectMember>;
|
|
2756
|
+
isObjectMethod(
|
|
2757
|
+
this: NodePath_Final,
|
|
2758
|
+
opts?: Opts<t.ObjectMethod>,
|
|
2759
|
+
): this is NodePath_Final<t.ObjectMethod>;
|
|
2760
|
+
isObjectPattern(
|
|
2761
|
+
this: NodePath_Final,
|
|
2762
|
+
opts?: Opts<t.ObjectPattern>,
|
|
2763
|
+
): this is NodePath_Final<t.ObjectPattern>;
|
|
2764
|
+
isObjectProperty(
|
|
2765
|
+
this: NodePath_Final,
|
|
2766
|
+
opts?: Opts<t.ObjectProperty>,
|
|
2767
|
+
): this is NodePath_Final<t.ObjectProperty>;
|
|
2768
|
+
isObjectTypeAnnotation(
|
|
2769
|
+
this: NodePath_Final,
|
|
2770
|
+
opts?: Opts<t.ObjectTypeAnnotation>,
|
|
2771
|
+
): this is NodePath_Final<t.ObjectTypeAnnotation>;
|
|
2772
|
+
isObjectTypeCallProperty(
|
|
2773
|
+
this: NodePath_Final,
|
|
2774
|
+
opts?: Opts<t.ObjectTypeCallProperty>,
|
|
2775
|
+
): this is NodePath_Final<t.ObjectTypeCallProperty>;
|
|
2776
|
+
isObjectTypeIndexer(
|
|
2777
|
+
this: NodePath_Final,
|
|
2778
|
+
opts?: Opts<t.ObjectTypeIndexer>,
|
|
2779
|
+
): this is NodePath_Final<t.ObjectTypeIndexer>;
|
|
2780
|
+
isObjectTypeInternalSlot(
|
|
2781
|
+
this: NodePath_Final,
|
|
2782
|
+
opts?: Opts<t.ObjectTypeInternalSlot>,
|
|
2783
|
+
): this is NodePath_Final<t.ObjectTypeInternalSlot>;
|
|
2784
|
+
isObjectTypeProperty(
|
|
2785
|
+
this: NodePath_Final,
|
|
2786
|
+
opts?: Opts<t.ObjectTypeProperty>,
|
|
2787
|
+
): this is NodePath_Final<t.ObjectTypeProperty>;
|
|
2788
|
+
isObjectTypeSpreadProperty(
|
|
2789
|
+
this: NodePath_Final,
|
|
2790
|
+
opts?: Opts<t.ObjectTypeSpreadProperty>,
|
|
2791
|
+
): this is NodePath_Final<t.ObjectTypeSpreadProperty>;
|
|
2792
|
+
isOpaqueType(
|
|
2793
|
+
this: NodePath_Final,
|
|
2794
|
+
opts?: Opts<t.OpaqueType>,
|
|
2795
|
+
): this is NodePath_Final<t.OpaqueType>;
|
|
2796
|
+
isOptionalCallExpression(
|
|
2797
|
+
this: NodePath_Final,
|
|
2798
|
+
opts?: Opts<t.OptionalCallExpression>,
|
|
2799
|
+
): this is NodePath_Final<t.OptionalCallExpression>;
|
|
2800
|
+
isOptionalIndexedAccessType(
|
|
2801
|
+
this: NodePath_Final,
|
|
2802
|
+
opts?: Opts<t.OptionalIndexedAccessType>,
|
|
2803
|
+
): this is NodePath_Final<t.OptionalIndexedAccessType>;
|
|
2804
|
+
isOptionalMemberExpression(
|
|
2805
|
+
this: NodePath_Final,
|
|
2806
|
+
opts?: Opts<t.OptionalMemberExpression>,
|
|
2807
|
+
): this is NodePath_Final<t.OptionalMemberExpression>;
|
|
2808
|
+
isParenthesizedExpression(
|
|
2809
|
+
this: NodePath_Final,
|
|
2810
|
+
opts?: Opts<t.ParenthesizedExpression>,
|
|
2811
|
+
): this is NodePath_Final<t.ParenthesizedExpression>;
|
|
2812
|
+
isPattern(
|
|
2813
|
+
this: NodePath_Final,
|
|
2814
|
+
opts?: Opts<t.Pattern>,
|
|
2815
|
+
): this is NodePath_Final<t.Pattern>;
|
|
2816
|
+
isPatternLike(
|
|
2817
|
+
this: NodePath_Final,
|
|
2818
|
+
opts?: Opts<t.PatternLike>,
|
|
2819
|
+
): this is NodePath_Final<t.PatternLike>;
|
|
2820
|
+
isPipelineBareFunction(
|
|
2821
|
+
this: NodePath_Final,
|
|
2822
|
+
opts?: Opts<t.PipelineBareFunction>,
|
|
2823
|
+
): this is NodePath_Final<t.PipelineBareFunction>;
|
|
2824
|
+
isPipelinePrimaryTopicReference(
|
|
2825
|
+
this: NodePath_Final,
|
|
2826
|
+
opts?: Opts<t.PipelinePrimaryTopicReference>,
|
|
2827
|
+
): this is NodePath_Final<t.PipelinePrimaryTopicReference>;
|
|
2828
|
+
isPipelineTopicExpression(
|
|
2829
|
+
this: NodePath_Final,
|
|
2830
|
+
opts?: Opts<t.PipelineTopicExpression>,
|
|
2831
|
+
): this is NodePath_Final<t.PipelineTopicExpression>;
|
|
2832
|
+
isPlaceholder(
|
|
2833
|
+
this: NodePath_Final,
|
|
2834
|
+
opts?: Opts<t.Placeholder>,
|
|
2835
|
+
): this is NodePath_Final<t.Placeholder>;
|
|
2836
|
+
isPrivate(
|
|
2837
|
+
this: NodePath_Final,
|
|
2838
|
+
opts?: Opts<t.Private>,
|
|
2839
|
+
): this is NodePath_Final<t.Private>;
|
|
2840
|
+
isPrivateName(
|
|
2841
|
+
this: NodePath_Final,
|
|
2842
|
+
opts?: Opts<t.PrivateName>,
|
|
2843
|
+
): this is NodePath_Final<t.PrivateName>;
|
|
2844
|
+
isProgram(
|
|
2845
|
+
this: NodePath_Final,
|
|
2846
|
+
opts?: Opts<t.Program>,
|
|
2847
|
+
): this is NodePath_Final<t.Program>;
|
|
2848
|
+
isProperty(
|
|
2849
|
+
this: NodePath_Final,
|
|
2850
|
+
opts?: Opts<t.Property>,
|
|
2851
|
+
): this is NodePath_Final<t.Property>;
|
|
2852
|
+
isPureish(
|
|
2853
|
+
this: NodePath_Final,
|
|
2854
|
+
opts?: Opts<t.Pureish>,
|
|
2855
|
+
): this is NodePath_Final<t.Pureish>;
|
|
2856
|
+
isQualifiedTypeIdentifier(
|
|
2857
|
+
this: NodePath_Final,
|
|
2858
|
+
opts?: Opts<t.QualifiedTypeIdentifier>,
|
|
2859
|
+
): this is NodePath_Final<t.QualifiedTypeIdentifier>;
|
|
2860
|
+
isRecordExpression(
|
|
2861
|
+
this: NodePath_Final,
|
|
2862
|
+
opts?: Opts<t.RecordExpression>,
|
|
2863
|
+
): this is NodePath_Final<t.RecordExpression>;
|
|
2864
|
+
isRegExpLiteral(
|
|
2865
|
+
this: NodePath_Final,
|
|
2866
|
+
opts?: Opts<t.RegExpLiteral>,
|
|
2867
|
+
): this is NodePath_Final<t.RegExpLiteral>;
|
|
2868
|
+
isRegexLiteral(
|
|
2869
|
+
this: NodePath_Final,
|
|
2870
|
+
opts?: Opts<t.RegexLiteral>,
|
|
2871
|
+
): this is NodePath_Final<t.RegexLiteral>;
|
|
2872
|
+
isRestElement(
|
|
2873
|
+
this: NodePath_Final,
|
|
2874
|
+
opts?: Opts<t.RestElement>,
|
|
2875
|
+
): this is NodePath_Final<t.RestElement>;
|
|
2876
|
+
isRestProperty(
|
|
2877
|
+
this: NodePath_Final,
|
|
2878
|
+
opts?: Opts<t.RestProperty>,
|
|
2879
|
+
): this is NodePath_Final<t.RestProperty>;
|
|
2880
|
+
isReturnStatement(
|
|
2881
|
+
this: NodePath_Final,
|
|
2882
|
+
opts?: Opts<t.ReturnStatement>,
|
|
2883
|
+
): this is NodePath_Final<t.ReturnStatement>;
|
|
2884
|
+
isScopable(
|
|
2885
|
+
this: NodePath_Final,
|
|
2886
|
+
opts?: Opts<t.Scopable>,
|
|
2887
|
+
): this is NodePath_Final<t.Scopable>;
|
|
2888
|
+
isSequenceExpression(
|
|
2889
|
+
this: NodePath_Final,
|
|
2890
|
+
opts?: Opts<t.SequenceExpression>,
|
|
2891
|
+
): this is NodePath_Final<t.SequenceExpression>;
|
|
2892
|
+
isSpreadElement(
|
|
2893
|
+
this: NodePath_Final,
|
|
2894
|
+
opts?: Opts<t.SpreadElement>,
|
|
2895
|
+
): this is NodePath_Final<t.SpreadElement>;
|
|
2896
|
+
isSpreadProperty(
|
|
2897
|
+
this: NodePath_Final,
|
|
2898
|
+
opts?: Opts<t.SpreadProperty>,
|
|
2899
|
+
): this is NodePath_Final<t.SpreadProperty>;
|
|
2900
|
+
isStandardized(
|
|
2901
|
+
this: NodePath_Final,
|
|
2902
|
+
opts?: Opts<t.Standardized>,
|
|
2903
|
+
): this is NodePath_Final<t.Standardized>;
|
|
2904
|
+
isStatement(
|
|
2905
|
+
this: NodePath_Final,
|
|
2906
|
+
opts?: Opts<t.Statement>,
|
|
2907
|
+
): this is NodePath_Final<t.Statement>;
|
|
2908
|
+
isStaticBlock(
|
|
2909
|
+
this: NodePath_Final,
|
|
2910
|
+
opts?: Opts<t.StaticBlock>,
|
|
2911
|
+
): this is NodePath_Final<t.StaticBlock>;
|
|
2912
|
+
isStringLiteral(
|
|
2913
|
+
this: NodePath_Final,
|
|
2914
|
+
opts?: Opts<t.StringLiteral>,
|
|
2915
|
+
): this is NodePath_Final<t.StringLiteral>;
|
|
2916
|
+
isStringLiteralTypeAnnotation(
|
|
2917
|
+
this: NodePath_Final,
|
|
2918
|
+
opts?: Opts<t.StringLiteralTypeAnnotation>,
|
|
2919
|
+
): this is NodePath_Final<t.StringLiteralTypeAnnotation>;
|
|
2920
|
+
isStringTypeAnnotation(
|
|
2921
|
+
this: NodePath_Final,
|
|
2922
|
+
opts?: Opts<t.StringTypeAnnotation>,
|
|
2923
|
+
): this is NodePath_Final<t.StringTypeAnnotation>;
|
|
2924
|
+
isSuper(this: NodePath_Final, opts?: Opts<t.Super>): this is NodePath_Final<t.Super>;
|
|
2925
|
+
isSwitchCase(
|
|
2926
|
+
this: NodePath_Final,
|
|
2927
|
+
opts?: Opts<t.SwitchCase>,
|
|
2928
|
+
): this is NodePath_Final<t.SwitchCase>;
|
|
2929
|
+
isSwitchStatement(
|
|
2930
|
+
this: NodePath_Final,
|
|
2931
|
+
opts?: Opts<t.SwitchStatement>,
|
|
2932
|
+
): this is NodePath_Final<t.SwitchStatement>;
|
|
2933
|
+
isSymbolTypeAnnotation(
|
|
2934
|
+
this: NodePath_Final,
|
|
2935
|
+
opts?: Opts<t.SymbolTypeAnnotation>,
|
|
2936
|
+
): this is NodePath_Final<t.SymbolTypeAnnotation>;
|
|
2937
|
+
isTSAnyKeyword(
|
|
2938
|
+
this: NodePath_Final,
|
|
2939
|
+
opts?: Opts<t.TSAnyKeyword>,
|
|
2940
|
+
): this is NodePath_Final<t.TSAnyKeyword>;
|
|
2941
|
+
isTSArrayType(
|
|
2942
|
+
this: NodePath_Final,
|
|
2943
|
+
opts?: Opts<t.TSArrayType>,
|
|
2944
|
+
): this is NodePath_Final<t.TSArrayType>;
|
|
2945
|
+
isTSAsExpression(
|
|
2946
|
+
this: NodePath_Final,
|
|
2947
|
+
opts?: Opts<t.TSAsExpression>,
|
|
2948
|
+
): this is NodePath_Final<t.TSAsExpression>;
|
|
2949
|
+
isTSBaseType(
|
|
2950
|
+
this: NodePath_Final,
|
|
2951
|
+
opts?: Opts<t.TSBaseType>,
|
|
2952
|
+
): this is NodePath_Final<t.TSBaseType>;
|
|
2953
|
+
isTSBigIntKeyword(
|
|
2954
|
+
this: NodePath_Final,
|
|
2955
|
+
opts?: Opts<t.TSBigIntKeyword>,
|
|
2956
|
+
): this is NodePath_Final<t.TSBigIntKeyword>;
|
|
2957
|
+
isTSBooleanKeyword(
|
|
2958
|
+
this: NodePath_Final,
|
|
2959
|
+
opts?: Opts<t.TSBooleanKeyword>,
|
|
2960
|
+
): this is NodePath_Final<t.TSBooleanKeyword>;
|
|
2961
|
+
isTSCallSignatureDeclaration(
|
|
2962
|
+
this: NodePath_Final,
|
|
2963
|
+
opts?: Opts<t.TSCallSignatureDeclaration>,
|
|
2964
|
+
): this is NodePath_Final<t.TSCallSignatureDeclaration>;
|
|
2965
|
+
isTSConditionalType(
|
|
2966
|
+
this: NodePath_Final,
|
|
2967
|
+
opts?: Opts<t.TSConditionalType>,
|
|
2968
|
+
): this is NodePath_Final<t.TSConditionalType>;
|
|
2969
|
+
isTSConstructSignatureDeclaration(
|
|
2970
|
+
this: NodePath_Final,
|
|
2971
|
+
opts?: Opts<t.TSConstructSignatureDeclaration>,
|
|
2972
|
+
): this is NodePath_Final<t.TSConstructSignatureDeclaration>;
|
|
2973
|
+
isTSConstructorType(
|
|
2974
|
+
this: NodePath_Final,
|
|
2975
|
+
opts?: Opts<t.TSConstructorType>,
|
|
2976
|
+
): this is NodePath_Final<t.TSConstructorType>;
|
|
2977
|
+
isTSDeclareFunction(
|
|
2978
|
+
this: NodePath_Final,
|
|
2979
|
+
opts?: Opts<t.TSDeclareFunction>,
|
|
2980
|
+
): this is NodePath_Final<t.TSDeclareFunction>;
|
|
2981
|
+
isTSDeclareMethod(
|
|
2982
|
+
this: NodePath_Final,
|
|
2983
|
+
opts?: Opts<t.TSDeclareMethod>,
|
|
2984
|
+
): this is NodePath_Final<t.TSDeclareMethod>;
|
|
2985
|
+
isTSEntityName(
|
|
2986
|
+
this: NodePath_Final,
|
|
2987
|
+
opts?: Opts<t.TSEntityName>,
|
|
2988
|
+
): this is NodePath_Final<t.TSEntityName>;
|
|
2989
|
+
isTSEnumDeclaration(
|
|
2990
|
+
this: NodePath_Final,
|
|
2991
|
+
opts?: Opts<t.TSEnumDeclaration>,
|
|
2992
|
+
): this is NodePath_Final<t.TSEnumDeclaration>;
|
|
2993
|
+
isTSEnumMember(
|
|
2994
|
+
this: NodePath_Final,
|
|
2995
|
+
opts?: Opts<t.TSEnumMember>,
|
|
2996
|
+
): this is NodePath_Final<t.TSEnumMember>;
|
|
2997
|
+
isTSExportAssignment(
|
|
2998
|
+
this: NodePath_Final,
|
|
2999
|
+
opts?: Opts<t.TSExportAssignment>,
|
|
3000
|
+
): this is NodePath_Final<t.TSExportAssignment>;
|
|
3001
|
+
isTSExpressionWithTypeArguments(
|
|
3002
|
+
this: NodePath_Final,
|
|
3003
|
+
opts?: Opts<t.TSExpressionWithTypeArguments>,
|
|
3004
|
+
): this is NodePath_Final<t.TSExpressionWithTypeArguments>;
|
|
3005
|
+
isTSExternalModuleReference(
|
|
3006
|
+
this: NodePath_Final,
|
|
3007
|
+
opts?: Opts<t.TSExternalModuleReference>,
|
|
3008
|
+
): this is NodePath_Final<t.TSExternalModuleReference>;
|
|
3009
|
+
isTSFunctionType(
|
|
3010
|
+
this: NodePath_Final,
|
|
3011
|
+
opts?: Opts<t.TSFunctionType>,
|
|
3012
|
+
): this is NodePath_Final<t.TSFunctionType>;
|
|
3013
|
+
isTSImportEqualsDeclaration(
|
|
3014
|
+
this: NodePath_Final,
|
|
3015
|
+
opts?: Opts<t.TSImportEqualsDeclaration>,
|
|
3016
|
+
): this is NodePath_Final<t.TSImportEqualsDeclaration>;
|
|
3017
|
+
isTSImportType(
|
|
3018
|
+
this: NodePath_Final,
|
|
3019
|
+
opts?: Opts<t.TSImportType>,
|
|
3020
|
+
): this is NodePath_Final<t.TSImportType>;
|
|
3021
|
+
isTSIndexSignature(
|
|
3022
|
+
this: NodePath_Final,
|
|
3023
|
+
opts?: Opts<t.TSIndexSignature>,
|
|
3024
|
+
): this is NodePath_Final<t.TSIndexSignature>;
|
|
3025
|
+
isTSIndexedAccessType(
|
|
3026
|
+
this: NodePath_Final,
|
|
3027
|
+
opts?: Opts<t.TSIndexedAccessType>,
|
|
3028
|
+
): this is NodePath_Final<t.TSIndexedAccessType>;
|
|
3029
|
+
isTSInferType(
|
|
3030
|
+
this: NodePath_Final,
|
|
3031
|
+
opts?: Opts<t.TSInferType>,
|
|
3032
|
+
): this is NodePath_Final<t.TSInferType>;
|
|
3033
|
+
isTSInstantiationExpression(
|
|
3034
|
+
this: NodePath_Final,
|
|
3035
|
+
opts?: Opts<t.TSInstantiationExpression>,
|
|
3036
|
+
): this is NodePath_Final<t.TSInstantiationExpression>;
|
|
3037
|
+
isTSInterfaceBody(
|
|
3038
|
+
this: NodePath_Final,
|
|
3039
|
+
opts?: Opts<t.TSInterfaceBody>,
|
|
3040
|
+
): this is NodePath_Final<t.TSInterfaceBody>;
|
|
3041
|
+
isTSInterfaceDeclaration(
|
|
3042
|
+
this: NodePath_Final,
|
|
3043
|
+
opts?: Opts<t.TSInterfaceDeclaration>,
|
|
3044
|
+
): this is NodePath_Final<t.TSInterfaceDeclaration>;
|
|
3045
|
+
isTSIntersectionType(
|
|
3046
|
+
this: NodePath_Final,
|
|
3047
|
+
opts?: Opts<t.TSIntersectionType>,
|
|
3048
|
+
): this is NodePath_Final<t.TSIntersectionType>;
|
|
3049
|
+
isTSIntrinsicKeyword(
|
|
3050
|
+
this: NodePath_Final,
|
|
3051
|
+
opts?: Opts<t.TSIntrinsicKeyword>,
|
|
3052
|
+
): this is NodePath_Final<t.TSIntrinsicKeyword>;
|
|
3053
|
+
isTSLiteralType(
|
|
3054
|
+
this: NodePath_Final,
|
|
3055
|
+
opts?: Opts<t.TSLiteralType>,
|
|
3056
|
+
): this is NodePath_Final<t.TSLiteralType>;
|
|
3057
|
+
isTSMappedType(
|
|
3058
|
+
this: NodePath_Final,
|
|
3059
|
+
opts?: Opts<t.TSMappedType>,
|
|
3060
|
+
): this is NodePath_Final<t.TSMappedType>;
|
|
3061
|
+
isTSMethodSignature(
|
|
3062
|
+
this: NodePath_Final,
|
|
3063
|
+
opts?: Opts<t.TSMethodSignature>,
|
|
3064
|
+
): this is NodePath_Final<t.TSMethodSignature>;
|
|
3065
|
+
isTSModuleBlock(
|
|
3066
|
+
this: NodePath_Final,
|
|
3067
|
+
opts?: Opts<t.TSModuleBlock>,
|
|
3068
|
+
): this is NodePath_Final<t.TSModuleBlock>;
|
|
3069
|
+
isTSModuleDeclaration(
|
|
3070
|
+
this: NodePath_Final,
|
|
3071
|
+
opts?: Opts<t.TSModuleDeclaration>,
|
|
3072
|
+
): this is NodePath_Final<t.TSModuleDeclaration>;
|
|
3073
|
+
isTSNamedTupleMember(
|
|
3074
|
+
this: NodePath_Final,
|
|
3075
|
+
opts?: Opts<t.TSNamedTupleMember>,
|
|
3076
|
+
): this is NodePath_Final<t.TSNamedTupleMember>;
|
|
3077
|
+
isTSNamespaceExportDeclaration(
|
|
3078
|
+
this: NodePath_Final,
|
|
3079
|
+
opts?: Opts<t.TSNamespaceExportDeclaration>,
|
|
3080
|
+
): this is NodePath_Final<t.TSNamespaceExportDeclaration>;
|
|
3081
|
+
isTSNeverKeyword(
|
|
3082
|
+
this: NodePath_Final,
|
|
3083
|
+
opts?: Opts<t.TSNeverKeyword>,
|
|
3084
|
+
): this is NodePath_Final<t.TSNeverKeyword>;
|
|
3085
|
+
isTSNonNullExpression(
|
|
3086
|
+
this: NodePath_Final,
|
|
3087
|
+
opts?: Opts<t.TSNonNullExpression>,
|
|
3088
|
+
): this is NodePath_Final<t.TSNonNullExpression>;
|
|
3089
|
+
isTSNullKeyword(
|
|
3090
|
+
this: NodePath_Final,
|
|
3091
|
+
opts?: Opts<t.TSNullKeyword>,
|
|
3092
|
+
): this is NodePath_Final<t.TSNullKeyword>;
|
|
3093
|
+
isTSNumberKeyword(
|
|
3094
|
+
this: NodePath_Final,
|
|
3095
|
+
opts?: Opts<t.TSNumberKeyword>,
|
|
3096
|
+
): this is NodePath_Final<t.TSNumberKeyword>;
|
|
3097
|
+
isTSObjectKeyword(
|
|
3098
|
+
this: NodePath_Final,
|
|
3099
|
+
opts?: Opts<t.TSObjectKeyword>,
|
|
3100
|
+
): this is NodePath_Final<t.TSObjectKeyword>;
|
|
3101
|
+
isTSOptionalType(
|
|
3102
|
+
this: NodePath_Final,
|
|
3103
|
+
opts?: Opts<t.TSOptionalType>,
|
|
3104
|
+
): this is NodePath_Final<t.TSOptionalType>;
|
|
3105
|
+
isTSParameterProperty(
|
|
3106
|
+
this: NodePath_Final,
|
|
3107
|
+
opts?: Opts<t.TSParameterProperty>,
|
|
3108
|
+
): this is NodePath_Final<t.TSParameterProperty>;
|
|
3109
|
+
isTSParenthesizedType(
|
|
3110
|
+
this: NodePath_Final,
|
|
3111
|
+
opts?: Opts<t.TSParenthesizedType>,
|
|
3112
|
+
): this is NodePath_Final<t.TSParenthesizedType>;
|
|
3113
|
+
isTSPropertySignature(
|
|
3114
|
+
this: NodePath_Final,
|
|
3115
|
+
opts?: Opts<t.TSPropertySignature>,
|
|
3116
|
+
): this is NodePath_Final<t.TSPropertySignature>;
|
|
3117
|
+
isTSQualifiedName(
|
|
3118
|
+
this: NodePath_Final,
|
|
3119
|
+
opts?: Opts<t.TSQualifiedName>,
|
|
3120
|
+
): this is NodePath_Final<t.TSQualifiedName>;
|
|
3121
|
+
isTSRestType(
|
|
3122
|
+
this: NodePath_Final,
|
|
3123
|
+
opts?: Opts<t.TSRestType>,
|
|
3124
|
+
): this is NodePath_Final<t.TSRestType>;
|
|
3125
|
+
isTSSatisfiesExpression(
|
|
3126
|
+
this: NodePath_Final,
|
|
3127
|
+
opts?: Opts<t.TSSatisfiesExpression>,
|
|
3128
|
+
): this is NodePath_Final<t.TSSatisfiesExpression>;
|
|
3129
|
+
isTSStringKeyword(
|
|
3130
|
+
this: NodePath_Final,
|
|
3131
|
+
opts?: Opts<t.TSStringKeyword>,
|
|
3132
|
+
): this is NodePath_Final<t.TSStringKeyword>;
|
|
3133
|
+
isTSSymbolKeyword(
|
|
3134
|
+
this: NodePath_Final,
|
|
3135
|
+
opts?: Opts<t.TSSymbolKeyword>,
|
|
3136
|
+
): this is NodePath_Final<t.TSSymbolKeyword>;
|
|
3137
|
+
isTSThisType(
|
|
3138
|
+
this: NodePath_Final,
|
|
3139
|
+
opts?: Opts<t.TSThisType>,
|
|
3140
|
+
): this is NodePath_Final<t.TSThisType>;
|
|
3141
|
+
isTSTupleType(
|
|
3142
|
+
this: NodePath_Final,
|
|
3143
|
+
opts?: Opts<t.TSTupleType>,
|
|
3144
|
+
): this is NodePath_Final<t.TSTupleType>;
|
|
3145
|
+
isTSType(this: NodePath_Final, opts?: Opts<t.TSType>): this is NodePath_Final<t.TSType>;
|
|
3146
|
+
isTSTypeAliasDeclaration(
|
|
3147
|
+
this: NodePath_Final,
|
|
3148
|
+
opts?: Opts<t.TSTypeAliasDeclaration>,
|
|
3149
|
+
): this is NodePath_Final<t.TSTypeAliasDeclaration>;
|
|
3150
|
+
isTSTypeAnnotation(
|
|
3151
|
+
this: NodePath_Final,
|
|
3152
|
+
opts?: Opts<t.TSTypeAnnotation>,
|
|
3153
|
+
): this is NodePath_Final<t.TSTypeAnnotation>;
|
|
3154
|
+
isTSTypeAssertion(
|
|
3155
|
+
this: NodePath_Final,
|
|
3156
|
+
opts?: Opts<t.TSTypeAssertion>,
|
|
3157
|
+
): this is NodePath_Final<t.TSTypeAssertion>;
|
|
3158
|
+
isTSTypeElement(
|
|
3159
|
+
this: NodePath_Final,
|
|
3160
|
+
opts?: Opts<t.TSTypeElement>,
|
|
3161
|
+
): this is NodePath_Final<t.TSTypeElement>;
|
|
3162
|
+
isTSTypeLiteral(
|
|
3163
|
+
this: NodePath_Final,
|
|
3164
|
+
opts?: Opts<t.TSTypeLiteral>,
|
|
3165
|
+
): this is NodePath_Final<t.TSTypeLiteral>;
|
|
3166
|
+
isTSTypeOperator(
|
|
3167
|
+
this: NodePath_Final,
|
|
3168
|
+
opts?: Opts<t.TSTypeOperator>,
|
|
3169
|
+
): this is NodePath_Final<t.TSTypeOperator>;
|
|
3170
|
+
isTSTypeParameter(
|
|
3171
|
+
this: NodePath_Final,
|
|
3172
|
+
opts?: Opts<t.TSTypeParameter>,
|
|
3173
|
+
): this is NodePath_Final<t.TSTypeParameter>;
|
|
3174
|
+
isTSTypeParameterDeclaration(
|
|
3175
|
+
this: NodePath_Final,
|
|
3176
|
+
opts?: Opts<t.TSTypeParameterDeclaration>,
|
|
3177
|
+
): this is NodePath_Final<t.TSTypeParameterDeclaration>;
|
|
3178
|
+
isTSTypeParameterInstantiation(
|
|
3179
|
+
this: NodePath_Final,
|
|
3180
|
+
opts?: Opts<t.TSTypeParameterInstantiation>,
|
|
3181
|
+
): this is NodePath_Final<t.TSTypeParameterInstantiation>;
|
|
3182
|
+
isTSTypePredicate(
|
|
3183
|
+
this: NodePath_Final,
|
|
3184
|
+
opts?: Opts<t.TSTypePredicate>,
|
|
3185
|
+
): this is NodePath_Final<t.TSTypePredicate>;
|
|
3186
|
+
isTSTypeQuery(
|
|
3187
|
+
this: NodePath_Final,
|
|
3188
|
+
opts?: Opts<t.TSTypeQuery>,
|
|
3189
|
+
): this is NodePath_Final<t.TSTypeQuery>;
|
|
3190
|
+
isTSTypeReference(
|
|
3191
|
+
this: NodePath_Final,
|
|
3192
|
+
opts?: Opts<t.TSTypeReference>,
|
|
3193
|
+
): this is NodePath_Final<t.TSTypeReference>;
|
|
3194
|
+
isTSUndefinedKeyword(
|
|
3195
|
+
this: NodePath_Final,
|
|
3196
|
+
opts?: Opts<t.TSUndefinedKeyword>,
|
|
3197
|
+
): this is NodePath_Final<t.TSUndefinedKeyword>;
|
|
3198
|
+
isTSUnionType(
|
|
3199
|
+
this: NodePath_Final,
|
|
3200
|
+
opts?: Opts<t.TSUnionType>,
|
|
3201
|
+
): this is NodePath_Final<t.TSUnionType>;
|
|
3202
|
+
isTSUnknownKeyword(
|
|
3203
|
+
this: NodePath_Final,
|
|
3204
|
+
opts?: Opts<t.TSUnknownKeyword>,
|
|
3205
|
+
): this is NodePath_Final<t.TSUnknownKeyword>;
|
|
3206
|
+
isTSVoidKeyword(
|
|
3207
|
+
this: NodePath_Final,
|
|
3208
|
+
opts?: Opts<t.TSVoidKeyword>,
|
|
3209
|
+
): this is NodePath_Final<t.TSVoidKeyword>;
|
|
3210
|
+
isTaggedTemplateExpression(
|
|
3211
|
+
this: NodePath_Final,
|
|
3212
|
+
opts?: Opts<t.TaggedTemplateExpression>,
|
|
3213
|
+
): this is NodePath_Final<t.TaggedTemplateExpression>;
|
|
3214
|
+
isTemplateElement(
|
|
3215
|
+
this: NodePath_Final,
|
|
3216
|
+
opts?: Opts<t.TemplateElement>,
|
|
3217
|
+
): this is NodePath_Final<t.TemplateElement>;
|
|
3218
|
+
isTemplateLiteral(
|
|
3219
|
+
this: NodePath_Final,
|
|
3220
|
+
opts?: Opts<t.TemplateLiteral>,
|
|
3221
|
+
): this is NodePath_Final<t.TemplateLiteral>;
|
|
3222
|
+
isTerminatorless(
|
|
3223
|
+
this: NodePath_Final,
|
|
3224
|
+
opts?: Opts<t.Terminatorless>,
|
|
3225
|
+
): this is NodePath_Final<t.Terminatorless>;
|
|
3226
|
+
isThisExpression(
|
|
3227
|
+
this: NodePath_Final,
|
|
3228
|
+
opts?: Opts<t.ThisExpression>,
|
|
3229
|
+
): this is NodePath_Final<t.ThisExpression>;
|
|
3230
|
+
isThisTypeAnnotation(
|
|
3231
|
+
this: NodePath_Final,
|
|
3232
|
+
opts?: Opts<t.ThisTypeAnnotation>,
|
|
3233
|
+
): this is NodePath_Final<t.ThisTypeAnnotation>;
|
|
3234
|
+
isThrowStatement(
|
|
3235
|
+
this: NodePath_Final,
|
|
3236
|
+
opts?: Opts<t.ThrowStatement>,
|
|
3237
|
+
): this is NodePath_Final<t.ThrowStatement>;
|
|
3238
|
+
isTopicReference(
|
|
3239
|
+
this: NodePath_Final,
|
|
3240
|
+
opts?: Opts<t.TopicReference>,
|
|
3241
|
+
): this is NodePath_Final<t.TopicReference>;
|
|
3242
|
+
isTryStatement(
|
|
3243
|
+
this: NodePath_Final,
|
|
3244
|
+
opts?: Opts<t.TryStatement>,
|
|
3245
|
+
): this is NodePath_Final<t.TryStatement>;
|
|
3246
|
+
isTupleExpression(
|
|
3247
|
+
this: NodePath_Final,
|
|
3248
|
+
opts?: Opts<t.TupleExpression>,
|
|
3249
|
+
): this is NodePath_Final<t.TupleExpression>;
|
|
3250
|
+
isTupleTypeAnnotation(
|
|
3251
|
+
this: NodePath_Final,
|
|
3252
|
+
opts?: Opts<t.TupleTypeAnnotation>,
|
|
3253
|
+
): this is NodePath_Final<t.TupleTypeAnnotation>;
|
|
3254
|
+
isTypeAlias(
|
|
3255
|
+
this: NodePath_Final,
|
|
3256
|
+
opts?: Opts<t.TypeAlias>,
|
|
3257
|
+
): this is NodePath_Final<t.TypeAlias>;
|
|
3258
|
+
isTypeAnnotation(
|
|
3259
|
+
this: NodePath_Final,
|
|
3260
|
+
opts?: Opts<t.TypeAnnotation>,
|
|
3261
|
+
): this is NodePath_Final<t.TypeAnnotation>;
|
|
3262
|
+
isTypeCastExpression(
|
|
3263
|
+
this: NodePath_Final,
|
|
3264
|
+
opts?: Opts<t.TypeCastExpression>,
|
|
3265
|
+
): this is NodePath_Final<t.TypeCastExpression>;
|
|
3266
|
+
isTypeParameter(
|
|
3267
|
+
this: NodePath_Final,
|
|
3268
|
+
opts?: Opts<t.TypeParameter>,
|
|
3269
|
+
): this is NodePath_Final<t.TypeParameter>;
|
|
3270
|
+
isTypeParameterDeclaration(
|
|
3271
|
+
this: NodePath_Final,
|
|
3272
|
+
opts?: Opts<t.TypeParameterDeclaration>,
|
|
3273
|
+
): this is NodePath_Final<t.TypeParameterDeclaration>;
|
|
3274
|
+
isTypeParameterInstantiation(
|
|
3275
|
+
this: NodePath_Final,
|
|
3276
|
+
opts?: Opts<t.TypeParameterInstantiation>,
|
|
3277
|
+
): this is NodePath_Final<t.TypeParameterInstantiation>;
|
|
3278
|
+
isTypeScript(
|
|
3279
|
+
this: NodePath_Final,
|
|
3280
|
+
opts?: Opts<t.TypeScript>,
|
|
3281
|
+
): this is NodePath_Final<t.TypeScript>;
|
|
3282
|
+
isTypeofTypeAnnotation(
|
|
3283
|
+
this: NodePath_Final,
|
|
3284
|
+
opts?: Opts<t.TypeofTypeAnnotation>,
|
|
3285
|
+
): this is NodePath_Final<t.TypeofTypeAnnotation>;
|
|
3286
|
+
isUnaryExpression(
|
|
3287
|
+
this: NodePath_Final,
|
|
3288
|
+
opts?: Opts<t.UnaryExpression>,
|
|
3289
|
+
): this is NodePath_Final<t.UnaryExpression>;
|
|
3290
|
+
isUnaryLike(
|
|
3291
|
+
this: NodePath_Final,
|
|
3292
|
+
opts?: Opts<t.UnaryLike>,
|
|
3293
|
+
): this is NodePath_Final<t.UnaryLike>;
|
|
3294
|
+
isUnionTypeAnnotation(
|
|
3295
|
+
this: NodePath_Final,
|
|
3296
|
+
opts?: Opts<t.UnionTypeAnnotation>,
|
|
3297
|
+
): this is NodePath_Final<t.UnionTypeAnnotation>;
|
|
3298
|
+
isUpdateExpression(
|
|
3299
|
+
this: NodePath_Final,
|
|
3300
|
+
opts?: Opts<t.UpdateExpression>,
|
|
3301
|
+
): this is NodePath_Final<t.UpdateExpression>;
|
|
3302
|
+
isUserWhitespacable(
|
|
3303
|
+
this: NodePath_Final,
|
|
3304
|
+
opts?: Opts<t.UserWhitespacable>,
|
|
3305
|
+
): this is NodePath_Final<t.UserWhitespacable>;
|
|
3306
|
+
isV8IntrinsicIdentifier(
|
|
3307
|
+
this: NodePath_Final,
|
|
3308
|
+
opts?: Opts<t.V8IntrinsicIdentifier>,
|
|
3309
|
+
): this is NodePath_Final<t.V8IntrinsicIdentifier>;
|
|
3310
|
+
isVariableDeclaration(
|
|
3311
|
+
this: NodePath_Final,
|
|
3312
|
+
opts?: Opts<t.VariableDeclaration>,
|
|
3313
|
+
): this is NodePath_Final<t.VariableDeclaration>;
|
|
3314
|
+
isVariableDeclarator(
|
|
3315
|
+
this: NodePath_Final,
|
|
3316
|
+
opts?: Opts<t.VariableDeclarator>,
|
|
3317
|
+
): this is NodePath_Final<t.VariableDeclarator>;
|
|
3318
|
+
isVariance(
|
|
3319
|
+
this: NodePath_Final,
|
|
3320
|
+
opts?: Opts<t.Variance>,
|
|
3321
|
+
): this is NodePath_Final<t.Variance>;
|
|
3322
|
+
isVoidTypeAnnotation(
|
|
3323
|
+
this: NodePath_Final,
|
|
3324
|
+
opts?: Opts<t.VoidTypeAnnotation>,
|
|
3325
|
+
): this is NodePath_Final<t.VoidTypeAnnotation>;
|
|
3326
|
+
isWhile(this: NodePath_Final, opts?: Opts<t.While>): this is NodePath_Final<t.While>;
|
|
3327
|
+
isWhileStatement(
|
|
3328
|
+
this: NodePath_Final,
|
|
3329
|
+
opts?: Opts<t.WhileStatement>,
|
|
3330
|
+
): this is NodePath_Final<t.WhileStatement>;
|
|
3331
|
+
isWithStatement(
|
|
3332
|
+
this: NodePath_Final,
|
|
3333
|
+
opts?: Opts<t.WithStatement>,
|
|
3334
|
+
): this is NodePath_Final<t.WithStatement>;
|
|
3335
|
+
isYieldExpression(
|
|
3336
|
+
this: NodePath_Final,
|
|
3337
|
+
opts?: Opts<t.YieldExpression>,
|
|
3338
|
+
): this is NodePath_Final<t.YieldExpression>;
|
|
3339
|
+
}
|
|
3340
|
+
|
|
3341
|
+
interface NodePathValidators
|
|
3342
|
+
extends Omit<BaseNodePathValidators, keyof VirtualTypeNodePathValidators>,
|
|
3343
|
+
VirtualTypeNodePathValidators {}
|
|
3344
|
+
|
|
3345
|
+
declare const methods: {
|
|
3346
|
+
findParent: typeof findParent;
|
|
3347
|
+
find: typeof find;
|
|
3348
|
+
getFunctionParent: typeof getFunctionParent;
|
|
3349
|
+
getStatementParent: typeof getStatementParent;
|
|
3350
|
+
getEarliestCommonAncestorFrom: typeof getEarliestCommonAncestorFrom;
|
|
3351
|
+
getDeepestCommonAncestorFrom: typeof getDeepestCommonAncestorFrom;
|
|
3352
|
+
getAncestry: typeof getAncestry;
|
|
3353
|
+
isAncestor: typeof isAncestor;
|
|
3354
|
+
isDescendant: typeof isDescendant;
|
|
3355
|
+
inType: typeof inType;
|
|
3356
|
+
getTypeAnnotation: typeof getTypeAnnotation;
|
|
3357
|
+
_getTypeAnnotation: typeof _getTypeAnnotation;
|
|
3358
|
+
isBaseType: typeof isBaseType;
|
|
3359
|
+
couldBeBaseType: typeof couldBeBaseType;
|
|
3360
|
+
baseTypeStrictlyMatches: typeof baseTypeStrictlyMatches;
|
|
3361
|
+
isGenericType: typeof isGenericType;
|
|
3362
|
+
replaceWithMultiple: typeof replaceWithMultiple;
|
|
3363
|
+
replaceWithSourceString: typeof replaceWithSourceString;
|
|
3364
|
+
replaceWith: typeof replaceWith;
|
|
3365
|
+
_replaceWith: typeof _replaceWith;
|
|
3366
|
+
replaceExpressionWithStatements: typeof replaceExpressionWithStatements;
|
|
3367
|
+
replaceInline: typeof replaceInline;
|
|
3368
|
+
evaluateTruthy: typeof evaluateTruthy;
|
|
3369
|
+
evaluate: typeof evaluate;
|
|
3370
|
+
toComputedKey: typeof toComputedKey;
|
|
3371
|
+
ensureBlock: typeof ensureBlock;
|
|
3372
|
+
unwrapFunctionEnvironment: typeof unwrapFunctionEnvironment;
|
|
3373
|
+
arrowFunctionToExpression: typeof arrowFunctionToExpression;
|
|
3374
|
+
matchesPattern: typeof matchesPattern;
|
|
3375
|
+
has: typeof has;
|
|
3376
|
+
isStatic: typeof isStatic;
|
|
3377
|
+
is: typeof has;
|
|
3378
|
+
isnt: typeof isnt;
|
|
3379
|
+
equals: typeof equals;
|
|
3380
|
+
isNodeType: typeof isNodeType;
|
|
3381
|
+
canHaveVariableDeclarationOrExpression: typeof canHaveVariableDeclarationOrExpression;
|
|
3382
|
+
canSwapBetweenExpressionAndStatement: typeof canSwapBetweenExpressionAndStatement;
|
|
3383
|
+
isCompletionRecord: typeof isCompletionRecord;
|
|
3384
|
+
isStatementOrBlock: typeof isStatementOrBlock;
|
|
3385
|
+
referencesImport: typeof referencesImport;
|
|
3386
|
+
getSource: typeof getSource;
|
|
3387
|
+
willIMaybeExecuteBefore: typeof willIMaybeExecuteBefore;
|
|
3388
|
+
_guessExecutionStatusRelativeTo: typeof _guessExecutionStatusRelativeTo;
|
|
3389
|
+
resolve: typeof resolve;
|
|
3390
|
+
_resolve: typeof _resolve;
|
|
3391
|
+
isConstantExpression: typeof isConstantExpression;
|
|
3392
|
+
isInStrictMode: typeof isInStrictMode;
|
|
3393
|
+
call: typeof call;
|
|
3394
|
+
_call: typeof _call;
|
|
3395
|
+
isDenylisted: typeof isDenylisted;
|
|
3396
|
+
isBlacklisted: typeof isDenylisted;
|
|
3397
|
+
visit: typeof visit;
|
|
3398
|
+
skip: typeof skip;
|
|
3399
|
+
skipKey: typeof skipKey;
|
|
3400
|
+
stop: typeof stop;
|
|
3401
|
+
setScope: typeof setScope;
|
|
3402
|
+
setContext: typeof setContext;
|
|
3403
|
+
resync: typeof resync;
|
|
3404
|
+
_resyncParent: typeof _resyncParent;
|
|
3405
|
+
_resyncKey: typeof _resyncKey;
|
|
3406
|
+
_resyncList: typeof _resyncList;
|
|
3407
|
+
_resyncRemoved: typeof _resyncRemoved;
|
|
3408
|
+
popContext: typeof popContext;
|
|
3409
|
+
pushContext: typeof pushContext;
|
|
3410
|
+
setup: typeof setup;
|
|
3411
|
+
setKey: typeof setKey;
|
|
3412
|
+
requeue: typeof requeue;
|
|
3413
|
+
_getQueueContexts: typeof _getQueueContexts;
|
|
3414
|
+
remove: typeof remove;
|
|
3415
|
+
_removeFromScope: typeof _removeFromScope;
|
|
3416
|
+
_callRemovalHooks: typeof _callRemovalHooks;
|
|
3417
|
+
_remove: typeof _remove;
|
|
3418
|
+
_markRemoved: typeof _markRemoved;
|
|
3419
|
+
_assertUnremoved: typeof _assertUnremoved;
|
|
3420
|
+
insertBefore: typeof insertBefore;
|
|
3421
|
+
_containerInsert: typeof _containerInsert;
|
|
3422
|
+
_containerInsertBefore: typeof _containerInsertBefore;
|
|
3423
|
+
_containerInsertAfter: typeof _containerInsertAfter;
|
|
3424
|
+
insertAfter: typeof insertAfter;
|
|
3425
|
+
updateSiblingKeys: typeof updateSiblingKeys;
|
|
3426
|
+
_verifyNodeList: typeof _verifyNodeList;
|
|
3427
|
+
unshiftContainer: typeof unshiftContainer;
|
|
3428
|
+
pushContainer: typeof pushContainer;
|
|
3429
|
+
hoist: typeof hoist;
|
|
3430
|
+
getOpposite: typeof getOpposite;
|
|
3431
|
+
getCompletionRecords: typeof getCompletionRecords;
|
|
3432
|
+
getSibling: typeof getSibling;
|
|
3433
|
+
getPrevSibling: typeof getPrevSibling;
|
|
3434
|
+
getNextSibling: typeof getNextSibling;
|
|
3435
|
+
getAllNextSiblings: typeof getAllNextSiblings;
|
|
3436
|
+
getAllPrevSiblings: typeof getAllPrevSiblings;
|
|
3437
|
+
get: typeof get;
|
|
3438
|
+
_getKey: typeof _getKey;
|
|
3439
|
+
_getPattern: typeof _getPattern;
|
|
3440
|
+
getBindingIdentifiers: typeof getBindingIdentifiers;
|
|
3441
|
+
getOuterBindingIdentifiers: typeof getOuterBindingIdentifiers;
|
|
3442
|
+
getBindingIdentifierPaths: typeof getBindingIdentifierPaths;
|
|
3443
|
+
getOuterBindingIdentifierPaths: typeof getOuterBindingIdentifierPaths;
|
|
3444
|
+
shareCommentsWithSiblings: typeof shareCommentsWithSiblings;
|
|
3445
|
+
addComment: typeof addComment;
|
|
3446
|
+
addComments: typeof addComments;
|
|
3447
|
+
};
|
|
3448
|
+
interface NodePathOverwrites {
|
|
3449
|
+
/**
|
|
3450
|
+
* NOTE: This assertion doesn't narrow the type on unions of
|
|
3451
|
+
* NodePaths, due to https://github.com/microsoft/TypeScript/issues/44212
|
|
3452
|
+
*
|
|
3453
|
+
* @see ./conversion.ts for implementation.
|
|
3454
|
+
*/
|
|
3455
|
+
ensureBlock(this: NodePath_Final): asserts this is NodePath_Final<(t.Loop | t.WithStatement | t.Function | t.LabeledStatement | t.CatchClause) & {
|
|
3456
|
+
body: t.BlockStatement;
|
|
3457
|
+
}>;
|
|
3458
|
+
/**
|
|
3459
|
+
* @see ./introspection.ts for implementation.
|
|
3460
|
+
*/
|
|
3461
|
+
isStatementOrBlock(this: NodePath_Final): this is NodePath_Final<t.Statement | t.Block>;
|
|
3462
|
+
}
|
|
3463
|
+
type NodePathMixins = Omit<typeof methods, keyof NodePathOverwrites>;
|
|
3464
|
+
interface NodePath<T extends t.Node> extends InstanceType<typeof NodePath_Final>, NodePathAssertions, NodePathValidators, NodePathMixins, NodePathOverwrites {
|
|
3465
|
+
type: T["type"] | null;
|
|
3466
|
+
node: T;
|
|
3467
|
+
parent: t.ParentMaps[T["type"]];
|
|
3468
|
+
parentPath: t.ParentMaps[T["type"]] extends null ? null : NodePath_Final<t.ParentMaps[T["type"]]> | null;
|
|
3469
|
+
}
|
|
3470
|
+
declare const NodePath_Final: {
|
|
3471
|
+
new (hub: HubInterface, parent: t.Node | null): {
|
|
3472
|
+
parent: t.Node;
|
|
3473
|
+
hub: HubInterface;
|
|
3474
|
+
data: Record<string | symbol, unknown>;
|
|
3475
|
+
context: TraversalContext;
|
|
3476
|
+
scope: Scope;
|
|
3477
|
+
contexts: Array<TraversalContext>;
|
|
3478
|
+
state: any;
|
|
3479
|
+
opts: ExplodedTraverseOptions | null;
|
|
3480
|
+
_traverseFlags: number;
|
|
3481
|
+
removed: boolean;
|
|
3482
|
+
shouldStop: boolean;
|
|
3483
|
+
shouldSkip: boolean;
|
|
3484
|
+
skipKeys: Record<string, boolean> | null;
|
|
3485
|
+
parentPath: NodePath_Final | null;
|
|
3486
|
+
container: t.Node | Array<t.Node> | null;
|
|
3487
|
+
listKey: string | null;
|
|
3488
|
+
key: string | number | null;
|
|
3489
|
+
node: t.Node | null;
|
|
3490
|
+
type: t.Node["type"] | null;
|
|
3491
|
+
getScope(this: NodePath_Final, scope: Scope): Scope;
|
|
3492
|
+
setData(key: string | symbol, val: any): any;
|
|
3493
|
+
getData(key: string | symbol, def?: any): any;
|
|
3494
|
+
hasNode(): boolean;
|
|
3495
|
+
buildCodeFrameError(msg: string, Error?: new () => Error): Error;
|
|
3496
|
+
traverse<T>(this: NodePath_Final, visitor: Visitor<T>, state: T): void;
|
|
3497
|
+
traverse(this: NodePath_Final, visitor: Visitor): void;
|
|
3498
|
+
set(key: string, node: any): void;
|
|
3499
|
+
getPathLocation(this: NodePath_Final): string;
|
|
3500
|
+
debug(this: NodePath_Final, message: string): void;
|
|
3501
|
+
toString(): string;
|
|
3502
|
+
inList: boolean;
|
|
3503
|
+
readonly parentKey: string;
|
|
3504
|
+
};
|
|
3505
|
+
get({ hub, parentPath, parent, container, listKey, key, }: {
|
|
3506
|
+
hub?: HubInterface;
|
|
3507
|
+
parentPath: NodePath_Final | null;
|
|
3508
|
+
parent: t.Node;
|
|
3509
|
+
container: t.Node | t.Node[];
|
|
3510
|
+
listKey?: string;
|
|
3511
|
+
key: string | number;
|
|
3512
|
+
}): NodePath_Final;
|
|
3513
|
+
};
|
|
3514
|
+
type NodePath_Final<T extends t.Node = t.Node> = T extends any ? NodePath<T> : never;
|
|
3515
|
+
|
|
3516
|
+
declare let pathsCache: WeakMap<HubInterface | typeof nullHub, WeakMap<Node, Map<Node, NodePath_Final>>>;
|
|
3517
|
+
|
|
3518
|
+
declare let scope: WeakMap<Node, Scope>;
|
|
3519
|
+
declare function clear(): void;
|
|
3520
|
+
declare function clearPath(): void;
|
|
3521
|
+
declare function clearScope(): void;
|
|
3522
|
+
declare const nullHub: Readonly<{}>;
|
|
3523
|
+
declare function getCachedPaths(hub: HubInterface | null, parent: Node): Map<Node, NodePath_Final>;
|
|
3524
|
+
declare function getOrCreateCachedPaths(hub: HubInterface | null, parent: Node): Map<Node, NodePath_Final>;
|
|
3525
|
+
|
|
3526
|
+
declare const __cache_ts_clear: typeof clear;
|
|
3527
|
+
declare const __cache_ts_clearPath: typeof clearPath;
|
|
3528
|
+
declare const __cache_ts_clearScope: typeof clearScope;
|
|
3529
|
+
declare const __cache_ts_getCachedPaths: typeof getCachedPaths;
|
|
3530
|
+
declare const __cache_ts_getOrCreateCachedPaths: typeof getOrCreateCachedPaths;
|
|
3531
|
+
declare const __cache_ts_scope: typeof scope;
|
|
3532
|
+
declare namespace __cache_ts {
|
|
3533
|
+
export { __cache_ts_clear as clear, __cache_ts_clearPath as clearPath, __cache_ts_clearScope as clearScope, __cache_ts_getCachedPaths as getCachedPaths, __cache_ts_getOrCreateCachedPaths as getOrCreateCachedPaths, pathsCache as path, __cache_ts_scope as scope };
|
|
3534
|
+
}
|
|
3535
|
+
|
|
3536
|
+
type VisitWrapper<S = any> = (stateName: string | undefined, visitorType: VisitPhase, callback: VisitNodeFunction<S, Node>) => VisitNodeFunction<S, Node>;
|
|
3537
|
+
declare function isExplodedVisitor(visitor: Visitor): visitor is ExplodedVisitor;
|
|
3538
|
+
|
|
3539
|
+
/**
|
|
3540
|
+
* explode() will take a visitor object with all of the various shorthands
|
|
3541
|
+
* that we support, and validates & normalizes it into a common format, ready
|
|
3542
|
+
* to be used in traversal
|
|
3543
|
+
*
|
|
3544
|
+
* The various shorthands are:
|
|
3545
|
+
* * `Identifier() { ... }` -> `Identifier: { enter() { ... } }`
|
|
3546
|
+
* * `"Identifier|NumericLiteral": { ... }` -> `Identifier: { ... }, NumericLiteral: { ... }`
|
|
3547
|
+
* * Aliases in `@babel/types`: e.g. `Property: { ... }` -> `ObjectProperty: { ... }, ClassProperty: { ... }`
|
|
3548
|
+
* Other normalizations are:
|
|
3549
|
+
* * Visitors of virtual types are wrapped, so that they are only visited when
|
|
3550
|
+
* their dynamic check passes
|
|
3551
|
+
* * `enter` and `exit` functions are wrapped in arrays, to ease merging of
|
|
3552
|
+
* visitors
|
|
3553
|
+
*/
|
|
3554
|
+
declare function explode$1<S>(visitor: Visitor<S>): ExplodedVisitor<S>;
|
|
3555
|
+
|
|
3556
|
+
declare function verify$1(visitor: Visitor): void;
|
|
3557
|
+
declare function merge<State>(visitors: Visitor<State>[]): ExplodedVisitor<State>;
|
|
3558
|
+
declare function merge(visitors: Visitor<unknown>[], states?: any[], wrapper?: Function | null): ExplodedVisitor<unknown>;
|
|
3559
|
+
|
|
3560
|
+
type __visitors_ts_VisitWrapper<S = any> = VisitWrapper<S>;
|
|
3561
|
+
declare const __visitors_ts_isExplodedVisitor: typeof isExplodedVisitor;
|
|
3562
|
+
declare const __visitors_ts_merge: typeof merge;
|
|
3563
|
+
declare namespace __visitors_ts {
|
|
3564
|
+
export { type __visitors_ts_VisitWrapper as VisitWrapper, explode$1 as explode, __visitors_ts_isExplodedVisitor as isExplodedVisitor, __visitors_ts_merge as merge, verify$1 as verify };
|
|
3565
|
+
}
|
|
3566
|
+
|
|
3567
|
+
type TraverseOptions<S = t.Node> = {
|
|
3568
|
+
scope?: Scope;
|
|
3569
|
+
noScope?: boolean;
|
|
3570
|
+
denylist?: string[];
|
|
3571
|
+
shouldSkip?: (node: NodePath_Final) => boolean;
|
|
3572
|
+
} & Visitor<S>;
|
|
3573
|
+
type ExplodedTraverseOptions<S = t.Node> = TraverseOptions<S> & ExplodedVisitor<S>;
|
|
3574
|
+
declare function traverse<S>(parent: t.Node, opts: TraverseOptions<S>, scope: Scope | undefined, state: S, parentPath?: NodePath_Final, visitSelf?: boolean): void;
|
|
3575
|
+
declare function traverse(parent: t.Node, opts: TraverseOptions, scope?: Scope, state?: any, parentPath?: NodePath_Final, visitSelf?: boolean): void;
|
|
3576
|
+
declare namespace traverse {
|
|
3577
|
+
var visitors: typeof __visitors_ts;
|
|
3578
|
+
var verify: typeof verify$1;
|
|
3579
|
+
var explode: typeof explode$1;
|
|
3580
|
+
var cheap: (node: t.Node, enter: (node: t.Node) => void) => void;
|
|
3581
|
+
var node: (node: t.Node, opts: ExplodedTraverseOptions<t.Node>, scope?: Scope, state?: any, path?: NodePath_Final, skipKeys?: Record<string, boolean>) => void;
|
|
3582
|
+
var clearNode: (node: t.Node, opts?: RemovePropertiesOptions) => void;
|
|
3583
|
+
var removeProperties: (tree: t.Node, opts?: RemovePropertiesOptions) => t.Node;
|
|
3584
|
+
var hasType: (tree: t.Node, type: "StringLiteral" | "NumericLiteral" | "JSXText" | "JSXIdentifier" | "AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression", denylistTypes?: string[]) => boolean;
|
|
3585
|
+
var cache: typeof __cache_ts;
|
|
3586
|
+
}
|
|
3587
|
+
|
|
3588
|
+
export { Binding, type ExplodedTraverseOptions, type ExplodedVisitor, Hub, type HubInterface, NodePath_Final as NodePath, Scope, type TraverseOptions, type Visitor, type VisitorBase, traverse as default, __visitors_ts as visitors };
|