“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); 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;

var t = _interopRequireWildcard(require(“@babel/types”));

var _index = _interopRequireDefault(require(“./index”));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _getRequireWildcardCache() { if (typeof WeakMap !== “function”) return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; if (obj != null) { var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj = obj; } } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

function findParent(callback) {

let path = this;

while (path = path.parentPath) {
  if (callback(path)) return path;
}

return null;

}

function find(callback) {

let path = this;

do {
  if (callback(path)) return path;
} while (path = path.parentPath);

return null;

}

function getFunctionParent() {

return this.findParent(p => p.isFunction());

}

function getStatementParent() {

let path = this;

do {
  if (!path.parentPath || Array.isArray(path.container) && path.isStatement()) {
    break;
  } else {
    path = path.parentPath;
  }
} while (path);

if (path && (path.isProgram() || path.isFile())) {
  throw new Error("File/Program node, we can't possibly find a statement parent to this");
}

return path;

}

function getEarliestCommonAncestorFrom(paths) {

return this.getDeepestCommonAncestorFrom(paths, function (deepest, i, ancestries) {
  let earliest;
  const keys = t.VISITOR_KEYS[deepest.type];

  for (const ancestry of ancestries) {
    const path = ancestry[i + 1];

    if (!earliest) {
      earliest = path;
      continue;
    }

    if (path.listKey && earliest.listKey === path.listKey) {
      if (path.key < earliest.key) {
        earliest = path;
        continue;
      }
    }

    const earliestKeyIndex = keys.indexOf(earliest.parentKey);
    const currentKeyIndex = keys.indexOf(path.parentKey);

    if (earliestKeyIndex > currentKeyIndex) {
      earliest = path;
    }
  }

  return earliest;
});

}

function getDeepestCommonAncestorFrom(paths, filter) {

if (!paths.length) {
  return this;
}

if (paths.length === 1) {
  return paths[0];
}

let minDepth = Infinity;
let lastCommonIndex, lastCommon;
const ancestries = paths.map(path => {
  const ancestry = [];

  do {
    ancestry.unshift(path);
  } while ((path = path.parentPath) && path !== this);

  if (ancestry.length < minDepth) {
    minDepth = ancestry.length;
  }

  return ancestry;
});
const first = ancestries[0];

depthLoop: for (let i = 0; i < minDepth; i++) {
  const shouldMatch = first[i];

  for (const ancestry of ancestries) {
    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() {

let path = this;
const paths = [];

do {
  paths.push(path);
} while (path = path.parentPath);

return paths;

}

function isAncestor(maybeDescendant) {

return maybeDescendant.isDescendant(this);

}

function isDescendant(maybeAncestor) {

return !!this.findParent(parent => parent === maybeAncestor);

}

function inType() {

let path = this;

while (path) {
  for (const type of arguments) {
    if (path.node.type === type) return true;
  }

  path = path.parentPath;
}

return false;

}