text: 'use strict';
  
  function _jestSnapshot() {
    const data = require('jest-snapshot');
  
    _jestSnapshot = function _jestSnapshot() {
      return data;
    };
  
    return data;
  }
  
  function _defineProperty(obj, key, value) {
    if (key in obj) {
      Object.defineProperty(obj, key, {
        value: value,
        enumerable: true,
        configurable: true,
        writable: true
      });
    } else {
      obj[key] = value;
    }
    return obj;
  }
  
  /**
   * DependencyResolver is used to resolve the direct dependencies of a module or
   * to retrieve a list of all transitive inverse dependencies.
   */
  
  /* eslint-disable-next-line no-redeclare */
  class DependencyResolver {
    constructor(resolver, hasteFS, snapshotResolver) {
      _defineProperty(this, '_hasteFS', void 0);
  
      _defineProperty(this, '_resolver', void 0);
  
      _defineProperty(this, '_snapshotResolver', void 0);
  
      this._resolver = resolver;
      this._hasteFS = hasteFS;
      this._snapshotResolver = snapshotResolver;
    }
  
    resolve(file, options) {
      const dependencies = this._hasteFS.getDependencies(file);
  
      if (!dependencies) {
        return [];
      }
  
      return dependencies.reduce((acc, dependency) => {
        if (this._resolver.isCoreModule(dependency)) {
          return acc;
        }
  
        let resolvedDependency;
  
        try {
          resolvedDependency = this._resolver.resolveModule(
            file,
            dependency,
            options
          );
        } catch (e) {
          resolvedDependency = this._resolver.getMockModule(file, dependency);
        }
  
        if (resolvedDependency) {
          acc.push(resolvedDependency);
        }
  
        return acc;
      }, []);
    }
  
    resolveInverseModuleMap(paths, filter, options) {
      if (!paths.size) {
        return [];
      }
  
      const collectModules = (related, moduleMap, changed) => {
        const visitedModules = new Set();
        const result = [];
  
        while (changed.size) {
          changed = new Set(
            moduleMap.reduce((acc, module) => {
              if (
                visitedModules.has(module.file) ||
                !module.dependencies.some(dep => changed.has(dep))
              ) {
                return acc;
              }
  
              const file = module.file;
  
              if (filter(file)) {
                result.push(module);
                related.delete(file);
              }
  
              visitedModules.add(file);
              acc.push(file);
              return acc;
            }, [])
          );
        }
  
        return result.concat(
          Array.from(related).map(file => ({
            dependencies: [],
            file
          }))
        );
      };
  
      const relatedPaths = new Set();
      const changed = new Set();
      var _iteratorNormalCompletion = true;
      var _didIteratorError = false;
      var _iteratorError = undefined;
  
      try {
        for (
          var _iterator = paths[Symbol.iterator](), _step;
          !(_iteratorNormalCompletion = (_step = _iterator.next()).done);
          _iteratorNormalCompletion = true
        ) {
          const path = _step.value;
  
          if (this._hasteFS.exists(path)) {
            const modulePath = (0, _jestSnapshot().isSnapshotPath)(path)
              ? this._snapshotResolver.resolveTestPath(path)
              : path;
            changed.add(modulePath);
  
            if (filter(modulePath)) {
              relatedPaths.add(modulePath);
            }
          }
        }
      } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion && _iterator.return != null) {
            _iterator.return();
          }
        } finally {
          if (_didIteratorError) {
            throw _iteratorError;
          }
        }
      }
  
      const modules = [];
      var _iteratorNormalCompletion2 = true;
      var _didIteratorError2 = false;
      var _iteratorError2 = undefined;
  
      try {
        for (
          var _iterator2 = this._hasteFS
              .getAbsoluteFileIterator()
              [Symbol.iterator](),
            _step2;
          !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done);
          _iteratorNormalCompletion2 = true
        ) {
          const file = _step2.value;
          modules.push({
            dependencies: this.resolve(file, options),
            file
          });
        }
      } catch (err) {
        _didIteratorError2 = true;
        _iteratorError2 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
            _iterator2.return();
          }
        } finally {
          if (_didIteratorError2) {
            throw _iteratorError2;
          }
        }
      }
  
      return collectModules(relatedPaths, modules, changed);
    }
  
    resolveInverse(paths, filter, options) {
      return this.resolveInverseModuleMap(paths, filter, options).map(
        module => module.file
      );
    }
  }
  
  module.exports = DependencyResolver;
  