babel-schmooze-sprockets 0.1.2 → 0.1.3

data/node_modules/babel-core/node_modules/babel-traverse/lib/path/comments.js

@@ -0,0 +1,55 @@
+"use strict";
+
+exports.__esModule = true;
+exports.shareCommentsWithSiblings = shareCommentsWithSiblings;
+exports.addComment = addComment;
+exports.addComments = addComments;
+// This file contains methods responsible for dealing with comments.
+
+/**
+ * Share comments amongst siblings.
+ */
+
+function shareCommentsWithSiblings() {
+  var node = this.node;
+  if (!node) return;
+
+  var trailing = node.trailingComments;
+  var leading = node.leadingComments;
+  if (!trailing && !leading) return;
+
+  var prev = this.getSibling(this.key - 1);
+  var next = this.getSibling(this.key + 1);
+
+  if (!prev.node) prev = next;
+  if (!next.node) next = prev;
+
+  prev.addComments("trailing", leading);
+  next.addComments("leading", trailing);
+}
+
+function addComment(type, content, line) {
+  this.addComments(type, [{
+    type: line ? "CommentLine" : "CommentBlock",
+    value: content
+  }]);
+}
+
+/**
+ * Give node `comments` of the specified `type`.
+ */
+
+function addComments(type, comments) {
+  if (!comments) return;
+
+  var node = this.node;
+  if (!node) return;
+
+  var key = type + "Comments";
+
+  if (node[key]) {
+    node[key] = node[key].concat(comments);
+  } else {
+    node[key] = comments;
+  }
+}

data/node_modules/babel-core/node_modules/babel-traverse/lib/path/context.js

@@ -0,0 +1,297 @@
+"use strict";
+
+exports.__esModule = true;
+
+var _getIterator2 = require("babel-runtime/core-js/get-iterator");
+
+var _getIterator3 = _interopRequireDefault(_getIterator2);
+
+exports.call = call;
+exports._call = _call;
+exports.isBlacklisted = isBlacklisted;
+exports.visit = visit;
+exports.skip = skip;
+exports.skipKey = skipKey;
+exports.stop = stop;
+exports.setScope = setScope;
+exports.setContext = setContext;
+exports.resync = resync;
+exports._resyncParent = _resyncParent;
+exports._resyncKey = _resyncKey;
+exports._resyncList = _resyncList;
+exports._resyncRemoved = _resyncRemoved;
+exports.popContext = popContext;
+exports.pushContext = pushContext;
+exports.setup = setup;
+exports.setKey = setKey;
+exports.requeue = requeue;
+exports._getQueueContexts = _getQueueContexts;
+
+var _index = require("../index");
+
+var _index2 = _interopRequireDefault(_index);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function call(key) {
+  var opts = this.opts;
+
+  this.debug(function () {
+    return key;
+  });
+
+  if (this.node) {
+    if (this._call(opts[key])) return true;
+  }
+
+  if (this.node) {
+    return this._call(opts[this.node.type] && opts[this.node.type][key]);
+  }
+
+  return false;
+} // This file contains methods responsible for maintaining a TraversalContext.
+
+function _call(fns) {
+  if (!fns) return false;
+
+  for (var _iterator = fns, _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 fn = _ref;
+
+    if (!fn) continue;
+
+    var node = this.node;
+    if (!node) return true;
+
+    var ret = fn.call(this.state, this, this.state);
+    if (ret) throw new Error("Unexpected return value from visitor method " + fn);
+
+    // node has been replaced, it will have been requeued
+    if (this.node !== node) return true;
+
+    if (this.shouldStop || this.shouldSkip || this.removed) return true;
+  }
+
+  return false;
+}
+
+function isBlacklisted() {
+  var blacklist = this.opts.blacklist;
+  return blacklist && blacklist.indexOf(this.node.type) > -1;
+}
+
+function visit() {
+  if (!this.node) {
+    return false;
+  }
+
+  if (this.isBlacklisted()) {
+    return false;
+  }
+
+  if (this.opts.shouldSkip && this.opts.shouldSkip(this)) {
+    return false;
+  }
+
+  if (this.call("enter") || this.shouldSkip) {
+    this.debug(function () {
+      return "Skip...";
+    });
+    return this.shouldStop;
+  }
+
+  this.debug(function () {
+    return "Recursing into...";
+  });
+  _index2.default.node(this.node, this.opts, this.scope, this.state, this, this.skipKeys);
+
+  this.call("exit");
+
+  return this.shouldStop;
+}
+
+function skip() {
+  this.shouldSkip = true;
+}
+
+function skipKey(key) {
+  this.skipKeys[key] = true;
+}
+
+function stop() {
+  this.shouldStop = true;
+  this.shouldSkip = true;
+}
+
+function setScope() {
+  if (this.opts && this.opts.noScope) return;
+
+  var target = this.context && this.context.scope;
+
+  if (!target) {
+    var path = this.parentPath;
+    while (path && !target) {
+      if (path.opts && path.opts.noScope) return;
+
+      target = path.scope;
+      path = path.parentPath;
+    }
+  }
+
+  this.scope = this.getScope(target);
+  if (this.scope) this.scope.init();
+}
+
+function setContext(context) {
+  this.shouldSkip = false;
+  this.shouldStop = false;
+  this.removed = false;
+  this.skipKeys = {};
+
+  if (context) {
+    this.context = context;
+    this.state = context.state;
+    this.opts = context.opts;
+  }
+
+  this.setScope();
+
+  return this;
+}
+
+/**
+ * Here we resync the node paths `key` and `container`. If they've changed according
+ * to what we have stored internally then we attempt to resync by crawling and looking
+ * for the new values.
+ */
+
+function resync() {
+  if (this.removed) return;
+
+  this._resyncParent();
+  this._resyncList();
+  this._resyncKey();
+  //this._resyncRemoved();
+}
+
+function _resyncParent() {
+  if (this.parentPath) {
+    this.parent = this.parentPath.node;
+  }
+}
+
+function _resyncKey() {
+  if (!this.container) return;
+
+  if (this.node === this.container[this.key]) return;
+
+  // grrr, path key is out of sync. this is likely due to a modification to the AST
+  // not done through our path APIs
+
+  if (Array.isArray(this.container)) {
+    for (var i = 0; i < this.container.length; i++) {
+      if (this.container[i] === this.node) {
+        return this.setKey(i);
+      }
+    }
+  } else {
+    for (var key in this.container) {
+      if (this.container[key] === this.node) {
+        return this.setKey(key);
+      }
+    }
+  }
+
+  // ¯\_(ツ)_/¯ who knows where it's gone lol
+  this.key = null;
+}
+
+function _resyncList() {
+  if (!this.parent || !this.inList) return;
+
+  var newContainer = this.parent[this.listKey];
+  if (this.container === newContainer) return;
+
+  // container is out of sync. this is likely the result of it being reassigned
+  this.container = newContainer || null;
+}
+
+function _resyncRemoved() {
+  if (this.key == null || !this.container || this.container[this.key] !== this.node) {
+    this._markRemoved();
+  }
+}
+
+function popContext() {
+  this.contexts.pop();
+  this.setContext(this.contexts[this.contexts.length - 1]);
+}
+
+function pushContext(context) {
+  this.contexts.push(context);
+  this.setContext(context);
+}
+
+function setup(parentPath, container, listKey, key) {
+  this.inList = !!listKey;
+  this.listKey = listKey;
+  this.parentKey = listKey || key;
+  this.container = container;
+
+  this.parentPath = parentPath || this.parentPath;
+  this.setKey(key);
+}
+
+function setKey(key) {
+  this.key = key;
+  this.node = this.container[this.key];
+  this.type = this.node && this.node.type;
+}
+
+function requeue() {
+  var pathToQueue = arguments.length <= 0 || arguments[0] === undefined ? this : arguments[0];
+
+  if (pathToQueue.removed) return;
+
+  // TODO(loganfsmyth): This should be switched back to queue in parent contexts
+  // automatically once T2892 and T7160 have been resolved. See T7166.
+  // let contexts = this._getQueueContexts();
+  var contexts = this.contexts;
+
+  for (var _iterator2 = contexts, _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 context = _ref2;
+
+    context.maybeQueue(pathToQueue);
+  }
+}
+
+function _getQueueContexts() {
+  var path = this;
+  var contexts = this.contexts;
+  while (!contexts.length) {
+    path = path.parentPath;
+    contexts = path.contexts;
+  }
+  return contexts;
+}

data/node_modules/babel-core/node_modules/babel-traverse/lib/path/conversion.js

@@ -0,0 +1,48 @@
+"use strict";
+
+exports.__esModule = true;
+exports.toComputedKey = toComputedKey;
+exports.ensureBlock = ensureBlock;
+exports.arrowFunctionToShadowed = arrowFunctionToShadowed;
+
+var _babelTypes = require("babel-types");
+
+var t = _interopRequireWildcard(_babelTypes);
+
+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 toComputedKey() {
+  var node = this.node;
+
+  var key = void 0;
+  if (this.isMemberExpression()) {
+    key = node.property;
+  } else if (this.isProperty() || this.isMethod()) {
+    key = node.key;
+  } else {
+    throw new ReferenceError("todo");
+  }
+
+  if (!node.computed) {
+    if (t.isIdentifier(key)) key = t.stringLiteral(key.name);
+  }
+
+  return key;
+} // This file contains methods that convert the path node into another node or some other type of data.
+
+function ensureBlock() {
+  return t.ensureBlock(this.node);
+}
+
+function arrowFunctionToShadowed() {
+  // todo: maybe error
+  if (!this.isArrowFunctionExpression()) return;
+
+  this.ensureBlock();
+
+  var node = this.node;
+
+  node.expression = false;
+  node.type = "FunctionExpression";
+  node.shadow = node.shadow || true;
+}

data/node_modules/babel-core/node_modules/babel-traverse/lib/path/evaluation.js

@@ -0,0 +1,406 @@
+"use strict";
+
+exports.__esModule = true;
+
+var _typeof2 = require("babel-runtime/helpers/typeof");
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+var _getIterator2 = require("babel-runtime/core-js/get-iterator");
+
+var _getIterator3 = _interopRequireDefault(_getIterator2);
+
+var _map = require("babel-runtime/core-js/map");
+
+var _map2 = _interopRequireDefault(_map);
+
+exports.evaluateTruthy = evaluateTruthy;
+exports.evaluate = evaluate;
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// This file contains Babels metainterpreter that can evaluate static code.
+
+/* eslint eqeqeq: 0 */
+
+var VALID_CALLEES = ["String", "Number", "Math"]; /* eslint indent: 0 */
+/* eslint max-len: 0 */
+
+var INVALID_METHODS = ["random"];
+
+/**
+ * Walk the input `node` and statically evaluate if it's truthy.
+ *
+ * Returning `true` when we're sure that the expression will evaluate to a
+ * truthy value, `false` if we're sure that it will evaluate to a falsy
+ * value and `undefined` if we aren't sure. Because of this please do not
+ * rely on coercion when using this method and check with === if it's false.
+ *
+ * For example do:
+ *
+ *   if (t.evaluateTruthy(node) === false) falsyLogic();
+ *
+ * **AND NOT**
+ *
+ *   if (!t.evaluateTruthy(node)) falsyLogic();
+ *
+ */
+
+function evaluateTruthy() {
+  var res = this.evaluate();
+  if (res.confident) return !!res.value;
+}
+
+/**
+ * Walk the input `node` and statically evaluate it.
+ *
+ * Returns an object in the form `{ confident, value }`. `confident` indicates
+ * whether or not we had to drop out of evaluating the expression because of
+ * hitting an unknown node that we couldn't confidently find the value of.
+ *
+ * Example:
+ *
+ *   t.evaluate(parse("5 + 5")) // { confident: true, value: 10 }
+ *   t.evaluate(parse("!true")) // { confident: true, value: false }
+ *   t.evaluate(parse("foo + foo")) // { confident: false, value: undefined }
+ *
+ */
+
+function evaluate() {
+  var confident = true;
+  var deoptPath = void 0;
+  var seen = new _map2.default();
+
+  function deopt(path) {
+    if (!confident) return;
+    deoptPath = path;
+    confident = false;
+  }
+
+  var value = evaluate(this);
+  if (!confident) value = undefined;
+  return {
+    confident: confident,
+    deopt: deoptPath,
+    value: value
+  };
+
+  // we wrap the _evaluate method so we can track `seen` nodes, we push an item
+  // to the map before we actually evaluate it so we can deopt on self recursive
+  // nodes such as:
+  //
+  //   var g = a ? 1 : 2,
+  //       a = g * this.foo
+  //
+  function evaluate(path) {
+    var node = path.node;
+
+
+    if (seen.has(node)) {
+      var existing = seen.get(node);
+      if (existing.resolved) {
+        return existing.value;
+      } else {
+        deopt(path);
+        return;
+      }
+    } else {
+      var item = { resolved: false };
+      seen.set(node, item);
+
+      var val = _evaluate(path);
+      item.resolved = true;
+      item.value = value;
+      return val;
+    }
+  }
+
+  function _evaluate(path) {
+    if (!confident) return;
+
+    var node = path.node;
+
+
+    if (path.isSequenceExpression()) {
+      var exprs = path.get("expressions");
+      return evaluate(exprs[exprs.length - 1]);
+    }
+
+    if (path.isStringLiteral() || path.isNumericLiteral() || path.isBooleanLiteral()) {
+      return node.value;
+    }
+
+    if (path.isNullLiteral()) {
+      return null;
+    }
+
+    if (path.isTemplateLiteral()) {
+      var str = "";
+
+      var i = 0;
+      var _exprs = path.get("expressions");
+
+      for (var _iterator = node.quasis, _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 elem = _ref;
+
+        // not confident, evaluated an expression we don't like
+        if (!confident) break;
+
+        // add on cooked element
+        str += elem.value.cooked;
+
+        // add on interpolated expression if it's present
+        var expr = _exprs[i++];
+        if (expr) str += String(evaluate(expr));
+      }
+
+      if (!confident) return;
+      return str;
+    }
+
+    if (path.isConditionalExpression()) {
+      var testResult = evaluate(path.get("test"));
+      if (!confident) return;
+      if (testResult) {
+        return evaluate(path.get("consequent"));
+      } else {
+        return evaluate(path.get("alternate"));
+      }
+    }
+
+    if (path.isExpressionWrapper()) {
+      // TypeCastExpression, ExpressionStatement etc
+      return evaluate(path.get("expression"));
+    }
+
+    // "foo".length
+    if (path.isMemberExpression() && !path.parentPath.isCallExpression({ callee: node })) {
+      var property = path.get("property");
+      var object = path.get("object");
+
+      if (object.isLiteral() && property.isIdentifier()) {
+        var _value = object.node.value;
+        var type = typeof _value === "undefined" ? "undefined" : (0, _typeof3.default)(_value);
+        if (type === "number" || type === "string") {
+          return _value[property.node.name];
+        }
+      }
+    }
+
+    if (path.isReferencedIdentifier()) {
+      var binding = path.scope.getBinding(node.name);
+      if (binding && binding.hasValue) {
+        return binding.value;
+      } else {
+        if (node.name === "undefined") {
+          return undefined;
+        } else if (node.name === "Infinity") {
+          return Infinity;
+        } else if (node.name === "NaN") {
+          return NaN;
+        }
+
+        var resolved = path.resolve();
+        if (resolved === path) {
+          return deopt(path);
+        } else {
+          return evaluate(resolved);
+        }
+      }
+    }
+
+    if (path.isUnaryExpression({ prefix: true })) {
+      if (node.operator === "void") {
+        // we don't need to evaluate the argument to know what this will return
+        return undefined;
+      }
+
+      var argument = path.get("argument");
+      if (node.operator === "typeof" && (argument.isFunction() || argument.isClass())) {
+        return "function";
+      }
+
+      var arg = evaluate(argument);
+      if (!confident) return;
+      switch (node.operator) {
+        case "!":
+          return !arg;
+        case "+":
+          return +arg;
+        case "-":
+          return -arg;
+        case "~":
+          return ~arg;
+        case "typeof":
+          return typeof arg === "undefined" ? "undefined" : (0, _typeof3.default)(arg);
+      }
+    }
+
+    if (path.isArrayExpression()) {
+      var arr = [];
+      var elems = path.get("elements");
+      for (var _iterator2 = elems, _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 _elem = _ref2;
+
+        _elem = _elem.evaluate();
+
+        if (_elem.confident) {
+          arr.push(_elem.value);
+        } else {
+          return deopt(_elem);
+        }
+      }
+      return arr;
+    }
+
+    if (path.isObjectExpression()) {
+      // todo
+    }
+
+    if (path.isLogicalExpression()) {
+      // If we are confident that one side of an && is false, or the left
+      // side of an || is true, we can be confident about the entire expression
+      var wasConfident = confident;
+      var left = evaluate(path.get("left"));
+      var leftConfident = confident;
+      confident = wasConfident;
+      var right = evaluate(path.get("right"));
+      var rightConfident = confident;
+      confident = leftConfident && rightConfident;
+
+      switch (node.operator) {
+        case "||":
+          // TODO consider having a "truthy type" that doesn't bail on
+          // left uncertainity but can still evaluate to truthy.
+          if (left && leftConfident) {
+            confident = true;
+            return left;
+          }
+
+          if (!confident) return;
+
+          return left || right;
+        case "&&":
+          if (!left && leftConfident || !right && rightConfident) {
+            confident = true;
+          }
+
+          if (!confident) return;
+
+          return left && right;
+      }
+    }
+
+    if (path.isBinaryExpression()) {
+      var _left = evaluate(path.get("left"));
+      if (!confident) return;
+      var _right = evaluate(path.get("right"));
+      if (!confident) return;
+
+      switch (node.operator) {
+        case "-":
+          return _left - _right;
+        case "+":
+          return _left + _right;
+        case "/":
+          return _left / _right;
+        case "*":
+          return _left * _right;
+        case "%":
+          return _left % _right;
+        case "**":
+          return Math.pow(_left, _right);
+        case "<":
+          return _left < _right;
+        case ">":
+          return _left > _right;
+        case "<=":
+          return _left <= _right;
+        case ">=":
+          return _left >= _right;
+        case "==":
+          return _left == _right;
+        case "!=":
+          return _left != _right;
+        case "===":
+          return _left === _right;
+        case "!==":
+          return _left !== _right;
+        case "|":
+          return _left | _right;
+        case "&":
+          return _left & _right;
+        case "^":
+          return _left ^ _right;
+        case "<<":
+          return _left << _right;
+        case ">>":
+          return _left >> _right;
+        case ">>>":
+          return _left >>> _right;
+      }
+    }
+
+    if (path.isCallExpression()) {
+      var callee = path.get("callee");
+      var context = void 0;
+      var func = void 0;
+
+      // Number(1);
+      if (callee.isIdentifier() && !path.scope.getBinding(callee.node.name, true) && VALID_CALLEES.indexOf(callee.node.name) >= 0) {
+        func = global[node.callee.name];
+      }
+
+      if (callee.isMemberExpression()) {
+        var _object = callee.get("object");
+        var _property = callee.get("property");
+
+        // Math.min(1, 2)
+        if (_object.isIdentifier() && _property.isIdentifier() && VALID_CALLEES.indexOf(_object.node.name) >= 0 && INVALID_METHODS.indexOf(_property.node.name) < 0) {
+          context = global[_object.node.name];
+          func = context[_property.node.name];
+        }
+
+        // "abc".charCodeAt(4)
+        if (_object.isLiteral() && _property.isIdentifier()) {
+          var _type = (0, _typeof3.default)(_object.node.value);
+          if (_type === "string" || _type === "number") {
+            context = _object.node.value;
+            func = context[_property.node.name];
+          }
+        }
+      }
+
+      if (func) {
+        var args = path.get("arguments").map(evaluate);
+        if (!confident) return;
+
+        return func.apply(context, args);
+      }
+    }
+
+    deopt(path);
+  }
+}