| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", { |
| value: true |
| }); |
| exports.patternLikeCommon = exports.functionDeclarationCommon = exports.functionTypeAnnotationCommon = exports.functionCommon = void 0; |
| |
| var _isValidIdentifier = _interopRequireDefault(require("../validators/isValidIdentifier")); |
| |
| var _constants = require("../constants"); |
| |
| var _utils = _interopRequireWildcard(require("./utils")); |
| |
| function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; } |
| |
| function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; if (obj != null) { var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; } |
| |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } |
| |
| (0, _utils.default)("ArrayExpression", { |
| fields: { |
| elements: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeOrValueType)("null", "Expression", "SpreadElement"))), |
| default: [] |
| } |
| }, |
| visitor: ["elements"], |
| aliases: ["Expression"] |
| }); |
| (0, _utils.default)("AssignmentExpression", { |
| fields: { |
| operator: { |
| validate: (0, _utils.assertValueType)("string") |
| }, |
| left: { |
| validate: (0, _utils.assertNodeType)("LVal") |
| }, |
| 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: (0, _utils.assertNodeType)("Expression") |
| }, |
| 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: { |
| 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"))) |
| }, |
| 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"), |
| 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") |
| } |
| } |
| }); |
| (0, _utils.default)("ForInStatement", { |
| visitor: ["left", "right", "body"], |
| aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"], |
| fields: { |
| left: { |
| validate: (0, _utils.assertNodeType)("VariableDeclaration", "LVal") |
| }, |
| 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", "TSParameterProperty"))) |
| }, |
| generator: { |
| default: false, |
| validate: (0, _utils.assertValueType)("boolean") |
| }, |
| async: { |
| validate: (0, _utils.assertValueType)("boolean"), |
| 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"] |
| }); |
| (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)(function (node, key, val) { |
| if (!(0, _isValidIdentifier.default)(val)) {} |
| }, (0, _utils.assertValueType)("string")) |
| }, |
| optional: { |
| validate: (0, _utils.assertValueType)("boolean"), |
| optional: true |
| } |
| }) |
| }); |
| (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", "Literal"], |
| fields: { |
| pattern: { |
| validate: (0, _utils.assertValueType)("string") |
| }, |
| flags: { |
| validate: (0, _utils.assertValueType)("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", "optional"], |
| visitor: ["object", "property"], |
| aliases: ["Expression", "LVal"], |
| fields: { |
| object: { |
| validate: (0, _utils.assertNodeType)("Expression") |
| }, |
| property: { |
| validate: function () { |
| const normal = (0, _utils.assertNodeType)("Identifier", "PrivateName"); |
| const computed = (0, _utils.assertNodeType)("Expression"); |
| return function (node, key, val) { |
| const validator = node.computed ? computed : normal; |
| validator(node, key, val); |
| }; |
| }() |
| }, |
| computed: { |
| default: false |
| }, |
| 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"], |
| fields: Object.assign({}, functionCommon, {}, functionTypeAnnotationCommon, { |
| kind: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("method", "get", "set")), |
| default: "method" |
| }, |
| computed: { |
| validate: (0, _utils.assertValueType)("boolean"), |
| default: false |
| }, |
| key: { |
| validate: 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); |
| }; |
| }() |
| }, |
| decorators: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))) |
| }, |
| 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", "decorators"], |
| fields: { |
| computed: { |
| validate: (0, _utils.assertValueType)("boolean"), |
| default: false |
| }, |
| key: { |
| validate: 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); |
| }; |
| }() |
| }, |
| value: { |
| validate: (0, _utils.assertNodeType)("Expression", "PatternLike") |
| }, |
| shorthand: { |
| validate: (0, _utils.assertValueType)("boolean"), |
| 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"] |
| }); |
| (0, _utils.default)("RestElement", { |
| visitor: ["argument", "typeAnnotation"], |
| builder: ["argument"], |
| aliases: ["LVal", "PatternLike"], |
| deprecatedAlias: "RestProperty", |
| fields: Object.assign({}, patternLikeCommon, { |
| argument: { |
| validate: (0, _utils.assertNodeType)("LVal") |
| } |
| }) |
| }); |
| (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.assertNodeType)("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: (0, _utils.assertNodeType)("Expression") |
| }, |
| 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.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("var", "let", "const")) |
| }, |
| declarations: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("VariableDeclarator"))) |
| } |
| } |
| }); |
| (0, _utils.default)("VariableDeclarator", { |
| visitor: ["id", "init"], |
| fields: { |
| id: { |
| validate: (0, _utils.assertNodeType)("LVal") |
| }, |
| 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)("BlockStatement", "Statement") |
| } |
| } |
| }); |
| (0, _utils.default)("WithStatement", { |
| visitor: ["object", "body"], |
| aliases: ["Statement"], |
| fields: { |
| object: { |
| validate: (0, _utils.assertNodeType)("Expression") |
| }, |
| body: { |
| validate: (0, _utils.assertNodeType)("BlockStatement", "Statement") |
| } |
| } |
| }); |