babel-schmooze-sprockets 0.1.2 → 0.1.3

data/node_modules/babel-generator/node_modules/babel-types/lib/constants.js

@@ -0,0 +1,40 @@
+"use strict";
+
+exports.__esModule = true;
+exports.NOT_LOCAL_BINDING = exports.BLOCK_SCOPED_SYMBOL = exports.INHERIT_KEYS = exports.UNARY_OPERATORS = exports.STRING_UNARY_OPERATORS = exports.NUMBER_UNARY_OPERATORS = exports.BOOLEAN_UNARY_OPERATORS = exports.BINARY_OPERATORS = exports.NUMBER_BINARY_OPERATORS = exports.BOOLEAN_BINARY_OPERATORS = exports.COMPARISON_BINARY_OPERATORS = exports.EQUALITY_BINARY_OPERATORS = exports.BOOLEAN_NUMBER_BINARY_OPERATORS = exports.UPDATE_OPERATORS = exports.LOGICAL_OPERATORS = exports.COMMENT_KEYS = exports.FOR_INIT_KEYS = exports.FLATTENABLE_KEYS = exports.STATEMENT_OR_BLOCK_KEYS = undefined;
+
+var _for = require("babel-runtime/core-js/symbol/for");
+
+var _for2 = _interopRequireDefault(_for);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* eslint max-len: 0 */
+
+var STATEMENT_OR_BLOCK_KEYS = exports.STATEMENT_OR_BLOCK_KEYS = ["consequent", "body", "alternate"];
+var FLATTENABLE_KEYS = exports.FLATTENABLE_KEYS = ["body", "expressions"];
+var FOR_INIT_KEYS = exports.FOR_INIT_KEYS = ["left", "init"];
+var COMMENT_KEYS = exports.COMMENT_KEYS = ["leadingComments", "trailingComments", "innerComments"];
+
+var LOGICAL_OPERATORS = exports.LOGICAL_OPERATORS = ["||", "&&"];
+var UPDATE_OPERATORS = exports.UPDATE_OPERATORS = ["++", "--"];
+
+var BOOLEAN_NUMBER_BINARY_OPERATORS = exports.BOOLEAN_NUMBER_BINARY_OPERATORS = [">", "<", ">=", "<="];
+var EQUALITY_BINARY_OPERATORS = exports.EQUALITY_BINARY_OPERATORS = ["==", "===", "!=", "!=="];
+var COMPARISON_BINARY_OPERATORS = exports.COMPARISON_BINARY_OPERATORS = [].concat(EQUALITY_BINARY_OPERATORS, ["in", "instanceof"]);
+var BOOLEAN_BINARY_OPERATORS = exports.BOOLEAN_BINARY_OPERATORS = [].concat(COMPARISON_BINARY_OPERATORS, BOOLEAN_NUMBER_BINARY_OPERATORS);
+var NUMBER_BINARY_OPERATORS = exports.NUMBER_BINARY_OPERATORS = ["-", "/", "%", "*", "**", "&", "|", ">>", ">>>", "<<", "^"];
+var BINARY_OPERATORS = exports.BINARY_OPERATORS = ["+"].concat(NUMBER_BINARY_OPERATORS, BOOLEAN_BINARY_OPERATORS);
+
+var BOOLEAN_UNARY_OPERATORS = exports.BOOLEAN_UNARY_OPERATORS = ["delete", "!"];
+var NUMBER_UNARY_OPERATORS = exports.NUMBER_UNARY_OPERATORS = ["+", "-", "++", "--", "~"];
+var STRING_UNARY_OPERATORS = exports.STRING_UNARY_OPERATORS = ["typeof"];
+var UNARY_OPERATORS = exports.UNARY_OPERATORS = ["void"].concat(BOOLEAN_UNARY_OPERATORS, NUMBER_UNARY_OPERATORS, STRING_UNARY_OPERATORS);
+
+var INHERIT_KEYS = exports.INHERIT_KEYS = {
+  optional: ["typeAnnotation", "typeParameters", "returnType"],
+  force: ["start", "loc", "end"]
+};
+
+var BLOCK_SCOPED_SYMBOL = exports.BLOCK_SCOPED_SYMBOL = (0, _for2.default)("var used to be block scoped");
+var NOT_LOCAL_BINDING = exports.NOT_LOCAL_BINDING = (0, _for2.default)("should not be considered a local binding");

data/node_modules/babel-generator/node_modules/babel-types/lib/converters.js

@@ -0,0 +1,378 @@
+"use strict";
+
+exports.__esModule = true;
+
+var _maxSafeInteger = require("babel-runtime/core-js/number/max-safe-integer");
+
+var _maxSafeInteger2 = _interopRequireDefault(_maxSafeInteger);
+
+var _stringify = require("babel-runtime/core-js/json/stringify");
+
+var _stringify2 = _interopRequireDefault(_stringify);
+
+var _getIterator2 = require("babel-runtime/core-js/get-iterator");
+
+var _getIterator3 = _interopRequireDefault(_getIterator2);
+
+exports.toComputedKey = toComputedKey;
+exports.toSequenceExpression = toSequenceExpression;
+exports.toKeyAlias = toKeyAlias;
+exports.toIdentifier = toIdentifier;
+exports.toBindingIdentifierName = toBindingIdentifierName;
+exports.toStatement = toStatement;
+exports.toExpression = toExpression;
+exports.toBlock = toBlock;
+exports.valueToNode = valueToNode;
+
+var _isPlainObject = require("lodash/isPlainObject");
+
+var _isPlainObject2 = _interopRequireDefault(_isPlainObject);
+
+var _isNumber = require("lodash/isNumber");
+
+var _isNumber2 = _interopRequireDefault(_isNumber);
+
+var _isRegExp = require("lodash/isRegExp");
+
+var _isRegExp2 = _interopRequireDefault(_isRegExp);
+
+var _isString = require("lodash/isString");
+
+var _isString2 = _interopRequireDefault(_isString);
+
+var _index = require("./index");
+
+var t = _interopRequireWildcard(_index);
+
+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; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function toComputedKey(node) {
+  var key = arguments.length <= 1 || arguments[1] === undefined ? node.key || node.property : arguments[1];
+
+  if (!node.computed) {
+    if (t.isIdentifier(key)) key = t.stringLiteral(key.name);
+  }
+  return key;
+}
+
+/**
+ * Turn an array of statement `nodes` into a `SequenceExpression`.
+ *
+ * Variable declarations are turned into simple assignments and their
+ * declarations hoisted to the top of the current scope.
+ *
+ * Expression statements are just resolved to their expression.
+ */
+
+function toSequenceExpression(nodes, scope) {
+  if (!nodes || !nodes.length) return;
+
+  var declars = [];
+  var bailed = false;
+
+  var result = convert(nodes);
+  if (bailed) return;
+
+  for (var i = 0; i < declars.length; i++) {
+    scope.push(declars[i]);
+  }
+
+  return result;
+
+  function convert(nodes) {
+    var ensureLastUndefined = false;
+    var exprs = [];
+
+    for (var _iterator = nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : (0, _getIterator3.default)(_iterator);;) {
+      var _ref;
+
+      if (_isArray) {
+        if (_i >= _iterator.length) break;
+        _ref = _iterator[_i++];
+      } else {
+        _i = _iterator.next();
+        if (_i.done) break;
+        _ref = _i.value;
+      }
+
+      var node = _ref;
+
+      if (t.isExpression(node)) {
+        exprs.push(node);
+      } else if (t.isExpressionStatement(node)) {
+        exprs.push(node.expression);
+      } else if (t.isVariableDeclaration(node)) {
+        if (node.kind !== "var") return bailed = true; // bailed
+
+        for (var _iterator2 = node.declarations, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : (0, _getIterator3.default)(_iterator2);;) {
+          var _ref2;
+
+          if (_isArray2) {
+            if (_i2 >= _iterator2.length) break;
+            _ref2 = _iterator2[_i2++];
+          } else {
+            _i2 = _iterator2.next();
+            if (_i2.done) break;
+            _ref2 = _i2.value;
+          }
+
+          var declar = _ref2;
+
+          var bindings = t.getBindingIdentifiers(declar);
+          for (var key in bindings) {
+            declars.push({
+              kind: node.kind,
+              id: bindings[key]
+            });
+          }
+
+          if (declar.init) {
+            exprs.push(t.assignmentExpression("=", declar.id, declar.init));
+          }
+        }
+
+        ensureLastUndefined = true;
+        continue;
+      } else if (t.isIfStatement(node)) {
+        var consequent = node.consequent ? convert([node.consequent]) : scope.buildUndefinedNode();
+        var alternate = node.alternate ? convert([node.alternate]) : scope.buildUndefinedNode();
+        if (!consequent || !alternate) return bailed = true;
+
+        exprs.push(t.conditionalExpression(node.test, consequent, alternate));
+      } else if (t.isBlockStatement(node)) {
+        exprs.push(convert(node.body));
+      } else if (t.isEmptyStatement(node)) {
+        // empty statement so ensure the last item is undefined if we're last
+        ensureLastUndefined = true;
+        continue;
+      } else {
+        // bailed, we can't turn this statement into an expression
+        return bailed = true;
+      }
+
+      ensureLastUndefined = false;
+    }
+
+    if (ensureLastUndefined || exprs.length === 0) {
+      exprs.push(scope.buildUndefinedNode());
+    }
+
+    //
+
+    if (exprs.length === 1) {
+      return exprs[0];
+    } else {
+      return t.sequenceExpression(exprs);
+    }
+  }
+}
+
+// Can't use import because of cyclic dependency between babel-traverse
+// and this module (babel-types). This require needs to appear after
+// we export the TYPES constant, so we lazy-initialize it before use.
+var traverse = void 0;
+
+function toKeyAlias(node) {
+  var key = arguments.length <= 1 || arguments[1] === undefined ? node.key : arguments[1];
+
+  if (!traverse) traverse = require("babel-traverse").default;
+
+  var alias = void 0;
+
+  if (node.kind === "method") {
+    return toKeyAlias.increment() + "";
+  } else if (t.isIdentifier(key)) {
+    alias = key.name;
+  } else if (t.isStringLiteral(key)) {
+    alias = (0, _stringify2.default)(key.value);
+  } else {
+    alias = (0, _stringify2.default)(traverse.removeProperties(t.cloneDeep(key)));
+  }
+
+  if (node.computed) {
+    alias = "[" + alias + "]";
+  }
+
+  if (node.static) {
+    alias = "static:" + alias;
+  }
+
+  return alias;
+}
+
+toKeyAlias.uid = 0;
+
+toKeyAlias.increment = function () {
+  if (toKeyAlias.uid >= _maxSafeInteger2.default) {
+    return toKeyAlias.uid = 0;
+  } else {
+    return toKeyAlias.uid++;
+  }
+};
+
+function toIdentifier(name) {
+  name = name + "";
+
+  // replace all non-valid identifiers with dashes
+  name = name.replace(/[^a-zA-Z0-9$_]/g, "-");
+
+  // remove all dashes and numbers from start of name
+  name = name.replace(/^[-0-9]+/, "");
+
+  // camel case
+  name = name.replace(/[-\s]+(.)?/g, function (match, c) {
+    return c ? c.toUpperCase() : "";
+  });
+
+  if (!t.isValidIdentifier(name)) {
+    name = "_" + name;
+  }
+
+  return name || "_";
+}
+
+function toBindingIdentifierName(name) {
+  name = toIdentifier(name);
+  if (name === "eval" || name === "arguments") name = "_" + name;
+  return name;
+}
+
+/**
+ * [Please add a description.]
+ * @returns {Object|Boolean}
+ */
+
+function toStatement(node, ignore) {
+  if (t.isStatement(node)) {
+    return node;
+  }
+
+  var mustHaveId = false;
+  var newType = void 0;
+
+  if (t.isClass(node)) {
+    mustHaveId = true;
+    newType = "ClassDeclaration";
+  } else if (t.isFunction(node)) {
+    mustHaveId = true;
+    newType = "FunctionDeclaration";
+  } else if (t.isAssignmentExpression(node)) {
+    return t.expressionStatement(node);
+  }
+
+  if (mustHaveId && !node.id) {
+    newType = false;
+  }
+
+  if (!newType) {
+    if (ignore) {
+      return false;
+    } else {
+      throw new Error("cannot turn " + node.type + " to a statement");
+    }
+  }
+
+  node.type = newType;
+
+  return node;
+}
+
+function toExpression(node) {
+  if (t.isExpressionStatement(node)) {
+    node = node.expression;
+  }
+
+  if (t.isClass(node)) {
+    node.type = "ClassExpression";
+  } else if (t.isFunction(node)) {
+    node.type = "FunctionExpression";
+  }
+
+  if (t.isExpression(node)) {
+    return node;
+  } else {
+    throw new Error("cannot turn " + node.type + " to an expression");
+  }
+}
+
+function toBlock(node, parent) {
+  if (t.isBlockStatement(node)) {
+    return node;
+  }
+
+  if (t.isEmptyStatement(node)) {
+    node = [];
+  }
+
+  if (!Array.isArray(node)) {
+    if (!t.isStatement(node)) {
+      if (t.isFunction(parent)) {
+        node = t.returnStatement(node);
+      } else {
+        node = t.expressionStatement(node);
+      }
+    }
+
+    node = [node];
+  }
+
+  return t.blockStatement(node);
+}
+
+function valueToNode(value) {
+  // undefined
+  if (value === undefined) {
+    return t.identifier("undefined");
+  }
+
+  // boolean
+  if (value === true || value === false) {
+    return t.booleanLiteral(value);
+  }
+
+  // null
+  if (value === null) {
+    return t.nullLiteral();
+  }
+
+  // strings
+  if ((0, _isString2.default)(value)) {
+    return t.stringLiteral(value);
+  }
+
+  // numbers
+  if ((0, _isNumber2.default)(value)) {
+    return t.numericLiteral(value);
+  }
+
+  // regexes
+  if ((0, _isRegExp2.default)(value)) {
+    var pattern = value.source;
+    var flags = value.toString().match(/\/([a-z]+|)$/)[1];
+    return t.regExpLiteral(pattern, flags);
+  }
+
+  // array
+  if (Array.isArray(value)) {
+    return t.arrayExpression(value.map(t.valueToNode));
+  }
+
+  // object
+  if ((0, _isPlainObject2.default)(value)) {
+    var props = [];
+    for (var key in value) {
+      var nodeKey = void 0;
+      if (t.isValidIdentifier(key)) {
+        nodeKey = t.identifier(key);
+      } else {
+        nodeKey = t.stringLiteral(key);
+      }
+      props.push(t.objectProperty(nodeKey, t.valueToNode(value[key])));
+    }
+    return t.objectExpression(props);
+  }
+
+  throw new Error("don't know how to turn this value into a node");
+}

data/node_modules/babel-generator/node_modules/babel-types/lib/definitions/core.js

@@ -0,0 +1,704 @@
+"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"]
+}); /* eslint max-len: 0 */
+
+(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)) {
+          // todo
+        }
+      }
+    },
+    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")
+    },
+    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")
+    }
+  }
+});
+
+// todo: at least handler or finalizer should be set to be valid
+(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")
+    }
+  }
+});