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