1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489 |
- "use strict";
-
- Object.defineProperty(exports, "__esModule", {
- value: true
- });
- exports.classMethodOrDeclareMethodCommon = exports.classMethodOrPropertyCommon = exports.patternLikeCommon = exports.functionDeclarationCommon = exports.functionTypeAnnotationCommon = exports.functionCommon = 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");
-
- (0, _utils.default)("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"]
- });
- (0, _utils.default)("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"]
- });
- (0, _utils.default)("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"]
- });
- (0, _utils.default)("InterpreterDirective", {
- builder: ["value"],
- fields: {
- value: {
- validate: (0, _utils.assertValueType)("string")
- }
- }
- });
- (0, _utils.default)("Directive", {
- visitor: ["value"],
- fields: {
- value: {
- validate: (0, _utils.assertNodeType)("DirectiveLiteral")
- }
- }
- });
- (0, _utils.default)("DirectiveLiteral", {
- builder: ["value"],
- fields: {
- value: {
- validate: (0, _utils.assertValueType)("string")
- }
- }
- });
- (0, _utils.default)("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"]
- });
- (0, _utils.default)("BreakStatement", {
- visitor: ["label"],
- fields: {
- label: {
- validate: (0, _utils.assertNodeType)("Identifier"),
- optional: true
- }
- },
- aliases: ["Statement", "Terminatorless", "CompletionStatement"]
- });
- (0, _utils.default)("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
- }
- })
- });
- (0, _utils.default)("CatchClause", {
- visitor: ["param", "body"],
- fields: {
- param: {
- validate: (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern"),
- optional: true
- },
- body: {
- validate: (0, _utils.assertNodeType)("BlockStatement")
- }
- },
- aliases: ["Scopable", "BlockParent"]
- });
- (0, _utils.default)("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"]
- });
- (0, _utils.default)("ContinueStatement", {
- visitor: ["label"],
- fields: {
- label: {
- validate: (0, _utils.assertNodeType)("Identifier"),
- optional: true
- }
- },
- aliases: ["Statement", "Terminatorless", "CompletionStatement"]
- });
- (0, _utils.default)("DebuggerStatement", {
- aliases: ["Statement"]
- });
- (0, _utils.default)("DoWhileStatement", {
- visitor: ["test", "body"],
- fields: {
- test: {
- validate: (0, _utils.assertNodeType)("Expression")
- },
- body: {
- validate: (0, _utils.assertNodeType)("Statement")
- }
- },
- aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"]
- });
- (0, _utils.default)("EmptyStatement", {
- aliases: ["Statement"]
- });
- (0, _utils.default)("ExpressionStatement", {
- visitor: ["expression"],
- fields: {
- expression: {
- validate: (0, _utils.assertNodeType)("Expression")
- }
- },
- aliases: ["Statement", "ExpressionWrapper"]
- });
- (0, _utils.default)("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
- }
- }
- });
- (0, _utils.default)("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")
- }
- }
- });
- (0, _utils.default)("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;
- (0, _utils.default)("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);
- }
- };
- }()
- });
- (0, _utils.default)("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;
- (0, _utils.default)("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`);
- }
- }
-
- });
- (0, _utils.default)("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")
- }
- }
- });
- (0, _utils.default)("LabeledStatement", {
- visitor: ["label", "body"],
- aliases: ["Statement"],
- fields: {
- label: {
- validate: (0, _utils.assertNodeType)("Identifier")
- },
- body: {
- validate: (0, _utils.assertNodeType)("Statement")
- }
- }
- });
- (0, _utils.default)("StringLiteral", {
- builder: ["value"],
- fields: {
- value: {
- validate: (0, _utils.assertValueType)("string")
- }
- },
- aliases: ["Expression", "Pureish", "Literal", "Immutable"]
- });
- (0, _utils.default)("NumericLiteral", {
- builder: ["value"],
- deprecatedAlias: "NumberLiteral",
- fields: {
- value: {
- validate: (0, _utils.assertValueType)("number")
- }
- },
- aliases: ["Expression", "Pureish", "Literal", "Immutable"]
- });
- (0, _utils.default)("NullLiteral", {
- aliases: ["Expression", "Pureish", "Literal", "Immutable"]
- });
- (0, _utils.default)("BooleanLiteral", {
- builder: ["value"],
- fields: {
- value: {
- validate: (0, _utils.assertValueType)("boolean")
- }
- },
- aliases: ["Expression", "Pureish", "Literal", "Immutable"]
- });
- (0, _utils.default)("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: ""
- }
- }
- });
- (0, _utils.default)("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")
- }
- }
- });
- (0, _utils.default)("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
- }
- } : {})
- });
- (0, _utils.default)("NewExpression", {
- inherits: "CallExpression"
- });
- (0, _utils.default)("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"]
- });
- (0, _utils.default)("ObjectExpression", {
- visitor: ["properties"],
- aliases: ["Expression"],
- fields: {
- properties: {
- validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ObjectMethod", "ObjectProperty", "SpreadElement")))
- }
- }
- });
- (0, _utils.default)("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"]
- });
- (0, _utils.default)("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);
- };
- }()
- });
- (0, _utils.default)("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", "Pattern", "MemberExpression")
- }
- }),
-
- 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}`);
- }
- }
-
- });
- (0, _utils.default)("ReturnStatement", {
- visitor: ["argument"],
- aliases: ["Statement", "Terminatorless", "CompletionStatement"],
- fields: {
- argument: {
- validate: (0, _utils.assertNodeType)("Expression"),
- optional: true
- }
- }
- });
- (0, _utils.default)("SequenceExpression", {
- visitor: ["expressions"],
- fields: {
- expressions: {
- validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression")))
- }
- },
- aliases: ["Expression"]
- });
- (0, _utils.default)("ParenthesizedExpression", {
- visitor: ["expression"],
- aliases: ["Expression", "ExpressionWrapper"],
- fields: {
- expression: {
- validate: (0, _utils.assertNodeType)("Expression")
- }
- }
- });
- (0, _utils.default)("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")))
- }
- }
- });
- (0, _utils.default)("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")))
- }
- }
- });
- (0, _utils.default)("ThisExpression", {
- aliases: ["Expression"]
- });
- (0, _utils.default)("ThrowStatement", {
- visitor: ["argument"],
- aliases: ["Statement", "Terminatorless", "CompletionStatement"],
- fields: {
- argument: {
- validate: (0, _utils.assertNodeType)("Expression")
- }
- }
- });
- (0, _utils.default)("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")
- }
- }
- });
- (0, _utils.default)("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"]
- });
- (0, _utils.default)("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"]
- });
- (0, _utils.default)("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}`);
- }
- }
-
- });
- (0, _utils.default)("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")
- }
- }
- });
- (0, _utils.default)("WhileStatement", {
- visitor: ["test", "body"],
- aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"],
- fields: {
- test: {
- validate: (0, _utils.assertNodeType)("Expression")
- },
- body: {
- validate: (0, _utils.assertNodeType)("Statement")
- }
- }
- });
- (0, _utils.default)("WithStatement", {
- visitor: ["object", "body"],
- aliases: ["Statement"],
- fields: {
- object: {
- validate: (0, _utils.assertNodeType)("Expression")
- },
- body: {
- validate: (0, _utils.assertNodeType)("Statement")
- }
- }
- });
- (0, _utils.default)("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
- }
- })
- });
- (0, _utils.default)("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
- }
- })
- });
- (0, _utils.default)("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")
- }
- })
- });
- (0, _utils.default)("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")))
- }
- }
- });
- (0, _utils.default)("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
- }
- }
- });
- (0, _utils.default)("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);
- }
- };
- }()
- });
- (0, _utils.default)("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")))
- }
- }
- });
- (0, _utils.default)("ExportDefaultDeclaration", {
- visitor: ["declaration"],
- aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"],
- fields: {
- declaration: {
- validate: (0, _utils.assertNodeType)("FunctionDeclaration", "TSDeclareFunction", "ClassDeclaration", "Expression")
- }
- }
- });
- (0, _utils.default)("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"))
- }
- });
- (0, _utils.default)("ExportSpecifier", {
- visitor: ["local", "exported"],
- aliases: ["ModuleSpecifier"],
- fields: {
- local: {
- validate: (0, _utils.assertNodeType)("Identifier")
- },
- exported: {
- validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral")
- }
- }
- });
- (0, _utils.default)("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
- }
- }
- });
- (0, _utils.default)("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
- }
- }
- });
- (0, _utils.default)("ImportDefaultSpecifier", {
- visitor: ["local"],
- aliases: ["ModuleSpecifier"],
- fields: {
- local: {
- validate: (0, _utils.assertNodeType)("Identifier")
- }
- }
- });
- (0, _utils.default)("ImportNamespaceSpecifier", {
- visitor: ["local"],
- aliases: ["ModuleSpecifier"],
- fields: {
- local: {
- validate: (0, _utils.assertNodeType)("Identifier")
- }
- }
- });
- (0, _utils.default)("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"),
- optional: true
- }
- }
- });
- (0, _utils.default)("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;
- (0, _utils.default)("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")
- }
- })
- });
- (0, _utils.default)("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")))
- }
- })
- });
- (0, _utils.default)("SpreadElement", {
- visitor: ["argument"],
- aliases: ["UnaryLike"],
- deprecatedAlias: "SpreadProperty",
- fields: {
- argument: {
- validate: (0, _utils.assertNodeType)("Expression")
- }
- }
- });
- (0, _utils.default)("Super", {
- aliases: ["Expression"]
- });
- (0, _utils.default)("TaggedTemplateExpression", {
- visitor: ["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
- }
- }
- });
- (0, _utils.default)("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
- }
- }
- });
- (0, _utils.default)("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}`);
- }
- })
- }
- }
- });
- (0, _utils.default)("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")
- }
- }
- });
- (0, _utils.default)("AwaitExpression", {
- builder: ["argument"],
- visitor: ["argument"],
- aliases: ["Expression", "Terminatorless"],
- fields: {
- argument: {
- validate: (0, _utils.assertNodeType)("Expression")
- }
- }
- });
- (0, _utils.default)("Import", {
- aliases: ["Expression"]
- });
- (0, _utils.default)("BigIntLiteral", {
- builder: ["value"],
- fields: {
- value: {
- validate: (0, _utils.assertValueType)("string")
- }
- },
- aliases: ["Expression", "Pureish", "Literal", "Immutable"]
- });
- (0, _utils.default)("ExportNamespaceSpecifier", {
- visitor: ["exported"],
- aliases: ["ModuleSpecifier"],
- fields: {
- exported: {
- validate: (0, _utils.assertNodeType)("Identifier")
- }
- }
- });
- (0, _utils.default)("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)())
- }
- }
- });
- (0, _utils.default)("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
- }
- }
- });
|