"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", "TSAsExpression", "TSTypeAssertion", "TSNonNullExpression")
|
},
|
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", "TSAsExpression", "TSTypeAssertion", "TSNonNullExpression")
|
},
|
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")
|
},
|
predicate: {
|
validate: (0, _utils.assertNodeType)("DeclaredPredicate", "InferredPredicate"),
|
optional: true
|
}
|
}),
|
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")
|
},
|
predicate: {
|
validate: (0, _utils.assertNodeType)("DeclaredPredicate", "InferredPredicate"),
|
optional: true
|
}
|
})
|
});
|
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", "TSAsExpression", "TSNonNullExpression", "TSTypeAssertion");
|
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", "TSAsExpression", "TSTypeAssertion", "TSNonNullExpression")
|
},
|
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", "TSAsExpression", "TSTypeAssertion", "TSNonNullExpression")
|
},
|
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")
|
},
|
predicate: {
|
validate: (0, _utils.assertNodeType)("DeclaredPredicate", "InferredPredicate"),
|
optional: true
|
}
|
})
|
});
|
defineType("ClassBody", {
|
visitor: ["body"],
|
fields: {
|
body: {
|
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ClassMethod", "ClassPrivateMethod", "ClassProperty", "ClassPrivateProperty", "ClassAccessorProperty", "TSDeclareMethod", "TSIndexSignature", "StaticBlock")))
|
}
|
}
|
});
|
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", "TSAsExpression", "TSTypeAssertion", "TSNonNullExpression");
|
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("ClassAccessorProperty", {
|
visitor: ["key", "value", "typeAnnotation", "decorators"],
|
builder: ["key", "value", "typeAnnotation", "decorators", "computed", "static"],
|
aliases: ["Property", "Accessor"],
|
fields: Object.assign({}, classMethodOrPropertyCommon, {
|
key: {
|
validate: (0, _utils.chain)(function () {
|
const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "PrivateName");
|
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", "PrivateName"))
|
},
|
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"]
|
});
|
