701 lines
18 KiB
JavaScript
701 lines
18 KiB
JavaScript
"use strict";
|
|
|
|
var _index = require("../index");
|
|
|
|
var t = _interopRequireWildcard(_index);
|
|
|
|
var _constants = require("../constants");
|
|
|
|
var _index2 = require("./index");
|
|
|
|
var _index3 = _interopRequireDefault(_index2);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
|
|
|
|
(0, _index3.default)("ArrayExpression", {
|
|
fields: {
|
|
elements: {
|
|
validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeOrValueType)("null", "Expression", "SpreadElement"))),
|
|
default: []
|
|
}
|
|
},
|
|
visitor: ["elements"],
|
|
aliases: ["Expression"]
|
|
});
|
|
|
|
(0, _index3.default)("AssignmentExpression", {
|
|
fields: {
|
|
operator: {
|
|
validate: (0, _index2.assertValueType)("string")
|
|
},
|
|
left: {
|
|
validate: (0, _index2.assertNodeType)("LVal")
|
|
},
|
|
right: {
|
|
validate: (0, _index2.assertNodeType)("Expression")
|
|
}
|
|
},
|
|
builder: ["operator", "left", "right"],
|
|
visitor: ["left", "right"],
|
|
aliases: ["Expression"]
|
|
});
|
|
|
|
(0, _index3.default)("BinaryExpression", {
|
|
builder: ["operator", "left", "right"],
|
|
fields: {
|
|
operator: {
|
|
validate: _index2.assertOneOf.apply(undefined, _constants.BINARY_OPERATORS)
|
|
},
|
|
left: {
|
|
validate: (0, _index2.assertNodeType)("Expression")
|
|
},
|
|
right: {
|
|
validate: (0, _index2.assertNodeType)("Expression")
|
|
}
|
|
},
|
|
visitor: ["left", "right"],
|
|
aliases: ["Binary", "Expression"]
|
|
});
|
|
|
|
(0, _index3.default)("Directive", {
|
|
visitor: ["value"],
|
|
fields: {
|
|
value: {
|
|
validate: (0, _index2.assertNodeType)("DirectiveLiteral")
|
|
}
|
|
}
|
|
});
|
|
|
|
(0, _index3.default)("DirectiveLiteral", {
|
|
builder: ["value"],
|
|
fields: {
|
|
value: {
|
|
validate: (0, _index2.assertValueType)("string")
|
|
}
|
|
}
|
|
});
|
|
|
|
(0, _index3.default)("BlockStatement", {
|
|
builder: ["body", "directives"],
|
|
visitor: ["directives", "body"],
|
|
fields: {
|
|
directives: {
|
|
validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("Directive"))),
|
|
default: []
|
|
},
|
|
body: {
|
|
validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("Statement")))
|
|
}
|
|
},
|
|
aliases: ["Scopable", "BlockParent", "Block", "Statement"]
|
|
});
|
|
|
|
(0, _index3.default)("BreakStatement", {
|
|
visitor: ["label"],
|
|
fields: {
|
|
label: {
|
|
validate: (0, _index2.assertNodeType)("Identifier"),
|
|
optional: true
|
|
}
|
|
},
|
|
aliases: ["Statement", "Terminatorless", "CompletionStatement"]
|
|
});
|
|
|
|
(0, _index3.default)("CallExpression", {
|
|
visitor: ["callee", "arguments"],
|
|
fields: {
|
|
callee: {
|
|
validate: (0, _index2.assertNodeType)("Expression")
|
|
},
|
|
arguments: {
|
|
validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("Expression", "SpreadElement")))
|
|
}
|
|
},
|
|
aliases: ["Expression"]
|
|
});
|
|
|
|
(0, _index3.default)("CatchClause", {
|
|
visitor: ["param", "body"],
|
|
fields: {
|
|
param: {
|
|
validate: (0, _index2.assertNodeType)("Identifier")
|
|
},
|
|
body: {
|
|
validate: (0, _index2.assertNodeType)("BlockStatement")
|
|
}
|
|
},
|
|
aliases: ["Scopable"]
|
|
});
|
|
|
|
(0, _index3.default)("ConditionalExpression", {
|
|
visitor: ["test", "consequent", "alternate"],
|
|
fields: {
|
|
test: {
|
|
validate: (0, _index2.assertNodeType)("Expression")
|
|
},
|
|
consequent: {
|
|
validate: (0, _index2.assertNodeType)("Expression")
|
|
},
|
|
alternate: {
|
|
validate: (0, _index2.assertNodeType)("Expression")
|
|
}
|
|
},
|
|
aliases: ["Expression", "Conditional"]
|
|
});
|
|
|
|
(0, _index3.default)("ContinueStatement", {
|
|
visitor: ["label"],
|
|
fields: {
|
|
label: {
|
|
validate: (0, _index2.assertNodeType)("Identifier"),
|
|
optional: true
|
|
}
|
|
},
|
|
aliases: ["Statement", "Terminatorless", "CompletionStatement"]
|
|
});
|
|
|
|
(0, _index3.default)("DebuggerStatement", {
|
|
aliases: ["Statement"]
|
|
});
|
|
|
|
(0, _index3.default)("DoWhileStatement", {
|
|
visitor: ["test", "body"],
|
|
fields: {
|
|
test: {
|
|
validate: (0, _index2.assertNodeType)("Expression")
|
|
},
|
|
body: {
|
|
validate: (0, _index2.assertNodeType)("Statement")
|
|
}
|
|
},
|
|
aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"]
|
|
});
|
|
|
|
(0, _index3.default)("EmptyStatement", {
|
|
aliases: ["Statement"]
|
|
});
|
|
|
|
(0, _index3.default)("ExpressionStatement", {
|
|
visitor: ["expression"],
|
|
fields: {
|
|
expression: {
|
|
validate: (0, _index2.assertNodeType)("Expression")
|
|
}
|
|
},
|
|
aliases: ["Statement", "ExpressionWrapper"]
|
|
});
|
|
|
|
(0, _index3.default)("File", {
|
|
builder: ["program", "comments", "tokens"],
|
|
visitor: ["program"],
|
|
fields: {
|
|
program: {
|
|
validate: (0, _index2.assertNodeType)("Program")
|
|
}
|
|
}
|
|
});
|
|
|
|
(0, _index3.default)("ForInStatement", {
|
|
visitor: ["left", "right", "body"],
|
|
aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"],
|
|
fields: {
|
|
left: {
|
|
validate: (0, _index2.assertNodeType)("VariableDeclaration", "LVal")
|
|
},
|
|
right: {
|
|
validate: (0, _index2.assertNodeType)("Expression")
|
|
},
|
|
body: {
|
|
validate: (0, _index2.assertNodeType)("Statement")
|
|
}
|
|
}
|
|
});
|
|
|
|
(0, _index3.default)("ForStatement", {
|
|
visitor: ["init", "test", "update", "body"],
|
|
aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop"],
|
|
fields: {
|
|
init: {
|
|
validate: (0, _index2.assertNodeType)("VariableDeclaration", "Expression"),
|
|
optional: true
|
|
},
|
|
test: {
|
|
validate: (0, _index2.assertNodeType)("Expression"),
|
|
optional: true
|
|
},
|
|
update: {
|
|
validate: (0, _index2.assertNodeType)("Expression"),
|
|
optional: true
|
|
},
|
|
body: {
|
|
validate: (0, _index2.assertNodeType)("Statement")
|
|
}
|
|
}
|
|
});
|
|
|
|
(0, _index3.default)("FunctionDeclaration", {
|
|
builder: ["id", "params", "body", "generator", "async"],
|
|
visitor: ["id", "params", "body", "returnType", "typeParameters"],
|
|
fields: {
|
|
id: {
|
|
validate: (0, _index2.assertNodeType)("Identifier")
|
|
},
|
|
params: {
|
|
validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("LVal")))
|
|
},
|
|
body: {
|
|
validate: (0, _index2.assertNodeType)("BlockStatement")
|
|
},
|
|
generator: {
|
|
default: false,
|
|
validate: (0, _index2.assertValueType)("boolean")
|
|
},
|
|
async: {
|
|
default: false,
|
|
validate: (0, _index2.assertValueType)("boolean")
|
|
}
|
|
},
|
|
aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Statement", "Pureish", "Declaration"]
|
|
});
|
|
|
|
(0, _index3.default)("FunctionExpression", {
|
|
inherits: "FunctionDeclaration",
|
|
aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"],
|
|
fields: {
|
|
id: {
|
|
validate: (0, _index2.assertNodeType)("Identifier"),
|
|
optional: true
|
|
},
|
|
params: {
|
|
validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("LVal")))
|
|
},
|
|
body: {
|
|
validate: (0, _index2.assertNodeType)("BlockStatement")
|
|
},
|
|
generator: {
|
|
default: false,
|
|
validate: (0, _index2.assertValueType)("boolean")
|
|
},
|
|
async: {
|
|
default: false,
|
|
validate: (0, _index2.assertValueType)("boolean")
|
|
}
|
|
}
|
|
});
|
|
|
|
(0, _index3.default)("Identifier", {
|
|
builder: ["name"],
|
|
visitor: ["typeAnnotation"],
|
|
aliases: ["Expression", "LVal"],
|
|
fields: {
|
|
name: {
|
|
validate: function validate(node, key, val) {
|
|
if (!t.isValidIdentifier(val)) {}
|
|
}
|
|
},
|
|
decorators: {
|
|
validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("Decorator")))
|
|
}
|
|
}
|
|
});
|
|
|
|
(0, _index3.default)("IfStatement", {
|
|
visitor: ["test", "consequent", "alternate"],
|
|
aliases: ["Statement", "Conditional"],
|
|
fields: {
|
|
test: {
|
|
validate: (0, _index2.assertNodeType)("Expression")
|
|
},
|
|
consequent: {
|
|
validate: (0, _index2.assertNodeType)("Statement")
|
|
},
|
|
alternate: {
|
|
optional: true,
|
|
validate: (0, _index2.assertNodeType)("Statement")
|
|
}
|
|
}
|
|
});
|
|
|
|
(0, _index3.default)("LabeledStatement", {
|
|
visitor: ["label", "body"],
|
|
aliases: ["Statement"],
|
|
fields: {
|
|
label: {
|
|
validate: (0, _index2.assertNodeType)("Identifier")
|
|
},
|
|
body: {
|
|
validate: (0, _index2.assertNodeType)("Statement")
|
|
}
|
|
}
|
|
});
|
|
|
|
(0, _index3.default)("StringLiteral", {
|
|
builder: ["value"],
|
|
fields: {
|
|
value: {
|
|
validate: (0, _index2.assertValueType)("string")
|
|
}
|
|
},
|
|
aliases: ["Expression", "Pureish", "Literal", "Immutable"]
|
|
});
|
|
|
|
(0, _index3.default)("NumericLiteral", {
|
|
builder: ["value"],
|
|
deprecatedAlias: "NumberLiteral",
|
|
fields: {
|
|
value: {
|
|
validate: (0, _index2.assertValueType)("number")
|
|
}
|
|
},
|
|
aliases: ["Expression", "Pureish", "Literal", "Immutable"]
|
|
});
|
|
|
|
(0, _index3.default)("NullLiteral", {
|
|
aliases: ["Expression", "Pureish", "Literal", "Immutable"]
|
|
});
|
|
|
|
(0, _index3.default)("BooleanLiteral", {
|
|
builder: ["value"],
|
|
fields: {
|
|
value: {
|
|
validate: (0, _index2.assertValueType)("boolean")
|
|
}
|
|
},
|
|
aliases: ["Expression", "Pureish", "Literal", "Immutable"]
|
|
});
|
|
|
|
(0, _index3.default)("RegExpLiteral", {
|
|
builder: ["pattern", "flags"],
|
|
deprecatedAlias: "RegexLiteral",
|
|
aliases: ["Expression", "Literal"],
|
|
fields: {
|
|
pattern: {
|
|
validate: (0, _index2.assertValueType)("string")
|
|
},
|
|
flags: {
|
|
validate: (0, _index2.assertValueType)("string"),
|
|
default: ""
|
|
}
|
|
}
|
|
});
|
|
|
|
(0, _index3.default)("LogicalExpression", {
|
|
builder: ["operator", "left", "right"],
|
|
visitor: ["left", "right"],
|
|
aliases: ["Binary", "Expression"],
|
|
fields: {
|
|
operator: {
|
|
validate: _index2.assertOneOf.apply(undefined, _constants.LOGICAL_OPERATORS)
|
|
},
|
|
left: {
|
|
validate: (0, _index2.assertNodeType)("Expression")
|
|
},
|
|
right: {
|
|
validate: (0, _index2.assertNodeType)("Expression")
|
|
}
|
|
}
|
|
});
|
|
|
|
(0, _index3.default)("MemberExpression", {
|
|
builder: ["object", "property", "computed"],
|
|
visitor: ["object", "property"],
|
|
aliases: ["Expression", "LVal"],
|
|
fields: {
|
|
object: {
|
|
validate: (0, _index2.assertNodeType)("Expression")
|
|
},
|
|
property: {
|
|
validate: function validate(node, key, val) {
|
|
var expectedType = node.computed ? "Expression" : "Identifier";
|
|
(0, _index2.assertNodeType)(expectedType)(node, key, val);
|
|
}
|
|
},
|
|
computed: {
|
|
default: false
|
|
}
|
|
}
|
|
});
|
|
|
|
(0, _index3.default)("NewExpression", {
|
|
visitor: ["callee", "arguments"],
|
|
aliases: ["Expression"],
|
|
fields: {
|
|
callee: {
|
|
validate: (0, _index2.assertNodeType)("Expression")
|
|
},
|
|
arguments: {
|
|
validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("Expression", "SpreadElement")))
|
|
}
|
|
}
|
|
});
|
|
|
|
(0, _index3.default)("Program", {
|
|
visitor: ["directives", "body"],
|
|
builder: ["body", "directives"],
|
|
fields: {
|
|
directives: {
|
|
validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("Directive"))),
|
|
default: []
|
|
},
|
|
body: {
|
|
validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("Statement")))
|
|
}
|
|
},
|
|
aliases: ["Scopable", "BlockParent", "Block", "FunctionParent"]
|
|
});
|
|
|
|
(0, _index3.default)("ObjectExpression", {
|
|
visitor: ["properties"],
|
|
aliases: ["Expression"],
|
|
fields: {
|
|
properties: {
|
|
validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("ObjectMethod", "ObjectProperty", "SpreadProperty")))
|
|
}
|
|
}
|
|
});
|
|
|
|
(0, _index3.default)("ObjectMethod", {
|
|
builder: ["kind", "key", "params", "body", "computed"],
|
|
fields: {
|
|
kind: {
|
|
validate: (0, _index2.chain)((0, _index2.assertValueType)("string"), (0, _index2.assertOneOf)("method", "get", "set")),
|
|
default: "method"
|
|
},
|
|
computed: {
|
|
validate: (0, _index2.assertValueType)("boolean"),
|
|
default: false
|
|
},
|
|
key: {
|
|
validate: function validate(node, key, val) {
|
|
var expectedTypes = node.computed ? ["Expression"] : ["Identifier", "StringLiteral", "NumericLiteral"];
|
|
_index2.assertNodeType.apply(undefined, expectedTypes)(node, key, val);
|
|
}
|
|
},
|
|
decorators: {
|
|
validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("Decorator")))
|
|
},
|
|
body: {
|
|
validate: (0, _index2.assertNodeType)("BlockStatement")
|
|
},
|
|
generator: {
|
|
default: false,
|
|
validate: (0, _index2.assertValueType)("boolean")
|
|
},
|
|
async: {
|
|
default: false,
|
|
validate: (0, _index2.assertValueType)("boolean")
|
|
}
|
|
},
|
|
visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
|
|
aliases: ["UserWhitespacable", "Function", "Scopable", "BlockParent", "FunctionParent", "Method", "ObjectMember"]
|
|
});
|
|
|
|
(0, _index3.default)("ObjectProperty", {
|
|
builder: ["key", "value", "computed", "shorthand", "decorators"],
|
|
fields: {
|
|
computed: {
|
|
validate: (0, _index2.assertValueType)("boolean"),
|
|
default: false
|
|
},
|
|
key: {
|
|
validate: function validate(node, key, val) {
|
|
var expectedTypes = node.computed ? ["Expression"] : ["Identifier", "StringLiteral", "NumericLiteral"];
|
|
_index2.assertNodeType.apply(undefined, expectedTypes)(node, key, val);
|
|
}
|
|
},
|
|
value: {
|
|
validate: (0, _index2.assertNodeType)("Expression", "Pattern", "RestElement")
|
|
},
|
|
shorthand: {
|
|
validate: (0, _index2.assertValueType)("boolean"),
|
|
default: false
|
|
},
|
|
decorators: {
|
|
validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("Decorator"))),
|
|
optional: true
|
|
}
|
|
},
|
|
visitor: ["key", "value", "decorators"],
|
|
aliases: ["UserWhitespacable", "Property", "ObjectMember"]
|
|
});
|
|
|
|
(0, _index3.default)("RestElement", {
|
|
visitor: ["argument", "typeAnnotation"],
|
|
aliases: ["LVal"],
|
|
fields: {
|
|
argument: {
|
|
validate: (0, _index2.assertNodeType)("LVal")
|
|
},
|
|
decorators: {
|
|
validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("Decorator")))
|
|
}
|
|
}
|
|
});
|
|
|
|
(0, _index3.default)("ReturnStatement", {
|
|
visitor: ["argument"],
|
|
aliases: ["Statement", "Terminatorless", "CompletionStatement"],
|
|
fields: {
|
|
argument: {
|
|
validate: (0, _index2.assertNodeType)("Expression"),
|
|
optional: true
|
|
}
|
|
}
|
|
});
|
|
|
|
(0, _index3.default)("SequenceExpression", {
|
|
visitor: ["expressions"],
|
|
fields: {
|
|
expressions: {
|
|
validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("Expression")))
|
|
}
|
|
},
|
|
aliases: ["Expression"]
|
|
});
|
|
|
|
(0, _index3.default)("SwitchCase", {
|
|
visitor: ["test", "consequent"],
|
|
fields: {
|
|
test: {
|
|
validate: (0, _index2.assertNodeType)("Expression"),
|
|
optional: true
|
|
},
|
|
consequent: {
|
|
validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("Statement")))
|
|
}
|
|
}
|
|
});
|
|
|
|
(0, _index3.default)("SwitchStatement", {
|
|
visitor: ["discriminant", "cases"],
|
|
aliases: ["Statement", "BlockParent", "Scopable"],
|
|
fields: {
|
|
discriminant: {
|
|
validate: (0, _index2.assertNodeType)("Expression")
|
|
},
|
|
cases: {
|
|
validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("SwitchCase")))
|
|
}
|
|
}
|
|
});
|
|
|
|
(0, _index3.default)("ThisExpression", {
|
|
aliases: ["Expression"]
|
|
});
|
|
|
|
(0, _index3.default)("ThrowStatement", {
|
|
visitor: ["argument"],
|
|
aliases: ["Statement", "Terminatorless", "CompletionStatement"],
|
|
fields: {
|
|
argument: {
|
|
validate: (0, _index2.assertNodeType)("Expression")
|
|
}
|
|
}
|
|
});
|
|
|
|
(0, _index3.default)("TryStatement", {
|
|
visitor: ["block", "handler", "finalizer"],
|
|
aliases: ["Statement"],
|
|
fields: {
|
|
body: {
|
|
validate: (0, _index2.assertNodeType)("BlockStatement")
|
|
},
|
|
handler: {
|
|
optional: true,
|
|
handler: (0, _index2.assertNodeType)("BlockStatement")
|
|
},
|
|
finalizer: {
|
|
optional: true,
|
|
validate: (0, _index2.assertNodeType)("BlockStatement")
|
|
}
|
|
}
|
|
});
|
|
|
|
(0, _index3.default)("UnaryExpression", {
|
|
builder: ["operator", "argument", "prefix"],
|
|
fields: {
|
|
prefix: {
|
|
default: true
|
|
},
|
|
argument: {
|
|
validate: (0, _index2.assertNodeType)("Expression")
|
|
},
|
|
operator: {
|
|
validate: _index2.assertOneOf.apply(undefined, _constants.UNARY_OPERATORS)
|
|
}
|
|
},
|
|
visitor: ["argument"],
|
|
aliases: ["UnaryLike", "Expression"]
|
|
});
|
|
|
|
(0, _index3.default)("UpdateExpression", {
|
|
builder: ["operator", "argument", "prefix"],
|
|
fields: {
|
|
prefix: {
|
|
default: false
|
|
},
|
|
argument: {
|
|
validate: (0, _index2.assertNodeType)("Expression")
|
|
},
|
|
operator: {
|
|
validate: _index2.assertOneOf.apply(undefined, _constants.UPDATE_OPERATORS)
|
|
}
|
|
},
|
|
visitor: ["argument"],
|
|
aliases: ["Expression"]
|
|
});
|
|
|
|
(0, _index3.default)("VariableDeclaration", {
|
|
builder: ["kind", "declarations"],
|
|
visitor: ["declarations"],
|
|
aliases: ["Statement", "Declaration"],
|
|
fields: {
|
|
kind: {
|
|
validate: (0, _index2.chain)((0, _index2.assertValueType)("string"), (0, _index2.assertOneOf)("var", "let", "const"))
|
|
},
|
|
declarations: {
|
|
validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("VariableDeclarator")))
|
|
}
|
|
}
|
|
});
|
|
|
|
(0, _index3.default)("VariableDeclarator", {
|
|
visitor: ["id", "init"],
|
|
fields: {
|
|
id: {
|
|
validate: (0, _index2.assertNodeType)("LVal")
|
|
},
|
|
init: {
|
|
optional: true,
|
|
validate: (0, _index2.assertNodeType)("Expression")
|
|
}
|
|
}
|
|
});
|
|
|
|
(0, _index3.default)("WhileStatement", {
|
|
visitor: ["test", "body"],
|
|
aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"],
|
|
fields: {
|
|
test: {
|
|
validate: (0, _index2.assertNodeType)("Expression")
|
|
},
|
|
body: {
|
|
validate: (0, _index2.assertNodeType)("BlockStatement", "Statement")
|
|
}
|
|
}
|
|
});
|
|
|
|
(0, _index3.default)("WithStatement", {
|
|
visitor: ["object", "body"],
|
|
aliases: ["Statement"],
|
|
fields: {
|
|
object: {
|
|
object: (0, _index2.assertNodeType)("Expression")
|
|
},
|
|
body: {
|
|
validate: (0, _index2.assertNodeType)("BlockStatement", "Statement")
|
|
}
|
|
}
|
|
}); |