{"version":3,"sources":["jsdelivr-header.js","/npm/jest-haste-map@30.2.0/build/index.js"],"names":[],"mappings":"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","file":"/npm/jest-haste-map@30.2.0/build/index.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/jest-haste-map@30.2.0/build/index.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","/*!\n * /**\n *  * Copyright (c) Meta Platforms, Inc. and affiliates.\n *  *\n *  * This source code is licensed under the MIT license found in the\n *  * LICENSE file in the root directory of this source tree.\n *  * /\n */\n/******/ (() => { // webpackBootstrap\n/******/ \t\"use strict\";\n/******/ \tvar __webpack_modules__ = ({\n\n/***/ \"./package.json\":\n/***/ ((module) => {\n\nmodule.exports = /*#__PURE__*/JSON.parse('{\"name\":\"jest-haste-map\",\"version\":\"30.1.0\",\"repository\":{\"type\":\"git\",\"url\":\"https://github.com/jestjs/jest.git\",\"directory\":\"packages/jest-haste-map\"},\"license\":\"MIT\",\"main\":\"./build/index.js\",\"types\":\"./build/index.d.ts\",\"exports\":{\".\":{\"types\":\"./build/index.d.ts\",\"require\":\"./build/index.js\",\"import\":\"./build/index.mjs\",\"default\":\"./build/index.js\"},\"./package.json\":\"./package.json\"},\"dependencies\":{\"@jest/types\":\"workspace:*\",\"@types/node\":\"*\",\"anymatch\":\"^3.1.3\",\"fb-watchman\":\"^2.0.2\",\"graceful-fs\":\"^4.2.11\",\"jest-regex-util\":\"workspace:*\",\"jest-util\":\"workspace:*\",\"jest-worker\":\"workspace:*\",\"micromatch\":\"^4.0.8\",\"walker\":\"^1.0.8\"},\"devDependencies\":{\"@types/fb-watchman\":\"^2.0.5\",\"@types/graceful-fs\":\"^4.1.9\",\"@types/micromatch\":\"^4.0.9\",\"slash\":\"^3.0.0\"},\"optionalDependencies\":{\"fsevents\":\"^2.3.3\"},\"engines\":{\"node\":\"^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0\"},\"publishConfig\":{\"access\":\"public\"}}');\n\n/***/ }),\n\n/***/ \"./src/HasteFS.ts\":\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\n\nObject.defineProperty(exports, \"__esModule\", ({\n  value: true\n}));\nexports[\"default\"] = void 0;\nfunction _jestUtil() {\n  const data = require(\"jest-util\");\n  _jestUtil = function () {\n    return data;\n  };\n  return data;\n}\nvar _constants = _interopRequireDefault(__webpack_require__(\"./src/constants.ts\"));\nvar fastPath = _interopRequireWildcard(__webpack_require__(\"./src/lib/fast_path.ts\"));\nfunction _interopRequireWildcard(e, t) { if (\"function\" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || \"object\" != typeof e && \"function\" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) \"default\" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }\nfunction _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nclass HasteFS {\n  _rootDir;\n  _files;\n  constructor({\n    rootDir,\n    files\n  }) {\n    this._rootDir = rootDir;\n    this._files = files;\n  }\n  getModuleName(file) {\n    const fileMetadata = this._getFileData(file);\n    return fileMetadata && fileMetadata[_constants.default.ID] || null;\n  }\n  getSize(file) {\n    const fileMetadata = this._getFileData(file);\n    return fileMetadata && fileMetadata[_constants.default.SIZE] || null;\n  }\n  getDependencies(file) {\n    const fileMetadata = this._getFileData(file);\n    if (fileMetadata) {\n      return fileMetadata[_constants.default.DEPENDENCIES] ? fileMetadata[_constants.default.DEPENDENCIES].split(_constants.default.DEPENDENCY_DELIM) : [];\n    } else {\n      return null;\n    }\n  }\n  getSha1(file) {\n    const fileMetadata = this._getFileData(file);\n    return fileMetadata && fileMetadata[_constants.default.SHA1] || null;\n  }\n  exists(file) {\n    return this._getFileData(file) != null;\n  }\n  getAllFiles() {\n    return [...this.getAbsoluteFileIterator()];\n  }\n  getFileIterator() {\n    return this._files.keys();\n  }\n  *getAbsoluteFileIterator() {\n    for (const file of this.getFileIterator()) {\n      yield fastPath.resolve(this._rootDir, file);\n    }\n  }\n  matchFiles(pattern) {\n    if (!(pattern instanceof RegExp)) {\n      pattern = new RegExp(pattern);\n    }\n    const files = [];\n    for (const file of this.getAbsoluteFileIterator()) {\n      if (pattern.test(file)) {\n        files.push(file);\n      }\n    }\n    return files;\n  }\n  matchFilesWithGlob(globs, root) {\n    const files = new Set();\n    const matcher = (0, _jestUtil().globsToMatcher)(globs);\n    for (const file of this.getAbsoluteFileIterator()) {\n      const filePath = root ? fastPath.relative(root, file) : file;\n      if (matcher((0, _jestUtil().replacePathSepForGlob)(filePath))) {\n        files.add(file);\n      }\n    }\n    return files;\n  }\n  _getFileData(file) {\n    const relativePath = fastPath.relative(this._rootDir, file);\n    return this._files.get(relativePath);\n  }\n}\nexports[\"default\"] = HasteFS;\n\n/***/ }),\n\n/***/ \"./src/ModuleMap.ts\":\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\n\nObject.defineProperty(exports, \"__esModule\", ({\n  value: true\n}));\nexports[\"default\"] = void 0;\nvar _constants = _interopRequireDefault(__webpack_require__(\"./src/constants.ts\"));\nvar fastPath = _interopRequireWildcard(__webpack_require__(\"./src/lib/fast_path.ts\"));\nfunction _interopRequireWildcard(e, t) { if (\"function\" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || \"object\" != typeof e && \"function\" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) \"default\" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }\nfunction _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nconst EMPTY_OBJ = {};\nconst EMPTY_MAP = new Map();\nclass ModuleMap {\n  static DuplicateHasteCandidatesError;\n  _raw;\n  json;\n  static mapToArrayRecursive(map) {\n    let arr = [...map];\n    if (arr[0] && arr[0][1] instanceof Map) {\n      arr = arr.map(el => [el[0], this.mapToArrayRecursive(el[1])]);\n    }\n    return arr;\n  }\n  static mapFromArrayRecursive(arr) {\n    if (arr[0] && Array.isArray(arr[1])) {\n      arr = arr.map(el => [el[0], this.mapFromArrayRecursive(el[1])]);\n    }\n    return new Map(arr);\n  }\n  constructor(raw) {\n    this._raw = raw;\n  }\n  getModule(name, platform, supportsNativePlatform, type) {\n    if (type == null) {\n      type = _constants.default.MODULE;\n    }\n    const module = this._getModuleMetadata(name, platform, !!supportsNativePlatform);\n    if (module && module[_constants.default.TYPE] === type) {\n      const modulePath = module[_constants.default.PATH];\n      return modulePath && fastPath.resolve(this._raw.rootDir, modulePath);\n    }\n    return null;\n  }\n  getPackage(name, platform, _supportsNativePlatform) {\n    return this.getModule(name, platform, null, _constants.default.PACKAGE);\n  }\n  getMockModule(name) {\n    const mockPath = this._raw.mocks.get(name) || this._raw.mocks.get(`${name}/index`);\n    return mockPath && fastPath.resolve(this._raw.rootDir, mockPath);\n  }\n  getRawModuleMap() {\n    return {\n      duplicates: this._raw.duplicates,\n      map: this._raw.map,\n      mocks: this._raw.mocks,\n      rootDir: this._raw.rootDir\n    };\n  }\n  toJSON() {\n    if (!this.json) {\n      this.json = {\n        duplicates: ModuleMap.mapToArrayRecursive(this._raw.duplicates),\n        map: [...this._raw.map],\n        mocks: [...this._raw.mocks],\n        rootDir: this._raw.rootDir\n      };\n    }\n    return this.json;\n  }\n  static fromJSON(serializableModuleMap) {\n    return new ModuleMap({\n      duplicates: ModuleMap.mapFromArrayRecursive(serializableModuleMap.duplicates),\n      map: new Map(serializableModuleMap.map),\n      mocks: new Map(serializableModuleMap.mocks),\n      rootDir: serializableModuleMap.rootDir\n    });\n  }\n\n  /**\n   * When looking up a module's data, we walk through each eligible platform for\n   * the query. For each platform, we want to check if there are known\n   * duplicates for that name+platform pair. The duplication logic normally\n   * removes elements from the `map` object, but we want to check upfront to be\n   * extra sure. If metadata exists both in the `duplicates` object and the\n   * `map`, this would be a bug.\n   */\n  _getModuleMetadata(name, platform, supportsNativePlatform) {\n    const map = this._raw.map.get(name) || EMPTY_OBJ;\n    const dupMap = this._raw.duplicates.get(name) || EMPTY_MAP;\n    if (platform != null) {\n      this._assertNoDuplicates(name, platform, supportsNativePlatform, dupMap.get(platform));\n      if (map[platform] != null) {\n        return map[platform];\n      }\n    }\n    if (supportsNativePlatform) {\n      this._assertNoDuplicates(name, _constants.default.NATIVE_PLATFORM, supportsNativePlatform, dupMap.get(_constants.default.NATIVE_PLATFORM));\n      if (map[_constants.default.NATIVE_PLATFORM]) {\n        return map[_constants.default.NATIVE_PLATFORM];\n      }\n    }\n    this._assertNoDuplicates(name, _constants.default.GENERIC_PLATFORM, supportsNativePlatform, dupMap.get(_constants.default.GENERIC_PLATFORM));\n    if (map[_constants.default.GENERIC_PLATFORM]) {\n      return map[_constants.default.GENERIC_PLATFORM];\n    }\n    return null;\n  }\n  _assertNoDuplicates(name, platform, supportsNativePlatform, relativePathSet) {\n    if (relativePathSet == null) {\n      return;\n    }\n    // Force flow refinement\n    const previousSet = relativePathSet;\n    const duplicates = new Map();\n    for (const [relativePath, type] of previousSet) {\n      const duplicatePath = fastPath.resolve(this._raw.rootDir, relativePath);\n      duplicates.set(duplicatePath, type);\n    }\n    throw new DuplicateHasteCandidatesError(name, platform, supportsNativePlatform, duplicates);\n  }\n  static create(rootDir) {\n    return new ModuleMap({\n      duplicates: new Map(),\n      map: new Map(),\n      mocks: new Map(),\n      rootDir\n    });\n  }\n}\nexports[\"default\"] = ModuleMap;\nclass DuplicateHasteCandidatesError extends Error {\n  hasteName;\n  platform;\n  supportsNativePlatform;\n  duplicatesSet;\n  constructor(name, platform, supportsNativePlatform, duplicatesSet) {\n    const platformMessage = getPlatformMessage(platform);\n    super(`The name \\`${name}\\` was looked up in the Haste module map. It ` + 'cannot be resolved, because there exists several different ' + 'files, or packages, that provide a module for ' + `that particular name and platform. ${platformMessage} You must ` + `delete or exclude files until there remains only one of these:\\n\\n${[...duplicatesSet].map(([dupFilePath, dupFileType]) => `  * \\`${dupFilePath}\\` (${getTypeMessage(dupFileType)})\\n`).sort().join('')}`);\n    this.hasteName = name;\n    this.platform = platform;\n    this.supportsNativePlatform = supportsNativePlatform;\n    this.duplicatesSet = duplicatesSet;\n  }\n}\nfunction getPlatformMessage(platform) {\n  if (platform === _constants.default.GENERIC_PLATFORM) {\n    return 'The platform is generic (no extension).';\n  }\n  return `The platform extension is \\`${platform}\\`.`;\n}\nfunction getTypeMessage(type) {\n  switch (type) {\n    case _constants.default.MODULE:\n      return 'module';\n    case _constants.default.PACKAGE:\n      return 'package';\n  }\n  return 'unknown';\n}\nModuleMap.DuplicateHasteCandidatesError = DuplicateHasteCandidatesError;\n\n/***/ }),\n\n/***/ \"./src/constants.ts\":\n/***/ ((__unused_webpack_module, exports) => {\n\n\n\nObject.defineProperty(exports, \"__esModule\", ({\n  value: true\n}));\nexports[\"default\"] = void 0;\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n/*\n * This file exports a set of constants that are used for Jest's haste map\n * serialization. On very large repositories, the haste map cache becomes very\n * large to the point where it is the largest overhead in starting up Jest.\n *\n * This constant key map allows to keep the map smaller without having to build\n * a custom serialization library.\n */\n\n/* eslint-disable sort-keys */\nconst constants = {\n  /* dependency serialization */\n  DEPENDENCY_DELIM: '\\0',\n  /* file map attributes */\n  ID: 0,\n  MTIME: 1,\n  SIZE: 2,\n  VISITED: 3,\n  DEPENDENCIES: 4,\n  SHA1: 5,\n  /* module map attributes */\n  PATH: 0,\n  TYPE: 1,\n  /* module types */\n  MODULE: 0,\n  PACKAGE: 1,\n  /* platforms */\n  GENERIC_PLATFORM: 'g',\n  NATIVE_PLATFORM: 'native'\n};\n/* eslint-enable */\nvar _default = exports[\"default\"] = constants;\n\n/***/ }),\n\n/***/ \"./src/crawlers/node.ts\":\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\n\nObject.defineProperty(exports, \"__esModule\", ({\n  value: true\n}));\nexports.nodeCrawl = nodeCrawl;\nfunction _child_process() {\n  const data = require(\"child_process\");\n  _child_process = function () {\n    return data;\n  };\n  return data;\n}\nfunction path() {\n  const data = _interopRequireWildcard(require(\"path\"));\n  path = function () {\n    return data;\n  };\n  return data;\n}\nfunction fs() {\n  const data = _interopRequireWildcard(require(\"graceful-fs\"));\n  fs = function () {\n    return data;\n  };\n  return data;\n}\nvar _constants = _interopRequireDefault(__webpack_require__(\"./src/constants.ts\"));\nvar fastPath = _interopRequireWildcard(__webpack_require__(\"./src/lib/fast_path.ts\"));\nfunction _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }\nfunction _interopRequireWildcard(e, t) { if (\"function\" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || \"object\" != typeof e && \"function\" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) \"default\" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nasync function hasNativeFindSupport(forceNodeFilesystemAPI) {\n  if (forceNodeFilesystemAPI) {\n    return false;\n  }\n  try {\n    return await new Promise(resolve => {\n      // Check the find binary supports the non-POSIX -iname parameter wrapped in parens.\n      const args = ['.', '-type', 'f', '(', '-iname', '*.ts', '-o', '-iname', '*.js', ')'];\n      const child = (0, _child_process().spawn)('find', args, {\n        cwd: __dirname\n      });\n      child.on('error', () => {\n        resolve(false);\n      });\n      child.on('exit', code => {\n        resolve(code === 0);\n      });\n    });\n  } catch {\n    return false;\n  }\n}\nfunction find(roots, extensions, ignore, enableSymlinks, callback) {\n  const result = [];\n  let activeCalls = 0;\n  function search(directory) {\n    activeCalls++;\n    fs().readdir(directory, {\n      withFileTypes: true\n    }, (err, entries) => {\n      activeCalls--;\n      if (err) {\n        if (activeCalls === 0) {\n          callback(result);\n        }\n        return;\n      }\n      for (const entry of entries) {\n        const file = path().join(directory, entry.name);\n        if (ignore(file)) {\n          continue;\n        }\n        if (entry.isSymbolicLink()) {\n          continue;\n        }\n        if (entry.isDirectory()) {\n          search(file);\n          continue;\n        }\n        activeCalls++;\n        const stat = enableSymlinks ? fs().stat : fs().lstat;\n        stat(file, (err, stat) => {\n          activeCalls--;\n\n          // This logic is unnecessary for node > v10.10, but leaving it in\n          // since we need it for backwards-compatibility still.\n          if (!err && stat && !stat.isSymbolicLink()) {\n            if (stat.isDirectory()) {\n              search(file);\n            } else {\n              const ext = path().extname(file).slice(1);\n              if (extensions.includes(ext)) {\n                result.push([file, stat.mtime.getTime(), stat.size]);\n              }\n            }\n          }\n          if (activeCalls === 0) {\n            callback(result);\n          }\n        });\n      }\n      if (activeCalls === 0) {\n        callback(result);\n      }\n    });\n  }\n  if (roots.length > 0) {\n    for (const root of roots) search(root);\n  } else {\n    callback(result);\n  }\n}\nfunction findNative(roots, extensions, ignore, enableSymlinks, callback) {\n  const args = [...roots];\n  if (enableSymlinks) {\n    args.push('(', '-type', 'f', '-o', '-type', 'l', ')');\n  } else {\n    args.push('-type', 'f');\n  }\n  if (extensions.length > 0) {\n    args.push('(');\n  }\n  for (const [index, ext] of extensions.entries()) {\n    if (index) {\n      args.push('-o');\n    }\n    args.push('-iname', `*.${ext}`);\n  }\n  if (extensions.length > 0) {\n    args.push(')');\n  }\n  const child = (0, _child_process().spawn)('find', args);\n  let stdout = '';\n  if (child.stdout === null) {\n    throw new Error('stdout is null - this should never happen. Please open up an issue at https://github.com/jestjs/jest');\n  }\n  child.stdout.setEncoding('utf8');\n  child.stdout.on('data', data => stdout += data);\n  child.stdout.on('close', () => {\n    const lines = stdout.trim().split('\\n').filter(x => !ignore(x));\n    const result = [];\n    let count = lines.length;\n    if (count) {\n      for (const path of lines) {\n        fs().stat(path, (err, stat) => {\n          // Filter out symlinks that describe directories\n          if (!err && stat && !stat.isDirectory()) {\n            result.push([path, stat.mtime.getTime(), stat.size]);\n          }\n          if (--count === 0) {\n            callback(result);\n          }\n        });\n      }\n    } else {\n      callback([]);\n    }\n  });\n}\nasync function nodeCrawl(options) {\n  const {\n    data,\n    extensions,\n    forceNodeFilesystemAPI,\n    ignore,\n    rootDir,\n    enableSymlinks,\n    roots\n  } = options;\n  const useNativeFind = await hasNativeFindSupport(forceNodeFilesystemAPI);\n  return new Promise(resolve => {\n    const callback = list => {\n      const files = new Map();\n      const removedFiles = new Map(data.files);\n      for (const fileData of list) {\n        const [filePath, mtime, size] = fileData;\n        const relativeFilePath = fastPath.relative(rootDir, filePath);\n        const existingFile = data.files.get(relativeFilePath);\n        if (existingFile && existingFile[_constants.default.MTIME] === mtime) {\n          files.set(relativeFilePath, existingFile);\n        } else {\n          // See ../constants.js; SHA-1 will always be null and fulfilled later.\n          files.set(relativeFilePath, ['', mtime, size, 0, '', null]);\n        }\n        removedFiles.delete(relativeFilePath);\n      }\n      data.files = files;\n      resolve({\n        hasteMap: data,\n        removedFiles\n      });\n    };\n    if (useNativeFind) {\n      findNative(roots, extensions, ignore, enableSymlinks, callback);\n    } else {\n      find(roots, extensions, ignore, enableSymlinks, callback);\n    }\n  });\n}\n\n/***/ }),\n\n/***/ \"./src/crawlers/watchman.ts\":\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\n\nObject.defineProperty(exports, \"__esModule\", ({\n  value: true\n}));\nexports.watchmanCrawl = watchmanCrawl;\nfunction path() {\n  const data = _interopRequireWildcard(require(\"path\"));\n  path = function () {\n    return data;\n  };\n  return data;\n}\nfunction watchman() {\n  const data = _interopRequireWildcard(require(\"fb-watchman\"));\n  watchman = function () {\n    return data;\n  };\n  return data;\n}\nvar _constants = _interopRequireDefault(__webpack_require__(\"./src/constants.ts\"));\nvar fastPath = _interopRequireWildcard(__webpack_require__(\"./src/lib/fast_path.ts\"));\nvar _normalizePathSep = _interopRequireDefault(__webpack_require__(\"./src/lib/normalizePathSep.ts\"));\nfunction _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }\nfunction _interopRequireWildcard(e, t) { if (\"function\" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || \"object\" != typeof e && \"function\" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) \"default\" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nconst watchmanURL = 'https://facebook.github.io/watchman/docs/troubleshooting';\nfunction watchmanError(error) {\n  error.message = `Watchman error: ${error.message.trim()}. Make sure watchman ` + `is running for this project. See ${watchmanURL}.`;\n  return error;\n}\n\n/**\n * Wrap watchman capabilityCheck method as a promise.\n *\n * @param client watchman client\n * @param caps capabilities to verify\n * @returns a promise resolving to a list of verified capabilities\n */\nasync function capabilityCheck(client, caps) {\n  return new Promise((resolve, reject) => {\n    client.capabilityCheck(\n    // @ts-expect-error: incorrectly typed\n    caps, (error, response) => {\n      if (error) {\n        reject(error);\n      } else {\n        resolve(response);\n      }\n    });\n  });\n}\nasync function watchmanCrawl(options) {\n  const fields = ['name', 'exists', 'mtime_ms', 'size'];\n  const {\n    data,\n    extensions,\n    ignore,\n    rootDir,\n    roots\n  } = options;\n  const defaultWatchExpression = ['allof', ['type', 'f']];\n  const clocks = data.clocks;\n  const client = new (watchman().Client)();\n\n  // https://facebook.github.io/watchman/docs/capabilities.html\n  // Check adds about ~28ms\n  const capabilities = await capabilityCheck(client, {\n    // If a required capability is missing then an error will be thrown,\n    // we don't need this assertion, so using optional instead.\n    optional: ['suffix-set']\n  });\n  if (capabilities?.capabilities['suffix-set']) {\n    // If available, use the optimized `suffix-set` operation:\n    // https://facebook.github.io/watchman/docs/expr/suffix.html#suffix-set\n    defaultWatchExpression.push(['suffix', extensions]);\n  } else {\n    // Otherwise use the older and less optimal suffix tuple array\n    defaultWatchExpression.push(['anyof', ...extensions.map(extension => ['suffix', extension])]);\n  }\n  let clientError;\n  client.on('error', error => clientError = watchmanError(error));\n  const cmd = (...args) => new Promise((resolve, reject) =>\n  // @ts-expect-error: client is typed strictly, but incomplete\n  client.command(args, (error, result) => error ? reject(watchmanError(error)) : resolve(result)));\n  if (options.computeSha1) {\n    const {\n      capabilities\n    } = await cmd('list-capabilities');\n    if (capabilities.includes('field-content.sha1hex')) {\n      fields.push('content.sha1hex');\n    }\n  }\n  async function getWatchmanRoots(roots) {\n    const watchmanRoots = new Map();\n    await Promise.all(roots.map(async root => {\n      const response = await cmd('watch-project', root);\n      const existing = watchmanRoots.get(response.watch);\n      // A root can only be filtered if it was never seen with a\n      // relative_path before.\n      const canBeFiltered = !existing || existing.length > 0;\n      if (canBeFiltered) {\n        if (response.relative_path) {\n          watchmanRoots.set(response.watch, [...(existing || []), response.relative_path]);\n        } else {\n          // Make the filter directories an empty array to signal that this\n          // root was already seen and needs to be watched for all files or\n          // directories.\n          watchmanRoots.set(response.watch, []);\n        }\n      }\n    }));\n    return watchmanRoots;\n  }\n  async function queryWatchmanForDirs(rootProjectDirMappings) {\n    const results = new Map();\n    let isFresh = false;\n    await Promise.all([...rootProjectDirMappings].map(async ([root, directoryFilters]) => {\n      const expression = [...defaultWatchExpression];\n      const glob = [];\n      if (directoryFilters.length > 0) {\n        expression.push(['anyof', ...directoryFilters.map(dir => ['dirname', dir])]);\n        for (const directory of directoryFilters) {\n          for (const extension of extensions) {\n            glob.push(`${directory}/**/*.${extension}`);\n          }\n        }\n      } else {\n        for (const extension of extensions) {\n          glob.push(`**/*.${extension}`);\n        }\n      }\n\n      // Jest is only going to store one type of clock; a string that\n      // represents a local clock. However, the Watchman crawler supports\n      // a second type of clock that can be written by automation outside of\n      // Jest, called an \"scm query\", which fetches changed files based on\n      // source control mergebases. The reason this is necessary is because\n      // local clocks are not portable across systems, but scm queries are.\n      // By using scm queries, we can create the haste map on a different\n      // system and import it, transforming the clock into a local clock.\n      const since = clocks.get(fastPath.relative(rootDir, root));\n      const query = since === undefined ?\n      // Use the `since` generator if we have a clock available\n      {\n        expression,\n        fields,\n        glob,\n        glob_includedotfiles: true\n      } :\n      // Otherwise use the `glob` filter\n      {\n        expression,\n        fields,\n        since\n      };\n      const response = await cmd('query', root, query);\n      if ('warning' in response) {\n        console.warn('watchman warning:', response.warning);\n      }\n\n      // When a source-control query is used, we ignore the \"is fresh\"\n      // response from Watchman because it will be true despite the query\n      // being incremental.\n      const isSourceControlQuery = typeof since !== 'string' && since?.scm?.['mergebase-with'] !== undefined;\n      if (!isSourceControlQuery) {\n        isFresh = isFresh || response.is_fresh_instance;\n      }\n      results.set(root, response);\n    }));\n    return {\n      isFresh,\n      results\n    };\n  }\n  let files = data.files;\n  let removedFiles = new Map();\n  const changedFiles = new Map();\n  let results;\n  let isFresh = false;\n  try {\n    const watchmanRoots = await getWatchmanRoots(roots);\n    const watchmanFileResults = await queryWatchmanForDirs(watchmanRoots);\n\n    // Reset the file map if watchman was restarted and sends us a list of\n    // files.\n    if (watchmanFileResults.isFresh) {\n      files = new Map();\n      removedFiles = new Map(data.files);\n      isFresh = true;\n    }\n    results = watchmanFileResults.results;\n  } finally {\n    client.end();\n  }\n  if (clientError) {\n    throw clientError;\n  }\n  for (const [watchRoot, response] of results) {\n    const fsRoot = (0, _normalizePathSep.default)(watchRoot);\n    const relativeFsRoot = fastPath.relative(rootDir, fsRoot);\n    clocks.set(relativeFsRoot,\n    // Ensure we persist only the local clock.\n    typeof response.clock === 'string' ? response.clock : response.clock.clock);\n    for (const fileData of response.files) {\n      const filePath = fsRoot + path().sep + (0, _normalizePathSep.default)(fileData.name);\n      const relativeFilePath = fastPath.relative(rootDir, filePath);\n      const existingFileData = data.files.get(relativeFilePath);\n\n      // If watchman is fresh, the removed files map starts with all files\n      // and we remove them as we verify they still exist.\n      if (isFresh && existingFileData && fileData.exists) {\n        removedFiles.delete(relativeFilePath);\n      }\n      if (!fileData.exists) {\n        // No need to act on files that do not exist and were not tracked.\n        if (existingFileData) {\n          files.delete(relativeFilePath);\n\n          // If watchman is not fresh, we will know what specific files were\n          // deleted since we last ran and can track only those files.\n          if (!isFresh) {\n            removedFiles.set(relativeFilePath, existingFileData);\n          }\n        }\n      } else if (!ignore(filePath)) {\n        const mtime = typeof fileData.mtime_ms === 'number' ? fileData.mtime_ms : fileData.mtime_ms.toNumber();\n        const size = fileData.size;\n        let sha1hex = fileData['content.sha1hex'];\n        if (typeof sha1hex !== 'string' || sha1hex.length !== 40) {\n          sha1hex = undefined;\n        }\n        let nextData;\n        if (existingFileData && existingFileData[_constants.default.MTIME] === mtime) {\n          nextData = existingFileData;\n        } else if (existingFileData && sha1hex && existingFileData[_constants.default.SHA1] === sha1hex) {\n          nextData = [existingFileData[0], mtime, existingFileData[2], existingFileData[3], existingFileData[4], existingFileData[5]];\n        } else {\n          // See ../constants.ts\n          nextData = ['', mtime, size, 0, '', sha1hex ?? null];\n        }\n        files.set(relativeFilePath, nextData);\n        changedFiles.set(relativeFilePath, nextData);\n      }\n    }\n  }\n  data.files = files;\n  return {\n    changedFiles: isFresh ? undefined : changedFiles,\n    hasteMap: data,\n    removedFiles\n  };\n}\n\n/***/ }),\n\n/***/ \"./src/getMockName.ts\":\n/***/ ((__unused_webpack_module, exports) => {\n\n\n\nObject.defineProperty(exports, \"__esModule\", ({\n  value: true\n}));\nexports[\"default\"] = void 0;\nfunction path() {\n  const data = _interopRequireWildcard(require(\"path\"));\n  path = function () {\n    return data;\n  };\n  return data;\n}\nfunction _interopRequireWildcard(e, t) { if (\"function\" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || \"object\" != typeof e && \"function\" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) \"default\" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nconst MOCKS_PATTERN = `${path().sep}__mocks__${path().sep}`;\nconst getMockName = filePath => {\n  const mockPath = filePath.split(MOCKS_PATTERN)[1];\n  return mockPath.slice(0, mockPath.lastIndexOf(path().extname(mockPath))).replaceAll('\\\\', '/');\n};\nvar _default = exports[\"default\"] = getMockName;\n\n/***/ }),\n\n/***/ \"./src/lib/fast_path.ts\":\n/***/ ((__unused_webpack_module, exports) => {\n\n\n\nObject.defineProperty(exports, \"__esModule\", ({\n  value: true\n}));\nexports.relative = relative;\nexports.resolve = resolve;\nfunction path() {\n  const data = _interopRequireWildcard(require(\"path\"));\n  path = function () {\n    return data;\n  };\n  return data;\n}\nfunction _interopRequireWildcard(e, t) { if (\"function\" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || \"object\" != typeof e && \"function\" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) \"default\" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n// rootDir and filename must be absolute paths (resolved)\nfunction relative(rootDir, filename) {\n  return filename.indexOf(rootDir + path().sep) === 0 ? filename.slice(rootDir.length + 1) : path().relative(rootDir, filename);\n}\nconst INDIRECTION_FRAGMENT = `..${path().sep}`;\n\n// rootDir must be an absolute path and relativeFilename must be simple\n// (e.g.: foo/bar or ../foo/bar, but never ./foo or foo/../bar)\nfunction resolve(rootDir, relativeFilename) {\n  return relativeFilename.indexOf(INDIRECTION_FRAGMENT) === 0 ? path().resolve(rootDir, relativeFilename) : rootDir + path().sep + relativeFilename;\n}\n\n/***/ }),\n\n/***/ \"./src/lib/getPlatformExtension.ts\":\n/***/ ((__unused_webpack_module, exports) => {\n\n\n\nObject.defineProperty(exports, \"__esModule\", ({\n  value: true\n}));\nexports[\"default\"] = getPlatformExtension;\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nconst SUPPORTED_PLATFORM_EXTS = new Set(['android', 'ios', 'native', 'web']);\n\n// Extract platform extension: index.ios.js -> ios\nfunction getPlatformExtension(file, platforms) {\n  const last = file.lastIndexOf('.');\n  const secondToLast = file.lastIndexOf('.', last - 1);\n  if (secondToLast === -1) {\n    return null;\n  }\n  const platform = file.slice(secondToLast + 1, last);\n  // If an overriding platform array is passed, check that first\n\n  if (platforms && platforms.includes(platform)) {\n    return platform;\n  }\n  return SUPPORTED_PLATFORM_EXTS.has(platform) ? platform : null;\n}\n\n/***/ }),\n\n/***/ \"./src/lib/isWatchmanInstalled.ts\":\n/***/ ((__unused_webpack_module, exports) => {\n\n\n\nObject.defineProperty(exports, \"__esModule\", ({\n  value: true\n}));\nexports[\"default\"] = isWatchmanInstalled;\nfunction _child_process() {\n  const data = require(\"child_process\");\n  _child_process = function () {\n    return data;\n  };\n  return data;\n}\nfunction _util() {\n  const data = require(\"util\");\n  _util = function () {\n    return data;\n  };\n  return data;\n}\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nasync function isWatchmanInstalled() {\n  try {\n    await (0, _util().promisify)(_child_process().execFile)('watchman', ['--version']);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/***/ }),\n\n/***/ \"./src/lib/normalizePathSep.ts\":\n/***/ ((__unused_webpack_module, exports) => {\n\n\n\nObject.defineProperty(exports, \"__esModule\", ({\n  value: true\n}));\nexports[\"default\"] = void 0;\nfunction path() {\n  const data = _interopRequireWildcard(require(\"path\"));\n  path = function () {\n    return data;\n  };\n  return data;\n}\nfunction _interopRequireWildcard(e, t) { if (\"function\" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || \"object\" != typeof e && \"function\" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) \"default\" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nlet normalizePathSep;\nif (path().sep === '/') {\n  normalizePathSep = filePath => filePath;\n} else {\n  normalizePathSep = filePath => filePath.replaceAll('/', path().sep);\n}\nvar _default = exports[\"default\"] = normalizePathSep;\n\n/***/ }),\n\n/***/ \"./src/watchers/FSEventsWatcher.ts\":\n/***/ ((__unused_webpack_module, exports) => {\n\n\n\nObject.defineProperty(exports, \"__esModule\", ({\n  value: true\n}));\nexports.FSEventsWatcher = void 0;\nfunction _events() {\n  const data = require(\"events\");\n  _events = function () {\n    return data;\n  };\n  return data;\n}\nfunction path() {\n  const data = _interopRequireWildcard(require(\"path\"));\n  path = function () {\n    return data;\n  };\n  return data;\n}\nfunction _anymatch() {\n  const data = _interopRequireDefault(require(\"anymatch\"));\n  _anymatch = function () {\n    return data;\n  };\n  return data;\n}\nfunction fs() {\n  const data = _interopRequireWildcard(require(\"graceful-fs\"));\n  fs = function () {\n    return data;\n  };\n  return data;\n}\nfunction _micromatch() {\n  const data = _interopRequireDefault(require(\"micromatch\"));\n  _micromatch = function () {\n    return data;\n  };\n  return data;\n}\nfunction _walker() {\n  const data = _interopRequireDefault(require(\"walker\"));\n  _walker = function () {\n    return data;\n  };\n  return data;\n}\nfunction _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }\nfunction _interopRequireWildcard(e, t) { if (\"function\" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || \"object\" != typeof e && \"function\" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) \"default\" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n// @ts-expect-error -- no types\n\n// eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error, @typescript-eslint/ban-ts-comment\n// @ts-ignore: this is for CI which runs linux and might not have this\nlet fsevents = null;\ntry {\n  fsevents = require('fsevents');\n} catch {\n  // Optional dependency, only supported on Darwin.\n}\nconst CHANGE_EVENT = 'change';\nconst DELETE_EVENT = 'delete';\nconst ADD_EVENT = 'add';\nconst ALL_EVENT = 'all';\n/**\n * Export `FSEventsWatcher` class.\n * Watches `dir`.\n */\nclass FSEventsWatcher extends _events().EventEmitter {\n  root;\n  ignored;\n  glob;\n  dot;\n  hasIgnore;\n  doIgnore;\n  fsEventsWatchStopper;\n  _tracked;\n  static isSupported() {\n    return fsevents !== null;\n  }\n  static normalizeProxy(callback) {\n    return (filepath, stats) => callback(path().normalize(filepath), stats);\n  }\n  static recReaddir(dir, dirCallback, fileCallback, endCallback, errorCallback, ignored) {\n    (0, _walker().default)(dir).filterDir(currentDir => !ignored || !(0, _anymatch().default)(ignored, currentDir)).on('dir', FSEventsWatcher.normalizeProxy(dirCallback)).on('file', FSEventsWatcher.normalizeProxy(fileCallback)).on('error', errorCallback).on('end', () => {\n      endCallback();\n    });\n  }\n  constructor(dir, opts) {\n    if (!fsevents) {\n      throw new Error('`fsevents` unavailable (this watcher can only be used on Darwin)');\n    }\n    super();\n    this.dot = opts.dot || false;\n    this.ignored = opts.ignored;\n    this.glob = Array.isArray(opts.glob) ? opts.glob : [opts.glob];\n    this.hasIgnore = Boolean(opts.ignored) && !(Array.isArray(opts) && opts.length > 0);\n    this.doIgnore = opts.ignored ? (0, _anymatch().default)(opts.ignored) : () => false;\n    this.root = path().resolve(dir);\n    this.fsEventsWatchStopper = fsevents.watch(this.root, this.handleEvent.bind(this));\n    this._tracked = new Set();\n    FSEventsWatcher.recReaddir(this.root, filepath => {\n      this._tracked.add(filepath);\n    }, filepath => {\n      this._tracked.add(filepath);\n    }, this.emit.bind(this, 'ready'), this.emit.bind(this, 'error'), this.ignored);\n  }\n\n  /**\n   * End watching.\n   */\n  async close(callback) {\n    await this.fsEventsWatchStopper();\n    this.removeAllListeners();\n    if (typeof callback === 'function') {\n      process.nextTick(() => callback());\n    }\n  }\n  isFileIncluded(relativePath) {\n    if (this.doIgnore(relativePath)) {\n      return false;\n    }\n    return this.glob.length > 0 ? (0, _micromatch().default)([relativePath], this.glob, {\n      dot: this.dot\n    }).length > 0 : this.dot || (0, _micromatch().default)([relativePath], '**/*').length > 0;\n  }\n  handleEvent(filepath) {\n    const relativePath = path().relative(this.root, filepath);\n    if (!this.isFileIncluded(relativePath)) {\n      return;\n    }\n    fs().lstat(filepath, (error, stat) => {\n      if (error && error.code !== 'ENOENT') {\n        this.emit('error', error);\n        return;\n      }\n      if (error) {\n        // Ignore files that aren't tracked and don't exist.\n        if (!this._tracked.has(filepath)) {\n          return;\n        }\n        this._emit(DELETE_EVENT, relativePath);\n        this._tracked.delete(filepath);\n        return;\n      }\n      if (this._tracked.has(filepath)) {\n        this._emit(CHANGE_EVENT, relativePath, stat);\n      } else {\n        this._tracked.add(filepath);\n        this._emit(ADD_EVENT, relativePath, stat);\n      }\n    });\n  }\n\n  /**\n   * Emit events.\n   */\n  _emit(type, file, stat) {\n    this.emit(type, file, this.root, stat);\n    this.emit(ALL_EVENT, type, file, this.root, stat);\n  }\n}\nexports.FSEventsWatcher = FSEventsWatcher;\n\n/***/ }),\n\n/***/ \"./src/watchers/NodeWatcher.js\":\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n// vendored from https://github.com/amasad/sane/blob/64ff3a870c42e84f744086884bf55a4f9c22d376/src/node_watcher.js\n\n\n\nconst EventEmitter = (__webpack_require__(\"events\").EventEmitter);\nconst fs = require('fs');\nconst platform = (__webpack_require__(\"os\").platform)();\nconst path = require('path');\nconst common = __webpack_require__(\"./src/watchers/common.js\");\n\n/**\n * Constants\n */\n\nconst DEFAULT_DELAY = common.DEFAULT_DELAY;\nconst CHANGE_EVENT = common.CHANGE_EVENT;\nconst DELETE_EVENT = common.DELETE_EVENT;\nconst ADD_EVENT = common.ADD_EVENT;\nconst ALL_EVENT = common.ALL_EVENT;\n\n/**\n * Export `NodeWatcher` class.\n * Watches `dir`.\n *\n * @class NodeWatcher\n * @param {String} dir\n * @param {Object} opts\n * @public\n */\n\nmodule.exports = class NodeWatcher extends EventEmitter {\n  constructor(dir, opts) {\n    super();\n\n    common.assignOptions(this, opts);\n\n    this.watched = Object.create(null);\n    this.changeTimers = Object.create(null);\n    this.dirRegistry = Object.create(null);\n    this.root = path.resolve(dir);\n    this.watchdir = this.watchdir.bind(this);\n    this.register = this.register.bind(this);\n    this.checkedEmitError = this.checkedEmitError.bind(this);\n\n    this.watchdir(this.root);\n    common.recReaddir(\n      this.root,\n      this.watchdir,\n      this.register,\n      this.emit.bind(this, 'ready'),\n      this.checkedEmitError,\n      this.ignored,\n    );\n  }\n\n  /**\n   * Register files that matches our globs to know what to type of event to\n   * emit in the future.\n   *\n   * Registry looks like the following:\n   *\n   *  dirRegister => Map {\n   *    dirpath => Map {\n   *       filename => true\n   *    }\n   *  }\n   *\n   * @param {string} filepath\n   * @return {boolean} whether or not we have registered the file.\n   * @private\n   */\n\n  register(filepath) {\n    const relativePath = path.relative(this.root, filepath);\n    if (\n      !common.isFileIncluded(this.globs, this.dot, this.doIgnore, relativePath)\n    ) {\n      return false;\n    }\n\n    const dir = path.dirname(filepath);\n    if (!this.dirRegistry[dir]) {\n      this.dirRegistry[dir] = Object.create(null);\n    }\n\n    const filename = path.basename(filepath);\n    this.dirRegistry[dir][filename] = true;\n\n    return true;\n  }\n\n  /**\n   * Removes a file from the registry.\n   *\n   * @param {string} filepath\n   * @private\n   */\n\n  unregister(filepath) {\n    const dir = path.dirname(filepath);\n    if (this.dirRegistry[dir]) {\n      const filename = path.basename(filepath);\n      delete this.dirRegistry[dir][filename];\n    }\n  }\n\n  /**\n   * Removes a dir from the registry.\n   *\n   * @param {string} dirpath\n   * @private\n   */\n\n  unregisterDir(dirpath) {\n    if (this.dirRegistry[dirpath]) {\n      delete this.dirRegistry[dirpath];\n    }\n  }\n\n  /**\n   * Checks if a file or directory exists in the registry.\n   *\n   * @param {string} fullpath\n   * @return {boolean}\n   * @private\n   */\n\n  registered(fullpath) {\n    const dir = path.dirname(fullpath);\n    return (\n      this.dirRegistry[fullpath] ||\n      (this.dirRegistry[dir] && this.dirRegistry[dir][path.basename(fullpath)])\n    );\n  }\n\n  /**\n   * Emit \"error\" event if it's not an ignorable event\n   *\n   * @param error\n   * @private\n   */\n  checkedEmitError(error) {\n    if (!isIgnorableFileError(error)) {\n      this.emit('error', error);\n    }\n  }\n\n  /**\n   * Watch a directory.\n   *\n   * @param {string} dir\n   * @private\n   */\n\n  watchdir(dir) {\n    if (this.watched[dir]) {\n      return;\n    }\n\n    const watcher = fs.watch(\n      dir,\n      {persistent: true},\n      this.normalizeChange.bind(this, dir),\n    );\n    this.watched[dir] = watcher;\n\n    watcher.on('error', this.checkedEmitError);\n\n    if (this.root !== dir) {\n      this.register(dir);\n    }\n  }\n\n  /**\n   * Stop watching a directory.\n   *\n   * @param {string} dir\n   * @private\n   */\n\n  stopWatching(dir) {\n    if (this.watched[dir]) {\n      this.watched[dir].close();\n      delete this.watched[dir];\n    }\n  }\n\n  /**\n   * End watching.\n   *\n   * @public\n   */\n\n  close() {\n    for (const key of Object.keys(this.watched)) this.stopWatching(key);\n    this.removeAllListeners();\n\n    return Promise.resolve();\n  }\n\n  /**\n   * On some platforms, as pointed out on the fs docs (most likely just win32)\n   * the file argument might be missing from the fs event. Try to detect what\n   * change by detecting if something was deleted or the most recent file change.\n   *\n   * @param {string} dir\n   * @param {string} event\n   * @param {string} file\n   * @public\n   */\n\n  detectChangedFile(dir, event, callback) {\n    if (!this.dirRegistry[dir]) {\n      return;\n    }\n\n    let found = false;\n    let closest = {mtime: 0};\n    let c = 0;\n    // eslint-disable-next-line unicorn/no-array-for-each\n    Object.keys(this.dirRegistry[dir]).forEach((file, i, arr) => {\n      fs.lstat(path.join(dir, file), (error, stat) => {\n        if (found) {\n          return;\n        }\n\n        if (error) {\n          if (isIgnorableFileError(error)) {\n            found = true;\n            callback(file);\n          } else {\n            this.emit('error', error);\n          }\n        } else {\n          if (stat.mtime > closest.mtime) {\n            stat.file = file;\n            closest = stat;\n          }\n          if (arr.length === ++c) {\n            callback(closest.file);\n          }\n        }\n      });\n    });\n  }\n\n  /**\n   * Normalize fs events and pass it on to be processed.\n   *\n   * @param {string} dir\n   * @param {string} event\n   * @param {string} file\n   * @public\n   */\n\n  normalizeChange(dir, event, file) {\n    if (file) {\n      this.processChange(dir, event, path.normalize(file));\n    } else {\n      this.detectChangedFile(dir, event, actualFile => {\n        if (actualFile) {\n          this.processChange(dir, event, actualFile);\n        }\n      });\n    }\n  }\n\n  /**\n   * Process changes.\n   *\n   * @param {string} dir\n   * @param {string} event\n   * @param {string} file\n   * @public\n   */\n\n  processChange(dir, event, file) {\n    const fullPath = path.join(dir, file);\n    const relativePath = path.join(path.relative(this.root, dir), file);\n\n    fs.lstat(fullPath, (error, stat) => {\n      if (error && error.code !== 'ENOENT') {\n        this.emit('error', error);\n      } else if (!error && stat.isDirectory()) {\n        // win32 emits usless change events on dirs.\n        if (event !== 'change') {\n          this.watchdir(fullPath);\n          if (\n            common.isFileIncluded(\n              this.globs,\n              this.dot,\n              this.doIgnore,\n              relativePath,\n            )\n          ) {\n            this.emitEvent(ADD_EVENT, relativePath, stat);\n          }\n        }\n      } else {\n        const registered = this.registered(fullPath);\n        if (error && error.code === 'ENOENT') {\n          this.unregister(fullPath);\n          this.stopWatching(fullPath);\n          this.unregisterDir(fullPath);\n          if (registered) {\n            this.emitEvent(DELETE_EVENT, relativePath);\n          }\n        } else if (registered) {\n          this.emitEvent(CHANGE_EVENT, relativePath, stat);\n        } else {\n          if (this.register(fullPath)) {\n            this.emitEvent(ADD_EVENT, relativePath, stat);\n          }\n        }\n      }\n    });\n  }\n\n  /**\n   * Triggers a 'change' event after debounding it to take care of duplicate\n   * events on os x.\n   *\n   * @private\n   */\n\n  emitEvent(type, file, stat) {\n    const key = `${type}-${file}`;\n    const addKey = `${ADD_EVENT}-${file}`;\n    if (type === CHANGE_EVENT && this.changeTimers[addKey]) {\n      // Ignore the change event that is immediately fired after an add event.\n      // (This happens on Linux).\n      return;\n    }\n    clearTimeout(this.changeTimers[key]);\n    this.changeTimers[key] = setTimeout(() => {\n      delete this.changeTimers[key];\n      if (type === ADD_EVENT && stat.isDirectory()) {\n        // Recursively emit add events and watch for sub-files/folders\n        common.recReaddir(\n          path.resolve(this.root, file),\n          function emitAddDir(dir, stats) {\n            this.watchdir(dir);\n            this.rawEmitEvent(ADD_EVENT, path.relative(this.root, dir), stats);\n          }.bind(this),\n          function emitAddFile(file, stats) {\n            this.register(file);\n            this.rawEmitEvent(ADD_EVENT, path.relative(this.root, file), stats);\n          }.bind(this),\n          function endCallback() {},\n          this.checkedEmitError,\n          this.ignored,\n        );\n      } else {\n        this.rawEmitEvent(type, file, stat);\n      }\n    }, DEFAULT_DELAY);\n  }\n\n  /**\n   * Actually emit the events\n   */\n  rawEmitEvent(type, file, stat) {\n    this.emit(type, file, this.root, stat);\n    this.emit(ALL_EVENT, type, file, this.root, stat);\n  }\n};\n/**\n * Determine if a given FS error can be ignored\n *\n * @private\n */\nfunction isIgnorableFileError(error) {\n  return (\n    error.code === 'ENOENT' ||\n    // Workaround Windows node issue #4337.\n    (error.code === 'EPERM' && platform === 'win32')\n  );\n}\n\n\n/***/ }),\n\n/***/ \"./src/watchers/RecrawlWarning.js\":\n/***/ ((module) => {\n\n// vendored from https://github.com/amasad/sane/blob/64ff3a870c42e84f744086884bf55a4f9c22d376/src/utils/recrawl-warning-dedupe.js\n\n\n\nclass RecrawlWarning {\n  constructor(root, count) {\n    this.root = root;\n    this.count = count;\n  }\n\n  static findByRoot(root) {\n    for (let i = 0; i < this.RECRAWL_WARNINGS.length; i++) {\n      const warning = this.RECRAWL_WARNINGS[i];\n      if (warning.root === root) {\n        return warning;\n      }\n    }\n\n    return undefined;\n  }\n\n  static isRecrawlWarningDupe(warningMessage) {\n    if (typeof warningMessage !== 'string') {\n      return false;\n    }\n    const match = warningMessage.match(this.REGEXP);\n    if (!match) {\n      return false;\n    }\n    const count = Number(match[1]);\n    const root = match[2];\n\n    const warning = this.findByRoot(root);\n\n    if (warning) {\n      // only keep the highest count, assume count to either stay the same or\n      // increase.\n      if (warning.count >= count) {\n        return true;\n      } else {\n        // update the existing warning to the latest (highest) count\n        warning.count = count;\n        return false;\n      }\n    } else {\n      this.RECRAWL_WARNINGS.push(new RecrawlWarning(root, count));\n      return false;\n    }\n  }\n}\n\nRecrawlWarning.RECRAWL_WARNINGS = [];\nRecrawlWarning.REGEXP =\n  /Recrawled this watch (\\d+) times, most recently because:\\n([^:]+)/;\n\nmodule.exports = RecrawlWarning;\n\n\n/***/ }),\n\n/***/ \"./src/watchers/WatchmanWatcher.js\":\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n// ESM COMPAT FLAG\n__webpack_require__.r(__webpack_exports__);\n\n// EXPORTS\n__webpack_require__.d(__webpack_exports__, {\n  \"default\": () => (/* binding */ WatchmanWatcher)\n});\n\n;// external \"assert\"\nconst external_assert_namespaceObject = require(\"assert\");\n// EXTERNAL MODULE: external \"events\"\nvar external_events_ = __webpack_require__(\"events\");\n;// external \"path\"\nconst external_path_namespaceObject = require(\"path\");\n;// external \"fb-watchman\"\nconst external_fb_watchman_namespaceObject = require(\"fb-watchman\");\nvar external_fb_watchman_default = /*#__PURE__*/__webpack_require__.n(external_fb_watchman_namespaceObject);\n;// external \"graceful-fs\"\nconst external_graceful_fs_namespaceObject = require(\"graceful-fs\");\nvar external_graceful_fs_default = /*#__PURE__*/__webpack_require__.n(external_graceful_fs_namespaceObject);\n// EXTERNAL MODULE: ./src/watchers/RecrawlWarning.js\nvar RecrawlWarning = __webpack_require__(\"./src/watchers/RecrawlWarning.js\");\nvar RecrawlWarning_default = /*#__PURE__*/__webpack_require__.n(RecrawlWarning);\n// EXTERNAL MODULE: ./src/watchers/common.js\nvar common = __webpack_require__(\"./src/watchers/common.js\");\n;// ./src/watchers/WatchmanWatcher.js\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n\n\n\n\n\n\n\n\nconst CHANGE_EVENT = common.CHANGE_EVENT;\nconst DELETE_EVENT = common.DELETE_EVENT;\nconst ADD_EVENT = common.ADD_EVENT;\nconst ALL_EVENT = common.ALL_EVENT;\nconst SUB_NAME = 'sane-sub';\n\n/**\n * Watches `dir`.\n *\n * @class PollWatcher\n * @param String dir\n * @param {Object} opts\n * @public\n */\n\nfunction WatchmanWatcher(dir, opts) {\n  common.assignOptions(this, opts);\n  this.root = external_path_namespaceObject.resolve(dir);\n  this.init();\n}\n\nObject.setPrototypeOf(WatchmanWatcher.prototype, external_events_.EventEmitter.prototype);\n\n/**\n * Run the watchman `watch` command on the root and subscribe to changes.\n *\n * @private\n */\n\nWatchmanWatcher.prototype.init = function () {\n  if (this.client) {\n    this.client.removeAllListeners();\n  }\n\n  const self = this;\n  this.client = new (external_fb_watchman_default()).Client();\n  this.client.on('error', error => {\n    self.emit('error', error);\n  });\n  this.client.on('subscription', this.handleChangeEvent.bind(this));\n  this.client.on('end', () => {\n    console.warn('[sane] Warning: Lost connection to watchman, reconnecting..');\n    self.init();\n  });\n\n  this.watchProjectInfo = null;\n\n  function getWatchRoot() {\n    return self.watchProjectInfo ? self.watchProjectInfo.root : self.root;\n  }\n\n  function onCapability(error, resp) {\n    if (handleError(self, error)) {\n      // The Watchman watcher is unusable on this system, we cannot continue\n      return;\n    }\n\n    handleWarning(resp);\n\n    self.capabilities = resp.capabilities;\n\n    if (self.capabilities.relative_root) {\n      self.client.command(['watch-project', getWatchRoot()], onWatchProject);\n    } else {\n      self.client.command(['watch', getWatchRoot()], onWatch);\n    }\n  }\n\n  function onWatchProject(error, resp) {\n    if (handleError(self, error)) {\n      return;\n    }\n\n    handleWarning(resp);\n\n    self.watchProjectInfo = {\n      relativePath: resp.relative_path ?? '',\n      root: resp.watch,\n    };\n\n    self.client.command(['clock', getWatchRoot()], onClock);\n  }\n\n  function onWatch(error, resp) {\n    if (handleError(self, error)) {\n      return;\n    }\n\n    handleWarning(resp);\n\n    self.client.command(['clock', getWatchRoot()], onClock);\n  }\n\n  function onClock(error, resp) {\n    if (handleError(self, error)) {\n      return;\n    }\n\n    handleWarning(resp);\n\n    const options = {\n      fields: ['name', 'exists', 'new'],\n      since: resp.clock,\n    };\n\n    // If the server has the wildmatch capability available it supports\n    // the recursive **/*.foo style match and we can offload our globs\n    // to the watchman server.  This saves both on data size to be\n    // communicated back to us and compute for evaluating the globs\n    // in our node process.\n    if (self.capabilities.wildmatch) {\n      if (self.globs.length === 0) {\n        if (!self.dot) {\n          // Make sure we honor the dot option if even we're not using globs.\n          options.expression = [\n            'match',\n            '**',\n            'wholename',\n            {\n              includedotfiles: false,\n            },\n          ];\n        }\n      } else {\n        options.expression = ['anyof'];\n        for (const i in self.globs) {\n          options.expression.push([\n            'match',\n            self.globs[i],\n            'wholename',\n            {\n              includedotfiles: self.dot,\n            },\n          ]);\n        }\n      }\n    }\n\n    if (self.capabilities.relative_root) {\n      options.relative_root = self.watchProjectInfo.relativePath;\n    }\n\n    self.client.command(\n      ['subscribe', getWatchRoot(), SUB_NAME, options],\n      onSubscribe,\n    );\n  }\n\n  function onSubscribe(error, resp) {\n    if (handleError(self, error)) {\n      return;\n    }\n\n    handleWarning(resp);\n\n    self.emit('ready');\n  }\n\n  self.client.capabilityCheck(\n    {\n      optional: ['wildmatch', 'relative_root'],\n    },\n    onCapability,\n  );\n};\n\n/**\n * Handles a change event coming from the subscription.\n *\n * @param {Object} resp\n * @private\n */\n\nWatchmanWatcher.prototype.handleChangeEvent = function (resp) {\n  external_assert_namespaceObject.strict.equal(resp.subscription, SUB_NAME, 'Invalid subscription event.');\n  if (resp.is_fresh_instance) {\n    this.emit('fresh_instance');\n  }\n  if (resp.is_fresh_instance) {\n    this.emit('fresh_instance');\n  }\n  if (Array.isArray(resp.files)) {\n    for (const file of resp.files) this.handleFileChange(file);\n  }\n};\n\n/**\n * Handles a single change event record.\n *\n * @param {Object} changeDescriptor\n * @private\n */\n\nWatchmanWatcher.prototype.handleFileChange = function (changeDescriptor) {\n  const self = this;\n  let absPath;\n  let relativePath;\n\n  if (this.capabilities.relative_root) {\n    relativePath = changeDescriptor.name;\n    absPath = external_path_namespaceObject.join(\n      this.watchProjectInfo.root,\n      this.watchProjectInfo.relativePath,\n      relativePath,\n    );\n  } else {\n    absPath = external_path_namespaceObject.join(this.root, changeDescriptor.name);\n    relativePath = changeDescriptor.name;\n  }\n\n  if (\n    !(self.capabilities.wildmatch && !this.hasIgnore) &&\n    !common.isFileIncluded(this.globs, this.dot, this.doIgnore, relativePath)\n  ) {\n    return;\n  }\n\n  if (changeDescriptor.exists) {\n    external_graceful_fs_default().lstat(absPath, (error, stat) => {\n      // Files can be deleted between the event and the lstat call\n      // the most reliable thing to do here is to ignore the event.\n      if (error && error.code === 'ENOENT') {\n        return;\n      }\n\n      if (handleError(self, error)) {\n        return;\n      }\n\n      const eventType = changeDescriptor.new ? ADD_EVENT : CHANGE_EVENT;\n\n      // Change event on dirs are mostly useless.\n      if (!(eventType === CHANGE_EVENT && stat.isDirectory())) {\n        self.emitEvent(eventType, relativePath, self.root, stat);\n      }\n    });\n  } else {\n    self.emitEvent(DELETE_EVENT, relativePath, self.root);\n  }\n};\n\n/**\n * Dispatches the event.\n *\n * @param {string} eventType\n * @param {string} filepath\n * @param {string} root\n * @param {fs.Stat} stat\n * @private\n */\n\nWatchmanWatcher.prototype.emitEvent = function (\n  eventType,\n  filepath,\n  root,\n  stat,\n) {\n  this.emit(eventType, filepath, root, stat);\n  this.emit(ALL_EVENT, eventType, filepath, root, stat);\n};\n\n/**\n * Closes the watcher.\n *\n */\n\nWatchmanWatcher.prototype.close = function () {\n  this.client.removeAllListeners();\n  this.client.end();\n  return Promise.resolve();\n};\n\n/**\n * Handles an error and returns true if exists.\n *\n * @param {WatchmanWatcher} self\n * @param {Error} error\n * @private\n */\n\nfunction handleError(self, error) {\n  if (error == null) {\n    return false;\n  } else {\n    self.emit('error', error);\n    return true;\n  }\n}\n\n/**\n * Handles a warning in the watchman resp object.\n *\n * @param {object} resp\n * @private\n */\n\nfunction handleWarning(resp) {\n  if ('warning' in resp) {\n    if (RecrawlWarning_default().isRecrawlWarningDupe(resp.warning)) {\n      return true;\n    }\n    console.warn(resp.warning);\n    return true;\n  } else {\n    return false;\n  }\n}\n\n\n/***/ }),\n\n/***/ \"./src/watchers/common.js\":\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n// vendored from https://github.com/amasad/sane/blob/64ff3a870c42e84f744086884bf55a4f9c22d376/src/common.js\n\n\n\nconst platform = (__webpack_require__(\"os\").platform)();\nconst path = require('path');\nconst anymatch = require('anymatch');\nconst micromatch = require('micromatch');\nconst walker = require('walker');\n\n/**\n * Constants\n */\n\nexports.DEFAULT_DELAY = 100;\nexports.CHANGE_EVENT = 'change';\nexports.DELETE_EVENT = 'delete';\nexports.ADD_EVENT = 'add';\nexports.ALL_EVENT = 'all';\n\n/**\n * Assigns options to the watcher.\n *\n * @param {NodeWatcher|PollWatcher|WatchmanWatcher} watcher\n * @param {?object} opts\n * @return {boolean}\n * @public\n */\n\nexports.assignOptions = function (watcher, opts) {\n  opts = opts || {};\n  watcher.globs = opts.glob || [];\n  watcher.dot = opts.dot || false;\n  watcher.ignored = opts.ignored || false;\n\n  if (!Array.isArray(watcher.globs)) {\n    watcher.globs = [watcher.globs];\n  }\n  watcher.hasIgnore =\n    Boolean(opts.ignored) && !(Array.isArray(opts) && opts.length > 0);\n  watcher.doIgnore = opts.ignored ? anymatch(opts.ignored) : () => false;\n\n  if (opts.watchman && opts.watchmanPath) {\n    watcher.watchmanPath = opts.watchmanPath;\n  }\n\n  return opts;\n};\n\n/**\n * Checks a file relative path against the globs array.\n *\n * @param {array} globs\n * @param {string} relativePath\n * @return {boolean}\n * @public\n */\n\nexports.isFileIncluded = function (globs, dot, doIgnore, relativePath) {\n  if (doIgnore(relativePath)) {\n    return false;\n  }\n  return globs.length > 0\n    ? micromatch.some(relativePath, globs, {dot})\n    : // eslint-disable-next-line unicorn/no-array-method-this-argument\n      dot || micromatch.some(relativePath, '**/*');\n};\n\n/**\n * Traverse a directory recursively calling `callback` on every directory.\n *\n * @param {string} dir\n * @param {function} dirCallback\n * @param {function} fileCallback\n * @param {function} endCallback\n * @param {*} ignored\n * @public\n */\n\nexports.recReaddir = function (\n  dir,\n  dirCallback,\n  fileCallback,\n  endCallback,\n  errorCallback,\n  ignored,\n) {\n  walker(dir)\n    .filterDir(currentDir => !anymatch(ignored, currentDir))\n    .on('dir', normalizeProxy(dirCallback))\n    .on('file', normalizeProxy(fileCallback))\n    .on('error', errorCallback)\n    .on('end', () => {\n      if (platform === 'win32') {\n        setTimeout(endCallback, 1000);\n      } else {\n        endCallback();\n      }\n    });\n};\n\n/**\n * Returns a callback that when called will normalize a path and call the\n * original callback\n *\n * @param {function} callback\n * @return {function}\n * @private\n */\n\nfunction normalizeProxy(callback) {\n  return (filepath, stats) => callback(path.normalize(filepath), stats);\n}\n\n\n/***/ }),\n\n/***/ \"events\":\n/***/ ((module) => {\n\nmodule.exports = require(\"events\");\n\n/***/ }),\n\n/***/ \"os\":\n/***/ ((module) => {\n\nmodule.exports = require(\"os\");\n\n/***/ })\n\n/******/ \t});\n/************************************************************************/\n/******/ \t// The module cache\n/******/ \tvar __webpack_module_cache__ = {};\n/******/ \t\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/ \t\t// Check if module is in cache\n/******/ \t\tvar cachedModule = __webpack_module_cache__[moduleId];\n/******/ \t\tif (cachedModule !== undefined) {\n/******/ \t\t\treturn cachedModule.exports;\n/******/ \t\t}\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = __webpack_module_cache__[moduleId] = {\n/******/ \t\t\t// no module.id needed\n/******/ \t\t\t// no module.loaded needed\n/******/ \t\t\texports: {}\n/******/ \t\t};\n/******/ \t\n/******/ \t\t// Execute the module function\n/******/ \t\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n/******/ \t\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/ \t\n/************************************************************************/\n/******/ \t/* webpack/runtime/compat get default export */\n/******/ \t(() => {\n/******/ \t\t// getDefaultExport function for compatibility with non-harmony modules\n/******/ \t\t__webpack_require__.n = (module) => {\n/******/ \t\t\tvar getter = module && module.__esModule ?\n/******/ \t\t\t\t() => (module['default']) :\n/******/ \t\t\t\t() => (module);\n/******/ \t\t\t__webpack_require__.d(getter, { a: getter });\n/******/ \t\t\treturn getter;\n/******/ \t\t};\n/******/ \t})();\n/******/ \t\n/******/ \t/* webpack/runtime/define property getters */\n/******/ \t(() => {\n/******/ \t\t// define getter functions for harmony exports\n/******/ \t\t__webpack_require__.d = (exports, definition) => {\n/******/ \t\t\tfor(var key in definition) {\n/******/ \t\t\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n/******/ \t\t\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n/******/ \t\t\t\t}\n/******/ \t\t\t}\n/******/ \t\t};\n/******/ \t})();\n/******/ \t\n/******/ \t/* webpack/runtime/hasOwnProperty shorthand */\n/******/ \t(() => {\n/******/ \t\t__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))\n/******/ \t})();\n/******/ \t\n/******/ \t/* webpack/runtime/make namespace object */\n/******/ \t(() => {\n/******/ \t\t// define __esModule on exports\n/******/ \t\t__webpack_require__.r = (exports) => {\n/******/ \t\t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n/******/ \t\t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n/******/ \t\t\t}\n/******/ \t\t\tObject.defineProperty(exports, '__esModule', { value: true });\n/******/ \t\t};\n/******/ \t})();\n/******/ \t\n/************************************************************************/\nvar __webpack_exports__ = {};\n// This entry needs to be wrapped in an IIFE because it uses a non-standard name for the exports (exports).\n(() => {\nvar exports = __webpack_exports__;\n\n\nObject.defineProperty(exports, \"__esModule\", ({\n  value: true\n}));\nexports[\"default\"] = exports.ModuleMap = exports.DuplicateError = void 0;\nfunction _crypto() {\n  const data = require(\"crypto\");\n  _crypto = function () {\n    return data;\n  };\n  return data;\n}\nfunction _events() {\n  const data = require(\"events\");\n  _events = function () {\n    return data;\n  };\n  return data;\n}\nfunction _os() {\n  const data = require(\"os\");\n  _os = function () {\n    return data;\n  };\n  return data;\n}\nfunction path() {\n  const data = _interopRequireWildcard(require(\"path\"));\n  path = function () {\n    return data;\n  };\n  return data;\n}\nfunction _v() {\n  const data = require(\"v8\");\n  _v = function () {\n    return data;\n  };\n  return data;\n}\nfunction _gracefulFs() {\n  const data = require(\"graceful-fs\");\n  _gracefulFs = function () {\n    return data;\n  };\n  return data;\n}\nfunction _jestRegexUtil() {\n  const data = require(\"jest-regex-util\");\n  _jestRegexUtil = function () {\n    return data;\n  };\n  return data;\n}\nfunction _jestUtil() {\n  const data = require(\"jest-util\");\n  _jestUtil = function () {\n    return data;\n  };\n  return data;\n}\nfunction _jestWorker() {\n  const data = require(\"jest-worker\");\n  _jestWorker = function () {\n    return data;\n  };\n  return data;\n}\nvar _HasteFS = _interopRequireDefault(__webpack_require__(\"./src/HasteFS.ts\"));\nvar _ModuleMap = _interopRequireDefault(__webpack_require__(\"./src/ModuleMap.ts\"));\nvar _constants = _interopRequireDefault(__webpack_require__(\"./src/constants.ts\"));\nvar _node = __webpack_require__(\"./src/crawlers/node.ts\");\nvar _watchman = __webpack_require__(\"./src/crawlers/watchman.ts\");\nvar _getMockName = _interopRequireDefault(__webpack_require__(\"./src/getMockName.ts\"));\nvar fastPath = _interopRequireWildcard(__webpack_require__(\"./src/lib/fast_path.ts\"));\nvar _getPlatformExtension = _interopRequireDefault(__webpack_require__(\"./src/lib/getPlatformExtension.ts\"));\nvar _isWatchmanInstalled = _interopRequireDefault(__webpack_require__(\"./src/lib/isWatchmanInstalled.ts\"));\nvar _normalizePathSep = _interopRequireDefault(__webpack_require__(\"./src/lib/normalizePathSep.ts\"));\nvar _FSEventsWatcher = __webpack_require__(\"./src/watchers/FSEventsWatcher.ts\");\nvar _NodeWatcher = _interopRequireDefault(__webpack_require__(\"./src/watchers/NodeWatcher.js\"));\nvar _WatchmanWatcher = _interopRequireDefault(__webpack_require__(\"./src/watchers/WatchmanWatcher.js\"));\nvar _worker = require(\"./worker\");\nfunction _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }\nfunction _interopRequireWildcard(e, t) { if (\"function\" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || \"object\" != typeof e && \"function\" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) \"default\" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n// @ts-expect-error: not converted to TypeScript - it's a fork: https://github.com/jestjs/jest/pull/10919\n\n// @ts-expect-error: not converted to TypeScript - it's a fork: https://github.com/jestjs/jest/pull/5387\n\n// TypeScript doesn't like us importing from outside `rootDir`, but it doesn't\n// understand `require`.\nconst {\n  version: VERSION\n} = __webpack_require__(\"./package.json\");\nlet isWatchmanInstalledPromise;\nconst ModuleMap = exports.ModuleMap = _ModuleMap.default;\nconst CHANGE_INTERVAL = 30;\nconst MAX_WAIT_TIME = 240_000;\nconst NODE_MODULES = `${path().sep}node_modules${path().sep}`;\nconst PACKAGE_JSON = `${path().sep}package.json`;\nconst VCS_DIRECTORIES = ['.git', '.hg', '.sl'].map(vcs => (0, _jestRegexUtil().escapePathForRegex)(path().sep + vcs + path().sep)).join('|');\n/**\n * HasteMap is a JavaScript implementation of Facebook's haste module system.\n *\n * This implementation is inspired by https://github.com/facebook/node-haste\n * and was built with for high-performance in large code repositories with\n * hundreds of thousands of files. This implementation is scalable and provides\n * predictable performance.\n *\n * Because the haste map creation and synchronization is critical to startup\n * performance and most tasks are blocked by I/O this class makes heavy use of\n * synchronous operations. It uses worker processes for parallelizing file\n * access and metadata extraction.\n *\n * The data structures created by `jest-haste-map` can be used directly from the\n * cache without further processing. The metadata objects in the `files` and\n * `map` objects contain cross-references: a metadata object from one can look\n * up the corresponding metadata object in the other map. Note that in most\n * projects, the number of files will be greater than the number of haste\n * modules one module can refer to many files based on platform extensions.\n *\n * type HasteMap = {\n *   clocks: WatchmanClocks,\n *   files: {[filepath: string]: FileMetaData},\n *   map: {[id: string]: ModuleMapItem},\n *   mocks: {[id: string]: string},\n * }\n *\n * // Watchman clocks are used for query synchronization and file system deltas.\n * type WatchmanClocks = {[filepath: string]: string};\n *\n * type FileMetaData = {\n *   id: ?string, // used to look up module metadata objects in `map`.\n *   mtime: number, // check for outdated files.\n *   size: number, // size of the file in bytes.\n *   visited: boolean, // whether the file has been parsed or not.\n *   dependencies: Array<string>, // all relative dependencies of this file.\n *   sha1: ?string, // SHA-1 of the file, if requested via options.\n * };\n *\n * // Modules can be targeted to a specific platform based on the file name.\n * // Example: platform.ios.js and Platform.android.js will both map to the same\n * // `Platform` module. The platform should be specified during resolution.\n * type ModuleMapItem = {[platform: string]: ModuleMetaData};\n *\n * //\n * type ModuleMetaData = {\n *   path: string, // the path to look up the file object in `files`.\n *   type: string, // the module type (either `package` or `module`).\n * };\n *\n * Note that the data structures described above are conceptual only. The actual\n * implementation uses arrays and constant keys for metadata storage. Instead of\n * `{id: 'flatMap', mtime: 3421, size: 42, visited: true, dependencies: []}` the real\n * representation is similar to `['flatMap', 3421, 42, 1, []]` to save storage space\n * and reduce parse and write time of a big JSON blob.\n *\n * The HasteMap is created as follows:\n *  1. read data from the cache or create an empty structure.\n *\n *  2. crawl the file system.\n *     * empty cache: crawl the entire file system.\n *     * cache available:\n *       * if watchman is available: get file system delta changes.\n *       * if watchman is unavailable: crawl the entire file system.\n *     * build metadata objects for every file. This builds the `files` part of\n *       the `HasteMap`.\n *\n *  3. parse and extract metadata from changed files.\n *     * this is done in parallel over worker processes to improve performance.\n *     * the worst case is to parse all files.\n *     * the best case is no file system access and retrieving all data from\n *       the cache.\n *     * the average case is a small number of changed files.\n *\n *  4. serialize the new `HasteMap` in a cache file.\n *     Worker processes can directly access the cache through `HasteMap.read()`.\n *\n */\nclass HasteMap extends _events().EventEmitter {\n  _buildPromise = null;\n  _cachePath = '';\n  _changeInterval;\n  _console;\n  _options;\n  _watchers = [];\n  _worker = null;\n  static getStatic(config) {\n    if (config.haste.hasteMapModulePath) {\n      return require(config.haste.hasteMapModulePath);\n    }\n    return HasteMap;\n  }\n  static async create(options) {\n    if (options.hasteMapModulePath) {\n      const CustomHasteMap = require(options.hasteMapModulePath);\n      return new CustomHasteMap(options);\n    }\n    const hasteMap = new HasteMap(options);\n    await hasteMap.setupCachePath(options);\n    return hasteMap;\n  }\n  constructor(options) {\n    super();\n    this._options = {\n      cacheDirectory: options.cacheDirectory || (0, _os().tmpdir)(),\n      computeDependencies: options.computeDependencies ?? true,\n      computeSha1: options.computeSha1 || false,\n      dependencyExtractor: options.dependencyExtractor || null,\n      enableSymlinks: options.enableSymlinks || false,\n      extensions: options.extensions,\n      forceNodeFilesystemAPI: !!options.forceNodeFilesystemAPI,\n      hasteImplModulePath: options.hasteImplModulePath,\n      id: options.id,\n      maxWorkers: options.maxWorkers,\n      mocksPattern: options.mocksPattern ? new RegExp(options.mocksPattern) : null,\n      platforms: options.platforms,\n      resetCache: options.resetCache,\n      retainAllFiles: options.retainAllFiles,\n      rootDir: options.rootDir,\n      roots: [...new Set(options.roots)],\n      skipPackageJson: !!options.skipPackageJson,\n      throwOnModuleCollision: !!options.throwOnModuleCollision,\n      useWatchman: options.useWatchman ?? true,\n      watch: !!options.watch,\n      workerThreads: options.workerThreads\n    };\n    this._console = options.console || globalThis.console;\n    if (options.ignorePattern) {\n      if (options.ignorePattern instanceof RegExp) {\n        this._options.ignorePattern = new RegExp(`${options.ignorePattern.source}|${VCS_DIRECTORIES}`, options.ignorePattern.flags);\n      } else {\n        throw new TypeError('jest-haste-map: the `ignorePattern` option must be a RegExp');\n      }\n    } else {\n      this._options.ignorePattern = new RegExp(VCS_DIRECTORIES);\n    }\n    if (this._options.enableSymlinks && this._options.useWatchman) {\n      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.');\n    }\n  }\n  async setupCachePath(options) {\n    const rootDirHash = (0, _crypto().createHash)('sha1').update(options.rootDir).digest('hex').slice(0, 32);\n    let hasteImplHash = '';\n    let dependencyExtractorHash = '';\n    if (options.hasteImplModulePath) {\n      const hasteImpl = require(options.hasteImplModulePath);\n      if (hasteImpl.getCacheKey) {\n        hasteImplHash = String(hasteImpl.getCacheKey());\n      }\n    }\n    if (options.dependencyExtractor) {\n      const dependencyExtractor = await (0, _jestUtil().requireOrImportModule)(options.dependencyExtractor, false);\n      if (dependencyExtractor.getCacheKey) {\n        dependencyExtractorHash = String(dependencyExtractor.getCacheKey());\n      }\n    }\n    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());\n  }\n  static getCacheFilePath(tmpdir, id, ...extra) {\n    const hash = (0, _crypto().createHash)('sha1').update(extra.join(''));\n    return path().join(tmpdir, `${id.replaceAll(/\\W/g, '-')}-${hash.digest('hex').slice(0, 32)}`);\n  }\n  static getModuleMapFromJSON(json) {\n    return _ModuleMap.default.fromJSON(json);\n  }\n  getCacheFilePath() {\n    return this._cachePath;\n  }\n  build() {\n    if (!this._buildPromise) {\n      this._buildPromise = (async () => {\n        const data = await this._buildFileMap();\n\n        // Persist when we don't know if files changed (changedFiles undefined)\n        // or when we know a file was changed or deleted.\n        let hasteMap;\n        if (data.changedFiles === undefined || data.changedFiles.size > 0 || data.removedFiles.size > 0) {\n          hasteMap = await this._buildHasteMap(data);\n          this._persist(hasteMap);\n        } else {\n          hasteMap = data.hasteMap;\n        }\n        const rootDir = this._options.rootDir;\n        const hasteFS = new _HasteFS.default({\n          files: hasteMap.files,\n          rootDir\n        });\n        const moduleMap = new _ModuleMap.default({\n          duplicates: hasteMap.duplicates,\n          map: hasteMap.map,\n          mocks: hasteMap.mocks,\n          rootDir\n        });\n        const __hasteMapForTest =  false || null;\n        await this._watch(hasteMap);\n        return {\n          __hasteMapForTest,\n          hasteFS,\n          moduleMap\n        };\n      })();\n    }\n    return this._buildPromise;\n  }\n\n  /**\n   * 1. read data from the cache or create an empty structure.\n   */\n  read() {\n    let hasteMap;\n    try {\n      hasteMap = (0, _v().deserialize)((0, _gracefulFs().readFileSync)(this._cachePath));\n    } catch {\n      hasteMap = this._createEmptyMap();\n    }\n    return hasteMap;\n  }\n  readModuleMap() {\n    const data = this.read();\n    return new _ModuleMap.default({\n      duplicates: data.duplicates,\n      map: data.map,\n      mocks: data.mocks,\n      rootDir: this._options.rootDir\n    });\n  }\n\n  /**\n   * 2. crawl the file system.\n   */\n  async _buildFileMap() {\n    let hasteMap;\n    try {\n      const read = this._options.resetCache ? this._createEmptyMap : this.read;\n      hasteMap = read.call(this);\n    } catch {\n      hasteMap = this._createEmptyMap();\n    }\n    return this._crawl(hasteMap);\n  }\n\n  /**\n   * 3. parse and extract metadata from changed files.\n   */\n  _processFile(hasteMap, map, mocks, filePath, workerOptions) {\n    const rootDir = this._options.rootDir;\n    const setModule = (id, module) => {\n      let moduleMap = map.get(id);\n      if (!moduleMap) {\n        moduleMap = Object.create(null);\n        map.set(id, moduleMap);\n      }\n      const platform = (0, _getPlatformExtension.default)(module[_constants.default.PATH], this._options.platforms) || _constants.default.GENERIC_PLATFORM;\n      const existingModule = moduleMap[platform];\n      if (existingModule && existingModule[_constants.default.PATH] !== module[_constants.default.PATH]) {\n        const method = this._options.throwOnModuleCollision ? 'error' : 'warn';\n        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'));\n        if (this._options.throwOnModuleCollision) {\n          throw new DuplicateError(existingModule[_constants.default.PATH], module[_constants.default.PATH]);\n        }\n\n        // We do NOT want consumers to use a module that is ambiguous.\n        delete moduleMap[platform];\n        if (Object.keys(moduleMap).length === 1) {\n          map.delete(id);\n        }\n        let dupsByPlatform = hasteMap.duplicates.get(id);\n        if (dupsByPlatform == null) {\n          dupsByPlatform = new Map();\n          hasteMap.duplicates.set(id, dupsByPlatform);\n        }\n        const dups = new Map([[module[_constants.default.PATH], module[_constants.default.TYPE]], [existingModule[_constants.default.PATH], existingModule[_constants.default.TYPE]]]);\n        dupsByPlatform.set(platform, dups);\n        return;\n      }\n      const dupsByPlatform = hasteMap.duplicates.get(id);\n      if (dupsByPlatform != null) {\n        const dups = dupsByPlatform.get(platform);\n        if (dups != null) {\n          dups.set(module[_constants.default.PATH], module[_constants.default.TYPE]);\n        }\n        return;\n      }\n      moduleMap[platform] = module;\n    };\n    const relativeFilePath = fastPath.relative(rootDir, filePath);\n    const fileMetadata = hasteMap.files.get(relativeFilePath);\n    if (!fileMetadata) {\n      throw new Error('jest-haste-map: File to process was not found in the haste map.');\n    }\n    const moduleMetadata = hasteMap.map.get(fileMetadata[_constants.default.ID]);\n    const computeSha1 = this._options.computeSha1 && !fileMetadata[_constants.default.SHA1];\n\n    // Callback called when the response from the worker is successful.\n    const workerReply = metadata => {\n      // `1` for truthy values instead of `true` to save cache space.\n      fileMetadata[_constants.default.VISITED] = 1;\n      const metadataId = metadata.id;\n      const metadataModule = metadata.module;\n      if (metadataId && metadataModule) {\n        fileMetadata[_constants.default.ID] = metadataId;\n        setModule(metadataId, metadataModule);\n      }\n      fileMetadata[_constants.default.DEPENDENCIES] = metadata.dependencies ? metadata.dependencies.join(_constants.default.DEPENDENCY_DELIM) : '';\n      if (computeSha1) {\n        fileMetadata[_constants.default.SHA1] = metadata.sha1;\n      }\n    };\n\n    // Callback called when the response from the worker is an error.\n    const workerError = error => {\n      if (typeof error !== 'object' || !error.message || !error.stack) {\n        error = new Error(error);\n        error.stack = ''; // Remove stack for stack-less errors.\n      }\n      if (!['ENOENT', 'EACCES'].includes(error.code)) {\n        throw error;\n      }\n\n      // If a file cannot be read we remove it from the file list and\n      // ignore the failure silently.\n      hasteMap.files.delete(relativeFilePath);\n    };\n\n    // If we retain all files in the virtual HasteFS representation, we avoid\n    // reading them if they aren't important (node_modules).\n    if (this._options.retainAllFiles && filePath.includes(NODE_MODULES)) {\n      if (computeSha1) {\n        return this._getWorker(workerOptions).getSha1({\n          computeDependencies: this._options.computeDependencies,\n          computeSha1,\n          dependencyExtractor: this._options.dependencyExtractor,\n          filePath,\n          hasteImplModulePath: this._options.hasteImplModulePath,\n          rootDir\n        }).then(workerReply, workerError);\n      }\n      return null;\n    }\n    if (this._options.mocksPattern && this._options.mocksPattern.test(filePath)) {\n      const mockPath = (0, _getMockName.default)(filePath);\n      const existingMockPath = mocks.get(mockPath);\n      if (existingMockPath) {\n        const secondMockPath = fastPath.relative(rootDir, filePath);\n        if (existingMockPath !== secondMockPath) {\n          const method = this._options.throwOnModuleCollision ? 'error' : 'warn';\n          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'));\n          if (this._options.throwOnModuleCollision) {\n            throw new DuplicateError(existingMockPath, secondMockPath);\n          }\n        }\n      }\n      mocks.set(mockPath, relativeFilePath);\n    }\n    if (fileMetadata[_constants.default.VISITED]) {\n      if (!fileMetadata[_constants.default.ID]) {\n        return null;\n      }\n      if (moduleMetadata != null) {\n        const platform = (0, _getPlatformExtension.default)(filePath, this._options.platforms) || _constants.default.GENERIC_PLATFORM;\n        const module = moduleMetadata[platform];\n        if (module == null) {\n          return null;\n        }\n        const moduleId = fileMetadata[_constants.default.ID];\n        let modulesByPlatform = map.get(moduleId);\n        if (!modulesByPlatform) {\n          modulesByPlatform = Object.create(null);\n          map.set(moduleId, modulesByPlatform);\n        }\n        modulesByPlatform[platform] = module;\n        return null;\n      }\n    }\n    return this._getWorker(workerOptions).worker({\n      computeDependencies: this._options.computeDependencies,\n      computeSha1,\n      dependencyExtractor: this._options.dependencyExtractor,\n      filePath,\n      hasteImplModulePath: this._options.hasteImplModulePath,\n      rootDir\n    }).then(workerReply, workerError);\n  }\n  _buildHasteMap(data) {\n    const {\n      removedFiles,\n      changedFiles,\n      hasteMap\n    } = data;\n\n    // If any files were removed or we did not track what files changed, process\n    // every file looking for changes. Otherwise, process only changed files.\n    let map;\n    let mocks;\n    let filesToProcess;\n    if (changedFiles === undefined || removedFiles.size > 0) {\n      map = new Map();\n      mocks = new Map();\n      filesToProcess = hasteMap.files;\n    } else {\n      map = hasteMap.map;\n      mocks = hasteMap.mocks;\n      filesToProcess = changedFiles;\n    }\n    for (const [relativeFilePath, fileMetadata] of removedFiles) {\n      this._recoverDuplicates(hasteMap, relativeFilePath, fileMetadata[_constants.default.ID]);\n    }\n    const promises = [];\n    for (const relativeFilePath of filesToProcess.keys()) {\n      if (this._options.skipPackageJson && relativeFilePath.endsWith(PACKAGE_JSON)) {\n        continue;\n      }\n      // SHA-1, if requested, should already be present thanks to the crawler.\n      const filePath = fastPath.resolve(this._options.rootDir, relativeFilePath);\n      const promise = this._processFile(hasteMap, map, mocks, filePath);\n      if (promise) {\n        promises.push(promise);\n      }\n    }\n    return Promise.all(promises).then(() => {\n      this._cleanup();\n      hasteMap.map = map;\n      hasteMap.mocks = mocks;\n      return hasteMap;\n    }, error => {\n      this._cleanup();\n      throw error;\n    });\n  }\n  _cleanup() {\n    const worker = this._worker;\n    if (worker && 'end' in worker) {\n      worker.end();\n    }\n    this._worker = null;\n  }\n\n  /**\n   * 4. serialize the new `HasteMap` in a cache file.\n   */\n  _persist(hasteMap) {\n    (0, _gracefulFs().writeFileSync)(this._cachePath, (0, _v().serialize)(hasteMap));\n  }\n\n  /**\n   * Creates workers or parses files and extracts metadata in-process.\n   */\n  _getWorker(options) {\n    if (!this._worker) {\n      if (options?.forceInBand || this._options.maxWorkers <= 1) {\n        this._worker = {\n          getSha1: _worker.getSha1,\n          worker: _worker.worker\n        };\n      } else {\n        this._worker = new (_jestWorker().Worker)(require.resolve('./worker'), {\n          enableWorkerThreads: this._options.workerThreads,\n          exposedMethods: ['getSha1', 'worker'],\n          forkOptions: {\n            serialization: 'json'\n          },\n          maxRetries: 3,\n          numWorkers: this._options.maxWorkers\n        });\n      }\n    }\n    return this._worker;\n  }\n  async _crawl(hasteMap) {\n    const options = this._options;\n    const ignore = this._ignore.bind(this);\n    const crawl = (await this._shouldUseWatchman()) ? _watchman.watchmanCrawl : _node.nodeCrawl;\n    const crawlerOptions = {\n      computeSha1: options.computeSha1,\n      data: hasteMap,\n      enableSymlinks: options.enableSymlinks,\n      extensions: options.extensions,\n      forceNodeFilesystemAPI: options.forceNodeFilesystemAPI,\n      ignore,\n      rootDir: options.rootDir,\n      roots: options.roots\n    };\n    const retry = retryError => {\n      if (crawl === _watchman.watchmanCrawl) {\n        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' + `  ${retryError}`);\n        return (0, _node.nodeCrawl)(crawlerOptions).catch(error => {\n          throw new Error('Crawler retry failed:\\n' + `  Original error: ${retryError.message}\\n` + `  Retry error: ${error.message}\\n`);\n        });\n      }\n      throw retryError;\n    };\n    try {\n      return await crawl(crawlerOptions);\n    } catch (error) {\n      return retry(error);\n    }\n  }\n\n  /**\n   * Watch mode\n   */\n  async _watch(hasteMap) {\n    if (!this._options.watch) {\n      return;\n    }\n\n    // In watch mode, we'll only warn about module collisions and we'll retain\n    // all files, even changes to node_modules.\n    this._options.throwOnModuleCollision = false;\n    this._options.retainAllFiles = true;\n\n    // WatchmanWatcher > FSEventsWatcher > sane.NodeWatcher\n    const Watcher = (await this._shouldUseWatchman()) ? _WatchmanWatcher.default : _FSEventsWatcher.FSEventsWatcher.isSupported() ? _FSEventsWatcher.FSEventsWatcher : _NodeWatcher.default;\n    const extensions = this._options.extensions;\n    const ignorePattern = this._options.ignorePattern;\n    const rootDir = this._options.rootDir;\n    let changeQueue = Promise.resolve();\n    let eventsQueue = [];\n    // We only need to copy the entire haste map once on every \"frame\".\n    let mustCopy = true;\n    const createWatcher = root => {\n      const watcher = new Watcher(root, {\n        dot: true,\n        glob: extensions.map(extension => `**/*.${extension}`),\n        ignored: ignorePattern\n      });\n      return new Promise((resolve, reject) => {\n        const rejectTimeout = setTimeout(() => reject(new Error('Failed to start watch mode.')), MAX_WAIT_TIME);\n        watcher.once('ready', () => {\n          clearTimeout(rejectTimeout);\n          watcher.on('all', onChange);\n          resolve(watcher);\n        });\n      });\n    };\n    const emitChange = () => {\n      if (eventsQueue.length > 0) {\n        mustCopy = true;\n        const changeEvent = {\n          eventsQueue,\n          hasteFS: new _HasteFS.default({\n            files: hasteMap.files,\n            rootDir\n          }),\n          moduleMap: new _ModuleMap.default({\n            duplicates: hasteMap.duplicates,\n            map: hasteMap.map,\n            mocks: hasteMap.mocks,\n            rootDir\n          })\n        };\n        this.emit('change', changeEvent);\n        eventsQueue = [];\n      }\n    };\n    const onChange = (type, filePath, root, stat) => {\n      filePath = path().join(root, (0, _normalizePathSep.default)(filePath));\n      if (stat && stat.isDirectory() || this._ignore(filePath) || !extensions.some(extension => filePath.endsWith(extension))) {\n        return;\n      }\n      const relativeFilePath = fastPath.relative(rootDir, filePath);\n      const fileMetadata = hasteMap.files.get(relativeFilePath);\n\n      // The file has been accessed, not modified\n      if (type === 'change' && fileMetadata && stat && fileMetadata[_constants.default.MTIME] === stat.mtime.getTime()) {\n        return;\n      }\n      changeQueue = changeQueue.then(() => {\n        // If we get duplicate events for the same file, ignore them.\n        if (eventsQueue.some(event => event.type === type && event.filePath === filePath && (!event.stat && !stat || !!event.stat && !!stat && event.stat.mtime.getTime() === stat.mtime.getTime()))) {\n          return null;\n        }\n        if (mustCopy) {\n          mustCopy = false;\n          hasteMap = {\n            clocks: new Map(hasteMap.clocks),\n            duplicates: new Map(hasteMap.duplicates),\n            files: new Map(hasteMap.files),\n            map: new Map(hasteMap.map),\n            mocks: new Map(hasteMap.mocks)\n          };\n        }\n        const add = () => {\n          eventsQueue.push({\n            filePath,\n            stat,\n            type\n          });\n          return null;\n        };\n        const fileMetadata = hasteMap.files.get(relativeFilePath);\n\n        // If it's not an addition, delete the file and all its metadata\n        if (fileMetadata != null) {\n          const moduleName = fileMetadata[_constants.default.ID];\n          const platform = (0, _getPlatformExtension.default)(filePath, this._options.platforms) || _constants.default.GENERIC_PLATFORM;\n          hasteMap.files.delete(relativeFilePath);\n          let moduleMap = hasteMap.map.get(moduleName);\n          if (moduleMap != null) {\n            // We are forced to copy the object because jest-haste-map exposes\n            // the map as an immutable entity.\n            moduleMap = copy(moduleMap);\n            delete moduleMap[platform];\n            if (Object.keys(moduleMap).length === 0) {\n              hasteMap.map.delete(moduleName);\n            } else {\n              hasteMap.map.set(moduleName, moduleMap);\n            }\n          }\n          if (this._options.mocksPattern && this._options.mocksPattern.test(filePath)) {\n            const mockName = (0, _getMockName.default)(filePath);\n            hasteMap.mocks.delete(mockName);\n          }\n          this._recoverDuplicates(hasteMap, relativeFilePath, moduleName);\n        }\n\n        // If the file was added or changed,\n        // parse it and update the haste map.\n        if (type === 'add' || type === 'change') {\n          (0, _jestUtil().invariant)(stat, 'since the file exists or changed, it should have stats');\n          const fileMetadata = ['', stat.mtime.getTime(), stat.size, 0, '', null];\n          hasteMap.files.set(relativeFilePath, fileMetadata);\n          const promise = this._processFile(hasteMap, hasteMap.map, hasteMap.mocks, filePath, {\n            forceInBand: true\n          });\n          // Cleanup\n          this._cleanup();\n          if (promise) {\n            return promise.then(add);\n          } else {\n            // If a file in node_modules has changed,\n            // emit an event regardless.\n            add();\n          }\n        } else {\n          add();\n        }\n        return null;\n      }).catch(error => {\n        this._console.error(`jest-haste-map: watch error:\\n  ${error.stack}\\n`);\n      });\n    };\n    this._changeInterval = setInterval(emitChange, CHANGE_INTERVAL);\n    return Promise.all(this._options.roots.map(createWatcher)).then(watchers => {\n      this._watchers = watchers;\n    });\n  }\n\n  /**\n   * This function should be called when the file under `filePath` is removed\n   * or changed. When that happens, we want to figure out if that file was\n   * part of a group of files that had the same ID. If it was, we want to\n   * remove it from the group. Furthermore, if there is only one file\n   * remaining in the group, then we want to restore that single file as the\n   * correct resolution for its ID, and cleanup the duplicates index.\n   */\n  _recoverDuplicates(hasteMap, relativeFilePath, moduleName) {\n    let dupsByPlatform = hasteMap.duplicates.get(moduleName);\n    if (dupsByPlatform == null) {\n      return;\n    }\n    const platform = (0, _getPlatformExtension.default)(relativeFilePath, this._options.platforms) || _constants.default.GENERIC_PLATFORM;\n    let dups = dupsByPlatform.get(platform);\n    if (dups == null) {\n      return;\n    }\n    dupsByPlatform = copyMap(dupsByPlatform);\n    hasteMap.duplicates.set(moduleName, dupsByPlatform);\n    dups = copyMap(dups);\n    dupsByPlatform.set(platform, dups);\n    dups.delete(relativeFilePath);\n    if (dups.size !== 1) {\n      return;\n    }\n    const uniqueModule = dups.entries().next().value;\n    if (!uniqueModule) {\n      return;\n    }\n    let dedupMap = hasteMap.map.get(moduleName);\n    if (!dedupMap) {\n      dedupMap = Object.create(null);\n      hasteMap.map.set(moduleName, dedupMap);\n    }\n    dedupMap[platform] = uniqueModule;\n    dupsByPlatform.delete(platform);\n    if (dupsByPlatform.size === 0) {\n      hasteMap.duplicates.delete(moduleName);\n    }\n  }\n  async end() {\n    if (this._changeInterval) {\n      clearInterval(this._changeInterval);\n    }\n    if (this._watchers.length === 0) {\n      return;\n    }\n    await Promise.all(this._watchers.map(watcher => watcher.close()));\n    this._watchers = [];\n  }\n\n  /**\n   * Helpers\n   */\n  _ignore(filePath) {\n    const ignorePattern = this._options.ignorePattern;\n    const ignoreMatched = ignorePattern instanceof RegExp ? ignorePattern.test(filePath) : ignorePattern && ignorePattern(filePath);\n    return ignoreMatched || !this._options.retainAllFiles && filePath.includes(NODE_MODULES);\n  }\n  async _shouldUseWatchman() {\n    if (!this._options.useWatchman) {\n      return false;\n    }\n    if (!isWatchmanInstalledPromise) {\n      isWatchmanInstalledPromise = (0, _isWatchmanInstalled.default)();\n    }\n    return isWatchmanInstalledPromise;\n  }\n  _createEmptyMap() {\n    return {\n      clocks: new Map(),\n      duplicates: new Map(),\n      files: new Map(),\n      map: new Map(),\n      mocks: new Map()\n    };\n  }\n  static H = _constants.default;\n}\nclass DuplicateError extends Error {\n  mockPath1;\n  mockPath2;\n  constructor(mockPath1, mockPath2) {\n    super('Duplicated files or mocks. Please check the console for more info');\n    this.mockPath1 = mockPath1;\n    this.mockPath2 = mockPath2;\n  }\n}\nexports.DuplicateError = DuplicateError;\nfunction copy(object) {\n  return Object.assign(Object.create(null), object);\n}\nfunction copyMap(input) {\n  return new Map(input);\n}\n\n// Export the smallest API surface required by Jest\n\nconst JestHasteMap = HasteMap;\nvar _default = exports[\"default\"] = JestHasteMap;\n})();\n\nmodule.exports = __webpack_exports__;\n/******/ })()\n;"]}