api, login, auth

1 files changed, 238 insertions, 0 deletions

diff --git a/node_modules/babel-traverse/lib/path/ancestry.js b/node_modules/babel-traverse/lib/path/ancestry.js
new file mode 100644
index 0000000..2a8c322
--- /dev/null
+++ b/node_modules/babel-traverse/lib/path/ancestry.js
@@ -0,0 +1,238 @@
+"use strict";
+
+exports.__esModule = true;
+
+var _getIterator2 = require("babel-runtime/core-js/get-iterator");
+
+var _getIterator3 = _interopRequireDefault(_getIterator2);
+
+exports.findParent = findParent;
+exports.find = find;
+exports.getFunctionParent = getFunctionParent;
+exports.getStatementParent = getStatementParent;
+exports.getEarliestCommonAncestorFrom = getEarliestCommonAncestorFrom;
+exports.getDeepestCommonAncestorFrom = getDeepestCommonAncestorFrom;
+exports.getAncestry = getAncestry;
+exports.isAncestor = isAncestor;
+exports.isDescendant = isDescendant;
+exports.inType = inType;
+exports.inShadow = inShadow;
+
+var _babelTypes = require("babel-types");
+
+var t = _interopRequireWildcard(_babelTypes);
+
+var _index = require("./index");
+
+var _index2 = _interopRequireDefault(_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 findParent(callback) {
+  var path = this;
+  while (path = path.parentPath) {
+    if (callback(path)) return path;
+  }
+  return null;
+}
+
+function find(callback) {
+  var path = this;
+  do {
+    if (callback(path)) return path;
+  } while (path = path.parentPath);
+  return null;
+}
+
+function getFunctionParent() {
+  return this.findParent(function (path) {
+    return path.isFunction() || path.isProgram();
+  });
+}
+
+function getStatementParent() {
+  var path = this;
+  do {
+    if (Array.isArray(path.container)) {
+      return path;
+    }
+  } while (path = path.parentPath);
+}
+
+function getEarliestCommonAncestorFrom(paths) {
+  return this.getDeepestCommonAncestorFrom(paths, function (deepest, i, ancestries) {
+    var earliest = void 0;
+    var keys = t.VISITOR_KEYS[deepest.type];
+
+    for (var _iterator = ancestries, _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 ancestry = _ref;
+
+      var path = ancestry[i + 1];
+
+      if (!earliest) {
+        earliest = path;
+        continue;
+      }
+
+      if (path.listKey && earliest.listKey === path.listKey) {
+        if (path.key < earliest.key) {
+          earliest = path;
+          continue;
+        }
+      }
+
+      var earliestKeyIndex = keys.indexOf(earliest.parentKey);
+      var currentKeyIndex = keys.indexOf(path.parentKey);
+      if (earliestKeyIndex > currentKeyIndex) {
+        earliest = path;
+      }
+    }
+
+    return earliest;
+  });
+}
+
+function getDeepestCommonAncestorFrom(paths, filter) {
+  var _this = this;
+
+  if (!paths.length) {
+    return this;
+  }
+
+  if (paths.length === 1) {
+    return paths[0];
+  }
+
+  var minDepth = Infinity;
+
+  var lastCommonIndex = void 0,
+      lastCommon = void 0;
+
+  var ancestries = paths.map(function (path) {
+    var ancestry = [];
+
+    do {
+      ancestry.unshift(path);
+    } while ((path = path.parentPath) && path !== _this);
+
+    if (ancestry.length < minDepth) {
+      minDepth = ancestry.length;
+    }
+
+    return ancestry;
+  });
+
+  var first = ancestries[0];
+
+  depthLoop: for (var i = 0; i < minDepth; i++) {
+    var shouldMatch = first[i];
+
+    for (var _iterator2 = ancestries, _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 ancestry = _ref2;
+
+      if (ancestry[i] !== shouldMatch) {
+        break depthLoop;
+      }
+    }
+
+    lastCommonIndex = i;
+    lastCommon = shouldMatch;
+  }
+
+  if (lastCommon) {
+    if (filter) {
+      return filter(lastCommon, lastCommonIndex, ancestries);
+    } else {
+      return lastCommon;
+    }
+  } else {
+    throw new Error("Couldn't find intersection");
+  }
+}
+
+function getAncestry() {
+  var path = this;
+  var paths = [];
+  do {
+    paths.push(path);
+  } while (path = path.parentPath);
+  return paths;
+}
+
+function isAncestor(maybeDescendant) {
+  return maybeDescendant.isDescendant(this);
+}
+
+function isDescendant(maybeAncestor) {
+  return !!this.findParent(function (parent) {
+    return parent === maybeAncestor;
+  });
+}
+
+function inType() {
+  var path = this;
+  while (path) {
+    for (var _iterator3 = arguments, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : (0, _getIterator3.default)(_iterator3);;) {
+      var _ref3;
+
+      if (_isArray3) {
+        if (_i3 >= _iterator3.length) break;
+        _ref3 = _iterator3[_i3++];
+      } else {
+        _i3 = _iterator3.next();
+        if (_i3.done) break;
+        _ref3 = _i3.value;
+      }
+
+      var type = _ref3;
+
+      if (path.node.type === type) return true;
+    }
+    path = path.parentPath;
+  }
+
+  return false;
+}
+
+function inShadow(key) {
+  var parentFn = this.isFunction() ? this : this.findParent(function (p) {
+    return p.isFunction();
+  });
+  if (!parentFn) return;
+
+  if (parentFn.isFunctionExpression() || parentFn.isFunctionDeclaration()) {
+    var shadow = parentFn.node.shadow;
+
+    if (shadow && (!key || shadow[key] !== false)) {
+      return parentFn;
+    }
+  } else if (parentFn.isArrowFunctionExpression()) {
+    return parentFn;
+  }
+
+  return null;
+}
\ No newline at end of file