claude-autopm 3.1.2 → 3.2.1

package/packages/plugin-devops/node_modules/jest-haste-map/build/index.js

@@ -1,1107 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-});
-exports.default = exports.ModuleMap = exports.DuplicateError = void 0;
-function _crypto() {
-  const data = require('crypto');
-  _crypto = function () {
-    return data;
-  };
-  return data;
-}
-function _events() {
-  const data = require('events');
-  _events = function () {
-    return data;
-  };
-  return data;
-}
-function _os() {
-  const data = require('os');
-  _os = function () {
-    return data;
-  };
-  return data;
-}
-function path() {
-  const data = _interopRequireWildcard(require('path'));
-  path = function () {
-    return data;
-  };
-  return data;
-}
-function _v() {
-  const data = require('v8');
-  _v = function () {
-    return data;
-  };
-  return data;
-}
-function _gracefulFs() {
-  const data = require('graceful-fs');
-  _gracefulFs = function () {
-    return data;
-  };
-  return data;
-}
-function _jestRegexUtil() {
-  const data = require('jest-regex-util');
-  _jestRegexUtil = function () {
-    return data;
-  };
-  return data;
-}
-function _jestUtil() {
-  const data = require('jest-util');
-  _jestUtil = function () {
-    return data;
-  };
-  return data;
-}
-function _jestWorker() {
-  const data = require('jest-worker');
-  _jestWorker = function () {
-    return data;
-  };
-  return data;
-}
-var _HasteFS = _interopRequireDefault(require('./HasteFS'));
-var _ModuleMap = _interopRequireDefault(require('./ModuleMap'));
-var _constants = _interopRequireDefault(require('./constants'));
-var _node = require('./crawlers/node');
-var _watchman = require('./crawlers/watchman');
-var _getMockName = _interopRequireDefault(require('./getMockName'));
-var fastPath = _interopRequireWildcard(require('./lib/fast_path'));
-var _getPlatformExtension = _interopRequireDefault(
-  require('./lib/getPlatformExtension')
-);
-var _isWatchmanInstalled = _interopRequireDefault(
-  require('./lib/isWatchmanInstalled')
-);
-var _normalizePathSep = _interopRequireDefault(
-  require('./lib/normalizePathSep')
-);
-var _FSEventsWatcher = require('./watchers/FSEventsWatcher');
-var _NodeWatcher = _interopRequireDefault(require('./watchers/NodeWatcher'));
-var _WatchmanWatcher = _interopRequireDefault(
-  require('./watchers/WatchmanWatcher')
-);
-var _worker = require('./worker');
-function _interopRequireDefault(obj) {
-  return obj && obj.__esModule ? obj : {default: obj};
-}
-function _getRequireWildcardCache(nodeInterop) {
-  if (typeof WeakMap !== 'function') return null;
-  var cacheBabelInterop = new WeakMap();
-  var cacheNodeInterop = new WeakMap();
-  return (_getRequireWildcardCache = function (nodeInterop) {
-    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
-  })(nodeInterop);
-}
-function _interopRequireWildcard(obj, nodeInterop) {
-  if (!nodeInterop && obj && obj.__esModule) {
-    return obj;
-  }
-  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
-    return {default: obj};
-  }
-  var cache = _getRequireWildcardCache(nodeInterop);
-  if (cache && cache.has(obj)) {
-    return cache.get(obj);
-  }
-  var newObj = {};
-  var hasPropertyDescriptor =
-    Object.defineProperty && Object.getOwnPropertyDescriptor;
-  for (var key in obj) {
-    if (key !== 'default' && 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[key] = obj[key];
-      }
-    }
-  }
-  newObj.default = obj;
-  if (cache) {
-    cache.set(obj, newObj);
-  }
-  return newObj;
-}
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-// @ts-expect-error: not converted to TypeScript - it's a fork: https://github.com/jestjs/jest/pull/10919
-
-// @ts-expect-error: not converted to TypeScript - it's a fork: https://github.com/jestjs/jest/pull/5387
-
-// TypeScript doesn't like us importing from outside `rootDir`, but it doesn't
-// understand `require`.
-const {version: VERSION} = require('../package.json');
-const ModuleMap = _ModuleMap.default;
-exports.ModuleMap = ModuleMap;
-const CHANGE_INTERVAL = 30;
-const MAX_WAIT_TIME = 240000;
-const NODE_MODULES = `${path().sep}node_modules${path().sep}`;
-const PACKAGE_JSON = `${path().sep}package.json`;
-const VCS_DIRECTORIES = ['.git', '.hg', '.sl']
-  .map(vcs =>
-    (0, _jestRegexUtil().escapePathForRegex)(path().sep + vcs + path().sep)
-  )
-  .join('|');
-
-/**
- * HasteMap is a JavaScript implementation of Facebook's haste module system.
- *
- * This implementation is inspired by https://github.com/facebook/node-haste
- * and was built with for high-performance in large code repositories with
- * hundreds of thousands of files. This implementation is scalable and provides
- * predictable performance.
- *
- * Because the haste map creation and synchronization is critical to startup
- * performance and most tasks are blocked by I/O this class makes heavy use of
- * synchronous operations. It uses worker processes for parallelizing file
- * access and metadata extraction.
- *
- * The data structures created by `jest-haste-map` can be used directly from the
- * cache without further processing. The metadata objects in the `files` and
- * `map` objects contain cross-references: a metadata object from one can look
- * up the corresponding metadata object in the other map. Note that in most
- * projects, the number of files will be greater than the number of haste
- * modules one module can refer to many files based on platform extensions.
- *
- * type HasteMap = {
- *   clocks: WatchmanClocks,
- *   files: {[filepath: string]: FileMetaData},
- *   map: {[id: string]: ModuleMapItem},
- *   mocks: {[id: string]: string},
- * }
- *
- * // Watchman clocks are used for query synchronization and file system deltas.
- * type WatchmanClocks = {[filepath: string]: string};
- *
- * type FileMetaData = {
- *   id: ?string, // used to look up module metadata objects in `map`.
- *   mtime: number, // check for outdated files.
- *   size: number, // size of the file in bytes.
- *   visited: boolean, // whether the file has been parsed or not.
- *   dependencies: Array<string>, // all relative dependencies of this file.
- *   sha1: ?string, // SHA-1 of the file, if requested via options.
- * };
- *
- * // Modules can be targeted to a specific platform based on the file name.
- * // Example: platform.ios.js and Platform.android.js will both map to the same
- * // `Platform` module. The platform should be specified during resolution.
- * type ModuleMapItem = {[platform: string]: ModuleMetaData};
- *
- * //
- * type ModuleMetaData = {
- *   path: string, // the path to look up the file object in `files`.
- *   type: string, // the module type (either `package` or `module`).
- * };
- *
- * Note that the data structures described above are conceptual only. The actual
- * implementation uses arrays and constant keys for metadata storage. Instead of
- * `{id: 'flatMap', mtime: 3421, size: 42, visited: true, dependencies: []}` the real
- * representation is similar to `['flatMap', 3421, 42, 1, []]` to save storage space
- * and reduce parse and write time of a big JSON blob.
- *
- * The HasteMap is created as follows:
- *  1. read data from the cache or create an empty structure.
- *
- *  2. crawl the file system.
- *     * empty cache: crawl the entire file system.
- *     * cache available:
- *       * if watchman is available: get file system delta changes.
- *       * if watchman is unavailable: crawl the entire file system.
- *     * build metadata objects for every file. This builds the `files` part of
- *       the `HasteMap`.
- *
- *  3. parse and extract metadata from changed files.
- *     * this is done in parallel over worker processes to improve performance.
- *     * the worst case is to parse all files.
- *     * the best case is no file system access and retrieving all data from
- *       the cache.
- *     * the average case is a small number of changed files.
- *
- *  4. serialize the new `HasteMap` in a cache file.
- *     Worker processes can directly access the cache through `HasteMap.read()`.
- *
- */
-class HasteMap extends _events().EventEmitter {
-  _buildPromise = null;
-  _cachePath = '';
-  _changeInterval;
-  _console;
-  _isWatchmanInstalledPromise = null;
-  _options;
-  _watchers = [];
-  _worker = null;
-  static getStatic(config) {
-    if (config.haste.hasteMapModulePath) {
-      return require(config.haste.hasteMapModulePath);
-    }
-    return HasteMap;
-  }
-  static async create(options) {
-    if (options.hasteMapModulePath) {
-      const CustomHasteMap = require(options.hasteMapModulePath);
-      return new CustomHasteMap(options);
-    }
-    const hasteMap = new HasteMap(options);
-    await hasteMap.setupCachePath(options);
-    return hasteMap;
-  }
-  constructor(options) {
-    super();
-    this._options = {
-      cacheDirectory: options.cacheDirectory || (0, _os().tmpdir)(),
-      computeDependencies: options.computeDependencies ?? true,
-      computeSha1: options.computeSha1 || false,
-      dependencyExtractor: options.dependencyExtractor || null,
-      enableSymlinks: options.enableSymlinks || false,
-      extensions: options.extensions,
-      forceNodeFilesystemAPI: !!options.forceNodeFilesystemAPI,
-      hasteImplModulePath: options.hasteImplModulePath,
-      id: options.id,
-      maxWorkers: options.maxWorkers,
-      mocksPattern: options.mocksPattern
-        ? new RegExp(options.mocksPattern)
-        : null,
-      platforms: options.platforms,
-      resetCache: options.resetCache,
-      retainAllFiles: options.retainAllFiles,
-      rootDir: options.rootDir,
-      roots: Array.from(new Set(options.roots)),
-      skipPackageJson: !!options.skipPackageJson,
-      throwOnModuleCollision: !!options.throwOnModuleCollision,
-      useWatchman: options.useWatchman ?? true,
-      watch: !!options.watch,
-      workerThreads: options.workerThreads
-    };
-    this._console = options.console || globalThis.console;
-    if (options.ignorePattern) {
-      if (options.ignorePattern instanceof RegExp) {
-        this._options.ignorePattern = new RegExp(
-          options.ignorePattern.source.concat(`|${VCS_DIRECTORIES}`),
-          options.ignorePattern.flags
-        );
-      } else {
-        throw new Error(
-          'jest-haste-map: the `ignorePattern` option must be a RegExp'
-        );
-      }
-    } else {
-      this._options.ignorePattern = new RegExp(VCS_DIRECTORIES);
-    }
-    if (this._options.enableSymlinks && this._options.useWatchman) {
-      throw new Error(
-        'jest-haste-map: enableSymlinks config option was set, but ' +
-          'is incompatible with watchman.\n' +
-          'Set either `enableSymlinks` to false or `useWatchman` to false.'
-      );
-    }
-  }
-  async setupCachePath(options) {
-    const rootDirHash = (0, _crypto().createHash)('sha1')
-      .update(options.rootDir)
-      .digest('hex')
-      .substring(0, 32);
-    let hasteImplHash = '';
-    let dependencyExtractorHash = '';
-    if (options.hasteImplModulePath) {
-      const hasteImpl = require(options.hasteImplModulePath);
-      if (hasteImpl.getCacheKey) {
-        hasteImplHash = String(hasteImpl.getCacheKey());
-      }
-    }
-    if (options.dependencyExtractor) {
-      const dependencyExtractor = await (0, _jestUtil().requireOrImportModule)(
-        options.dependencyExtractor,
-        false
-      );
-      if (dependencyExtractor.getCacheKey) {
-        dependencyExtractorHash = String(dependencyExtractor.getCacheKey());
-      }
-    }
-    this._cachePath = HasteMap.getCacheFilePath(
-      this._options.cacheDirectory,
-      `haste-map-${this._options.id}-${rootDirHash}`,
-      VERSION,
-      this._options.id,
-      this._options.roots
-        .map(root => fastPath.relative(options.rootDir, root))
-        .join(':'),
-      this._options.extensions.join(':'),
-      this._options.platforms.join(':'),
-      this._options.computeSha1.toString(),
-      options.mocksPattern || '',
-      (options.ignorePattern || '').toString(),
-      hasteImplHash,
-      dependencyExtractorHash,
-      this._options.computeDependencies.toString()
-    );
-  }
-  static getCacheFilePath(tmpdir, id, ...extra) {
-    const hash = (0, _crypto().createHash)('sha1').update(extra.join(''));
-    return path().join(
-      tmpdir,
-      `${id.replace(/\W/g, '-')}-${hash.digest('hex').substring(0, 32)}`
-    );
-  }
-  static getModuleMapFromJSON(json) {
-    return _ModuleMap.default.fromJSON(json);
-  }
-  getCacheFilePath() {
-    return this._cachePath;
-  }
-  build() {
-    if (!this._buildPromise) {
-      this._buildPromise = (async () => {
-        const data = await this._buildFileMap();
-
-        // Persist when we don't know if files changed (changedFiles undefined)
-        // or when we know a file was changed or deleted.
-        let hasteMap;
-        if (
-          data.changedFiles === undefined ||
-          data.changedFiles.size > 0 ||
-          data.removedFiles.size > 0
-        ) {
-          hasteMap = await this._buildHasteMap(data);
-          this._persist(hasteMap);
-        } else {
-          hasteMap = data.hasteMap;
-        }
-        const rootDir = this._options.rootDir;
-        const hasteFS = new _HasteFS.default({
-          files: hasteMap.files,
-          rootDir
-        });
-        const moduleMap = new _ModuleMap.default({
-          duplicates: hasteMap.duplicates,
-          map: hasteMap.map,
-          mocks: hasteMap.mocks,
-          rootDir
-        });
-        const __hasteMapForTest =
-          (process.env.NODE_ENV === 'test' && hasteMap) || null;
-        await this._watch(hasteMap);
-        return {
-          __hasteMapForTest,
-          hasteFS,
-          moduleMap
-        };
-      })();
-    }
-    return this._buildPromise;
-  }
-
-  /**
-   * 1. read data from the cache or create an empty structure.
-   */
-  read() {
-    let hasteMap;
-    try {
-      hasteMap = (0, _v().deserialize)(
-        (0, _gracefulFs().readFileSync)(this._cachePath)
-      );
-    } catch {
-      hasteMap = this._createEmptyMap();
-    }
-    return hasteMap;
-  }
-  readModuleMap() {
-    const data = this.read();
-    return new _ModuleMap.default({
-      duplicates: data.duplicates,
-      map: data.map,
-      mocks: data.mocks,
-      rootDir: this._options.rootDir
-    });
-  }
-
-  /**
-   * 2. crawl the file system.
-   */
-  async _buildFileMap() {
-    let hasteMap;
-    try {
-      const read = this._options.resetCache ? this._createEmptyMap : this.read;
-      hasteMap = read.call(this);
-    } catch {
-      hasteMap = this._createEmptyMap();
-    }
-    return this._crawl(hasteMap);
-  }
-
-  /**
-   * 3. parse and extract metadata from changed files.
-   */
-  _processFile(hasteMap, map, mocks, filePath, workerOptions) {
-    const rootDir = this._options.rootDir;
-    const setModule = (id, module) => {
-      let moduleMap = map.get(id);
-      if (!moduleMap) {
-        moduleMap = Object.create(null);
-        map.set(id, moduleMap);
-      }
-      const platform =
-        (0, _getPlatformExtension.default)(
-          module[_constants.default.PATH],
-          this._options.platforms
-        ) || _constants.default.GENERIC_PLATFORM;
-      const existingModule = moduleMap[platform];
-      if (
-        existingModule &&
-        existingModule[_constants.default.PATH] !==
-          module[_constants.default.PATH]
-      ) {
-        const method = this._options.throwOnModuleCollision ? 'error' : 'warn';
-        this._console[method](
-          [
-            `jest-haste-map: Haste module naming collision: ${id}`,
-            '  The following files share their name; please adjust your hasteImpl:',
-            `    * <rootDir>${path().sep}${
-              existingModule[_constants.default.PATH]
-            }`,
-            `    * <rootDir>${path().sep}${module[_constants.default.PATH]}`,
-            ''
-          ].join('\n')
-        );
-        if (this._options.throwOnModuleCollision) {
-          throw new DuplicateError(
-            existingModule[_constants.default.PATH],
-            module[_constants.default.PATH]
-          );
-        }
-
-        // We do NOT want consumers to use a module that is ambiguous.
-        delete moduleMap[platform];
-        if (Object.keys(moduleMap).length === 1) {
-          map.delete(id);
-        }
-        let dupsByPlatform = hasteMap.duplicates.get(id);
-        if (dupsByPlatform == null) {
-          dupsByPlatform = new Map();
-          hasteMap.duplicates.set(id, dupsByPlatform);
-        }
-        const dups = new Map([
-          [module[_constants.default.PATH], module[_constants.default.TYPE]],
-          [
-            existingModule[_constants.default.PATH],
-            existingModule[_constants.default.TYPE]
-          ]
-        ]);
-        dupsByPlatform.set(platform, dups);
-        return;
-      }
-      const dupsByPlatform = hasteMap.duplicates.get(id);
-      if (dupsByPlatform != null) {
-        const dups = dupsByPlatform.get(platform);
-        if (dups != null) {
-          dups.set(
-            module[_constants.default.PATH],
-            module[_constants.default.TYPE]
-          );
-        }
-        return;
-      }
-      moduleMap[platform] = module;
-    };
-    const relativeFilePath = fastPath.relative(rootDir, filePath);
-    const fileMetadata = hasteMap.files.get(relativeFilePath);
-    if (!fileMetadata) {
-      throw new Error(
-        'jest-haste-map: File to process was not found in the haste map.'
-      );
-    }
-    const moduleMetadata = hasteMap.map.get(
-      fileMetadata[_constants.default.ID]
-    );
-    const computeSha1 =
-      this._options.computeSha1 && !fileMetadata[_constants.default.SHA1];
-
-    // Callback called when the response from the worker is successful.
-    const workerReply = metadata => {
-      // `1` for truthy values instead of `true` to save cache space.
-      fileMetadata[_constants.default.VISITED] = 1;
-      const metadataId = metadata.id;
-      const metadataModule = metadata.module;
-      if (metadataId && metadataModule) {
-        fileMetadata[_constants.default.ID] = metadataId;
-        setModule(metadataId, metadataModule);
-      }
-      fileMetadata[_constants.default.DEPENDENCIES] = metadata.dependencies
-        ? metadata.dependencies.join(_constants.default.DEPENDENCY_DELIM)
-        : '';
-      if (computeSha1) {
-        fileMetadata[_constants.default.SHA1] = metadata.sha1;
-      }
-    };
-
-    // Callback called when the response from the worker is an error.
-    const workerError = error => {
-      if (typeof error !== 'object' || !error.message || !error.stack) {
-        error = new Error(error);
-        error.stack = ''; // Remove stack for stack-less errors.
-      }
-
-      if (!['ENOENT', 'EACCES'].includes(error.code)) {
-        throw error;
-      }
-
-      // If a file cannot be read we remove it from the file list and
-      // ignore the failure silently.
-      hasteMap.files.delete(relativeFilePath);
-    };
-
-    // If we retain all files in the virtual HasteFS representation, we avoid
-    // reading them if they aren't important (node_modules).
-    if (this._options.retainAllFiles && filePath.includes(NODE_MODULES)) {
-      if (computeSha1) {
-        return this._getWorker(workerOptions)
-          .getSha1({
-            computeDependencies: this._options.computeDependencies,
-            computeSha1,
-            dependencyExtractor: this._options.dependencyExtractor,
-            filePath,
-            hasteImplModulePath: this._options.hasteImplModulePath,
-            rootDir
-          })
-          .then(workerReply, workerError);
-      }
-      return null;
-    }
-    if (
-      this._options.mocksPattern &&
-      this._options.mocksPattern.test(filePath)
-    ) {
-      const mockPath = (0, _getMockName.default)(filePath);
-      const existingMockPath = mocks.get(mockPath);
-      if (existingMockPath) {
-        const secondMockPath = fastPath.relative(rootDir, filePath);
-        if (existingMockPath !== secondMockPath) {
-          const method = this._options.throwOnModuleCollision
-            ? 'error'
-            : 'warn';
-          this._console[method](
-            [
-              `jest-haste-map: duplicate manual mock found: ${mockPath}`,
-              '  The following files share their name; please delete one of them:',
-              `    * <rootDir>${path().sep}${existingMockPath}`,
-              `    * <rootDir>${path().sep}${secondMockPath}`,
-              ''
-            ].join('\n')
-          );
-          if (this._options.throwOnModuleCollision) {
-            throw new DuplicateError(existingMockPath, secondMockPath);
-          }
-        }
-      }
-      mocks.set(mockPath, relativeFilePath);
-    }
-    if (fileMetadata[_constants.default.VISITED]) {
-      if (!fileMetadata[_constants.default.ID]) {
-        return null;
-      }
-      if (moduleMetadata != null) {
-        const platform =
-          (0, _getPlatformExtension.default)(
-            filePath,
-            this._options.platforms
-          ) || _constants.default.GENERIC_PLATFORM;
-        const module = moduleMetadata[platform];
-        if (module == null) {
-          return null;
-        }
-        const moduleId = fileMetadata[_constants.default.ID];
-        let modulesByPlatform = map.get(moduleId);
-        if (!modulesByPlatform) {
-          modulesByPlatform = Object.create(null);
-          map.set(moduleId, modulesByPlatform);
-        }
-        modulesByPlatform[platform] = module;
-        return null;
-      }
-    }
-    return this._getWorker(workerOptions)
-      .worker({
-        computeDependencies: this._options.computeDependencies,
-        computeSha1,
-        dependencyExtractor: this._options.dependencyExtractor,
-        filePath,
-        hasteImplModulePath: this._options.hasteImplModulePath,
-        rootDir
-      })
-      .then(workerReply, workerError);
-  }
-  _buildHasteMap(data) {
-    const {removedFiles, changedFiles, hasteMap} = data;
-
-    // If any files were removed or we did not track what files changed, process
-    // every file looking for changes. Otherwise, process only changed files.
-    let map;
-    let mocks;
-    let filesToProcess;
-    if (changedFiles === undefined || removedFiles.size) {
-      map = new Map();
-      mocks = new Map();
-      filesToProcess = hasteMap.files;
-    } else {
-      map = hasteMap.map;
-      mocks = hasteMap.mocks;
-      filesToProcess = changedFiles;
-    }
-    for (const [relativeFilePath, fileMetadata] of removedFiles) {
-      this._recoverDuplicates(
-        hasteMap,
-        relativeFilePath,
-        fileMetadata[_constants.default.ID]
-      );
-    }
-    const promises = [];
-    for (const relativeFilePath of filesToProcess.keys()) {
-      if (
-        this._options.skipPackageJson &&
-        relativeFilePath.endsWith(PACKAGE_JSON)
-      ) {
-        continue;
-      }
-      // SHA-1, if requested, should already be present thanks to the crawler.
-      const filePath = fastPath.resolve(
-        this._options.rootDir,
-        relativeFilePath
-      );
-      const promise = this._processFile(hasteMap, map, mocks, filePath);
-      if (promise) {
-        promises.push(promise);
-      }
-    }
-    return Promise.all(promises).then(
-      () => {
-        this._cleanup();
-        hasteMap.map = map;
-        hasteMap.mocks = mocks;
-        return hasteMap;
-      },
-      error => {
-        this._cleanup();
-        throw error;
-      }
-    );
-  }
-  _cleanup() {
-    const worker = this._worker;
-    if (worker && 'end' in worker) {
-      worker.end();
-    }
-    this._worker = null;
-  }
-
-  /**
-   * 4. serialize the new `HasteMap` in a cache file.
-   */
-  _persist(hasteMap) {
-    (0, _gracefulFs().writeFileSync)(
-      this._cachePath,
-      (0, _v().serialize)(hasteMap)
-    );
-  }
-
-  /**
-   * Creates workers or parses files and extracts metadata in-process.
-   */
-  _getWorker(
-    options = {
-      forceInBand: false
-    }
-  ) {
-    if (!this._worker) {
-      if (options.forceInBand || this._options.maxWorkers <= 1) {
-        this._worker = {
-          getSha1: _worker.getSha1,
-          worker: _worker.worker
-        };
-      } else {
-        this._worker = new (_jestWorker().Worker)(require.resolve('./worker'), {
-          enableWorkerThreads: this._options.workerThreads,
-          exposedMethods: ['getSha1', 'worker'],
-          forkOptions: {
-            serialization: 'json'
-          },
-          maxRetries: 3,
-          numWorkers: this._options.maxWorkers
-        });
-      }
-    }
-    return this._worker;
-  }
-  async _crawl(hasteMap) {
-    const options = this._options;
-    const ignore = this._ignore.bind(this);
-    const crawl = (await this._shouldUseWatchman())
-      ? _watchman.watchmanCrawl
-      : _node.nodeCrawl;
-    const crawlerOptions = {
-      computeSha1: options.computeSha1,
-      data: hasteMap,
-      enableSymlinks: options.enableSymlinks,
-      extensions: options.extensions,
-      forceNodeFilesystemAPI: options.forceNodeFilesystemAPI,
-      ignore,
-      rootDir: options.rootDir,
-      roots: options.roots
-    };
-    const retry = error => {
-      if (crawl === _watchman.watchmanCrawl) {
-        this._console.warn(
-          'jest-haste-map: Watchman crawl failed. Retrying once with node ' +
-            'crawler.\n' +
-            "  Usually this happens when watchman isn't running. Create an " +
-            "empty `.watchmanconfig` file in your project's root folder or " +
-            'initialize a git or hg repository in your project.\n' +
-            `  ${error}`
-        );
-        return (0, _node.nodeCrawl)(crawlerOptions).catch(e => {
-          throw new Error(
-            'Crawler retry failed:\n' +
-              `  Original error: ${error.message}\n` +
-              `  Retry error: ${e.message}\n`
-          );
-        });
-      }
-      throw error;
-    };
-    try {
-      return await crawl(crawlerOptions);
-    } catch (error) {
-      return retry(error);
-    }
-  }
-
-  /**
-   * Watch mode
-   */
-  async _watch(hasteMap) {
-    if (!this._options.watch) {
-      return Promise.resolve();
-    }
-
-    // In watch mode, we'll only warn about module collisions and we'll retain
-    // all files, even changes to node_modules.
-    this._options.throwOnModuleCollision = false;
-    this._options.retainAllFiles = true;
-
-    // WatchmanWatcher > FSEventsWatcher > sane.NodeWatcher
-    const Watcher = (await this._shouldUseWatchman())
-      ? _WatchmanWatcher.default
-      : _FSEventsWatcher.FSEventsWatcher.isSupported()
-      ? _FSEventsWatcher.FSEventsWatcher
-      : _NodeWatcher.default;
-    const extensions = this._options.extensions;
-    const ignorePattern = this._options.ignorePattern;
-    const rootDir = this._options.rootDir;
-    let changeQueue = Promise.resolve();
-    let eventsQueue = [];
-    // We only need to copy the entire haste map once on every "frame".
-    let mustCopy = true;
-    const createWatcher = root => {
-      const watcher = new Watcher(root, {
-        dot: true,
-        glob: extensions.map(extension => `**/*.${extension}`),
-        ignored: ignorePattern
-      });
-      return new Promise((resolve, reject) => {
-        const rejectTimeout = setTimeout(
-          () => reject(new Error('Failed to start watch mode.')),
-          MAX_WAIT_TIME
-        );
-        watcher.once('ready', () => {
-          clearTimeout(rejectTimeout);
-          watcher.on('all', onChange);
-          resolve(watcher);
-        });
-      });
-    };
-    const emitChange = () => {
-      if (eventsQueue.length) {
-        mustCopy = true;
-        const changeEvent = {
-          eventsQueue,
-          hasteFS: new _HasteFS.default({
-            files: hasteMap.files,
-            rootDir
-          }),
-          moduleMap: new _ModuleMap.default({
-            duplicates: hasteMap.duplicates,
-            map: hasteMap.map,
-            mocks: hasteMap.mocks,
-            rootDir
-          })
-        };
-        this.emit('change', changeEvent);
-        eventsQueue = [];
-      }
-    };
-    const onChange = (type, filePath, root, stat) => {
-      filePath = path().join(root, (0, _normalizePathSep.default)(filePath));
-      if (
-        (stat && stat.isDirectory()) ||
-        this._ignore(filePath) ||
-        !extensions.some(extension => filePath.endsWith(extension))
-      ) {
-        return;
-      }
-      const relativeFilePath = fastPath.relative(rootDir, filePath);
-      const fileMetadata = hasteMap.files.get(relativeFilePath);
-
-      // The file has been accessed, not modified
-      if (
-        type === 'change' &&
-        fileMetadata &&
-        stat &&
-        fileMetadata[_constants.default.MTIME] === stat.mtime.getTime()
-      ) {
-        return;
-      }
-      changeQueue = changeQueue
-        .then(() => {
-          // If we get duplicate events for the same file, ignore them.
-          if (
-            eventsQueue.find(
-              event =>
-                event.type === type &&
-                event.filePath === filePath &&
-                ((!event.stat && !stat) ||
-                  (!!event.stat &&
-                    !!stat &&
-                    event.stat.mtime.getTime() === stat.mtime.getTime()))
-            )
-          ) {
-            return null;
-          }
-          if (mustCopy) {
-            mustCopy = false;
-            hasteMap = {
-              clocks: new Map(hasteMap.clocks),
-              duplicates: new Map(hasteMap.duplicates),
-              files: new Map(hasteMap.files),
-              map: new Map(hasteMap.map),
-              mocks: new Map(hasteMap.mocks)
-            };
-          }
-          const add = () => {
-            eventsQueue.push({
-              filePath,
-              stat,
-              type
-            });
-            return null;
-          };
-          const fileMetadata = hasteMap.files.get(relativeFilePath);
-
-          // If it's not an addition, delete the file and all its metadata
-          if (fileMetadata != null) {
-            const moduleName = fileMetadata[_constants.default.ID];
-            const platform =
-              (0, _getPlatformExtension.default)(
-                filePath,
-                this._options.platforms
-              ) || _constants.default.GENERIC_PLATFORM;
-            hasteMap.files.delete(relativeFilePath);
-            let moduleMap = hasteMap.map.get(moduleName);
-            if (moduleMap != null) {
-              // We are forced to copy the object because jest-haste-map exposes
-              // the map as an immutable entity.
-              moduleMap = copy(moduleMap);
-              delete moduleMap[platform];
-              if (Object.keys(moduleMap).length === 0) {
-                hasteMap.map.delete(moduleName);
-              } else {
-                hasteMap.map.set(moduleName, moduleMap);
-              }
-            }
-            if (
-              this._options.mocksPattern &&
-              this._options.mocksPattern.test(filePath)
-            ) {
-              const mockName = (0, _getMockName.default)(filePath);
-              hasteMap.mocks.delete(mockName);
-            }
-            this._recoverDuplicates(hasteMap, relativeFilePath, moduleName);
-          }
-
-          // If the file was added or changed,
-          // parse it and update the haste map.
-          if (type === 'add' || type === 'change') {
-            (0, _jestUtil().invariant)(
-              stat,
-              'since the file exists or changed, it should have stats'
-            );
-            const fileMetadata = [
-              '',
-              stat.mtime.getTime(),
-              stat.size,
-              0,
-              '',
-              null
-            ];
-            hasteMap.files.set(relativeFilePath, fileMetadata);
-            const promise = this._processFile(
-              hasteMap,
-              hasteMap.map,
-              hasteMap.mocks,
-              filePath,
-              {
-                forceInBand: true
-              }
-            );
-            // Cleanup
-            this._cleanup();
-            if (promise) {
-              return promise.then(add);
-            } else {
-              // If a file in node_modules has changed,
-              // emit an event regardless.
-              add();
-            }
-          } else {
-            add();
-          }
-          return null;
-        })
-        .catch(error => {
-          this._console.error(
-            `jest-haste-map: watch error:\n  ${error.stack}\n`
-          );
-        });
-    };
-    this._changeInterval = setInterval(emitChange, CHANGE_INTERVAL);
-    return Promise.all(this._options.roots.map(createWatcher)).then(
-      watchers => {
-        this._watchers = watchers;
-      }
-    );
-  }
-
-  /**
-   * This function should be called when the file under `filePath` is removed
-   * or changed. When that happens, we want to figure out if that file was
-   * part of a group of files that had the same ID. If it was, we want to
-   * remove it from the group. Furthermore, if there is only one file
-   * remaining in the group, then we want to restore that single file as the
-   * correct resolution for its ID, and cleanup the duplicates index.
-   */
-  _recoverDuplicates(hasteMap, relativeFilePath, moduleName) {
-    let dupsByPlatform = hasteMap.duplicates.get(moduleName);
-    if (dupsByPlatform == null) {
-      return;
-    }
-    const platform =
-      (0, _getPlatformExtension.default)(
-        relativeFilePath,
-        this._options.platforms
-      ) || _constants.default.GENERIC_PLATFORM;
-    let dups = dupsByPlatform.get(platform);
-    if (dups == null) {
-      return;
-    }
-    dupsByPlatform = copyMap(dupsByPlatform);
-    hasteMap.duplicates.set(moduleName, dupsByPlatform);
-    dups = copyMap(dups);
-    dupsByPlatform.set(platform, dups);
-    dups.delete(relativeFilePath);
-    if (dups.size !== 1) {
-      return;
-    }
-    const uniqueModule = dups.entries().next().value;
-    if (!uniqueModule) {
-      return;
-    }
-    let dedupMap = hasteMap.map.get(moduleName);
-    if (!dedupMap) {
-      dedupMap = Object.create(null);
-      hasteMap.map.set(moduleName, dedupMap);
-    }
-    dedupMap[platform] = uniqueModule;
-    dupsByPlatform.delete(platform);
-    if (dupsByPlatform.size === 0) {
-      hasteMap.duplicates.delete(moduleName);
-    }
-  }
-  async end() {
-    if (this._changeInterval) {
-      clearInterval(this._changeInterval);
-    }
-    if (!this._watchers.length) {
-      return;
-    }
-    await Promise.all(this._watchers.map(watcher => watcher.close()));
-    this._watchers = [];
-  }
-
-  /**
-   * Helpers
-   */
-  _ignore(filePath) {
-    const ignorePattern = this._options.ignorePattern;
-    const ignoreMatched =
-      ignorePattern instanceof RegExp
-        ? ignorePattern.test(filePath)
-        : ignorePattern && ignorePattern(filePath);
-    return (
-      ignoreMatched ||
-      (!this._options.retainAllFiles && filePath.includes(NODE_MODULES))
-    );
-  }
-  async _shouldUseWatchman() {
-    if (!this._options.useWatchman) {
-      return false;
-    }
-    if (!this._isWatchmanInstalledPromise) {
-      this._isWatchmanInstalledPromise = (0, _isWatchmanInstalled.default)();
-    }
-    return this._isWatchmanInstalledPromise;
-  }
-  _createEmptyMap() {
-    return {
-      clocks: new Map(),
-      duplicates: new Map(),
-      files: new Map(),
-      map: new Map(),
-      mocks: new Map()
-    };
-  }
-  static H = _constants.default;
-}
-class DuplicateError extends Error {
-  mockPath1;
-  mockPath2;
-  constructor(mockPath1, mockPath2) {
-    super('Duplicated files or mocks. Please check the console for more info');
-    this.mockPath1 = mockPath1;
-    this.mockPath2 = mockPath2;
-  }
-}
-exports.DuplicateError = DuplicateError;
-function copy(object) {
-  return Object.assign(Object.create(null), object);
-}
-function copyMap(input) {
-  return new Map(input);
-}
-
-// Export the smallest API surface required by Jest
-
-const JestHasteMap = HasteMap;
-var _default = JestHasteMap;
-exports.default = _default;