@systemfsoftware/stryker-js-instrumenter 12.1.0 → 15.0.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/CHANGELOG.md +56 -0
- package/README.md +10 -8
- package/dist/index.d.mts +956 -914
- package/dist/index.mjs +752 -326
- package/package.json +24 -15
package/dist/index.d.mts
CHANGED
|
@@ -12,12 +12,16 @@ import "oxc-parser";
|
|
|
12
12
|
//#region src/ErrorText.schema.d.ts
|
|
13
13
|
declare const ErrorText_base: S.Class<ErrorText, S.Struct<{
|
|
14
14
|
readonly text: S.NonEmptyString;
|
|
15
|
-
}>, {
|
|
15
|
+
}>, {
|
|
16
|
+
readonly brand: unique symbol;
|
|
17
|
+
}>;
|
|
16
18
|
declare class ErrorText extends ErrorText_base {}
|
|
17
19
|
type ErrorTextValue = ErrorText;
|
|
18
20
|
declare const CauseText_base: S.Class<CauseText, S.Struct<{
|
|
19
21
|
readonly text: S.NonEmptyString;
|
|
20
|
-
}>, {
|
|
22
|
+
}>, {
|
|
23
|
+
readonly brand: unique symbol;
|
|
24
|
+
}>;
|
|
21
25
|
declare class CauseText extends CauseText_base {}
|
|
22
26
|
type CauseTextValue = CauseText;
|
|
23
27
|
interface ErrnoException extends Error {
|
|
@@ -35,186 +39,126 @@ declare namespace mod_d_exports {
|
|
|
35
39
|
}
|
|
36
40
|
//#endregion
|
|
37
41
|
//#region ../ignorers/interface/dist/index.d.ts
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
override?: boolean;
|
|
47
|
-
definite?: boolean;
|
|
48
|
-
accessibility?: TSAccessibility | null;
|
|
49
|
-
declare?: false;
|
|
50
|
-
optional?: false;
|
|
51
|
-
readonly?: false;
|
|
52
|
-
parent?: Node$1;
|
|
42
|
+
// Auto-generated code, DO NOT EDIT DIRECTLY!
|
|
43
|
+
// To edit this generated file you have to edit `tasks/ast_tools/src/generators/typescript.rs`.
|
|
44
|
+
interface Program$1 extends Span$1 {
|
|
45
|
+
type: "Program";
|
|
46
|
+
body: Array<Directive | Statement$1>;
|
|
47
|
+
sourceType: ModuleKind;
|
|
48
|
+
hashbang: Hashbang | null;
|
|
49
|
+
parent?: null;
|
|
53
50
|
}
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
type: "ArrayPattern";
|
|
51
|
+
type Expression$1 = BooleanLiteral$1 | NullLiteral$1 | NumericLiteral$1 | BigIntLiteral$1 | RegExpLiteral$1 | StringLiteral$1 | TemplateLiteral$1 | IdentifierReference$1 | Super$1 | ArrayExpression$1 | ArrowFunctionExpression$1 | AssignmentExpression$1 | AwaitExpression | BinaryExpression$1 | CallExpression$1 | ChainExpression$1 | Class$1 | ConditionalExpression$1 | Function$1 | ImportExpression$1 | LogicalExpression$1 | NewExpression$1 | ObjectExpression$1 | ParenthesizedExpression | SequenceExpression$1 | TaggedTemplateExpression$1 | ThisExpression$1 | UnaryExpression$1 | UpdateExpression$1 | YieldExpression$1 | PrivateInExpression$1 | MetaProperty$1 | JSXElement$1 | JSXFragment$1 | TSAsExpression$1 | TSSatisfiesExpression$1 | TSTypeAssertion$1 | TSNonNullExpression$1 | TSInstantiationExpression$1 | V8IntrinsicExpression | MemberExpression$1;
|
|
52
|
+
interface IdentifierName$1 extends Span$1 {
|
|
53
|
+
type: "Identifier";
|
|
58
54
|
decorators?: [];
|
|
59
|
-
|
|
55
|
+
name: string;
|
|
60
56
|
optional?: false;
|
|
61
57
|
typeAnnotation?: null;
|
|
62
58
|
parent?: Node$1;
|
|
63
59
|
}
|
|
64
|
-
|
|
65
|
-
type: "
|
|
66
|
-
elements: Array<ArrayExpressionElement>;
|
|
67
|
-
parent?: Node$1;
|
|
68
|
-
}
|
|
69
|
-
declare type ArrayExpressionElement = SpreadElement$1 | null | Expression$1;
|
|
70
|
-
declare interface ArrayPattern$1 extends Span$1 {
|
|
71
|
-
type: "ArrayPattern";
|
|
72
|
-
decorators?: [];
|
|
73
|
-
elements: Array<BindingPattern$1 | BindingRestElement$1 | null>;
|
|
74
|
-
optional?: false;
|
|
75
|
-
typeAnnotation?: TSTypeAnnotation$1 | null;
|
|
76
|
-
parent?: Node$1;
|
|
77
|
-
}
|
|
78
|
-
declare interface ArrowFunctionExpression$1 extends Span$1 {
|
|
79
|
-
type: "ArrowFunctionExpression";
|
|
80
|
-
expression: boolean;
|
|
81
|
-
async: boolean;
|
|
82
|
-
typeParameters?: TSTypeParameterDeclaration$1 | null;
|
|
83
|
-
params: ParamPattern$1[];
|
|
84
|
-
returnType?: TSTypeAnnotation$1 | null;
|
|
85
|
-
body: FunctionBody | Expression$1;
|
|
86
|
-
id: null;
|
|
87
|
-
generator: false;
|
|
88
|
-
parent?: Node$1;
|
|
89
|
-
}
|
|
90
|
-
declare interface AssignmentExpression$1 extends Span$1 {
|
|
91
|
-
type: "AssignmentExpression";
|
|
92
|
-
operator: AssignmentOperator;
|
|
93
|
-
left: AssignmentTarget;
|
|
94
|
-
right: Expression$1;
|
|
95
|
-
parent?: Node$1;
|
|
96
|
-
}
|
|
97
|
-
declare type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??=";
|
|
98
|
-
declare interface AssignmentPattern$1 extends Span$1 {
|
|
99
|
-
type: "AssignmentPattern";
|
|
60
|
+
interface IdentifierReference$1 extends Span$1 {
|
|
61
|
+
type: "Identifier";
|
|
100
62
|
decorators?: [];
|
|
101
|
-
|
|
102
|
-
right: Expression$1;
|
|
63
|
+
name: string;
|
|
103
64
|
optional?: false;
|
|
104
65
|
typeAnnotation?: null;
|
|
105
66
|
parent?: Node$1;
|
|
106
67
|
}
|
|
107
|
-
|
|
108
|
-
|
|
109
|
-
declare type AssignmentTargetPattern = ArrayAssignmentTarget | ObjectAssignmentTarget;
|
|
110
|
-
declare type AssignmentTargetProperty = AssignmentTargetPropertyIdentifier | AssignmentTargetPropertyProperty;
|
|
111
|
-
declare interface AssignmentTargetPropertyIdentifier extends Span$1 {
|
|
112
|
-
type: "Property";
|
|
113
|
-
kind: "init";
|
|
114
|
-
key: IdentifierReference$1;
|
|
115
|
-
value: IdentifierReference$1 | AssignmentTargetWithDefault;
|
|
116
|
-
method: false;
|
|
117
|
-
shorthand: true;
|
|
118
|
-
computed: false;
|
|
119
|
-
optional?: false;
|
|
120
|
-
parent?: Node$1;
|
|
121
|
-
}
|
|
122
|
-
declare interface AssignmentTargetPropertyProperty extends Span$1 {
|
|
123
|
-
type: "Property";
|
|
124
|
-
kind: "init";
|
|
125
|
-
key: PropertyKey_2;
|
|
126
|
-
value: AssignmentTargetMaybeDefault;
|
|
127
|
-
method: false;
|
|
128
|
-
shorthand: false;
|
|
129
|
-
computed: boolean;
|
|
130
|
-
optional?: false;
|
|
131
|
-
parent?: Node$1;
|
|
132
|
-
}
|
|
133
|
-
declare interface AssignmentTargetRest extends Span$1 {
|
|
134
|
-
type: "RestElement";
|
|
68
|
+
interface BindingIdentifier$1 extends Span$1 {
|
|
69
|
+
type: "Identifier";
|
|
135
70
|
decorators?: [];
|
|
136
|
-
|
|
71
|
+
name: string;
|
|
137
72
|
optional?: false;
|
|
138
|
-
typeAnnotation?: null;
|
|
139
|
-
value?: null;
|
|
73
|
+
typeAnnotation?: TSTypeAnnotation$1 | null;
|
|
140
74
|
parent?: Node$1;
|
|
141
75
|
}
|
|
142
|
-
|
|
143
|
-
type: "
|
|
76
|
+
interface LabelIdentifier$1 extends Span$1 {
|
|
77
|
+
type: "Identifier";
|
|
144
78
|
decorators?: [];
|
|
145
|
-
|
|
146
|
-
right: Expression$1;
|
|
79
|
+
name: string;
|
|
147
80
|
optional?: false;
|
|
148
81
|
typeAnnotation?: null;
|
|
149
82
|
parent?: Node$1;
|
|
150
83
|
}
|
|
151
|
-
|
|
152
|
-
type: "
|
|
153
|
-
argument: Expression$1;
|
|
154
|
-
parent?: Node$1;
|
|
155
|
-
}
|
|
156
|
-
declare interface BigIntLiteral$1 extends Span$1 {
|
|
157
|
-
type: "Literal";
|
|
158
|
-
value: bigint;
|
|
159
|
-
raw: string | null;
|
|
160
|
-
bigint: string;
|
|
84
|
+
interface ThisExpression$1 extends Span$1 {
|
|
85
|
+
type: "ThisExpression";
|
|
161
86
|
parent?: Node$1;
|
|
162
87
|
}
|
|
163
|
-
|
|
164
|
-
type: "
|
|
165
|
-
|
|
166
|
-
operator: BinaryOperator;
|
|
167
|
-
right: Expression$1;
|
|
88
|
+
interface ArrayExpression$1 extends Span$1 {
|
|
89
|
+
type: "ArrayExpression";
|
|
90
|
+
elements: Array<ArrayExpressionElement>;
|
|
168
91
|
parent?: Node$1;
|
|
169
92
|
}
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
type: "
|
|
173
|
-
|
|
174
|
-
name: string;
|
|
175
|
-
optional?: false;
|
|
176
|
-
typeAnnotation?: TSTypeAnnotation$1 | null;
|
|
93
|
+
type ArrayExpressionElement = SpreadElement$1 | null | Expression$1;
|
|
94
|
+
interface ObjectExpression$1 extends Span$1 {
|
|
95
|
+
type: "ObjectExpression";
|
|
96
|
+
properties: Array<ObjectPropertyKind>;
|
|
177
97
|
parent?: Node$1;
|
|
178
98
|
}
|
|
179
|
-
|
|
180
|
-
|
|
99
|
+
type ObjectPropertyKind = ObjectProperty$1 | SpreadElement$1;
|
|
100
|
+
interface ObjectProperty$1 extends Span$1 {
|
|
181
101
|
type: "Property";
|
|
182
|
-
kind:
|
|
183
|
-
key:
|
|
184
|
-
value:
|
|
185
|
-
method:
|
|
102
|
+
kind: PropertyKind;
|
|
103
|
+
key: PropertyKey;
|
|
104
|
+
value: Expression$1;
|
|
105
|
+
method: boolean;
|
|
186
106
|
shorthand: boolean;
|
|
187
107
|
computed: boolean;
|
|
188
108
|
optional?: false;
|
|
189
109
|
parent?: Node$1;
|
|
190
110
|
}
|
|
191
|
-
|
|
192
|
-
|
|
193
|
-
|
|
194
|
-
|
|
195
|
-
|
|
196
|
-
|
|
197
|
-
value?: null;
|
|
111
|
+
type PropertyKey = IdentifierName$1 | PrivateIdentifier$1 | Expression$1;
|
|
112
|
+
type PropertyKind = "init" | "get" | "set";
|
|
113
|
+
interface TemplateLiteral$1 extends Span$1 {
|
|
114
|
+
type: "TemplateLiteral";
|
|
115
|
+
quasis: Array<TemplateElement$1>;
|
|
116
|
+
expressions: Array<Expression$1>;
|
|
198
117
|
parent?: Node$1;
|
|
199
118
|
}
|
|
200
|
-
|
|
201
|
-
type: "
|
|
202
|
-
|
|
119
|
+
interface TaggedTemplateExpression$1 extends Span$1 {
|
|
120
|
+
type: "TaggedTemplateExpression";
|
|
121
|
+
tag: Expression$1;
|
|
122
|
+
typeArguments?: TSTypeParameterInstantiation$1 | null;
|
|
123
|
+
quasi: TemplateLiteral$1;
|
|
203
124
|
parent?: Node$1;
|
|
204
125
|
}
|
|
205
|
-
|
|
206
|
-
type: "
|
|
207
|
-
value:
|
|
208
|
-
|
|
126
|
+
interface TemplateElement$1 extends Span$1 {
|
|
127
|
+
type: "TemplateElement";
|
|
128
|
+
value: TemplateElementValue;
|
|
129
|
+
tail: boolean;
|
|
209
130
|
parent?: Node$1;
|
|
210
131
|
}
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
132
|
+
interface TemplateElementValue {
|
|
133
|
+
raw: string;
|
|
134
|
+
cooked: string | null;
|
|
135
|
+
}
|
|
136
|
+
type MemberExpression$1 = ComputedMemberExpression | StaticMemberExpression$1 | PrivateFieldExpression;
|
|
137
|
+
interface ComputedMemberExpression extends Span$1 {
|
|
138
|
+
type: "MemberExpression";
|
|
139
|
+
object: Expression$1;
|
|
140
|
+
property: Expression$1;
|
|
141
|
+
optional: boolean;
|
|
142
|
+
computed: true;
|
|
143
|
+
parent?: Node$1;
|
|
144
|
+
}
|
|
145
|
+
interface StaticMemberExpression$1 extends Span$1 {
|
|
146
|
+
type: "MemberExpression";
|
|
147
|
+
object: Expression$1;
|
|
148
|
+
property: IdentifierName$1;
|
|
149
|
+
optional: boolean;
|
|
150
|
+
computed: false;
|
|
151
|
+
parent?: Node$1;
|
|
152
|
+
}
|
|
153
|
+
interface PrivateFieldExpression extends Span$1 {
|
|
154
|
+
type: "MemberExpression";
|
|
155
|
+
object: Expression$1;
|
|
156
|
+
property: PrivateIdentifier$1;
|
|
157
|
+
optional: boolean;
|
|
158
|
+
computed: false;
|
|
214
159
|
parent?: Node$1;
|
|
215
160
|
}
|
|
216
|
-
|
|
217
|
-
declare interface CallExpression$1 extends Span$1 {
|
|
161
|
+
interface CallExpression$1 extends Span$1 {
|
|
218
162
|
type: "CallExpression";
|
|
219
163
|
callee: Expression$1;
|
|
220
164
|
typeArguments?: TSTypeParameterInstantiation$1 | null;
|
|
@@ -222,395 +166,438 @@ declare interface CallExpression$1 extends Span$1 {
|
|
|
222
166
|
optional: boolean;
|
|
223
167
|
parent?: Node$1;
|
|
224
168
|
}
|
|
225
|
-
|
|
226
|
-
type: "
|
|
227
|
-
|
|
228
|
-
|
|
169
|
+
interface NewExpression$1 extends Span$1 {
|
|
170
|
+
type: "NewExpression";
|
|
171
|
+
callee: Expression$1;
|
|
172
|
+
typeArguments?: TSTypeParameterInstantiation$1 | null;
|
|
173
|
+
arguments: Array<Argument$1>;
|
|
229
174
|
parent?: Node$1;
|
|
230
175
|
}
|
|
231
|
-
|
|
232
|
-
|
|
233
|
-
|
|
234
|
-
|
|
176
|
+
interface MetaProperty$1 extends Span$1 {
|
|
177
|
+
type: "MetaProperty";
|
|
178
|
+
meta: IdentifierName$1;
|
|
179
|
+
property: IdentifierName$1;
|
|
235
180
|
parent?: Node$1;
|
|
236
181
|
}
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
|
|
240
|
-
decorators: Array<Decorator$1>;
|
|
241
|
-
id: BindingIdentifier$1 | null;
|
|
242
|
-
typeParameters?: TSTypeParameterDeclaration$1 | null;
|
|
243
|
-
superClass: Expression$1 | null;
|
|
244
|
-
superTypeArguments?: TSTypeParameterInstantiation$1 | null;
|
|
245
|
-
implements?: Array<TSClassImplements>;
|
|
246
|
-
body: ClassBody$1;
|
|
247
|
-
abstract?: boolean;
|
|
248
|
-
declare?: boolean;
|
|
182
|
+
interface SpreadElement$1 extends Span$1 {
|
|
183
|
+
type: "SpreadElement";
|
|
184
|
+
argument: Expression$1;
|
|
249
185
|
parent?: Node$1;
|
|
250
186
|
}
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
|
|
187
|
+
type Argument$1 = SpreadElement$1 | Expression$1;
|
|
188
|
+
interface UpdateExpression$1 extends Span$1 {
|
|
189
|
+
type: "UpdateExpression";
|
|
190
|
+
operator: UpdateOperator;
|
|
191
|
+
prefix: boolean;
|
|
192
|
+
argument: SimpleAssignmentTarget$1;
|
|
254
193
|
parent?: Node$1;
|
|
255
194
|
}
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
|
|
259
|
-
|
|
260
|
-
|
|
261
|
-
|
|
262
|
-
|
|
263
|
-
|
|
195
|
+
interface UnaryExpression$1 extends Span$1 {
|
|
196
|
+
type: "UnaryExpression";
|
|
197
|
+
operator: UnaryOperator;
|
|
198
|
+
argument: Expression$1;
|
|
199
|
+
prefix: true;
|
|
200
|
+
parent?: Node$1;
|
|
201
|
+
}
|
|
202
|
+
interface BinaryExpression$1 extends Span$1 {
|
|
203
|
+
type: "BinaryExpression";
|
|
204
|
+
left: Expression$1;
|
|
205
|
+
operator: BinaryOperator;
|
|
206
|
+
right: Expression$1;
|
|
207
|
+
parent?: Node$1;
|
|
208
|
+
}
|
|
209
|
+
interface PrivateInExpression$1 extends Span$1 {
|
|
210
|
+
type: "BinaryExpression";
|
|
211
|
+
left: PrivateIdentifier$1;
|
|
212
|
+
operator: "in";
|
|
213
|
+
right: Expression$1;
|
|
214
|
+
parent?: Node$1;
|
|
215
|
+
}
|
|
216
|
+
interface LogicalExpression$1 extends Span$1 {
|
|
217
|
+
type: "LogicalExpression";
|
|
218
|
+
left: Expression$1;
|
|
219
|
+
operator: LogicalOperator;
|
|
220
|
+
right: Expression$1;
|
|
264
221
|
parent?: Node$1;
|
|
265
222
|
}
|
|
266
|
-
|
|
223
|
+
interface ConditionalExpression$1 extends Span$1 {
|
|
267
224
|
type: "ConditionalExpression";
|
|
268
225
|
test: Expression$1;
|
|
269
226
|
consequent: Expression$1;
|
|
270
227
|
alternate: Expression$1;
|
|
271
228
|
parent?: Node$1;
|
|
272
229
|
}
|
|
273
|
-
|
|
274
|
-
type: "
|
|
275
|
-
|
|
230
|
+
interface AssignmentExpression$1 extends Span$1 {
|
|
231
|
+
type: "AssignmentExpression";
|
|
232
|
+
operator: AssignmentOperator;
|
|
233
|
+
left: AssignmentTarget;
|
|
234
|
+
right: Expression$1;
|
|
276
235
|
parent?: Node$1;
|
|
277
236
|
}
|
|
278
|
-
|
|
279
|
-
|
|
237
|
+
type AssignmentTarget = SimpleAssignmentTarget$1 | AssignmentTargetPattern;
|
|
238
|
+
type SimpleAssignmentTarget$1 = IdentifierReference$1 | TSAsExpression$1 | TSSatisfiesExpression$1 | TSNonNullExpression$1 | TSTypeAssertion$1 | MemberExpression$1;
|
|
239
|
+
type AssignmentTargetPattern = ArrayAssignmentTarget | ObjectAssignmentTarget;
|
|
240
|
+
interface ArrayAssignmentTarget extends Span$1 {
|
|
241
|
+
type: "ArrayPattern";
|
|
242
|
+
decorators?: [];
|
|
243
|
+
elements: Array<AssignmentTargetMaybeDefault | AssignmentTargetRest | null>;
|
|
244
|
+
optional?: false;
|
|
245
|
+
typeAnnotation?: null;
|
|
280
246
|
parent?: Node$1;
|
|
281
247
|
}
|
|
282
|
-
|
|
283
|
-
|
|
284
|
-
|
|
285
|
-
|
|
248
|
+
interface ObjectAssignmentTarget extends Span$1 {
|
|
249
|
+
type: "ObjectPattern";
|
|
250
|
+
decorators?: [];
|
|
251
|
+
properties: Array<AssignmentTargetProperty | AssignmentTargetRest>;
|
|
252
|
+
optional?: false;
|
|
253
|
+
typeAnnotation?: null;
|
|
286
254
|
parent?: Node$1;
|
|
287
255
|
}
|
|
288
|
-
|
|
289
|
-
type: "
|
|
290
|
-
|
|
291
|
-
|
|
256
|
+
interface AssignmentTargetRest extends Span$1 {
|
|
257
|
+
type: "RestElement";
|
|
258
|
+
decorators?: [];
|
|
259
|
+
argument: AssignmentTarget;
|
|
260
|
+
optional?: false;
|
|
261
|
+
typeAnnotation?: null;
|
|
262
|
+
value?: null;
|
|
292
263
|
parent?: Node$1;
|
|
293
264
|
}
|
|
294
|
-
|
|
295
|
-
|
|
296
|
-
|
|
297
|
-
|
|
265
|
+
type AssignmentTargetMaybeDefault = AssignmentTargetWithDefault | AssignmentTarget;
|
|
266
|
+
interface AssignmentTargetWithDefault extends Span$1 {
|
|
267
|
+
type: "AssignmentPattern";
|
|
268
|
+
decorators?: [];
|
|
269
|
+
left: AssignmentTarget;
|
|
270
|
+
right: Expression$1;
|
|
271
|
+
optional?: false;
|
|
272
|
+
typeAnnotation?: null;
|
|
298
273
|
parent?: Node$1;
|
|
299
274
|
}
|
|
300
|
-
|
|
301
|
-
|
|
275
|
+
type AssignmentTargetProperty = AssignmentTargetPropertyIdentifier | AssignmentTargetPropertyProperty;
|
|
276
|
+
interface AssignmentTargetPropertyIdentifier extends Span$1 {
|
|
277
|
+
type: "Property";
|
|
278
|
+
kind: "init";
|
|
279
|
+
key: IdentifierReference$1;
|
|
280
|
+
value: IdentifierReference$1 | AssignmentTargetWithDefault;
|
|
281
|
+
method: false;
|
|
282
|
+
shorthand: true;
|
|
283
|
+
computed: false;
|
|
284
|
+
optional?: false;
|
|
302
285
|
parent?: Node$1;
|
|
303
286
|
}
|
|
304
|
-
|
|
305
|
-
type: "
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
|
|
287
|
+
interface AssignmentTargetPropertyProperty extends Span$1 {
|
|
288
|
+
type: "Property";
|
|
289
|
+
kind: "init";
|
|
290
|
+
key: PropertyKey;
|
|
291
|
+
value: AssignmentTargetMaybeDefault;
|
|
292
|
+
method: false;
|
|
293
|
+
shorthand: false;
|
|
294
|
+
computed: boolean;
|
|
295
|
+
optional?: false;
|
|
310
296
|
parent?: Node$1;
|
|
311
297
|
}
|
|
312
|
-
|
|
313
|
-
type: "
|
|
314
|
-
|
|
315
|
-
exportKind?: "value";
|
|
298
|
+
interface SequenceExpression$1 extends Span$1 {
|
|
299
|
+
type: "SequenceExpression";
|
|
300
|
+
expressions: Array<Expression$1>;
|
|
316
301
|
parent?: Node$1;
|
|
317
302
|
}
|
|
318
|
-
|
|
319
|
-
|
|
320
|
-
type: "ExportNamedDeclaration";
|
|
321
|
-
declaration: Declaration | null;
|
|
322
|
-
specifiers: Array<ExportSpecifier>;
|
|
323
|
-
source: StringLiteral$1 | null;
|
|
324
|
-
exportKind?: ImportOrExportKind;
|
|
325
|
-
attributes: Array<ImportAttribute$1>;
|
|
303
|
+
interface Super$1 extends Span$1 {
|
|
304
|
+
type: "Super";
|
|
326
305
|
parent?: Node$1;
|
|
327
306
|
}
|
|
328
|
-
|
|
329
|
-
type: "
|
|
330
|
-
|
|
331
|
-
exported: ModuleExportName;
|
|
332
|
-
exportKind?: ImportOrExportKind;
|
|
307
|
+
interface AwaitExpression extends Span$1 {
|
|
308
|
+
type: "AwaitExpression";
|
|
309
|
+
argument: Expression$1;
|
|
333
310
|
parent?: Node$1;
|
|
334
311
|
}
|
|
335
|
-
|
|
336
|
-
|
|
337
|
-
|
|
338
|
-
expression: Expression$1;
|
|
339
|
-
directive?: string | null;
|
|
312
|
+
interface ChainExpression$1 extends Span$1 {
|
|
313
|
+
type: "ChainExpression";
|
|
314
|
+
expression: ChainElement;
|
|
340
315
|
parent?: Node$1;
|
|
341
316
|
}
|
|
342
|
-
|
|
343
|
-
|
|
344
|
-
|
|
345
|
-
|
|
346
|
-
body: Statement$1;
|
|
317
|
+
type ChainElement = CallExpression$1 | TSNonNullExpression$1 | MemberExpression$1;
|
|
318
|
+
interface ParenthesizedExpression extends Span$1 {
|
|
319
|
+
type: "ParenthesizedExpression";
|
|
320
|
+
expression: Expression$1;
|
|
347
321
|
parent?: Node$1;
|
|
348
322
|
}
|
|
349
|
-
|
|
350
|
-
|
|
351
|
-
|
|
352
|
-
|
|
353
|
-
|
|
354
|
-
argument: BindingPattern$1;
|
|
355
|
-
decorators?: Array<Decorator$1>;
|
|
356
|
-
optional?: boolean;
|
|
357
|
-
typeAnnotation?: TSTypeAnnotation$1 | null;
|
|
358
|
-
value?: null;
|
|
323
|
+
type Statement$1 = BlockStatement$1 | BreakStatement$1 | ContinueStatement$1 | DebuggerStatement | DoWhileStatement$1 | EmptyStatement$1 | ExpressionStatement$1 | ForInStatement$1 | ForOfStatement$1 | ForStatement$1 | IfStatement$1 | LabeledStatement$1 | ReturnStatement$1 | SwitchStatement$1 | ThrowStatement$1 | TryStatement$1 | WhileStatement$1 | WithStatement$1 | Declaration | ModuleDeclaration;
|
|
324
|
+
interface Directive extends Span$1 {
|
|
325
|
+
type: "ExpressionStatement";
|
|
326
|
+
expression: StringLiteral$1;
|
|
327
|
+
directive: string;
|
|
359
328
|
parent?: Node$1;
|
|
360
329
|
}
|
|
361
|
-
|
|
362
|
-
type: "
|
|
363
|
-
|
|
364
|
-
left: ForStatementLeft;
|
|
365
|
-
right: Expression$1;
|
|
366
|
-
body: Statement$1;
|
|
330
|
+
interface Hashbang extends Span$1 {
|
|
331
|
+
type: "Hashbang";
|
|
332
|
+
value: string;
|
|
367
333
|
parent?: Node$1;
|
|
368
334
|
}
|
|
369
|
-
|
|
370
|
-
type: "
|
|
371
|
-
|
|
372
|
-
test: Expression$1 | null;
|
|
373
|
-
update: Expression$1 | null;
|
|
374
|
-
body: Statement$1;
|
|
335
|
+
interface BlockStatement$1 extends Span$1 {
|
|
336
|
+
type: "BlockStatement";
|
|
337
|
+
body: Array<Statement$1>;
|
|
375
338
|
parent?: Node$1;
|
|
376
339
|
}
|
|
377
|
-
|
|
378
|
-
|
|
379
|
-
|
|
380
|
-
|
|
381
|
-
|
|
382
|
-
generator: boolean;
|
|
383
|
-
async: boolean;
|
|
340
|
+
type Declaration = VariableDeclaration$1 | Function$1 | Class$1 | TSTypeAliasDeclaration$1 | TSInterfaceDeclaration$1 | TSEnumDeclaration$1 | TSModuleDeclaration$1 | TSGlobalDeclaration | TSImportEqualsDeclaration$1;
|
|
341
|
+
interface VariableDeclaration$1 extends Span$1 {
|
|
342
|
+
type: "VariableDeclaration";
|
|
343
|
+
kind: VariableDeclarationKind;
|
|
344
|
+
declarations: Array<VariableDeclarator$1>;
|
|
384
345
|
declare?: boolean;
|
|
385
|
-
typeParameters?: TSTypeParameterDeclaration$1 | null;
|
|
386
|
-
params: ParamPattern$1[];
|
|
387
|
-
returnType?: TSTypeAnnotation$1 | null;
|
|
388
|
-
body: FunctionBody | null;
|
|
389
|
-
expression: false;
|
|
390
346
|
parent?: Node$1;
|
|
391
347
|
}
|
|
392
|
-
|
|
393
|
-
|
|
394
|
-
|
|
395
|
-
|
|
396
|
-
|
|
397
|
-
|
|
398
|
-
declare interface Hashbang extends Span$1 {
|
|
399
|
-
type: "Hashbang";
|
|
400
|
-
value: string;
|
|
348
|
+
type VariableDeclarationKind = "var" | "let" | "const" | "using" | "await using";
|
|
349
|
+
interface VariableDeclarator$1 extends Span$1 {
|
|
350
|
+
type: "VariableDeclarator";
|
|
351
|
+
id: BindingPattern$1;
|
|
352
|
+
init: Expression$1 | null;
|
|
353
|
+
definite?: boolean;
|
|
401
354
|
parent?: Node$1;
|
|
402
355
|
}
|
|
403
|
-
|
|
404
|
-
type: "
|
|
405
|
-
decorators?: [];
|
|
406
|
-
name: string;
|
|
407
|
-
optional?: false;
|
|
408
|
-
typeAnnotation?: null;
|
|
356
|
+
interface EmptyStatement$1 extends Span$1 {
|
|
357
|
+
type: "EmptyStatement";
|
|
409
358
|
parent?: Node$1;
|
|
410
359
|
}
|
|
411
|
-
|
|
412
|
-
type: "
|
|
413
|
-
|
|
414
|
-
|
|
415
|
-
optional?: false;
|
|
416
|
-
typeAnnotation?: null;
|
|
360
|
+
interface ExpressionStatement$1 extends Span$1 {
|
|
361
|
+
type: "ExpressionStatement";
|
|
362
|
+
expression: Expression$1;
|
|
363
|
+
directive?: string | null;
|
|
417
364
|
parent?: Node$1;
|
|
418
365
|
}
|
|
419
|
-
|
|
366
|
+
interface IfStatement$1 extends Span$1 {
|
|
420
367
|
type: "IfStatement";
|
|
421
368
|
test: Expression$1;
|
|
422
369
|
consequent: Statement$1;
|
|
423
370
|
alternate: Statement$1 | null;
|
|
424
371
|
parent?: Node$1;
|
|
425
372
|
}
|
|
426
|
-
|
|
427
|
-
|
|
428
|
-
|
|
373
|
+
interface DoWhileStatement$1 extends Span$1 {
|
|
374
|
+
type: "DoWhileStatement";
|
|
375
|
+
body: Statement$1;
|
|
376
|
+
test: Expression$1;
|
|
377
|
+
parent?: Node$1;
|
|
429
378
|
}
|
|
430
|
-
|
|
431
|
-
type: "
|
|
432
|
-
|
|
433
|
-
|
|
379
|
+
interface WhileStatement$1 extends Span$1 {
|
|
380
|
+
type: "WhileStatement";
|
|
381
|
+
test: Expression$1;
|
|
382
|
+
body: Statement$1;
|
|
434
383
|
parent?: Node$1;
|
|
435
384
|
}
|
|
436
|
-
|
|
437
|
-
|
|
438
|
-
|
|
439
|
-
|
|
440
|
-
|
|
441
|
-
|
|
442
|
-
attributes: Array<ImportAttribute$1>;
|
|
443
|
-
importKind?: ImportOrExportKind;
|
|
385
|
+
interface ForStatement$1 extends Span$1 {
|
|
386
|
+
type: "ForStatement";
|
|
387
|
+
init: ForStatementInit | null;
|
|
388
|
+
test: Expression$1 | null;
|
|
389
|
+
update: Expression$1 | null;
|
|
390
|
+
body: Statement$1;
|
|
444
391
|
parent?: Node$1;
|
|
445
392
|
}
|
|
446
|
-
|
|
447
|
-
|
|
448
|
-
type: "
|
|
449
|
-
|
|
393
|
+
type ForStatementInit = VariableDeclaration$1 | Expression$1;
|
|
394
|
+
interface ForInStatement$1 extends Span$1 {
|
|
395
|
+
type: "ForInStatement";
|
|
396
|
+
left: ForStatementLeft;
|
|
397
|
+
right: Expression$1;
|
|
398
|
+
body: Statement$1;
|
|
450
399
|
parent?: Node$1;
|
|
451
400
|
}
|
|
452
|
-
|
|
453
|
-
|
|
454
|
-
|
|
455
|
-
|
|
456
|
-
|
|
401
|
+
type ForStatementLeft = VariableDeclaration$1 | AssignmentTarget;
|
|
402
|
+
interface ForOfStatement$1 extends Span$1 {
|
|
403
|
+
type: "ForOfStatement";
|
|
404
|
+
await: boolean;
|
|
405
|
+
left: ForStatementLeft;
|
|
406
|
+
right: Expression$1;
|
|
407
|
+
body: Statement$1;
|
|
457
408
|
parent?: Node$1;
|
|
458
409
|
}
|
|
459
|
-
|
|
460
|
-
type: "
|
|
461
|
-
|
|
410
|
+
interface ContinueStatement$1 extends Span$1 {
|
|
411
|
+
type: "ContinueStatement";
|
|
412
|
+
label: LabelIdentifier$1 | null;
|
|
462
413
|
parent?: Node$1;
|
|
463
414
|
}
|
|
464
|
-
|
|
465
|
-
|
|
466
|
-
|
|
467
|
-
type: "ImportSpecifier";
|
|
468
|
-
imported: ModuleExportName;
|
|
469
|
-
local: BindingIdentifier$1;
|
|
470
|
-
importKind?: ImportOrExportKind;
|
|
415
|
+
interface BreakStatement$1 extends Span$1 {
|
|
416
|
+
type: "BreakStatement";
|
|
417
|
+
label: LabelIdentifier$1 | null;
|
|
471
418
|
parent?: Node$1;
|
|
472
419
|
}
|
|
473
|
-
|
|
474
|
-
type: "
|
|
475
|
-
|
|
476
|
-
postfix: boolean;
|
|
420
|
+
interface ReturnStatement$1 extends Span$1 {
|
|
421
|
+
type: "ReturnStatement";
|
|
422
|
+
argument: Expression$1 | null;
|
|
477
423
|
parent?: Node$1;
|
|
478
424
|
}
|
|
479
|
-
|
|
480
|
-
type: "
|
|
481
|
-
|
|
482
|
-
|
|
425
|
+
interface WithStatement$1 extends Span$1 {
|
|
426
|
+
type: "WithStatement";
|
|
427
|
+
object: Expression$1;
|
|
428
|
+
body: Statement$1;
|
|
483
429
|
parent?: Node$1;
|
|
484
430
|
}
|
|
485
|
-
|
|
486
|
-
type: "
|
|
431
|
+
interface SwitchStatement$1 extends Span$1 {
|
|
432
|
+
type: "SwitchStatement";
|
|
433
|
+
discriminant: Expression$1;
|
|
434
|
+
cases: Array<SwitchCase$1>;
|
|
487
435
|
parent?: Node$1;
|
|
488
436
|
}
|
|
489
|
-
|
|
490
|
-
type: "
|
|
491
|
-
|
|
492
|
-
|
|
437
|
+
interface SwitchCase$1 extends Span$1 {
|
|
438
|
+
type: "SwitchCase";
|
|
439
|
+
test: Expression$1 | null;
|
|
440
|
+
consequent: Array<Statement$1>;
|
|
493
441
|
parent?: Node$1;
|
|
494
442
|
}
|
|
495
|
-
|
|
496
|
-
|
|
497
|
-
|
|
498
|
-
|
|
499
|
-
declare interface JSXClosingElement extends Span$1 {
|
|
500
|
-
type: "JSXClosingElement";
|
|
501
|
-
name: JSXElementName;
|
|
443
|
+
interface LabeledStatement$1 extends Span$1 {
|
|
444
|
+
type: "LabeledStatement";
|
|
445
|
+
label: LabelIdentifier$1;
|
|
446
|
+
body: Statement$1;
|
|
502
447
|
parent?: Node$1;
|
|
503
448
|
}
|
|
504
|
-
|
|
505
|
-
type: "
|
|
449
|
+
interface ThrowStatement$1 extends Span$1 {
|
|
450
|
+
type: "ThrowStatement";
|
|
451
|
+
argument: Expression$1;
|
|
506
452
|
parent?: Node$1;
|
|
507
453
|
}
|
|
508
|
-
|
|
509
|
-
type: "
|
|
510
|
-
|
|
511
|
-
|
|
512
|
-
|
|
454
|
+
interface TryStatement$1 extends Span$1 {
|
|
455
|
+
type: "TryStatement";
|
|
456
|
+
block: BlockStatement$1;
|
|
457
|
+
handler: CatchClause$1 | null;
|
|
458
|
+
finalizer: BlockStatement$1 | null;
|
|
513
459
|
parent?: Node$1;
|
|
514
460
|
}
|
|
515
|
-
|
|
516
|
-
|
|
517
|
-
|
|
461
|
+
interface CatchClause$1 extends Span$1 {
|
|
462
|
+
type: "CatchClause";
|
|
463
|
+
param: BindingPattern$1 | null;
|
|
464
|
+
body: BlockStatement$1;
|
|
518
465
|
parent?: Node$1;
|
|
519
466
|
}
|
|
520
|
-
|
|
521
|
-
|
|
522
|
-
type: "JSXExpressionContainer";
|
|
523
|
-
expression: JSXExpression;
|
|
467
|
+
interface DebuggerStatement extends Span$1 {
|
|
468
|
+
type: "DebuggerStatement";
|
|
524
469
|
parent?: Node$1;
|
|
525
470
|
}
|
|
526
|
-
|
|
527
|
-
|
|
528
|
-
|
|
529
|
-
|
|
530
|
-
|
|
471
|
+
type BindingPattern$1 = BindingIdentifier$1 | ObjectPattern | ArrayPattern$1 | AssignmentPattern$1;
|
|
472
|
+
interface AssignmentPattern$1 extends Span$1 {
|
|
473
|
+
type: "AssignmentPattern";
|
|
474
|
+
decorators?: [];
|
|
475
|
+
left: BindingPattern$1;
|
|
476
|
+
right: Expression$1;
|
|
477
|
+
optional?: false;
|
|
478
|
+
typeAnnotation?: null;
|
|
531
479
|
parent?: Node$1;
|
|
532
480
|
}
|
|
533
|
-
|
|
534
|
-
type: "
|
|
535
|
-
|
|
481
|
+
interface ObjectPattern extends Span$1 {
|
|
482
|
+
type: "ObjectPattern";
|
|
483
|
+
decorators?: [];
|
|
484
|
+
properties: Array<BindingProperty$1 | BindingRestElement$1>;
|
|
485
|
+
optional?: false;
|
|
486
|
+
typeAnnotation?: TSTypeAnnotation$1 | null;
|
|
536
487
|
parent?: Node$1;
|
|
537
488
|
}
|
|
538
|
-
|
|
539
|
-
type: "
|
|
540
|
-
|
|
541
|
-
|
|
489
|
+
interface BindingProperty$1 extends Span$1 {
|
|
490
|
+
type: "Property";
|
|
491
|
+
kind: "init";
|
|
492
|
+
key: PropertyKey;
|
|
493
|
+
value: BindingPattern$1;
|
|
494
|
+
method: false;
|
|
495
|
+
shorthand: boolean;
|
|
496
|
+
computed: boolean;
|
|
497
|
+
optional?: false;
|
|
542
498
|
parent?: Node$1;
|
|
543
499
|
}
|
|
544
|
-
|
|
545
|
-
|
|
546
|
-
|
|
547
|
-
|
|
548
|
-
|
|
500
|
+
interface ArrayPattern$1 extends Span$1 {
|
|
501
|
+
type: "ArrayPattern";
|
|
502
|
+
decorators?: [];
|
|
503
|
+
elements: Array<BindingPattern$1 | BindingRestElement$1 | null>;
|
|
504
|
+
optional?: false;
|
|
505
|
+
typeAnnotation?: TSTypeAnnotation$1 | null;
|
|
549
506
|
parent?: Node$1;
|
|
550
507
|
}
|
|
551
|
-
|
|
552
|
-
type: "
|
|
553
|
-
|
|
554
|
-
|
|
555
|
-
|
|
556
|
-
|
|
508
|
+
interface BindingRestElement$1 extends Span$1 {
|
|
509
|
+
type: "RestElement";
|
|
510
|
+
decorators?: [];
|
|
511
|
+
argument: BindingPattern$1;
|
|
512
|
+
optional?: false;
|
|
513
|
+
typeAnnotation?: TSTypeAnnotation$1 | null;
|
|
514
|
+
value?: null;
|
|
557
515
|
parent?: Node$1;
|
|
558
516
|
}
|
|
559
|
-
|
|
560
|
-
type:
|
|
561
|
-
|
|
562
|
-
|
|
517
|
+
interface Function$1 extends Span$1 {
|
|
518
|
+
type: FunctionType;
|
|
519
|
+
id: BindingIdentifier$1 | null;
|
|
520
|
+
generator: boolean;
|
|
521
|
+
async: boolean;
|
|
522
|
+
declare?: boolean;
|
|
523
|
+
typeParameters?: TSTypeParameterDeclaration$1 | null;
|
|
524
|
+
params: ParamPattern$1[];
|
|
525
|
+
returnType?: TSTypeAnnotation$1 | null;
|
|
526
|
+
body: FunctionBody | null;
|
|
527
|
+
expression: false;
|
|
563
528
|
parent?: Node$1;
|
|
564
529
|
}
|
|
565
|
-
|
|
566
|
-
|
|
567
|
-
|
|
530
|
+
type ParamPattern$1 = FormalParameter | TSParameterProperty | FormalParameterRest;
|
|
531
|
+
type FunctionType = "FunctionDeclaration" | "FunctionExpression" | "TSDeclareFunction" | "TSEmptyBodyFunctionExpression";
|
|
532
|
+
interface FormalParameterRest extends Span$1 {
|
|
533
|
+
type: "RestElement";
|
|
534
|
+
argument: BindingPattern$1;
|
|
535
|
+
decorators?: Array<Decorator$1>;
|
|
536
|
+
optional?: boolean;
|
|
537
|
+
typeAnnotation?: TSTypeAnnotation$1 | null;
|
|
538
|
+
value?: null;
|
|
568
539
|
parent?: Node$1;
|
|
569
540
|
}
|
|
570
|
-
|
|
571
|
-
|
|
572
|
-
|
|
541
|
+
type FormalParameter = {
|
|
542
|
+
decorators?: Array<Decorator$1>;
|
|
543
|
+
} & BindingPattern$1;
|
|
544
|
+
interface TSParameterProperty extends Span$1 {
|
|
545
|
+
type: "TSParameterProperty";
|
|
546
|
+
accessibility: TSAccessibility | null;
|
|
547
|
+
decorators: Array<Decorator$1>;
|
|
548
|
+
override: boolean;
|
|
549
|
+
parameter: FormalParameter;
|
|
550
|
+
readonly: boolean;
|
|
551
|
+
static: boolean;
|
|
573
552
|
parent?: Node$1;
|
|
574
553
|
}
|
|
575
|
-
|
|
576
|
-
type: "
|
|
577
|
-
|
|
578
|
-
raw: string | null;
|
|
554
|
+
interface FunctionBody extends Span$1 {
|
|
555
|
+
type: "BlockStatement";
|
|
556
|
+
body: Array<Directive | Statement$1>;
|
|
579
557
|
parent?: Node$1;
|
|
580
558
|
}
|
|
581
|
-
|
|
582
|
-
type: "
|
|
583
|
-
|
|
584
|
-
|
|
559
|
+
interface ArrowFunctionExpression$1 extends Span$1 {
|
|
560
|
+
type: "ArrowFunctionExpression";
|
|
561
|
+
expression: boolean;
|
|
562
|
+
async: boolean;
|
|
563
|
+
typeParameters?: TSTypeParameterDeclaration$1 | null;
|
|
564
|
+
params: ParamPattern$1[];
|
|
565
|
+
returnType?: TSTypeAnnotation$1 | null;
|
|
566
|
+
body: FunctionBody | Expression$1;
|
|
567
|
+
id: null;
|
|
568
|
+
generator: false;
|
|
585
569
|
parent?: Node$1;
|
|
586
570
|
}
|
|
587
|
-
|
|
588
|
-
type: "
|
|
589
|
-
|
|
590
|
-
|
|
591
|
-
optional?: false;
|
|
592
|
-
typeAnnotation?: null;
|
|
571
|
+
interface YieldExpression$1 extends Span$1 {
|
|
572
|
+
type: "YieldExpression";
|
|
573
|
+
delegate: boolean;
|
|
574
|
+
argument: Expression$1 | null;
|
|
593
575
|
parent?: Node$1;
|
|
594
576
|
}
|
|
595
|
-
|
|
596
|
-
type:
|
|
597
|
-
|
|
598
|
-
|
|
599
|
-
|
|
577
|
+
interface Class$1 extends Span$1 {
|
|
578
|
+
type: ClassType;
|
|
579
|
+
decorators: Array<Decorator$1>;
|
|
580
|
+
id: BindingIdentifier$1 | null;
|
|
581
|
+
typeParameters?: TSTypeParameterDeclaration$1 | null;
|
|
582
|
+
superClass: Expression$1 | null;
|
|
583
|
+
superTypeArguments?: TSTypeParameterInstantiation$1 | null;
|
|
584
|
+
implements?: Array<TSClassImplements>;
|
|
585
|
+
body: ClassBody$1;
|
|
586
|
+
abstract?: boolean;
|
|
587
|
+
declare?: boolean;
|
|
600
588
|
parent?: Node$1;
|
|
601
589
|
}
|
|
602
|
-
|
|
603
|
-
|
|
604
|
-
|
|
605
|
-
|
|
606
|
-
meta: IdentifierName$1;
|
|
607
|
-
property: IdentifierName$1;
|
|
590
|
+
type ClassType = "ClassDeclaration" | "ClassExpression";
|
|
591
|
+
interface ClassBody$1 extends Span$1 {
|
|
592
|
+
type: "ClassBody";
|
|
593
|
+
body: Array<ClassElement>;
|
|
608
594
|
parent?: Node$1;
|
|
609
595
|
}
|
|
610
|
-
|
|
596
|
+
type ClassElement = StaticBlock$1 | MethodDefinition$1 | PropertyDefinition$1 | AccessorProperty$1 | TSIndexSignature$1;
|
|
597
|
+
interface MethodDefinition$1 extends Span$1 {
|
|
611
598
|
type: MethodDefinitionType;
|
|
612
599
|
decorators: Array<Decorator$1>;
|
|
613
|
-
key:
|
|
600
|
+
key: PropertyKey;
|
|
614
601
|
value: Function$1;
|
|
615
602
|
kind: MethodDefinitionKind;
|
|
616
603
|
computed: boolean;
|
|
@@ -620,291 +607,275 @@ declare interface MethodDefinition$1 extends Span$1 {
|
|
|
620
607
|
accessibility?: TSAccessibility | null;
|
|
621
608
|
parent?: Node$1;
|
|
622
609
|
}
|
|
623
|
-
|
|
624
|
-
|
|
625
|
-
|
|
626
|
-
|
|
627
|
-
|
|
628
|
-
declare interface NewExpression$1 extends Span$1 {
|
|
629
|
-
type: "NewExpression";
|
|
630
|
-
callee: Expression$1;
|
|
631
|
-
typeArguments?: TSTypeParameterInstantiation$1 | null;
|
|
632
|
-
arguments: Array<Argument$1>;
|
|
633
|
-
parent?: Node$1;
|
|
634
|
-
}
|
|
635
|
-
declare type Node$1 = Program$1 | IdentifierName$1 | IdentifierReference$1 | BindingIdentifier$1 | LabelIdentifier$1 | ThisExpression$1 | ArrayExpression$1 | ObjectExpression$1 | ObjectProperty$1 | TemplateLiteral$1 | TaggedTemplateExpression$1 | TemplateElement$1 | ComputedMemberExpression | StaticMemberExpression$1 | PrivateFieldExpression | CallExpression$1 | NewExpression$1 | MetaProperty$1 | SpreadElement$1 | UpdateExpression$1 | UnaryExpression$1 | BinaryExpression$1 | PrivateInExpression$1 | LogicalExpression$1 | ConditionalExpression$1 | AssignmentExpression$1 | ArrayAssignmentTarget | ObjectAssignmentTarget | AssignmentTargetRest | AssignmentTargetWithDefault | AssignmentTargetPropertyIdentifier | AssignmentTargetPropertyProperty | SequenceExpression$1 | Super$1 | AwaitExpression | ChainExpression$1 | ParenthesizedExpression | Directive | Hashbang | BlockStatement$1 | VariableDeclaration$1 | VariableDeclarator$1 | EmptyStatement$1 | ExpressionStatement$1 | IfStatement$1 | DoWhileStatement$1 | WhileStatement$1 | ForStatement$1 | ForInStatement$1 | ForOfStatement$1 | ContinueStatement$1 | BreakStatement$1 | ReturnStatement$1 | WithStatement$1 | SwitchStatement$1 | SwitchCase$1 | LabeledStatement$1 | ThrowStatement$1 | TryStatement$1 | CatchClause$1 | DebuggerStatement | AssignmentPattern$1 | ObjectPattern | BindingProperty$1 | ArrayPattern$1 | BindingRestElement$1 | Function$1 | FunctionBody | ArrowFunctionExpression$1 | YieldExpression$1 | Class$1 | ClassBody$1 | MethodDefinition$1 | PropertyDefinition$1 | PrivateIdentifier$1 | StaticBlock$1 | AccessorProperty$1 | ImportExpression$1 | ImportDeclaration$1 | ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportAttribute$1 | ExportNamedDeclaration$1 | ExportDefaultDeclaration$1 | ExportAllDeclaration$1 | ExportSpecifier | V8IntrinsicExpression | BooleanLiteral$1 | NullLiteral$1 | NumericLiteral$1 | StringLiteral$1 | BigIntLiteral$1 | RegExpLiteral$1 | JSXElement$1 | JSXOpeningElement$1 | JSXClosingElement | JSXFragment$1 | JSXOpeningFragment | JSXClosingFragment | JSXNamespacedName$1 | JSXMemberExpression$1 | JSXExpressionContainer$1 | JSXEmptyExpression | JSXAttribute$1 | JSXSpreadAttribute$1 | JSXIdentifier$1 | JSXSpreadChild$1 | JSXText$1 | TSThisParameter | TSEnumDeclaration$1 | TSEnumBody | TSEnumMember | TSTypeAnnotation$1 | TSLiteralType$1 | TSConditionalType$1 | TSUnionType$1 | TSIntersectionType$1 | TSParenthesizedType$1 | TSTypeOperator$1 | TSArrayType$1 | TSIndexedAccessType$1 | TSTupleType$1 | TSNamedTupleMember$1 | TSOptionalType$1 | TSRestType$1 | TSAnyKeyword | TSStringKeyword | TSBooleanKeyword | TSNumberKeyword | TSNeverKeyword | TSIntrinsicKeyword | TSUnknownKeyword | TSNullKeyword | TSUndefinedKeyword | TSVoidKeyword | TSSymbolKeyword | TSThisType | TSObjectKeyword | TSBigIntKeyword | TSTypeReference$1 | TSQualifiedName$1 | TSTypeParameterInstantiation$1 | TSTypeParameter | TSTypeParameterDeclaration$1 | TSTypeAliasDeclaration$1 | TSClassImplements | TSInterfaceDeclaration$1 | TSInterfaceBody$1 | TSPropertySignature$1 | TSIndexSignature$1 | TSCallSignatureDeclaration$1 | TSMethodSignature$1 | TSConstructSignatureDeclaration$1 | TSIndexSignatureName | TSInterfaceHeritage | TSTypePredicate$1 | TSModuleDeclaration$1 | TSGlobalDeclaration | TSModuleBlock$1 | TSTypeLiteral | TSInferType$1 | TSTypeQuery$1 | TSImportType$1 | TSImportTypeQualifiedName | TSFunctionType$1 | TSConstructorType$1 | TSMappedType$1 | TSTemplateLiteralType$1 | TSAsExpression$1 | TSSatisfiesExpression$1 | TSTypeAssertion$1 | TSImportEqualsDeclaration$1 | TSExternalModuleReference | TSNonNullExpression$1 | Decorator$1 | TSExportAssignment$1 | TSNamespaceExportDeclaration$1 | TSInstantiationExpression$1 | JSDocNullableType$1 | JSDocNonNullableType$1 | JSDocUnknownType | ParamPattern$1;
|
|
636
|
-
declare type Node_2 = Simplify<Built<Node$1>> | Node$1;
|
|
637
|
-
declare interface NullLiteral$1 extends Span$1 {
|
|
638
|
-
type: "Literal";
|
|
639
|
-
value: null;
|
|
640
|
-
raw: "null" | null;
|
|
641
|
-
parent?: Node$1;
|
|
642
|
-
}
|
|
643
|
-
declare interface NumericLiteral$1 extends Span$1 {
|
|
644
|
-
type: "Literal";
|
|
645
|
-
value: number;
|
|
646
|
-
raw: string | null;
|
|
647
|
-
parent?: Node$1;
|
|
648
|
-
}
|
|
649
|
-
declare interface ObjectAssignmentTarget extends Span$1 {
|
|
650
|
-
type: "ObjectPattern";
|
|
651
|
-
decorators?: [];
|
|
652
|
-
properties: Array<AssignmentTargetProperty | AssignmentTargetRest>;
|
|
653
|
-
optional?: false;
|
|
654
|
-
typeAnnotation?: null;
|
|
655
|
-
parent?: Node$1;
|
|
656
|
-
}
|
|
657
|
-
declare interface ObjectExpression$1 extends Span$1 {
|
|
658
|
-
type: "ObjectExpression";
|
|
659
|
-
properties: Array<ObjectPropertyKind>;
|
|
660
|
-
parent?: Node$1;
|
|
661
|
-
}
|
|
662
|
-
declare interface ObjectPattern extends Span$1 {
|
|
663
|
-
type: "ObjectPattern";
|
|
664
|
-
decorators?: [];
|
|
665
|
-
properties: Array<BindingProperty$1 | BindingRestElement$1>;
|
|
666
|
-
optional?: false;
|
|
610
|
+
type MethodDefinitionType = "MethodDefinition" | "TSAbstractMethodDefinition";
|
|
611
|
+
interface PropertyDefinition$1 extends Span$1 {
|
|
612
|
+
type: PropertyDefinitionType;
|
|
613
|
+
decorators: Array<Decorator$1>;
|
|
614
|
+
key: PropertyKey;
|
|
667
615
|
typeAnnotation?: TSTypeAnnotation$1 | null;
|
|
668
|
-
|
|
669
|
-
}
|
|
670
|
-
declare interface ObjectProperty$1 extends Span$1 {
|
|
671
|
-
type: "Property";
|
|
672
|
-
kind: PropertyKind;
|
|
673
|
-
key: PropertyKey_2;
|
|
674
|
-
value: Expression$1;
|
|
675
|
-
method: boolean;
|
|
676
|
-
shorthand: boolean;
|
|
616
|
+
value: Expression$1 | null;
|
|
677
617
|
computed: boolean;
|
|
678
|
-
|
|
679
|
-
|
|
680
|
-
|
|
681
|
-
|
|
682
|
-
|
|
683
|
-
|
|
684
|
-
|
|
685
|
-
expression: Expression$1;
|
|
686
|
-
parent?: Node$1;
|
|
687
|
-
}
|
|
688
|
-
declare interface PrivateFieldExpression extends Span$1 {
|
|
689
|
-
type: "MemberExpression";
|
|
690
|
-
object: Expression$1;
|
|
691
|
-
property: PrivateIdentifier$1;
|
|
692
|
-
optional: boolean;
|
|
693
|
-
computed: false;
|
|
618
|
+
static: boolean;
|
|
619
|
+
declare?: boolean;
|
|
620
|
+
override?: boolean;
|
|
621
|
+
optional?: boolean;
|
|
622
|
+
definite?: boolean;
|
|
623
|
+
readonly?: boolean;
|
|
624
|
+
accessibility?: TSAccessibility | null;
|
|
694
625
|
parent?: Node$1;
|
|
695
626
|
}
|
|
696
|
-
|
|
627
|
+
type PropertyDefinitionType = "PropertyDefinition" | "TSAbstractPropertyDefinition";
|
|
628
|
+
type MethodDefinitionKind = "constructor" | "method" | "get" | "set";
|
|
629
|
+
interface PrivateIdentifier$1 extends Span$1 {
|
|
697
630
|
type: "PrivateIdentifier";
|
|
698
631
|
name: string;
|
|
699
632
|
parent?: Node$1;
|
|
700
633
|
}
|
|
701
|
-
|
|
702
|
-
type: "
|
|
703
|
-
|
|
704
|
-
operator: "in";
|
|
705
|
-
right: Expression$1;
|
|
634
|
+
interface StaticBlock$1 extends Span$1 {
|
|
635
|
+
type: "StaticBlock";
|
|
636
|
+
body: Array<Statement$1>;
|
|
706
637
|
parent?: Node$1;
|
|
707
638
|
}
|
|
708
|
-
|
|
709
|
-
|
|
710
|
-
|
|
711
|
-
|
|
712
|
-
hashbang: Hashbang | null;
|
|
713
|
-
parent?: null;
|
|
714
|
-
}
|
|
715
|
-
declare type Program = Simplify<Built<Program$1>>;
|
|
716
|
-
declare interface PropertyDefinition$1 extends Span$1 {
|
|
717
|
-
type: PropertyDefinitionType;
|
|
639
|
+
type ModuleDeclaration = ImportDeclaration$1 | ExportAllDeclaration$1 | ExportDefaultDeclaration$1 | ExportNamedDeclaration$1 | TSExportAssignment$1 | TSNamespaceExportDeclaration$1;
|
|
640
|
+
type AccessorPropertyType = "AccessorProperty" | "TSAbstractAccessorProperty";
|
|
641
|
+
interface AccessorProperty$1 extends Span$1 {
|
|
642
|
+
type: AccessorPropertyType;
|
|
718
643
|
decorators: Array<Decorator$1>;
|
|
719
|
-
key:
|
|
644
|
+
key: PropertyKey;
|
|
720
645
|
typeAnnotation?: TSTypeAnnotation$1 | null;
|
|
721
646
|
value: Expression$1 | null;
|
|
722
647
|
computed: boolean;
|
|
723
648
|
static: boolean;
|
|
724
|
-
declare?: boolean;
|
|
725
649
|
override?: boolean;
|
|
726
|
-
optional?: boolean;
|
|
727
650
|
definite?: boolean;
|
|
728
|
-
readonly?: boolean;
|
|
729
651
|
accessibility?: TSAccessibility | null;
|
|
652
|
+
declare?: false;
|
|
653
|
+
optional?: false;
|
|
654
|
+
readonly?: false;
|
|
730
655
|
parent?: Node$1;
|
|
731
656
|
}
|
|
732
|
-
|
|
733
|
-
|
|
734
|
-
|
|
735
|
-
|
|
736
|
-
|
|
737
|
-
value: RegExp | null;
|
|
738
|
-
raw: string | null;
|
|
739
|
-
regex: {
|
|
740
|
-
pattern: string;
|
|
741
|
-
flags: string;
|
|
742
|
-
};
|
|
657
|
+
interface ImportExpression$1 extends Span$1 {
|
|
658
|
+
type: "ImportExpression";
|
|
659
|
+
source: Expression$1;
|
|
660
|
+
options: Expression$1 | null;
|
|
661
|
+
phase: ImportPhase | null;
|
|
743
662
|
parent?: Node$1;
|
|
744
663
|
}
|
|
745
|
-
|
|
746
|
-
type: "
|
|
747
|
-
|
|
664
|
+
interface ImportDeclaration$1 extends Span$1 {
|
|
665
|
+
type: "ImportDeclaration";
|
|
666
|
+
specifiers: Array<ImportDeclarationSpecifier>;
|
|
667
|
+
source: StringLiteral$1;
|
|
668
|
+
phase: ImportPhase | null;
|
|
669
|
+
attributes: Array<ImportAttribute$1>;
|
|
670
|
+
importKind?: ImportOrExportKind;
|
|
748
671
|
parent?: Node$1;
|
|
749
672
|
}
|
|
750
|
-
|
|
751
|
-
|
|
752
|
-
|
|
673
|
+
type ImportPhase = "source" | "defer";
|
|
674
|
+
type ImportDeclarationSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier;
|
|
675
|
+
interface ImportSpecifier extends Span$1 {
|
|
676
|
+
type: "ImportSpecifier";
|
|
677
|
+
imported: ModuleExportName;
|
|
678
|
+
local: BindingIdentifier$1;
|
|
679
|
+
importKind?: ImportOrExportKind;
|
|
753
680
|
parent?: Node$1;
|
|
754
681
|
}
|
|
755
|
-
|
|
756
|
-
|
|
757
|
-
|
|
758
|
-
|
|
759
|
-
end: number;
|
|
760
|
-
range?: [number, number];
|
|
682
|
+
interface ImportDefaultSpecifier extends Span$1 {
|
|
683
|
+
type: "ImportDefaultSpecifier";
|
|
684
|
+
local: BindingIdentifier$1;
|
|
685
|
+
parent?: Node$1;
|
|
761
686
|
}
|
|
762
|
-
|
|
763
|
-
type: "
|
|
764
|
-
|
|
687
|
+
interface ImportNamespaceSpecifier extends Span$1 {
|
|
688
|
+
type: "ImportNamespaceSpecifier";
|
|
689
|
+
local: BindingIdentifier$1;
|
|
765
690
|
parent?: Node$1;
|
|
766
691
|
}
|
|
767
|
-
|
|
768
|
-
|
|
769
|
-
|
|
770
|
-
|
|
692
|
+
interface ImportAttribute$1 extends Span$1 {
|
|
693
|
+
type: "ImportAttribute";
|
|
694
|
+
key: ImportAttributeKey;
|
|
695
|
+
value: StringLiteral$1;
|
|
771
696
|
parent?: Node$1;
|
|
772
697
|
}
|
|
773
|
-
|
|
774
|
-
|
|
775
|
-
|
|
776
|
-
|
|
777
|
-
|
|
778
|
-
|
|
698
|
+
type ImportAttributeKey = IdentifierName$1 | StringLiteral$1;
|
|
699
|
+
interface ExportNamedDeclaration$1 extends Span$1 {
|
|
700
|
+
type: "ExportNamedDeclaration";
|
|
701
|
+
declaration: Declaration | null;
|
|
702
|
+
specifiers: Array<ExportSpecifier>;
|
|
703
|
+
source: StringLiteral$1 | null;
|
|
704
|
+
exportKind?: ImportOrExportKind;
|
|
705
|
+
attributes: Array<ImportAttribute$1>;
|
|
706
|
+
parent?: Node$1;
|
|
707
|
+
}
|
|
708
|
+
interface ExportDefaultDeclaration$1 extends Span$1 {
|
|
709
|
+
type: "ExportDefaultDeclaration";
|
|
710
|
+
declaration: ExportDefaultDeclarationKind;
|
|
711
|
+
exportKind?: "value";
|
|
712
|
+
parent?: Node$1;
|
|
713
|
+
}
|
|
714
|
+
interface ExportAllDeclaration$1 extends Span$1 {
|
|
715
|
+
type: "ExportAllDeclaration";
|
|
716
|
+
exported: ModuleExportName | null;
|
|
717
|
+
source: StringLiteral$1;
|
|
718
|
+
attributes: Array<ImportAttribute$1>;
|
|
719
|
+
exportKind?: ImportOrExportKind;
|
|
720
|
+
parent?: Node$1;
|
|
721
|
+
}
|
|
722
|
+
interface ExportSpecifier extends Span$1 {
|
|
723
|
+
type: "ExportSpecifier";
|
|
724
|
+
local: ModuleExportName;
|
|
725
|
+
exported: ModuleExportName;
|
|
726
|
+
exportKind?: ImportOrExportKind;
|
|
727
|
+
parent?: Node$1;
|
|
728
|
+
}
|
|
729
|
+
type ExportDefaultDeclarationKind = Function$1 | Class$1 | TSInterfaceDeclaration$1 | Expression$1;
|
|
730
|
+
type ModuleExportName = IdentifierName$1 | IdentifierReference$1 | StringLiteral$1;
|
|
731
|
+
interface V8IntrinsicExpression extends Span$1 {
|
|
732
|
+
type: "V8IntrinsicExpression";
|
|
733
|
+
name: IdentifierName$1;
|
|
734
|
+
arguments: Array<Argument$1>;
|
|
779
735
|
parent?: Node$1;
|
|
780
736
|
}
|
|
781
|
-
|
|
737
|
+
interface BooleanLiteral$1 extends Span$1 {
|
|
782
738
|
type: "Literal";
|
|
783
|
-
value:
|
|
739
|
+
value: boolean;
|
|
784
740
|
raw: string | null;
|
|
785
741
|
parent?: Node$1;
|
|
786
742
|
}
|
|
787
|
-
|
|
788
|
-
type: "
|
|
743
|
+
interface NullLiteral$1 extends Span$1 {
|
|
744
|
+
type: "Literal";
|
|
745
|
+
value: null;
|
|
746
|
+
raw: "null" | null;
|
|
789
747
|
parent?: Node$1;
|
|
790
748
|
}
|
|
791
|
-
|
|
792
|
-
type: "
|
|
793
|
-
|
|
794
|
-
|
|
749
|
+
interface NumericLiteral$1 extends Span$1 {
|
|
750
|
+
type: "Literal";
|
|
751
|
+
value: number;
|
|
752
|
+
raw: string | null;
|
|
795
753
|
parent?: Node$1;
|
|
796
754
|
}
|
|
797
|
-
|
|
798
|
-
type: "
|
|
799
|
-
|
|
800
|
-
|
|
755
|
+
interface StringLiteral$1 extends Span$1 {
|
|
756
|
+
type: "Literal";
|
|
757
|
+
value: string;
|
|
758
|
+
raw: string | null;
|
|
801
759
|
parent?: Node$1;
|
|
802
760
|
}
|
|
803
|
-
|
|
804
|
-
type: "
|
|
805
|
-
|
|
806
|
-
|
|
807
|
-
|
|
761
|
+
interface BigIntLiteral$1 extends Span$1 {
|
|
762
|
+
type: "Literal";
|
|
763
|
+
value: bigint;
|
|
764
|
+
raw: string | null;
|
|
765
|
+
bigint: string;
|
|
808
766
|
parent?: Node$1;
|
|
809
767
|
}
|
|
810
|
-
|
|
811
|
-
type: "
|
|
812
|
-
value:
|
|
813
|
-
|
|
768
|
+
interface RegExpLiteral$1 extends Span$1 {
|
|
769
|
+
type: "Literal";
|
|
770
|
+
value: RegExp | null;
|
|
771
|
+
raw: string | null;
|
|
772
|
+
regex: {
|
|
773
|
+
pattern: string;
|
|
774
|
+
flags: string;
|
|
775
|
+
};
|
|
814
776
|
parent?: Node$1;
|
|
815
777
|
}
|
|
816
|
-
|
|
817
|
-
|
|
818
|
-
|
|
778
|
+
interface JSXElement$1 extends Span$1 {
|
|
779
|
+
type: "JSXElement";
|
|
780
|
+
openingElement: JSXOpeningElement$1;
|
|
781
|
+
children: Array<JSXChild>;
|
|
782
|
+
closingElement: JSXClosingElement | null;
|
|
783
|
+
parent?: Node$1;
|
|
819
784
|
}
|
|
820
|
-
|
|
821
|
-
type: "
|
|
822
|
-
|
|
823
|
-
|
|
785
|
+
interface JSXOpeningElement$1 extends Span$1 {
|
|
786
|
+
type: "JSXOpeningElement";
|
|
787
|
+
name: JSXElementName;
|
|
788
|
+
typeArguments?: TSTypeParameterInstantiation$1 | null;
|
|
789
|
+
attributes: Array<JSXAttributeItem>;
|
|
790
|
+
selfClosing: boolean;
|
|
824
791
|
parent?: Node$1;
|
|
825
792
|
}
|
|
826
|
-
|
|
827
|
-
type: "
|
|
793
|
+
interface JSXClosingElement extends Span$1 {
|
|
794
|
+
type: "JSXClosingElement";
|
|
795
|
+
name: JSXElementName;
|
|
828
796
|
parent?: Node$1;
|
|
829
797
|
}
|
|
830
|
-
|
|
831
|
-
type: "
|
|
832
|
-
|
|
798
|
+
interface JSXFragment$1 extends Span$1 {
|
|
799
|
+
type: "JSXFragment";
|
|
800
|
+
openingFragment: JSXOpeningFragment;
|
|
801
|
+
children: Array<JSXChild>;
|
|
802
|
+
closingFragment: JSXClosingFragment;
|
|
833
803
|
parent?: Node$1;
|
|
834
804
|
}
|
|
835
|
-
|
|
836
|
-
type: "
|
|
837
|
-
|
|
838
|
-
|
|
839
|
-
finalizer: BlockStatement$1 | null;
|
|
805
|
+
interface JSXOpeningFragment extends Span$1 {
|
|
806
|
+
type: "JSXOpeningFragment";
|
|
807
|
+
attributes?: [];
|
|
808
|
+
selfClosing?: false;
|
|
840
809
|
parent?: Node$1;
|
|
841
810
|
}
|
|
842
|
-
|
|
843
|
-
|
|
844
|
-
type: "TSAnyKeyword";
|
|
811
|
+
interface JSXClosingFragment extends Span$1 {
|
|
812
|
+
type: "JSXClosingFragment";
|
|
845
813
|
parent?: Node$1;
|
|
846
814
|
}
|
|
847
|
-
|
|
848
|
-
|
|
849
|
-
|
|
815
|
+
type JSXElementName = JSXIdentifier$1 | JSXNamespacedName$1 | JSXMemberExpression$1;
|
|
816
|
+
interface JSXNamespacedName$1 extends Span$1 {
|
|
817
|
+
type: "JSXNamespacedName";
|
|
818
|
+
namespace: JSXIdentifier$1;
|
|
819
|
+
name: JSXIdentifier$1;
|
|
850
820
|
parent?: Node$1;
|
|
851
821
|
}
|
|
852
|
-
|
|
853
|
-
type: "
|
|
854
|
-
|
|
855
|
-
|
|
822
|
+
interface JSXMemberExpression$1 extends Span$1 {
|
|
823
|
+
type: "JSXMemberExpression";
|
|
824
|
+
object: JSXMemberExpressionObject;
|
|
825
|
+
property: JSXIdentifier$1;
|
|
856
826
|
parent?: Node$1;
|
|
857
827
|
}
|
|
858
|
-
|
|
859
|
-
|
|
828
|
+
type JSXMemberExpressionObject = JSXIdentifier$1 | JSXMemberExpression$1;
|
|
829
|
+
interface JSXExpressionContainer$1 extends Span$1 {
|
|
830
|
+
type: "JSXExpressionContainer";
|
|
831
|
+
expression: JSXExpression;
|
|
860
832
|
parent?: Node$1;
|
|
861
833
|
}
|
|
862
|
-
|
|
863
|
-
|
|
834
|
+
type JSXExpression = JSXEmptyExpression | Expression$1;
|
|
835
|
+
interface JSXEmptyExpression extends Span$1 {
|
|
836
|
+
type: "JSXEmptyExpression";
|
|
864
837
|
parent?: Node$1;
|
|
865
838
|
}
|
|
866
|
-
|
|
867
|
-
|
|
868
|
-
|
|
869
|
-
|
|
870
|
-
|
|
839
|
+
type JSXAttributeItem = JSXAttribute$1 | JSXSpreadAttribute$1;
|
|
840
|
+
interface JSXAttribute$1 extends Span$1 {
|
|
841
|
+
type: "JSXAttribute";
|
|
842
|
+
name: JSXAttributeName;
|
|
843
|
+
value: JSXAttributeValue | null;
|
|
871
844
|
parent?: Node$1;
|
|
872
845
|
}
|
|
873
|
-
|
|
874
|
-
type: "
|
|
875
|
-
|
|
876
|
-
typeArguments: TSTypeParameterInstantiation$1 | null;
|
|
846
|
+
interface JSXSpreadAttribute$1 extends Span$1 {
|
|
847
|
+
type: "JSXSpreadAttribute";
|
|
848
|
+
argument: Expression$1;
|
|
877
849
|
parent?: Node$1;
|
|
878
850
|
}
|
|
879
|
-
|
|
880
|
-
|
|
881
|
-
|
|
882
|
-
|
|
883
|
-
|
|
884
|
-
falseType: TSType$1;
|
|
851
|
+
type JSXAttributeName = JSXIdentifier$1 | JSXNamespacedName$1;
|
|
852
|
+
type JSXAttributeValue = StringLiteral$1 | JSXExpressionContainer$1 | JSXElement$1 | JSXFragment$1;
|
|
853
|
+
interface JSXIdentifier$1 extends Span$1 {
|
|
854
|
+
type: "JSXIdentifier";
|
|
855
|
+
name: string;
|
|
885
856
|
parent?: Node$1;
|
|
886
857
|
}
|
|
887
|
-
|
|
888
|
-
|
|
889
|
-
|
|
890
|
-
|
|
891
|
-
params: ParamPattern$1[];
|
|
892
|
-
returnType: TSTypeAnnotation$1;
|
|
858
|
+
type JSXChild = JSXText$1 | JSXElement$1 | JSXFragment$1 | JSXExpressionContainer$1 | JSXSpreadChild$1;
|
|
859
|
+
interface JSXSpreadChild$1 extends Span$1 {
|
|
860
|
+
type: "JSXSpreadChild";
|
|
861
|
+
expression: Expression$1;
|
|
893
862
|
parent?: Node$1;
|
|
894
863
|
}
|
|
895
|
-
|
|
896
|
-
type: "
|
|
897
|
-
|
|
898
|
-
|
|
899
|
-
returnType: TSTypeAnnotation$1 | null;
|
|
864
|
+
interface JSXText$1 extends Span$1 {
|
|
865
|
+
type: "JSXText";
|
|
866
|
+
value: string;
|
|
867
|
+
raw: string | null;
|
|
900
868
|
parent?: Node$1;
|
|
901
869
|
}
|
|
902
|
-
|
|
903
|
-
type: "
|
|
904
|
-
|
|
870
|
+
interface TSThisParameter extends Span$1 {
|
|
871
|
+
type: "Identifier";
|
|
872
|
+
decorators: [];
|
|
873
|
+
name: "this";
|
|
874
|
+
optional: false;
|
|
875
|
+
typeAnnotation: TSTypeAnnotation$1 | null;
|
|
905
876
|
parent?: Node$1;
|
|
906
877
|
}
|
|
907
|
-
|
|
878
|
+
interface TSEnumDeclaration$1 extends Span$1 {
|
|
908
879
|
type: "TSEnumDeclaration";
|
|
909
880
|
id: BindingIdentifier$1;
|
|
910
881
|
body: TSEnumBody;
|
|
@@ -912,433 +883,472 @@ declare interface TSEnumDeclaration$1 extends Span$1 {
|
|
|
912
883
|
declare: boolean;
|
|
913
884
|
parent?: Node$1;
|
|
914
885
|
}
|
|
915
|
-
|
|
886
|
+
interface TSEnumBody extends Span$1 {
|
|
887
|
+
type: "TSEnumBody";
|
|
888
|
+
members: Array<TSEnumMember>;
|
|
889
|
+
parent?: Node$1;
|
|
890
|
+
}
|
|
891
|
+
interface TSEnumMember extends Span$1 {
|
|
916
892
|
type: "TSEnumMember";
|
|
917
893
|
id: TSEnumMemberName;
|
|
918
894
|
initializer: Expression$1 | null;
|
|
919
895
|
computed: boolean;
|
|
920
896
|
parent?: Node$1;
|
|
921
897
|
}
|
|
922
|
-
|
|
923
|
-
|
|
924
|
-
type: "
|
|
925
|
-
|
|
898
|
+
type TSEnumMemberName = IdentifierName$1 | StringLiteral$1 | TemplateLiteral$1;
|
|
899
|
+
interface TSTypeAnnotation$1 extends Span$1 {
|
|
900
|
+
type: "TSTypeAnnotation";
|
|
901
|
+
typeAnnotation: TSType$1;
|
|
926
902
|
parent?: Node$1;
|
|
927
903
|
}
|
|
928
|
-
|
|
929
|
-
type: "
|
|
930
|
-
|
|
904
|
+
interface TSLiteralType$1 extends Span$1 {
|
|
905
|
+
type: "TSLiteralType";
|
|
906
|
+
literal: TSLiteral;
|
|
931
907
|
parent?: Node$1;
|
|
932
908
|
}
|
|
933
|
-
|
|
934
|
-
|
|
935
|
-
|
|
936
|
-
|
|
937
|
-
|
|
909
|
+
type TSLiteral = BooleanLiteral$1 | NumericLiteral$1 | BigIntLiteral$1 | StringLiteral$1 | TemplateLiteral$1 | UnaryExpression$1;
|
|
910
|
+
type TSType$1 = TSAnyKeyword | TSBigIntKeyword | TSBooleanKeyword | TSIntrinsicKeyword | TSNeverKeyword | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSStringKeyword | TSSymbolKeyword | TSUndefinedKeyword | TSUnknownKeyword | TSVoidKeyword | TSArrayType$1 | TSConditionalType$1 | TSConstructorType$1 | TSFunctionType$1 | TSImportType$1 | TSIndexedAccessType$1 | TSInferType$1 | TSIntersectionType$1 | TSLiteralType$1 | TSMappedType$1 | TSNamedTupleMember$1 | TSTemplateLiteralType$1 | TSThisType | TSTupleType$1 | TSTypeLiteral | TSTypeOperator$1 | TSTypePredicate$1 | TSTypeQuery$1 | TSTypeReference$1 | TSUnionType$1 | TSParenthesizedType$1 | JSDocNullableType$1 | JSDocNonNullableType$1 | JSDocUnknownType;
|
|
911
|
+
interface TSConditionalType$1 extends Span$1 {
|
|
912
|
+
type: "TSConditionalType";
|
|
913
|
+
checkType: TSType$1;
|
|
914
|
+
extendsType: TSType$1;
|
|
915
|
+
trueType: TSType$1;
|
|
916
|
+
falseType: TSType$1;
|
|
938
917
|
parent?: Node$1;
|
|
939
918
|
}
|
|
940
|
-
|
|
941
|
-
type: "
|
|
942
|
-
|
|
943
|
-
body: TSModuleBlock$1;
|
|
944
|
-
kind: "global";
|
|
945
|
-
declare: boolean;
|
|
946
|
-
global: true;
|
|
919
|
+
interface TSUnionType$1 extends Span$1 {
|
|
920
|
+
type: "TSUnionType";
|
|
921
|
+
types: Array<TSType$1>;
|
|
947
922
|
parent?: Node$1;
|
|
948
923
|
}
|
|
949
|
-
|
|
950
|
-
type: "
|
|
951
|
-
|
|
952
|
-
moduleReference: TSModuleReference;
|
|
953
|
-
importKind: ImportOrExportKind;
|
|
924
|
+
interface TSIntersectionType$1 extends Span$1 {
|
|
925
|
+
type: "TSIntersectionType";
|
|
926
|
+
types: Array<TSType$1>;
|
|
954
927
|
parent?: Node$1;
|
|
955
928
|
}
|
|
956
|
-
|
|
957
|
-
type: "
|
|
958
|
-
|
|
959
|
-
options: ObjectExpression$1 | null;
|
|
960
|
-
qualifier: TSImportTypeQualifier | null;
|
|
961
|
-
typeArguments: TSTypeParameterInstantiation$1 | null;
|
|
929
|
+
interface TSParenthesizedType$1 extends Span$1 {
|
|
930
|
+
type: "TSParenthesizedType";
|
|
931
|
+
typeAnnotation: TSType$1;
|
|
962
932
|
parent?: Node$1;
|
|
963
933
|
}
|
|
964
|
-
|
|
965
|
-
type: "
|
|
966
|
-
|
|
967
|
-
|
|
934
|
+
interface TSTypeOperator$1 extends Span$1 {
|
|
935
|
+
type: "TSTypeOperator";
|
|
936
|
+
operator: TSTypeOperatorOperator;
|
|
937
|
+
typeAnnotation: TSType$1;
|
|
938
|
+
parent?: Node$1;
|
|
939
|
+
}
|
|
940
|
+
type TSTypeOperatorOperator = "keyof" | "unique" | "readonly";
|
|
941
|
+
interface TSArrayType$1 extends Span$1 {
|
|
942
|
+
type: "TSArrayType";
|
|
943
|
+
elementType: TSType$1;
|
|
968
944
|
parent?: Node$1;
|
|
969
945
|
}
|
|
970
|
-
|
|
971
|
-
declare interface TSIndexedAccessType$1 extends Span$1 {
|
|
946
|
+
interface TSIndexedAccessType$1 extends Span$1 {
|
|
972
947
|
type: "TSIndexedAccessType";
|
|
973
948
|
objectType: TSType$1;
|
|
974
949
|
indexType: TSType$1;
|
|
975
950
|
parent?: Node$1;
|
|
976
951
|
}
|
|
977
|
-
|
|
978
|
-
type: "
|
|
979
|
-
|
|
980
|
-
typeAnnotation: TSTypeAnnotation$1;
|
|
981
|
-
readonly: boolean;
|
|
982
|
-
static: boolean;
|
|
983
|
-
accessibility: null;
|
|
952
|
+
interface TSTupleType$1 extends Span$1 {
|
|
953
|
+
type: "TSTupleType";
|
|
954
|
+
elementTypes: Array<TSTupleElement>;
|
|
984
955
|
parent?: Node$1;
|
|
985
956
|
}
|
|
986
|
-
|
|
987
|
-
type: "
|
|
988
|
-
|
|
989
|
-
|
|
990
|
-
optional:
|
|
991
|
-
typeAnnotation: TSTypeAnnotation$1;
|
|
957
|
+
interface TSNamedTupleMember$1 extends Span$1 {
|
|
958
|
+
type: "TSNamedTupleMember";
|
|
959
|
+
label: IdentifierName$1;
|
|
960
|
+
elementType: TSTupleElement;
|
|
961
|
+
optional: boolean;
|
|
992
962
|
parent?: Node$1;
|
|
993
963
|
}
|
|
994
|
-
|
|
995
|
-
type: "
|
|
996
|
-
|
|
964
|
+
interface TSOptionalType$1 extends Span$1 {
|
|
965
|
+
type: "TSOptionalType";
|
|
966
|
+
typeAnnotation: TSType$1;
|
|
997
967
|
parent?: Node$1;
|
|
998
968
|
}
|
|
999
|
-
|
|
1000
|
-
type: "
|
|
1001
|
-
|
|
1002
|
-
typeArguments: TSTypeParameterInstantiation$1;
|
|
969
|
+
interface TSRestType$1 extends Span$1 {
|
|
970
|
+
type: "TSRestType";
|
|
971
|
+
typeAnnotation: TSType$1;
|
|
1003
972
|
parent?: Node$1;
|
|
1004
973
|
}
|
|
1005
|
-
|
|
1006
|
-
|
|
1007
|
-
|
|
974
|
+
type TSTupleElement = TSOptionalType$1 | TSRestType$1 | TSType$1;
|
|
975
|
+
interface TSAnyKeyword extends Span$1 {
|
|
976
|
+
type: "TSAnyKeyword";
|
|
1008
977
|
parent?: Node$1;
|
|
1009
978
|
}
|
|
1010
|
-
|
|
1011
|
-
type: "
|
|
1012
|
-
id: BindingIdentifier$1;
|
|
1013
|
-
typeParameters: TSTypeParameterDeclaration$1 | null;
|
|
1014
|
-
extends: Array<TSInterfaceHeritage>;
|
|
1015
|
-
body: TSInterfaceBody$1;
|
|
1016
|
-
declare: boolean;
|
|
979
|
+
interface TSStringKeyword extends Span$1 {
|
|
980
|
+
type: "TSStringKeyword";
|
|
1017
981
|
parent?: Node$1;
|
|
1018
982
|
}
|
|
1019
|
-
|
|
1020
|
-
type: "
|
|
1021
|
-
expression: Expression$1;
|
|
1022
|
-
typeArguments: TSTypeParameterInstantiation$1 | null;
|
|
983
|
+
interface TSBooleanKeyword extends Span$1 {
|
|
984
|
+
type: "TSBooleanKeyword";
|
|
1023
985
|
parent?: Node$1;
|
|
1024
986
|
}
|
|
1025
|
-
|
|
1026
|
-
type: "
|
|
1027
|
-
|
|
987
|
+
interface TSNumberKeyword extends Span$1 {
|
|
988
|
+
type: "TSNumberKeyword";
|
|
989
|
+
parent?: Node$1;
|
|
990
|
+
}
|
|
991
|
+
interface TSNeverKeyword extends Span$1 {
|
|
992
|
+
type: "TSNeverKeyword";
|
|
1028
993
|
parent?: Node$1;
|
|
1029
994
|
}
|
|
1030
|
-
|
|
995
|
+
interface TSIntrinsicKeyword extends Span$1 {
|
|
1031
996
|
type: "TSIntrinsicKeyword";
|
|
1032
997
|
parent?: Node$1;
|
|
1033
998
|
}
|
|
1034
|
-
|
|
1035
|
-
|
|
1036
|
-
type: "TSLiteralType";
|
|
1037
|
-
literal: TSLiteral;
|
|
999
|
+
interface TSUnknownKeyword extends Span$1 {
|
|
1000
|
+
type: "TSUnknownKeyword";
|
|
1038
1001
|
parent?: Node$1;
|
|
1039
1002
|
}
|
|
1040
|
-
|
|
1041
|
-
type: "
|
|
1042
|
-
key: BindingIdentifier$1;
|
|
1043
|
-
constraint: TSType$1;
|
|
1044
|
-
nameType: TSType$1 | null;
|
|
1045
|
-
typeAnnotation: TSType$1 | null;
|
|
1046
|
-
optional: TSMappedTypeModifierOperator | false;
|
|
1047
|
-
readonly: TSMappedTypeModifierOperator | null;
|
|
1003
|
+
interface TSNullKeyword extends Span$1 {
|
|
1004
|
+
type: "TSNullKeyword";
|
|
1048
1005
|
parent?: Node$1;
|
|
1049
1006
|
}
|
|
1050
|
-
|
|
1051
|
-
|
|
1052
|
-
type: "TSMethodSignature";
|
|
1053
|
-
key: PropertyKey_2;
|
|
1054
|
-
computed: boolean;
|
|
1055
|
-
optional: boolean;
|
|
1056
|
-
kind: TSMethodSignatureKind;
|
|
1057
|
-
typeParameters: TSTypeParameterDeclaration$1 | null;
|
|
1058
|
-
params: ParamPattern$1[];
|
|
1059
|
-
returnType: TSTypeAnnotation$1 | null;
|
|
1060
|
-
accessibility: null;
|
|
1061
|
-
readonly: false;
|
|
1062
|
-
static: false;
|
|
1007
|
+
interface TSUndefinedKeyword extends Span$1 {
|
|
1008
|
+
type: "TSUndefinedKeyword";
|
|
1063
1009
|
parent?: Node$1;
|
|
1064
1010
|
}
|
|
1065
|
-
|
|
1066
|
-
|
|
1067
|
-
type: "TSModuleBlock";
|
|
1068
|
-
body: Array<Directive | Statement$1>;
|
|
1011
|
+
interface TSVoidKeyword extends Span$1 {
|
|
1012
|
+
type: "TSVoidKeyword";
|
|
1069
1013
|
parent?: Node$1;
|
|
1070
1014
|
}
|
|
1071
|
-
|
|
1072
|
-
type: "
|
|
1073
|
-
id: BindingIdentifier$1 | StringLiteral$1 | TSQualifiedName$1;
|
|
1074
|
-
body: TSModuleBlock$1 | null;
|
|
1075
|
-
kind: TSModuleDeclarationKind;
|
|
1076
|
-
declare: boolean;
|
|
1077
|
-
global: false;
|
|
1015
|
+
interface TSSymbolKeyword extends Span$1 {
|
|
1016
|
+
type: "TSSymbolKeyword";
|
|
1078
1017
|
parent?: Node$1;
|
|
1079
1018
|
}
|
|
1080
|
-
|
|
1081
|
-
|
|
1082
|
-
declare interface TSNamedTupleMember$1 extends Span$1 {
|
|
1083
|
-
type: "TSNamedTupleMember";
|
|
1084
|
-
label: IdentifierName$1;
|
|
1085
|
-
elementType: TSTupleElement;
|
|
1086
|
-
optional: boolean;
|
|
1019
|
+
interface TSThisType extends Span$1 {
|
|
1020
|
+
type: "TSThisType";
|
|
1087
1021
|
parent?: Node$1;
|
|
1088
1022
|
}
|
|
1089
|
-
|
|
1090
|
-
type: "
|
|
1091
|
-
id: IdentifierName$1;
|
|
1023
|
+
interface TSObjectKeyword extends Span$1 {
|
|
1024
|
+
type: "TSObjectKeyword";
|
|
1092
1025
|
parent?: Node$1;
|
|
1093
1026
|
}
|
|
1094
|
-
|
|
1095
|
-
type: "
|
|
1027
|
+
interface TSBigIntKeyword extends Span$1 {
|
|
1028
|
+
type: "TSBigIntKeyword";
|
|
1096
1029
|
parent?: Node$1;
|
|
1097
1030
|
}
|
|
1098
|
-
|
|
1099
|
-
type: "
|
|
1100
|
-
|
|
1031
|
+
interface TSTypeReference$1 extends Span$1 {
|
|
1032
|
+
type: "TSTypeReference";
|
|
1033
|
+
typeName: TSTypeName;
|
|
1034
|
+
typeArguments: TSTypeParameterInstantiation$1 | null;
|
|
1035
|
+
parent?: Node$1;
|
|
1036
|
+
}
|
|
1037
|
+
type TSTypeName = IdentifierReference$1 | TSQualifiedName$1 | ThisExpression$1;
|
|
1038
|
+
interface TSQualifiedName$1 extends Span$1 {
|
|
1039
|
+
type: "TSQualifiedName";
|
|
1040
|
+
left: TSTypeName;
|
|
1041
|
+
right: IdentifierName$1;
|
|
1042
|
+
parent?: Node$1;
|
|
1043
|
+
}
|
|
1044
|
+
interface TSTypeParameterInstantiation$1 extends Span$1 {
|
|
1045
|
+
type: "TSTypeParameterInstantiation";
|
|
1046
|
+
params: Array<TSType$1>;
|
|
1101
1047
|
parent?: Node$1;
|
|
1102
1048
|
}
|
|
1103
|
-
|
|
1104
|
-
type: "
|
|
1049
|
+
interface TSTypeParameter extends Span$1 {
|
|
1050
|
+
type: "TSTypeParameter";
|
|
1051
|
+
name: BindingIdentifier$1;
|
|
1052
|
+
constraint: TSType$1 | null;
|
|
1053
|
+
default: TSType$1 | null;
|
|
1054
|
+
in: boolean;
|
|
1055
|
+
out: boolean;
|
|
1056
|
+
const: boolean;
|
|
1105
1057
|
parent?: Node$1;
|
|
1106
1058
|
}
|
|
1107
|
-
|
|
1108
|
-
type: "
|
|
1059
|
+
interface TSTypeParameterDeclaration$1 extends Span$1 {
|
|
1060
|
+
type: "TSTypeParameterDeclaration";
|
|
1061
|
+
params: Array<TSTypeParameter>;
|
|
1109
1062
|
parent?: Node$1;
|
|
1110
1063
|
}
|
|
1111
|
-
|
|
1112
|
-
type: "
|
|
1064
|
+
interface TSTypeAliasDeclaration$1 extends Span$1 {
|
|
1065
|
+
type: "TSTypeAliasDeclaration";
|
|
1066
|
+
id: BindingIdentifier$1;
|
|
1067
|
+
typeParameters: TSTypeParameterDeclaration$1 | null;
|
|
1068
|
+
typeAnnotation: TSType$1;
|
|
1069
|
+
declare: boolean;
|
|
1113
1070
|
parent?: Node$1;
|
|
1114
1071
|
}
|
|
1115
|
-
|
|
1116
|
-
|
|
1117
|
-
|
|
1072
|
+
type TSAccessibility = "private" | "protected" | "public";
|
|
1073
|
+
interface TSClassImplements extends Span$1 {
|
|
1074
|
+
type: "TSClassImplements";
|
|
1075
|
+
expression: IdentifierReference$1 | ThisExpression$1 | MemberExpression$1;
|
|
1076
|
+
typeArguments: TSTypeParameterInstantiation$1 | null;
|
|
1118
1077
|
parent?: Node$1;
|
|
1119
1078
|
}
|
|
1120
|
-
|
|
1121
|
-
type: "
|
|
1122
|
-
|
|
1123
|
-
|
|
1124
|
-
|
|
1125
|
-
|
|
1126
|
-
|
|
1127
|
-
static: boolean;
|
|
1079
|
+
interface TSInterfaceDeclaration$1 extends Span$1 {
|
|
1080
|
+
type: "TSInterfaceDeclaration";
|
|
1081
|
+
id: BindingIdentifier$1;
|
|
1082
|
+
typeParameters: TSTypeParameterDeclaration$1 | null;
|
|
1083
|
+
extends: Array<TSInterfaceHeritage>;
|
|
1084
|
+
body: TSInterfaceBody$1;
|
|
1085
|
+
declare: boolean;
|
|
1128
1086
|
parent?: Node$1;
|
|
1129
1087
|
}
|
|
1130
|
-
|
|
1131
|
-
type: "
|
|
1132
|
-
|
|
1088
|
+
interface TSInterfaceBody$1 extends Span$1 {
|
|
1089
|
+
type: "TSInterfaceBody";
|
|
1090
|
+
body: Array<TSSignature>;
|
|
1133
1091
|
parent?: Node$1;
|
|
1134
1092
|
}
|
|
1135
|
-
|
|
1093
|
+
interface TSPropertySignature$1 extends Span$1 {
|
|
1136
1094
|
type: "TSPropertySignature";
|
|
1137
1095
|
computed: boolean;
|
|
1138
1096
|
optional: boolean;
|
|
1139
1097
|
readonly: boolean;
|
|
1140
|
-
key:
|
|
1098
|
+
key: PropertyKey;
|
|
1141
1099
|
typeAnnotation: TSTypeAnnotation$1 | null;
|
|
1142
1100
|
accessibility: null;
|
|
1143
1101
|
static: false;
|
|
1144
1102
|
parent?: Node$1;
|
|
1145
1103
|
}
|
|
1146
|
-
|
|
1147
|
-
|
|
1148
|
-
|
|
1149
|
-
|
|
1150
|
-
|
|
1151
|
-
|
|
1152
|
-
|
|
1153
|
-
|
|
1154
|
-
typeAnnotation: TSType$1;
|
|
1155
|
-
parent?: Node$1;
|
|
1156
|
-
}
|
|
1157
|
-
declare interface TSSatisfiesExpression$1 extends Span$1 {
|
|
1158
|
-
type: "TSSatisfiesExpression";
|
|
1159
|
-
expression: Expression$1;
|
|
1160
|
-
typeAnnotation: TSType$1;
|
|
1104
|
+
type TSSignature = TSIndexSignature$1 | TSPropertySignature$1 | TSCallSignatureDeclaration$1 | TSConstructSignatureDeclaration$1 | TSMethodSignature$1;
|
|
1105
|
+
interface TSIndexSignature$1 extends Span$1 {
|
|
1106
|
+
type: "TSIndexSignature";
|
|
1107
|
+
parameters: Array<TSIndexSignatureName>;
|
|
1108
|
+
typeAnnotation: TSTypeAnnotation$1;
|
|
1109
|
+
readonly: boolean;
|
|
1110
|
+
static: boolean;
|
|
1111
|
+
accessibility: null;
|
|
1161
1112
|
parent?: Node$1;
|
|
1162
1113
|
}
|
|
1163
|
-
|
|
1164
|
-
|
|
1165
|
-
|
|
1114
|
+
interface TSCallSignatureDeclaration$1 extends Span$1 {
|
|
1115
|
+
type: "TSCallSignatureDeclaration";
|
|
1116
|
+
typeParameters: TSTypeParameterDeclaration$1 | null;
|
|
1117
|
+
params: ParamPattern$1[];
|
|
1118
|
+
returnType: TSTypeAnnotation$1 | null;
|
|
1166
1119
|
parent?: Node$1;
|
|
1167
1120
|
}
|
|
1168
|
-
|
|
1169
|
-
|
|
1121
|
+
type TSMethodSignatureKind = "method" | "get" | "set";
|
|
1122
|
+
interface TSMethodSignature$1 extends Span$1 {
|
|
1123
|
+
type: "TSMethodSignature";
|
|
1124
|
+
key: PropertyKey;
|
|
1125
|
+
computed: boolean;
|
|
1126
|
+
optional: boolean;
|
|
1127
|
+
kind: TSMethodSignatureKind;
|
|
1128
|
+
typeParameters: TSTypeParameterDeclaration$1 | null;
|
|
1129
|
+
params: ParamPattern$1[];
|
|
1130
|
+
returnType: TSTypeAnnotation$1 | null;
|
|
1131
|
+
accessibility: null;
|
|
1132
|
+
readonly: false;
|
|
1133
|
+
static: false;
|
|
1170
1134
|
parent?: Node$1;
|
|
1171
1135
|
}
|
|
1172
|
-
|
|
1173
|
-
type: "
|
|
1174
|
-
|
|
1175
|
-
|
|
1136
|
+
interface TSConstructSignatureDeclaration$1 extends Span$1 {
|
|
1137
|
+
type: "TSConstructSignatureDeclaration";
|
|
1138
|
+
typeParameters: TSTypeParameterDeclaration$1 | null;
|
|
1139
|
+
params: ParamPattern$1[];
|
|
1140
|
+
returnType: TSTypeAnnotation$1 | null;
|
|
1176
1141
|
parent?: Node$1;
|
|
1177
1142
|
}
|
|
1178
|
-
|
|
1143
|
+
interface TSIndexSignatureName extends Span$1 {
|
|
1179
1144
|
type: "Identifier";
|
|
1180
1145
|
decorators: [];
|
|
1181
|
-
name:
|
|
1146
|
+
name: string;
|
|
1182
1147
|
optional: false;
|
|
1183
|
-
typeAnnotation: TSTypeAnnotation$1
|
|
1148
|
+
typeAnnotation: TSTypeAnnotation$1;
|
|
1184
1149
|
parent?: Node$1;
|
|
1185
1150
|
}
|
|
1186
|
-
|
|
1187
|
-
type: "
|
|
1151
|
+
interface TSInterfaceHeritage extends Span$1 {
|
|
1152
|
+
type: "TSInterfaceHeritage";
|
|
1153
|
+
expression: Expression$1;
|
|
1154
|
+
typeArguments: TSTypeParameterInstantiation$1 | null;
|
|
1188
1155
|
parent?: Node$1;
|
|
1189
1156
|
}
|
|
1190
|
-
|
|
1191
|
-
|
|
1192
|
-
|
|
1193
|
-
|
|
1157
|
+
interface TSTypePredicate$1 extends Span$1 {
|
|
1158
|
+
type: "TSTypePredicate";
|
|
1159
|
+
parameterName: TSTypePredicateName;
|
|
1160
|
+
asserts: boolean;
|
|
1161
|
+
typeAnnotation: TSTypeAnnotation$1 | null;
|
|
1194
1162
|
parent?: Node$1;
|
|
1195
1163
|
}
|
|
1196
|
-
|
|
1197
|
-
|
|
1198
|
-
|
|
1199
|
-
|
|
1200
|
-
|
|
1201
|
-
|
|
1164
|
+
type TSTypePredicateName = IdentifierName$1 | TSThisType;
|
|
1165
|
+
type TSModuleDeclarationKind = "module" | "namespace";
|
|
1166
|
+
interface TSModuleDeclaration$1 extends Span$1 {
|
|
1167
|
+
type: "TSModuleDeclaration";
|
|
1168
|
+
id: BindingIdentifier$1 | StringLiteral$1 | TSQualifiedName$1;
|
|
1169
|
+
body: TSModuleBlock$1 | null;
|
|
1170
|
+
kind: TSModuleDeclarationKind;
|
|
1202
1171
|
declare: boolean;
|
|
1172
|
+
global: false;
|
|
1203
1173
|
parent?: Node$1;
|
|
1204
1174
|
}
|
|
1205
|
-
|
|
1206
|
-
type: "
|
|
1207
|
-
|
|
1175
|
+
interface TSGlobalDeclaration extends Span$1 {
|
|
1176
|
+
type: "TSModuleDeclaration";
|
|
1177
|
+
id: IdentifierName$1;
|
|
1178
|
+
body: TSModuleBlock$1;
|
|
1179
|
+
kind: "global";
|
|
1180
|
+
declare: boolean;
|
|
1181
|
+
global: true;
|
|
1208
1182
|
parent?: Node$1;
|
|
1209
1183
|
}
|
|
1210
|
-
|
|
1211
|
-
type: "
|
|
1212
|
-
|
|
1213
|
-
expression: Expression$1;
|
|
1184
|
+
interface TSModuleBlock$1 extends Span$1 {
|
|
1185
|
+
type: "TSModuleBlock";
|
|
1186
|
+
body: Array<Directive | Statement$1>;
|
|
1214
1187
|
parent?: Node$1;
|
|
1215
1188
|
}
|
|
1216
|
-
|
|
1189
|
+
interface TSTypeLiteral extends Span$1 {
|
|
1217
1190
|
type: "TSTypeLiteral";
|
|
1218
1191
|
members: Array<TSSignature>;
|
|
1219
1192
|
parent?: Node$1;
|
|
1220
1193
|
}
|
|
1221
|
-
|
|
1222
|
-
|
|
1223
|
-
|
|
1224
|
-
operator: TSTypeOperatorOperator;
|
|
1225
|
-
typeAnnotation: TSType$1;
|
|
1194
|
+
interface TSInferType$1 extends Span$1 {
|
|
1195
|
+
type: "TSInferType";
|
|
1196
|
+
typeParameter: TSTypeParameter;
|
|
1226
1197
|
parent?: Node$1;
|
|
1227
1198
|
}
|
|
1228
|
-
|
|
1229
|
-
|
|
1230
|
-
|
|
1231
|
-
|
|
1232
|
-
constraint: TSType$1 | null;
|
|
1233
|
-
default: TSType$1 | null;
|
|
1234
|
-
in: boolean;
|
|
1235
|
-
out: boolean;
|
|
1236
|
-
const: boolean;
|
|
1199
|
+
interface TSTypeQuery$1 extends Span$1 {
|
|
1200
|
+
type: "TSTypeQuery";
|
|
1201
|
+
exprName: TSTypeQueryExprName;
|
|
1202
|
+
typeArguments: TSTypeParameterInstantiation$1 | null;
|
|
1237
1203
|
parent?: Node$1;
|
|
1238
1204
|
}
|
|
1239
|
-
|
|
1240
|
-
|
|
1241
|
-
|
|
1205
|
+
type TSTypeQueryExprName = TSImportType$1 | TSTypeName;
|
|
1206
|
+
interface TSImportType$1 extends Span$1 {
|
|
1207
|
+
type: "TSImportType";
|
|
1208
|
+
source: StringLiteral$1;
|
|
1209
|
+
options: ObjectExpression$1 | null;
|
|
1210
|
+
qualifier: TSImportTypeQualifier | null;
|
|
1211
|
+
typeArguments: TSTypeParameterInstantiation$1 | null;
|
|
1242
1212
|
parent?: Node$1;
|
|
1243
1213
|
}
|
|
1244
|
-
|
|
1245
|
-
|
|
1246
|
-
|
|
1214
|
+
type TSImportTypeQualifier = IdentifierName$1 | TSImportTypeQualifiedName;
|
|
1215
|
+
interface TSImportTypeQualifiedName extends Span$1 {
|
|
1216
|
+
type: "TSQualifiedName";
|
|
1217
|
+
left: TSImportTypeQualifier;
|
|
1218
|
+
right: IdentifierName$1;
|
|
1247
1219
|
parent?: Node$1;
|
|
1248
1220
|
}
|
|
1249
|
-
|
|
1250
|
-
type: "
|
|
1251
|
-
|
|
1252
|
-
|
|
1253
|
-
|
|
1221
|
+
interface TSFunctionType$1 extends Span$1 {
|
|
1222
|
+
type: "TSFunctionType";
|
|
1223
|
+
typeParameters: TSTypeParameterDeclaration$1 | null;
|
|
1224
|
+
params: ParamPattern$1[];
|
|
1225
|
+
returnType: TSTypeAnnotation$1;
|
|
1254
1226
|
parent?: Node$1;
|
|
1255
1227
|
}
|
|
1256
|
-
|
|
1257
|
-
|
|
1258
|
-
|
|
1259
|
-
|
|
1260
|
-
|
|
1228
|
+
interface TSConstructorType$1 extends Span$1 {
|
|
1229
|
+
type: "TSConstructorType";
|
|
1230
|
+
abstract: boolean;
|
|
1231
|
+
typeParameters: TSTypeParameterDeclaration$1 | null;
|
|
1232
|
+
params: ParamPattern$1[];
|
|
1233
|
+
returnType: TSTypeAnnotation$1;
|
|
1261
1234
|
parent?: Node$1;
|
|
1262
1235
|
}
|
|
1263
|
-
|
|
1264
|
-
|
|
1265
|
-
|
|
1266
|
-
|
|
1267
|
-
|
|
1236
|
+
interface TSMappedType$1 extends Span$1 {
|
|
1237
|
+
type: "TSMappedType";
|
|
1238
|
+
key: BindingIdentifier$1;
|
|
1239
|
+
constraint: TSType$1;
|
|
1240
|
+
nameType: TSType$1 | null;
|
|
1241
|
+
typeAnnotation: TSType$1 | null;
|
|
1242
|
+
optional: TSMappedTypeModifierOperator | false;
|
|
1243
|
+
readonly: TSMappedTypeModifierOperator | null;
|
|
1268
1244
|
parent?: Node$1;
|
|
1269
1245
|
}
|
|
1270
|
-
|
|
1271
|
-
|
|
1246
|
+
type TSMappedTypeModifierOperator = true | "+" | "-";
|
|
1247
|
+
interface TSTemplateLiteralType$1 extends Span$1 {
|
|
1248
|
+
type: "TSTemplateLiteralType";
|
|
1249
|
+
quasis: Array<TemplateElement$1>;
|
|
1250
|
+
types: Array<TSType$1>;
|
|
1272
1251
|
parent?: Node$1;
|
|
1273
1252
|
}
|
|
1274
|
-
|
|
1275
|
-
type: "
|
|
1276
|
-
|
|
1253
|
+
interface TSAsExpression$1 extends Span$1 {
|
|
1254
|
+
type: "TSAsExpression";
|
|
1255
|
+
expression: Expression$1;
|
|
1256
|
+
typeAnnotation: TSType$1;
|
|
1277
1257
|
parent?: Node$1;
|
|
1278
1258
|
}
|
|
1279
|
-
|
|
1280
|
-
type: "
|
|
1259
|
+
interface TSSatisfiesExpression$1 extends Span$1 {
|
|
1260
|
+
type: "TSSatisfiesExpression";
|
|
1261
|
+
expression: Expression$1;
|
|
1262
|
+
typeAnnotation: TSType$1;
|
|
1281
1263
|
parent?: Node$1;
|
|
1282
1264
|
}
|
|
1283
|
-
|
|
1284
|
-
type: "
|
|
1265
|
+
interface TSTypeAssertion$1 extends Span$1 {
|
|
1266
|
+
type: "TSTypeAssertion";
|
|
1267
|
+
typeAnnotation: TSType$1;
|
|
1268
|
+
expression: Expression$1;
|
|
1285
1269
|
parent?: Node$1;
|
|
1286
1270
|
}
|
|
1287
|
-
|
|
1288
|
-
type: "
|
|
1289
|
-
|
|
1290
|
-
|
|
1291
|
-
|
|
1271
|
+
interface TSImportEqualsDeclaration$1 extends Span$1 {
|
|
1272
|
+
type: "TSImportEqualsDeclaration";
|
|
1273
|
+
id: BindingIdentifier$1;
|
|
1274
|
+
moduleReference: TSModuleReference;
|
|
1275
|
+
importKind: ImportOrExportKind;
|
|
1292
1276
|
parent?: Node$1;
|
|
1293
1277
|
}
|
|
1294
|
-
|
|
1295
|
-
|
|
1296
|
-
type: "
|
|
1297
|
-
|
|
1298
|
-
prefix: boolean;
|
|
1299
|
-
argument: SimpleAssignmentTarget$1;
|
|
1278
|
+
type TSModuleReference = TSExternalModuleReference | IdentifierReference$1 | TSQualifiedName$1;
|
|
1279
|
+
interface TSExternalModuleReference extends Span$1 {
|
|
1280
|
+
type: "TSExternalModuleReference";
|
|
1281
|
+
expression: StringLiteral$1;
|
|
1300
1282
|
parent?: Node$1;
|
|
1301
1283
|
}
|
|
1302
|
-
|
|
1303
|
-
|
|
1304
|
-
|
|
1305
|
-
name: IdentifierName$1;
|
|
1306
|
-
arguments: Array<Argument$1>;
|
|
1284
|
+
interface TSNonNullExpression$1 extends Span$1 {
|
|
1285
|
+
type: "TSNonNullExpression";
|
|
1286
|
+
expression: Expression$1;
|
|
1307
1287
|
parent?: Node$1;
|
|
1308
1288
|
}
|
|
1309
|
-
|
|
1310
|
-
type: "
|
|
1311
|
-
|
|
1312
|
-
declarations: Array<VariableDeclarator$1>;
|
|
1313
|
-
declare?: boolean;
|
|
1289
|
+
interface Decorator$1 extends Span$1 {
|
|
1290
|
+
type: "Decorator";
|
|
1291
|
+
expression: Expression$1;
|
|
1314
1292
|
parent?: Node$1;
|
|
1315
1293
|
}
|
|
1316
|
-
|
|
1317
|
-
|
|
1318
|
-
|
|
1319
|
-
id: BindingPattern$1;
|
|
1320
|
-
init: Expression$1 | null;
|
|
1321
|
-
definite?: boolean;
|
|
1294
|
+
interface TSExportAssignment$1 extends Span$1 {
|
|
1295
|
+
type: "TSExportAssignment";
|
|
1296
|
+
expression: Expression$1;
|
|
1322
1297
|
parent?: Node$1;
|
|
1323
1298
|
}
|
|
1324
|
-
|
|
1325
|
-
type: "
|
|
1326
|
-
|
|
1327
|
-
body: Statement$1;
|
|
1299
|
+
interface TSNamespaceExportDeclaration$1 extends Span$1 {
|
|
1300
|
+
type: "TSNamespaceExportDeclaration";
|
|
1301
|
+
id: IdentifierName$1;
|
|
1328
1302
|
parent?: Node$1;
|
|
1329
1303
|
}
|
|
1330
|
-
|
|
1331
|
-
type: "
|
|
1332
|
-
|
|
1333
|
-
|
|
1304
|
+
interface TSInstantiationExpression$1 extends Span$1 {
|
|
1305
|
+
type: "TSInstantiationExpression";
|
|
1306
|
+
expression: Expression$1;
|
|
1307
|
+
typeArguments: TSTypeParameterInstantiation$1;
|
|
1334
1308
|
parent?: Node$1;
|
|
1335
1309
|
}
|
|
1336
|
-
|
|
1337
|
-
|
|
1338
|
-
|
|
1339
|
-
|
|
1310
|
+
type ImportOrExportKind = "value" | "type";
|
|
1311
|
+
interface JSDocNullableType$1 extends Span$1 {
|
|
1312
|
+
type: "TSJSDocNullableType";
|
|
1313
|
+
typeAnnotation: TSType$1;
|
|
1314
|
+
postfix: boolean;
|
|
1315
|
+
parent?: Node$1;
|
|
1316
|
+
}
|
|
1317
|
+
interface JSDocNonNullableType$1 extends Span$1 {
|
|
1318
|
+
type: "TSJSDocNonNullableType";
|
|
1319
|
+
typeAnnotation: TSType$1;
|
|
1320
|
+
postfix: boolean;
|
|
1321
|
+
parent?: Node$1;
|
|
1322
|
+
}
|
|
1323
|
+
interface JSDocUnknownType extends Span$1 {
|
|
1324
|
+
type: "TSJSDocUnknownType";
|
|
1340
1325
|
parent?: Node$1;
|
|
1341
1326
|
}
|
|
1327
|
+
type ModuleKind = "script" | "module" | "commonjs";
|
|
1328
|
+
interface Span$1 {
|
|
1329
|
+
start: number;
|
|
1330
|
+
end: number;
|
|
1331
|
+
range?: [number, number];
|
|
1332
|
+
}
|
|
1333
|
+
type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??=";
|
|
1334
|
+
type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "+" | "-" | "*" | "/" | "%" | "**" | "<<" | ">>" | ">>>" | "|" | "^" | "&" | "in" | "instanceof";
|
|
1335
|
+
type LogicalOperator = "||" | "&&" | "??";
|
|
1336
|
+
type UnaryOperator = "+" | "-" | "!" | "~" | "typeof" | "void" | "delete";
|
|
1337
|
+
type UpdateOperator = "++" | "--";
|
|
1338
|
+
type Node$1 = Program$1 | IdentifierName$1 | IdentifierReference$1 | BindingIdentifier$1 | LabelIdentifier$1 | ThisExpression$1 | ArrayExpression$1 | ObjectExpression$1 | ObjectProperty$1 | TemplateLiteral$1 | TaggedTemplateExpression$1 | TemplateElement$1 | ComputedMemberExpression | StaticMemberExpression$1 | PrivateFieldExpression | CallExpression$1 | NewExpression$1 | MetaProperty$1 | SpreadElement$1 | UpdateExpression$1 | UnaryExpression$1 | BinaryExpression$1 | PrivateInExpression$1 | LogicalExpression$1 | ConditionalExpression$1 | AssignmentExpression$1 | ArrayAssignmentTarget | ObjectAssignmentTarget | AssignmentTargetRest | AssignmentTargetWithDefault | AssignmentTargetPropertyIdentifier | AssignmentTargetPropertyProperty | SequenceExpression$1 | Super$1 | AwaitExpression | ChainExpression$1 | ParenthesizedExpression | Directive | Hashbang | BlockStatement$1 | VariableDeclaration$1 | VariableDeclarator$1 | EmptyStatement$1 | ExpressionStatement$1 | IfStatement$1 | DoWhileStatement$1 | WhileStatement$1 | ForStatement$1 | ForInStatement$1 | ForOfStatement$1 | ContinueStatement$1 | BreakStatement$1 | ReturnStatement$1 | WithStatement$1 | SwitchStatement$1 | SwitchCase$1 | LabeledStatement$1 | ThrowStatement$1 | TryStatement$1 | CatchClause$1 | DebuggerStatement | AssignmentPattern$1 | ObjectPattern | BindingProperty$1 | ArrayPattern$1 | BindingRestElement$1 | Function$1 | FunctionBody | ArrowFunctionExpression$1 | YieldExpression$1 | Class$1 | ClassBody$1 | MethodDefinition$1 | PropertyDefinition$1 | PrivateIdentifier$1 | StaticBlock$1 | AccessorProperty$1 | ImportExpression$1 | ImportDeclaration$1 | ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportAttribute$1 | ExportNamedDeclaration$1 | ExportDefaultDeclaration$1 | ExportAllDeclaration$1 | ExportSpecifier | V8IntrinsicExpression | BooleanLiteral$1 | NullLiteral$1 | NumericLiteral$1 | StringLiteral$1 | BigIntLiteral$1 | RegExpLiteral$1 | JSXElement$1 | JSXOpeningElement$1 | JSXClosingElement | JSXFragment$1 | JSXOpeningFragment | JSXClosingFragment | JSXNamespacedName$1 | JSXMemberExpression$1 | JSXExpressionContainer$1 | JSXEmptyExpression | JSXAttribute$1 | JSXSpreadAttribute$1 | JSXIdentifier$1 | JSXSpreadChild$1 | JSXText$1 | TSThisParameter | TSEnumDeclaration$1 | TSEnumBody | TSEnumMember | TSTypeAnnotation$1 | TSLiteralType$1 | TSConditionalType$1 | TSUnionType$1 | TSIntersectionType$1 | TSParenthesizedType$1 | TSTypeOperator$1 | TSArrayType$1 | TSIndexedAccessType$1 | TSTupleType$1 | TSNamedTupleMember$1 | TSOptionalType$1 | TSRestType$1 | TSAnyKeyword | TSStringKeyword | TSBooleanKeyword | TSNumberKeyword | TSNeverKeyword | TSIntrinsicKeyword | TSUnknownKeyword | TSNullKeyword | TSUndefinedKeyword | TSVoidKeyword | TSSymbolKeyword | TSThisType | TSObjectKeyword | TSBigIntKeyword | TSTypeReference$1 | TSQualifiedName$1 | TSTypeParameterInstantiation$1 | TSTypeParameter | TSTypeParameterDeclaration$1 | TSTypeAliasDeclaration$1 | TSClassImplements | TSInterfaceDeclaration$1 | TSInterfaceBody$1 | TSPropertySignature$1 | TSIndexSignature$1 | TSCallSignatureDeclaration$1 | TSMethodSignature$1 | TSConstructSignatureDeclaration$1 | TSIndexSignatureName | TSInterfaceHeritage | TSTypePredicate$1 | TSModuleDeclaration$1 | TSGlobalDeclaration | TSModuleBlock$1 | TSTypeLiteral | TSInferType$1 | TSTypeQuery$1 | TSImportType$1 | TSImportTypeQualifiedName | TSFunctionType$1 | TSConstructorType$1 | TSMappedType$1 | TSTemplateLiteralType$1 | TSAsExpression$1 | TSSatisfiesExpression$1 | TSTypeAssertion$1 | TSImportEqualsDeclaration$1 | TSExternalModuleReference | TSNonNullExpression$1 | Decorator$1 | TSExportAssignment$1 | TSNamespaceExportDeclaration$1 | TSInstantiationExpression$1 | JSDocNullableType$1 | JSDocNonNullableType$1 | JSDocUnknownType | ParamPattern$1;
|
|
1339
|
+
//#endregion
|
|
1340
|
+
//#region src/node.d.ts
|
|
1341
|
+
type Simplify<T> = { [K in keyof T]: T[K]; } & {};
|
|
1342
|
+
type Built<T> = T extends null | undefined ? T : T extends readonly unknown[] ? (number extends T['length'] ? Array<Built<T[number]>> : T) : T extends Span$1 ? { [K in keyof T as K extends keyof Span$1 ? never : K]: Child<T[K]>; } & Partial<Pick<T, keyof Span$1>> : T;
|
|
1343
|
+
type Child<T> = T extends null | undefined ? T : T extends readonly unknown[] ? (number extends T['length'] ? Array<Child<T[number]>> : T) : T extends Span$1 ? Built<T> | T : T;
|
|
1344
|
+
type Program = Simplify<Built<Program$1>>;
|
|
1345
|
+
type Node = Simplify<Built<Node$1>> | Node$1;
|
|
1346
|
+
//#endregion
|
|
1347
|
+
//#region src/ignorer.d.ts
|
|
1348
|
+
interface Ignorer {
|
|
1349
|
+
readonly name: string;
|
|
1350
|
+
shouldIgnore(node: Node, ancestors: readonly Node[]): string | undefined;
|
|
1351
|
+
}
|
|
1342
1352
|
//#endregion
|
|
1343
1353
|
//#region src/Location.schema.d.ts
|
|
1344
1354
|
export declare const Offset: S.Int;
|
|
@@ -1411,19 +1421,20 @@ type Ast = JSAst | TSAst | TsxAst | EmbeddedAst;
|
|
|
1411
1421
|
interface Mutable {
|
|
1412
1422
|
mutatorName: string;
|
|
1413
1423
|
ignoreReason?: string | undefined;
|
|
1414
|
-
replacement:
|
|
1424
|
+
replacement: Node;
|
|
1415
1425
|
}
|
|
1416
1426
|
interface Mutant$1 extends Mutable {
|
|
1417
1427
|
readonly id: Mutant.MutantId;
|
|
1418
1428
|
readonly fileName: string;
|
|
1419
|
-
readonly original:
|
|
1429
|
+
readonly original: Node;
|
|
1420
1430
|
readonly location: Mutant.Location;
|
|
1421
1431
|
readonly replacementCode: string;
|
|
1432
|
+
readonly subsumption?: Mutant.Subsumed;
|
|
1422
1433
|
}
|
|
1423
1434
|
interface MutatorContext {
|
|
1424
|
-
readonly parent:
|
|
1425
|
-
readonly grandParent:
|
|
1426
|
-
readonly ancestors: readonly
|
|
1435
|
+
readonly parent: Node | undefined;
|
|
1436
|
+
readonly grandParent: Node | undefined;
|
|
1437
|
+
readonly ancestors: readonly Node[];
|
|
1427
1438
|
readonly mutantSetPolicy: Options.MutantSetPolicyType;
|
|
1428
1439
|
}
|
|
1429
1440
|
/**
|
|
@@ -1434,7 +1445,7 @@ interface MutatorContext {
|
|
|
1434
1445
|
* two could disagree; the registry's key is now the only place a name is
|
|
1435
1446
|
* written.
|
|
1436
1447
|
*/
|
|
1437
|
-
type Mutator = (node:
|
|
1448
|
+
type Mutator = (node: Node, context: MutatorContext) => Iterable<Node>;
|
|
1438
1449
|
interface MutatorOptions {
|
|
1439
1450
|
excludedMutations: string[];
|
|
1440
1451
|
mutators: MutatorSelection;
|
|
@@ -1457,11 +1468,14 @@ interface MutatorOptions {
|
|
|
1457
1468
|
* Naming each mutator here costs one line when a mutator is added and makes
|
|
1458
1469
|
* that line a compile-checked import instead of a runtime effect.
|
|
1459
1470
|
*
|
|
1460
|
-
*
|
|
1461
|
-
*
|
|
1471
|
+
* Every stock mutator is default-tier: the stock registry declares no opt-in
|
|
1472
|
+
* entries, so `stockRegistry.optIn` is empty. Opt-in is a tier only a plugin
|
|
1473
|
+
* catalog declares for its own entries; a stock name placed in a run's
|
|
1474
|
+
* `mutator.optInMutations` is refused before instrumentation as a config
|
|
1475
|
+
* failure (`NotOptInTier`), because naming a default-tier entry as opt-in
|
|
1476
|
+
* would silently select nothing.
|
|
1462
1477
|
*/
|
|
1463
1478
|
declare const defaultMutators: Readonly<Record<StockCatalog.StockDefaultName, Mutator>>;
|
|
1464
|
-
declare const optInMutators: Readonly<Record<StockCatalog.StockOptInName, Mutator>>;
|
|
1465
1479
|
type MutatorEntry = readonly [name: string, mutate: Mutator];
|
|
1466
1480
|
interface MutatorRegistry {
|
|
1467
1481
|
readonly defaults: Readonly<Record<string, Mutator>>;
|
|
@@ -1499,7 +1513,9 @@ declare const selectMutators: {
|
|
|
1499
1513
|
declare const InstrumentError_base: S.Class<InstrumentError, S.TaggedStruct<"InstrumentError", {
|
|
1500
1514
|
readonly message: S.String;
|
|
1501
1515
|
readonly cause: S.Defect;
|
|
1502
|
-
}>, import("effect/Cause").YieldableError
|
|
1516
|
+
}>, import("effect/Cause").YieldableError & {
|
|
1517
|
+
readonly brand: unique symbol;
|
|
1518
|
+
}>;
|
|
1503
1519
|
declare class InstrumentError extends InstrumentError_base {
|
|
1504
1520
|
get message(): string;
|
|
1505
1521
|
}
|
|
@@ -1550,7 +1566,9 @@ declare const InstrumentFileSkip_base: S.Class<InstrumentFileSkip, S.TaggedStruc
|
|
|
1550
1566
|
readonly file: S.String;
|
|
1551
1567
|
readonly extension: S.String;
|
|
1552
1568
|
readonly reason: S.String;
|
|
1553
|
-
}>, {
|
|
1569
|
+
}>, {
|
|
1570
|
+
readonly brand: unique symbol;
|
|
1571
|
+
}>;
|
|
1554
1572
|
declare class InstrumentFileSkip extends InstrumentFileSkip_base {}
|
|
1555
1573
|
declare const InstrumentResult_base: S.Class<InstrumentResult$1, S.TaggedStruct<"InstrumentResult", {
|
|
1556
1574
|
readonly files: S.$Array<S.Struct<{
|
|
@@ -1625,9 +1643,27 @@ declare const InstrumentResult_base: S.Class<InstrumentResult$1, S.TaggedStruct<
|
|
|
1625
1643
|
readonly static: S.optional<S.Boolean>;
|
|
1626
1644
|
readonly testsCompleted: S.optional<S.Finite>;
|
|
1627
1645
|
readonly description: S.optional<S.String>;
|
|
1646
|
+
readonly subsumption: S.optional<S.Union<readonly [S.TaggedStruct<"Subsumed", {
|
|
1647
|
+
readonly rule: S.Literals<readonly ["complement"]>;
|
|
1648
|
+
readonly dominators: S.NonEmptyArray<S.brand<S.String, "MutantId">>;
|
|
1649
|
+
}>, S.TaggedStruct<"Readmitted", {
|
|
1650
|
+
readonly rule: S.Literals<readonly ["complement"]>;
|
|
1651
|
+
readonly causes: S.NonEmptyArray<S.Struct<{
|
|
1652
|
+
readonly dominator: S.brand<S.String, "MutantId">;
|
|
1653
|
+
readonly code: S.Literals<readonly ["dominator-ignored-at-check", "dominator-compile-error", "dominator-ignored-at-plan", "dominator-remembered-without-running", "dominator-unsettled"]>;
|
|
1654
|
+
readonly detail: S.String;
|
|
1655
|
+
}>>;
|
|
1656
|
+
}>]>>;
|
|
1657
|
+
readonly probeEligibility: S.withDecodingDefaultKey<S.withConstructorDefault<S.Union<readonly [S.TaggedStruct<"Probed", {
|
|
1658
|
+
readonly kind: S.Literals<readonly ["arithmetic", "relational", "unary", "constant"]>;
|
|
1659
|
+
}>, S.TaggedStruct<"Unprobed", {
|
|
1660
|
+
readonly reason: S.Literals<readonly ["mutator-not-probed", "operator-not-probed", "every-reach-infects", "not-a-comparison", "operand-not-proven-local", "shape-not-recognized", "not-decided"]>;
|
|
1661
|
+
}>]>>, never>;
|
|
1628
1662
|
}>>;
|
|
1629
1663
|
readonly skipped: S.$Array<typeof InstrumentFileSkip>;
|
|
1630
|
-
}>, {
|
|
1664
|
+
}>, {
|
|
1665
|
+
readonly brand: unique symbol;
|
|
1666
|
+
}>;
|
|
1631
1667
|
declare class InstrumentResult$1 extends InstrumentResult_base {}
|
|
1632
1668
|
//#endregion
|
|
1633
1669
|
//#region src/Parser.schema.d.ts
|
|
@@ -1639,12 +1675,14 @@ declare const ParseFailed_base: S.Class<ParseFailed, S.TaggedStruct<"ParseFailed
|
|
|
1639
1675
|
readonly column: S.Int;
|
|
1640
1676
|
}>;
|
|
1641
1677
|
readonly cause: S.Defect;
|
|
1642
|
-
}>, import("effect/Cause").YieldableError
|
|
1678
|
+
}>, import("effect/Cause").YieldableError & {
|
|
1679
|
+
readonly brand: unique symbol;
|
|
1680
|
+
}>;
|
|
1643
1681
|
declare class ParseFailed extends ParseFailed_base {
|
|
1644
1682
|
get message(): string;
|
|
1645
1683
|
}
|
|
1646
1684
|
//#endregion
|
|
1647
|
-
//#region src/Parser.
|
|
1685
|
+
//#region src/Parser.d.ts
|
|
1648
1686
|
interface ParserOptions {}
|
|
1649
1687
|
interface ParserContext {
|
|
1650
1688
|
parse: (code: string, fileName: string, scriptFormat: ScriptFormat) => Effect.Effect<ScriptAst, ParseFailed>;
|
|
@@ -1653,7 +1691,9 @@ interface ParserContext {
|
|
|
1653
1691
|
//#region src/print/PrintFailed.schema.d.ts
|
|
1654
1692
|
declare const PrintFailed_base: S.Class<PrintFailed, S.TaggedStruct<"PrintFailed", {
|
|
1655
1693
|
readonly message: S.String;
|
|
1656
|
-
}>, import("effect/Cause").YieldableError
|
|
1694
|
+
}>, import("effect/Cause").YieldableError & {
|
|
1695
|
+
readonly brand: unique symbol;
|
|
1696
|
+
}>;
|
|
1657
1697
|
declare class PrintFailed extends PrintFailed_base {}
|
|
1658
1698
|
//#endregion
|
|
1659
1699
|
//#region src/Printer.d.ts
|
|
@@ -1767,7 +1807,9 @@ declare const InstrumenterContext_base: S.Class<InstrumenterContext, S.Struct<{
|
|
|
1767
1807
|
}>>;
|
|
1768
1808
|
readonly hitCount: S.optional<S.Int>;
|
|
1769
1809
|
readonly hitLimit: S.optional<S.Int>;
|
|
1770
|
-
}>, {
|
|
1810
|
+
}>, {
|
|
1811
|
+
readonly brand: unique symbol;
|
|
1812
|
+
}>;
|
|
1771
1813
|
declare class InstrumenterContext extends InstrumenterContext_base {
|
|
1772
1814
|
static readonly NAMESPACE = "__stryker__";
|
|
1773
1815
|
static readonly MUTATION_COVERAGE_OBJECT = "mutantCoverage";
|
|
@@ -1778,7 +1820,7 @@ declare class InstrumenterContext extends InstrumenterContext_base {
|
|
|
1778
1820
|
static readonly ACTIVE_MUTANT_ENV_VARIABLE = "__STRYKER_ACTIVE_MUTANT__";
|
|
1779
1821
|
}
|
|
1780
1822
|
declare namespace mod_d_exports$2 {
|
|
1781
|
-
export { File, FileDescription, FileDescriptions, InstrumentError, InstrumentFileSkip, InstrumentResult, InstrumenterContext, InstrumenterOptions, MutateDescription, ParserOptions, disableTypeChecks, instrument };
|
|
1823
|
+
export { File, FileDescription, FileDescriptions, InstrumentError, InstrumentFileSkip, InstrumentResult, InstrumenterContext, InstrumenterOptions, MutateDescription, MutateDescriptionSchema, ParserOptions, disableTypeChecks, instrument };
|
|
1782
1824
|
}
|
|
1783
1825
|
//#endregion
|
|
1784
1826
|
//#region src/Location.d.ts
|
|
@@ -1800,7 +1842,7 @@ export declare const offsetAt: {
|
|
|
1800
1842
|
(position: Mutant.Position): (lineStarts: LineStarts) => Option.Option<Offset>;
|
|
1801
1843
|
};
|
|
1802
1844
|
declare namespace mod_d_exports$3 {
|
|
1803
|
-
export { Mutator, MutatorContext, MutatorEntry, MutatorRegistry, MutatorSelection, RegistryCatalog, RegistryContribution, defaultMutators,
|
|
1845
|
+
export { Mutator, MutatorContext, MutatorEntry, MutatorRegistry, MutatorSelection, RegistryCatalog, RegistryContribution, defaultMutators, registryOf, selectMutators, stockRegistry };
|
|
1804
1846
|
}
|
|
1805
1847
|
declare namespace mod_d_exports$4 {
|
|
1806
1848
|
export { LineStarts, Offset, ScriptOrigin, Span };
|