1 | "use strict";
|
---|
2 |
|
---|
3 | Object.defineProperty(exports, "__esModule", {
|
---|
4 | value: true
|
---|
5 | });
|
---|
6 | exports.classMethodOrDeclareMethodCommon = exports.classMethodOrPropertyCommon = exports.patternLikeCommon = exports.functionDeclarationCommon = exports.functionTypeAnnotationCommon = exports.functionCommon = void 0;
|
---|
7 |
|
---|
8 | var _is = require("../validators/is");
|
---|
9 |
|
---|
10 | var _isValidIdentifier = require("../validators/isValidIdentifier");
|
---|
11 |
|
---|
12 | var _helperValidatorIdentifier = require("@babel/helper-validator-identifier");
|
---|
13 |
|
---|
14 | var _constants = require("../constants");
|
---|
15 |
|
---|
16 | var _utils = require("./utils");
|
---|
17 |
|
---|
18 | (0, _utils.default)("ArrayExpression", {
|
---|
19 | fields: {
|
---|
20 | elements: {
|
---|
21 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeOrValueType)("null", "Expression", "SpreadElement"))),
|
---|
22 | default: !process.env.BABEL_TYPES_8_BREAKING ? [] : undefined
|
---|
23 | }
|
---|
24 | },
|
---|
25 | visitor: ["elements"],
|
---|
26 | aliases: ["Expression"]
|
---|
27 | });
|
---|
28 | (0, _utils.default)("AssignmentExpression", {
|
---|
29 | fields: {
|
---|
30 | operator: {
|
---|
31 | validate: function () {
|
---|
32 | if (!process.env.BABEL_TYPES_8_BREAKING) {
|
---|
33 | return (0, _utils.assertValueType)("string");
|
---|
34 | }
|
---|
35 |
|
---|
36 | const identifier = (0, _utils.assertOneOf)(..._constants.ASSIGNMENT_OPERATORS);
|
---|
37 | const pattern = (0, _utils.assertOneOf)("=");
|
---|
38 | return function (node, key, val) {
|
---|
39 | const validator = (0, _is.default)("Pattern", node.left) ? pattern : identifier;
|
---|
40 | validator(node, key, val);
|
---|
41 | };
|
---|
42 | }()
|
---|
43 | },
|
---|
44 | left: {
|
---|
45 | validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("LVal") : (0, _utils.assertNodeType)("Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern")
|
---|
46 | },
|
---|
47 | right: {
|
---|
48 | validate: (0, _utils.assertNodeType)("Expression")
|
---|
49 | }
|
---|
50 | },
|
---|
51 | builder: ["operator", "left", "right"],
|
---|
52 | visitor: ["left", "right"],
|
---|
53 | aliases: ["Expression"]
|
---|
54 | });
|
---|
55 | (0, _utils.default)("BinaryExpression", {
|
---|
56 | builder: ["operator", "left", "right"],
|
---|
57 | fields: {
|
---|
58 | operator: {
|
---|
59 | validate: (0, _utils.assertOneOf)(..._constants.BINARY_OPERATORS)
|
---|
60 | },
|
---|
61 | left: {
|
---|
62 | validate: function () {
|
---|
63 | const expression = (0, _utils.assertNodeType)("Expression");
|
---|
64 | const inOp = (0, _utils.assertNodeType)("Expression", "PrivateName");
|
---|
65 |
|
---|
66 | const validator = function (node, key, val) {
|
---|
67 | const validator = node.operator === "in" ? inOp : expression;
|
---|
68 | validator(node, key, val);
|
---|
69 | };
|
---|
70 |
|
---|
71 | validator.oneOfNodeTypes = ["Expression", "PrivateName"];
|
---|
72 | return validator;
|
---|
73 | }()
|
---|
74 | },
|
---|
75 | right: {
|
---|
76 | validate: (0, _utils.assertNodeType)("Expression")
|
---|
77 | }
|
---|
78 | },
|
---|
79 | visitor: ["left", "right"],
|
---|
80 | aliases: ["Binary", "Expression"]
|
---|
81 | });
|
---|
82 | (0, _utils.default)("InterpreterDirective", {
|
---|
83 | builder: ["value"],
|
---|
84 | fields: {
|
---|
85 | value: {
|
---|
86 | validate: (0, _utils.assertValueType)("string")
|
---|
87 | }
|
---|
88 | }
|
---|
89 | });
|
---|
90 | (0, _utils.default)("Directive", {
|
---|
91 | visitor: ["value"],
|
---|
92 | fields: {
|
---|
93 | value: {
|
---|
94 | validate: (0, _utils.assertNodeType)("DirectiveLiteral")
|
---|
95 | }
|
---|
96 | }
|
---|
97 | });
|
---|
98 | (0, _utils.default)("DirectiveLiteral", {
|
---|
99 | builder: ["value"],
|
---|
100 | fields: {
|
---|
101 | value: {
|
---|
102 | validate: (0, _utils.assertValueType)("string")
|
---|
103 | }
|
---|
104 | }
|
---|
105 | });
|
---|
106 | (0, _utils.default)("BlockStatement", {
|
---|
107 | builder: ["body", "directives"],
|
---|
108 | visitor: ["directives", "body"],
|
---|
109 | fields: {
|
---|
110 | directives: {
|
---|
111 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Directive"))),
|
---|
112 | default: []
|
---|
113 | },
|
---|
114 | body: {
|
---|
115 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
|
---|
116 | }
|
---|
117 | },
|
---|
118 | aliases: ["Scopable", "BlockParent", "Block", "Statement"]
|
---|
119 | });
|
---|
120 | (0, _utils.default)("BreakStatement", {
|
---|
121 | visitor: ["label"],
|
---|
122 | fields: {
|
---|
123 | label: {
|
---|
124 | validate: (0, _utils.assertNodeType)("Identifier"),
|
---|
125 | optional: true
|
---|
126 | }
|
---|
127 | },
|
---|
128 | aliases: ["Statement", "Terminatorless", "CompletionStatement"]
|
---|
129 | });
|
---|
130 | (0, _utils.default)("CallExpression", {
|
---|
131 | visitor: ["callee", "arguments", "typeParameters", "typeArguments"],
|
---|
132 | builder: ["callee", "arguments"],
|
---|
133 | aliases: ["Expression"],
|
---|
134 | fields: Object.assign({
|
---|
135 | callee: {
|
---|
136 | validate: (0, _utils.assertNodeType)("Expression", "V8IntrinsicIdentifier")
|
---|
137 | },
|
---|
138 | arguments: {
|
---|
139 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement", "JSXNamespacedName", "ArgumentPlaceholder")))
|
---|
140 | }
|
---|
141 | }, !process.env.BABEL_TYPES_8_BREAKING ? {
|
---|
142 | optional: {
|
---|
143 | validate: (0, _utils.assertOneOf)(true, false),
|
---|
144 | optional: true
|
---|
145 | }
|
---|
146 | } : {}, {
|
---|
147 | typeArguments: {
|
---|
148 | validate: (0, _utils.assertNodeType)("TypeParameterInstantiation"),
|
---|
149 | optional: true
|
---|
150 | },
|
---|
151 | typeParameters: {
|
---|
152 | validate: (0, _utils.assertNodeType)("TSTypeParameterInstantiation"),
|
---|
153 | optional: true
|
---|
154 | }
|
---|
155 | })
|
---|
156 | });
|
---|
157 | (0, _utils.default)("CatchClause", {
|
---|
158 | visitor: ["param", "body"],
|
---|
159 | fields: {
|
---|
160 | param: {
|
---|
161 | validate: (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern"),
|
---|
162 | optional: true
|
---|
163 | },
|
---|
164 | body: {
|
---|
165 | validate: (0, _utils.assertNodeType)("BlockStatement")
|
---|
166 | }
|
---|
167 | },
|
---|
168 | aliases: ["Scopable", "BlockParent"]
|
---|
169 | });
|
---|
170 | (0, _utils.default)("ConditionalExpression", {
|
---|
171 | visitor: ["test", "consequent", "alternate"],
|
---|
172 | fields: {
|
---|
173 | test: {
|
---|
174 | validate: (0, _utils.assertNodeType)("Expression")
|
---|
175 | },
|
---|
176 | consequent: {
|
---|
177 | validate: (0, _utils.assertNodeType)("Expression")
|
---|
178 | },
|
---|
179 | alternate: {
|
---|
180 | validate: (0, _utils.assertNodeType)("Expression")
|
---|
181 | }
|
---|
182 | },
|
---|
183 | aliases: ["Expression", "Conditional"]
|
---|
184 | });
|
---|
185 | (0, _utils.default)("ContinueStatement", {
|
---|
186 | visitor: ["label"],
|
---|
187 | fields: {
|
---|
188 | label: {
|
---|
189 | validate: (0, _utils.assertNodeType)("Identifier"),
|
---|
190 | optional: true
|
---|
191 | }
|
---|
192 | },
|
---|
193 | aliases: ["Statement", "Terminatorless", "CompletionStatement"]
|
---|
194 | });
|
---|
195 | (0, _utils.default)("DebuggerStatement", {
|
---|
196 | aliases: ["Statement"]
|
---|
197 | });
|
---|
198 | (0, _utils.default)("DoWhileStatement", {
|
---|
199 | visitor: ["test", "body"],
|
---|
200 | fields: {
|
---|
201 | test: {
|
---|
202 | validate: (0, _utils.assertNodeType)("Expression")
|
---|
203 | },
|
---|
204 | body: {
|
---|
205 | validate: (0, _utils.assertNodeType)("Statement")
|
---|
206 | }
|
---|
207 | },
|
---|
208 | aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"]
|
---|
209 | });
|
---|
210 | (0, _utils.default)("EmptyStatement", {
|
---|
211 | aliases: ["Statement"]
|
---|
212 | });
|
---|
213 | (0, _utils.default)("ExpressionStatement", {
|
---|
214 | visitor: ["expression"],
|
---|
215 | fields: {
|
---|
216 | expression: {
|
---|
217 | validate: (0, _utils.assertNodeType)("Expression")
|
---|
218 | }
|
---|
219 | },
|
---|
220 | aliases: ["Statement", "ExpressionWrapper"]
|
---|
221 | });
|
---|
222 | (0, _utils.default)("File", {
|
---|
223 | builder: ["program", "comments", "tokens"],
|
---|
224 | visitor: ["program"],
|
---|
225 | fields: {
|
---|
226 | program: {
|
---|
227 | validate: (0, _utils.assertNodeType)("Program")
|
---|
228 | },
|
---|
229 | comments: {
|
---|
230 | validate: !process.env.BABEL_TYPES_8_BREAKING ? Object.assign(() => {}, {
|
---|
231 | each: {
|
---|
232 | oneOfNodeTypes: ["CommentBlock", "CommentLine"]
|
---|
233 | }
|
---|
234 | }) : (0, _utils.assertEach)((0, _utils.assertNodeType)("CommentBlock", "CommentLine")),
|
---|
235 | optional: true
|
---|
236 | },
|
---|
237 | tokens: {
|
---|
238 | validate: (0, _utils.assertEach)(Object.assign(() => {}, {
|
---|
239 | type: "any"
|
---|
240 | })),
|
---|
241 | optional: true
|
---|
242 | }
|
---|
243 | }
|
---|
244 | });
|
---|
245 | (0, _utils.default)("ForInStatement", {
|
---|
246 | visitor: ["left", "right", "body"],
|
---|
247 | aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"],
|
---|
248 | fields: {
|
---|
249 | left: {
|
---|
250 | validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("VariableDeclaration", "LVal") : (0, _utils.assertNodeType)("VariableDeclaration", "Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern")
|
---|
251 | },
|
---|
252 | right: {
|
---|
253 | validate: (0, _utils.assertNodeType)("Expression")
|
---|
254 | },
|
---|
255 | body: {
|
---|
256 | validate: (0, _utils.assertNodeType)("Statement")
|
---|
257 | }
|
---|
258 | }
|
---|
259 | });
|
---|
260 | (0, _utils.default)("ForStatement", {
|
---|
261 | visitor: ["init", "test", "update", "body"],
|
---|
262 | aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop"],
|
---|
263 | fields: {
|
---|
264 | init: {
|
---|
265 | validate: (0, _utils.assertNodeType)("VariableDeclaration", "Expression"),
|
---|
266 | optional: true
|
---|
267 | },
|
---|
268 | test: {
|
---|
269 | validate: (0, _utils.assertNodeType)("Expression"),
|
---|
270 | optional: true
|
---|
271 | },
|
---|
272 | update: {
|
---|
273 | validate: (0, _utils.assertNodeType)("Expression"),
|
---|
274 | optional: true
|
---|
275 | },
|
---|
276 | body: {
|
---|
277 | validate: (0, _utils.assertNodeType)("Statement")
|
---|
278 | }
|
---|
279 | }
|
---|
280 | });
|
---|
281 | const functionCommon = {
|
---|
282 | params: {
|
---|
283 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Identifier", "Pattern", "RestElement")))
|
---|
284 | },
|
---|
285 | generator: {
|
---|
286 | default: false
|
---|
287 | },
|
---|
288 | async: {
|
---|
289 | default: false
|
---|
290 | }
|
---|
291 | };
|
---|
292 | exports.functionCommon = functionCommon;
|
---|
293 | const functionTypeAnnotationCommon = {
|
---|
294 | returnType: {
|
---|
295 | validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
|
---|
296 | optional: true
|
---|
297 | },
|
---|
298 | typeParameters: {
|
---|
299 | validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
|
---|
300 | optional: true
|
---|
301 | }
|
---|
302 | };
|
---|
303 | exports.functionTypeAnnotationCommon = functionTypeAnnotationCommon;
|
---|
304 | const functionDeclarationCommon = Object.assign({}, functionCommon, {
|
---|
305 | declare: {
|
---|
306 | validate: (0, _utils.assertValueType)("boolean"),
|
---|
307 | optional: true
|
---|
308 | },
|
---|
309 | id: {
|
---|
310 | validate: (0, _utils.assertNodeType)("Identifier"),
|
---|
311 | optional: true
|
---|
312 | }
|
---|
313 | });
|
---|
314 | exports.functionDeclarationCommon = functionDeclarationCommon;
|
---|
315 | (0, _utils.default)("FunctionDeclaration", {
|
---|
316 | builder: ["id", "params", "body", "generator", "async"],
|
---|
317 | visitor: ["id", "params", "body", "returnType", "typeParameters"],
|
---|
318 | fields: Object.assign({}, functionDeclarationCommon, functionTypeAnnotationCommon, {
|
---|
319 | body: {
|
---|
320 | validate: (0, _utils.assertNodeType)("BlockStatement")
|
---|
321 | }
|
---|
322 | }),
|
---|
323 | aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Statement", "Pureish", "Declaration"],
|
---|
324 | validate: function () {
|
---|
325 | if (!process.env.BABEL_TYPES_8_BREAKING) return () => {};
|
---|
326 | const identifier = (0, _utils.assertNodeType)("Identifier");
|
---|
327 | return function (parent, key, node) {
|
---|
328 | if (!(0, _is.default)("ExportDefaultDeclaration", parent)) {
|
---|
329 | identifier(node, "id", node.id);
|
---|
330 | }
|
---|
331 | };
|
---|
332 | }()
|
---|
333 | });
|
---|
334 | (0, _utils.default)("FunctionExpression", {
|
---|
335 | inherits: "FunctionDeclaration",
|
---|
336 | aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"],
|
---|
337 | fields: Object.assign({}, functionCommon, functionTypeAnnotationCommon, {
|
---|
338 | id: {
|
---|
339 | validate: (0, _utils.assertNodeType)("Identifier"),
|
---|
340 | optional: true
|
---|
341 | },
|
---|
342 | body: {
|
---|
343 | validate: (0, _utils.assertNodeType)("BlockStatement")
|
---|
344 | }
|
---|
345 | })
|
---|
346 | });
|
---|
347 | const patternLikeCommon = {
|
---|
348 | typeAnnotation: {
|
---|
349 | validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
|
---|
350 | optional: true
|
---|
351 | },
|
---|
352 | decorators: {
|
---|
353 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator")))
|
---|
354 | }
|
---|
355 | };
|
---|
356 | exports.patternLikeCommon = patternLikeCommon;
|
---|
357 | (0, _utils.default)("Identifier", {
|
---|
358 | builder: ["name"],
|
---|
359 | visitor: ["typeAnnotation", "decorators"],
|
---|
360 | aliases: ["Expression", "PatternLike", "LVal", "TSEntityName"],
|
---|
361 | fields: Object.assign({}, patternLikeCommon, {
|
---|
362 | name: {
|
---|
363 | validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), Object.assign(function (node, key, val) {
|
---|
364 | if (!process.env.BABEL_TYPES_8_BREAKING) return;
|
---|
365 |
|
---|
366 | if (!(0, _isValidIdentifier.default)(val, false)) {
|
---|
367 | throw new TypeError(`"${val}" is not a valid identifier name`);
|
---|
368 | }
|
---|
369 | }, {
|
---|
370 | type: "string"
|
---|
371 | }))
|
---|
372 | },
|
---|
373 | optional: {
|
---|
374 | validate: (0, _utils.assertValueType)("boolean"),
|
---|
375 | optional: true
|
---|
376 | }
|
---|
377 | }),
|
---|
378 |
|
---|
379 | validate(parent, key, node) {
|
---|
380 | if (!process.env.BABEL_TYPES_8_BREAKING) return;
|
---|
381 | const match = /\.(\w+)$/.exec(key);
|
---|
382 | if (!match) return;
|
---|
383 | const [, parentKey] = match;
|
---|
384 | const nonComp = {
|
---|
385 | computed: false
|
---|
386 | };
|
---|
387 |
|
---|
388 | if (parentKey === "property") {
|
---|
389 | if ((0, _is.default)("MemberExpression", parent, nonComp)) return;
|
---|
390 | if ((0, _is.default)("OptionalMemberExpression", parent, nonComp)) return;
|
---|
391 | } else if (parentKey === "key") {
|
---|
392 | if ((0, _is.default)("Property", parent, nonComp)) return;
|
---|
393 | if ((0, _is.default)("Method", parent, nonComp)) return;
|
---|
394 | } else if (parentKey === "exported") {
|
---|
395 | if ((0, _is.default)("ExportSpecifier", parent)) return;
|
---|
396 | } else if (parentKey === "imported") {
|
---|
397 | if ((0, _is.default)("ImportSpecifier", parent, {
|
---|
398 | imported: node
|
---|
399 | })) return;
|
---|
400 | } else if (parentKey === "meta") {
|
---|
401 | if ((0, _is.default)("MetaProperty", parent, {
|
---|
402 | meta: node
|
---|
403 | })) return;
|
---|
404 | }
|
---|
405 |
|
---|
406 | if (((0, _helperValidatorIdentifier.isKeyword)(node.name) || (0, _helperValidatorIdentifier.isReservedWord)(node.name, false)) && node.name !== "this") {
|
---|
407 | throw new TypeError(`"${node.name}" is not a valid identifier`);
|
---|
408 | }
|
---|
409 | }
|
---|
410 |
|
---|
411 | });
|
---|
412 | (0, _utils.default)("IfStatement", {
|
---|
413 | visitor: ["test", "consequent", "alternate"],
|
---|
414 | aliases: ["Statement", "Conditional"],
|
---|
415 | fields: {
|
---|
416 | test: {
|
---|
417 | validate: (0, _utils.assertNodeType)("Expression")
|
---|
418 | },
|
---|
419 | consequent: {
|
---|
420 | validate: (0, _utils.assertNodeType)("Statement")
|
---|
421 | },
|
---|
422 | alternate: {
|
---|
423 | optional: true,
|
---|
424 | validate: (0, _utils.assertNodeType)("Statement")
|
---|
425 | }
|
---|
426 | }
|
---|
427 | });
|
---|
428 | (0, _utils.default)("LabeledStatement", {
|
---|
429 | visitor: ["label", "body"],
|
---|
430 | aliases: ["Statement"],
|
---|
431 | fields: {
|
---|
432 | label: {
|
---|
433 | validate: (0, _utils.assertNodeType)("Identifier")
|
---|
434 | },
|
---|
435 | body: {
|
---|
436 | validate: (0, _utils.assertNodeType)("Statement")
|
---|
437 | }
|
---|
438 | }
|
---|
439 | });
|
---|
440 | (0, _utils.default)("StringLiteral", {
|
---|
441 | builder: ["value"],
|
---|
442 | fields: {
|
---|
443 | value: {
|
---|
444 | validate: (0, _utils.assertValueType)("string")
|
---|
445 | }
|
---|
446 | },
|
---|
447 | aliases: ["Expression", "Pureish", "Literal", "Immutable"]
|
---|
448 | });
|
---|
449 | (0, _utils.default)("NumericLiteral", {
|
---|
450 | builder: ["value"],
|
---|
451 | deprecatedAlias: "NumberLiteral",
|
---|
452 | fields: {
|
---|
453 | value: {
|
---|
454 | validate: (0, _utils.assertValueType)("number")
|
---|
455 | }
|
---|
456 | },
|
---|
457 | aliases: ["Expression", "Pureish", "Literal", "Immutable"]
|
---|
458 | });
|
---|
459 | (0, _utils.default)("NullLiteral", {
|
---|
460 | aliases: ["Expression", "Pureish", "Literal", "Immutable"]
|
---|
461 | });
|
---|
462 | (0, _utils.default)("BooleanLiteral", {
|
---|
463 | builder: ["value"],
|
---|
464 | fields: {
|
---|
465 | value: {
|
---|
466 | validate: (0, _utils.assertValueType)("boolean")
|
---|
467 | }
|
---|
468 | },
|
---|
469 | aliases: ["Expression", "Pureish", "Literal", "Immutable"]
|
---|
470 | });
|
---|
471 | (0, _utils.default)("RegExpLiteral", {
|
---|
472 | builder: ["pattern", "flags"],
|
---|
473 | deprecatedAlias: "RegexLiteral",
|
---|
474 | aliases: ["Expression", "Pureish", "Literal"],
|
---|
475 | fields: {
|
---|
476 | pattern: {
|
---|
477 | validate: (0, _utils.assertValueType)("string")
|
---|
478 | },
|
---|
479 | flags: {
|
---|
480 | validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), Object.assign(function (node, key, val) {
|
---|
481 | if (!process.env.BABEL_TYPES_8_BREAKING) return;
|
---|
482 | const invalid = /[^gimsuy]/.exec(val);
|
---|
483 |
|
---|
484 | if (invalid) {
|
---|
485 | throw new TypeError(`"${invalid[0]}" is not a valid RegExp flag`);
|
---|
486 | }
|
---|
487 | }, {
|
---|
488 | type: "string"
|
---|
489 | })),
|
---|
490 | default: ""
|
---|
491 | }
|
---|
492 | }
|
---|
493 | });
|
---|
494 | (0, _utils.default)("LogicalExpression", {
|
---|
495 | builder: ["operator", "left", "right"],
|
---|
496 | visitor: ["left", "right"],
|
---|
497 | aliases: ["Binary", "Expression"],
|
---|
498 | fields: {
|
---|
499 | operator: {
|
---|
500 | validate: (0, _utils.assertOneOf)(..._constants.LOGICAL_OPERATORS)
|
---|
501 | },
|
---|
502 | left: {
|
---|
503 | validate: (0, _utils.assertNodeType)("Expression")
|
---|
504 | },
|
---|
505 | right: {
|
---|
506 | validate: (0, _utils.assertNodeType)("Expression")
|
---|
507 | }
|
---|
508 | }
|
---|
509 | });
|
---|
510 | (0, _utils.default)("MemberExpression", {
|
---|
511 | builder: ["object", "property", "computed", ...(!process.env.BABEL_TYPES_8_BREAKING ? ["optional"] : [])],
|
---|
512 | visitor: ["object", "property"],
|
---|
513 | aliases: ["Expression", "LVal"],
|
---|
514 | fields: Object.assign({
|
---|
515 | object: {
|
---|
516 | validate: (0, _utils.assertNodeType)("Expression")
|
---|
517 | },
|
---|
518 | property: {
|
---|
519 | validate: function () {
|
---|
520 | const normal = (0, _utils.assertNodeType)("Identifier", "PrivateName");
|
---|
521 | const computed = (0, _utils.assertNodeType)("Expression");
|
---|
522 |
|
---|
523 | const validator = function (node, key, val) {
|
---|
524 | const validator = node.computed ? computed : normal;
|
---|
525 | validator(node, key, val);
|
---|
526 | };
|
---|
527 |
|
---|
528 | validator.oneOfNodeTypes = ["Expression", "Identifier", "PrivateName"];
|
---|
529 | return validator;
|
---|
530 | }()
|
---|
531 | },
|
---|
532 | computed: {
|
---|
533 | default: false
|
---|
534 | }
|
---|
535 | }, !process.env.BABEL_TYPES_8_BREAKING ? {
|
---|
536 | optional: {
|
---|
537 | validate: (0, _utils.assertOneOf)(true, false),
|
---|
538 | optional: true
|
---|
539 | }
|
---|
540 | } : {})
|
---|
541 | });
|
---|
542 | (0, _utils.default)("NewExpression", {
|
---|
543 | inherits: "CallExpression"
|
---|
544 | });
|
---|
545 | (0, _utils.default)("Program", {
|
---|
546 | visitor: ["directives", "body"],
|
---|
547 | builder: ["body", "directives", "sourceType", "interpreter"],
|
---|
548 | fields: {
|
---|
549 | sourceFile: {
|
---|
550 | validate: (0, _utils.assertValueType)("string")
|
---|
551 | },
|
---|
552 | sourceType: {
|
---|
553 | validate: (0, _utils.assertOneOf)("script", "module"),
|
---|
554 | default: "script"
|
---|
555 | },
|
---|
556 | interpreter: {
|
---|
557 | validate: (0, _utils.assertNodeType)("InterpreterDirective"),
|
---|
558 | default: null,
|
---|
559 | optional: true
|
---|
560 | },
|
---|
561 | directives: {
|
---|
562 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Directive"))),
|
---|
563 | default: []
|
---|
564 | },
|
---|
565 | body: {
|
---|
566 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
|
---|
567 | }
|
---|
568 | },
|
---|
569 | aliases: ["Scopable", "BlockParent", "Block"]
|
---|
570 | });
|
---|
571 | (0, _utils.default)("ObjectExpression", {
|
---|
572 | visitor: ["properties"],
|
---|
573 | aliases: ["Expression"],
|
---|
574 | fields: {
|
---|
575 | properties: {
|
---|
576 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ObjectMethod", "ObjectProperty", "SpreadElement")))
|
---|
577 | }
|
---|
578 | }
|
---|
579 | });
|
---|
580 | (0, _utils.default)("ObjectMethod", {
|
---|
581 | builder: ["kind", "key", "params", "body", "computed", "generator", "async"],
|
---|
582 | fields: Object.assign({}, functionCommon, functionTypeAnnotationCommon, {
|
---|
583 | kind: Object.assign({
|
---|
584 | validate: (0, _utils.assertOneOf)("method", "get", "set")
|
---|
585 | }, !process.env.BABEL_TYPES_8_BREAKING ? {
|
---|
586 | default: "method"
|
---|
587 | } : {}),
|
---|
588 | computed: {
|
---|
589 | default: false
|
---|
590 | },
|
---|
591 | key: {
|
---|
592 | validate: function () {
|
---|
593 | const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral");
|
---|
594 | const computed = (0, _utils.assertNodeType)("Expression");
|
---|
595 |
|
---|
596 | const validator = function (node, key, val) {
|
---|
597 | const validator = node.computed ? computed : normal;
|
---|
598 | validator(node, key, val);
|
---|
599 | };
|
---|
600 |
|
---|
601 | validator.oneOfNodeTypes = ["Expression", "Identifier", "StringLiteral", "NumericLiteral"];
|
---|
602 | return validator;
|
---|
603 | }()
|
---|
604 | },
|
---|
605 | decorators: {
|
---|
606 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
|
---|
607 | optional: true
|
---|
608 | },
|
---|
609 | body: {
|
---|
610 | validate: (0, _utils.assertNodeType)("BlockStatement")
|
---|
611 | }
|
---|
612 | }),
|
---|
613 | visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
|
---|
614 | aliases: ["UserWhitespacable", "Function", "Scopable", "BlockParent", "FunctionParent", "Method", "ObjectMember"]
|
---|
615 | });
|
---|
616 | (0, _utils.default)("ObjectProperty", {
|
---|
617 | builder: ["key", "value", "computed", "shorthand", ...(!process.env.BABEL_TYPES_8_BREAKING ? ["decorators"] : [])],
|
---|
618 | fields: {
|
---|
619 | computed: {
|
---|
620 | default: false
|
---|
621 | },
|
---|
622 | key: {
|
---|
623 | validate: function () {
|
---|
624 | const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral");
|
---|
625 | const computed = (0, _utils.assertNodeType)("Expression");
|
---|
626 |
|
---|
627 | const validator = function (node, key, val) {
|
---|
628 | const validator = node.computed ? computed : normal;
|
---|
629 | validator(node, key, val);
|
---|
630 | };
|
---|
631 |
|
---|
632 | validator.oneOfNodeTypes = ["Expression", "Identifier", "StringLiteral", "NumericLiteral"];
|
---|
633 | return validator;
|
---|
634 | }()
|
---|
635 | },
|
---|
636 | value: {
|
---|
637 | validate: (0, _utils.assertNodeType)("Expression", "PatternLike")
|
---|
638 | },
|
---|
639 | shorthand: {
|
---|
640 | validate: (0, _utils.chain)((0, _utils.assertValueType)("boolean"), Object.assign(function (node, key, val) {
|
---|
641 | if (!process.env.BABEL_TYPES_8_BREAKING) return;
|
---|
642 |
|
---|
643 | if (val && node.computed) {
|
---|
644 | throw new TypeError("Property shorthand of ObjectProperty cannot be true if computed is true");
|
---|
645 | }
|
---|
646 | }, {
|
---|
647 | type: "boolean"
|
---|
648 | }), function (node, key, val) {
|
---|
649 | if (!process.env.BABEL_TYPES_8_BREAKING) return;
|
---|
650 |
|
---|
651 | if (val && !(0, _is.default)("Identifier", node.key)) {
|
---|
652 | throw new TypeError("Property shorthand of ObjectProperty cannot be true if key is not an Identifier");
|
---|
653 | }
|
---|
654 | }),
|
---|
655 | default: false
|
---|
656 | },
|
---|
657 | decorators: {
|
---|
658 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
|
---|
659 | optional: true
|
---|
660 | }
|
---|
661 | },
|
---|
662 | visitor: ["key", "value", "decorators"],
|
---|
663 | aliases: ["UserWhitespacable", "Property", "ObjectMember"],
|
---|
664 | validate: function () {
|
---|
665 | const pattern = (0, _utils.assertNodeType)("Identifier", "Pattern");
|
---|
666 | const expression = (0, _utils.assertNodeType)("Expression");
|
---|
667 | return function (parent, key, node) {
|
---|
668 | if (!process.env.BABEL_TYPES_8_BREAKING) return;
|
---|
669 | const validator = (0, _is.default)("ObjectPattern", parent) ? pattern : expression;
|
---|
670 | validator(node, "value", node.value);
|
---|
671 | };
|
---|
672 | }()
|
---|
673 | });
|
---|
674 | (0, _utils.default)("RestElement", {
|
---|
675 | visitor: ["argument", "typeAnnotation"],
|
---|
676 | builder: ["argument"],
|
---|
677 | aliases: ["LVal", "PatternLike"],
|
---|
678 | deprecatedAlias: "RestProperty",
|
---|
679 | fields: Object.assign({}, patternLikeCommon, {
|
---|
680 | argument: {
|
---|
681 | validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("LVal") : (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern", "MemberExpression")
|
---|
682 | },
|
---|
683 | optional: {
|
---|
684 | validate: (0, _utils.assertValueType)("boolean"),
|
---|
685 | optional: true
|
---|
686 | }
|
---|
687 | }),
|
---|
688 |
|
---|
689 | validate(parent, key) {
|
---|
690 | if (!process.env.BABEL_TYPES_8_BREAKING) return;
|
---|
691 | const match = /(\w+)\[(\d+)\]/.exec(key);
|
---|
692 | if (!match) throw new Error("Internal Babel error: malformed key.");
|
---|
693 | const [, listKey, index] = match;
|
---|
694 |
|
---|
695 | if (parent[listKey].length > index + 1) {
|
---|
696 | throw new TypeError(`RestElement must be last element of ${listKey}`);
|
---|
697 | }
|
---|
698 | }
|
---|
699 |
|
---|
700 | });
|
---|
701 | (0, _utils.default)("ReturnStatement", {
|
---|
702 | visitor: ["argument"],
|
---|
703 | aliases: ["Statement", "Terminatorless", "CompletionStatement"],
|
---|
704 | fields: {
|
---|
705 | argument: {
|
---|
706 | validate: (0, _utils.assertNodeType)("Expression"),
|
---|
707 | optional: true
|
---|
708 | }
|
---|
709 | }
|
---|
710 | });
|
---|
711 | (0, _utils.default)("SequenceExpression", {
|
---|
712 | visitor: ["expressions"],
|
---|
713 | fields: {
|
---|
714 | expressions: {
|
---|
715 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression")))
|
---|
716 | }
|
---|
717 | },
|
---|
718 | aliases: ["Expression"]
|
---|
719 | });
|
---|
720 | (0, _utils.default)("ParenthesizedExpression", {
|
---|
721 | visitor: ["expression"],
|
---|
722 | aliases: ["Expression", "ExpressionWrapper"],
|
---|
723 | fields: {
|
---|
724 | expression: {
|
---|
725 | validate: (0, _utils.assertNodeType)("Expression")
|
---|
726 | }
|
---|
727 | }
|
---|
728 | });
|
---|
729 | (0, _utils.default)("SwitchCase", {
|
---|
730 | visitor: ["test", "consequent"],
|
---|
731 | fields: {
|
---|
732 | test: {
|
---|
733 | validate: (0, _utils.assertNodeType)("Expression"),
|
---|
734 | optional: true
|
---|
735 | },
|
---|
736 | consequent: {
|
---|
737 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
|
---|
738 | }
|
---|
739 | }
|
---|
740 | });
|
---|
741 | (0, _utils.default)("SwitchStatement", {
|
---|
742 | visitor: ["discriminant", "cases"],
|
---|
743 | aliases: ["Statement", "BlockParent", "Scopable"],
|
---|
744 | fields: {
|
---|
745 | discriminant: {
|
---|
746 | validate: (0, _utils.assertNodeType)("Expression")
|
---|
747 | },
|
---|
748 | cases: {
|
---|
749 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("SwitchCase")))
|
---|
750 | }
|
---|
751 | }
|
---|
752 | });
|
---|
753 | (0, _utils.default)("ThisExpression", {
|
---|
754 | aliases: ["Expression"]
|
---|
755 | });
|
---|
756 | (0, _utils.default)("ThrowStatement", {
|
---|
757 | visitor: ["argument"],
|
---|
758 | aliases: ["Statement", "Terminatorless", "CompletionStatement"],
|
---|
759 | fields: {
|
---|
760 | argument: {
|
---|
761 | validate: (0, _utils.assertNodeType)("Expression")
|
---|
762 | }
|
---|
763 | }
|
---|
764 | });
|
---|
765 | (0, _utils.default)("TryStatement", {
|
---|
766 | visitor: ["block", "handler", "finalizer"],
|
---|
767 | aliases: ["Statement"],
|
---|
768 | fields: {
|
---|
769 | block: {
|
---|
770 | validate: (0, _utils.chain)((0, _utils.assertNodeType)("BlockStatement"), Object.assign(function (node) {
|
---|
771 | if (!process.env.BABEL_TYPES_8_BREAKING) return;
|
---|
772 |
|
---|
773 | if (!node.handler && !node.finalizer) {
|
---|
774 | throw new TypeError("TryStatement expects either a handler or finalizer, or both");
|
---|
775 | }
|
---|
776 | }, {
|
---|
777 | oneOfNodeTypes: ["BlockStatement"]
|
---|
778 | }))
|
---|
779 | },
|
---|
780 | handler: {
|
---|
781 | optional: true,
|
---|
782 | validate: (0, _utils.assertNodeType)("CatchClause")
|
---|
783 | },
|
---|
784 | finalizer: {
|
---|
785 | optional: true,
|
---|
786 | validate: (0, _utils.assertNodeType)("BlockStatement")
|
---|
787 | }
|
---|
788 | }
|
---|
789 | });
|
---|
790 | (0, _utils.default)("UnaryExpression", {
|
---|
791 | builder: ["operator", "argument", "prefix"],
|
---|
792 | fields: {
|
---|
793 | prefix: {
|
---|
794 | default: true
|
---|
795 | },
|
---|
796 | argument: {
|
---|
797 | validate: (0, _utils.assertNodeType)("Expression")
|
---|
798 | },
|
---|
799 | operator: {
|
---|
800 | validate: (0, _utils.assertOneOf)(..._constants.UNARY_OPERATORS)
|
---|
801 | }
|
---|
802 | },
|
---|
803 | visitor: ["argument"],
|
---|
804 | aliases: ["UnaryLike", "Expression"]
|
---|
805 | });
|
---|
806 | (0, _utils.default)("UpdateExpression", {
|
---|
807 | builder: ["operator", "argument", "prefix"],
|
---|
808 | fields: {
|
---|
809 | prefix: {
|
---|
810 | default: false
|
---|
811 | },
|
---|
812 | argument: {
|
---|
813 | validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("Expression") : (0, _utils.assertNodeType)("Identifier", "MemberExpression")
|
---|
814 | },
|
---|
815 | operator: {
|
---|
816 | validate: (0, _utils.assertOneOf)(..._constants.UPDATE_OPERATORS)
|
---|
817 | }
|
---|
818 | },
|
---|
819 | visitor: ["argument"],
|
---|
820 | aliases: ["Expression"]
|
---|
821 | });
|
---|
822 | (0, _utils.default)("VariableDeclaration", {
|
---|
823 | builder: ["kind", "declarations"],
|
---|
824 | visitor: ["declarations"],
|
---|
825 | aliases: ["Statement", "Declaration"],
|
---|
826 | fields: {
|
---|
827 | declare: {
|
---|
828 | validate: (0, _utils.assertValueType)("boolean"),
|
---|
829 | optional: true
|
---|
830 | },
|
---|
831 | kind: {
|
---|
832 | validate: (0, _utils.assertOneOf)("var", "let", "const")
|
---|
833 | },
|
---|
834 | declarations: {
|
---|
835 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("VariableDeclarator")))
|
---|
836 | }
|
---|
837 | },
|
---|
838 |
|
---|
839 | validate(parent, key, node) {
|
---|
840 | if (!process.env.BABEL_TYPES_8_BREAKING) return;
|
---|
841 | if (!(0, _is.default)("ForXStatement", parent, {
|
---|
842 | left: node
|
---|
843 | })) return;
|
---|
844 |
|
---|
845 | if (node.declarations.length !== 1) {
|
---|
846 | throw new TypeError(`Exactly one VariableDeclarator is required in the VariableDeclaration of a ${parent.type}`);
|
---|
847 | }
|
---|
848 | }
|
---|
849 |
|
---|
850 | });
|
---|
851 | (0, _utils.default)("VariableDeclarator", {
|
---|
852 | visitor: ["id", "init"],
|
---|
853 | fields: {
|
---|
854 | id: {
|
---|
855 | validate: function () {
|
---|
856 | if (!process.env.BABEL_TYPES_8_BREAKING) {
|
---|
857 | return (0, _utils.assertNodeType)("LVal");
|
---|
858 | }
|
---|
859 |
|
---|
860 | const normal = (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern");
|
---|
861 | const without = (0, _utils.assertNodeType)("Identifier");
|
---|
862 | return function (node, key, val) {
|
---|
863 | const validator = node.init ? normal : without;
|
---|
864 | validator(node, key, val);
|
---|
865 | };
|
---|
866 | }()
|
---|
867 | },
|
---|
868 | definite: {
|
---|
869 | optional: true,
|
---|
870 | validate: (0, _utils.assertValueType)("boolean")
|
---|
871 | },
|
---|
872 | init: {
|
---|
873 | optional: true,
|
---|
874 | validate: (0, _utils.assertNodeType)("Expression")
|
---|
875 | }
|
---|
876 | }
|
---|
877 | });
|
---|
878 | (0, _utils.default)("WhileStatement", {
|
---|
879 | visitor: ["test", "body"],
|
---|
880 | aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"],
|
---|
881 | fields: {
|
---|
882 | test: {
|
---|
883 | validate: (0, _utils.assertNodeType)("Expression")
|
---|
884 | },
|
---|
885 | body: {
|
---|
886 | validate: (0, _utils.assertNodeType)("Statement")
|
---|
887 | }
|
---|
888 | }
|
---|
889 | });
|
---|
890 | (0, _utils.default)("WithStatement", {
|
---|
891 | visitor: ["object", "body"],
|
---|
892 | aliases: ["Statement"],
|
---|
893 | fields: {
|
---|
894 | object: {
|
---|
895 | validate: (0, _utils.assertNodeType)("Expression")
|
---|
896 | },
|
---|
897 | body: {
|
---|
898 | validate: (0, _utils.assertNodeType)("Statement")
|
---|
899 | }
|
---|
900 | }
|
---|
901 | });
|
---|
902 | (0, _utils.default)("AssignmentPattern", {
|
---|
903 | visitor: ["left", "right", "decorators"],
|
---|
904 | builder: ["left", "right"],
|
---|
905 | aliases: ["Pattern", "PatternLike", "LVal"],
|
---|
906 | fields: Object.assign({}, patternLikeCommon, {
|
---|
907 | left: {
|
---|
908 | validate: (0, _utils.assertNodeType)("Identifier", "ObjectPattern", "ArrayPattern", "MemberExpression")
|
---|
909 | },
|
---|
910 | right: {
|
---|
911 | validate: (0, _utils.assertNodeType)("Expression")
|
---|
912 | },
|
---|
913 | decorators: {
|
---|
914 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
|
---|
915 | optional: true
|
---|
916 | }
|
---|
917 | })
|
---|
918 | });
|
---|
919 | (0, _utils.default)("ArrayPattern", {
|
---|
920 | visitor: ["elements", "typeAnnotation"],
|
---|
921 | builder: ["elements"],
|
---|
922 | aliases: ["Pattern", "PatternLike", "LVal"],
|
---|
923 | fields: Object.assign({}, patternLikeCommon, {
|
---|
924 | elements: {
|
---|
925 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeOrValueType)("null", "PatternLike")))
|
---|
926 | },
|
---|
927 | decorators: {
|
---|
928 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
|
---|
929 | optional: true
|
---|
930 | },
|
---|
931 | optional: {
|
---|
932 | validate: (0, _utils.assertValueType)("boolean"),
|
---|
933 | optional: true
|
---|
934 | }
|
---|
935 | })
|
---|
936 | });
|
---|
937 | (0, _utils.default)("ArrowFunctionExpression", {
|
---|
938 | builder: ["params", "body", "async"],
|
---|
939 | visitor: ["params", "body", "returnType", "typeParameters"],
|
---|
940 | aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"],
|
---|
941 | fields: Object.assign({}, functionCommon, functionTypeAnnotationCommon, {
|
---|
942 | expression: {
|
---|
943 | validate: (0, _utils.assertValueType)("boolean")
|
---|
944 | },
|
---|
945 | body: {
|
---|
946 | validate: (0, _utils.assertNodeType)("BlockStatement", "Expression")
|
---|
947 | }
|
---|
948 | })
|
---|
949 | });
|
---|
950 | (0, _utils.default)("ClassBody", {
|
---|
951 | visitor: ["body"],
|
---|
952 | fields: {
|
---|
953 | body: {
|
---|
954 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ClassMethod", "ClassPrivateMethod", "ClassProperty", "ClassPrivateProperty", "TSDeclareMethod", "TSIndexSignature")))
|
---|
955 | }
|
---|
956 | }
|
---|
957 | });
|
---|
958 | (0, _utils.default)("ClassExpression", {
|
---|
959 | builder: ["id", "superClass", "body", "decorators"],
|
---|
960 | visitor: ["id", "body", "superClass", "mixins", "typeParameters", "superTypeParameters", "implements", "decorators"],
|
---|
961 | aliases: ["Scopable", "Class", "Expression"],
|
---|
962 | fields: {
|
---|
963 | id: {
|
---|
964 | validate: (0, _utils.assertNodeType)("Identifier"),
|
---|
965 | optional: true
|
---|
966 | },
|
---|
967 | typeParameters: {
|
---|
968 | validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
|
---|
969 | optional: true
|
---|
970 | },
|
---|
971 | body: {
|
---|
972 | validate: (0, _utils.assertNodeType)("ClassBody")
|
---|
973 | },
|
---|
974 | superClass: {
|
---|
975 | optional: true,
|
---|
976 | validate: (0, _utils.assertNodeType)("Expression")
|
---|
977 | },
|
---|
978 | superTypeParameters: {
|
---|
979 | validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
|
---|
980 | optional: true
|
---|
981 | },
|
---|
982 | implements: {
|
---|
983 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSExpressionWithTypeArguments", "ClassImplements"))),
|
---|
984 | optional: true
|
---|
985 | },
|
---|
986 | decorators: {
|
---|
987 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
|
---|
988 | optional: true
|
---|
989 | },
|
---|
990 | mixins: {
|
---|
991 | validate: (0, _utils.assertNodeType)("InterfaceExtends"),
|
---|
992 | optional: true
|
---|
993 | }
|
---|
994 | }
|
---|
995 | });
|
---|
996 | (0, _utils.default)("ClassDeclaration", {
|
---|
997 | inherits: "ClassExpression",
|
---|
998 | aliases: ["Scopable", "Class", "Statement", "Declaration"],
|
---|
999 | fields: {
|
---|
1000 | id: {
|
---|
1001 | validate: (0, _utils.assertNodeType)("Identifier")
|
---|
1002 | },
|
---|
1003 | typeParameters: {
|
---|
1004 | validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
|
---|
1005 | optional: true
|
---|
1006 | },
|
---|
1007 | body: {
|
---|
1008 | validate: (0, _utils.assertNodeType)("ClassBody")
|
---|
1009 | },
|
---|
1010 | superClass: {
|
---|
1011 | optional: true,
|
---|
1012 | validate: (0, _utils.assertNodeType)("Expression")
|
---|
1013 | },
|
---|
1014 | superTypeParameters: {
|
---|
1015 | validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
|
---|
1016 | optional: true
|
---|
1017 | },
|
---|
1018 | implements: {
|
---|
1019 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSExpressionWithTypeArguments", "ClassImplements"))),
|
---|
1020 | optional: true
|
---|
1021 | },
|
---|
1022 | decorators: {
|
---|
1023 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
|
---|
1024 | optional: true
|
---|
1025 | },
|
---|
1026 | mixins: {
|
---|
1027 | validate: (0, _utils.assertNodeType)("InterfaceExtends"),
|
---|
1028 | optional: true
|
---|
1029 | },
|
---|
1030 | declare: {
|
---|
1031 | validate: (0, _utils.assertValueType)("boolean"),
|
---|
1032 | optional: true
|
---|
1033 | },
|
---|
1034 | abstract: {
|
---|
1035 | validate: (0, _utils.assertValueType)("boolean"),
|
---|
1036 | optional: true
|
---|
1037 | }
|
---|
1038 | },
|
---|
1039 | validate: function () {
|
---|
1040 | const identifier = (0, _utils.assertNodeType)("Identifier");
|
---|
1041 | return function (parent, key, node) {
|
---|
1042 | if (!process.env.BABEL_TYPES_8_BREAKING) return;
|
---|
1043 |
|
---|
1044 | if (!(0, _is.default)("ExportDefaultDeclaration", parent)) {
|
---|
1045 | identifier(node, "id", node.id);
|
---|
1046 | }
|
---|
1047 | };
|
---|
1048 | }()
|
---|
1049 | });
|
---|
1050 | (0, _utils.default)("ExportAllDeclaration", {
|
---|
1051 | visitor: ["source"],
|
---|
1052 | aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"],
|
---|
1053 | fields: {
|
---|
1054 | source: {
|
---|
1055 | validate: (0, _utils.assertNodeType)("StringLiteral")
|
---|
1056 | },
|
---|
1057 | exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value")),
|
---|
1058 | assertions: {
|
---|
1059 | optional: true,
|
---|
1060 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportAttribute")))
|
---|
1061 | }
|
---|
1062 | }
|
---|
1063 | });
|
---|
1064 | (0, _utils.default)("ExportDefaultDeclaration", {
|
---|
1065 | visitor: ["declaration"],
|
---|
1066 | aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"],
|
---|
1067 | fields: {
|
---|
1068 | declaration: {
|
---|
1069 | validate: (0, _utils.assertNodeType)("FunctionDeclaration", "TSDeclareFunction", "ClassDeclaration", "Expression")
|
---|
1070 | },
|
---|
1071 | exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("value"))
|
---|
1072 | }
|
---|
1073 | });
|
---|
1074 | (0, _utils.default)("ExportNamedDeclaration", {
|
---|
1075 | visitor: ["declaration", "specifiers", "source"],
|
---|
1076 | aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"],
|
---|
1077 | fields: {
|
---|
1078 | declaration: {
|
---|
1079 | optional: true,
|
---|
1080 | validate: (0, _utils.chain)((0, _utils.assertNodeType)("Declaration"), Object.assign(function (node, key, val) {
|
---|
1081 | if (!process.env.BABEL_TYPES_8_BREAKING) return;
|
---|
1082 |
|
---|
1083 | if (val && node.specifiers.length) {
|
---|
1084 | throw new TypeError("Only declaration or specifiers is allowed on ExportNamedDeclaration");
|
---|
1085 | }
|
---|
1086 | }, {
|
---|
1087 | oneOfNodeTypes: ["Declaration"]
|
---|
1088 | }), function (node, key, val) {
|
---|
1089 | if (!process.env.BABEL_TYPES_8_BREAKING) return;
|
---|
1090 |
|
---|
1091 | if (val && node.source) {
|
---|
1092 | throw new TypeError("Cannot export a declaration from a source");
|
---|
1093 | }
|
---|
1094 | })
|
---|
1095 | },
|
---|
1096 | assertions: {
|
---|
1097 | optional: true,
|
---|
1098 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportAttribute")))
|
---|
1099 | },
|
---|
1100 | specifiers: {
|
---|
1101 | default: [],
|
---|
1102 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)(function () {
|
---|
1103 | const sourced = (0, _utils.assertNodeType)("ExportSpecifier", "ExportDefaultSpecifier", "ExportNamespaceSpecifier");
|
---|
1104 | const sourceless = (0, _utils.assertNodeType)("ExportSpecifier");
|
---|
1105 | if (!process.env.BABEL_TYPES_8_BREAKING) return sourced;
|
---|
1106 | return function (node, key, val) {
|
---|
1107 | const validator = node.source ? sourced : sourceless;
|
---|
1108 | validator(node, key, val);
|
---|
1109 | };
|
---|
1110 | }()))
|
---|
1111 | },
|
---|
1112 | source: {
|
---|
1113 | validate: (0, _utils.assertNodeType)("StringLiteral"),
|
---|
1114 | optional: true
|
---|
1115 | },
|
---|
1116 | exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value"))
|
---|
1117 | }
|
---|
1118 | });
|
---|
1119 | (0, _utils.default)("ExportSpecifier", {
|
---|
1120 | visitor: ["local", "exported"],
|
---|
1121 | aliases: ["ModuleSpecifier"],
|
---|
1122 | fields: {
|
---|
1123 | local: {
|
---|
1124 | validate: (0, _utils.assertNodeType)("Identifier")
|
---|
1125 | },
|
---|
1126 | exported: {
|
---|
1127 | validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral")
|
---|
1128 | }
|
---|
1129 | }
|
---|
1130 | });
|
---|
1131 | (0, _utils.default)("ForOfStatement", {
|
---|
1132 | visitor: ["left", "right", "body"],
|
---|
1133 | builder: ["left", "right", "body", "await"],
|
---|
1134 | aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"],
|
---|
1135 | fields: {
|
---|
1136 | left: {
|
---|
1137 | validate: function () {
|
---|
1138 | if (!process.env.BABEL_TYPES_8_BREAKING) {
|
---|
1139 | return (0, _utils.assertNodeType)("VariableDeclaration", "LVal");
|
---|
1140 | }
|
---|
1141 |
|
---|
1142 | const declaration = (0, _utils.assertNodeType)("VariableDeclaration");
|
---|
1143 | const lval = (0, _utils.assertNodeType)("Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern");
|
---|
1144 | return function (node, key, val) {
|
---|
1145 | if ((0, _is.default)("VariableDeclaration", val)) {
|
---|
1146 | declaration(node, key, val);
|
---|
1147 | } else {
|
---|
1148 | lval(node, key, val);
|
---|
1149 | }
|
---|
1150 | };
|
---|
1151 | }()
|
---|
1152 | },
|
---|
1153 | right: {
|
---|
1154 | validate: (0, _utils.assertNodeType)("Expression")
|
---|
1155 | },
|
---|
1156 | body: {
|
---|
1157 | validate: (0, _utils.assertNodeType)("Statement")
|
---|
1158 | },
|
---|
1159 | await: {
|
---|
1160 | default: false
|
---|
1161 | }
|
---|
1162 | }
|
---|
1163 | });
|
---|
1164 | (0, _utils.default)("ImportDeclaration", {
|
---|
1165 | visitor: ["specifiers", "source"],
|
---|
1166 | aliases: ["Statement", "Declaration", "ModuleDeclaration"],
|
---|
1167 | fields: {
|
---|
1168 | assertions: {
|
---|
1169 | optional: true,
|
---|
1170 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportAttribute")))
|
---|
1171 | },
|
---|
1172 | specifiers: {
|
---|
1173 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportSpecifier", "ImportDefaultSpecifier", "ImportNamespaceSpecifier")))
|
---|
1174 | },
|
---|
1175 | source: {
|
---|
1176 | validate: (0, _utils.assertNodeType)("StringLiteral")
|
---|
1177 | },
|
---|
1178 | importKind: {
|
---|
1179 | validate: (0, _utils.assertOneOf)("type", "typeof", "value"),
|
---|
1180 | optional: true
|
---|
1181 | }
|
---|
1182 | }
|
---|
1183 | });
|
---|
1184 | (0, _utils.default)("ImportDefaultSpecifier", {
|
---|
1185 | visitor: ["local"],
|
---|
1186 | aliases: ["ModuleSpecifier"],
|
---|
1187 | fields: {
|
---|
1188 | local: {
|
---|
1189 | validate: (0, _utils.assertNodeType)("Identifier")
|
---|
1190 | }
|
---|
1191 | }
|
---|
1192 | });
|
---|
1193 | (0, _utils.default)("ImportNamespaceSpecifier", {
|
---|
1194 | visitor: ["local"],
|
---|
1195 | aliases: ["ModuleSpecifier"],
|
---|
1196 | fields: {
|
---|
1197 | local: {
|
---|
1198 | validate: (0, _utils.assertNodeType)("Identifier")
|
---|
1199 | }
|
---|
1200 | }
|
---|
1201 | });
|
---|
1202 | (0, _utils.default)("ImportSpecifier", {
|
---|
1203 | visitor: ["local", "imported"],
|
---|
1204 | aliases: ["ModuleSpecifier"],
|
---|
1205 | fields: {
|
---|
1206 | local: {
|
---|
1207 | validate: (0, _utils.assertNodeType)("Identifier")
|
---|
1208 | },
|
---|
1209 | imported: {
|
---|
1210 | validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral")
|
---|
1211 | },
|
---|
1212 | importKind: {
|
---|
1213 | validate: (0, _utils.assertOneOf)("type", "typeof"),
|
---|
1214 | optional: true
|
---|
1215 | }
|
---|
1216 | }
|
---|
1217 | });
|
---|
1218 | (0, _utils.default)("MetaProperty", {
|
---|
1219 | visitor: ["meta", "property"],
|
---|
1220 | aliases: ["Expression"],
|
---|
1221 | fields: {
|
---|
1222 | meta: {
|
---|
1223 | validate: (0, _utils.chain)((0, _utils.assertNodeType)("Identifier"), Object.assign(function (node, key, val) {
|
---|
1224 | if (!process.env.BABEL_TYPES_8_BREAKING) return;
|
---|
1225 | let property;
|
---|
1226 |
|
---|
1227 | switch (val.name) {
|
---|
1228 | case "function":
|
---|
1229 | property = "sent";
|
---|
1230 | break;
|
---|
1231 |
|
---|
1232 | case "new":
|
---|
1233 | property = "target";
|
---|
1234 | break;
|
---|
1235 |
|
---|
1236 | case "import":
|
---|
1237 | property = "meta";
|
---|
1238 | break;
|
---|
1239 | }
|
---|
1240 |
|
---|
1241 | if (!(0, _is.default)("Identifier", node.property, {
|
---|
1242 | name: property
|
---|
1243 | })) {
|
---|
1244 | throw new TypeError("Unrecognised MetaProperty");
|
---|
1245 | }
|
---|
1246 | }, {
|
---|
1247 | oneOfNodeTypes: ["Identifier"]
|
---|
1248 | }))
|
---|
1249 | },
|
---|
1250 | property: {
|
---|
1251 | validate: (0, _utils.assertNodeType)("Identifier")
|
---|
1252 | }
|
---|
1253 | }
|
---|
1254 | });
|
---|
1255 | const classMethodOrPropertyCommon = {
|
---|
1256 | abstract: {
|
---|
1257 | validate: (0, _utils.assertValueType)("boolean"),
|
---|
1258 | optional: true
|
---|
1259 | },
|
---|
1260 | accessibility: {
|
---|
1261 | validate: (0, _utils.assertOneOf)("public", "private", "protected"),
|
---|
1262 | optional: true
|
---|
1263 | },
|
---|
1264 | static: {
|
---|
1265 | default: false
|
---|
1266 | },
|
---|
1267 | override: {
|
---|
1268 | default: false
|
---|
1269 | },
|
---|
1270 | computed: {
|
---|
1271 | default: false
|
---|
1272 | },
|
---|
1273 | optional: {
|
---|
1274 | validate: (0, _utils.assertValueType)("boolean"),
|
---|
1275 | optional: true
|
---|
1276 | },
|
---|
1277 | key: {
|
---|
1278 | validate: (0, _utils.chain)(function () {
|
---|
1279 | const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral");
|
---|
1280 | const computed = (0, _utils.assertNodeType)("Expression");
|
---|
1281 | return function (node, key, val) {
|
---|
1282 | const validator = node.computed ? computed : normal;
|
---|
1283 | validator(node, key, val);
|
---|
1284 | };
|
---|
1285 | }(), (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "Expression"))
|
---|
1286 | }
|
---|
1287 | };
|
---|
1288 | exports.classMethodOrPropertyCommon = classMethodOrPropertyCommon;
|
---|
1289 | const classMethodOrDeclareMethodCommon = Object.assign({}, functionCommon, classMethodOrPropertyCommon, {
|
---|
1290 | params: {
|
---|
1291 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Identifier", "Pattern", "RestElement", "TSParameterProperty")))
|
---|
1292 | },
|
---|
1293 | kind: {
|
---|
1294 | validate: (0, _utils.assertOneOf)("get", "set", "method", "constructor"),
|
---|
1295 | default: "method"
|
---|
1296 | },
|
---|
1297 | access: {
|
---|
1298 | validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("public", "private", "protected")),
|
---|
1299 | optional: true
|
---|
1300 | },
|
---|
1301 | decorators: {
|
---|
1302 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
|
---|
1303 | optional: true
|
---|
1304 | }
|
---|
1305 | });
|
---|
1306 | exports.classMethodOrDeclareMethodCommon = classMethodOrDeclareMethodCommon;
|
---|
1307 | (0, _utils.default)("ClassMethod", {
|
---|
1308 | aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method"],
|
---|
1309 | builder: ["kind", "key", "params", "body", "computed", "static", "generator", "async"],
|
---|
1310 | visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
|
---|
1311 | fields: Object.assign({}, classMethodOrDeclareMethodCommon, functionTypeAnnotationCommon, {
|
---|
1312 | body: {
|
---|
1313 | validate: (0, _utils.assertNodeType)("BlockStatement")
|
---|
1314 | }
|
---|
1315 | })
|
---|
1316 | });
|
---|
1317 | (0, _utils.default)("ObjectPattern", {
|
---|
1318 | visitor: ["properties", "typeAnnotation", "decorators"],
|
---|
1319 | builder: ["properties"],
|
---|
1320 | aliases: ["Pattern", "PatternLike", "LVal"],
|
---|
1321 | fields: Object.assign({}, patternLikeCommon, {
|
---|
1322 | properties: {
|
---|
1323 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("RestElement", "ObjectProperty")))
|
---|
1324 | }
|
---|
1325 | })
|
---|
1326 | });
|
---|
1327 | (0, _utils.default)("SpreadElement", {
|
---|
1328 | visitor: ["argument"],
|
---|
1329 | aliases: ["UnaryLike"],
|
---|
1330 | deprecatedAlias: "SpreadProperty",
|
---|
1331 | fields: {
|
---|
1332 | argument: {
|
---|
1333 | validate: (0, _utils.assertNodeType)("Expression")
|
---|
1334 | }
|
---|
1335 | }
|
---|
1336 | });
|
---|
1337 | (0, _utils.default)("Super", {
|
---|
1338 | aliases: ["Expression"]
|
---|
1339 | });
|
---|
1340 | (0, _utils.default)("TaggedTemplateExpression", {
|
---|
1341 | visitor: ["tag", "quasi", "typeParameters"],
|
---|
1342 | builder: ["tag", "quasi"],
|
---|
1343 | aliases: ["Expression"],
|
---|
1344 | fields: {
|
---|
1345 | tag: {
|
---|
1346 | validate: (0, _utils.assertNodeType)("Expression")
|
---|
1347 | },
|
---|
1348 | quasi: {
|
---|
1349 | validate: (0, _utils.assertNodeType)("TemplateLiteral")
|
---|
1350 | },
|
---|
1351 | typeParameters: {
|
---|
1352 | validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
|
---|
1353 | optional: true
|
---|
1354 | }
|
---|
1355 | }
|
---|
1356 | });
|
---|
1357 | (0, _utils.default)("TemplateElement", {
|
---|
1358 | builder: ["value", "tail"],
|
---|
1359 | fields: {
|
---|
1360 | value: {
|
---|
1361 | validate: (0, _utils.assertShape)({
|
---|
1362 | raw: {
|
---|
1363 | validate: (0, _utils.assertValueType)("string")
|
---|
1364 | },
|
---|
1365 | cooked: {
|
---|
1366 | validate: (0, _utils.assertValueType)("string"),
|
---|
1367 | optional: true
|
---|
1368 | }
|
---|
1369 | })
|
---|
1370 | },
|
---|
1371 | tail: {
|
---|
1372 | default: false
|
---|
1373 | }
|
---|
1374 | }
|
---|
1375 | });
|
---|
1376 | (0, _utils.default)("TemplateLiteral", {
|
---|
1377 | visitor: ["quasis", "expressions"],
|
---|
1378 | aliases: ["Expression", "Literal"],
|
---|
1379 | fields: {
|
---|
1380 | quasis: {
|
---|
1381 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TemplateElement")))
|
---|
1382 | },
|
---|
1383 | expressions: {
|
---|
1384 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "TSType")), function (node, key, val) {
|
---|
1385 | if (node.quasis.length !== val.length + 1) {
|
---|
1386 | throw new TypeError(`Number of ${node.type} quasis should be exactly one more than the number of expressions.\nExpected ${val.length + 1} quasis but got ${node.quasis.length}`);
|
---|
1387 | }
|
---|
1388 | })
|
---|
1389 | }
|
---|
1390 | }
|
---|
1391 | });
|
---|
1392 | (0, _utils.default)("YieldExpression", {
|
---|
1393 | builder: ["argument", "delegate"],
|
---|
1394 | visitor: ["argument"],
|
---|
1395 | aliases: ["Expression", "Terminatorless"],
|
---|
1396 | fields: {
|
---|
1397 | delegate: {
|
---|
1398 | validate: (0, _utils.chain)((0, _utils.assertValueType)("boolean"), Object.assign(function (node, key, val) {
|
---|
1399 | if (!process.env.BABEL_TYPES_8_BREAKING) return;
|
---|
1400 |
|
---|
1401 | if (val && !node.argument) {
|
---|
1402 | throw new TypeError("Property delegate of YieldExpression cannot be true if there is no argument");
|
---|
1403 | }
|
---|
1404 | }, {
|
---|
1405 | type: "boolean"
|
---|
1406 | })),
|
---|
1407 | default: false
|
---|
1408 | },
|
---|
1409 | argument: {
|
---|
1410 | optional: true,
|
---|
1411 | validate: (0, _utils.assertNodeType)("Expression")
|
---|
1412 | }
|
---|
1413 | }
|
---|
1414 | });
|
---|
1415 | (0, _utils.default)("AwaitExpression", {
|
---|
1416 | builder: ["argument"],
|
---|
1417 | visitor: ["argument"],
|
---|
1418 | aliases: ["Expression", "Terminatorless"],
|
---|
1419 | fields: {
|
---|
1420 | argument: {
|
---|
1421 | validate: (0, _utils.assertNodeType)("Expression")
|
---|
1422 | }
|
---|
1423 | }
|
---|
1424 | });
|
---|
1425 | (0, _utils.default)("Import", {
|
---|
1426 | aliases: ["Expression"]
|
---|
1427 | });
|
---|
1428 | (0, _utils.default)("BigIntLiteral", {
|
---|
1429 | builder: ["value"],
|
---|
1430 | fields: {
|
---|
1431 | value: {
|
---|
1432 | validate: (0, _utils.assertValueType)("string")
|
---|
1433 | }
|
---|
1434 | },
|
---|
1435 | aliases: ["Expression", "Pureish", "Literal", "Immutable"]
|
---|
1436 | });
|
---|
1437 | (0, _utils.default)("ExportNamespaceSpecifier", {
|
---|
1438 | visitor: ["exported"],
|
---|
1439 | aliases: ["ModuleSpecifier"],
|
---|
1440 | fields: {
|
---|
1441 | exported: {
|
---|
1442 | validate: (0, _utils.assertNodeType)("Identifier")
|
---|
1443 | }
|
---|
1444 | }
|
---|
1445 | });
|
---|
1446 | (0, _utils.default)("OptionalMemberExpression", {
|
---|
1447 | builder: ["object", "property", "computed", "optional"],
|
---|
1448 | visitor: ["object", "property"],
|
---|
1449 | aliases: ["Expression"],
|
---|
1450 | fields: {
|
---|
1451 | object: {
|
---|
1452 | validate: (0, _utils.assertNodeType)("Expression")
|
---|
1453 | },
|
---|
1454 | property: {
|
---|
1455 | validate: function () {
|
---|
1456 | const normal = (0, _utils.assertNodeType)("Identifier");
|
---|
1457 | const computed = (0, _utils.assertNodeType)("Expression");
|
---|
1458 |
|
---|
1459 | const validator = function (node, key, val) {
|
---|
1460 | const validator = node.computed ? computed : normal;
|
---|
1461 | validator(node, key, val);
|
---|
1462 | };
|
---|
1463 |
|
---|
1464 | validator.oneOfNodeTypes = ["Expression", "Identifier"];
|
---|
1465 | return validator;
|
---|
1466 | }()
|
---|
1467 | },
|
---|
1468 | computed: {
|
---|
1469 | default: false
|
---|
1470 | },
|
---|
1471 | optional: {
|
---|
1472 | validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertValueType)("boolean") : (0, _utils.chain)((0, _utils.assertValueType)("boolean"), (0, _utils.assertOptionalChainStart)())
|
---|
1473 | }
|
---|
1474 | }
|
---|
1475 | });
|
---|
1476 | (0, _utils.default)("OptionalCallExpression", {
|
---|
1477 | visitor: ["callee", "arguments", "typeParameters", "typeArguments"],
|
---|
1478 | builder: ["callee", "arguments", "optional"],
|
---|
1479 | aliases: ["Expression"],
|
---|
1480 | fields: {
|
---|
1481 | callee: {
|
---|
1482 | validate: (0, _utils.assertNodeType)("Expression")
|
---|
1483 | },
|
---|
1484 | arguments: {
|
---|
1485 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement", "JSXNamespacedName", "ArgumentPlaceholder")))
|
---|
1486 | },
|
---|
1487 | optional: {
|
---|
1488 | validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertValueType)("boolean") : (0, _utils.chain)((0, _utils.assertValueType)("boolean"), (0, _utils.assertOptionalChainStart)())
|
---|
1489 | },
|
---|
1490 | typeArguments: {
|
---|
1491 | validate: (0, _utils.assertNodeType)("TypeParameterInstantiation"),
|
---|
1492 | optional: true
|
---|
1493 | },
|
---|
1494 | typeParameters: {
|
---|
1495 | validate: (0, _utils.assertNodeType)("TSTypeParameterInstantiation"),
|
---|
1496 | optional: true
|
---|
1497 | }
|
---|
1498 | }
|
---|
1499 | });
|
---|
1500 | (0, _utils.default)("ClassProperty", {
|
---|
1501 | visitor: ["key", "value", "typeAnnotation", "decorators"],
|
---|
1502 | builder: ["key", "value", "typeAnnotation", "decorators", "computed", "static"],
|
---|
1503 | aliases: ["Property"],
|
---|
1504 | fields: Object.assign({}, classMethodOrPropertyCommon, {
|
---|
1505 | value: {
|
---|
1506 | validate: (0, _utils.assertNodeType)("Expression"),
|
---|
1507 | optional: true
|
---|
1508 | },
|
---|
1509 | definite: {
|
---|
1510 | validate: (0, _utils.assertValueType)("boolean"),
|
---|
1511 | optional: true
|
---|
1512 | },
|
---|
1513 | typeAnnotation: {
|
---|
1514 | validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
|
---|
1515 | optional: true
|
---|
1516 | },
|
---|
1517 | decorators: {
|
---|
1518 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
|
---|
1519 | optional: true
|
---|
1520 | },
|
---|
1521 | readonly: {
|
---|
1522 | validate: (0, _utils.assertValueType)("boolean"),
|
---|
1523 | optional: true
|
---|
1524 | },
|
---|
1525 | declare: {
|
---|
1526 | validate: (0, _utils.assertValueType)("boolean"),
|
---|
1527 | optional: true
|
---|
1528 | },
|
---|
1529 | variance: {
|
---|
1530 | validate: (0, _utils.assertNodeType)("Variance"),
|
---|
1531 | optional: true
|
---|
1532 | }
|
---|
1533 | })
|
---|
1534 | });
|
---|
1535 | (0, _utils.default)("ClassPrivateProperty", {
|
---|
1536 | visitor: ["key", "value", "decorators", "typeAnnotation"],
|
---|
1537 | builder: ["key", "value", "decorators", "static"],
|
---|
1538 | aliases: ["Property", "Private"],
|
---|
1539 | fields: {
|
---|
1540 | key: {
|
---|
1541 | validate: (0, _utils.assertNodeType)("PrivateName")
|
---|
1542 | },
|
---|
1543 | value: {
|
---|
1544 | validate: (0, _utils.assertNodeType)("Expression"),
|
---|
1545 | optional: true
|
---|
1546 | },
|
---|
1547 | typeAnnotation: {
|
---|
1548 | validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
|
---|
1549 | optional: true
|
---|
1550 | },
|
---|
1551 | decorators: {
|
---|
1552 | validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
|
---|
1553 | optional: true
|
---|
1554 | },
|
---|
1555 | readonly: {
|
---|
1556 | validate: (0, _utils.assertValueType)("boolean"),
|
---|
1557 | optional: true
|
---|
1558 | },
|
---|
1559 | definite: {
|
---|
1560 | validate: (0, _utils.assertValueType)("boolean"),
|
---|
1561 | optional: true
|
---|
1562 | },
|
---|
1563 | variance: {
|
---|
1564 | validate: (0, _utils.assertNodeType)("Variance"),
|
---|
1565 | optional: true
|
---|
1566 | }
|
---|
1567 | }
|
---|
1568 | });
|
---|
1569 | (0, _utils.default)("ClassPrivateMethod", {
|
---|
1570 | builder: ["kind", "key", "params", "body", "static"],
|
---|
1571 | visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
|
---|
1572 | aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method", "Private"],
|
---|
1573 | fields: Object.assign({}, classMethodOrDeclareMethodCommon, functionTypeAnnotationCommon, {
|
---|
1574 | key: {
|
---|
1575 | validate: (0, _utils.assertNodeType)("PrivateName")
|
---|
1576 | },
|
---|
1577 | body: {
|
---|
1578 | validate: (0, _utils.assertNodeType)("BlockStatement")
|
---|
1579 | }
|
---|
1580 | })
|
---|
1581 | });
|
---|
1582 | (0, _utils.default)("PrivateName", {
|
---|
1583 | visitor: ["id"],
|
---|
1584 | aliases: ["Private"],
|
---|
1585 | fields: {
|
---|
1586 | id: {
|
---|
1587 | validate: (0, _utils.assertNodeType)("Identifier")
|
---|
1588 | }
|
---|
1589 | }
|
---|
1590 | }); |
---|