| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", { |
| value: true |
| }); |
| exports.patternLikeCommon = exports.functionTypeAnnotationCommon = exports.functionDeclarationCommon = exports.functionCommon = exports.classMethodOrPropertyCommon = exports.classMethodOrDeclareMethodCommon = void 0; |
| |
| var _is = require("../validators/is"); |
| |
| var _isValidIdentifier = require("../validators/isValidIdentifier"); |
| |
| var _helperValidatorIdentifier = require("@babel/helper-validator-identifier"); |
| |
| var _constants = require("../constants"); |
| |
| var _utils = require("./utils"); |
| |
| const defineType = (0, _utils.defineAliasedType)("Standardized"); |
| defineType("ArrayExpression", { |
| fields: { |
| elements: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeOrValueType)("null", "Expression", "SpreadElement"))), |
| default: !process.env.BABEL_TYPES_8_BREAKING ? [] : undefined |
| } |
| }, |
| visitor: ["elements"], |
| aliases: ["Expression"] |
| }); |
| defineType("AssignmentExpression", { |
| fields: { |
| operator: { |
| validate: function () { |
| if (!process.env.BABEL_TYPES_8_BREAKING) { |
| return (0, _utils.assertValueType)("string"); |
| } |
| |
| const identifier = (0, _utils.assertOneOf)(..._constants.ASSIGNMENT_OPERATORS); |
| const pattern = (0, _utils.assertOneOf)("="); |
| return function (node, key, val) { |
| const validator = (0, _is.default)("Pattern", node.left) ? pattern : identifier; |
| validator(node, key, val); |
| }; |
| }() |
| }, |
| left: { |
| validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("LVal") : (0, _utils.assertNodeType)("Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern") |
| }, |
| right: { |
| validate: (0, _utils.assertNodeType)("Expression") |
| } |
| }, |
| builder: ["operator", "left", "right"], |
| visitor: ["left", "right"], |
| aliases: ["Expression"] |
| }); |
| defineType("BinaryExpression", { |
| builder: ["operator", "left", "right"], |
| fields: { |
| operator: { |
| validate: (0, _utils.assertOneOf)(..._constants.BINARY_OPERATORS) |
| }, |
| left: { |
| validate: function () { |
| const expression = (0, _utils.assertNodeType)("Expression"); |
| const inOp = (0, _utils.assertNodeType)("Expression", "PrivateName"); |
| |
| const validator = function (node, key, val) { |
| const validator = node.operator === "in" ? inOp : expression; |
| validator(node, key, val); |
| }; |
| |
| validator.oneOfNodeTypes = ["Expression", "PrivateName"]; |
| return validator; |
| }() |
| }, |
| right: { |
| validate: (0, _utils.assertNodeType)("Expression") |
| } |
| }, |
| visitor: ["left", "right"], |
| aliases: ["Binary", "Expression"] |
| }); |
| defineType("InterpreterDirective", { |
| builder: ["value"], |
| fields: { |
| value: { |
| validate: (0, _utils.assertValueType)("string") |
| } |
| } |
| }); |
| defineType("Directive", { |
| visitor: ["value"], |
| fields: { |
| value: { |
| validate: (0, _utils.assertNodeType)("DirectiveLiteral") |
| } |
| } |
| }); |
| defineType("DirectiveLiteral", { |
| builder: ["value"], |
| fields: { |
| value: { |
| validate: (0, _utils.assertValueType)("string") |
| } |
| } |
| }); |
| defineType("BlockStatement", { |
| builder: ["body", "directives"], |
| visitor: ["directives", "body"], |
| fields: { |
| directives: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Directive"))), |
| default: [] |
| }, |
| body: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement"))) |
| } |
| }, |
| aliases: ["Scopable", "BlockParent", "Block", "Statement"] |
| }); |
| defineType("BreakStatement", { |
| visitor: ["label"], |
| fields: { |
| label: { |
| validate: (0, _utils.assertNodeType)("Identifier"), |
| optional: true |
| } |
| }, |
| aliases: ["Statement", "Terminatorless", "CompletionStatement"] |
| }); |
| defineType("CallExpression", { |
| visitor: ["callee", "arguments", "typeParameters", "typeArguments"], |
| builder: ["callee", "arguments"], |
| aliases: ["Expression"], |
| fields: Object.assign({ |
| callee: { |
| validate: (0, _utils.assertNodeType)("Expression", "V8IntrinsicIdentifier") |
| }, |
| arguments: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement", "JSXNamespacedName", "ArgumentPlaceholder"))) |
| } |
| }, !process.env.BABEL_TYPES_8_BREAKING ? { |
| optional: { |
| validate: (0, _utils.assertOneOf)(true, false), |
| optional: true |
| } |
| } : {}, { |
| typeArguments: { |
| validate: (0, _utils.assertNodeType)("TypeParameterInstantiation"), |
| optional: true |
| }, |
| typeParameters: { |
| validate: (0, _utils.assertNodeType)("TSTypeParameterInstantiation"), |
| optional: true |
| } |
| }) |
| }); |
| defineType("CatchClause", { |
| visitor: ["param", "body"], |
| fields: { |
| param: { |
| validate: (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern"), |
| optional: true |
| }, |
| body: { |
| validate: (0, _utils.assertNodeType)("BlockStatement") |
| } |
| }, |
| aliases: ["Scopable", "BlockParent"] |
| }); |
| defineType("ConditionalExpression", { |
| visitor: ["test", "consequent", "alternate"], |
| fields: { |
| test: { |
| validate: (0, _utils.assertNodeType)("Expression") |
| }, |
| consequent: { |
| validate: (0, _utils.assertNodeType)("Expression") |
| }, |
| alternate: { |
| validate: (0, _utils.assertNodeType)("Expression") |
| } |
| }, |
| aliases: ["Expression", "Conditional"] |
| }); |
| defineType("ContinueStatement", { |
| visitor: ["label"], |
| fields: { |
| label: { |
| validate: (0, _utils.assertNodeType)("Identifier"), |
| optional: true |
| } |
| }, |
| aliases: ["Statement", "Terminatorless", "CompletionStatement"] |
| }); |
| defineType("DebuggerStatement", { |
| aliases: ["Statement"] |
| }); |
| defineType("DoWhileStatement", { |
| visitor: ["test", "body"], |
| fields: { |
| test: { |
| validate: (0, _utils.assertNodeType)("Expression") |
| }, |
| body: { |
| validate: (0, _utils.assertNodeType)("Statement") |
| } |
| }, |
| aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"] |
| }); |
| defineType("EmptyStatement", { |
| aliases: ["Statement"] |
| }); |
| defineType("ExpressionStatement", { |
| visitor: ["expression"], |
| fields: { |
| expression: { |
| validate: (0, _utils.assertNodeType)("Expression") |
| } |
| }, |
| aliases: ["Statement", "ExpressionWrapper"] |
| }); |
| defineType("File", { |
| builder: ["program", "comments", "tokens"], |
| visitor: ["program"], |
| fields: { |
| program: { |
| validate: (0, _utils.assertNodeType)("Program") |
| }, |
| comments: { |
| validate: !process.env.BABEL_TYPES_8_BREAKING ? Object.assign(() => {}, { |
| each: { |
| oneOfNodeTypes: ["CommentBlock", "CommentLine"] |
| } |
| }) : (0, _utils.assertEach)((0, _utils.assertNodeType)("CommentBlock", "CommentLine")), |
| optional: true |
| }, |
| tokens: { |
| validate: (0, _utils.assertEach)(Object.assign(() => {}, { |
| type: "any" |
| })), |
| optional: true |
| } |
| } |
| }); |
| defineType("ForInStatement", { |
| visitor: ["left", "right", "body"], |
| aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"], |
| fields: { |
| left: { |
| validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("VariableDeclaration", "LVal") : (0, _utils.assertNodeType)("VariableDeclaration", "Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern") |
| }, |
| right: { |
| validate: (0, _utils.assertNodeType)("Expression") |
| }, |
| body: { |
| validate: (0, _utils.assertNodeType)("Statement") |
| } |
| } |
| }); |
| defineType("ForStatement", { |
| visitor: ["init", "test", "update", "body"], |
| aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop"], |
| fields: { |
| init: { |
| validate: (0, _utils.assertNodeType)("VariableDeclaration", "Expression"), |
| optional: true |
| }, |
| test: { |
| validate: (0, _utils.assertNodeType)("Expression"), |
| optional: true |
| }, |
| update: { |
| validate: (0, _utils.assertNodeType)("Expression"), |
| optional: true |
| }, |
| body: { |
| validate: (0, _utils.assertNodeType)("Statement") |
| } |
| } |
| }); |
| const functionCommon = { |
| params: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Identifier", "Pattern", "RestElement"))) |
| }, |
| generator: { |
| default: false |
| }, |
| async: { |
| default: false |
| } |
| }; |
| exports.functionCommon = functionCommon; |
| const functionTypeAnnotationCommon = { |
| returnType: { |
| validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"), |
| optional: true |
| }, |
| typeParameters: { |
| validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"), |
| optional: true |
| } |
| }; |
| exports.functionTypeAnnotationCommon = functionTypeAnnotationCommon; |
| const functionDeclarationCommon = Object.assign({}, functionCommon, { |
| declare: { |
| validate: (0, _utils.assertValueType)("boolean"), |
| optional: true |
| }, |
| id: { |
| validate: (0, _utils.assertNodeType)("Identifier"), |
| optional: true |
| } |
| }); |
| exports.functionDeclarationCommon = functionDeclarationCommon; |
| defineType("FunctionDeclaration", { |
| builder: ["id", "params", "body", "generator", "async"], |
| visitor: ["id", "params", "body", "returnType", "typeParameters"], |
| fields: Object.assign({}, functionDeclarationCommon, functionTypeAnnotationCommon, { |
| body: { |
| validate: (0, _utils.assertNodeType)("BlockStatement") |
| } |
| }), |
| aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Statement", "Pureish", "Declaration"], |
| validate: function () { |
| if (!process.env.BABEL_TYPES_8_BREAKING) return () => {}; |
| const identifier = (0, _utils.assertNodeType)("Identifier"); |
| return function (parent, key, node) { |
| if (!(0, _is.default)("ExportDefaultDeclaration", parent)) { |
| identifier(node, "id", node.id); |
| } |
| }; |
| }() |
| }); |
| defineType("FunctionExpression", { |
| inherits: "FunctionDeclaration", |
| aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"], |
| fields: Object.assign({}, functionCommon, functionTypeAnnotationCommon, { |
| id: { |
| validate: (0, _utils.assertNodeType)("Identifier"), |
| optional: true |
| }, |
| body: { |
| validate: (0, _utils.assertNodeType)("BlockStatement") |
| } |
| }) |
| }); |
| const patternLikeCommon = { |
| typeAnnotation: { |
| validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"), |
| optional: true |
| }, |
| decorators: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))) |
| } |
| }; |
| exports.patternLikeCommon = patternLikeCommon; |
| defineType("Identifier", { |
| builder: ["name"], |
| visitor: ["typeAnnotation", "decorators"], |
| aliases: ["Expression", "PatternLike", "LVal", "TSEntityName"], |
| fields: Object.assign({}, patternLikeCommon, { |
| name: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), Object.assign(function (node, key, val) { |
| if (!process.env.BABEL_TYPES_8_BREAKING) return; |
| |
| if (!(0, _isValidIdentifier.default)(val, false)) { |
| throw new TypeError(`"${val}" is not a valid identifier name`); |
| } |
| }, { |
| type: "string" |
| })) |
| }, |
| optional: { |
| validate: (0, _utils.assertValueType)("boolean"), |
| optional: true |
| } |
| }), |
| |
| validate(parent, key, node) { |
| if (!process.env.BABEL_TYPES_8_BREAKING) return; |
| const match = /\.(\w+)$/.exec(key); |
| if (!match) return; |
| const [, parentKey] = match; |
| const nonComp = { |
| computed: false |
| }; |
| |
| if (parentKey === "property") { |
| if ((0, _is.default)("MemberExpression", parent, nonComp)) return; |
| if ((0, _is.default)("OptionalMemberExpression", parent, nonComp)) return; |
| } else if (parentKey === "key") { |
| if ((0, _is.default)("Property", parent, nonComp)) return; |
| if ((0, _is.default)("Method", parent, nonComp)) return; |
| } else if (parentKey === "exported") { |
| if ((0, _is.default)("ExportSpecifier", parent)) return; |
| } else if (parentKey === "imported") { |
| if ((0, _is.default)("ImportSpecifier", parent, { |
| imported: node |
| })) return; |
| } else if (parentKey === "meta") { |
| if ((0, _is.default)("MetaProperty", parent, { |
| meta: node |
| })) return; |
| } |
| |
| if (((0, _helperValidatorIdentifier.isKeyword)(node.name) || (0, _helperValidatorIdentifier.isReservedWord)(node.name, false)) && node.name !== "this") { |
| throw new TypeError(`"${node.name}" is not a valid identifier`); |
| } |
| } |
| |
| }); |
| defineType("IfStatement", { |
| visitor: ["test", "consequent", "alternate"], |
| aliases: ["Statement", "Conditional"], |
| fields: { |
| test: { |
| validate: (0, _utils.assertNodeType)("Expression") |
| }, |
| consequent: { |
| validate: (0, _utils.assertNodeType)("Statement") |
| }, |
| alternate: { |
| optional: true, |
| validate: (0, _utils.assertNodeType)("Statement") |
| } |
| } |
| }); |
| defineType("LabeledStatement", { |
| visitor: ["label", "body"], |
| aliases: ["Statement"], |
| fields: { |
| label: { |
| validate: (0, _utils.assertNodeType)("Identifier") |
| }, |
| body: { |
| validate: (0, _utils.assertNodeType)("Statement") |
| } |
| } |
| }); |
| defineType("StringLiteral", { |
| builder: ["value"], |
| fields: { |
| value: { |
| validate: (0, _utils.assertValueType)("string") |
| } |
| }, |
| aliases: ["Expression", "Pureish", "Literal", "Immutable"] |
| }); |
| defineType("NumericLiteral", { |
| builder: ["value"], |
| deprecatedAlias: "NumberLiteral", |
| fields: { |
| value: { |
| validate: (0, _utils.assertValueType)("number") |
| } |
| }, |
| aliases: ["Expression", "Pureish", "Literal", "Immutable"] |
| }); |
| defineType("NullLiteral", { |
| aliases: ["Expression", "Pureish", "Literal", "Immutable"] |
| }); |
| defineType("BooleanLiteral", { |
| builder: ["value"], |
| fields: { |
| value: { |
| validate: (0, _utils.assertValueType)("boolean") |
| } |
| }, |
| aliases: ["Expression", "Pureish", "Literal", "Immutable"] |
| }); |
| defineType("RegExpLiteral", { |
| builder: ["pattern", "flags"], |
| deprecatedAlias: "RegexLiteral", |
| aliases: ["Expression", "Pureish", "Literal"], |
| fields: { |
| pattern: { |
| validate: (0, _utils.assertValueType)("string") |
| }, |
| flags: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), Object.assign(function (node, key, val) { |
| if (!process.env.BABEL_TYPES_8_BREAKING) return; |
| const invalid = /[^gimsuy]/.exec(val); |
| |
| if (invalid) { |
| throw new TypeError(`"${invalid[0]}" is not a valid RegExp flag`); |
| } |
| }, { |
| type: "string" |
| })), |
| default: "" |
| } |
| } |
| }); |
| defineType("LogicalExpression", { |
| builder: ["operator", "left", "right"], |
| visitor: ["left", "right"], |
| aliases: ["Binary", "Expression"], |
| fields: { |
| operator: { |
| validate: (0, _utils.assertOneOf)(..._constants.LOGICAL_OPERATORS) |
| }, |
| left: { |
| validate: (0, _utils.assertNodeType)("Expression") |
| }, |
| right: { |
| validate: (0, _utils.assertNodeType)("Expression") |
| } |
| } |
| }); |
| defineType("MemberExpression", { |
| builder: ["object", "property", "computed", ...(!process.env.BABEL_TYPES_8_BREAKING ? ["optional"] : [])], |
| visitor: ["object", "property"], |
| aliases: ["Expression", "LVal"], |
| fields: Object.assign({ |
| object: { |
| validate: (0, _utils.assertNodeType)("Expression") |
| }, |
| property: { |
| validate: function () { |
| const normal = (0, _utils.assertNodeType)("Identifier", "PrivateName"); |
| const computed = (0, _utils.assertNodeType)("Expression"); |
| |
| const validator = function (node, key, val) { |
| const validator = node.computed ? computed : normal; |
| validator(node, key, val); |
| }; |
| |
| validator.oneOfNodeTypes = ["Expression", "Identifier", "PrivateName"]; |
| return validator; |
| }() |
| }, |
| computed: { |
| default: false |
| } |
| }, !process.env.BABEL_TYPES_8_BREAKING ? { |
| optional: { |
| validate: (0, _utils.assertOneOf)(true, false), |
| optional: true |
| } |
| } : {}) |
| }); |
| defineType("NewExpression", { |
| inherits: "CallExpression" |
| }); |
| defineType("Program", { |
| visitor: ["directives", "body"], |
| builder: ["body", "directives", "sourceType", "interpreter"], |
| fields: { |
| sourceFile: { |
| validate: (0, _utils.assertValueType)("string") |
| }, |
| sourceType: { |
| validate: (0, _utils.assertOneOf)("script", "module"), |
| default: "script" |
| }, |
| interpreter: { |
| validate: (0, _utils.assertNodeType)("InterpreterDirective"), |
| default: null, |
| optional: true |
| }, |
| directives: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Directive"))), |
| default: [] |
| }, |
| body: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement"))) |
| } |
| }, |
| aliases: ["Scopable", "BlockParent", "Block"] |
| }); |
| defineType("ObjectExpression", { |
| visitor: ["properties"], |
| aliases: ["Expression"], |
| fields: { |
| properties: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ObjectMethod", "ObjectProperty", "SpreadElement"))) |
| } |
| } |
| }); |
| defineType("ObjectMethod", { |
| builder: ["kind", "key", "params", "body", "computed", "generator", "async"], |
| fields: Object.assign({}, functionCommon, functionTypeAnnotationCommon, { |
| kind: Object.assign({ |
| validate: (0, _utils.assertOneOf)("method", "get", "set") |
| }, !process.env.BABEL_TYPES_8_BREAKING ? { |
| default: "method" |
| } : {}), |
| computed: { |
| default: false |
| }, |
| key: { |
| validate: function () { |
| const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral"); |
| const computed = (0, _utils.assertNodeType)("Expression"); |
| |
| const validator = function (node, key, val) { |
| const validator = node.computed ? computed : normal; |
| validator(node, key, val); |
| }; |
| |
| validator.oneOfNodeTypes = ["Expression", "Identifier", "StringLiteral", "NumericLiteral"]; |
| return validator; |
| }() |
| }, |
| decorators: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), |
| optional: true |
| }, |
| body: { |
| validate: (0, _utils.assertNodeType)("BlockStatement") |
| } |
| }), |
| visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"], |
| aliases: ["UserWhitespacable", "Function", "Scopable", "BlockParent", "FunctionParent", "Method", "ObjectMember"] |
| }); |
| defineType("ObjectProperty", { |
| builder: ["key", "value", "computed", "shorthand", ...(!process.env.BABEL_TYPES_8_BREAKING ? ["decorators"] : [])], |
| fields: { |
| computed: { |
| default: false |
| }, |
| key: { |
| validate: function () { |
| const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral"); |
| const computed = (0, _utils.assertNodeType)("Expression"); |
| |
| const validator = function (node, key, val) { |
| const validator = node.computed ? computed : normal; |
| validator(node, key, val); |
| }; |
| |
| validator.oneOfNodeTypes = ["Expression", "Identifier", "StringLiteral", "NumericLiteral"]; |
| return validator; |
| }() |
| }, |
| value: { |
| validate: (0, _utils.assertNodeType)("Expression", "PatternLike") |
| }, |
| shorthand: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("boolean"), Object.assign(function (node, key, val) { |
| if (!process.env.BABEL_TYPES_8_BREAKING) return; |
| |
| if (val && node.computed) { |
| throw new TypeError("Property shorthand of ObjectProperty cannot be true if computed is true"); |
| } |
| }, { |
| type: "boolean" |
| }), function (node, key, val) { |
| if (!process.env.BABEL_TYPES_8_BREAKING) return; |
| |
| if (val && !(0, _is.default)("Identifier", node.key)) { |
| throw new TypeError("Property shorthand of ObjectProperty cannot be true if key is not an Identifier"); |
| } |
| }), |
| default: false |
| }, |
| decorators: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), |
| optional: true |
| } |
| }, |
| visitor: ["key", "value", "decorators"], |
| aliases: ["UserWhitespacable", "Property", "ObjectMember"], |
| validate: function () { |
| const pattern = (0, _utils.assertNodeType)("Identifier", "Pattern"); |
| const expression = (0, _utils.assertNodeType)("Expression"); |
| return function (parent, key, node) { |
| if (!process.env.BABEL_TYPES_8_BREAKING) return; |
| const validator = (0, _is.default)("ObjectPattern", parent) ? pattern : expression; |
| validator(node, "value", node.value); |
| }; |
| }() |
| }); |
| defineType("RestElement", { |
| visitor: ["argument", "typeAnnotation"], |
| builder: ["argument"], |
| aliases: ["LVal", "PatternLike"], |
| deprecatedAlias: "RestProperty", |
| fields: Object.assign({}, patternLikeCommon, { |
| argument: { |
| validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("LVal") : (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern", "MemberExpression") |
| }, |
| optional: { |
| validate: (0, _utils.assertValueType)("boolean"), |
| optional: true |
| } |
| }), |
| |
| validate(parent, key) { |
| if (!process.env.BABEL_TYPES_8_BREAKING) return; |
| const match = /(\w+)\[(\d+)\]/.exec(key); |
| if (!match) throw new Error("Internal Babel error: malformed key."); |
| const [, listKey, index] = match; |
| |
| if (parent[listKey].length > index + 1) { |
| throw new TypeError(`RestElement must be last element of ${listKey}`); |
| } |
| } |
| |
| }); |
| defineType("ReturnStatement", { |
| visitor: ["argument"], |
| aliases: ["Statement", "Terminatorless", "CompletionStatement"], |
| fields: { |
| argument: { |
| validate: (0, _utils.assertNodeType)("Expression"), |
| optional: true |
| } |
| } |
| }); |
| defineType("SequenceExpression", { |
| visitor: ["expressions"], |
| fields: { |
| expressions: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression"))) |
| } |
| }, |
| aliases: ["Expression"] |
| }); |
| defineType("ParenthesizedExpression", { |
| visitor: ["expression"], |
| aliases: ["Expression", "ExpressionWrapper"], |
| fields: { |
| expression: { |
| validate: (0, _utils.assertNodeType)("Expression") |
| } |
| } |
| }); |
| defineType("SwitchCase", { |
| visitor: ["test", "consequent"], |
| fields: { |
| test: { |
| validate: (0, _utils.assertNodeType)("Expression"), |
| optional: true |
| }, |
| consequent: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement"))) |
| } |
| } |
| }); |
| defineType("SwitchStatement", { |
| visitor: ["discriminant", "cases"], |
| aliases: ["Statement", "BlockParent", "Scopable"], |
| fields: { |
| discriminant: { |
| validate: (0, _utils.assertNodeType)("Expression") |
| }, |
| cases: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("SwitchCase"))) |
| } |
| } |
| }); |
| defineType("ThisExpression", { |
| aliases: ["Expression"] |
| }); |
| defineType("ThrowStatement", { |
| visitor: ["argument"], |
| aliases: ["Statement", "Terminatorless", "CompletionStatement"], |
| fields: { |
| argument: { |
| validate: (0, _utils.assertNodeType)("Expression") |
| } |
| } |
| }); |
| defineType("TryStatement", { |
| visitor: ["block", "handler", "finalizer"], |
| aliases: ["Statement"], |
| fields: { |
| block: { |
| validate: (0, _utils.chain)((0, _utils.assertNodeType)("BlockStatement"), Object.assign(function (node) { |
| if (!process.env.BABEL_TYPES_8_BREAKING) return; |
| |
| if (!node.handler && !node.finalizer) { |
| throw new TypeError("TryStatement expects either a handler or finalizer, or both"); |
| } |
| }, { |
| oneOfNodeTypes: ["BlockStatement"] |
| })) |
| }, |
| handler: { |
| optional: true, |
| validate: (0, _utils.assertNodeType)("CatchClause") |
| }, |
| finalizer: { |
| optional: true, |
| validate: (0, _utils.assertNodeType)("BlockStatement") |
| } |
| } |
| }); |
| defineType("UnaryExpression", { |
| builder: ["operator", "argument", "prefix"], |
| fields: { |
| prefix: { |
| default: true |
| }, |
| argument: { |
| validate: (0, _utils.assertNodeType)("Expression") |
| }, |
| operator: { |
| validate: (0, _utils.assertOneOf)(..._constants.UNARY_OPERATORS) |
| } |
| }, |
| visitor: ["argument"], |
| aliases: ["UnaryLike", "Expression"] |
| }); |
| defineType("UpdateExpression", { |
| builder: ["operator", "argument", "prefix"], |
| fields: { |
| prefix: { |
| default: false |
| }, |
| argument: { |
| validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("Expression") : (0, _utils.assertNodeType)("Identifier", "MemberExpression") |
| }, |
| operator: { |
| validate: (0, _utils.assertOneOf)(..._constants.UPDATE_OPERATORS) |
| } |
| }, |
| visitor: ["argument"], |
| aliases: ["Expression"] |
| }); |
| defineType("VariableDeclaration", { |
| builder: ["kind", "declarations"], |
| visitor: ["declarations"], |
| aliases: ["Statement", "Declaration"], |
| fields: { |
| declare: { |
| validate: (0, _utils.assertValueType)("boolean"), |
| optional: true |
| }, |
| kind: { |
| validate: (0, _utils.assertOneOf)("var", "let", "const") |
| }, |
| declarations: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("VariableDeclarator"))) |
| } |
| }, |
| |
| validate(parent, key, node) { |
| if (!process.env.BABEL_TYPES_8_BREAKING) return; |
| if (!(0, _is.default)("ForXStatement", parent, { |
| left: node |
| })) return; |
| |
| if (node.declarations.length !== 1) { |
| throw new TypeError(`Exactly one VariableDeclarator is required in the VariableDeclaration of a ${parent.type}`); |
| } |
| } |
| |
| }); |
| defineType("VariableDeclarator", { |
| visitor: ["id", "init"], |
| fields: { |
| id: { |
| validate: function () { |
| if (!process.env.BABEL_TYPES_8_BREAKING) { |
| return (0, _utils.assertNodeType)("LVal"); |
| } |
| |
| const normal = (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern"); |
| const without = (0, _utils.assertNodeType)("Identifier"); |
| return function (node, key, val) { |
| const validator = node.init ? normal : without; |
| validator(node, key, val); |
| }; |
| }() |
| }, |
| definite: { |
| optional: true, |
| validate: (0, _utils.assertValueType)("boolean") |
| }, |
| init: { |
| optional: true, |
| validate: (0, _utils.assertNodeType)("Expression") |
| } |
| } |
| }); |
| defineType("WhileStatement", { |
| visitor: ["test", "body"], |
| aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"], |
| fields: { |
| test: { |
| validate: (0, _utils.assertNodeType)("Expression") |
| }, |
| body: { |
| validate: (0, _utils.assertNodeType)("Statement") |
| } |
| } |
| }); |
| defineType("WithStatement", { |
| visitor: ["object", "body"], |
| aliases: ["Statement"], |
| fields: { |
| object: { |
| validate: (0, _utils.assertNodeType)("Expression") |
| }, |
| body: { |
| validate: (0, _utils.assertNodeType)("Statement") |
| } |
| } |
| }); |
| defineType("AssignmentPattern", { |
| visitor: ["left", "right", "decorators"], |
| builder: ["left", "right"], |
| aliases: ["Pattern", "PatternLike", "LVal"], |
| fields: Object.assign({}, patternLikeCommon, { |
| left: { |
| validate: (0, _utils.assertNodeType)("Identifier", "ObjectPattern", "ArrayPattern", "MemberExpression") |
| }, |
| right: { |
| validate: (0, _utils.assertNodeType)("Expression") |
| }, |
| decorators: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), |
| optional: true |
| } |
| }) |
| }); |
| defineType("ArrayPattern", { |
| visitor: ["elements", "typeAnnotation"], |
| builder: ["elements"], |
| aliases: ["Pattern", "PatternLike", "LVal"], |
| fields: Object.assign({}, patternLikeCommon, { |
| elements: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeOrValueType)("null", "PatternLike"))) |
| }, |
| decorators: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), |
| optional: true |
| }, |
| optional: { |
| validate: (0, _utils.assertValueType)("boolean"), |
| optional: true |
| } |
| }) |
| }); |
| defineType("ArrowFunctionExpression", { |
| builder: ["params", "body", "async"], |
| visitor: ["params", "body", "returnType", "typeParameters"], |
| aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"], |
| fields: Object.assign({}, functionCommon, functionTypeAnnotationCommon, { |
| expression: { |
| validate: (0, _utils.assertValueType)("boolean") |
| }, |
| body: { |
| validate: (0, _utils.assertNodeType)("BlockStatement", "Expression") |
| } |
| }) |
| }); |
| defineType("ClassBody", { |
| visitor: ["body"], |
| fields: { |
| body: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ClassMethod", "ClassPrivateMethod", "ClassProperty", "ClassPrivateProperty", "TSDeclareMethod", "TSIndexSignature"))) |
| } |
| } |
| }); |
| defineType("ClassExpression", { |
| builder: ["id", "superClass", "body", "decorators"], |
| visitor: ["id", "body", "superClass", "mixins", "typeParameters", "superTypeParameters", "implements", "decorators"], |
| aliases: ["Scopable", "Class", "Expression"], |
| fields: { |
| id: { |
| validate: (0, _utils.assertNodeType)("Identifier"), |
| optional: true |
| }, |
| typeParameters: { |
| validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"), |
| optional: true |
| }, |
| body: { |
| validate: (0, _utils.assertNodeType)("ClassBody") |
| }, |
| superClass: { |
| optional: true, |
| validate: (0, _utils.assertNodeType)("Expression") |
| }, |
| superTypeParameters: { |
| validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"), |
| optional: true |
| }, |
| implements: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSExpressionWithTypeArguments", "ClassImplements"))), |
| optional: true |
| }, |
| decorators: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), |
| optional: true |
| }, |
| mixins: { |
| validate: (0, _utils.assertNodeType)("InterfaceExtends"), |
| optional: true |
| } |
| } |
| }); |
| defineType("ClassDeclaration", { |
| inherits: "ClassExpression", |
| aliases: ["Scopable", "Class", "Statement", "Declaration"], |
| fields: { |
| id: { |
| validate: (0, _utils.assertNodeType)("Identifier") |
| }, |
| typeParameters: { |
| validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"), |
| optional: true |
| }, |
| body: { |
| validate: (0, _utils.assertNodeType)("ClassBody") |
| }, |
| superClass: { |
| optional: true, |
| validate: (0, _utils.assertNodeType)("Expression") |
| }, |
| superTypeParameters: { |
| validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"), |
| optional: true |
| }, |
| implements: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSExpressionWithTypeArguments", "ClassImplements"))), |
| optional: true |
| }, |
| decorators: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), |
| optional: true |
| }, |
| mixins: { |
| validate: (0, _utils.assertNodeType)("InterfaceExtends"), |
| optional: true |
| }, |
| declare: { |
| validate: (0, _utils.assertValueType)("boolean"), |
| optional: true |
| }, |
| abstract: { |
| validate: (0, _utils.assertValueType)("boolean"), |
| optional: true |
| } |
| }, |
| validate: function () { |
| const identifier = (0, _utils.assertNodeType)("Identifier"); |
| return function (parent, key, node) { |
| if (!process.env.BABEL_TYPES_8_BREAKING) return; |
| |
| if (!(0, _is.default)("ExportDefaultDeclaration", parent)) { |
| identifier(node, "id", node.id); |
| } |
| }; |
| }() |
| }); |
| defineType("ExportAllDeclaration", { |
| visitor: ["source"], |
| aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"], |
| fields: { |
| source: { |
| validate: (0, _utils.assertNodeType)("StringLiteral") |
| }, |
| exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value")), |
| assertions: { |
| optional: true, |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportAttribute"))) |
| } |
| } |
| }); |
| defineType("ExportDefaultDeclaration", { |
| visitor: ["declaration"], |
| aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"], |
| fields: { |
| declaration: { |
| validate: (0, _utils.assertNodeType)("FunctionDeclaration", "TSDeclareFunction", "ClassDeclaration", "Expression") |
| }, |
| exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("value")) |
| } |
| }); |
| defineType("ExportNamedDeclaration", { |
| visitor: ["declaration", "specifiers", "source"], |
| aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"], |
| fields: { |
| declaration: { |
| optional: true, |
| validate: (0, _utils.chain)((0, _utils.assertNodeType)("Declaration"), Object.assign(function (node, key, val) { |
| if (!process.env.BABEL_TYPES_8_BREAKING) return; |
| |
| if (val && node.specifiers.length) { |
| throw new TypeError("Only declaration or specifiers is allowed on ExportNamedDeclaration"); |
| } |
| }, { |
| oneOfNodeTypes: ["Declaration"] |
| }), function (node, key, val) { |
| if (!process.env.BABEL_TYPES_8_BREAKING) return; |
| |
| if (val && node.source) { |
| throw new TypeError("Cannot export a declaration from a source"); |
| } |
| }) |
| }, |
| assertions: { |
| optional: true, |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportAttribute"))) |
| }, |
| specifiers: { |
| default: [], |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)(function () { |
| const sourced = (0, _utils.assertNodeType)("ExportSpecifier", "ExportDefaultSpecifier", "ExportNamespaceSpecifier"); |
| const sourceless = (0, _utils.assertNodeType)("ExportSpecifier"); |
| if (!process.env.BABEL_TYPES_8_BREAKING) return sourced; |
| return function (node, key, val) { |
| const validator = node.source ? sourced : sourceless; |
| validator(node, key, val); |
| }; |
| }())) |
| }, |
| source: { |
| validate: (0, _utils.assertNodeType)("StringLiteral"), |
| optional: true |
| }, |
| exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value")) |
| } |
| }); |
| defineType("ExportSpecifier", { |
| visitor: ["local", "exported"], |
| aliases: ["ModuleSpecifier"], |
| fields: { |
| local: { |
| validate: (0, _utils.assertNodeType)("Identifier") |
| }, |
| exported: { |
| validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral") |
| }, |
| exportKind: { |
| validate: (0, _utils.assertOneOf)("type", "value"), |
| optional: true |
| } |
| } |
| }); |
| defineType("ForOfStatement", { |
| visitor: ["left", "right", "body"], |
| builder: ["left", "right", "body", "await"], |
| aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"], |
| fields: { |
| left: { |
| validate: function () { |
| if (!process.env.BABEL_TYPES_8_BREAKING) { |
| return (0, _utils.assertNodeType)("VariableDeclaration", "LVal"); |
| } |
| |
| const declaration = (0, _utils.assertNodeType)("VariableDeclaration"); |
| const lval = (0, _utils.assertNodeType)("Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern"); |
| return function (node, key, val) { |
| if ((0, _is.default)("VariableDeclaration", val)) { |
| declaration(node, key, val); |
| } else { |
| lval(node, key, val); |
| } |
| }; |
| }() |
| }, |
| right: { |
| validate: (0, _utils.assertNodeType)("Expression") |
| }, |
| body: { |
| validate: (0, _utils.assertNodeType)("Statement") |
| }, |
| await: { |
| default: false |
| } |
| } |
| }); |
| defineType("ImportDeclaration", { |
| visitor: ["specifiers", "source"], |
| aliases: ["Statement", "Declaration", "ModuleDeclaration"], |
| fields: { |
| assertions: { |
| optional: true, |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportAttribute"))) |
| }, |
| specifiers: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportSpecifier", "ImportDefaultSpecifier", "ImportNamespaceSpecifier"))) |
| }, |
| source: { |
| validate: (0, _utils.assertNodeType)("StringLiteral") |
| }, |
| importKind: { |
| validate: (0, _utils.assertOneOf)("type", "typeof", "value"), |
| optional: true |
| } |
| } |
| }); |
| defineType("ImportDefaultSpecifier", { |
| visitor: ["local"], |
| aliases: ["ModuleSpecifier"], |
| fields: { |
| local: { |
| validate: (0, _utils.assertNodeType)("Identifier") |
| } |
| } |
| }); |
| defineType("ImportNamespaceSpecifier", { |
| visitor: ["local"], |
| aliases: ["ModuleSpecifier"], |
| fields: { |
| local: { |
| validate: (0, _utils.assertNodeType)("Identifier") |
| } |
| } |
| }); |
| defineType("ImportSpecifier", { |
| visitor: ["local", "imported"], |
| aliases: ["ModuleSpecifier"], |
| fields: { |
| local: { |
| validate: (0, _utils.assertNodeType)("Identifier") |
| }, |
| imported: { |
| validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral") |
| }, |
| importKind: { |
| validate: (0, _utils.assertOneOf)("type", "typeof", "value"), |
| optional: true |
| } |
| } |
| }); |
| defineType("MetaProperty", { |
| visitor: ["meta", "property"], |
| aliases: ["Expression"], |
| fields: { |
| meta: { |
| validate: (0, _utils.chain)((0, _utils.assertNodeType)("Identifier"), Object.assign(function (node, key, val) { |
| if (!process.env.BABEL_TYPES_8_BREAKING) return; |
| let property; |
| |
| switch (val.name) { |
| case "function": |
| property = "sent"; |
| break; |
| |
| case "new": |
| property = "target"; |
| break; |
| |
| case "import": |
| property = "meta"; |
| break; |
| } |
| |
| if (!(0, _is.default)("Identifier", node.property, { |
| name: property |
| })) { |
| throw new TypeError("Unrecognised MetaProperty"); |
| } |
| }, { |
| oneOfNodeTypes: ["Identifier"] |
| })) |
| }, |
| property: { |
| validate: (0, _utils.assertNodeType)("Identifier") |
| } |
| } |
| }); |
| const classMethodOrPropertyCommon = { |
| abstract: { |
| validate: (0, _utils.assertValueType)("boolean"), |
| optional: true |
| }, |
| accessibility: { |
| validate: (0, _utils.assertOneOf)("public", "private", "protected"), |
| optional: true |
| }, |
| static: { |
| default: false |
| }, |
| override: { |
| default: false |
| }, |
| computed: { |
| default: false |
| }, |
| optional: { |
| validate: (0, _utils.assertValueType)("boolean"), |
| optional: true |
| }, |
| key: { |
| validate: (0, _utils.chain)(function () { |
| const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral"); |
| const computed = (0, _utils.assertNodeType)("Expression"); |
| return function (node, key, val) { |
| const validator = node.computed ? computed : normal; |
| validator(node, key, val); |
| }; |
| }(), (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "Expression")) |
| } |
| }; |
| exports.classMethodOrPropertyCommon = classMethodOrPropertyCommon; |
| const classMethodOrDeclareMethodCommon = Object.assign({}, functionCommon, classMethodOrPropertyCommon, { |
| params: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Identifier", "Pattern", "RestElement", "TSParameterProperty"))) |
| }, |
| kind: { |
| validate: (0, _utils.assertOneOf)("get", "set", "method", "constructor"), |
| default: "method" |
| }, |
| access: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("public", "private", "protected")), |
| optional: true |
| }, |
| decorators: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), |
| optional: true |
| } |
| }); |
| exports.classMethodOrDeclareMethodCommon = classMethodOrDeclareMethodCommon; |
| defineType("ClassMethod", { |
| aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method"], |
| builder: ["kind", "key", "params", "body", "computed", "static", "generator", "async"], |
| visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"], |
| fields: Object.assign({}, classMethodOrDeclareMethodCommon, functionTypeAnnotationCommon, { |
| body: { |
| validate: (0, _utils.assertNodeType)("BlockStatement") |
| } |
| }) |
| }); |
| defineType("ObjectPattern", { |
| visitor: ["properties", "typeAnnotation", "decorators"], |
| builder: ["properties"], |
| aliases: ["Pattern", "PatternLike", "LVal"], |
| fields: Object.assign({}, patternLikeCommon, { |
| properties: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("RestElement", "ObjectProperty"))) |
| } |
| }) |
| }); |
| defineType("SpreadElement", { |
| visitor: ["argument"], |
| aliases: ["UnaryLike"], |
| deprecatedAlias: "SpreadProperty", |
| fields: { |
| argument: { |
| validate: (0, _utils.assertNodeType)("Expression") |
| } |
| } |
| }); |
| defineType("Super", { |
| aliases: ["Expression"] |
| }); |
| defineType("TaggedTemplateExpression", { |
| visitor: ["tag", "quasi", "typeParameters"], |
| builder: ["tag", "quasi"], |
| aliases: ["Expression"], |
| fields: { |
| tag: { |
| validate: (0, _utils.assertNodeType)("Expression") |
| }, |
| quasi: { |
| validate: (0, _utils.assertNodeType)("TemplateLiteral") |
| }, |
| typeParameters: { |
| validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"), |
| optional: true |
| } |
| } |
| }); |
| defineType("TemplateElement", { |
| builder: ["value", "tail"], |
| fields: { |
| value: { |
| validate: (0, _utils.assertShape)({ |
| raw: { |
| validate: (0, _utils.assertValueType)("string") |
| }, |
| cooked: { |
| validate: (0, _utils.assertValueType)("string"), |
| optional: true |
| } |
| }) |
| }, |
| tail: { |
| default: false |
| } |
| } |
| }); |
| defineType("TemplateLiteral", { |
| visitor: ["quasis", "expressions"], |
| aliases: ["Expression", "Literal"], |
| fields: { |
| quasis: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TemplateElement"))) |
| }, |
| expressions: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "TSType")), function (node, key, val) { |
| if (node.quasis.length !== val.length + 1) { |
| 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}`); |
| } |
| }) |
| } |
| } |
| }); |
| defineType("YieldExpression", { |
| builder: ["argument", "delegate"], |
| visitor: ["argument"], |
| aliases: ["Expression", "Terminatorless"], |
| fields: { |
| delegate: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("boolean"), Object.assign(function (node, key, val) { |
| if (!process.env.BABEL_TYPES_8_BREAKING) return; |
| |
| if (val && !node.argument) { |
| throw new TypeError("Property delegate of YieldExpression cannot be true if there is no argument"); |
| } |
| }, { |
| type: "boolean" |
| })), |
| default: false |
| }, |
| argument: { |
| optional: true, |
| validate: (0, _utils.assertNodeType)("Expression") |
| } |
| } |
| }); |
| defineType("AwaitExpression", { |
| builder: ["argument"], |
| visitor: ["argument"], |
| aliases: ["Expression", "Terminatorless"], |
| fields: { |
| argument: { |
| validate: (0, _utils.assertNodeType)("Expression") |
| } |
| } |
| }); |
| defineType("Import", { |
| aliases: ["Expression"] |
| }); |
| defineType("BigIntLiteral", { |
| builder: ["value"], |
| fields: { |
| value: { |
| validate: (0, _utils.assertValueType)("string") |
| } |
| }, |
| aliases: ["Expression", "Pureish", "Literal", "Immutable"] |
| }); |
| defineType("ExportNamespaceSpecifier", { |
| visitor: ["exported"], |
| aliases: ["ModuleSpecifier"], |
| fields: { |
| exported: { |
| validate: (0, _utils.assertNodeType)("Identifier") |
| } |
| } |
| }); |
| defineType("OptionalMemberExpression", { |
| builder: ["object", "property", "computed", "optional"], |
| visitor: ["object", "property"], |
| aliases: ["Expression"], |
| fields: { |
| object: { |
| validate: (0, _utils.assertNodeType)("Expression") |
| }, |
| property: { |
| validate: function () { |
| const normal = (0, _utils.assertNodeType)("Identifier"); |
| const computed = (0, _utils.assertNodeType)("Expression"); |
| |
| const validator = function (node, key, val) { |
| const validator = node.computed ? computed : normal; |
| validator(node, key, val); |
| }; |
| |
| validator.oneOfNodeTypes = ["Expression", "Identifier"]; |
| return validator; |
| }() |
| }, |
| computed: { |
| default: false |
| }, |
| optional: { |
| validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertValueType)("boolean") : (0, _utils.chain)((0, _utils.assertValueType)("boolean"), (0, _utils.assertOptionalChainStart)()) |
| } |
| } |
| }); |
| defineType("OptionalCallExpression", { |
| visitor: ["callee", "arguments", "typeParameters", "typeArguments"], |
| builder: ["callee", "arguments", "optional"], |
| aliases: ["Expression"], |
| fields: { |
| callee: { |
| validate: (0, _utils.assertNodeType)("Expression") |
| }, |
| arguments: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement", "JSXNamespacedName", "ArgumentPlaceholder"))) |
| }, |
| optional: { |
| validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertValueType)("boolean") : (0, _utils.chain)((0, _utils.assertValueType)("boolean"), (0, _utils.assertOptionalChainStart)()) |
| }, |
| typeArguments: { |
| validate: (0, _utils.assertNodeType)("TypeParameterInstantiation"), |
| optional: true |
| }, |
| typeParameters: { |
| validate: (0, _utils.assertNodeType)("TSTypeParameterInstantiation"), |
| optional: true |
| } |
| } |
| }); |
| defineType("ClassProperty", { |
| visitor: ["key", "value", "typeAnnotation", "decorators"], |
| builder: ["key", "value", "typeAnnotation", "decorators", "computed", "static"], |
| aliases: ["Property"], |
| fields: Object.assign({}, classMethodOrPropertyCommon, { |
| value: { |
| validate: (0, _utils.assertNodeType)("Expression"), |
| optional: true |
| }, |
| definite: { |
| validate: (0, _utils.assertValueType)("boolean"), |
| optional: true |
| }, |
| typeAnnotation: { |
| validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"), |
| optional: true |
| }, |
| decorators: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), |
| optional: true |
| }, |
| readonly: { |
| validate: (0, _utils.assertValueType)("boolean"), |
| optional: true |
| }, |
| declare: { |
| validate: (0, _utils.assertValueType)("boolean"), |
| optional: true |
| }, |
| variance: { |
| validate: (0, _utils.assertNodeType)("Variance"), |
| optional: true |
| } |
| }) |
| }); |
| defineType("ClassPrivateProperty", { |
| visitor: ["key", "value", "decorators", "typeAnnotation"], |
| builder: ["key", "value", "decorators", "static"], |
| aliases: ["Property", "Private"], |
| fields: { |
| key: { |
| validate: (0, _utils.assertNodeType)("PrivateName") |
| }, |
| value: { |
| validate: (0, _utils.assertNodeType)("Expression"), |
| optional: true |
| }, |
| typeAnnotation: { |
| validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"), |
| optional: true |
| }, |
| decorators: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), |
| optional: true |
| }, |
| readonly: { |
| validate: (0, _utils.assertValueType)("boolean"), |
| optional: true |
| }, |
| definite: { |
| validate: (0, _utils.assertValueType)("boolean"), |
| optional: true |
| }, |
| variance: { |
| validate: (0, _utils.assertNodeType)("Variance"), |
| optional: true |
| } |
| } |
| }); |
| defineType("ClassPrivateMethod", { |
| builder: ["kind", "key", "params", "body", "static"], |
| visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"], |
| aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method", "Private"], |
| fields: Object.assign({}, classMethodOrDeclareMethodCommon, functionTypeAnnotationCommon, { |
| key: { |
| validate: (0, _utils.assertNodeType)("PrivateName") |
| }, |
| body: { |
| validate: (0, _utils.assertNodeType)("BlockStatement") |
| } |
| }) |
| }); |
| defineType("PrivateName", { |
| visitor: ["id"], |
| aliases: ["Private"], |
| fields: { |
| id: { |
| validate: (0, _utils.assertNodeType)("Identifier") |
| } |
| } |
| }); |
| defineType("StaticBlock", { |
| visitor: ["body"], |
| fields: { |
| body: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement"))) |
| } |
| }, |
| aliases: ["Scopable", "BlockParent", "FunctionParent"] |
| }); |