@putout/plugin-putout 7.2.0 → 7.6.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.
|
@@ -4,5 +4,10 @@ module.exports.report = () => 'Test operator should be destructured';
|
|
|
4
4
|
|
|
5
5
|
module.exports.replace = () => ({
|
|
6
6
|
'async (t) => {await t.process(__args)}': 'async ({process}) => {await process(__args)}',
|
|
7
|
+
'async (t) => {await t.noProcess(__args)}': 'async ({noProcess}) => {await noProcess(__args)}',
|
|
7
8
|
'async (t) => {await t.comparePlaces(__args)}': 'async ({comparePlaces}) => {await comparePlaces(__args)}',
|
|
9
|
+
|
|
10
|
+
'async (t) => {await t.process(__args); t.end();}': 'async ({process}) => {await process(__args)}',
|
|
11
|
+
'async (t) => {await t.noProcess(__args); t.end();}': 'async ({noProcess}) => {await noProcess(__args)}',
|
|
12
|
+
'async (t) => {await t.comparePlaces(__args); t.end();}': 'async ({comparePlaces}) => {await comparePlaces(__args)}',
|
|
8
13
|
});
|
|
@@ -1,14 +1,11 @@
|
|
|
1
1
|
'use strict';
|
|
2
2
|
|
|
3
|
-
const {template} = require('putout');
|
|
4
|
-
const lazyAST = (a) => () => template.ast.fresh(a);
|
|
5
3
|
const types = require('./types');
|
|
4
|
+
const operator = require('./operator');
|
|
6
5
|
|
|
7
6
|
module.exports = {
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
traverse: lazyAST(`const {traverse} = operator`),
|
|
11
|
-
operator: lazyAST(`import {operator} from 'putout'`),
|
|
7
|
+
template: `const {template} = require('putout')`,
|
|
8
|
+
...operator,
|
|
12
9
|
...types,
|
|
13
10
|
};
|
|
14
11
|
|
|
@@ -0,0 +1,10 @@
|
|
|
1
|
+
'use strict';
|
|
2
|
+
|
|
3
|
+
module.exports = {
|
|
4
|
+
operator: `import {operator} from 'putout'`,
|
|
5
|
+
compare: `const {compare} = operator`,
|
|
6
|
+
contains: `const {contains} = operator`,
|
|
7
|
+
traverse: `const {traverse} = operator`,
|
|
8
|
+
getTemplateValues: `const {getTemplateValues} = operator`,
|
|
9
|
+
};
|
|
10
|
+
|
|
@@ -0,0 +1,638 @@
|
|
|
1
|
+
{
|
|
2
|
+
"types": "import {types} from 'putout'",
|
|
3
|
+
"is": "const {is} = types",
|
|
4
|
+
"isBinding": "const {isBinding} = types",
|
|
5
|
+
"isBlockScoped": "const {isBlockScoped} = types",
|
|
6
|
+
"isImmutable": "const {isImmutable} = types",
|
|
7
|
+
"isLet": "const {isLet} = types",
|
|
8
|
+
"isNode": "const {isNode} = types",
|
|
9
|
+
"isNodesEquivalent": "const {isNodesEquivalent} = types",
|
|
10
|
+
"isPlaceholderType": "const {isPlaceholderType} = types",
|
|
11
|
+
"isReferenced": "const {isReferenced} = types",
|
|
12
|
+
"isScope": "const {isScope} = types",
|
|
13
|
+
"isSpecifierDefault": "const {isSpecifierDefault} = types",
|
|
14
|
+
"isType": "const {isType} = types",
|
|
15
|
+
"isValidES3Identifier": "const {isValidES3Identifier} = types",
|
|
16
|
+
"isValidIdentifier": "const {isValidIdentifier} = types",
|
|
17
|
+
"isVar": "const {isVar} = types",
|
|
18
|
+
"ArrayExpression": "const {ArrayExpression} = types",
|
|
19
|
+
"AssignmentExpression": "const {AssignmentExpression} = types",
|
|
20
|
+
"BinaryExpression": "const {BinaryExpression} = types",
|
|
21
|
+
"InterpreterDirective": "const {InterpreterDirective} = types",
|
|
22
|
+
"Directive": "const {Directive} = types",
|
|
23
|
+
"DirectiveLiteral": "const {DirectiveLiteral} = types",
|
|
24
|
+
"BlockStatement": "const {BlockStatement} = types",
|
|
25
|
+
"BreakStatement": "const {BreakStatement} = types",
|
|
26
|
+
"CallExpression": "const {CallExpression} = types",
|
|
27
|
+
"CatchClause": "const {CatchClause} = types",
|
|
28
|
+
"ConditionalExpression": "const {ConditionalExpression} = types",
|
|
29
|
+
"ContinueStatement": "const {ContinueStatement} = types",
|
|
30
|
+
"DebuggerStatement": "const {DebuggerStatement} = types",
|
|
31
|
+
"DoWhileStatement": "const {DoWhileStatement} = types",
|
|
32
|
+
"EmptyStatement": "const {EmptyStatement} = types",
|
|
33
|
+
"ExpressionStatement": "const {ExpressionStatement} = types",
|
|
34
|
+
"File": "const {File} = types",
|
|
35
|
+
"ForInStatement": "const {ForInStatement} = types",
|
|
36
|
+
"ForStatement": "const {ForStatement} = types",
|
|
37
|
+
"FunctionDeclaration": "const {FunctionDeclaration} = types",
|
|
38
|
+
"FunctionExpression": "const {FunctionExpression} = types",
|
|
39
|
+
"Identifier": "const {Identifier} = types",
|
|
40
|
+
"IfStatement": "const {IfStatement} = types",
|
|
41
|
+
"LabeledStatement": "const {LabeledStatement} = types",
|
|
42
|
+
"StringLiteral": "const {StringLiteral} = types",
|
|
43
|
+
"NumericLiteral": "const {NumericLiteral} = types",
|
|
44
|
+
"NullLiteral": "const {NullLiteral} = types",
|
|
45
|
+
"BooleanLiteral": "const {BooleanLiteral} = types",
|
|
46
|
+
"RegExpLiteral": "const {RegExpLiteral} = types",
|
|
47
|
+
"LogicalExpression": "const {LogicalExpression} = types",
|
|
48
|
+
"MemberExpression": "const {MemberExpression} = types",
|
|
49
|
+
"NewExpression": "const {NewExpression} = types",
|
|
50
|
+
"Program": "const {Program} = types",
|
|
51
|
+
"ObjectExpression": "const {ObjectExpression} = types",
|
|
52
|
+
"ObjectMethod": "const {ObjectMethod} = types",
|
|
53
|
+
"ObjectProperty": "const {ObjectProperty} = types",
|
|
54
|
+
"RestElement": "const {RestElement} = types",
|
|
55
|
+
"ReturnStatement": "const {ReturnStatement} = types",
|
|
56
|
+
"SequenceExpression": "const {SequenceExpression} = types",
|
|
57
|
+
"ParenthesizedExpression": "const {ParenthesizedExpression} = types",
|
|
58
|
+
"SwitchCase": "const {SwitchCase} = types",
|
|
59
|
+
"SwitchStatement": "const {SwitchStatement} = types",
|
|
60
|
+
"ThisExpression": "const {ThisExpression} = types",
|
|
61
|
+
"ThrowStatement": "const {ThrowStatement} = types",
|
|
62
|
+
"TryStatement": "const {TryStatement} = types",
|
|
63
|
+
"UnaryExpression": "const {UnaryExpression} = types",
|
|
64
|
+
"UpdateExpression": "const {UpdateExpression} = types",
|
|
65
|
+
"VariableDeclaration": "const {VariableDeclaration} = types",
|
|
66
|
+
"VariableDeclarator": "const {VariableDeclarator} = types",
|
|
67
|
+
"WhileStatement": "const {WhileStatement} = types",
|
|
68
|
+
"WithStatement": "const {WithStatement} = types",
|
|
69
|
+
"AssignmentPattern": "const {AssignmentPattern} = types",
|
|
70
|
+
"ArrayPattern": "const {ArrayPattern} = types",
|
|
71
|
+
"ArrowFunctionExpression": "const {ArrowFunctionExpression} = types",
|
|
72
|
+
"ClassBody": "const {ClassBody} = types",
|
|
73
|
+
"ClassExpression": "const {ClassExpression} = types",
|
|
74
|
+
"ClassDeclaration": "const {ClassDeclaration} = types",
|
|
75
|
+
"ExportAllDeclaration": "const {ExportAllDeclaration} = types",
|
|
76
|
+
"ExportDefaultDeclaration": "const {ExportDefaultDeclaration} = types",
|
|
77
|
+
"ExportNamedDeclaration": "const {ExportNamedDeclaration} = types",
|
|
78
|
+
"ExportSpecifier": "const {ExportSpecifier} = types",
|
|
79
|
+
"ForOfStatement": "const {ForOfStatement} = types",
|
|
80
|
+
"ImportDeclaration": "const {ImportDeclaration} = types",
|
|
81
|
+
"ImportDefaultSpecifier": "const {ImportDefaultSpecifier} = types",
|
|
82
|
+
"ImportNamespaceSpecifier": "const {ImportNamespaceSpecifier} = types",
|
|
83
|
+
"ImportSpecifier": "const {ImportSpecifier} = types",
|
|
84
|
+
"MetaProperty": "const {MetaProperty} = types",
|
|
85
|
+
"ClassMethod": "const {ClassMethod} = types",
|
|
86
|
+
"ObjectPattern": "const {ObjectPattern} = types",
|
|
87
|
+
"SpreadElement": "const {SpreadElement} = types",
|
|
88
|
+
"Super": "const {Super} = types",
|
|
89
|
+
"TaggedTemplateExpression": "const {TaggedTemplateExpression} = types",
|
|
90
|
+
"TemplateElement": "const {TemplateElement} = types",
|
|
91
|
+
"TemplateLiteral": "const {TemplateLiteral} = types",
|
|
92
|
+
"YieldExpression": "const {YieldExpression} = types",
|
|
93
|
+
"AwaitExpression": "const {AwaitExpression} = types",
|
|
94
|
+
"Import": "const {Import} = types",
|
|
95
|
+
"BigIntLiteral": "const {BigIntLiteral} = types",
|
|
96
|
+
"ExportNamespaceSpecifier": "const {ExportNamespaceSpecifier} = types",
|
|
97
|
+
"OptionalMemberExpression": "const {OptionalMemberExpression} = types",
|
|
98
|
+
"OptionalCallExpression": "const {OptionalCallExpression} = types",
|
|
99
|
+
"ClassProperty": "const {ClassProperty} = types",
|
|
100
|
+
"ClassPrivateProperty": "const {ClassPrivateProperty} = types",
|
|
101
|
+
"ClassPrivateMethod": "const {ClassPrivateMethod} = types",
|
|
102
|
+
"PrivateName": "const {PrivateName} = types",
|
|
103
|
+
"AnyTypeAnnotation": "const {AnyTypeAnnotation} = types",
|
|
104
|
+
"ArrayTypeAnnotation": "const {ArrayTypeAnnotation} = types",
|
|
105
|
+
"BooleanTypeAnnotation": "const {BooleanTypeAnnotation} = types",
|
|
106
|
+
"BooleanLiteralTypeAnnotation": "const {BooleanLiteralTypeAnnotation} = types",
|
|
107
|
+
"NullLiteralTypeAnnotation": "const {NullLiteralTypeAnnotation} = types",
|
|
108
|
+
"ClassImplements": "const {ClassImplements} = types",
|
|
109
|
+
"DeclareClass": "const {DeclareClass} = types",
|
|
110
|
+
"DeclareFunction": "const {DeclareFunction} = types",
|
|
111
|
+
"DeclareInterface": "const {DeclareInterface} = types",
|
|
112
|
+
"DeclareModule": "const {DeclareModule} = types",
|
|
113
|
+
"DeclareModuleExports": "const {DeclareModuleExports} = types",
|
|
114
|
+
"DeclareTypeAlias": "const {DeclareTypeAlias} = types",
|
|
115
|
+
"DeclareOpaqueType": "const {DeclareOpaqueType} = types",
|
|
116
|
+
"DeclareVariable": "const {DeclareVariable} = types",
|
|
117
|
+
"DeclareExportDeclaration": "const {DeclareExportDeclaration} = types",
|
|
118
|
+
"DeclareExportAllDeclaration": "const {DeclareExportAllDeclaration} = types",
|
|
119
|
+
"DeclaredPredicate": "const {DeclaredPredicate} = types",
|
|
120
|
+
"ExistsTypeAnnotation": "const {ExistsTypeAnnotation} = types",
|
|
121
|
+
"FunctionTypeAnnotation": "const {FunctionTypeAnnotation} = types",
|
|
122
|
+
"FunctionTypeParam": "const {FunctionTypeParam} = types",
|
|
123
|
+
"GenericTypeAnnotation": "const {GenericTypeAnnotation} = types",
|
|
124
|
+
"InferredPredicate": "const {InferredPredicate} = types",
|
|
125
|
+
"InterfaceExtends": "const {InterfaceExtends} = types",
|
|
126
|
+
"InterfaceDeclaration": "const {InterfaceDeclaration} = types",
|
|
127
|
+
"InterfaceTypeAnnotation": "const {InterfaceTypeAnnotation} = types",
|
|
128
|
+
"IntersectionTypeAnnotation": "const {IntersectionTypeAnnotation} = types",
|
|
129
|
+
"MixedTypeAnnotation": "const {MixedTypeAnnotation} = types",
|
|
130
|
+
"EmptyTypeAnnotation": "const {EmptyTypeAnnotation} = types",
|
|
131
|
+
"NullableTypeAnnotation": "const {NullableTypeAnnotation} = types",
|
|
132
|
+
"NumberLiteralTypeAnnotation": "const {NumberLiteralTypeAnnotation} = types",
|
|
133
|
+
"NumberTypeAnnotation": "const {NumberTypeAnnotation} = types",
|
|
134
|
+
"ObjectTypeAnnotation": "const {ObjectTypeAnnotation} = types",
|
|
135
|
+
"ObjectTypeInternalSlot": "const {ObjectTypeInternalSlot} = types",
|
|
136
|
+
"ObjectTypeCallProperty": "const {ObjectTypeCallProperty} = types",
|
|
137
|
+
"ObjectTypeIndexer": "const {ObjectTypeIndexer} = types",
|
|
138
|
+
"ObjectTypeProperty": "const {ObjectTypeProperty} = types",
|
|
139
|
+
"ObjectTypeSpreadProperty": "const {ObjectTypeSpreadProperty} = types",
|
|
140
|
+
"OpaqueType": "const {OpaqueType} = types",
|
|
141
|
+
"QualifiedTypeIdentifier": "const {QualifiedTypeIdentifier} = types",
|
|
142
|
+
"StringLiteralTypeAnnotation": "const {StringLiteralTypeAnnotation} = types",
|
|
143
|
+
"StringTypeAnnotation": "const {StringTypeAnnotation} = types",
|
|
144
|
+
"SymbolTypeAnnotation": "const {SymbolTypeAnnotation} = types",
|
|
145
|
+
"ThisTypeAnnotation": "const {ThisTypeAnnotation} = types",
|
|
146
|
+
"TupleTypeAnnotation": "const {TupleTypeAnnotation} = types",
|
|
147
|
+
"TypeofTypeAnnotation": "const {TypeofTypeAnnotation} = types",
|
|
148
|
+
"TypeAlias": "const {TypeAlias} = types",
|
|
149
|
+
"TypeAnnotation": "const {TypeAnnotation} = types",
|
|
150
|
+
"TypeCastExpression": "const {TypeCastExpression} = types",
|
|
151
|
+
"TypeParameter": "const {TypeParameter} = types",
|
|
152
|
+
"TypeParameterDeclaration": "const {TypeParameterDeclaration} = types",
|
|
153
|
+
"TypeParameterInstantiation": "const {TypeParameterInstantiation} = types",
|
|
154
|
+
"UnionTypeAnnotation": "const {UnionTypeAnnotation} = types",
|
|
155
|
+
"Variance": "const {Variance} = types",
|
|
156
|
+
"VoidTypeAnnotation": "const {VoidTypeAnnotation} = types",
|
|
157
|
+
"EnumDeclaration": "const {EnumDeclaration} = types",
|
|
158
|
+
"EnumBooleanBody": "const {EnumBooleanBody} = types",
|
|
159
|
+
"EnumNumberBody": "const {EnumNumberBody} = types",
|
|
160
|
+
"EnumStringBody": "const {EnumStringBody} = types",
|
|
161
|
+
"EnumSymbolBody": "const {EnumSymbolBody} = types",
|
|
162
|
+
"EnumBooleanMember": "const {EnumBooleanMember} = types",
|
|
163
|
+
"EnumNumberMember": "const {EnumNumberMember} = types",
|
|
164
|
+
"EnumStringMember": "const {EnumStringMember} = types",
|
|
165
|
+
"EnumDefaultedMember": "const {EnumDefaultedMember} = types",
|
|
166
|
+
"IndexedAccessType": "const {IndexedAccessType} = types",
|
|
167
|
+
"OptionalIndexedAccessType": "const {OptionalIndexedAccessType} = types",
|
|
168
|
+
"JSXAttribute": "const {JSXAttribute} = types",
|
|
169
|
+
"JSXClosingElement": "const {JSXClosingElement} = types",
|
|
170
|
+
"JSXElement": "const {JSXElement} = types",
|
|
171
|
+
"JSXEmptyExpression": "const {JSXEmptyExpression} = types",
|
|
172
|
+
"JSXExpressionContainer": "const {JSXExpressionContainer} = types",
|
|
173
|
+
"JSXSpreadChild": "const {JSXSpreadChild} = types",
|
|
174
|
+
"JSXIdentifier": "const {JSXIdentifier} = types",
|
|
175
|
+
"JSXMemberExpression": "const {JSXMemberExpression} = types",
|
|
176
|
+
"JSXNamespacedName": "const {JSXNamespacedName} = types",
|
|
177
|
+
"JSXOpeningElement": "const {JSXOpeningElement} = types",
|
|
178
|
+
"JSXSpreadAttribute": "const {JSXSpreadAttribute} = types",
|
|
179
|
+
"JSXText": "const {JSXText} = types",
|
|
180
|
+
"JSXFragment": "const {JSXFragment} = types",
|
|
181
|
+
"JSXOpeningFragment": "const {JSXOpeningFragment} = types",
|
|
182
|
+
"JSXClosingFragment": "const {JSXClosingFragment} = types",
|
|
183
|
+
"Noop": "const {Noop} = types",
|
|
184
|
+
"Placeholder": "const {Placeholder} = types",
|
|
185
|
+
"V8IntrinsicIdentifier": "const {V8IntrinsicIdentifier} = types",
|
|
186
|
+
"ArgumentPlaceholder": "const {ArgumentPlaceholder} = types",
|
|
187
|
+
"BindExpression": "const {BindExpression} = types",
|
|
188
|
+
"ImportAttribute": "const {ImportAttribute} = types",
|
|
189
|
+
"Decorator": "const {Decorator} = types",
|
|
190
|
+
"DoExpression": "const {DoExpression} = types",
|
|
191
|
+
"ExportDefaultSpecifier": "const {ExportDefaultSpecifier} = types",
|
|
192
|
+
"RecordExpression": "const {RecordExpression} = types",
|
|
193
|
+
"TupleExpression": "const {TupleExpression} = types",
|
|
194
|
+
"DecimalLiteral": "const {DecimalLiteral} = types",
|
|
195
|
+
"StaticBlock": "const {StaticBlock} = types",
|
|
196
|
+
"ModuleExpression": "const {ModuleExpression} = types",
|
|
197
|
+
"TopicReference": "const {TopicReference} = types",
|
|
198
|
+
"PipelineTopicExpression": "const {PipelineTopicExpression} = types",
|
|
199
|
+
"PipelineBareFunction": "const {PipelineBareFunction} = types",
|
|
200
|
+
"PipelinePrimaryTopicReference": "const {PipelinePrimaryTopicReference} = types",
|
|
201
|
+
"TSParameterProperty": "const {TSParameterProperty} = types",
|
|
202
|
+
"TSDeclareFunction": "const {TSDeclareFunction} = types",
|
|
203
|
+
"TSDeclareMethod": "const {TSDeclareMethod} = types",
|
|
204
|
+
"TSQualifiedName": "const {TSQualifiedName} = types",
|
|
205
|
+
"TSCallSignatureDeclaration": "const {TSCallSignatureDeclaration} = types",
|
|
206
|
+
"TSConstructSignatureDeclaration": "const {TSConstructSignatureDeclaration} = types",
|
|
207
|
+
"TSPropertySignature": "const {TSPropertySignature} = types",
|
|
208
|
+
"TSMethodSignature": "const {TSMethodSignature} = types",
|
|
209
|
+
"TSIndexSignature": "const {TSIndexSignature} = types",
|
|
210
|
+
"TSAnyKeyword": "const {TSAnyKeyword} = types",
|
|
211
|
+
"TSBooleanKeyword": "const {TSBooleanKeyword} = types",
|
|
212
|
+
"TSBigIntKeyword": "const {TSBigIntKeyword} = types",
|
|
213
|
+
"TSIntrinsicKeyword": "const {TSIntrinsicKeyword} = types",
|
|
214
|
+
"TSNeverKeyword": "const {TSNeverKeyword} = types",
|
|
215
|
+
"TSNullKeyword": "const {TSNullKeyword} = types",
|
|
216
|
+
"TSNumberKeyword": "const {TSNumberKeyword} = types",
|
|
217
|
+
"TSObjectKeyword": "const {TSObjectKeyword} = types",
|
|
218
|
+
"TSStringKeyword": "const {TSStringKeyword} = types",
|
|
219
|
+
"TSSymbolKeyword": "const {TSSymbolKeyword} = types",
|
|
220
|
+
"TSUndefinedKeyword": "const {TSUndefinedKeyword} = types",
|
|
221
|
+
"TSUnknownKeyword": "const {TSUnknownKeyword} = types",
|
|
222
|
+
"TSVoidKeyword": "const {TSVoidKeyword} = types",
|
|
223
|
+
"TSThisType": "const {TSThisType} = types",
|
|
224
|
+
"TSFunctionType": "const {TSFunctionType} = types",
|
|
225
|
+
"TSConstructorType": "const {TSConstructorType} = types",
|
|
226
|
+
"TSTypeReference": "const {TSTypeReference} = types",
|
|
227
|
+
"TSTypePredicate": "const {TSTypePredicate} = types",
|
|
228
|
+
"TSTypeQuery": "const {TSTypeQuery} = types",
|
|
229
|
+
"TSTypeLiteral": "const {TSTypeLiteral} = types",
|
|
230
|
+
"TSArrayType": "const {TSArrayType} = types",
|
|
231
|
+
"TSTupleType": "const {TSTupleType} = types",
|
|
232
|
+
"TSOptionalType": "const {TSOptionalType} = types",
|
|
233
|
+
"TSRestType": "const {TSRestType} = types",
|
|
234
|
+
"TSNamedTupleMember": "const {TSNamedTupleMember} = types",
|
|
235
|
+
"TSUnionType": "const {TSUnionType} = types",
|
|
236
|
+
"TSIntersectionType": "const {TSIntersectionType} = types",
|
|
237
|
+
"TSConditionalType": "const {TSConditionalType} = types",
|
|
238
|
+
"TSInferType": "const {TSInferType} = types",
|
|
239
|
+
"TSParenthesizedType": "const {TSParenthesizedType} = types",
|
|
240
|
+
"TSTypeOperator": "const {TSTypeOperator} = types",
|
|
241
|
+
"TSIndexedAccessType": "const {TSIndexedAccessType} = types",
|
|
242
|
+
"TSMappedType": "const {TSMappedType} = types",
|
|
243
|
+
"TSLiteralType": "const {TSLiteralType} = types",
|
|
244
|
+
"TSExpressionWithTypeArguments": "const {TSExpressionWithTypeArguments} = types",
|
|
245
|
+
"TSInterfaceDeclaration": "const {TSInterfaceDeclaration} = types",
|
|
246
|
+
"TSInterfaceBody": "const {TSInterfaceBody} = types",
|
|
247
|
+
"TSTypeAliasDeclaration": "const {TSTypeAliasDeclaration} = types",
|
|
248
|
+
"TSAsExpression": "const {TSAsExpression} = types",
|
|
249
|
+
"TSTypeAssertion": "const {TSTypeAssertion} = types",
|
|
250
|
+
"TSEnumDeclaration": "const {TSEnumDeclaration} = types",
|
|
251
|
+
"TSEnumMember": "const {TSEnumMember} = types",
|
|
252
|
+
"TSModuleDeclaration": "const {TSModuleDeclaration} = types",
|
|
253
|
+
"TSModuleBlock": "const {TSModuleBlock} = types",
|
|
254
|
+
"TSImportType": "const {TSImportType} = types",
|
|
255
|
+
"TSImportEqualsDeclaration": "const {TSImportEqualsDeclaration} = types",
|
|
256
|
+
"TSExternalModuleReference": "const {TSExternalModuleReference} = types",
|
|
257
|
+
"TSNonNullExpression": "const {TSNonNullExpression} = types",
|
|
258
|
+
"TSExportAssignment": "const {TSExportAssignment} = types",
|
|
259
|
+
"TSNamespaceExportDeclaration": "const {TSNamespaceExportDeclaration} = types",
|
|
260
|
+
"TSTypeAnnotation": "const {TSTypeAnnotation} = types",
|
|
261
|
+
"TSTypeParameterInstantiation": "const {TSTypeParameterInstantiation} = types",
|
|
262
|
+
"TSTypeParameterDeclaration": "const {TSTypeParameterDeclaration} = types",
|
|
263
|
+
"TSTypeParameter": "const {TSTypeParameter} = types",
|
|
264
|
+
"NumberLiteral": "const {NumberLiteral} = types",
|
|
265
|
+
"RegexLiteral": "const {RegexLiteral} = types",
|
|
266
|
+
"RestProperty": "const {RestProperty} = types",
|
|
267
|
+
"SpreadProperty": "const {SpreadProperty} = types",
|
|
268
|
+
"EXPRESSION_TYPES": "const {EXPRESSION_TYPES} = types",
|
|
269
|
+
"BINARY_TYPES": "const {BINARY_TYPES} = types",
|
|
270
|
+
"SCOPABLE_TYPES": "const {SCOPABLE_TYPES} = types",
|
|
271
|
+
"BLOCKPARENT_TYPES": "const {BLOCKPARENT_TYPES} = types",
|
|
272
|
+
"BLOCK_TYPES": "const {BLOCK_TYPES} = types",
|
|
273
|
+
"STATEMENT_TYPES": "const {STATEMENT_TYPES} = types",
|
|
274
|
+
"TERMINATORLESS_TYPES": "const {TERMINATORLESS_TYPES} = types",
|
|
275
|
+
"COMPLETIONSTATEMENT_TYPES": "const {COMPLETIONSTATEMENT_TYPES} = types",
|
|
276
|
+
"CONDITIONAL_TYPES": "const {CONDITIONAL_TYPES} = types",
|
|
277
|
+
"LOOP_TYPES": "const {LOOP_TYPES} = types",
|
|
278
|
+
"WHILE_TYPES": "const {WHILE_TYPES} = types",
|
|
279
|
+
"EXPRESSIONWRAPPER_TYPES": "const {EXPRESSIONWRAPPER_TYPES} = types",
|
|
280
|
+
"FOR_TYPES": "const {FOR_TYPES} = types",
|
|
281
|
+
"FORXSTATEMENT_TYPES": "const {FORXSTATEMENT_TYPES} = types",
|
|
282
|
+
"FUNCTION_TYPES": "const {FUNCTION_TYPES} = types",
|
|
283
|
+
"FUNCTIONPARENT_TYPES": "const {FUNCTIONPARENT_TYPES} = types",
|
|
284
|
+
"PUREISH_TYPES": "const {PUREISH_TYPES} = types",
|
|
285
|
+
"DECLARATION_TYPES": "const {DECLARATION_TYPES} = types",
|
|
286
|
+
"PATTERNLIKE_TYPES": "const {PATTERNLIKE_TYPES} = types",
|
|
287
|
+
"LVAL_TYPES": "const {LVAL_TYPES} = types",
|
|
288
|
+
"TSENTITYNAME_TYPES": "const {TSENTITYNAME_TYPES} = types",
|
|
289
|
+
"LITERAL_TYPES": "const {LITERAL_TYPES} = types",
|
|
290
|
+
"IMMUTABLE_TYPES": "const {IMMUTABLE_TYPES} = types",
|
|
291
|
+
"USERWHITESPACABLE_TYPES": "const {USERWHITESPACABLE_TYPES} = types",
|
|
292
|
+
"METHOD_TYPES": "const {METHOD_TYPES} = types",
|
|
293
|
+
"OBJECTMEMBER_TYPES": "const {OBJECTMEMBER_TYPES} = types",
|
|
294
|
+
"PROPERTY_TYPES": "const {PROPERTY_TYPES} = types",
|
|
295
|
+
"UNARYLIKE_TYPES": "const {UNARYLIKE_TYPES} = types",
|
|
296
|
+
"PATTERN_TYPES": "const {PATTERN_TYPES} = types",
|
|
297
|
+
"CLASS_TYPES": "const {CLASS_TYPES} = types",
|
|
298
|
+
"MODULEDECLARATION_TYPES": "const {MODULEDECLARATION_TYPES} = types",
|
|
299
|
+
"EXPORTDECLARATION_TYPES": "const {EXPORTDECLARATION_TYPES} = types",
|
|
300
|
+
"MODULESPECIFIER_TYPES": "const {MODULESPECIFIER_TYPES} = types",
|
|
301
|
+
"PRIVATE_TYPES": "const {PRIVATE_TYPES} = types",
|
|
302
|
+
"FLOW_TYPES": "const {FLOW_TYPES} = types",
|
|
303
|
+
"FLOWTYPE_TYPES": "const {FLOWTYPE_TYPES} = types",
|
|
304
|
+
"FLOWBASEANNOTATION_TYPES": "const {FLOWBASEANNOTATION_TYPES} = types",
|
|
305
|
+
"FLOWDECLARATION_TYPES": "const {FLOWDECLARATION_TYPES} = types",
|
|
306
|
+
"FLOWPREDICATE_TYPES": "const {FLOWPREDICATE_TYPES} = types",
|
|
307
|
+
"ENUMBODY_TYPES": "const {ENUMBODY_TYPES} = types",
|
|
308
|
+
"ENUMMEMBER_TYPES": "const {ENUMMEMBER_TYPES} = types",
|
|
309
|
+
"JSX_TYPES": "const {JSX_TYPES} = types",
|
|
310
|
+
"TSTYPEELEMENT_TYPES": "const {TSTYPEELEMENT_TYPES} = types",
|
|
311
|
+
"TSTYPE_TYPES": "const {TSTYPE_TYPES} = types",
|
|
312
|
+
"TSBASETYPE_TYPES": "const {TSBASETYPE_TYPES} = types",
|
|
313
|
+
"STATEMENT_OR_BLOCK_KEYS": "const {STATEMENT_OR_BLOCK_KEYS} = types",
|
|
314
|
+
"FLATTENABLE_KEYS": "const {FLATTENABLE_KEYS} = types",
|
|
315
|
+
"FOR_INIT_KEYS": "const {FOR_INIT_KEYS} = types",
|
|
316
|
+
"COMMENT_KEYS": "const {COMMENT_KEYS} = types",
|
|
317
|
+
"LOGICAL_OPERATORS": "const {LOGICAL_OPERATORS} = types",
|
|
318
|
+
"UPDATE_OPERATORS": "const {UPDATE_OPERATORS} = types",
|
|
319
|
+
"BOOLEAN_NUMBER_BINARY_OPERATORS": "const {BOOLEAN_NUMBER_BINARY_OPERATORS} = types",
|
|
320
|
+
"EQUALITY_BINARY_OPERATORS": "const {EQUALITY_BINARY_OPERATORS} = types",
|
|
321
|
+
"COMPARISON_BINARY_OPERATORS": "const {COMPARISON_BINARY_OPERATORS} = types",
|
|
322
|
+
"BOOLEAN_BINARY_OPERATORS": "const {BOOLEAN_BINARY_OPERATORS} = types",
|
|
323
|
+
"NUMBER_BINARY_OPERATORS": "const {NUMBER_BINARY_OPERATORS} = types",
|
|
324
|
+
"BINARY_OPERATORS": "const {BINARY_OPERATORS} = types",
|
|
325
|
+
"ASSIGNMENT_OPERATORS": "const {ASSIGNMENT_OPERATORS} = types",
|
|
326
|
+
"BOOLEAN_UNARY_OPERATORS": "const {BOOLEAN_UNARY_OPERATORS} = types",
|
|
327
|
+
"NUMBER_UNARY_OPERATORS": "const {NUMBER_UNARY_OPERATORS} = types",
|
|
328
|
+
"STRING_UNARY_OPERATORS": "const {STRING_UNARY_OPERATORS} = types",
|
|
329
|
+
"UNARY_OPERATORS": "const {UNARY_OPERATORS} = types",
|
|
330
|
+
"INHERIT_KEYS": "const {INHERIT_KEYS} = types",
|
|
331
|
+
"BLOCK_SCOPED_SYMBOL": "const {BLOCK_SCOPED_SYMBOL} = types",
|
|
332
|
+
"NOT_LOCAL_BINDING": "const {NOT_LOCAL_BINDING} = types",
|
|
333
|
+
"VISITOR_KEYS": "const {VISITOR_KEYS} = types",
|
|
334
|
+
"ALIAS_KEYS": "const {ALIAS_KEYS} = types",
|
|
335
|
+
"FLIPPED_ALIAS_KEYS": "const {FLIPPED_ALIAS_KEYS} = types",
|
|
336
|
+
"NODE_FIELDS": "const {NODE_FIELDS} = types",
|
|
337
|
+
"BUILDER_KEYS": "const {BUILDER_KEYS} = types",
|
|
338
|
+
"DEPRECATED_KEYS": "const {DEPRECATED_KEYS} = types",
|
|
339
|
+
"NODE_PARENT_VALIDATIONS": "const {NODE_PARENT_VALIDATIONS} = types",
|
|
340
|
+
"PLACEHOLDERS": "const {PLACEHOLDERS} = types",
|
|
341
|
+
"PLACEHOLDERS_ALIAS": "const {PLACEHOLDERS_ALIAS} = types",
|
|
342
|
+
"PLACEHOLDERS_FLIPPED_ALIAS": "const {PLACEHOLDERS_FLIPPED_ALIAS} = types",
|
|
343
|
+
"TYPES": "const {TYPES} = types",
|
|
344
|
+
"isArrayExpression": "const {isArrayExpression} = types",
|
|
345
|
+
"isAssignmentExpression": "const {isAssignmentExpression} = types",
|
|
346
|
+
"isBinaryExpression": "const {isBinaryExpression} = types",
|
|
347
|
+
"isInterpreterDirective": "const {isInterpreterDirective} = types",
|
|
348
|
+
"isDirective": "const {isDirective} = types",
|
|
349
|
+
"isDirectiveLiteral": "const {isDirectiveLiteral} = types",
|
|
350
|
+
"isBlockStatement": "const {isBlockStatement} = types",
|
|
351
|
+
"isBreakStatement": "const {isBreakStatement} = types",
|
|
352
|
+
"isCallExpression": "const {isCallExpression} = types",
|
|
353
|
+
"isCatchClause": "const {isCatchClause} = types",
|
|
354
|
+
"isConditionalExpression": "const {isConditionalExpression} = types",
|
|
355
|
+
"isContinueStatement": "const {isContinueStatement} = types",
|
|
356
|
+
"isDebuggerStatement": "const {isDebuggerStatement} = types",
|
|
357
|
+
"isDoWhileStatement": "const {isDoWhileStatement} = types",
|
|
358
|
+
"isEmptyStatement": "const {isEmptyStatement} = types",
|
|
359
|
+
"isExpressionStatement": "const {isExpressionStatement} = types",
|
|
360
|
+
"isFile": "const {isFile} = types",
|
|
361
|
+
"isForInStatement": "const {isForInStatement} = types",
|
|
362
|
+
"isForStatement": "const {isForStatement} = types",
|
|
363
|
+
"isFunctionDeclaration": "const {isFunctionDeclaration} = types",
|
|
364
|
+
"isFunctionExpression": "const {isFunctionExpression} = types",
|
|
365
|
+
"isIdentifier": "const {isIdentifier} = types",
|
|
366
|
+
"isIfStatement": "const {isIfStatement} = types",
|
|
367
|
+
"isLabeledStatement": "const {isLabeledStatement} = types",
|
|
368
|
+
"isStringLiteral": "const {isStringLiteral} = types",
|
|
369
|
+
"isNumericLiteral": "const {isNumericLiteral} = types",
|
|
370
|
+
"isNullLiteral": "const {isNullLiteral} = types",
|
|
371
|
+
"isBooleanLiteral": "const {isBooleanLiteral} = types",
|
|
372
|
+
"isRegExpLiteral": "const {isRegExpLiteral} = types",
|
|
373
|
+
"isLogicalExpression": "const {isLogicalExpression} = types",
|
|
374
|
+
"isMemberExpression": "const {isMemberExpression} = types",
|
|
375
|
+
"isNewExpression": "const {isNewExpression} = types",
|
|
376
|
+
"isProgram": "const {isProgram} = types",
|
|
377
|
+
"isObjectExpression": "const {isObjectExpression} = types",
|
|
378
|
+
"isObjectMethod": "const {isObjectMethod} = types",
|
|
379
|
+
"isObjectProperty": "const {isObjectProperty} = types",
|
|
380
|
+
"isRestElement": "const {isRestElement} = types",
|
|
381
|
+
"isReturnStatement": "const {isReturnStatement} = types",
|
|
382
|
+
"isSequenceExpression": "const {isSequenceExpression} = types",
|
|
383
|
+
"isParenthesizedExpression": "const {isParenthesizedExpression} = types",
|
|
384
|
+
"isSwitchCase": "const {isSwitchCase} = types",
|
|
385
|
+
"isSwitchStatement": "const {isSwitchStatement} = types",
|
|
386
|
+
"isThisExpression": "const {isThisExpression} = types",
|
|
387
|
+
"isThrowStatement": "const {isThrowStatement} = types",
|
|
388
|
+
"isTryStatement": "const {isTryStatement} = types",
|
|
389
|
+
"isUnaryExpression": "const {isUnaryExpression} = types",
|
|
390
|
+
"isUpdateExpression": "const {isUpdateExpression} = types",
|
|
391
|
+
"isVariableDeclaration": "const {isVariableDeclaration} = types",
|
|
392
|
+
"isVariableDeclarator": "const {isVariableDeclarator} = types",
|
|
393
|
+
"isWhileStatement": "const {isWhileStatement} = types",
|
|
394
|
+
"isWithStatement": "const {isWithStatement} = types",
|
|
395
|
+
"isAssignmentPattern": "const {isAssignmentPattern} = types",
|
|
396
|
+
"isArrayPattern": "const {isArrayPattern} = types",
|
|
397
|
+
"isArrowFunctionExpression": "const {isArrowFunctionExpression} = types",
|
|
398
|
+
"isClassBody": "const {isClassBody} = types",
|
|
399
|
+
"isClassExpression": "const {isClassExpression} = types",
|
|
400
|
+
"isClassDeclaration": "const {isClassDeclaration} = types",
|
|
401
|
+
"isExportAllDeclaration": "const {isExportAllDeclaration} = types",
|
|
402
|
+
"isExportDefaultDeclaration": "const {isExportDefaultDeclaration} = types",
|
|
403
|
+
"isExportNamedDeclaration": "const {isExportNamedDeclaration} = types",
|
|
404
|
+
"isExportSpecifier": "const {isExportSpecifier} = types",
|
|
405
|
+
"isForOfStatement": "const {isForOfStatement} = types",
|
|
406
|
+
"isImportDeclaration": "const {isImportDeclaration} = types",
|
|
407
|
+
"isImportDefaultSpecifier": "const {isImportDefaultSpecifier} = types",
|
|
408
|
+
"isImportNamespaceSpecifier": "const {isImportNamespaceSpecifier} = types",
|
|
409
|
+
"isImportSpecifier": "const {isImportSpecifier} = types",
|
|
410
|
+
"isMetaProperty": "const {isMetaProperty} = types",
|
|
411
|
+
"isClassMethod": "const {isClassMethod} = types",
|
|
412
|
+
"isObjectPattern": "const {isObjectPattern} = types",
|
|
413
|
+
"isSpreadElement": "const {isSpreadElement} = types",
|
|
414
|
+
"isSuper": "const {isSuper} = types",
|
|
415
|
+
"isTaggedTemplateExpression": "const {isTaggedTemplateExpression} = types",
|
|
416
|
+
"isTemplateElement": "const {isTemplateElement} = types",
|
|
417
|
+
"isTemplateLiteral": "const {isTemplateLiteral} = types",
|
|
418
|
+
"isYieldExpression": "const {isYieldExpression} = types",
|
|
419
|
+
"isAwaitExpression": "const {isAwaitExpression} = types",
|
|
420
|
+
"isImport": "const {isImport} = types",
|
|
421
|
+
"isBigIntLiteral": "const {isBigIntLiteral} = types",
|
|
422
|
+
"isExportNamespaceSpecifier": "const {isExportNamespaceSpecifier} = types",
|
|
423
|
+
"isOptionalMemberExpression": "const {isOptionalMemberExpression} = types",
|
|
424
|
+
"isOptionalCallExpression": "const {isOptionalCallExpression} = types",
|
|
425
|
+
"isClassProperty": "const {isClassProperty} = types",
|
|
426
|
+
"isClassPrivateProperty": "const {isClassPrivateProperty} = types",
|
|
427
|
+
"isClassPrivateMethod": "const {isClassPrivateMethod} = types",
|
|
428
|
+
"isPrivateName": "const {isPrivateName} = types",
|
|
429
|
+
"isAnyTypeAnnotation": "const {isAnyTypeAnnotation} = types",
|
|
430
|
+
"isArrayTypeAnnotation": "const {isArrayTypeAnnotation} = types",
|
|
431
|
+
"isBooleanTypeAnnotation": "const {isBooleanTypeAnnotation} = types",
|
|
432
|
+
"isBooleanLiteralTypeAnnotation": "const {isBooleanLiteralTypeAnnotation} = types",
|
|
433
|
+
"isNullLiteralTypeAnnotation": "const {isNullLiteralTypeAnnotation} = types",
|
|
434
|
+
"isClassImplements": "const {isClassImplements} = types",
|
|
435
|
+
"isDeclareClass": "const {isDeclareClass} = types",
|
|
436
|
+
"isDeclareFunction": "const {isDeclareFunction} = types",
|
|
437
|
+
"isDeclareInterface": "const {isDeclareInterface} = types",
|
|
438
|
+
"isDeclareModule": "const {isDeclareModule} = types",
|
|
439
|
+
"isDeclareModuleExports": "const {isDeclareModuleExports} = types",
|
|
440
|
+
"isDeclareTypeAlias": "const {isDeclareTypeAlias} = types",
|
|
441
|
+
"isDeclareOpaqueType": "const {isDeclareOpaqueType} = types",
|
|
442
|
+
"isDeclareVariable": "const {isDeclareVariable} = types",
|
|
443
|
+
"isDeclareExportDeclaration": "const {isDeclareExportDeclaration} = types",
|
|
444
|
+
"isDeclareExportAllDeclaration": "const {isDeclareExportAllDeclaration} = types",
|
|
445
|
+
"isDeclaredPredicate": "const {isDeclaredPredicate} = types",
|
|
446
|
+
"isExistsTypeAnnotation": "const {isExistsTypeAnnotation} = types",
|
|
447
|
+
"isFunctionTypeAnnotation": "const {isFunctionTypeAnnotation} = types",
|
|
448
|
+
"isFunctionTypeParam": "const {isFunctionTypeParam} = types",
|
|
449
|
+
"isGenericTypeAnnotation": "const {isGenericTypeAnnotation} = types",
|
|
450
|
+
"isInferredPredicate": "const {isInferredPredicate} = types",
|
|
451
|
+
"isInterfaceExtends": "const {isInterfaceExtends} = types",
|
|
452
|
+
"isInterfaceDeclaration": "const {isInterfaceDeclaration} = types",
|
|
453
|
+
"isInterfaceTypeAnnotation": "const {isInterfaceTypeAnnotation} = types",
|
|
454
|
+
"isIntersectionTypeAnnotation": "const {isIntersectionTypeAnnotation} = types",
|
|
455
|
+
"isMixedTypeAnnotation": "const {isMixedTypeAnnotation} = types",
|
|
456
|
+
"isEmptyTypeAnnotation": "const {isEmptyTypeAnnotation} = types",
|
|
457
|
+
"isNullableTypeAnnotation": "const {isNullableTypeAnnotation} = types",
|
|
458
|
+
"isNumberLiteralTypeAnnotation": "const {isNumberLiteralTypeAnnotation} = types",
|
|
459
|
+
"isNumberTypeAnnotation": "const {isNumberTypeAnnotation} = types",
|
|
460
|
+
"isObjectTypeAnnotation": "const {isObjectTypeAnnotation} = types",
|
|
461
|
+
"isObjectTypeInternalSlot": "const {isObjectTypeInternalSlot} = types",
|
|
462
|
+
"isObjectTypeCallProperty": "const {isObjectTypeCallProperty} = types",
|
|
463
|
+
"isObjectTypeIndexer": "const {isObjectTypeIndexer} = types",
|
|
464
|
+
"isObjectTypeProperty": "const {isObjectTypeProperty} = types",
|
|
465
|
+
"isObjectTypeSpreadProperty": "const {isObjectTypeSpreadProperty} = types",
|
|
466
|
+
"isOpaqueType": "const {isOpaqueType} = types",
|
|
467
|
+
"isQualifiedTypeIdentifier": "const {isQualifiedTypeIdentifier} = types",
|
|
468
|
+
"isStringLiteralTypeAnnotation": "const {isStringLiteralTypeAnnotation} = types",
|
|
469
|
+
"isStringTypeAnnotation": "const {isStringTypeAnnotation} = types",
|
|
470
|
+
"isSymbolTypeAnnotation": "const {isSymbolTypeAnnotation} = types",
|
|
471
|
+
"isThisTypeAnnotation": "const {isThisTypeAnnotation} = types",
|
|
472
|
+
"isTupleTypeAnnotation": "const {isTupleTypeAnnotation} = types",
|
|
473
|
+
"isTypeofTypeAnnotation": "const {isTypeofTypeAnnotation} = types",
|
|
474
|
+
"isTypeAlias": "const {isTypeAlias} = types",
|
|
475
|
+
"isTypeAnnotation": "const {isTypeAnnotation} = types",
|
|
476
|
+
"isTypeCastExpression": "const {isTypeCastExpression} = types",
|
|
477
|
+
"isTypeParameter": "const {isTypeParameter} = types",
|
|
478
|
+
"isTypeParameterDeclaration": "const {isTypeParameterDeclaration} = types",
|
|
479
|
+
"isTypeParameterInstantiation": "const {isTypeParameterInstantiation} = types",
|
|
480
|
+
"isUnionTypeAnnotation": "const {isUnionTypeAnnotation} = types",
|
|
481
|
+
"isVariance": "const {isVariance} = types",
|
|
482
|
+
"isVoidTypeAnnotation": "const {isVoidTypeAnnotation} = types",
|
|
483
|
+
"isEnumDeclaration": "const {isEnumDeclaration} = types",
|
|
484
|
+
"isEnumBooleanBody": "const {isEnumBooleanBody} = types",
|
|
485
|
+
"isEnumNumberBody": "const {isEnumNumberBody} = types",
|
|
486
|
+
"isEnumStringBody": "const {isEnumStringBody} = types",
|
|
487
|
+
"isEnumSymbolBody": "const {isEnumSymbolBody} = types",
|
|
488
|
+
"isEnumBooleanMember": "const {isEnumBooleanMember} = types",
|
|
489
|
+
"isEnumNumberMember": "const {isEnumNumberMember} = types",
|
|
490
|
+
"isEnumStringMember": "const {isEnumStringMember} = types",
|
|
491
|
+
"isEnumDefaultedMember": "const {isEnumDefaultedMember} = types",
|
|
492
|
+
"isIndexedAccessType": "const {isIndexedAccessType} = types",
|
|
493
|
+
"isOptionalIndexedAccessType": "const {isOptionalIndexedAccessType} = types",
|
|
494
|
+
"isJSXAttribute": "const {isJSXAttribute} = types",
|
|
495
|
+
"isJSXClosingElement": "const {isJSXClosingElement} = types",
|
|
496
|
+
"isJSXElement": "const {isJSXElement} = types",
|
|
497
|
+
"isJSXEmptyExpression": "const {isJSXEmptyExpression} = types",
|
|
498
|
+
"isJSXExpressionContainer": "const {isJSXExpressionContainer} = types",
|
|
499
|
+
"isJSXSpreadChild": "const {isJSXSpreadChild} = types",
|
|
500
|
+
"isJSXIdentifier": "const {isJSXIdentifier} = types",
|
|
501
|
+
"isJSXMemberExpression": "const {isJSXMemberExpression} = types",
|
|
502
|
+
"isJSXNamespacedName": "const {isJSXNamespacedName} = types",
|
|
503
|
+
"isJSXOpeningElement": "const {isJSXOpeningElement} = types",
|
|
504
|
+
"isJSXSpreadAttribute": "const {isJSXSpreadAttribute} = types",
|
|
505
|
+
"isJSXText": "const {isJSXText} = types",
|
|
506
|
+
"isJSXFragment": "const {isJSXFragment} = types",
|
|
507
|
+
"isJSXOpeningFragment": "const {isJSXOpeningFragment} = types",
|
|
508
|
+
"isJSXClosingFragment": "const {isJSXClosingFragment} = types",
|
|
509
|
+
"isNoop": "const {isNoop} = types",
|
|
510
|
+
"isPlaceholder": "const {isPlaceholder} = types",
|
|
511
|
+
"isV8IntrinsicIdentifier": "const {isV8IntrinsicIdentifier} = types",
|
|
512
|
+
"isArgumentPlaceholder": "const {isArgumentPlaceholder} = types",
|
|
513
|
+
"isBindExpression": "const {isBindExpression} = types",
|
|
514
|
+
"isImportAttribute": "const {isImportAttribute} = types",
|
|
515
|
+
"isDecorator": "const {isDecorator} = types",
|
|
516
|
+
"isDoExpression": "const {isDoExpression} = types",
|
|
517
|
+
"isExportDefaultSpecifier": "const {isExportDefaultSpecifier} = types",
|
|
518
|
+
"isRecordExpression": "const {isRecordExpression} = types",
|
|
519
|
+
"isTupleExpression": "const {isTupleExpression} = types",
|
|
520
|
+
"isDecimalLiteral": "const {isDecimalLiteral} = types",
|
|
521
|
+
"isStaticBlock": "const {isStaticBlock} = types",
|
|
522
|
+
"isModuleExpression": "const {isModuleExpression} = types",
|
|
523
|
+
"isTopicReference": "const {isTopicReference} = types",
|
|
524
|
+
"isPipelineTopicExpression": "const {isPipelineTopicExpression} = types",
|
|
525
|
+
"isPipelineBareFunction": "const {isPipelineBareFunction} = types",
|
|
526
|
+
"isPipelinePrimaryTopicReference": "const {isPipelinePrimaryTopicReference} = types",
|
|
527
|
+
"isTSParameterProperty": "const {isTSParameterProperty} = types",
|
|
528
|
+
"isTSDeclareFunction": "const {isTSDeclareFunction} = types",
|
|
529
|
+
"isTSDeclareMethod": "const {isTSDeclareMethod} = types",
|
|
530
|
+
"isTSQualifiedName": "const {isTSQualifiedName} = types",
|
|
531
|
+
"isTSCallSignatureDeclaration": "const {isTSCallSignatureDeclaration} = types",
|
|
532
|
+
"isTSConstructSignatureDeclaration": "const {isTSConstructSignatureDeclaration} = types",
|
|
533
|
+
"isTSPropertySignature": "const {isTSPropertySignature} = types",
|
|
534
|
+
"isTSMethodSignature": "const {isTSMethodSignature} = types",
|
|
535
|
+
"isTSIndexSignature": "const {isTSIndexSignature} = types",
|
|
536
|
+
"isTSAnyKeyword": "const {isTSAnyKeyword} = types",
|
|
537
|
+
"isTSBooleanKeyword": "const {isTSBooleanKeyword} = types",
|
|
538
|
+
"isTSBigIntKeyword": "const {isTSBigIntKeyword} = types",
|
|
539
|
+
"isTSIntrinsicKeyword": "const {isTSIntrinsicKeyword} = types",
|
|
540
|
+
"isTSNeverKeyword": "const {isTSNeverKeyword} = types",
|
|
541
|
+
"isTSNullKeyword": "const {isTSNullKeyword} = types",
|
|
542
|
+
"isTSNumberKeyword": "const {isTSNumberKeyword} = types",
|
|
543
|
+
"isTSObjectKeyword": "const {isTSObjectKeyword} = types",
|
|
544
|
+
"isTSStringKeyword": "const {isTSStringKeyword} = types",
|
|
545
|
+
"isTSSymbolKeyword": "const {isTSSymbolKeyword} = types",
|
|
546
|
+
"isTSUndefinedKeyword": "const {isTSUndefinedKeyword} = types",
|
|
547
|
+
"isTSUnknownKeyword": "const {isTSUnknownKeyword} = types",
|
|
548
|
+
"isTSVoidKeyword": "const {isTSVoidKeyword} = types",
|
|
549
|
+
"isTSThisType": "const {isTSThisType} = types",
|
|
550
|
+
"isTSFunctionType": "const {isTSFunctionType} = types",
|
|
551
|
+
"isTSConstructorType": "const {isTSConstructorType} = types",
|
|
552
|
+
"isTSTypeReference": "const {isTSTypeReference} = types",
|
|
553
|
+
"isTSTypePredicate": "const {isTSTypePredicate} = types",
|
|
554
|
+
"isTSTypeQuery": "const {isTSTypeQuery} = types",
|
|
555
|
+
"isTSTypeLiteral": "const {isTSTypeLiteral} = types",
|
|
556
|
+
"isTSArrayType": "const {isTSArrayType} = types",
|
|
557
|
+
"isTSTupleType": "const {isTSTupleType} = types",
|
|
558
|
+
"isTSOptionalType": "const {isTSOptionalType} = types",
|
|
559
|
+
"isTSRestType": "const {isTSRestType} = types",
|
|
560
|
+
"isTSNamedTupleMember": "const {isTSNamedTupleMember} = types",
|
|
561
|
+
"isTSUnionType": "const {isTSUnionType} = types",
|
|
562
|
+
"isTSIntersectionType": "const {isTSIntersectionType} = types",
|
|
563
|
+
"isTSConditionalType": "const {isTSConditionalType} = types",
|
|
564
|
+
"isTSInferType": "const {isTSInferType} = types",
|
|
565
|
+
"isTSParenthesizedType": "const {isTSParenthesizedType} = types",
|
|
566
|
+
"isTSTypeOperator": "const {isTSTypeOperator} = types",
|
|
567
|
+
"isTSIndexedAccessType": "const {isTSIndexedAccessType} = types",
|
|
568
|
+
"isTSMappedType": "const {isTSMappedType} = types",
|
|
569
|
+
"isTSLiteralType": "const {isTSLiteralType} = types",
|
|
570
|
+
"isTSExpressionWithTypeArguments": "const {isTSExpressionWithTypeArguments} = types",
|
|
571
|
+
"isTSInterfaceDeclaration": "const {isTSInterfaceDeclaration} = types",
|
|
572
|
+
"isTSInterfaceBody": "const {isTSInterfaceBody} = types",
|
|
573
|
+
"isTSTypeAliasDeclaration": "const {isTSTypeAliasDeclaration} = types",
|
|
574
|
+
"isTSAsExpression": "const {isTSAsExpression} = types",
|
|
575
|
+
"isTSTypeAssertion": "const {isTSTypeAssertion} = types",
|
|
576
|
+
"isTSEnumDeclaration": "const {isTSEnumDeclaration} = types",
|
|
577
|
+
"isTSEnumMember": "const {isTSEnumMember} = types",
|
|
578
|
+
"isTSModuleDeclaration": "const {isTSModuleDeclaration} = types",
|
|
579
|
+
"isTSModuleBlock": "const {isTSModuleBlock} = types",
|
|
580
|
+
"isTSImportType": "const {isTSImportType} = types",
|
|
581
|
+
"isTSImportEqualsDeclaration": "const {isTSImportEqualsDeclaration} = types",
|
|
582
|
+
"isTSExternalModuleReference": "const {isTSExternalModuleReference} = types",
|
|
583
|
+
"isTSNonNullExpression": "const {isTSNonNullExpression} = types",
|
|
584
|
+
"isTSExportAssignment": "const {isTSExportAssignment} = types",
|
|
585
|
+
"isTSNamespaceExportDeclaration": "const {isTSNamespaceExportDeclaration} = types",
|
|
586
|
+
"isTSTypeAnnotation": "const {isTSTypeAnnotation} = types",
|
|
587
|
+
"isTSTypeParameterInstantiation": "const {isTSTypeParameterInstantiation} = types",
|
|
588
|
+
"isTSTypeParameterDeclaration": "const {isTSTypeParameterDeclaration} = types",
|
|
589
|
+
"isTSTypeParameter": "const {isTSTypeParameter} = types",
|
|
590
|
+
"isExpression": "const {isExpression} = types",
|
|
591
|
+
"isBinary": "const {isBinary} = types",
|
|
592
|
+
"isScopable": "const {isScopable} = types",
|
|
593
|
+
"isBlockParent": "const {isBlockParent} = types",
|
|
594
|
+
"isBlock": "const {isBlock} = types",
|
|
595
|
+
"isStatement": "const {isStatement} = types",
|
|
596
|
+
"isTerminatorless": "const {isTerminatorless} = types",
|
|
597
|
+
"isCompletionStatement": "const {isCompletionStatement} = types",
|
|
598
|
+
"isConditional": "const {isConditional} = types",
|
|
599
|
+
"isLoop": "const {isLoop} = types",
|
|
600
|
+
"isWhile": "const {isWhile} = types",
|
|
601
|
+
"isExpressionWrapper": "const {isExpressionWrapper} = types",
|
|
602
|
+
"isFor": "const {isFor} = types",
|
|
603
|
+
"isForXStatement": "const {isForXStatement} = types",
|
|
604
|
+
"isFunction": "const {isFunction} = types",
|
|
605
|
+
"isFunctionParent": "const {isFunctionParent} = types",
|
|
606
|
+
"isPureish": "const {isPureish} = types",
|
|
607
|
+
"isDeclaration": "const {isDeclaration} = types",
|
|
608
|
+
"isPatternLike": "const {isPatternLike} = types",
|
|
609
|
+
"isLVal": "const {isLVal} = types",
|
|
610
|
+
"isTSEntityName": "const {isTSEntityName} = types",
|
|
611
|
+
"isLiteral": "const {isLiteral} = types",
|
|
612
|
+
"isUserWhitespacable": "const {isUserWhitespacable} = types",
|
|
613
|
+
"isMethod": "const {isMethod} = types",
|
|
614
|
+
"isObjectMember": "const {isObjectMember} = types",
|
|
615
|
+
"isProperty": "const {isProperty} = types",
|
|
616
|
+
"isUnaryLike": "const {isUnaryLike} = types",
|
|
617
|
+
"isPattern": "const {isPattern} = types",
|
|
618
|
+
"isClass": "const {isClass} = types",
|
|
619
|
+
"isModuleDeclaration": "const {isModuleDeclaration} = types",
|
|
620
|
+
"isExportDeclaration": "const {isExportDeclaration} = types",
|
|
621
|
+
"isModuleSpecifier": "const {isModuleSpecifier} = types",
|
|
622
|
+
"isPrivate": "const {isPrivate} = types",
|
|
623
|
+
"isFlow": "const {isFlow} = types",
|
|
624
|
+
"isFlowType": "const {isFlowType} = types",
|
|
625
|
+
"isFlowBaseAnnotation": "const {isFlowBaseAnnotation} = types",
|
|
626
|
+
"isFlowDeclaration": "const {isFlowDeclaration} = types",
|
|
627
|
+
"isFlowPredicate": "const {isFlowPredicate} = types",
|
|
628
|
+
"isEnumBody": "const {isEnumBody} = types",
|
|
629
|
+
"isEnumMember": "const {isEnumMember} = types",
|
|
630
|
+
"isJSX": "const {isJSX} = types",
|
|
631
|
+
"isTSTypeElement": "const {isTSTypeElement} = types",
|
|
632
|
+
"isTSType": "const {isTSType} = types",
|
|
633
|
+
"isTSBaseType": "const {isTSBaseType} = types",
|
|
634
|
+
"isNumberLiteral": "const {isNumberLiteral} = types",
|
|
635
|
+
"isRegexLiteral": "const {isRegexLiteral} = types",
|
|
636
|
+
"isRestProperty": "const {isRestProperty} = types",
|
|
637
|
+
"isSpreadProperty": "const {isSpreadProperty} = types"
|
|
638
|
+
}
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@putout/plugin-putout",
|
|
3
|
-
"version": "7.
|
|
3
|
+
"version": "7.6.0",
|
|
4
4
|
"author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
|
|
5
5
|
"description": "putout plugin helps with plugins development",
|
|
6
6
|
"homepage": "http://github.com/coderaiser/putout",
|
|
@@ -23,7 +23,7 @@
|
|
|
23
23
|
"report": "madrun report"
|
|
24
24
|
},
|
|
25
25
|
"dependencies": {
|
|
26
|
-
"@putout/plugin-declare-undefined-variables": "^
|
|
26
|
+
"@putout/plugin-declare-undefined-variables": "^4.0.0",
|
|
27
27
|
"fullstore": "^3.0.0",
|
|
28
28
|
"try-catch": "^3.0.0"
|
|
29
29
|
},
|
package/lib/declare/types.js
DELETED
|
@@ -1,17 +0,0 @@
|
|
|
1
|
-
'use strict';
|
|
2
|
-
|
|
3
|
-
const {template, types} = require('putout');
|
|
4
|
-
const lazyAST = (a) => () => template.ast.fresh(a);
|
|
5
|
-
const lazyASTDeclare = (a) => () => template.ast.fresh(`const {${a}} = types`);
|
|
6
|
-
|
|
7
|
-
const result = {
|
|
8
|
-
types: lazyAST(`import {types} from 'putout'`),
|
|
9
|
-
};
|
|
10
|
-
const {keys} = Object;
|
|
11
|
-
|
|
12
|
-
for (const name of keys(types)) {
|
|
13
|
-
if (/^is/.test(name))
|
|
14
|
-
result[name] = lazyASTDeclare(name);
|
|
15
|
-
}
|
|
16
|
-
|
|
17
|
-
module.exports = result;
|