switch to vuepress

1 files changed, 244 insertions, 0 deletions

diff --git a/node_modules/@babel/traverse/lib/path/family.js b/node_modules/@babel/traverse/lib/path/family.js
new file mode 100644
index 00000000..2a193940
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/family.js
@@ -0,0 +1,244 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getOpposite = getOpposite;
+exports.getCompletionRecords = getCompletionRecords;
+exports.getSibling = getSibling;
+exports.getPrevSibling = getPrevSibling;
+exports.getNextSibling = getNextSibling;
+exports.getAllNextSiblings = getAllNextSiblings;
+exports.getAllPrevSiblings = getAllPrevSiblings;
+exports.get = get;
+exports._getKey = _getKey;
+exports._getPattern = _getPattern;
+exports.getBindingIdentifiers = getBindingIdentifiers;
+exports.getOuterBindingIdentifiers = getOuterBindingIdentifiers;
+exports.getBindingIdentifierPaths = getBindingIdentifierPaths;
+exports.getOuterBindingIdentifierPaths = getOuterBindingIdentifierPaths;
+
+var _index = _interopRequireDefault(require("./index"));
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+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)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function getOpposite() {
+  if (this.key === "left") {
+    return this.getSibling("right");
+  } else if (this.key === "right") {
+    return this.getSibling("left");
+  }
+}
+
+function addCompletionRecords(path, paths) {
+  if (path) return paths.concat(path.getCompletionRecords());
+  return paths;
+}
+
+function getCompletionRecords() {
+  let paths = [];
+
+  if (this.isIfStatement()) {
+    paths = addCompletionRecords(this.get("consequent"), paths);
+    paths = addCompletionRecords(this.get("alternate"), paths);
+  } else if (this.isDoExpression() || this.isFor() || this.isWhile()) {
+    paths = addCompletionRecords(this.get("body"), paths);
+  } else if (this.isProgram() || this.isBlockStatement()) {
+    paths = addCompletionRecords(this.get("body").pop(), paths);
+  } else if (this.isFunction()) {
+    return this.get("body").getCompletionRecords();
+  } else if (this.isTryStatement()) {
+    paths = addCompletionRecords(this.get("block"), paths);
+    paths = addCompletionRecords(this.get("handler"), paths);
+    paths = addCompletionRecords(this.get("finalizer"), paths);
+  } else if (this.isCatchClause()) {
+    paths = addCompletionRecords(this.get("body"), paths);
+  } else {
+    paths.push(this);
+  }
+
+  return paths;
+}
+
+function getSibling(key) {
+  return _index.default.get({
+    parentPath: this.parentPath,
+    parent: this.parent,
+    container: this.container,
+    listKey: this.listKey,
+    key: key
+  });
+}
+
+function getPrevSibling() {
+  return this.getSibling(this.key - 1);
+}
+
+function getNextSibling() {
+  return this.getSibling(this.key + 1);
+}
+
+function getAllNextSiblings() {
+  let _key = this.key;
+  let sibling = this.getSibling(++_key);
+  const siblings = [];
+
+  while (sibling.node) {
+    siblings.push(sibling);
+    sibling = this.getSibling(++_key);
+  }
+
+  return siblings;
+}
+
+function getAllPrevSiblings() {
+  let _key = this.key;
+  let sibling = this.getSibling(--_key);
+  const siblings = [];
+
+  while (sibling.node) {
+    siblings.push(sibling);
+    sibling = this.getSibling(--_key);
+  }
+
+  return siblings;
+}
+
+function get(key, context) {
+  if (context === true) context = this.context;
+  const parts = key.split(".");
+
+  if (parts.length === 1) {
+    return this._getKey(key, context);
+  } else {
+    return this._getPattern(parts, context);
+  }
+}
+
+function _getKey(key, context) {
+  const node = this.node;
+  const container = node[key];
+
+  if (Array.isArray(container)) {
+    return container.map((_, i) => {
+      return _index.default.get({
+        listKey: key,
+        parentPath: this,
+        parent: node,
+        container: container,
+        key: i
+      }).setContext(context);
+    });
+  } else {
+    return _index.default.get({
+      parentPath: this,
+      parent: node,
+      container: node,
+      key: key
+    }).setContext(context);
+  }
+}
+
+function _getPattern(parts, context) {
+  let path = this;
+  var _arr = parts;
+
+  for (var _i = 0; _i < _arr.length; _i++) {
+    const part = _arr[_i];
+
+    if (part === ".") {
+      path = path.parentPath;
+    } else {
+      if (Array.isArray(path)) {
+        path = path[part];
+      } else {
+        path = path.get(part, context);
+      }
+    }
+  }
+
+  return path;
+}
+
+function getBindingIdentifiers(duplicates) {
+  return t().getBindingIdentifiers(this.node, duplicates);
+}
+
+function getOuterBindingIdentifiers(duplicates) {
+  return t().getOuterBindingIdentifiers(this.node, duplicates);
+}
+
+function getBindingIdentifierPaths(duplicates = false, outerOnly = false) {
+  const path = this;
+  let search = [].concat(path);
+  const ids = Object.create(null);
+
+  while (search.length) {
+    const id = search.shift();
+    if (!id) continue;
+    if (!id.node) continue;
+    const keys = t().getBindingIdentifiers.keys[id.node.type];
+
+    if (id.isIdentifier()) {
+      if (duplicates) {
+        const _ids = ids[id.node.name] = ids[id.node.name] || [];
+
+        _ids.push(id);
+      } else {
+        ids[id.node.name] = id;
+      }
+
+      continue;
+    }
+
+    if (id.isExportDeclaration()) {
+      const declaration = id.get("declaration");
+
+      if (declaration.isDeclaration()) {
+        search.push(declaration);
+      }
+
+      continue;
+    }
+
+    if (outerOnly) {
+      if (id.isFunctionDeclaration()) {
+        search.push(id.get("id"));
+        continue;
+      }
+
+      if (id.isFunctionExpression()) {
+        continue;
+      }
+    }
+
+    if (keys) {
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const child = id.get(key);
+
+        if (Array.isArray(child) || child.node) {
+          search = search.concat(child);
+        }
+      }
+    }
+  }
+
+  return ids;
+}
+
+function getOuterBindingIdentifierPaths(duplicates) {
+  return this.getBindingIdentifierPaths(duplicates, true);
+}
\ No newline at end of file