Add node modules and compiled JavaScript from main (#57)

Co-authored-by: Oliver King <oking3@uncc.edu>

node_modules/jest-haste-map/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Facebook, Inc. and its affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/jest-haste-map/build/HasteFS.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+import type { FileData } from './types';
+export default class HasteFS {
+    private readonly _rootDir;
+    private readonly _files;
+    constructor({ rootDir, files }: {
+        rootDir: Config.Path;
+        files: FileData;
+    });
+    getModuleName(file: Config.Path): string | null;
+    getSize(file: Config.Path): number | null;
+    getDependencies(file: Config.Path): Array<string> | null;
+    getSha1(file: Config.Path): string | null;
+    exists(file: Config.Path): boolean;
+    getAllFiles(): Array<Config.Path>;
+    getFileIterator(): Iterable<Config.Path>;
+    getAbsoluteFileIterator(): Iterable<Config.Path>;
+    matchFiles(pattern: RegExp | string): Array<Config.Path>;
+    matchFilesWithGlob(globs: Array<Config.Glob>, root: Config.Path | null): Set<Config.Path>;
+    private _getFileData;
+}

node_modules/jest-haste-map/build/HasteFS.js

@@ -0,0 +1,179 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+function _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var fastPath = _interopRequireWildcard(require('./lib/fast_path'));
+
+var _constants = _interopRequireDefault(require('./constants'));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+function _getRequireWildcardCache() {
+  if (typeof WeakMap !== 'function') return null;
+  var cache = new WeakMap();
+  _getRequireWildcardCache = function () {
+    return cache;
+  };
+  return cache;
+}
+
+function _interopRequireWildcard(obj) {
+  if (obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
+    return {default: obj};
+  }
+  var cache = _getRequireWildcardCache();
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor
+        ? Object.getOwnPropertyDescriptor(obj, key)
+        : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+class HasteFS {
+  constructor({rootDir, files}) {
+    _defineProperty(this, '_rootDir', void 0);
+
+    _defineProperty(this, '_files', void 0);
+
+    this._rootDir = rootDir;
+    this._files = files;
+  }
+
+  getModuleName(file) {
+    const fileMetadata = this._getFileData(file);
+
+    return (fileMetadata && fileMetadata[_constants.default.ID]) || null;
+  }
+
+  getSize(file) {
+    const fileMetadata = this._getFileData(file);
+
+    return (fileMetadata && fileMetadata[_constants.default.SIZE]) || null;
+  }
+
+  getDependencies(file) {
+    const fileMetadata = this._getFileData(file);
+
+    if (fileMetadata) {
+      return fileMetadata[_constants.default.DEPENDENCIES]
+        ? fileMetadata[_constants.default.DEPENDENCIES].split(
+            _constants.default.DEPENDENCY_DELIM
+          )
+        : [];
+    } else {
+      return null;
+    }
+  }
+
+  getSha1(file) {
+    const fileMetadata = this._getFileData(file);
+
+    return (fileMetadata && fileMetadata[_constants.default.SHA1]) || null;
+  }
+
+  exists(file) {
+    return this._getFileData(file) != null;
+  }
+
+  getAllFiles() {
+    return Array.from(this.getAbsoluteFileIterator());
+  }
+
+  getFileIterator() {
+    return this._files.keys();
+  }
+
+  *getAbsoluteFileIterator() {
+    for (const file of this.getFileIterator()) {
+      yield fastPath.resolve(this._rootDir, file);
+    }
+  }
+
+  matchFiles(pattern) {
+    if (!(pattern instanceof RegExp)) {
+      pattern = new RegExp(pattern);
+    }
+
+    const files = [];
+
+    for (const file of this.getAbsoluteFileIterator()) {
+      if (pattern.test(file)) {
+        files.push(file);
+      }
+    }
+
+    return files;
+  }
+
+  matchFilesWithGlob(globs, root) {
+    const files = new Set();
+    const matcher = (0, _jestUtil().globsToMatcher)(globs);
+
+    for (const file of this.getAbsoluteFileIterator()) {
+      const filePath = root ? fastPath.relative(root, file) : file;
+
+      if (matcher((0, _jestUtil().replacePathSepForGlob)(filePath))) {
+        files.add(file);
+      }
+    }
+
+    return files;
+  }
+
+  _getFileData(file) {
+    const relativePath = fastPath.relative(this._rootDir, file);
+    return this._files.get(relativePath);
+  }
+}
+
+exports.default = HasteFS;

node_modules/jest-haste-map/build/ModuleMap.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+import type { DuplicatesSet, HTypeValue, MockData, ModuleMapData, RawModuleMap } from './types';
+declare type ValueType<T> = T extends Map<string, infer V> ? V : never;
+export declare type SerializableModuleMap = {
+    duplicates: ReadonlyArray<[string, [string, [string, [string, number]]]]>;
+    map: ReadonlyArray<[string, ValueType<ModuleMapData>]>;
+    mocks: ReadonlyArray<[string, ValueType<MockData>]>;
+    rootDir: Config.Path;
+};
+export default class ModuleMap {
+    static DuplicateHasteCandidatesError: typeof DuplicateHasteCandidatesError;
+    private readonly _raw;
+    private json;
+    private static mapToArrayRecursive;
+    private static mapFromArrayRecursive;
+    constructor(raw: RawModuleMap);
+    getModule(name: string, platform?: string | null, supportsNativePlatform?: boolean | null, type?: HTypeValue | null): Config.Path | null;
+    getPackage(name: string, platform: string | null | undefined, _supportsNativePlatform: boolean | null): Config.Path | null;
+    getMockModule(name: string): Config.Path | undefined;
+    getRawModuleMap(): RawModuleMap;
+    toJSON(): SerializableModuleMap;
+    static fromJSON(serializableModuleMap: SerializableModuleMap): ModuleMap;
+    /**
+     * When looking up a module's data, we walk through each eligible platform for
+     * the query. For each platform, we want to check if there are known
+     * duplicates for that name+platform pair. The duplication logic normally
+     * removes elements from the `map` object, but we want to check upfront to be
+     * extra sure. If metadata exists both in the `duplicates` object and the
+     * `map`, this would be a bug.
+     */
+    private _getModuleMetadata;
+    private _assertNoDuplicates;
+    static create(rootDir: Config.Path): ModuleMap;
+}
+declare class DuplicateHasteCandidatesError extends Error {
+    hasteName: string;
+    platform: string | null;
+    supportsNativePlatform: boolean;
+    duplicatesSet: DuplicatesSet;
+    constructor(name: string, platform: string, supportsNativePlatform: boolean, duplicatesSet: DuplicatesSet);
+}
+export {};

node_modules/jest-haste-map/build/ModuleMap.js

@@ -0,0 +1,305 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+var fastPath = _interopRequireWildcard(require('./lib/fast_path'));
+
+var _constants = _interopRequireDefault(require('./constants'));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+function _getRequireWildcardCache() {
+  if (typeof WeakMap !== 'function') return null;
+  var cache = new WeakMap();
+  _getRequireWildcardCache = function () {
+    return cache;
+  };
+  return cache;
+}
+
+function _interopRequireWildcard(obj) {
+  if (obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
+    return {default: obj};
+  }
+  var cache = _getRequireWildcardCache();
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor
+        ? Object.getOwnPropertyDescriptor(obj, key)
+        : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+const EMPTY_OBJ = {};
+const EMPTY_MAP = new Map();
+
+class ModuleMap {
+  static mapToArrayRecursive(map) {
+    let arr = Array.from(map);
+
+    if (arr[0] && arr[0][1] instanceof Map) {
+      arr = arr.map(el => [el[0], this.mapToArrayRecursive(el[1])]);
+    }
+
+    return arr;
+  }
+
+  static mapFromArrayRecursive(arr) {
+    if (arr[0] && Array.isArray(arr[1])) {
+      arr = arr.map(el => [el[0], this.mapFromArrayRecursive(el[1])]);
+    }
+
+    return new Map(arr);
+  }
+
+  constructor(raw) {
+    _defineProperty(this, '_raw', void 0);
+
+    _defineProperty(this, 'json', void 0);
+
+    this._raw = raw;
+  }
+
+  getModule(name, platform, supportsNativePlatform, type) {
+    if (type == null) {
+      type = _constants.default.MODULE;
+    }
+
+    const module = this._getModuleMetadata(
+      name,
+      platform,
+      !!supportsNativePlatform
+    );
+
+    if (module && module[_constants.default.TYPE] === type) {
+      const modulePath = module[_constants.default.PATH];
+      return modulePath && fastPath.resolve(this._raw.rootDir, modulePath);
+    }
+
+    return null;
+  }
+
+  getPackage(name, platform, _supportsNativePlatform) {
+    return this.getModule(name, platform, null, _constants.default.PACKAGE);
+  }
+
+  getMockModule(name) {
+    const mockPath =
+      this._raw.mocks.get(name) || this._raw.mocks.get(name + '/index');
+
+    return mockPath && fastPath.resolve(this._raw.rootDir, mockPath);
+  }
+
+  getRawModuleMap() {
+    return {
+      duplicates: this._raw.duplicates,
+      map: this._raw.map,
+      mocks: this._raw.mocks,
+      rootDir: this._raw.rootDir
+    };
+  }
+
+  toJSON() {
+    if (!this.json) {
+      this.json = {
+        duplicates: ModuleMap.mapToArrayRecursive(this._raw.duplicates),
+        map: Array.from(this._raw.map),
+        mocks: Array.from(this._raw.mocks),
+        rootDir: this._raw.rootDir
+      };
+    }
+
+    return this.json;
+  }
+
+  static fromJSON(serializableModuleMap) {
+    return new ModuleMap({
+      duplicates: ModuleMap.mapFromArrayRecursive(
+        serializableModuleMap.duplicates
+      ),
+      map: new Map(serializableModuleMap.map),
+      mocks: new Map(serializableModuleMap.mocks),
+      rootDir: serializableModuleMap.rootDir
+    });
+  }
+  /**
+   * When looking up a module's data, we walk through each eligible platform for
+   * the query. For each platform, we want to check if there are known
+   * duplicates for that name+platform pair. The duplication logic normally
+   * removes elements from the `map` object, but we want to check upfront to be
+   * extra sure. If metadata exists both in the `duplicates` object and the
+   * `map`, this would be a bug.
+   */
+
+  _getModuleMetadata(name, platform, supportsNativePlatform) {
+    const map = this._raw.map.get(name) || EMPTY_OBJ;
+    const dupMap = this._raw.duplicates.get(name) || EMPTY_MAP;
+
+    if (platform != null) {
+      this._assertNoDuplicates(
+        name,
+        platform,
+        supportsNativePlatform,
+        dupMap.get(platform)
+      );
+
+      if (map[platform] != null) {
+        return map[platform];
+      }
+    }
+
+    if (supportsNativePlatform) {
+      this._assertNoDuplicates(
+        name,
+        _constants.default.NATIVE_PLATFORM,
+        supportsNativePlatform,
+        dupMap.get(_constants.default.NATIVE_PLATFORM)
+      );
+
+      if (map[_constants.default.NATIVE_PLATFORM]) {
+        return map[_constants.default.NATIVE_PLATFORM];
+      }
+    }
+
+    this._assertNoDuplicates(
+      name,
+      _constants.default.GENERIC_PLATFORM,
+      supportsNativePlatform,
+      dupMap.get(_constants.default.GENERIC_PLATFORM)
+    );
+
+    if (map[_constants.default.GENERIC_PLATFORM]) {
+      return map[_constants.default.GENERIC_PLATFORM];
+    }
+
+    return null;
+  }
+
+  _assertNoDuplicates(name, platform, supportsNativePlatform, relativePathSet) {
+    if (relativePathSet == null) {
+      return;
+    } // Force flow refinement
+
+    const previousSet = relativePathSet;
+    const duplicates = new Map();
+
+    for (const [relativePath, type] of previousSet) {
+      const duplicatePath = fastPath.resolve(this._raw.rootDir, relativePath);
+      duplicates.set(duplicatePath, type);
+    }
+
+    throw new DuplicateHasteCandidatesError(
+      name,
+      platform,
+      supportsNativePlatform,
+      duplicates
+    );
+  }
+
+  static create(rootDir) {
+    return new ModuleMap({
+      duplicates: new Map(),
+      map: new Map(),
+      mocks: new Map(),
+      rootDir
+    });
+  }
+}
+
+exports.default = ModuleMap;
+
+_defineProperty(ModuleMap, 'DuplicateHasteCandidatesError', void 0);
+
+class DuplicateHasteCandidatesError extends Error {
+  constructor(name, platform, supportsNativePlatform, duplicatesSet) {
+    const platformMessage = getPlatformMessage(platform);
+    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` +
+        Array.from(duplicatesSet)
+          .map(
+            ([dupFilePath, dupFileType]) =>
+              `  * \`${dupFilePath}\` (${getTypeMessage(dupFileType)})\n`
+          )
+          .sort()
+          .join('')
+    );
+
+    _defineProperty(this, 'hasteName', void 0);
+
+    _defineProperty(this, 'platform', void 0);
+
+    _defineProperty(this, 'supportsNativePlatform', void 0);
+
+    _defineProperty(this, 'duplicatesSet', void 0);
+
+    this.hasteName = name;
+    this.platform = platform;
+    this.supportsNativePlatform = supportsNativePlatform;
+    this.duplicatesSet = duplicatesSet;
+  }
+}
+
+function getPlatformMessage(platform) {
+  if (platform === _constants.default.GENERIC_PLATFORM) {
+    return 'The platform is generic (no extension).';
+  }
+
+  return `The platform extension is \`${platform}\`.`;
+}
+
+function getTypeMessage(type) {
+  switch (type) {
+    case _constants.default.MODULE:
+      return 'module';
+
+    case _constants.default.PACKAGE:
+      return 'package';
+  }
+
+  return 'unknown';
+}
+
+ModuleMap.DuplicateHasteCandidatesError = DuplicateHasteCandidatesError;

node_modules/jest-haste-map/build/blacklist.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+declare const extensions: Set<string>;
+export default extensions;

node_modules/jest-haste-map/build/blacklist.js

@@ -0,0 +1,59 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+// This list is compiled after the MDN list of the most common MIME types (see
+// https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/
+// Complete_list_of_MIME_types).
+//
+// Only MIME types starting with "image/", "video/", "audio/" and "font/" are
+// reflected in the list. Adding "application/" is too risky since some text
+// file formats (like ".js" and ".json") have an "application/" MIME type.
+//
+// Feel free to add any extensions that cannot be a Haste module.
+const extensions = new Set([
+  // JSONs are never haste modules, except for "package.json", which is handled.
+  '.json', // Image extensions.
+  '.bmp',
+  '.gif',
+  '.ico',
+  '.jpeg',
+  '.jpg',
+  '.png',
+  '.svg',
+  '.tiff',
+  '.tif',
+  '.webp', // Video extensions.
+  '.avi',
+  '.mp4',
+  '.mpeg',
+  '.mpg',
+  '.ogv',
+  '.webm',
+  '.3gp',
+  '.3g2', // Audio extensions.
+  '.aac',
+  '.midi',
+  '.mid',
+  '.mp3',
+  '.oga',
+  '.wav',
+  '.3gp',
+  '.3g2', // Font extensions.
+  '.eot',
+  '.otf',
+  '.ttf',
+  '.woff',
+  '.woff2'
+]);
+var _default = extensions;
+exports.default = _default;

node_modules/jest-haste-map/build/constants.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { HType } from './types';
+declare const constants: HType;
+export default constants;

node_modules/jest-haste-map/build/constants.js

@@ -0,0 +1,52 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/*
+ * This file exports a set of constants that are used for Jest's haste map
+ * serialization. On very large repositories, the haste map cache becomes very
+ * large to the point where it is the largest overhead in starting up Jest.
+ *
+ * This constant key map allows to keep the map smaller without having to build
+ * a custom serialization library.
+ */
+
+/* eslint-disable sort-keys */
+const constants = {
+  /* dependency serialization */
+  DEPENDENCY_DELIM: '\0',
+
+  /* file map attributes */
+  ID: 0,
+  MTIME: 1,
+  SIZE: 2,
+  VISITED: 3,
+  DEPENDENCIES: 4,
+  SHA1: 5,
+
+  /* module map attributes */
+  PATH: 0,
+  TYPE: 1,
+
+  /* module types */
+  MODULE: 0,
+  PACKAGE: 1,
+
+  /* platforms */
+  GENERIC_PLATFORM: 'g',
+  NATIVE_PLATFORM: 'native'
+};
+/* eslint-enable */
+
+var _default = constants;
+exports.default = _default;

node_modules/jest-haste-map/build/crawlers/node.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { CrawlerOptions, FileData, InternalHasteMap } from '../types';
+declare const _default: (options: CrawlerOptions) => Promise<{
+    removedFiles: FileData;
+    hasteMap: InternalHasteMap;
+}>;
+export = _default;

node_modules/jest-haste-map/build/crawlers/node.js

@@ -0,0 +1,320 @@
+'use strict';
+
+function path() {
+  const data = _interopRequireWildcard(require('path'));
+
+  path = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _child_process() {
+  const data = require('child_process');
+
+  _child_process = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function fs() {
+  const data = _interopRequireWildcard(require('graceful-fs'));
+
+  fs = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _constants() {
+  const data = _interopRequireDefault(require('../constants'));
+
+  _constants = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function fastPath() {
+  const data = _interopRequireWildcard(require('../lib/fast_path'));
+
+  fastPath = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+function _getRequireWildcardCache() {
+  if (typeof WeakMap !== 'function') return null;
+  var cache = new WeakMap();
+  _getRequireWildcardCache = function () {
+    return cache;
+  };
+  return cache;
+}
+
+function _interopRequireWildcard(obj) {
+  if (obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
+    return {default: obj};
+  }
+  var cache = _getRequireWildcardCache();
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor
+        ? Object.getOwnPropertyDescriptor(obj, key)
+        : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+async function hasNativeFindSupport(forceNodeFilesystemAPI) {
+  if (forceNodeFilesystemAPI) {
+    return false;
+  }
+
+  try {
+    return await new Promise(resolve => {
+      // Check the find binary supports the non-POSIX -iname parameter wrapped in parens.
+      const args = [
+        '.',
+        '-type',
+        'f',
+        '(',
+        '-iname',
+        '*.ts',
+        '-o',
+        '-iname',
+        '*.js',
+        ')'
+      ];
+      const child = (0, _child_process().spawn)('find', args, {
+        cwd: __dirname
+      });
+      child.on('error', () => {
+        resolve(false);
+      });
+      child.on('exit', code => {
+        resolve(code === 0);
+      });
+    });
+  } catch {
+    return false;
+  }
+}
+
+function find(roots, extensions, ignore, callback) {
+  const result = [];
+  let activeCalls = 0;
+
+  function search(directory) {
+    activeCalls++;
+    fs().readdir(
+      directory,
+      {
+        withFileTypes: true
+      },
+      (err, entries) => {
+        activeCalls--;
+
+        if (err) {
+          callback(result);
+          return;
+        } // node < v10.10 does not support the withFileTypes option, and
+        // entry will be a string.
+
+        entries.forEach(entry => {
+          const file = path().join(
+            directory,
+            typeof entry === 'string' ? entry : entry.name
+          );
+
+          if (ignore(file)) {
+            return;
+          }
+
+          if (typeof entry !== 'string') {
+            if (entry.isSymbolicLink()) {
+              return;
+            }
+
+            if (entry.isDirectory()) {
+              search(file);
+              return;
+            }
+          }
+
+          activeCalls++;
+          fs().lstat(file, (err, stat) => {
+            activeCalls--; // This logic is unnecessary for node > v10.10, but leaving it in
+            // since we need it for backwards-compatibility still.
+
+            if (!err && stat && !stat.isSymbolicLink()) {
+              if (stat.isDirectory()) {
+                search(file);
+              } else {
+                const ext = path().extname(file).substr(1);
+
+                if (extensions.indexOf(ext) !== -1) {
+                  result.push([file, stat.mtime.getTime(), stat.size]);
+                }
+              }
+            }
+
+            if (activeCalls === 0) {
+              callback(result);
+            }
+          });
+        });
+
+        if (activeCalls === 0) {
+          callback(result);
+        }
+      }
+    );
+  }
+
+  if (roots.length > 0) {
+    roots.forEach(search);
+  } else {
+    callback(result);
+  }
+}
+
+function findNative(roots, extensions, ignore, callback) {
+  const args = Array.from(roots);
+  args.push('-type', 'f');
+
+  if (extensions.length) {
+    args.push('(');
+  }
+
+  extensions.forEach((ext, index) => {
+    if (index) {
+      args.push('-o');
+    }
+
+    args.push('-iname');
+    args.push('*.' + ext);
+  });
+
+  if (extensions.length) {
+    args.push(')');
+  }
+
+  const child = (0, _child_process().spawn)('find', args);
+  let stdout = '';
+
+  if (child.stdout === null) {
+    throw new Error(
+      'stdout is null - this should never happen. Please open up an issue at https://github.com/facebook/jest'
+    );
+  }
+
+  child.stdout.setEncoding('utf-8');
+  child.stdout.on('data', data => (stdout += data));
+  child.stdout.on('close', () => {
+    const lines = stdout
+      .trim()
+      .split('\n')
+      .filter(x => !ignore(x));
+    const result = [];
+    let count = lines.length;
+
+    if (!count) {
+      callback([]);
+    } else {
+      lines.forEach(path => {
+        fs().stat(path, (err, stat) => {
+          if (!err && stat) {
+            result.push([path, stat.mtime.getTime(), stat.size]);
+          }
+
+          if (--count === 0) {
+            callback(result);
+          }
+        });
+      });
+    }
+  });
+}
+
+module.exports = async function nodeCrawl(options) {
+  const {
+    data,
+    extensions,
+    forceNodeFilesystemAPI,
+    ignore,
+    rootDir,
+    roots
+  } = options;
+  const useNativeFind = await hasNativeFindSupport(forceNodeFilesystemAPI);
+  return new Promise(resolve => {
+    const callback = list => {
+      const files = new Map();
+      const removedFiles = new Map(data.files);
+      list.forEach(fileData => {
+        const [filePath, mtime, size] = fileData;
+        const relativeFilePath = fastPath().relative(rootDir, filePath);
+        const existingFile = data.files.get(relativeFilePath);
+
+        if (
+          existingFile &&
+          existingFile[_constants().default.MTIME] === mtime
+        ) {
+          files.set(relativeFilePath, existingFile);
+        } else {
+          // See ../constants.js; SHA-1 will always be null and fulfilled later.
+          files.set(relativeFilePath, ['', mtime, size, 0, '', null]);
+        }
+
+        removedFiles.delete(relativeFilePath);
+      });
+      data.files = files;
+      resolve({
+        hasteMap: data,
+        removedFiles
+      });
+    };
+
+    if (useNativeFind) {
+      findNative(roots, extensions, ignore, callback);
+    } else {
+      find(roots, extensions, ignore, callback);
+    }
+  });
+};

node_modules/jest-haste-map/build/crawlers/watchman.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { CrawlerOptions, FileData, InternalHasteMap } from '../types';
+declare const _default: (options: CrawlerOptions) => Promise<{
+    changedFiles?: FileData | undefined;
+    removedFiles: FileData;
+    hasteMap: InternalHasteMap;
+}>;
+export = _default;

node_modules/jest-haste-map/build/crawlers/watchman.js

@@ -0,0 +1,327 @@
+'use strict';
+
+function path() {
+  const data = _interopRequireWildcard(require('path'));
+
+  path = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _fbWatchman() {
+  const data = _interopRequireDefault(require('fb-watchman'));
+
+  _fbWatchman = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function fastPath() {
+  const data = _interopRequireWildcard(require('../lib/fast_path'));
+
+  fastPath = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _normalizePathSep() {
+  const data = _interopRequireDefault(require('../lib/normalizePathSep'));
+
+  _normalizePathSep = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _constants() {
+  const data = _interopRequireDefault(require('../constants'));
+
+  _constants = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+function _getRequireWildcardCache() {
+  if (typeof WeakMap !== 'function') return null;
+  var cache = new WeakMap();
+  _getRequireWildcardCache = function () {
+    return cache;
+  };
+  return cache;
+}
+
+function _interopRequireWildcard(obj) {
+  if (obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
+    return {default: obj};
+  }
+  var cache = _getRequireWildcardCache();
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor
+        ? Object.getOwnPropertyDescriptor(obj, key)
+        : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const watchmanURL = 'https://facebook.github.io/watchman/docs/troubleshooting';
+
+function WatchmanError(error) {
+  error.message =
+    `Watchman error: ${error.message.trim()}. Make sure watchman ` +
+    `is running for this project. See ${watchmanURL}.`;
+  return error;
+}
+
+module.exports = async function watchmanCrawl(options) {
+  const fields = ['name', 'exists', 'mtime_ms', 'size'];
+  const {data, extensions, ignore, rootDir, roots} = options;
+  const defaultWatchExpression = [
+    'allof',
+    ['type', 'f'],
+    ['anyof', ...extensions.map(extension => ['suffix', extension])]
+  ];
+  const clocks = data.clocks;
+  const client = new (_fbWatchman().default.Client)();
+  let clientError;
+  client.on('error', error => (clientError = WatchmanError(error))); // TODO: type better than `any`
+
+  const cmd = (...args) =>
+    new Promise((resolve, reject) =>
+      client.command(args, (error, result) =>
+        error ? reject(WatchmanError(error)) : resolve(result)
+      )
+    );
+
+  if (options.computeSha1) {
+    const {capabilities} = await cmd('list-capabilities');
+
+    if (capabilities.indexOf('field-content.sha1hex') !== -1) {
+      fields.push('content.sha1hex');
+    }
+  }
+
+  async function getWatchmanRoots(roots) {
+    const watchmanRoots = new Map();
+    await Promise.all(
+      roots.map(async root => {
+        const response = await cmd('watch-project', root);
+        const existing = watchmanRoots.get(response.watch); // A root can only be filtered if it was never seen with a
+        // relative_path before.
+
+        const canBeFiltered = !existing || existing.length > 0;
+
+        if (canBeFiltered) {
+          if (response.relative_path) {
+            watchmanRoots.set(
+              response.watch,
+              (existing || []).concat(response.relative_path)
+            );
+          } else {
+            // Make the filter directories an empty array to signal that this
+            // root was already seen and needs to be watched for all files or
+            // directories.
+            watchmanRoots.set(response.watch, []);
+          }
+        }
+      })
+    );
+    return watchmanRoots;
+  }
+
+  async function queryWatchmanForDirs(rootProjectDirMappings) {
+    const files = new Map();
+    let isFresh = false;
+    await Promise.all(
+      Array.from(rootProjectDirMappings).map(
+        async ([root, directoryFilters]) => {
+          const expression = Array.from(defaultWatchExpression);
+          const glob = [];
+
+          if (directoryFilters.length > 0) {
+            expression.push([
+              'anyof',
+              ...directoryFilters.map(dir => ['dirname', dir])
+            ]);
+
+            for (const directory of directoryFilters) {
+              for (const extension of extensions) {
+                glob.push(`${directory}/**/*.${extension}`);
+              }
+            }
+          } else {
+            for (const extension of extensions) {
+              glob.push(`**/*.${extension}`);
+            }
+          }
+
+          const relativeRoot = fastPath().relative(rootDir, root);
+          const query = clocks.has(relativeRoot) // Use the `since` generator if we have a clock available
+            ? {
+                expression,
+                fields,
+                since: clocks.get(relativeRoot)
+              } // Otherwise use the `glob` filter
+            : {
+                expression,
+                fields,
+                glob,
+                glob_includedotfiles: true
+              };
+          const response = await cmd('query', root, query);
+
+          if ('warning' in response) {
+            console.warn('watchman warning: ', response.warning);
+          }
+
+          isFresh = isFresh || response.is_fresh_instance;
+          files.set(root, response);
+        }
+      )
+    );
+    return {
+      files,
+      isFresh
+    };
+  }
+
+  let files = data.files;
+  let removedFiles = new Map();
+  const changedFiles = new Map();
+  let watchmanFiles;
+  let isFresh = false;
+
+  try {
+    const watchmanRoots = await getWatchmanRoots(roots);
+    const watchmanFileResults = await queryWatchmanForDirs(watchmanRoots); // Reset the file map if watchman was restarted and sends us a list of
+    // files.
+
+    if (watchmanFileResults.isFresh) {
+      files = new Map();
+      removedFiles = new Map(data.files);
+      isFresh = true;
+    }
+
+    watchmanFiles = watchmanFileResults.files;
+  } finally {
+    client.end();
+  }
+
+  if (clientError) {
+    throw clientError;
+  } // TODO: remove non-null
+
+  for (const [watchRoot, response] of watchmanFiles) {
+    const fsRoot = (0, _normalizePathSep().default)(watchRoot);
+    const relativeFsRoot = fastPath().relative(rootDir, fsRoot);
+    clocks.set(relativeFsRoot, response.clock);
+
+    for (const fileData of response.files) {
+      const filePath =
+        fsRoot + path().sep + (0, _normalizePathSep().default)(fileData.name);
+      const relativeFilePath = fastPath().relative(rootDir, filePath);
+      const existingFileData = data.files.get(relativeFilePath); // If watchman is fresh, the removed files map starts with all files
+      // and we remove them as we verify they still exist.
+
+      if (isFresh && existingFileData && fileData.exists) {
+        removedFiles.delete(relativeFilePath);
+      }
+
+      if (!fileData.exists) {
+        // No need to act on files that do not exist and were not tracked.
+        if (existingFileData) {
+          files.delete(relativeFilePath); // If watchman is not fresh, we will know what specific files were
+          // deleted since we last ran and can track only those files.
+
+          if (!isFresh) {
+            removedFiles.set(relativeFilePath, existingFileData);
+          }
+        }
+      } else if (!ignore(filePath)) {
+        const mtime =
+          typeof fileData.mtime_ms === 'number'
+            ? fileData.mtime_ms
+            : fileData.mtime_ms.toNumber();
+        const size = fileData.size;
+        let sha1hex = fileData['content.sha1hex'];
+
+        if (typeof sha1hex !== 'string' || sha1hex.length !== 40) {
+          sha1hex = null;
+        }
+
+        let nextData;
+
+        if (
+          existingFileData &&
+          existingFileData[_constants().default.MTIME] === mtime
+        ) {
+          nextData = existingFileData;
+        } else if (
+          existingFileData &&
+          sha1hex &&
+          existingFileData[_constants().default.SHA1] === sha1hex
+        ) {
+          nextData = [
+            existingFileData[0],
+            mtime,
+            existingFileData[2],
+            existingFileData[3],
+            existingFileData[4],
+            existingFileData[5]
+          ];
+        } else {
+          // See ../constants.ts
+          nextData = ['', mtime, size, 0, '', sha1hex];
+        }
+
+        files.set(relativeFilePath, nextData);
+        changedFiles.set(relativeFilePath, nextData);
+      }
+    }
+  }
+
+  data.files = files;
+  return {
+    changedFiles: isFresh ? undefined : changedFiles,
+    hasteMap: data,
+    removedFiles
+  };
+};

node_modules/jest-haste-map/build/getMockName.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+declare const getMockName: (filePath: string) => string;
+export default getMockName;

node_modules/jest-haste-map/build/getMockName.js

@@ -0,0 +1,76 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+function path() {
+  const data = _interopRequireWildcard(require('path'));
+
+  path = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _getRequireWildcardCache() {
+  if (typeof WeakMap !== 'function') return null;
+  var cache = new WeakMap();
+  _getRequireWildcardCache = function () {
+    return cache;
+  };
+  return cache;
+}
+
+function _interopRequireWildcard(obj) {
+  if (obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
+    return {default: obj};
+  }
+  var cache = _getRequireWildcardCache();
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor
+        ? Object.getOwnPropertyDescriptor(obj, key)
+        : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const MOCKS_PATTERN = path().sep + '__mocks__' + path().sep;
+
+const getMockName = filePath => {
+  const mockPath = filePath.split(MOCKS_PATTERN)[1];
+  return mockPath
+    .substring(0, mockPath.lastIndexOf(path().extname(mockPath)))
+    .replace(/\\/g, '/');
+};
+
+var _default = getMockName;
+exports.default = _default;

node_modules/jest-haste-map/build/index.d.ts

@@ -0,0 +1,187 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import type { Config } from '@jest/types';
+import H from './constants';
+import HasteFS from './HasteFS';
+import HasteModuleMap, { SerializableModuleMap as HasteSerializableModuleMap } from './ModuleMap';
+import type { ChangeEvent, HasteRegExp, InternalHasteMap, HasteMap as InternalHasteMapObject } from './types';
+declare type HType = typeof H;
+declare type Options = {
+    cacheDirectory?: string;
+    computeDependencies?: boolean;
+    computeSha1?: boolean;
+    console?: Console;
+    dependencyExtractor?: string | null;
+    extensions: Array<string>;
+    forceNodeFilesystemAPI?: boolean;
+    hasteImplModulePath?: string;
+    ignorePattern?: HasteRegExp;
+    maxWorkers: number;
+    mocksPattern?: string;
+    name: string;
+    platforms: Array<string>;
+    resetCache?: boolean;
+    retainAllFiles: boolean;
+    rootDir: string;
+    roots: Array<string>;
+    skipPackageJson?: boolean;
+    throwOnModuleCollision?: boolean;
+    useWatchman?: boolean;
+    watch?: boolean;
+};
+declare namespace HasteMap {
+    type ModuleMap = HasteModuleMap;
+    type SerializableModuleMap = HasteSerializableModuleMap;
+    type FS = HasteFS;
+    type HasteMapObject = InternalHasteMapObject;
+    type HasteChangeEvent = ChangeEvent;
+}
+/**
+ * HasteMap is a JavaScript implementation of Facebook's haste module system.
+ *
+ * This implementation is inspired by https://github.com/facebook/node-haste
+ * and was built with for high-performance in large code repositories with
+ * hundreds of thousands of files. This implementation is scalable and provides
+ * predictable performance.
+ *
+ * Because the haste map creation and synchronization is critical to startup
+ * performance and most tasks are blocked by I/O this class makes heavy use of
+ * synchronous operations. It uses worker processes for parallelizing file
+ * access and metadata extraction.
+ *
+ * The data structures created by `jest-haste-map` can be used directly from the
+ * cache without further processing. The metadata objects in the `files` and
+ * `map` objects contain cross-references: a metadata object from one can look
+ * up the corresponding metadata object in the other map. Note that in most
+ * projects, the number of files will be greater than the number of haste
+ * modules one module can refer to many files based on platform extensions.
+ *
+ * type HasteMap = {
+ *   clocks: WatchmanClocks,
+ *   files: {[filepath: string]: FileMetaData},
+ *   map: {[id: string]: ModuleMapItem},
+ *   mocks: {[id: string]: string},
+ * }
+ *
+ * // Watchman clocks are used for query synchronization and file system deltas.
+ * type WatchmanClocks = {[filepath: string]: string};
+ *
+ * type FileMetaData = {
+ *   id: ?string, // used to look up module metadata objects in `map`.
+ *   mtime: number, // check for outdated files.
+ *   size: number, // size of the file in bytes.
+ *   visited: boolean, // whether the file has been parsed or not.
+ *   dependencies: Array<string>, // all relative dependencies of this file.
+ *   sha1: ?string, // SHA-1 of the file, if requested via options.
+ * };
+ *
+ * // Modules can be targeted to a specific platform based on the file name.
+ * // Example: platform.ios.js and Platform.android.js will both map to the same
+ * // `Platform` module. The platform should be specified during resolution.
+ * type ModuleMapItem = {[platform: string]: ModuleMetaData};
+ *
+ * //
+ * type ModuleMetaData = {
+ *   path: string, // the path to look up the file object in `files`.
+ *   type: string, // the module type (either `package` or `module`).
+ * };
+ *
+ * Note that the data structures described above are conceptual only. The actual
+ * implementation uses arrays and constant keys for metadata storage. Instead of
+ * `{id: 'flatMap', mtime: 3421, size: 42, visited: true, dependencies: []}` the real
+ * representation is similar to `['flatMap', 3421, 42, 1, []]` to save storage space
+ * and reduce parse and write time of a big JSON blob.
+ *
+ * The HasteMap is created as follows:
+ *  1. read data from the cache or create an empty structure.
+ *
+ *  2. crawl the file system.
+ *     * empty cache: crawl the entire file system.
+ *     * cache available:
+ *       * if watchman is available: get file system delta changes.
+ *       * if watchman is unavailable: crawl the entire file system.
+ *     * build metadata objects for every file. This builds the `files` part of
+ *       the `HasteMap`.
+ *
+ *  3. parse and extract metadata from changed files.
+ *     * this is done in parallel over worker processes to improve performance.
+ *     * the worst case is to parse all files.
+ *     * the best case is no file system access and retrieving all data from
+ *       the cache.
+ *     * the average case is a small number of changed files.
+ *
+ *  4. serialize the new `HasteMap` in a cache file.
+ *     Worker processes can directly access the cache through `HasteMap.read()`.
+ *
+ */
+declare class HasteMap extends EventEmitter {
+    private _buildPromise;
+    private _cachePath;
+    private _changeInterval?;
+    private _console;
+    private _options;
+    private _watchers;
+    private _worker;
+    constructor(options: Options);
+    static getCacheFilePath(tmpdir: Config.Path, name: string, ...extra: Array<string>): string;
+    getCacheFilePath(): string;
+    build(): Promise<InternalHasteMapObject>;
+    /**
+     * 1. read data from the cache or create an empty structure.
+     */
+    read(): InternalHasteMap;
+    readModuleMap(): HasteModuleMap;
+    /**
+     * 2. crawl the file system.
+     */
+    private _buildFileMap;
+    /**
+     * 3. parse and extract metadata from changed files.
+     */
+    private _processFile;
+    private _buildHasteMap;
+    private _cleanup;
+    /**
+     * 4. serialize the new `HasteMap` in a cache file.
+     */
+    private _persist;
+    /**
+     * Creates workers or parses files and extracts metadata in-process.
+     */
+    private _getWorker;
+    private _crawl;
+    /**
+     * Watch mode
+     */
+    private _watch;
+    /**
+     * This function should be called when the file under `filePath` is removed
+     * or changed. When that happens, we want to figure out if that file was
+     * part of a group of files that had the same ID. If it was, we want to
+     * remove it from the group. Furthermore, if there is only one file
+     * remaining in the group, then we want to restore that single file as the
+     * correct resolution for its ID, and cleanup the duplicates index.
+     */
+    private _recoverDuplicates;
+    end(): Promise<void>;
+    /**
+     * Helpers
+     */
+    private _ignore;
+    private _createEmptyMap;
+    static H: HType;
+    static DuplicateError: typeof DuplicateError;
+    static ModuleMap: typeof HasteModuleMap;
+}
+declare class DuplicateError extends Error {
+    mockPath1: string;
+    mockPath2: string;
+    constructor(mockPath1: string, mockPath2: string);
+}
+export = HasteMap;

node_modules/jest-haste-map/build/lib/FSEventsWatcher.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { Matcher } from 'anymatch';
+/**
+ * Export `FSEventsWatcher` class.
+ * Watches `dir`.
+ */
+declare class FSEventsWatcher extends EventEmitter {
+    readonly root: string;
+    readonly ignored?: Matcher;
+    readonly glob: Array<string>;
+    readonly dot: boolean;
+    readonly hasIgnore: boolean;
+    readonly doIgnore: (path: string) => boolean;
+    readonly fsEventsWatchStopper: () => Promise<void>;
+    private _tracked;
+    static isSupported(): boolean;
+    private static normalizeProxy;
+    private static recReaddir;
+    constructor(dir: string, opts: {
+        root: string;
+        ignored?: Matcher;
+        glob: string | Array<string>;
+        dot: boolean;
+    });
+    /**
+     * End watching.
+     */
+    close(callback?: () => void): void;
+    private isFileIncluded;
+    private handleEvent;
+    /**
+     * Emit events.
+     */
+    private _emit;
+}
+export = FSEventsWatcher;

node_modules/jest-haste-map/build/lib/FSEventsWatcher.js

@@ -0,0 +1,295 @@
+'use strict';
+
+function path() {
+  const data = _interopRequireWildcard(require('path'));
+
+  path = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _events() {
+  const data = require('events');
+
+  _events = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function fs() {
+  const data = _interopRequireWildcard(require('graceful-fs'));
+
+  fs = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _anymatch() {
+  const data = _interopRequireDefault(require('anymatch'));
+
+  _anymatch = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _micromatch() {
+  const data = _interopRequireDefault(require('micromatch'));
+
+  _micromatch = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _walker() {
+  const data = _interopRequireDefault(require('walker'));
+
+  _walker = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+function _getRequireWildcardCache() {
+  if (typeof WeakMap !== 'function') return null;
+  var cache = new WeakMap();
+  _getRequireWildcardCache = function () {
+    return cache;
+  };
+  return cache;
+}
+
+function _interopRequireWildcard(obj) {
+  if (obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
+    return {default: obj};
+  }
+  var cache = _getRequireWildcardCache();
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor
+        ? Object.getOwnPropertyDescriptor(obj, key)
+        : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+// eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
+// @ts-ignore: this is for CI which runs linux and might not have this
+let fsevents = null;
+
+try {
+  fsevents = require('fsevents');
+} catch {
+  // Optional dependency, only supported on Darwin.
+}
+
+const CHANGE_EVENT = 'change';
+const DELETE_EVENT = 'delete';
+const ADD_EVENT = 'add';
+const ALL_EVENT = 'all';
+
+/**
+ * Export `FSEventsWatcher` class.
+ * Watches `dir`.
+ */
+class FSEventsWatcher extends _events().EventEmitter {
+  static isSupported() {
+    return fsevents !== null;
+  }
+
+  static normalizeProxy(callback) {
+    return (filepath, stats) => callback(path().normalize(filepath), stats);
+  }
+
+  static recReaddir(
+    dir,
+    dirCallback,
+    fileCallback,
+    endCallback,
+    errorCallback,
+    ignored
+  ) {
+    (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', () => {
+        endCallback();
+      });
+  }
+
+  constructor(dir, opts) {
+    if (!fsevents) {
+      throw new Error(
+        '`fsevents` unavailable (this watcher can only be used on Darwin)'
+      );
+    }
+
+    super();
+
+    _defineProperty(this, 'root', void 0);
+
+    _defineProperty(this, 'ignored', void 0);
+
+    _defineProperty(this, 'glob', void 0);
+
+    _defineProperty(this, 'dot', void 0);
+
+    _defineProperty(this, 'hasIgnore', void 0);
+
+    _defineProperty(this, 'doIgnore', void 0);
+
+    _defineProperty(this, 'fsEventsWatchStopper', void 0);
+
+    _defineProperty(this, '_tracked', void 0);
+
+    this.dot = opts.dot || false;
+    this.ignored = opts.ignored;
+    this.glob = Array.isArray(opts.glob) ? opts.glob : [opts.glob];
+    this.hasIgnore =
+      Boolean(opts.ignored) && !(Array.isArray(opts) && opts.length > 0);
+    this.doIgnore = opts.ignored
+      ? (0, _anymatch().default)(opts.ignored)
+      : () => false;
+    this.root = path().resolve(dir);
+    this.fsEventsWatchStopper = fsevents.watch(
+      this.root,
+      this.handleEvent.bind(this)
+    );
+    this._tracked = new Set();
+    FSEventsWatcher.recReaddir(
+      this.root,
+      filepath => {
+        this._tracked.add(filepath);
+      },
+      filepath => {
+        this._tracked.add(filepath);
+      },
+      this.emit.bind(this, 'ready'),
+      this.emit.bind(this, 'error'),
+      this.ignored
+    );
+  }
+  /**
+   * End watching.
+   */
+
+  close(callback) {
+    this.fsEventsWatchStopper().then(() => {
+      this.removeAllListeners();
+
+      if (typeof callback === 'function') {
+        process.nextTick(callback.bind(null, null, true));
+      }
+    });
+  }
+
+  isFileIncluded(relativePath) {
+    if (this.doIgnore(relativePath)) {
+      return false;
+    }
+
+    return this.glob.length
+      ? (0, _micromatch().default)([relativePath], this.glob, {
+          dot: this.dot
+        }).length > 0
+      : this.dot ||
+          (0, _micromatch().default)([relativePath], '**/*').length > 0;
+  }
+
+  handleEvent(filepath) {
+    const relativePath = path().relative(this.root, filepath);
+
+    if (!this.isFileIncluded(relativePath)) {
+      return;
+    }
+
+    fs().lstat(filepath, (error, stat) => {
+      if (error && error.code !== 'ENOENT') {
+        this.emit('error', error);
+        return;
+      }
+
+      if (error) {
+        // Ignore files that aren't tracked and don't exist.
+        if (!this._tracked.has(filepath)) {
+          return;
+        }
+
+        this._emit(DELETE_EVENT, relativePath);
+
+        this._tracked.delete(filepath);
+
+        return;
+      }
+
+      if (this._tracked.has(filepath)) {
+        this._emit(CHANGE_EVENT, relativePath, stat);
+      } else {
+        this._tracked.add(filepath);
+
+        this._emit(ADD_EVENT, relativePath, stat);
+      }
+    });
+  }
+  /**
+   * Emit events.
+   */
+
+  _emit(type, file, stat) {
+    this.emit(type, file, this.root, stat);
+    this.emit(ALL_EVENT, type, file, this.root, stat);
+  }
+}
+
+module.exports = FSEventsWatcher;

node_modules/jest-haste-map/build/lib/WatchmanWatcher.js

@@ -0,0 +1,442 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = WatchmanWatcher;
+
+function _path() {
+  const data = _interopRequireDefault(require('path'));
+
+  _path = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _assert() {
+  const data = _interopRequireDefault(require('assert'));
+
+  _assert = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _events() {
+  const data = require('events');
+
+  _events = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function fs() {
+  const data = _interopRequireWildcard(require('graceful-fs'));
+
+  fs = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _fbWatchman() {
+  const data = _interopRequireDefault(require('fb-watchman'));
+
+  _fbWatchman = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _common() {
+  const data = _interopRequireDefault(require('sane/src/common'));
+
+  _common = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _recrawlWarningDedupe() {
+  const data = _interopRequireDefault(
+    require('sane/src/utils/recrawl-warning-dedupe')
+  );
+
+  _recrawlWarningDedupe = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _getRequireWildcardCache() {
+  if (typeof WeakMap !== 'function') return null;
+  var cache = new WeakMap();
+  _getRequireWildcardCache = function () {
+    return cache;
+  };
+  return cache;
+}
+
+function _interopRequireWildcard(obj) {
+  if (obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
+    return {default: obj};
+  }
+  var cache = _getRequireWildcardCache();
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor
+        ? Object.getOwnPropertyDescriptor(obj, key)
+        : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const CHANGE_EVENT = _common().default.CHANGE_EVENT;
+
+const DELETE_EVENT = _common().default.DELETE_EVENT;
+
+const ADD_EVENT = _common().default.ADD_EVENT;
+
+const ALL_EVENT = _common().default.ALL_EVENT;
+
+const SUB_NAME = 'sane-sub';
+/**
+ * Watches `dir`.
+ *
+ * @class PollWatcher
+ * @param String dir
+ * @param {Object} opts
+ * @public
+ */
+
+function WatchmanWatcher(dir, opts) {
+  _common().default.assignOptions(this, opts);
+
+  this.root = _path().default.resolve(dir);
+  this.init();
+} // eslint-disable-next-line no-proto
+
+WatchmanWatcher.prototype.__proto__ = _events().EventEmitter.prototype;
+/**
+ * Run the watchman `watch` command on the root and subscribe to changes.
+ *
+ * @private
+ */
+
+WatchmanWatcher.prototype.init = function () {
+  if (this.client) {
+    this.client.removeAllListeners();
+  }
+
+  const self = this;
+  this.client = new (_fbWatchman().default.Client)();
+  this.client.on('error', error => {
+    self.emit('error', error);
+  });
+  this.client.on('subscription', this.handleChangeEvent.bind(this));
+  this.client.on('end', () => {
+    console.warn('[sane] Warning: Lost connection to watchman, reconnecting..');
+    self.init();
+  });
+  this.watchProjectInfo = null;
+
+  function getWatchRoot() {
+    return self.watchProjectInfo ? self.watchProjectInfo.root : self.root;
+  }
+
+  function onCapability(error, resp) {
+    if (handleError(self, error)) {
+      // The Watchman watcher is unusable on this system, we cannot continue
+      return;
+    }
+
+    handleWarning(resp);
+    self.capabilities = resp.capabilities;
+
+    if (self.capabilities.relative_root) {
+      self.client.command(['watch-project', getWatchRoot()], onWatchProject);
+    } else {
+      self.client.command(['watch', getWatchRoot()], onWatch);
+    }
+  }
+
+  function onWatchProject(error, resp) {
+    if (handleError(self, error)) {
+      return;
+    }
+
+    handleWarning(resp);
+    self.watchProjectInfo = {
+      relativePath: resp.relative_path ? resp.relative_path : '',
+      root: resp.watch
+    };
+    self.client.command(['clock', getWatchRoot()], onClock);
+  }
+
+  function onWatch(error, resp) {
+    if (handleError(self, error)) {
+      return;
+    }
+
+    handleWarning(resp);
+    self.client.command(['clock', getWatchRoot()], onClock);
+  }
+
+  function onClock(error, resp) {
+    if (handleError(self, error)) {
+      return;
+    }
+
+    handleWarning(resp);
+    const options = {
+      fields: ['name', 'exists', 'new'],
+      since: resp.clock
+    }; // If the server has the wildmatch capability available it supports
+    // the recursive **/*.foo style match and we can offload our globs
+    // to the watchman server.  This saves both on data size to be
+    // communicated back to us and compute for evaluating the globs
+    // in our node process.
+
+    if (self.capabilities.wildmatch) {
+      if (self.globs.length === 0) {
+        if (!self.dot) {
+          // Make sure we honor the dot option if even we're not using globs.
+          options.expression = [
+            'match',
+            '**',
+            'wholename',
+            {
+              includedotfiles: false
+            }
+          ];
+        }
+      } else {
+        options.expression = ['anyof'];
+
+        for (const i in self.globs) {
+          options.expression.push([
+            'match',
+            self.globs[i],
+            'wholename',
+            {
+              includedotfiles: self.dot
+            }
+          ]);
+        }
+      }
+    }
+
+    if (self.capabilities.relative_root) {
+      options.relative_root = self.watchProjectInfo.relativePath;
+    }
+
+    self.client.command(
+      ['subscribe', getWatchRoot(), SUB_NAME, options],
+      onSubscribe
+    );
+  }
+
+  function onSubscribe(error, resp) {
+    if (handleError(self, error)) {
+      return;
+    }
+
+    handleWarning(resp);
+    self.emit('ready');
+  }
+
+  self.client.capabilityCheck(
+    {
+      optional: ['wildmatch', 'relative_root']
+    },
+    onCapability
+  );
+};
+/**
+ * Handles a change event coming from the subscription.
+ *
+ * @param {Object} resp
+ * @private
+ */
+
+WatchmanWatcher.prototype.handleChangeEvent = function (resp) {
+  _assert().default.equal(
+    resp.subscription,
+    SUB_NAME,
+    'Invalid subscription event.'
+  );
+
+  if (resp.is_fresh_instance) {
+    this.emit('fresh_instance');
+  }
+
+  if (resp.is_fresh_instance) {
+    this.emit('fresh_instance');
+  }
+
+  if (Array.isArray(resp.files)) {
+    resp.files.forEach(this.handleFileChange, this);
+  }
+};
+/**
+ * Handles a single change event record.
+ *
+ * @param {Object} changeDescriptor
+ * @private
+ */
+
+WatchmanWatcher.prototype.handleFileChange = function (changeDescriptor) {
+  const self = this;
+  let absPath;
+  let relativePath;
+
+  if (this.capabilities.relative_root) {
+    relativePath = changeDescriptor.name;
+    absPath = _path().default.join(
+      this.watchProjectInfo.root,
+      this.watchProjectInfo.relativePath,
+      relativePath
+    );
+  } else {
+    absPath = _path().default.join(this.root, changeDescriptor.name);
+    relativePath = changeDescriptor.name;
+  }
+
+  if (
+    !(self.capabilities.wildmatch && !this.hasIgnore) &&
+    !_common().default.isFileIncluded(
+      this.globs,
+      this.dot,
+      this.doIgnore,
+      relativePath
+    )
+  ) {
+    return;
+  }
+
+  if (!changeDescriptor.exists) {
+    self.emitEvent(DELETE_EVENT, relativePath, self.root);
+  } else {
+    fs().lstat(absPath, (error, stat) => {
+      // Files can be deleted between the event and the lstat call
+      // the most reliable thing to do here is to ignore the event.
+      if (error && error.code === 'ENOENT') {
+        return;
+      }
+
+      if (handleError(self, error)) {
+        return;
+      }
+
+      const eventType = changeDescriptor.new ? ADD_EVENT : CHANGE_EVENT; // Change event on dirs are mostly useless.
+
+      if (!(eventType === CHANGE_EVENT && stat.isDirectory())) {
+        self.emitEvent(eventType, relativePath, self.root, stat);
+      }
+    });
+  }
+};
+/**
+ * Dispatches the event.
+ *
+ * @param {string} eventType
+ * @param {string} filepath
+ * @param {string} root
+ * @param {fs.Stat} stat
+ * @private
+ */
+
+WatchmanWatcher.prototype.emitEvent = function (
+  eventType,
+  filepath,
+  root,
+  stat
+) {
+  this.emit(eventType, filepath, root, stat);
+  this.emit(ALL_EVENT, eventType, filepath, root, stat);
+};
+/**
+ * Closes the watcher.
+ *
+ * @param {function} callback
+ * @private
+ */
+
+WatchmanWatcher.prototype.close = function (callback) {
+  this.client.removeAllListeners();
+  this.client.end();
+  callback && callback(null, true);
+};
+/**
+ * Handles an error and returns true if exists.
+ *
+ * @param {WatchmanWatcher} self
+ * @param {Error} error
+ * @private
+ */
+
+function handleError(self, error) {
+  if (error != null) {
+    self.emit('error', error);
+    return true;
+  } else {
+    return false;
+  }
+}
+/**
+ * Handles a warning in the watchman resp object.
+ *
+ * @param {object} resp
+ * @private
+ */
+
+function handleWarning(resp) {
+  if ('warning' in resp) {
+    if (_recrawlWarningDedupe().default.isRecrawlWarningDupe(resp.warning)) {
+      return true;
+    }
+
+    console.warn(resp.warning);
+    return true;
+  } else {
+    return false;
+  }
+}

node_modules/jest-haste-map/build/lib/dependencyExtractor.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export declare function extract(code: string): Set<string>;

node_modules/jest-haste-map/build/lib/dependencyExtractor.js

@@ -0,0 +1,99 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.extract = extract;
+
+var _isRegExpSupported = _interopRequireDefault(require('./isRegExpSupported'));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+// Negative look behind is only supported in Node 9+
+const NOT_A_DOT = (0, _isRegExpSupported.default)('(?<!\\.\\s*)')
+  ? '(?<!\\.\\s*)'
+  : '(?:^|[^.]\\s*)';
+
+const CAPTURE_STRING_LITERAL = pos => `([\`'"])([^'"\`]*?)(?:\\${pos})`;
+
+const WORD_SEPARATOR = '\\b';
+const LEFT_PARENTHESIS = '\\(';
+const RIGHT_PARENTHESIS = '\\)';
+const WHITESPACE = '\\s*';
+const OPTIONAL_COMMA = '(:?,\\s*)?';
+
+function createRegExp(parts, flags) {
+  return new RegExp(parts.join(''), flags);
+}
+
+function alternatives(...parts) {
+  return `(?:${parts.join('|')})`;
+}
+
+function functionCallStart(...names) {
+  return [
+    NOT_A_DOT,
+    WORD_SEPARATOR,
+    alternatives(...names),
+    WHITESPACE,
+    LEFT_PARENTHESIS,
+    WHITESPACE
+  ];
+}
+
+const BLOCK_COMMENT_RE = /\/\*[^]*?\*\//g;
+const LINE_COMMENT_RE = /\/\/.*/g;
+const REQUIRE_OR_DYNAMIC_IMPORT_RE = createRegExp(
+  [
+    ...functionCallStart('require', 'import'),
+    CAPTURE_STRING_LITERAL(1),
+    WHITESPACE,
+    OPTIONAL_COMMA,
+    RIGHT_PARENTHESIS
+  ],
+  'g'
+);
+const IMPORT_OR_EXPORT_RE = createRegExp(
+  [
+    '\\b(?:import|export)\\s+(?!type(?:of)?\\s+)(?:[^\'"]+\\s+from\\s+)?',
+    CAPTURE_STRING_LITERAL(1)
+  ],
+  'g'
+);
+const JEST_EXTENSIONS_RE = createRegExp(
+  [
+    ...functionCallStart(
+      'jest\\s*\\.\\s*(?:requireActual|requireMock|genMockFromModule|createMockFromModule)'
+    ),
+    CAPTURE_STRING_LITERAL(1),
+    WHITESPACE,
+    OPTIONAL_COMMA,
+    RIGHT_PARENTHESIS
+  ],
+  'g'
+);
+
+function extract(code) {
+  const dependencies = new Set();
+
+  const addDependency = (match, _, dep) => {
+    dependencies.add(dep);
+    return match;
+  };
+
+  code
+    .replace(BLOCK_COMMENT_RE, '')
+    .replace(LINE_COMMENT_RE, '')
+    .replace(IMPORT_OR_EXPORT_RE, addDependency)
+    .replace(REQUIRE_OR_DYNAMIC_IMPORT_RE, addDependency)
+    .replace(JEST_EXTENSIONS_RE, addDependency);
+  return dependencies;
+}

node_modules/jest-haste-map/build/lib/fast_path.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export declare function relative(rootDir: string, filename: string): string;
+export declare function resolve(rootDir: string, relativeFilename: string): string;

node_modules/jest-haste-map/build/lib/fast_path.js

@@ -0,0 +1,81 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.relative = relative;
+exports.resolve = resolve;
+
+function path() {
+  const data = _interopRequireWildcard(require('path'));
+
+  path = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _getRequireWildcardCache() {
+  if (typeof WeakMap !== 'function') return null;
+  var cache = new WeakMap();
+  _getRequireWildcardCache = function () {
+    return cache;
+  };
+  return cache;
+}
+
+function _interopRequireWildcard(obj) {
+  if (obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
+    return {default: obj};
+  }
+  var cache = _getRequireWildcardCache();
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor
+        ? Object.getOwnPropertyDescriptor(obj, key)
+        : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+// rootDir and filename must be absolute paths (resolved)
+function relative(rootDir, filename) {
+  return filename.indexOf(rootDir + path().sep) === 0
+    ? filename.substr(rootDir.length + 1)
+    : path().relative(rootDir, filename);
+}
+
+const INDIRECTION_FRAGMENT = '..' + path().sep; // rootDir must be an absolute path and relativeFilename must be simple
+// (e.g.: foo/bar or ../foo/bar, but never ./foo or foo/../bar)
+
+function resolve(rootDir, relativeFilename) {
+  return relativeFilename.indexOf(INDIRECTION_FRAGMENT) === 0
+    ? path().resolve(rootDir, relativeFilename)
+    : rootDir + path().sep + relativeFilename;
+}

node_modules/jest-haste-map/build/lib/getPlatformExtension.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export default function getPlatformExtension(file: string, platforms?: Array<string>): string | null;

node_modules/jest-haste-map/build/lib/getPlatformExtension.js

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = getPlatformExtension;
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const SUPPORTED_PLATFORM_EXTS = new Set(['android', 'ios', 'native', 'web']); // Extract platform extension: index.ios.js -> ios
+
+function getPlatformExtension(file, platforms) {
+  const last = file.lastIndexOf('.');
+  const secondToLast = file.lastIndexOf('.', last - 1);
+
+  if (secondToLast === -1) {
+    return null;
+  }
+
+  const platform = file.substring(secondToLast + 1, last); // If an overriding platform array is passed, check that first
+
+  if (platforms && platforms.indexOf(platform) !== -1) {
+    return platform;
+  }
+
+  return SUPPORTED_PLATFORM_EXTS.has(platform) ? platform : null;
+}

node_modules/jest-haste-map/build/lib/isRegExpSupported.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export default function isRegExpSupported(value: string): boolean;

node_modules/jest-haste-map/build/lib/isRegExpSupported.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = isRegExpSupported;
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+function isRegExpSupported(value) {
+  try {
+    // eslint-disable-next-line no-new
+    new RegExp(value);
+    return true;
+  } catch {
+    return false;
+  }
+}

node_modules/jest-haste-map/build/lib/normalizePathSep.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+declare let normalizePathSep: (string: string) => string;
+export default normalizePathSep;

node_modules/jest-haste-map/build/lib/normalizePathSep.js

@@ -0,0 +1,75 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+function path() {
+  const data = _interopRequireWildcard(require('path'));
+
+  path = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _getRequireWildcardCache() {
+  if (typeof WeakMap !== 'function') return null;
+  var cache = new WeakMap();
+  _getRequireWildcardCache = function () {
+    return cache;
+  };
+  return cache;
+}
+
+function _interopRequireWildcard(obj) {
+  if (obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
+    return {default: obj};
+  }
+  var cache = _getRequireWildcardCache();
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor
+        ? Object.getOwnPropertyDescriptor(obj, key)
+        : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+let normalizePathSep;
+
+if (path().sep === '/') {
+  normalizePathSep = filePath => filePath;
+} else {
+  normalizePathSep = filePath => filePath.replace(/\//g, path().sep);
+}
+
+var _default = normalizePathSep;
+exports.default = _default;

node_modules/jest-haste-map/build/types.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/// <reference types="node" />
+import type { Stats } from 'graceful-fs';
+import type { Config } from '@jest/types';
+import type ModuleMap from './ModuleMap';
+import type HasteFS from './HasteFS';
+export declare type IgnoreMatcher = (item: string) => boolean;
+export declare type WorkerMessage = {
+    computeDependencies: boolean;
+    computeSha1: boolean;
+    dependencyExtractor?: string | null;
+    rootDir: string;
+    filePath: string;
+    hasteImplModulePath?: string;
+};
+export declare type WorkerMetadata = {
+    dependencies: Array<string> | undefined | null;
+    id: string | undefined | null;
+    module: ModuleMetaData | undefined | null;
+    sha1: string | undefined | null;
+};
+export declare type CrawlerOptions = {
+    computeSha1: boolean;
+    data: InternalHasteMap;
+    extensions: Array<string>;
+    forceNodeFilesystemAPI: boolean;
+    ignore: IgnoreMatcher;
+    rootDir: string;
+    roots: Array<string>;
+};
+export declare type HasteImpl = {
+    getHasteName(filePath: Config.Path): string | undefined;
+};
+export declare type FileData = Map<Config.Path, FileMetaData>;
+export declare type FileMetaData = [string, number, number, 0 | 1, string, string | null | undefined];
+export declare type MockData = Map<string, Config.Path>;
+export declare type ModuleMapData = Map<string, ModuleMapItem>;
+export declare type WatchmanClocks = Map<Config.Path, string>;
+export declare type HasteRegExp = RegExp | ((str: string) => boolean);
+export declare type DuplicatesSet = Map<string, /* type */ number>;
+export declare type DuplicatesIndex = Map<string, Map<string, DuplicatesSet>>;
+export declare type InternalHasteMap = {
+    clocks: WatchmanClocks;
+    duplicates: DuplicatesIndex;
+    files: FileData;
+    map: ModuleMapData;
+    mocks: MockData;
+};
+export declare type HasteMap = {
+    hasteFS: HasteFS;
+    moduleMap: ModuleMap;
+    __hasteMapForTest?: InternalHasteMap | null;
+};
+export declare type RawModuleMap = {
+    rootDir: Config.Path;
+    duplicates: DuplicatesIndex;
+    map: ModuleMapData;
+    mocks: MockData;
+};
+declare type ModuleMapItem = {
+    [platform: string]: ModuleMetaData;
+};
+export declare type ModuleMetaData = [Config.Path, /* type */ number];
+export declare type HType = {
+    ID: 0;
+    MTIME: 1;
+    SIZE: 2;
+    VISITED: 3;
+    DEPENDENCIES: 4;
+    SHA1: 5;
+    PATH: 0;
+    TYPE: 1;
+    MODULE: 0;
+    PACKAGE: 1;
+    GENERIC_PLATFORM: 'g';
+    NATIVE_PLATFORM: 'native';
+    DEPENDENCY_DELIM: '\0';
+};
+export declare type HTypeValue = HType[keyof HType];
+export declare type EventsQueue = Array<{
+    filePath: Config.Path;
+    stat: Stats | undefined;
+    type: string;
+}>;
+export declare type ChangeEvent = {
+    eventsQueue: EventsQueue;
+    hasteFS: HasteFS;
+    moduleMap: ModuleMap;
+};
+export {};

node_modules/jest-haste-map/build/types.js

@@ -0,0 +1 @@
+'use strict';

node_modules/jest-haste-map/build/worker.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { WorkerMessage, WorkerMetadata } from './types';
+export declare function worker(data: WorkerMessage): Promise<WorkerMetadata>;
+export declare function getSha1(data: WorkerMessage): Promise<WorkerMetadata>;

node_modules/jest-haste-map/build/worker.js

@@ -0,0 +1,197 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.worker = worker;
+exports.getSha1 = getSha1;
+
+function _crypto() {
+  const data = require('crypto');
+
+  _crypto = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function path() {
+  const data = _interopRequireWildcard(require('path'));
+
+  path = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function fs() {
+  const data = _interopRequireWildcard(require('graceful-fs'));
+
+  fs = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _blacklist = _interopRequireDefault(require('./blacklist'));
+
+var _constants = _interopRequireDefault(require('./constants'));
+
+var dependencyExtractor = _interopRequireWildcard(
+  require('./lib/dependencyExtractor')
+);
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+function _getRequireWildcardCache() {
+  if (typeof WeakMap !== 'function') return null;
+  var cache = new WeakMap();
+  _getRequireWildcardCache = function () {
+    return cache;
+  };
+  return cache;
+}
+
+function _interopRequireWildcard(obj) {
+  if (obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
+    return {default: obj};
+  }
+  var cache = _getRequireWildcardCache();
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor
+        ? Object.getOwnPropertyDescriptor(obj, key)
+        : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const PACKAGE_JSON = path().sep + 'package.json';
+let hasteImpl = null;
+let hasteImplModulePath = null;
+
+function sha1hex(content) {
+  return (0, _crypto().createHash)('sha1').update(content).digest('hex');
+}
+
+async function worker(data) {
+  if (
+    data.hasteImplModulePath &&
+    data.hasteImplModulePath !== hasteImplModulePath
+  ) {
+    if (hasteImpl) {
+      throw new Error('jest-haste-map: hasteImplModulePath changed');
+    }
+
+    hasteImplModulePath = data.hasteImplModulePath;
+    hasteImpl = require(hasteImplModulePath);
+  }
+
+  let content;
+  let dependencies;
+  let id;
+  let module;
+  let sha1;
+  const {computeDependencies, computeSha1, rootDir, filePath} = data;
+
+  const getContent = () => {
+    if (content === undefined) {
+      content = fs().readFileSync(filePath, 'utf8');
+    }
+
+    return content;
+  };
+
+  if (filePath.endsWith(PACKAGE_JSON)) {
+    // Process a package.json that is returned as a PACKAGE type with its name.
+    try {
+      const fileData = JSON.parse(getContent());
+
+      if (fileData.name) {
+        const relativeFilePath = path().relative(rootDir, filePath);
+        id = fileData.name;
+        module = [relativeFilePath, _constants.default.PACKAGE];
+      }
+    } catch (err) {
+      throw new Error(`Cannot parse ${filePath} as JSON: ${err.message}`);
+    }
+  } else if (
+    !_blacklist.default.has(filePath.substr(filePath.lastIndexOf('.')))
+  ) {
+    // Process a random file that is returned as a MODULE.
+    if (hasteImpl) {
+      id = hasteImpl.getHasteName(filePath);
+    }
+
+    if (computeDependencies) {
+      const content = getContent();
+      dependencies = Array.from(
+        data.dependencyExtractor
+          ? require(data.dependencyExtractor).extract(
+              content,
+              filePath,
+              dependencyExtractor.extract
+            )
+          : dependencyExtractor.extract(content)
+      );
+    }
+
+    if (id) {
+      const relativeFilePath = path().relative(rootDir, filePath);
+      module = [relativeFilePath, _constants.default.MODULE];
+    }
+  } // If a SHA-1 is requested on update, compute it.
+
+  if (computeSha1) {
+    sha1 = sha1hex(getContent() || fs().readFileSync(filePath));
+  }
+
+  return {
+    dependencies,
+    id,
+    module,
+    sha1
+  };
+}
+
+async function getSha1(data) {
+  const sha1 = data.computeSha1
+    ? sha1hex(fs().readFileSync(data.filePath))
+    : null;
+  return {
+    dependencies: undefined,
+    id: undefined,
+    module: undefined,
+    sha1
+  };
+}

node_modules/jest-haste-map/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "jest-haste-map",
+  "version": "26.3.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/facebook/jest.git",
+    "directory": "packages/jest-haste-map"
+  },
+  "license": "MIT",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "dependencies": {
+    "@jest/types": "^26.3.0",
+    "@types/graceful-fs": "^4.1.2",
+    "@types/node": "*",
+    "anymatch": "^3.0.3",
+    "fb-watchman": "^2.0.0",
+    "graceful-fs": "^4.2.4",
+    "jest-regex-util": "^26.0.0",
+    "jest-serializer": "^26.3.0",
+    "jest-util": "^26.3.0",
+    "jest-worker": "^26.3.0",
+    "micromatch": "^4.0.2",
+    "sane": "^4.0.3",
+    "walker": "^1.0.7"
+  },
+  "devDependencies": {
+    "@jest/test-utils": "^26.3.0",
+    "@types/anymatch": "^1.3.1",
+    "@types/fb-watchman": "^2.0.0",
+    "@types/micromatch": "^4.0.0",
+    "@types/sane": "^2.0.0",
+    "slash": "^3.0.0"
+  },
+  "optionalDependencies": {
+    "fsevents": "^2.1.2"
+  },
+  "engines": {
+    "node": ">= 10.14.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "3a7e06fe855515a848241bb06a6f6e117847443d"
+}