Initial commit

node_modules/jest-resolve/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Meta Platforms, Inc. and 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-resolve/build/ModuleNotFoundError.js

@@ -0,0 +1,108 @@
+'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 _slash() {
+  const data = _interopRequireDefault(require('slash'));
+  _slash = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== 'function') return null;
+  var cacheBabelInterop = new WeakMap();
+  var cacheNodeInterop = new WeakMap();
+  return (_getRequireWildcardCache = function (nodeInterop) {
+    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
+    return {default: obj};
+  }
+  var cache = _getRequireWildcardCache(nodeInterop);
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor
+        ? Object.getOwnPropertyDescriptor(obj, key)
+        : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+class ModuleNotFoundError extends Error {
+  code = 'MODULE_NOT_FOUND';
+  hint;
+  requireStack;
+  siblingWithSimilarExtensionFound;
+  moduleName;
+  _originalMessage;
+  constructor(message, moduleName) {
+    super(message);
+    this._originalMessage = message;
+    this.moduleName = moduleName;
+  }
+  buildMessage(rootDir) {
+    if (!this._originalMessage) {
+      this._originalMessage = this.message || '';
+    }
+    let message = this._originalMessage;
+    if (this.requireStack?.length && this.requireStack.length > 1) {
+      message += `
+
+Require stack:
+  ${this.requireStack
+    .map(p => p.replace(`${rootDir}${path().sep}`, ''))
+    .map(_slash().default)
+    .join('\n  ')}
+`;
+    }
+    if (this.hint) {
+      message += this.hint;
+    }
+    this.message = message;
+  }
+  static duckType(error) {
+    error.buildMessage = ModuleNotFoundError.prototype.buildMessage;
+    return error;
+  }
+}
+exports.default = ModuleNotFoundError;

node_modules/jest-resolve/build/defaultResolver.js

@@ -0,0 +1,240 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+function _path() {
+  const data = require('path');
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _jestPnpResolver() {
+  const data = _interopRequireDefault(require('jest-pnp-resolver'));
+  _jestPnpResolver = function () {
+    return data;
+  };
+  return data;
+}
+function _resolve() {
+  const data = require('resolve');
+  _resolve = function () {
+    return data;
+  };
+  return data;
+}
+var resolve = _interopRequireWildcard(require('resolve.exports'));
+var _fileWalkers = require('./fileWalkers');
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== 'function') return null;
+  var cacheBabelInterop = new WeakMap();
+  var cacheNodeInterop = new WeakMap();
+  return (_getRequireWildcardCache = function (nodeInterop) {
+    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
+    return {default: obj};
+  }
+  var cache = _getRequireWildcardCache(nodeInterop);
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor
+        ? Object.getOwnPropertyDescriptor(obj, key)
+        : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * Allows transforming parsed `package.json` contents.
+ *
+ * @param pkg - Parsed `package.json` contents.
+ * @param file - Path to `package.json` file.
+ * @param dir - Directory that contains the `package.json`.
+ *
+ * @returns Transformed `package.json` contents.
+ */
+
+/**
+ * Allows transforming a path within a package.
+ *
+ * @param pkg - Parsed `package.json` contents.
+ * @param path - Path being resolved.
+ * @param relativePath - Path relative from the `package.json` location.
+ *
+ * @returns Relative path that will be joined from the `package.json` location.
+ */
+
+const defaultResolver = (path, options) => {
+  // Yarn 2 adds support to `resolve` automatically so the pnpResolver is only
+  // needed for Yarn 1 which implements version 1 of the pnp spec
+  if (process.versions.pnp === '1') {
+    return (0, _jestPnpResolver().default)(path, options);
+  }
+  const resolveOptions = {
+    ...options,
+    isDirectory: _fileWalkers.isDirectory,
+    isFile: _fileWalkers.isFile,
+    preserveSymlinks: false,
+    readPackageSync,
+    realpathSync: _fileWalkers.realpathSync
+  };
+  const pathToResolve = getPathInModule(path, resolveOptions);
+
+  // resolveSync dereferences symlinks to ensure we don't create a separate
+  // module instance depending on how it was referenced.
+  const result = (0, _resolve().sync)(pathToResolve, resolveOptions);
+  return result;
+};
+var _default = defaultResolver;
+/*
+ * helper functions
+ */
+exports.default = _default;
+function readPackageSync(_, file) {
+  return (0, _fileWalkers.readPackageCached)(file);
+}
+function getPathInModule(path, options) {
+  if (shouldIgnoreRequestForExports(path)) {
+    return path;
+  }
+  if (path.startsWith('#')) {
+    const closestPackageJson = (0, _fileWalkers.findClosestPackageJson)(
+      options.basedir
+    );
+    if (!closestPackageJson) {
+      throw new Error(
+        `Jest: unable to locate closest package.json from ${options.basedir} when resolving import "${path}"`
+      );
+    }
+    const pkg = (0, _fileWalkers.readPackageCached)(closestPackageJson);
+    const resolved = resolve.imports(
+      pkg,
+      path,
+      createResolveOptions(options.conditions)
+    );
+    if (resolved) {
+      const target = resolved[0];
+      return target.startsWith('.')
+        ? // internal relative filepath
+          (0, _path().resolve)((0, _path().dirname)(closestPackageJson), target)
+        : // this is an external module, re-resolve it
+          defaultResolver(target, options);
+    }
+    if (pkg.imports) {
+      throw new Error(
+        '`imports` exists, but no results - this is a bug in Jest. Please report an issue'
+      );
+    }
+  }
+  const segments = path.split('/');
+  let moduleName = segments.shift();
+  if (moduleName) {
+    if (moduleName.startsWith('@')) {
+      moduleName = `${moduleName}/${segments.shift()}`;
+    }
+
+    // self-reference
+    const closestPackageJson = (0, _fileWalkers.findClosestPackageJson)(
+      options.basedir
+    );
+    if (closestPackageJson) {
+      const pkg = (0, _fileWalkers.readPackageCached)(closestPackageJson);
+      if (pkg.name === moduleName) {
+        const resolved = resolve.exports(
+          pkg,
+          segments.join('/') || '.',
+          createResolveOptions(options.conditions)
+        );
+        if (resolved) {
+          return (0, _path().resolve)(
+            (0, _path().dirname)(closestPackageJson),
+            resolved[0]
+          );
+        }
+        if (pkg.exports) {
+          throw new Error(
+            '`exports` exists, but no results - this is a bug in Jest. Please report an issue'
+          );
+        }
+      }
+    }
+    let packageJsonPath = '';
+    try {
+      packageJsonPath = (0, _resolve().sync)(
+        `${moduleName}/package.json`,
+        options
+      );
+    } catch {
+      // ignore if package.json cannot be found
+    }
+    if (packageJsonPath && (0, _fileWalkers.isFile)(packageJsonPath)) {
+      const pkg = (0, _fileWalkers.readPackageCached)(packageJsonPath);
+      const resolved = resolve.exports(
+        pkg,
+        segments.join('/') || '.',
+        createResolveOptions(options.conditions)
+      );
+      if (resolved) {
+        return (0, _path().resolve)(
+          (0, _path().dirname)(packageJsonPath),
+          resolved[0]
+        );
+      }
+      if (pkg.exports) {
+        throw new Error(
+          '`exports` exists, but no results - this is a bug in Jest. Please report an issue'
+        );
+      }
+    }
+  }
+  return path;
+}
+function createResolveOptions(conditions) {
+  return conditions
+    ? {
+        conditions,
+        unsafe: true
+      }
+    : // no conditions were passed - let's assume this is Jest internal and it should be `require`
+      {
+        browser: false,
+        require: true
+      };
+}
+
+// if it's a relative import or an absolute path, imports/exports are ignored
+const shouldIgnoreRequestForExports = path =>
+  path.startsWith('.') || (0, _path().isAbsolute)(path);

node_modules/jest-resolve/build/fileWalkers.js

@@ -0,0 +1,178 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.clearFsCache = clearFsCache;
+exports.findClosestPackageJson = findClosestPackageJson;
+exports.isDirectory = isDirectory;
+exports.isFile = isFile;
+exports.readPackageCached = readPackageCached;
+exports.realpathSync = realpathSync;
+function _path() {
+  const data = require('path');
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function fs() {
+  const data = _interopRequireWildcard(require('graceful-fs'));
+  fs = function () {
+    return data;
+  };
+  return data;
+}
+function _jestUtil() {
+  const data = require('jest-util');
+  _jestUtil = function () {
+    return data;
+  };
+  return data;
+}
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== 'function') return null;
+  var cacheBabelInterop = new WeakMap();
+  var cacheNodeInterop = new WeakMap();
+  return (_getRequireWildcardCache = function (nodeInterop) {
+    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
+    return {default: obj};
+  }
+  var cache = _getRequireWildcardCache(nodeInterop);
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor
+        ? Object.getOwnPropertyDescriptor(obj, key)
+        : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+function clearFsCache() {
+  checkedPaths.clear();
+  checkedRealpathPaths.clear();
+  packageContents.clear();
+}
+var IPathType = /*#__PURE__*/ (function (IPathType) {
+  IPathType[(IPathType['FILE'] = 1)] = 'FILE';
+  IPathType[(IPathType['DIRECTORY'] = 2)] = 'DIRECTORY';
+  IPathType[(IPathType['OTHER'] = 3)] = 'OTHER';
+  return IPathType;
+})(IPathType || {});
+const checkedPaths = new Map();
+function statSyncCached(path) {
+  const result = checkedPaths.get(path);
+  if (result != null) {
+    return result;
+  }
+  let stat;
+  try {
+    // @ts-expect-error TS2554 - throwIfNoEntry is only available in recent version of node, but inclusion of the option is a backward compatible no-op.
+    stat = fs().statSync(path, {
+      throwIfNoEntry: false
+    });
+  } catch (e) {
+    if (!(e && (e.code === 'ENOENT' || e.code === 'ENOTDIR'))) {
+      throw e;
+    }
+  }
+  if (stat) {
+    if (stat.isFile() || stat.isFIFO()) {
+      checkedPaths.set(path, IPathType.FILE);
+      return IPathType.FILE;
+    } else if (stat.isDirectory()) {
+      checkedPaths.set(path, IPathType.DIRECTORY);
+      return IPathType.DIRECTORY;
+    }
+  }
+  checkedPaths.set(path, IPathType.OTHER);
+  return IPathType.OTHER;
+}
+const checkedRealpathPaths = new Map();
+function realpathCached(path) {
+  let result = checkedRealpathPaths.get(path);
+  if (result != null) {
+    return result;
+  }
+  result = (0, _jestUtil().tryRealpath)(path);
+  checkedRealpathPaths.set(path, result);
+  if (path !== result) {
+    // also cache the result in case it's ever referenced directly - no reason to `realpath` that as well
+    checkedRealpathPaths.set(result, result);
+  }
+  return result;
+}
+const packageContents = new Map();
+function readPackageCached(path) {
+  let result = packageContents.get(path);
+  if (result != null) {
+    return result;
+  }
+  result = JSON.parse(fs().readFileSync(path, 'utf8'));
+  packageContents.set(path, result);
+  return result;
+}
+
+// adapted from
+// https://github.com/lukeed/escalade/blob/2477005062cdbd8407afc90d3f48f4930354252b/src/sync.js
+// to use cached `fs` calls
+function findClosestPackageJson(start) {
+  let dir = (0, _path().resolve)('.', start);
+  if (!isDirectory(dir)) {
+    dir = (0, _path().dirname)(dir);
+  }
+  while (true) {
+    const pkgJsonFile = (0, _path().resolve)(dir, './package.json');
+    const hasPackageJson = isFile(pkgJsonFile);
+    if (hasPackageJson) {
+      return pkgJsonFile;
+    }
+    const prevDir = dir;
+    dir = (0, _path().dirname)(dir);
+    if (prevDir === dir) {
+      return undefined;
+    }
+  }
+}
+
+/*
+ * helper functions
+ */
+function isFile(file) {
+  return statSyncCached(file) === IPathType.FILE;
+}
+function isDirectory(dir) {
+  return statSyncCached(dir) === IPathType.DIRECTORY;
+}
+function realpathSync(file) {
+  return realpathCached(file);
+}

node_modules/jest-resolve/build/index.d.ts

@@ -0,0 +1,320 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type {IModuleMap} from 'jest-haste-map';
+
+export declare type AsyncResolver = (
+  path: string,
+  options: ResolverOptions,
+) => Promise<string>;
+
+declare function cachedShouldLoadAsEsm(
+  path: string,
+  extensionsToTreatAsEsm: Array<string>,
+): boolean;
+
+declare const defaultResolver: SyncResolver;
+
+export declare type FindNodeModuleConfig = {
+  basedir: string;
+  conditions?: Array<string>;
+  extensions?: Array<string>;
+  moduleDirectory?: Array<string>;
+  paths?: Array<string>;
+  resolver?: string | null;
+  rootDir?: string;
+  throwIfNotFound?: boolean;
+};
+
+export declare type JestResolver = ResolverSyncObject | ResolverAsyncObject;
+
+declare interface JSONObject {
+  [key: string]: JSONValue;
+}
+
+declare type JSONValue =
+  | string
+  | number
+  | boolean
+  | JSONObject
+  | Array<JSONValue>;
+
+declare type ModuleNameMapperConfig = {
+  regex: RegExp;
+  moduleName: string | Array<string>;
+};
+
+declare class ModuleNotFoundError extends Error {
+  code: string;
+  hint?: string;
+  requireStack?: Array<string>;
+  siblingWithSimilarExtensionFound?: boolean;
+  moduleName?: string;
+  private _originalMessage?;
+  constructor(message: string, moduleName?: string);
+  buildMessage(rootDir: string): void;
+  static duckType(error: ModuleNotFoundError): ModuleNotFoundError;
+}
+
+/**
+ * Allows transforming parsed `package.json` contents.
+ *
+ * @param pkg - Parsed `package.json` contents.
+ * @param file - Path to `package.json` file.
+ * @param dir - Directory that contains the `package.json`.
+ *
+ * @returns Transformed `package.json` contents.
+ */
+export declare type PackageFilter = (
+  pkg: PackageJSON,
+  file: string,
+  dir: string,
+) => PackageJSON;
+
+export declare type PackageJSON = JSONObject;
+
+/**
+ * Allows transforming a path within a package.
+ *
+ * @param pkg - Parsed `package.json` contents.
+ * @param path - Path being resolved.
+ * @param relativePath - Path relative from the `package.json` location.
+ *
+ * @returns Relative path that will be joined from the `package.json` location.
+ */
+export declare type PathFilter = (
+  pkg: PackageJSON,
+  path: string,
+  relativePath: string,
+) => string;
+
+export declare type ResolveModuleConfig = {
+  conditions?: Array<string>;
+  skipNodeResolution?: boolean;
+  paths?: Array<string>;
+};
+
+declare class Resolver {
+  private readonly _options;
+  private readonly _moduleMap;
+  private readonly _moduleIDCache;
+  private readonly _moduleNameCache;
+  private readonly _modulePathCache;
+  private readonly _supportsNativePlatform;
+  constructor(moduleMap: IModuleMap, options: ResolverConfig);
+  static ModuleNotFoundError: typeof ModuleNotFoundError;
+  static tryCastModuleNotFoundError(error: unknown): ModuleNotFoundError | null;
+  static clearDefaultResolverCache(): void;
+  static findNodeModule(
+    path: string,
+    options: FindNodeModuleConfig,
+  ): string | null;
+  static findNodeModuleAsync(
+    path: string,
+    options: FindNodeModuleConfig,
+  ): Promise<string | null>;
+  static unstable_shouldLoadAsEsm: typeof cachedShouldLoadAsEsm;
+  resolveModuleFromDirIfExists(
+    dirname: string,
+    moduleName: string,
+    options?: ResolveModuleConfig,
+  ): string | null;
+  resolveModuleFromDirIfExistsAsync(
+    dirname: string,
+    moduleName: string,
+    options?: ResolveModuleConfig,
+  ): Promise<string | null>;
+  resolveModule(
+    from: string,
+    moduleName: string,
+    options?: ResolveModuleConfig,
+  ): string;
+  resolveModuleAsync(
+    from: string,
+    moduleName: string,
+    options?: ResolveModuleConfig,
+  ): Promise<string>;
+  /**
+   * _prepareForResolution is shared between the sync and async module resolution
+   * methods, to try to keep them as DRY as possible.
+   */
+  private _prepareForResolution;
+  /**
+   * _getHasteModulePath attempts to return the path to a haste module.
+   */
+  private _getHasteModulePath;
+  private _throwModNotFoundError;
+  private _getMapModuleName;
+  private _isAliasModule;
+  isCoreModule(moduleName: string): boolean;
+  getModule(name: string): string | null;
+  getModulePath(from: string, moduleName: string): string;
+  getPackage(name: string): string | null;
+  getMockModule(from: string, name: string): string | null;
+  getMockModuleAsync(from: string, name: string): Promise<string | null>;
+  getModulePaths(from: string): Array<string>;
+  getGlobalPaths(moduleName?: string): Array<string>;
+  getModuleID(
+    virtualMocks: Map<string, boolean>,
+    from: string,
+    moduleName?: string,
+    options?: ResolveModuleConfig,
+  ): string;
+  getModuleIDAsync(
+    virtualMocks: Map<string, boolean>,
+    from: string,
+    moduleName?: string,
+    options?: ResolveModuleConfig,
+  ): Promise<string>;
+  private _getModuleType;
+  private _getAbsolutePath;
+  private _getAbsolutePathAsync;
+  private _getMockPath;
+  private _getMockPathAsync;
+  private _getVirtualMockPath;
+  private _getVirtualMockPathAsync;
+  private _isModuleResolved;
+  private _isModuleResolvedAsync;
+  resolveStubModuleName(from: string, moduleName: string): string | null;
+  resolveStubModuleNameAsync(
+    from: string,
+    moduleName: string,
+  ): Promise<string | null>;
+}
+export default Resolver;
+
+declare type ResolverAsyncObject = {
+  sync?: SyncResolver;
+  async: AsyncResolver;
+};
+
+declare type ResolverConfig = {
+  defaultPlatform?: string | null;
+  extensions: Array<string>;
+  hasCoreModules: boolean;
+  moduleDirectories: Array<string>;
+  moduleNameMapper?: Array<ModuleNameMapperConfig> | null;
+  modulePaths?: Array<string>;
+  platforms?: Array<string>;
+  resolver?: string | null;
+  rootDir: string;
+};
+
+export declare type ResolverOptions = {
+  /** Directory to begin resolving from. */
+  basedir: string;
+  /** List of export conditions. */
+  conditions?: Array<string>;
+  /** Instance of default resolver. */
+  defaultResolver: typeof defaultResolver;
+  /** List of file extensions to search in order. */
+  extensions?: Array<string>;
+  /**
+   * List of directory names to be looked up for modules recursively.
+   *
+   * @defaultValue
+   * The default is `['node_modules']`.
+   */
+  moduleDirectory?: Array<string>;
+  /**
+   * List of `require.paths` to use if nothing is found in `node_modules`.
+   *
+   * @defaultValue
+   * The default is `undefined`.
+   */
+  paths?: Array<string>;
+  /** Allows transforming parsed `package.json` contents. */
+  packageFilter?: PackageFilter;
+  /** Allows transforms a path within a package. */
+  pathFilter?: PathFilter;
+  /** Current root directory. */
+  rootDir?: string;
+};
+
+declare type ResolverSyncObject = {
+  sync: SyncResolver;
+  async?: AsyncResolver;
+};
+
+/**
+ * Finds the runner to use:
+ *
+ * 1. looks for jest-runner-<name> relative to project.
+ * 1. looks for jest-runner-<name> relative to Jest.
+ * 1. looks for <name> relative to project.
+ * 1. looks for <name> relative to Jest.
+ */
+export declare const resolveRunner: (
+  resolver: string | undefined | null,
+  {
+    filePath,
+    rootDir,
+    requireResolveFunction,
+  }: {
+    filePath: string;
+    rootDir: string;
+    requireResolveFunction: (moduleName: string) => string;
+  },
+) => string;
+
+export declare const resolveSequencer: (
+  resolver: string | undefined | null,
+  {
+    filePath,
+    rootDir,
+    requireResolveFunction,
+  }: {
+    filePath: string;
+    rootDir: string;
+    requireResolveFunction: (moduleName: string) => string;
+  },
+) => string;
+
+/**
+ * Finds the test environment to use:
+ *
+ * 1. looks for jest-environment-<name> relative to project.
+ * 1. looks for jest-environment-<name> relative to Jest.
+ * 1. looks for <name> relative to project.
+ * 1. looks for <name> relative to Jest.
+ */
+export declare const resolveTestEnvironment: ({
+  rootDir,
+  testEnvironment: filePath,
+  requireResolveFunction,
+}: {
+  rootDir: string;
+  testEnvironment: string;
+  requireResolveFunction: (moduleName: string) => string;
+}) => string;
+
+/**
+ * Finds the watch plugins to use:
+ *
+ * 1. looks for jest-watch-<name> relative to project.
+ * 1. looks for jest-watch-<name> relative to Jest.
+ * 1. looks for <name> relative to project.
+ * 1. looks for <name> relative to Jest.
+ */
+export declare const resolveWatchPlugin: (
+  resolver: string | undefined | null,
+  {
+    filePath,
+    rootDir,
+    requireResolveFunction,
+  }: {
+    filePath: string;
+    rootDir: string;
+    requireResolveFunction: (moduleName: string) => string;
+  },
+) => string;
+
+export declare type SyncResolver = (
+  path: string,
+  options: ResolverOptions,
+) => string;
+
+export {};

node_modules/jest-resolve/build/index.js

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+var _exportNames = {};
+exports.default = void 0;
+var _resolver = _interopRequireDefault(require('./resolver'));
+var _utils = require('./utils');
+Object.keys(_utils).forEach(function (key) {
+  if (key === 'default' || key === '__esModule') return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _utils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _utils[key];
+    }
+  });
+});
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var _default = _resolver.default;
+exports.default = _default;

node_modules/jest-resolve/build/isBuiltinModule.js

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = isBuiltinModule;
+function _module() {
+  const data = _interopRequireDefault(require('module'));
+  _module = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+const BUILTIN_MODULES = new Set(_module().default.builtinModules);
+function isBuiltinModule(module) {
+  return BUILTIN_MODULES.has(module);
+}

node_modules/jest-resolve/build/nodeModulesPaths.js

@@ -0,0 +1,131 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.GlobalPaths = void 0;
+exports.default = nodeModulesPaths;
+function path() {
+  const data = _interopRequireWildcard(require('path'));
+  path = function () {
+    return data;
+  };
+  return data;
+}
+function _jestUtil() {
+  const data = require('jest-util');
+  _jestUtil = function () {
+    return data;
+  };
+  return data;
+}
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== 'function') return null;
+  var cacheBabelInterop = new WeakMap();
+  var cacheNodeInterop = new WeakMap();
+  return (_getRequireWildcardCache = function (nodeInterop) {
+    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
+    return {default: obj};
+  }
+  var cache = _getRequireWildcardCache(nodeInterop);
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor
+        ? Object.getOwnPropertyDescriptor(obj, key)
+        : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * Adapted from: https://github.com/substack/node-resolve
+ */
+
+function nodeModulesPaths(basedir, options) {
+  const modules =
+    options && options.moduleDirectory
+      ? Array.from(options.moduleDirectory)
+      : ['node_modules'];
+
+  // ensure that `basedir` is an absolute path at this point,
+  // resolving against the process' current working directory
+  const basedirAbs = path().resolve(basedir);
+  let prefix = '/';
+  if (/^([A-Za-z]:)/.test(basedirAbs)) {
+    prefix = '';
+  } else if (/^\\\\/.test(basedirAbs)) {
+    prefix = '\\\\';
+  }
+
+  // The node resolution algorithm (as implemented by NodeJS and TypeScript)
+  // traverses parents of the physical path, not the symlinked path
+  let physicalBasedir;
+  try {
+    physicalBasedir = (0, _jestUtil().tryRealpath)(basedirAbs);
+  } catch {
+    // realpath can throw, e.g. on mapped drives
+    physicalBasedir = basedirAbs;
+  }
+  const paths = [physicalBasedir];
+  let parsed = path().parse(physicalBasedir);
+  while (parsed.dir !== paths[paths.length - 1]) {
+    paths.push(parsed.dir);
+    parsed = path().parse(parsed.dir);
+  }
+  const dirs = paths.reduce((dirs, aPath) => {
+    for (const moduleDir of modules) {
+      if (path().isAbsolute(moduleDir)) {
+        if (aPath === basedirAbs && moduleDir) {
+          dirs.push(moduleDir);
+        }
+      } else {
+        dirs.push(path().join(prefix, aPath, moduleDir));
+      }
+    }
+    return dirs;
+  }, []);
+  if (options.paths) {
+    dirs.push(...options.paths);
+  }
+  return dirs;
+}
+function findGlobalPaths() {
+  const {root} = path().parse(process.cwd());
+  const globalPath = path().join(root, 'node_modules');
+  const resolvePaths = require.resolve.paths('/');
+  if (resolvePaths) {
+    // the global paths start one after the root node_modules
+    const rootIndex = resolvePaths.indexOf(globalPath);
+    return rootIndex > -1 ? resolvePaths.slice(rootIndex + 1) : [];
+  }
+  return [];
+}
+const GlobalPaths = findGlobalPaths();
+exports.GlobalPaths = GlobalPaths;

node_modules/jest-resolve/build/resolver.js

@@ -0,0 +1,796 @@
+'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 _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function _slash() {
+  const data = _interopRequireDefault(require('slash'));
+  _slash = function () {
+    return data;
+  };
+  return data;
+}
+function _jestUtil() {
+  const data = require('jest-util');
+  _jestUtil = function () {
+    return data;
+  };
+  return data;
+}
+var _ModuleNotFoundError = _interopRequireDefault(
+  require('./ModuleNotFoundError')
+);
+var _defaultResolver = _interopRequireDefault(require('./defaultResolver'));
+var _fileWalkers = require('./fileWalkers');
+var _isBuiltinModule = _interopRequireDefault(require('./isBuiltinModule'));
+var _nodeModulesPaths = _interopRequireWildcard(require('./nodeModulesPaths'));
+var _shouldLoadAsEsm = _interopRequireWildcard(require('./shouldLoadAsEsm'));
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== 'function') return null;
+  var cacheBabelInterop = new WeakMap();
+  var cacheNodeInterop = new WeakMap();
+  return (_getRequireWildcardCache = function (nodeInterop) {
+    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
+    return {default: obj};
+  }
+  var cache = _getRequireWildcardCache(nodeInterop);
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor
+        ? Object.getOwnPropertyDescriptor(obj, key)
+        : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/* eslint-disable local/prefer-spread-eventually */
+
+const NATIVE_PLATFORM = 'native';
+
+// We might be inside a symlink.
+const resolvedCwd = (0, _jestUtil().tryRealpath)(process.cwd());
+const {NODE_PATH} = process.env;
+const nodePaths = NODE_PATH
+  ? NODE_PATH.split(path().delimiter)
+      .filter(Boolean)
+      // The resolver expects absolute paths.
+      .map(p => path().resolve(resolvedCwd, p))
+  : undefined;
+class Resolver {
+  _options;
+  _moduleMap;
+  _moduleIDCache;
+  _moduleNameCache;
+  _modulePathCache;
+  _supportsNativePlatform;
+  constructor(moduleMap, options) {
+    this._options = {
+      defaultPlatform: options.defaultPlatform,
+      extensions: options.extensions,
+      hasCoreModules:
+        options.hasCoreModules === undefined ? true : options.hasCoreModules,
+      moduleDirectories: options.moduleDirectories || ['node_modules'],
+      moduleNameMapper: options.moduleNameMapper,
+      modulePaths: options.modulePaths,
+      platforms: options.platforms,
+      resolver: options.resolver,
+      rootDir: options.rootDir
+    };
+    this._supportsNativePlatform = options.platforms
+      ? options.platforms.includes(NATIVE_PLATFORM)
+      : false;
+    this._moduleMap = moduleMap;
+    this._moduleIDCache = new Map();
+    this._moduleNameCache = new Map();
+    this._modulePathCache = new Map();
+  }
+  static ModuleNotFoundError = _ModuleNotFoundError.default;
+  static tryCastModuleNotFoundError(error) {
+    if (error instanceof _ModuleNotFoundError.default) {
+      return error;
+    }
+    const casted = error;
+    if (casted.code === 'MODULE_NOT_FOUND') {
+      return _ModuleNotFoundError.default.duckType(casted);
+    }
+    return null;
+  }
+  static clearDefaultResolverCache() {
+    (0, _fileWalkers.clearFsCache)();
+    (0, _shouldLoadAsEsm.clearCachedLookups)();
+  }
+  static findNodeModule(path, options) {
+    const resolverModule = loadResolver(options.resolver);
+    let resolver = _defaultResolver.default;
+    if (typeof resolverModule === 'function') {
+      resolver = resolverModule;
+    } else if (typeof resolverModule.sync === 'function') {
+      resolver = resolverModule.sync;
+    }
+    const paths = options.paths;
+    try {
+      return resolver(path, {
+        basedir: options.basedir,
+        conditions: options.conditions,
+        defaultResolver: _defaultResolver.default,
+        extensions: options.extensions,
+        moduleDirectory: options.moduleDirectory,
+        paths: paths ? (nodePaths || []).concat(paths) : nodePaths,
+        rootDir: options.rootDir
+      });
+    } catch (e) {
+      // we always wanna throw if it's an internal import
+      if (options.throwIfNotFound || path.startsWith('#')) {
+        throw e;
+      }
+    }
+    return null;
+  }
+  static async findNodeModuleAsync(path, options) {
+    const resolverModule = loadResolver(options.resolver);
+    let resolver = _defaultResolver.default;
+    if (typeof resolverModule === 'function') {
+      resolver = resolverModule;
+    } else if (
+      typeof resolverModule.async === 'function' ||
+      typeof resolverModule.sync === 'function'
+    ) {
+      const asyncOrSync = resolverModule.async || resolverModule.sync;
+      if (asyncOrSync == null) {
+        throw new Error(`Unable to load resolver at ${options.resolver}`);
+      }
+      resolver = asyncOrSync;
+    }
+    const paths = options.paths;
+    try {
+      const result = await resolver(path, {
+        basedir: options.basedir,
+        conditions: options.conditions,
+        defaultResolver: _defaultResolver.default,
+        extensions: options.extensions,
+        moduleDirectory: options.moduleDirectory,
+        paths: paths ? (nodePaths || []).concat(paths) : nodePaths,
+        rootDir: options.rootDir
+      });
+      return result;
+    } catch (e) {
+      // we always wanna throw if it's an internal import
+      if (options.throwIfNotFound || path.startsWith('#')) {
+        throw e;
+      }
+    }
+    return null;
+  }
+
+  // unstable as it should be replaced by https://github.com/nodejs/modules/issues/393, and we don't want people to use it
+  static unstable_shouldLoadAsEsm = _shouldLoadAsEsm.default;
+  resolveModuleFromDirIfExists(dirname, moduleName, options) {
+    const {extensions, key, moduleDirectory, paths, skipResolution} =
+      this._prepareForResolution(dirname, moduleName, options);
+    let module;
+
+    // 1. If we have already resolved this module for this directory name,
+    // return a value from the cache.
+    const cacheResult = this._moduleNameCache.get(key);
+    if (cacheResult) {
+      return cacheResult;
+    }
+
+    // 2. Check if the module is a haste module.
+    module = this.getModule(moduleName);
+    if (module) {
+      this._moduleNameCache.set(key, module);
+      return module;
+    }
+
+    // 3. Check if the module is a node module and resolve it based on
+    // the node module resolution algorithm. If skipNodeResolution is given we
+    // ignore all modules that look like node modules (ie. are not relative
+    // requires). This enables us to speed up resolution when we build a
+    // dependency graph because we don't have to look at modules that may not
+    // exist and aren't mocked.
+    const resolveNodeModule = (name, throwIfNotFound = false) => {
+      // Only skip default resolver
+      if (this.isCoreModule(name) && !this._options.resolver) {
+        return name;
+      }
+      return Resolver.findNodeModule(name, {
+        basedir: dirname,
+        conditions: options?.conditions,
+        extensions,
+        moduleDirectory,
+        paths,
+        resolver: this._options.resolver,
+        rootDir: this._options.rootDir,
+        throwIfNotFound
+      });
+    };
+    if (!skipResolution) {
+      module = resolveNodeModule(moduleName, Boolean(process.versions.pnp));
+      if (module) {
+        this._moduleNameCache.set(key, module);
+        return module;
+      }
+    }
+
+    // 4. Resolve "haste packages" which are `package.json` files outside of
+    // `node_modules` folders anywhere in the file system.
+    try {
+      const hasteModulePath = this._getHasteModulePath(moduleName);
+      if (hasteModulePath) {
+        // try resolving with custom resolver first to support extensions,
+        // then fallback to require.resolve
+        const resolvedModule =
+          resolveNodeModule(hasteModulePath) ||
+          require.resolve(hasteModulePath);
+        this._moduleNameCache.set(key, resolvedModule);
+        return resolvedModule;
+      }
+    } catch {}
+    return null;
+  }
+  async resolveModuleFromDirIfExistsAsync(dirname, moduleName, options) {
+    const {extensions, key, moduleDirectory, paths, skipResolution} =
+      this._prepareForResolution(dirname, moduleName, options);
+    let module;
+
+    // 1. If we have already resolved this module for this directory name,
+    // return a value from the cache.
+    const cacheResult = this._moduleNameCache.get(key);
+    if (cacheResult) {
+      return cacheResult;
+    }
+
+    // 2. Check if the module is a haste module.
+    module = this.getModule(moduleName);
+    if (module) {
+      this._moduleNameCache.set(key, module);
+      return module;
+    }
+
+    // 3. Check if the module is a node module and resolve it based on
+    // the node module resolution algorithm. If skipNodeResolution is given we
+    // ignore all modules that look like node modules (ie. are not relative
+    // requires). This enables us to speed up resolution when we build a
+    // dependency graph because we don't have to look at modules that may not
+    // exist and aren't mocked.
+    const resolveNodeModule = async (name, throwIfNotFound = false) => {
+      // Only skip default resolver
+      if (this.isCoreModule(name) && !this._options.resolver) {
+        return name;
+      }
+      return Resolver.findNodeModuleAsync(name, {
+        basedir: dirname,
+        conditions: options?.conditions,
+        extensions,
+        moduleDirectory,
+        paths,
+        resolver: this._options.resolver,
+        rootDir: this._options.rootDir,
+        throwIfNotFound
+      });
+    };
+    if (!skipResolution) {
+      module = await resolveNodeModule(
+        moduleName,
+        Boolean(process.versions.pnp)
+      );
+      if (module) {
+        this._moduleNameCache.set(key, module);
+        return module;
+      }
+    }
+
+    // 4. Resolve "haste packages" which are `package.json` files outside of
+    // `node_modules` folders anywhere in the file system.
+    try {
+      const hasteModulePath = this._getHasteModulePath(moduleName);
+      if (hasteModulePath) {
+        // try resolving with custom resolver first to support extensions,
+        // then fallback to require.resolve
+        const resolvedModule =
+          (await resolveNodeModule(hasteModulePath)) ||
+          // QUESTION: should this be async?
+          require.resolve(hasteModulePath);
+        this._moduleNameCache.set(key, resolvedModule);
+        return resolvedModule;
+      }
+    } catch {}
+    return null;
+  }
+  resolveModule(from, moduleName, options) {
+    const dirname = path().dirname(from);
+    const module =
+      this.resolveStubModuleName(from, moduleName) ||
+      this.resolveModuleFromDirIfExists(dirname, moduleName, options);
+    if (module) return module;
+
+    // 5. Throw an error if the module could not be found. `resolve.sync` only
+    // produces an error based on the dirname but we have the actual current
+    // module name available.
+    this._throwModNotFoundError(from, moduleName);
+  }
+  async resolveModuleAsync(from, moduleName, options) {
+    const dirname = path().dirname(from);
+    const module =
+      (await this.resolveStubModuleNameAsync(from, moduleName)) ||
+      (await this.resolveModuleFromDirIfExistsAsync(
+        dirname,
+        moduleName,
+        options
+      ));
+    if (module) return module;
+
+    // 5. Throw an error if the module could not be found. `resolve` only
+    // produces an error based on the dirname but we have the actual current
+    // module name available.
+    this._throwModNotFoundError(from, moduleName);
+  }
+
+  /**
+   * _prepareForResolution is shared between the sync and async module resolution
+   * methods, to try to keep them as DRY as possible.
+   */
+  _prepareForResolution(dirname, moduleName, options) {
+    const paths = options?.paths || this._options.modulePaths;
+    const moduleDirectory = this._options.moduleDirectories;
+    const stringifiedOptions = options ? JSON.stringify(options) : '';
+    const key = dirname + path().delimiter + moduleName + stringifiedOptions;
+    const defaultPlatform = this._options.defaultPlatform;
+    const extensions = this._options.extensions.slice();
+    if (this._supportsNativePlatform) {
+      extensions.unshift(
+        ...this._options.extensions.map(ext => `.${NATIVE_PLATFORM}${ext}`)
+      );
+    }
+    if (defaultPlatform) {
+      extensions.unshift(
+        ...this._options.extensions.map(ext => `.${defaultPlatform}${ext}`)
+      );
+    }
+    const skipResolution =
+      options && options.skipNodeResolution && !moduleName.includes(path().sep);
+    return {
+      extensions,
+      key,
+      moduleDirectory,
+      paths,
+      skipResolution
+    };
+  }
+
+  /**
+   * _getHasteModulePath attempts to return the path to a haste module.
+   */
+  _getHasteModulePath(moduleName) {
+    const parts = moduleName.split('/');
+    const hastePackage = this.getPackage(parts.shift());
+    if (hastePackage) {
+      return path().join.apply(
+        path(),
+        [path().dirname(hastePackage)].concat(parts)
+      );
+    }
+    return null;
+  }
+  _throwModNotFoundError(from, moduleName) {
+    const relativePath =
+      (0, _slash().default)(path().relative(this._options.rootDir, from)) ||
+      '.';
+    throw new _ModuleNotFoundError.default(
+      `Cannot find module '${moduleName}' from '${relativePath}'`,
+      moduleName
+    );
+  }
+  _getMapModuleName(matches) {
+    return matches
+      ? moduleName =>
+          moduleName.replace(
+            /\$([0-9]+)/g,
+            (_, index) => matches[parseInt(index, 10)] || ''
+          )
+      : moduleName => moduleName;
+  }
+  _isAliasModule(moduleName) {
+    const moduleNameMapper = this._options.moduleNameMapper;
+    if (!moduleNameMapper) {
+      return false;
+    }
+    return moduleNameMapper.some(({regex}) => regex.test(moduleName));
+  }
+  isCoreModule(moduleName) {
+    return (
+      this._options.hasCoreModules &&
+      ((0, _isBuiltinModule.default)(moduleName) ||
+        moduleName.startsWith('node:')) &&
+      !this._isAliasModule(moduleName)
+    );
+  }
+  getModule(name) {
+    return this._moduleMap.getModule(
+      name,
+      this._options.defaultPlatform,
+      this._supportsNativePlatform
+    );
+  }
+  getModulePath(from, moduleName) {
+    if (moduleName[0] !== '.' || path().isAbsolute(moduleName)) {
+      return moduleName;
+    }
+    return path().normalize(`${path().dirname(from)}/${moduleName}`);
+  }
+  getPackage(name) {
+    return this._moduleMap.getPackage(
+      name,
+      this._options.defaultPlatform,
+      this._supportsNativePlatform
+    );
+  }
+  getMockModule(from, name) {
+    const mock = this._moduleMap.getMockModule(name);
+    if (mock) {
+      return mock;
+    } else {
+      const moduleName = this.resolveStubModuleName(from, name);
+      if (moduleName) {
+        return this.getModule(moduleName) || moduleName;
+      }
+    }
+    return null;
+  }
+  async getMockModuleAsync(from, name) {
+    const mock = this._moduleMap.getMockModule(name);
+    if (mock) {
+      return mock;
+    } else {
+      const moduleName = await this.resolveStubModuleNameAsync(from, name);
+      if (moduleName) {
+        return this.getModule(moduleName) || moduleName;
+      }
+    }
+    return null;
+  }
+  getModulePaths(from) {
+    const cachedModule = this._modulePathCache.get(from);
+    if (cachedModule) {
+      return cachedModule;
+    }
+    const moduleDirectory = this._options.moduleDirectories;
+    const paths = (0, _nodeModulesPaths.default)(from, {
+      moduleDirectory
+    });
+    if (paths[paths.length - 1] === undefined) {
+      // circumvent node-resolve bug that adds `undefined` as last item.
+      paths.pop();
+    }
+    this._modulePathCache.set(from, paths);
+    return paths;
+  }
+  getGlobalPaths(moduleName) {
+    if (!moduleName || moduleName[0] === '.' || this.isCoreModule(moduleName)) {
+      return [];
+    }
+    return _nodeModulesPaths.GlobalPaths;
+  }
+  getModuleID(virtualMocks, from, moduleName = '', options) {
+    const stringifiedOptions = options ? JSON.stringify(options) : '';
+    const key = from + path().delimiter + moduleName + stringifiedOptions;
+    const cachedModuleID = this._moduleIDCache.get(key);
+    if (cachedModuleID) {
+      return cachedModuleID;
+    }
+    const moduleType = this._getModuleType(moduleName);
+    const absolutePath = this._getAbsolutePath(
+      virtualMocks,
+      from,
+      moduleName,
+      options
+    );
+    const mockPath = this._getMockPath(from, moduleName);
+    const sep = path().delimiter;
+    const id =
+      moduleType +
+      sep +
+      (absolutePath ? absolutePath + sep : '') +
+      (mockPath ? mockPath + sep : '') +
+      (stringifiedOptions ? stringifiedOptions + sep : '');
+    this._moduleIDCache.set(key, id);
+    return id;
+  }
+  async getModuleIDAsync(virtualMocks, from, moduleName = '', options) {
+    const stringifiedOptions = options ? JSON.stringify(options) : '';
+    const key = from + path().delimiter + moduleName + stringifiedOptions;
+    const cachedModuleID = this._moduleIDCache.get(key);
+    if (cachedModuleID) {
+      return cachedModuleID;
+    }
+    if (moduleName.startsWith('data:')) {
+      return moduleName;
+    }
+    const moduleType = this._getModuleType(moduleName);
+    const absolutePath = await this._getAbsolutePathAsync(
+      virtualMocks,
+      from,
+      moduleName,
+      options
+    );
+    const mockPath = await this._getMockPathAsync(from, moduleName);
+    const sep = path().delimiter;
+    const id =
+      moduleType +
+      sep +
+      (absolutePath ? absolutePath + sep : '') +
+      (mockPath ? mockPath + sep : '') +
+      (stringifiedOptions ? stringifiedOptions + sep : '');
+    this._moduleIDCache.set(key, id);
+    return id;
+  }
+  _getModuleType(moduleName) {
+    return this.isCoreModule(moduleName) ? 'node' : 'user';
+  }
+  _getAbsolutePath(virtualMocks, from, moduleName, options) {
+    if (this.isCoreModule(moduleName)) {
+      return moduleName;
+    }
+    if (moduleName.startsWith('data:')) {
+      return moduleName;
+    }
+    return this._isModuleResolved(from, moduleName)
+      ? this.getModule(moduleName)
+      : this._getVirtualMockPath(virtualMocks, from, moduleName, options);
+  }
+  async _getAbsolutePathAsync(virtualMocks, from, moduleName, options) {
+    if (this.isCoreModule(moduleName)) {
+      return moduleName;
+    }
+    if (moduleName.startsWith('data:')) {
+      return moduleName;
+    }
+    const isModuleResolved = await this._isModuleResolvedAsync(
+      from,
+      moduleName
+    );
+    return isModuleResolved
+      ? this.getModule(moduleName)
+      : this._getVirtualMockPathAsync(virtualMocks, from, moduleName, options);
+  }
+  _getMockPath(from, moduleName) {
+    return !this.isCoreModule(moduleName)
+      ? this.getMockModule(from, moduleName)
+      : null;
+  }
+  async _getMockPathAsync(from, moduleName) {
+    return !this.isCoreModule(moduleName)
+      ? this.getMockModuleAsync(from, moduleName)
+      : null;
+  }
+  _getVirtualMockPath(virtualMocks, from, moduleName, options) {
+    const virtualMockPath = this.getModulePath(from, moduleName);
+    return virtualMocks.get(virtualMockPath)
+      ? virtualMockPath
+      : moduleName
+      ? this.resolveModule(from, moduleName, options)
+      : from;
+  }
+  async _getVirtualMockPathAsync(virtualMocks, from, moduleName, options) {
+    const virtualMockPath = this.getModulePath(from, moduleName);
+    return virtualMocks.get(virtualMockPath)
+      ? virtualMockPath
+      : moduleName
+      ? this.resolveModuleAsync(from, moduleName, options)
+      : from;
+  }
+  _isModuleResolved(from, moduleName) {
+    return !!(
+      this.getModule(moduleName) || this.getMockModule(from, moduleName)
+    );
+  }
+  async _isModuleResolvedAsync(from, moduleName) {
+    return !!(
+      this.getModule(moduleName) ||
+      (await this.getMockModuleAsync(from, moduleName))
+    );
+  }
+  resolveStubModuleName(from, moduleName) {
+    const dirname = path().dirname(from);
+    const {extensions, moduleDirectory, paths} = this._prepareForResolution(
+      dirname,
+      moduleName
+    );
+    const moduleNameMapper = this._options.moduleNameMapper;
+    const resolver = this._options.resolver;
+    if (moduleNameMapper) {
+      for (const {moduleName: mappedModuleName, regex} of moduleNameMapper) {
+        if (regex.test(moduleName)) {
+          // Note: once a moduleNameMapper matches the name, it must result
+          // in a module, or else an error is thrown.
+          const matches = moduleName.match(regex);
+          const mapModuleName = this._getMapModuleName(matches);
+          const possibleModuleNames = Array.isArray(mappedModuleName)
+            ? mappedModuleName
+            : [mappedModuleName];
+          let module = null;
+          for (const possibleModuleName of possibleModuleNames) {
+            const updatedName = mapModuleName(possibleModuleName);
+            module =
+              this.getModule(updatedName) ||
+              Resolver.findNodeModule(updatedName, {
+                basedir: dirname,
+                extensions,
+                moduleDirectory,
+                paths,
+                resolver,
+                rootDir: this._options.rootDir
+              });
+            if (module) {
+              break;
+            }
+          }
+          if (!module) {
+            throw createNoMappedModuleFoundError(
+              moduleName,
+              mapModuleName,
+              mappedModuleName,
+              regex,
+              resolver
+            );
+          }
+          return module;
+        }
+      }
+    }
+    return null;
+  }
+  async resolveStubModuleNameAsync(from, moduleName) {
+    const dirname = path().dirname(from);
+    const {extensions, moduleDirectory, paths} = this._prepareForResolution(
+      dirname,
+      moduleName
+    );
+    const moduleNameMapper = this._options.moduleNameMapper;
+    const resolver = this._options.resolver;
+    if (moduleNameMapper) {
+      for (const {moduleName: mappedModuleName, regex} of moduleNameMapper) {
+        if (regex.test(moduleName)) {
+          // Note: once a moduleNameMapper matches the name, it must result
+          // in a module, or else an error is thrown.
+          const matches = moduleName.match(regex);
+          const mapModuleName = this._getMapModuleName(matches);
+          const possibleModuleNames = Array.isArray(mappedModuleName)
+            ? mappedModuleName
+            : [mappedModuleName];
+          let module = null;
+          for (const possibleModuleName of possibleModuleNames) {
+            const updatedName = mapModuleName(possibleModuleName);
+            module =
+              this.getModule(updatedName) ||
+              (await Resolver.findNodeModuleAsync(updatedName, {
+                basedir: dirname,
+                extensions,
+                moduleDirectory,
+                paths,
+                resolver,
+                rootDir: this._options.rootDir
+              }));
+            if (module) {
+              break;
+            }
+          }
+          if (!module) {
+            throw createNoMappedModuleFoundError(
+              moduleName,
+              mapModuleName,
+              mappedModuleName,
+              regex,
+              resolver
+            );
+          }
+          return module;
+        }
+      }
+    }
+    return null;
+  }
+}
+exports.default = Resolver;
+const createNoMappedModuleFoundError = (
+  moduleName,
+  mapModuleName,
+  mappedModuleName,
+  regex,
+  resolver
+) => {
+  const mappedAs = Array.isArray(mappedModuleName)
+    ? JSON.stringify(mappedModuleName.map(mapModuleName), null, 2)
+    : mappedModuleName;
+  const original = Array.isArray(mappedModuleName)
+    ? `${
+        JSON.stringify(mappedModuleName, null, 6) // using 6 because of misalignment when nested below
+          .slice(0, -1) + ' '.repeat(4)
+      }]` /// align last bracket correctly as well
+    : mappedModuleName;
+  const error = new Error(
+    _chalk().default.red(`${_chalk().default.bold('Configuration error')}:
+
+Could not locate module ${_chalk().default.bold(moduleName)} mapped as:
+${_chalk().default.bold(mappedAs)}.
+
+Please check your configuration for these entries:
+{
+  "moduleNameMapper": {
+    "${regex.toString()}": "${_chalk().default.bold(original)}"
+  },
+  "resolver": ${_chalk().default.bold(String(resolver))}
+}`)
+  );
+  error.name = '';
+  return error;
+};
+function loadResolver(resolver) {
+  if (resolver == null) {
+    return _defaultResolver.default;
+  }
+  const loadedResolver = require(resolver);
+  if (loadedResolver == null) {
+    throw new Error(`Resolver located at ${resolver} does not export anything`);
+  }
+  if (typeof loadedResolver === 'function') {
+    return loadedResolver;
+  }
+  if (
+    typeof loadedResolver === 'object' &&
+    (loadedResolver.sync != null || loadedResolver.async != null)
+  ) {
+    return loadedResolver;
+  }
+  throw new Error(
+    `Resolver located at ${resolver} does not export a function or an object with "sync" and "async" props`
+  );
+}

node_modules/jest-resolve/build/shouldLoadAsEsm.js

@@ -0,0 +1,90 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.clearCachedLookups = clearCachedLookups;
+exports.default = cachedShouldLoadAsEsm;
+function _path() {
+  const data = require('path');
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _vm() {
+  const data = require('vm');
+  _vm = function () {
+    return data;
+  };
+  return data;
+}
+var _fileWalkers = require('./fileWalkers');
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// @ts-expect-error: experimental, not added to the types
+
+const runtimeSupportsVmModules = typeof _vm().SyntheticModule === 'function';
+const cachedFileLookups = new Map();
+const cachedDirLookups = new Map();
+const cachedChecks = new Map();
+function clearCachedLookups() {
+  cachedFileLookups.clear();
+  cachedDirLookups.clear();
+  cachedChecks.clear();
+}
+function cachedShouldLoadAsEsm(path, extensionsToTreatAsEsm) {
+  if (!runtimeSupportsVmModules) {
+    return false;
+  }
+  let cachedLookup = cachedFileLookups.get(path);
+  if (cachedLookup === undefined) {
+    cachedLookup = shouldLoadAsEsm(path, extensionsToTreatAsEsm);
+    cachedFileLookups.set(path, cachedLookup);
+  }
+  return cachedLookup;
+}
+
+// this is a bad version of what https://github.com/nodejs/modules/issues/393 would provide
+function shouldLoadAsEsm(path, extensionsToTreatAsEsm) {
+  const extension = (0, _path().extname)(path);
+  if (extension === '.mjs') {
+    return true;
+  }
+  if (extension === '.cjs') {
+    return false;
+  }
+  if (extension !== '.js') {
+    return extensionsToTreatAsEsm.includes(extension);
+  }
+  const cwd = (0, _path().dirname)(path);
+  let cachedLookup = cachedDirLookups.get(cwd);
+  if (cachedLookup === undefined) {
+    cachedLookup = cachedPkgCheck(cwd);
+    cachedFileLookups.set(cwd, cachedLookup);
+  }
+  return cachedLookup;
+}
+function cachedPkgCheck(cwd) {
+  const pkgPath = (0, _fileWalkers.findClosestPackageJson)(cwd);
+  if (!pkgPath) {
+    return false;
+  }
+  let hasModuleField = cachedChecks.get(pkgPath);
+  if (hasModuleField != null) {
+    return hasModuleField;
+  }
+  try {
+    const pkg = (0, _fileWalkers.readPackageCached)(pkgPath);
+    hasModuleField = pkg.type === 'module';
+  } catch {
+    hasModuleField = false;
+  }
+  cachedChecks.set(pkgPath, hasModuleField);
+  return hasModuleField;
+}

node_modules/jest-resolve/build/types.js

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

node_modules/jest-resolve/build/utils.js

@@ -0,0 +1,233 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.resolveWatchPlugin =
+  exports.resolveTestEnvironment =
+  exports.resolveSequencer =
+  exports.resolveRunner =
+    void 0;
+function path() {
+  const data = _interopRequireWildcard(require('path'));
+  path = function () {
+    return data;
+  };
+  return data;
+}
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function _jestValidate() {
+  const data = require('jest-validate');
+  _jestValidate = function () {
+    return data;
+  };
+  return data;
+}
+var _resolver = _interopRequireDefault(require('./resolver'));
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== 'function') return null;
+  var cacheBabelInterop = new WeakMap();
+  var cacheNodeInterop = new WeakMap();
+  return (_getRequireWildcardCache = function (nodeInterop) {
+    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
+    return {default: obj};
+  }
+  var cache = _getRequireWildcardCache(nodeInterop);
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor
+        ? Object.getOwnPropertyDescriptor(obj, key)
+        : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+const BULLET = _chalk().default.bold('\u25cf ');
+const DOCUMENTATION_NOTE = `  ${_chalk().default.bold(
+  'Configuration Documentation:'
+)}
+  https://jestjs.io/docs/configuration
+`;
+const createValidationError = message =>
+  new (_jestValidate().ValidationError)(
+    `${BULLET}Validation Error`,
+    message,
+    DOCUMENTATION_NOTE
+  );
+const replaceRootDirInPath = (rootDir, filePath) => {
+  if (!/^<rootDir>/.test(filePath)) {
+    return filePath;
+  }
+  return path().resolve(
+    rootDir,
+    path().normalize(`./${filePath.substr('<rootDir>'.length)}`)
+  );
+};
+const resolveWithPrefix = (
+  resolver,
+  {
+    filePath,
+    humanOptionName,
+    optionName,
+    prefix,
+    requireResolveFunction,
+    rootDir
+  }
+) => {
+  const fileName = replaceRootDirInPath(rootDir, filePath);
+  let module = _resolver.default.findNodeModule(`${prefix}${fileName}`, {
+    basedir: rootDir,
+    resolver: resolver || undefined
+  });
+  if (module) {
+    return module;
+  }
+  try {
+    return requireResolveFunction(`${prefix}${fileName}`);
+  } catch {}
+  module = _resolver.default.findNodeModule(fileName, {
+    basedir: rootDir,
+    resolver: resolver || undefined
+  });
+  if (module) {
+    return module;
+  }
+  try {
+    return requireResolveFunction(fileName);
+  } catch {}
+  throw createValidationError(
+    `  ${humanOptionName} ${_chalk().default.bold(
+      fileName
+    )} cannot be found. Make sure the ${_chalk().default.bold(
+      optionName
+    )} configuration option points to an existing node module.`
+  );
+};
+
+/**
+ * Finds the test environment to use:
+ *
+ * 1. looks for jest-environment-<name> relative to project.
+ * 1. looks for jest-environment-<name> relative to Jest.
+ * 1. looks for <name> relative to project.
+ * 1. looks for <name> relative to Jest.
+ */
+const resolveTestEnvironment = ({
+  rootDir,
+  testEnvironment: filePath,
+  requireResolveFunction
+}) => {
+  // we don't want to resolve the actual `jsdom` module if `jest-environment-jsdom` is not installed, but `jsdom` package is
+  if (filePath === 'jsdom') {
+    filePath = 'jest-environment-jsdom';
+  }
+  try {
+    return resolveWithPrefix(undefined, {
+      filePath,
+      humanOptionName: 'Test environment',
+      optionName: 'testEnvironment',
+      prefix: 'jest-environment-',
+      requireResolveFunction,
+      rootDir
+    });
+  } catch (error) {
+    if (filePath === 'jest-environment-jsdom') {
+      error.message +=
+        '\n\nAs of Jest 28 "jest-environment-jsdom" is no longer shipped by default, make sure to install it separately.';
+    }
+    throw error;
+  }
+};
+
+/**
+ * Finds the watch plugins to use:
+ *
+ * 1. looks for jest-watch-<name> relative to project.
+ * 1. looks for jest-watch-<name> relative to Jest.
+ * 1. looks for <name> relative to project.
+ * 1. looks for <name> relative to Jest.
+ */
+exports.resolveTestEnvironment = resolveTestEnvironment;
+const resolveWatchPlugin = (
+  resolver,
+  {filePath, rootDir, requireResolveFunction}
+) =>
+  resolveWithPrefix(resolver, {
+    filePath,
+    humanOptionName: 'Watch plugin',
+    optionName: 'watchPlugins',
+    prefix: 'jest-watch-',
+    requireResolveFunction,
+    rootDir
+  });
+
+/**
+ * Finds the runner to use:
+ *
+ * 1. looks for jest-runner-<name> relative to project.
+ * 1. looks for jest-runner-<name> relative to Jest.
+ * 1. looks for <name> relative to project.
+ * 1. looks for <name> relative to Jest.
+ */
+exports.resolveWatchPlugin = resolveWatchPlugin;
+const resolveRunner = (resolver, {filePath, rootDir, requireResolveFunction}) =>
+  resolveWithPrefix(resolver, {
+    filePath,
+    humanOptionName: 'Jest Runner',
+    optionName: 'runner',
+    prefix: 'jest-runner-',
+    requireResolveFunction,
+    rootDir
+  });
+exports.resolveRunner = resolveRunner;
+const resolveSequencer = (
+  resolver,
+  {filePath, rootDir, requireResolveFunction}
+) =>
+  resolveWithPrefix(resolver, {
+    filePath,
+    humanOptionName: 'Jest Sequencer',
+    optionName: 'testSequencer',
+    prefix: 'jest-sequencer-',
+    requireResolveFunction,
+    rootDir
+  });
+exports.resolveSequencer = resolveSequencer;

node_modules/jest-resolve/node_modules/resolve/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2012 James Halliday
+
+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-resolve/node_modules/resolve/SECURITY.md

@@ -0,0 +1,3 @@
+# Security
+
+Please email [@ljharb](https://github.com/ljharb) or see https://tidelift.com/security if you have a potential security vulnerability to report.

node_modules/jest-resolve/node_modules/resolve/async.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./lib/async');

node_modules/jest-resolve/node_modules/resolve/bin/resolve

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+'use strict';
+
+var path = require('path');
+var fs = require('fs');
+
+if (
+    String(process.env.npm_lifecycle_script).slice(0, 8) !== 'resolve '
+    && (
+        !process.argv
+        || process.argv.length < 2
+        || (process.argv[1] !== __filename && fs.statSync(process.argv[1]).ino !== fs.statSync(__filename).ino)
+        || (process.env.npm_lifecycle_event !== 'npx' && process.env._ && fs.realpathSync(path.resolve(process.env._)) !== __filename)
+    )
+) {
+    console.error('Error: `resolve` must be run directly as an executable');
+    process.exit(1);
+}
+
+var supportsPreserveSymlinkFlag = require('supports-preserve-symlinks-flag');
+
+var preserveSymlinks = false;
+for (var i = 2; i < process.argv.length; i += 1) {
+    if (process.argv[i].slice(0, 2) === '--') {
+        if (supportsPreserveSymlinkFlag && process.argv[i] === '--preserve-symlinks') {
+            preserveSymlinks = true;
+        } else if (process.argv[i].length > 2) {
+            console.error('Unknown argument ' + process.argv[i].replace(/[=].*$/, ''));
+            process.exit(2);
+        }
+        process.argv.splice(i, 1);
+        i -= 1;
+        if (process.argv[i] === '--') { break; } // eslint-disable-line no-restricted-syntax
+    }
+}
+
+if (process.argv.length < 3) {
+    console.error('Error: `resolve` expects a specifier');
+    process.exit(2);
+}
+
+var resolve = require('../');
+
+var result = resolve.sync(process.argv[2], {
+    basedir: process.cwd(),
+    preserveSymlinks: preserveSymlinks
+});
+
+console.log(result);

node_modules/jest-resolve/node_modules/resolve/example/async.js

@@ -0,0 +1,5 @@
+var resolve = require('../');
+resolve('tap', { basedir: __dirname }, function (err, res) {
+    if (err) console.error(err);
+    else console.log(res);
+});

node_modules/jest-resolve/node_modules/resolve/example/sync.js

@@ -0,0 +1,3 @@
+var resolve = require('../');
+var res = resolve.sync('tap', { basedir: __dirname });
+console.log(res);

node_modules/jest-resolve/node_modules/resolve/index.js

@@ -0,0 +1,6 @@
+var async = require('./lib/async');
+async.core = require('./lib/core');
+async.isCore = require('./lib/is-core');
+async.sync = require('./lib/sync');
+
+module.exports = async;

node_modules/jest-resolve/node_modules/resolve/lib/async.js

@@ -0,0 +1,329 @@
+var fs = require('fs');
+var getHomedir = require('./homedir');
+var path = require('path');
+var caller = require('./caller');
+var nodeModulesPaths = require('./node-modules-paths');
+var normalizeOptions = require('./normalize-options');
+var isCore = require('is-core-module');
+
+var realpathFS = process.platform !== 'win32' && fs.realpath && typeof fs.realpath.native === 'function' ? fs.realpath.native : fs.realpath;
+
+var homedir = getHomedir();
+var defaultPaths = function () {
+    return [
+        path.join(homedir, '.node_modules'),
+        path.join(homedir, '.node_libraries')
+    ];
+};
+
+var defaultIsFile = function isFile(file, cb) {
+    fs.stat(file, function (err, stat) {
+        if (!err) {
+            return cb(null, stat.isFile() || stat.isFIFO());
+        }
+        if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
+        return cb(err);
+    });
+};
+
+var defaultIsDir = function isDirectory(dir, cb) {
+    fs.stat(dir, function (err, stat) {
+        if (!err) {
+            return cb(null, stat.isDirectory());
+        }
+        if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
+        return cb(err);
+    });
+};
+
+var defaultRealpath = function realpath(x, cb) {
+    realpathFS(x, function (realpathErr, realPath) {
+        if (realpathErr && realpathErr.code !== 'ENOENT') cb(realpathErr);
+        else cb(null, realpathErr ? x : realPath);
+    });
+};
+
+var maybeRealpath = function maybeRealpath(realpath, x, opts, cb) {
+    if (opts && opts.preserveSymlinks === false) {
+        realpath(x, cb);
+    } else {
+        cb(null, x);
+    }
+};
+
+var defaultReadPackage = function defaultReadPackage(readFile, pkgfile, cb) {
+    readFile(pkgfile, function (readFileErr, body) {
+        if (readFileErr) cb(readFileErr);
+        else {
+            try {
+                var pkg = JSON.parse(body);
+                cb(null, pkg);
+            } catch (jsonErr) {
+                cb(null);
+            }
+        }
+    });
+};
+
+var getPackageCandidates = function getPackageCandidates(x, start, opts) {
+    var dirs = nodeModulesPaths(start, opts, x);
+    for (var i = 0; i < dirs.length; i++) {
+        dirs[i] = path.join(dirs[i], x);
+    }
+    return dirs;
+};
+
+module.exports = function resolve(x, options, callback) {
+    var cb = callback;
+    var opts = options;
+    if (typeof options === 'function') {
+        cb = opts;
+        opts = {};
+    }
+    if (typeof x !== 'string') {
+        var err = new TypeError('Path must be a string.');
+        return process.nextTick(function () {
+            cb(err);
+        });
+    }
+
+    opts = normalizeOptions(x, opts);
+
+    var isFile = opts.isFile || defaultIsFile;
+    var isDirectory = opts.isDirectory || defaultIsDir;
+    var readFile = opts.readFile || fs.readFile;
+    var realpath = opts.realpath || defaultRealpath;
+    var readPackage = opts.readPackage || defaultReadPackage;
+    if (opts.readFile && opts.readPackage) {
+        var conflictErr = new TypeError('`readFile` and `readPackage` are mutually exclusive.');
+        return process.nextTick(function () {
+            cb(conflictErr);
+        });
+    }
+    var packageIterator = opts.packageIterator;
+
+    var extensions = opts.extensions || ['.js'];
+    var includeCoreModules = opts.includeCoreModules !== false;
+    var basedir = opts.basedir || path.dirname(caller());
+    var parent = opts.filename || basedir;
+
+    opts.paths = opts.paths || defaultPaths();
+
+    // ensure that `basedir` is an absolute path at this point, resolving against the process' current working directory
+    var absoluteStart = path.resolve(basedir);
+
+    maybeRealpath(
+        realpath,
+        absoluteStart,
+        opts,
+        function (err, realStart) {
+            if (err) cb(err);
+            else init(realStart);
+        }
+    );
+
+    var res;
+    function init(basedir) {
+        if ((/^(?:\.\.?(?:\/|$)|\/|([A-Za-z]:)?[/\\])/).test(x)) {
+            res = path.resolve(basedir, x);
+            if (x === '.' || x === '..' || x.slice(-1) === '/') res += '/';
+            if ((/\/$/).test(x) && res === basedir) {
+                loadAsDirectory(res, opts.package, onfile);
+            } else loadAsFile(res, opts.package, onfile);
+        } else if (includeCoreModules && isCore(x)) {
+            return cb(null, x);
+        } else loadNodeModules(x, basedir, function (err, n, pkg) {
+            if (err) cb(err);
+            else if (n) {
+                return maybeRealpath(realpath, n, opts, function (err, realN) {
+                    if (err) {
+                        cb(err);
+                    } else {
+                        cb(null, realN, pkg);
+                    }
+                });
+            } else {
+                var moduleError = new Error("Cannot find module '" + x + "' from '" + parent + "'");
+                moduleError.code = 'MODULE_NOT_FOUND';
+                cb(moduleError);
+            }
+        });
+    }
+
+    function onfile(err, m, pkg) {
+        if (err) cb(err);
+        else if (m) cb(null, m, pkg);
+        else loadAsDirectory(res, function (err, d, pkg) {
+            if (err) cb(err);
+            else if (d) {
+                maybeRealpath(realpath, d, opts, function (err, realD) {
+                    if (err) {
+                        cb(err);
+                    } else {
+                        cb(null, realD, pkg);
+                    }
+                });
+            } else {
+                var moduleError = new Error("Cannot find module '" + x + "' from '" + parent + "'");
+                moduleError.code = 'MODULE_NOT_FOUND';
+                cb(moduleError);
+            }
+        });
+    }
+
+    function loadAsFile(x, thePackage, callback) {
+        var loadAsFilePackage = thePackage;
+        var cb = callback;
+        if (typeof loadAsFilePackage === 'function') {
+            cb = loadAsFilePackage;
+            loadAsFilePackage = undefined;
+        }
+
+        var exts = [''].concat(extensions);
+        load(exts, x, loadAsFilePackage);
+
+        function load(exts, x, loadPackage) {
+            if (exts.length === 0) return cb(null, undefined, loadPackage);
+            var file = x + exts[0];
+
+            var pkg = loadPackage;
+            if (pkg) onpkg(null, pkg);
+            else loadpkg(path.dirname(file), onpkg);
+
+            function onpkg(err, pkg_, dir) {
+                pkg = pkg_;
+                if (err) return cb(err);
+                if (dir && pkg && opts.pathFilter) {
+                    var rfile = path.relative(dir, file);
+                    var rel = rfile.slice(0, rfile.length - exts[0].length);
+                    var r = opts.pathFilter(pkg, x, rel);
+                    if (r) return load(
+                        [''].concat(extensions.slice()),
+                        path.resolve(dir, r),
+                        pkg
+                    );
+                }
+                isFile(file, onex);
+            }
+            function onex(err, ex) {
+                if (err) return cb(err);
+                if (ex) return cb(null, file, pkg);
+                load(exts.slice(1), x, pkg);
+            }
+        }
+    }
+
+    function loadpkg(dir, cb) {
+        if (dir === '' || dir === '/') return cb(null);
+        if (process.platform === 'win32' && (/^\w:[/\\]*$/).test(dir)) {
+            return cb(null);
+        }
+        if ((/[/\\]node_modules[/\\]*$/).test(dir)) return cb(null);
+
+        maybeRealpath(realpath, dir, opts, function (unwrapErr, pkgdir) {
+            if (unwrapErr) return loadpkg(path.dirname(dir), cb);
+            var pkgfile = path.join(pkgdir, 'package.json');
+            isFile(pkgfile, function (err, ex) {
+                // on err, ex is false
+                if (!ex) return loadpkg(path.dirname(dir), cb);
+
+                readPackage(readFile, pkgfile, function (err, pkgParam) {
+                    if (err) cb(err);
+
+                    var pkg = pkgParam;
+
+                    if (pkg && opts.packageFilter) {
+                        pkg = opts.packageFilter(pkg, pkgfile);
+                    }
+                    cb(null, pkg, dir);
+                });
+            });
+        });
+    }
+
+    function loadAsDirectory(x, loadAsDirectoryPackage, callback) {
+        var cb = callback;
+        var fpkg = loadAsDirectoryPackage;
+        if (typeof fpkg === 'function') {
+            cb = fpkg;
+            fpkg = opts.package;
+        }
+
+        maybeRealpath(realpath, x, opts, function (unwrapErr, pkgdir) {
+            if (unwrapErr) return cb(unwrapErr);
+            var pkgfile = path.join(pkgdir, 'package.json');
+            isFile(pkgfile, function (err, ex) {
+                if (err) return cb(err);
+                if (!ex) return loadAsFile(path.join(x, 'index'), fpkg, cb);
+
+                readPackage(readFile, pkgfile, function (err, pkgParam) {
+                    if (err) return cb(err);
+
+                    var pkg = pkgParam;
+
+                    if (pkg && opts.packageFilter) {
+                        pkg = opts.packageFilter(pkg, pkgfile);
+                    }
+
+                    if (pkg && pkg.main) {
+                        if (typeof pkg.main !== 'string') {
+                            var mainError = new TypeError('package “' + pkg.name + '” `main` must be a string');
+                            mainError.code = 'INVALID_PACKAGE_MAIN';
+                            return cb(mainError);
+                        }
+                        if (pkg.main === '.' || pkg.main === './') {
+                            pkg.main = 'index';
+                        }
+                        loadAsFile(path.resolve(x, pkg.main), pkg, function (err, m, pkg) {
+                            if (err) return cb(err);
+                            if (m) return cb(null, m, pkg);
+                            if (!pkg) return loadAsFile(path.join(x, 'index'), pkg, cb);
+
+                            var dir = path.resolve(x, pkg.main);
+                            loadAsDirectory(dir, pkg, function (err, n, pkg) {
+                                if (err) return cb(err);
+                                if (n) return cb(null, n, pkg);
+                                loadAsFile(path.join(x, 'index'), pkg, cb);
+                            });
+                        });
+                        return;
+                    }
+
+                    loadAsFile(path.join(x, '/index'), pkg, cb);
+                });
+            });
+        });
+    }
+
+    function processDirs(cb, dirs) {
+        if (dirs.length === 0) return cb(null, undefined);
+        var dir = dirs[0];
+
+        isDirectory(path.dirname(dir), isdir);
+
+        function isdir(err, isdir) {
+            if (err) return cb(err);
+            if (!isdir) return processDirs(cb, dirs.slice(1));
+            loadAsFile(dir, opts.package, onfile);
+        }
+
+        function onfile(err, m, pkg) {
+            if (err) return cb(err);
+            if (m) return cb(null, m, pkg);
+            loadAsDirectory(dir, opts.package, ondir);
+        }
+
+        function ondir(err, n, pkg) {
+            if (err) return cb(err);
+            if (n) return cb(null, n, pkg);
+            processDirs(cb, dirs.slice(1));
+        }
+    }
+    function loadNodeModules(x, start, cb) {
+        var thunk = function () { return getPackageCandidates(x, start, opts); };
+        processDirs(
+            cb,
+            packageIterator ? packageIterator(x, start, thunk, opts) : thunk()
+        );
+    }
+};

node_modules/jest-resolve/node_modules/resolve/lib/caller.js

@@ -0,0 +1,8 @@
+module.exports = function () {
+    // see https://code.google.com/p/v8/wiki/JavaScriptStackTraceApi
+    var origPrepareStackTrace = Error.prepareStackTrace;
+    Error.prepareStackTrace = function (_, stack) { return stack; };
+    var stack = (new Error()).stack;
+    Error.prepareStackTrace = origPrepareStackTrace;
+    return stack[2].getFileName();
+};

node_modules/jest-resolve/node_modules/resolve/lib/core.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var isCoreModule = require('is-core-module');
+var data = require('./core.json');
+
+var core = {};
+for (var mod in data) { // eslint-disable-line no-restricted-syntax
+    if (Object.prototype.hasOwnProperty.call(data, mod)) {
+        core[mod] = isCoreModule(mod);
+    }
+}
+module.exports = core;

node_modules/jest-resolve/node_modules/resolve/lib/core.json

@@ -0,0 +1,158 @@
+{
+	"assert": true,
+	"node:assert": [">= 14.18 && < 15", ">= 16"],
+	"assert/strict": ">= 15",
+	"node:assert/strict": ">= 16",
+	"async_hooks": ">= 8",
+	"node:async_hooks": [">= 14.18 && < 15", ">= 16"],
+	"buffer_ieee754": ">= 0.5 && < 0.9.7",
+	"buffer": true,
+	"node:buffer": [">= 14.18 && < 15", ">= 16"],
+	"child_process": true,
+	"node:child_process": [">= 14.18 && < 15", ">= 16"],
+	"cluster": ">= 0.5",
+	"node:cluster": [">= 14.18 && < 15", ">= 16"],
+	"console": true,
+	"node:console": [">= 14.18 && < 15", ">= 16"],
+	"constants": true,
+	"node:constants": [">= 14.18 && < 15", ">= 16"],
+	"crypto": true,
+	"node:crypto": [">= 14.18 && < 15", ">= 16"],
+	"_debug_agent": ">= 1 && < 8",
+	"_debugger": "< 8",
+	"dgram": true,
+	"node:dgram": [">= 14.18 && < 15", ">= 16"],
+	"diagnostics_channel": [">= 14.17 && < 15", ">= 15.1"],
+	"node:diagnostics_channel": [">= 14.18 && < 15", ">= 16"],
+	"dns": true,
+	"node:dns": [">= 14.18 && < 15", ">= 16"],
+	"dns/promises": ">= 15",
+	"node:dns/promises": ">= 16",
+	"domain": ">= 0.7.12",
+	"node:domain": [">= 14.18 && < 15", ">= 16"],
+	"events": true,
+	"node:events": [">= 14.18 && < 15", ">= 16"],
+	"freelist": "< 6",
+	"fs": true,
+	"node:fs": [">= 14.18 && < 15", ">= 16"],
+	"fs/promises": [">= 10 && < 10.1", ">= 14"],
+	"node:fs/promises": [">= 14.18 && < 15", ">= 16"],
+	"_http_agent": ">= 0.11.1",
+	"node:_http_agent": [">= 14.18 && < 15", ">= 16"],
+	"_http_client": ">= 0.11.1",
+	"node:_http_client": [">= 14.18 && < 15", ">= 16"],
+	"_http_common": ">= 0.11.1",
+	"node:_http_common": [">= 14.18 && < 15", ">= 16"],
+	"_http_incoming": ">= 0.11.1",
+	"node:_http_incoming": [">= 14.18 && < 15", ">= 16"],
+	"_http_outgoing": ">= 0.11.1",
+	"node:_http_outgoing": [">= 14.18 && < 15", ">= 16"],
+	"_http_server": ">= 0.11.1",
+	"node:_http_server": [">= 14.18 && < 15", ">= 16"],
+	"http": true,
+	"node:http": [">= 14.18 && < 15", ">= 16"],
+	"http2": ">= 8.8",
+	"node:http2": [">= 14.18 && < 15", ">= 16"],
+	"https": true,
+	"node:https": [">= 14.18 && < 15", ">= 16"],
+	"inspector": ">= 8",
+	"node:inspector": [">= 14.18 && < 15", ">= 16"],
+	"inspector/promises": [">= 19"],
+	"node:inspector/promises": [">= 19"],
+	"_linklist": "< 8",
+	"module": true,
+	"node:module": [">= 14.18 && < 15", ">= 16"],
+	"net": true,
+	"node:net": [">= 14.18 && < 15", ">= 16"],
+	"node-inspect/lib/_inspect": ">= 7.6 && < 12",
+	"node-inspect/lib/internal/inspect_client": ">= 7.6 && < 12",
+	"node-inspect/lib/internal/inspect_repl": ">= 7.6 && < 12",
+	"os": true,
+	"node:os": [">= 14.18 && < 15", ">= 16"],
+	"path": true,
+	"node:path": [">= 14.18 && < 15", ">= 16"],
+	"path/posix": ">= 15.3",
+	"node:path/posix": ">= 16",
+	"path/win32": ">= 15.3",
+	"node:path/win32": ">= 16",
+	"perf_hooks": ">= 8.5",
+	"node:perf_hooks": [">= 14.18 && < 15", ">= 16"],
+	"process": ">= 1",
+	"node:process": [">= 14.18 && < 15", ">= 16"],
+	"punycode": ">= 0.5",
+	"node:punycode": [">= 14.18 && < 15", ">= 16"],
+	"querystring": true,
+	"node:querystring": [">= 14.18 && < 15", ">= 16"],
+	"readline": true,
+	"node:readline": [">= 14.18 && < 15", ">= 16"],
+	"readline/promises": ">= 17",
+	"node:readline/promises": ">= 17",
+	"repl": true,
+	"node:repl": [">= 14.18 && < 15", ">= 16"],
+	"smalloc": ">= 0.11.5 && < 3",
+	"_stream_duplex": ">= 0.9.4",
+	"node:_stream_duplex": [">= 14.18 && < 15", ">= 16"],
+	"_stream_transform": ">= 0.9.4",
+	"node:_stream_transform": [">= 14.18 && < 15", ">= 16"],
+	"_stream_wrap": ">= 1.4.1",
+	"node:_stream_wrap": [">= 14.18 && < 15", ">= 16"],
+	"_stream_passthrough": ">= 0.9.4",
+	"node:_stream_passthrough": [">= 14.18 && < 15", ">= 16"],
+	"_stream_readable": ">= 0.9.4",
+	"node:_stream_readable": [">= 14.18 && < 15", ">= 16"],
+	"_stream_writable": ">= 0.9.4",
+	"node:_stream_writable": [">= 14.18 && < 15", ">= 16"],
+	"stream": true,
+	"node:stream": [">= 14.18 && < 15", ">= 16"],
+	"stream/consumers": ">= 16.7",
+	"node:stream/consumers": ">= 16.7",
+	"stream/promises": ">= 15",
+	"node:stream/promises": ">= 16",
+	"stream/web": ">= 16.5",
+	"node:stream/web": ">= 16.5",
+	"string_decoder": true,
+	"node:string_decoder": [">= 14.18 && < 15", ">= 16"],
+	"sys": [">= 0.4 && < 0.7", ">= 0.8"],
+	"node:sys": [">= 14.18 && < 15", ">= 16"],
+	"test/reporters": ">= 19.9 && < 20.2",
+	"node:test/reporters": [">= 18.17 && < 19", ">= 19.9", ">= 20"],
+	"node:test": [">= 16.17 && < 17", ">= 18"],
+	"timers": true,
+	"node:timers": [">= 14.18 && < 15", ">= 16"],
+	"timers/promises": ">= 15",
+	"node:timers/promises": ">= 16",
+	"_tls_common": ">= 0.11.13",
+	"node:_tls_common": [">= 14.18 && < 15", ">= 16"],
+	"_tls_legacy": ">= 0.11.3 && < 10",
+	"_tls_wrap": ">= 0.11.3",
+	"node:_tls_wrap": [">= 14.18 && < 15", ">= 16"],
+	"tls": true,
+	"node:tls": [">= 14.18 && < 15", ">= 16"],
+	"trace_events": ">= 10",
+	"node:trace_events": [">= 14.18 && < 15", ">= 16"],
+	"tty": true,
+	"node:tty": [">= 14.18 && < 15", ">= 16"],
+	"url": true,
+	"node:url": [">= 14.18 && < 15", ">= 16"],
+	"util": true,
+	"node:util": [">= 14.18 && < 15", ">= 16"],
+	"util/types": ">= 15.3",
+	"node:util/types": ">= 16",
+	"v8/tools/arguments": ">= 10 && < 12",
+	"v8/tools/codemap": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+	"v8/tools/consarray": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+	"v8/tools/csvparser": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+	"v8/tools/logreader": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+	"v8/tools/profile_view": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+	"v8/tools/splaytree": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+	"v8": ">= 1",
+	"node:v8": [">= 14.18 && < 15", ">= 16"],
+	"vm": true,
+	"node:vm": [">= 14.18 && < 15", ">= 16"],
+	"wasi": [">= 13.4 && < 13.5", ">= 18.17 && < 19", ">= 20"],
+	"node:wasi": [">= 18.17 && < 19", ">= 20"],
+	"worker_threads": ">= 11.7",
+	"node:worker_threads": [">= 14.18 && < 15", ">= 16"],
+	"zlib": ">= 0.5",
+	"node:zlib": [">= 14.18 && < 15", ">= 16"]
+}

node_modules/jest-resolve/node_modules/resolve/lib/homedir.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var os = require('os');
+
+// adapted from https://github.com/sindresorhus/os-homedir/blob/11e089f4754db38bb535e5a8416320c4446e8cfd/index.js
+
+module.exports = os.homedir || function homedir() {
+    var home = process.env.HOME;
+    var user = process.env.LOGNAME || process.env.USER || process.env.LNAME || process.env.USERNAME;
+
+    if (process.platform === 'win32') {
+        return process.env.USERPROFILE || process.env.HOMEDRIVE + process.env.HOMEPATH || home || null;
+    }
+
+    if (process.platform === 'darwin') {
+        return home || (user ? '/Users/' + user : null);
+    }
+
+    if (process.platform === 'linux') {
+        return home || (process.getuid() === 0 ? '/root' : (user ? '/home/' + user : null)); // eslint-disable-line no-extra-parens
+    }
+
+    return home || null;
+};

node_modules/jest-resolve/node_modules/resolve/lib/is-core.js

@@ -0,0 +1,5 @@
+var isCoreModule = require('is-core-module');
+
+module.exports = function isCore(x) {
+    return isCoreModule(x);
+};

node_modules/jest-resolve/node_modules/resolve/lib/node-modules-paths.js

@@ -0,0 +1,42 @@
+var path = require('path');
+var parse = path.parse || require('path-parse'); // eslint-disable-line global-require
+
+var getNodeModulesDirs = function getNodeModulesDirs(absoluteStart, modules) {
+    var prefix = '/';
+    if ((/^([A-Za-z]:)/).test(absoluteStart)) {
+        prefix = '';
+    } else if ((/^\\\\/).test(absoluteStart)) {
+        prefix = '\\\\';
+    }
+
+    var paths = [absoluteStart];
+    var parsed = parse(absoluteStart);
+    while (parsed.dir !== paths[paths.length - 1]) {
+        paths.push(parsed.dir);
+        parsed = parse(parsed.dir);
+    }
+
+    return paths.reduce(function (dirs, aPath) {
+        return dirs.concat(modules.map(function (moduleDir) {
+            return path.resolve(prefix, aPath, moduleDir);
+        }));
+    }, []);
+};
+
+module.exports = function nodeModulesPaths(start, opts, request) {
+    var modules = opts && opts.moduleDirectory
+        ? [].concat(opts.moduleDirectory)
+        : ['node_modules'];
+
+    if (opts && typeof opts.paths === 'function') {
+        return opts.paths(
+            request,
+            start,
+            function () { return getNodeModulesDirs(start, modules); },
+            opts
+        );
+    }
+
+    var dirs = getNodeModulesDirs(start, modules);
+    return opts && opts.paths ? dirs.concat(opts.paths) : dirs;
+};

node_modules/jest-resolve/node_modules/resolve/lib/normalize-options.js

@@ -0,0 +1,10 @@
+module.exports = function (x, opts) {
+    /**
+     * This file is purposefully a passthrough. It's expected that third-party
+     * environments will override it at runtime in order to inject special logic
+     * into `resolve` (by manipulating the options). One such example is the PnP
+     * code path in Yarn.
+     */
+
+    return opts || {};
+};

node_modules/jest-resolve/node_modules/resolve/lib/sync.js

@@ -0,0 +1,208 @@
+var isCore = require('is-core-module');
+var fs = require('fs');
+var path = require('path');
+var getHomedir = require('./homedir');
+var caller = require('./caller');
+var nodeModulesPaths = require('./node-modules-paths');
+var normalizeOptions = require('./normalize-options');
+
+var realpathFS = process.platform !== 'win32' && fs.realpathSync && typeof fs.realpathSync.native === 'function' ? fs.realpathSync.native : fs.realpathSync;
+
+var homedir = getHomedir();
+var defaultPaths = function () {
+    return [
+        path.join(homedir, '.node_modules'),
+        path.join(homedir, '.node_libraries')
+    ];
+};
+
+var defaultIsFile = function isFile(file) {
+    try {
+        var stat = fs.statSync(file, { throwIfNoEntry: false });
+    } catch (e) {
+        if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return false;
+        throw e;
+    }
+    return !!stat && (stat.isFile() || stat.isFIFO());
+};
+
+var defaultIsDir = function isDirectory(dir) {
+    try {
+        var stat = fs.statSync(dir, { throwIfNoEntry: false });
+    } catch (e) {
+        if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return false;
+        throw e;
+    }
+    return !!stat && stat.isDirectory();
+};
+
+var defaultRealpathSync = function realpathSync(x) {
+    try {
+        return realpathFS(x);
+    } catch (realpathErr) {
+        if (realpathErr.code !== 'ENOENT') {
+            throw realpathErr;
+        }
+    }
+    return x;
+};
+
+var maybeRealpathSync = function maybeRealpathSync(realpathSync, x, opts) {
+    if (opts && opts.preserveSymlinks === false) {
+        return realpathSync(x);
+    }
+    return x;
+};
+
+var defaultReadPackageSync = function defaultReadPackageSync(readFileSync, pkgfile) {
+    var body = readFileSync(pkgfile);
+    try {
+        var pkg = JSON.parse(body);
+        return pkg;
+    } catch (jsonErr) {}
+};
+
+var getPackageCandidates = function getPackageCandidates(x, start, opts) {
+    var dirs = nodeModulesPaths(start, opts, x);
+    for (var i = 0; i < dirs.length; i++) {
+        dirs[i] = path.join(dirs[i], x);
+    }
+    return dirs;
+};
+
+module.exports = function resolveSync(x, options) {
+    if (typeof x !== 'string') {
+        throw new TypeError('Path must be a string.');
+    }
+    var opts = normalizeOptions(x, options);
+
+    var isFile = opts.isFile || defaultIsFile;
+    var readFileSync = opts.readFileSync || fs.readFileSync;
+    var isDirectory = opts.isDirectory || defaultIsDir;
+    var realpathSync = opts.realpathSync || defaultRealpathSync;
+    var readPackageSync = opts.readPackageSync || defaultReadPackageSync;
+    if (opts.readFileSync && opts.readPackageSync) {
+        throw new TypeError('`readFileSync` and `readPackageSync` are mutually exclusive.');
+    }
+    var packageIterator = opts.packageIterator;
+
+    var extensions = opts.extensions || ['.js'];
+    var includeCoreModules = opts.includeCoreModules !== false;
+    var basedir = opts.basedir || path.dirname(caller());
+    var parent = opts.filename || basedir;
+
+    opts.paths = opts.paths || defaultPaths();
+
+    // ensure that `basedir` is an absolute path at this point, resolving against the process' current working directory
+    var absoluteStart = maybeRealpathSync(realpathSync, path.resolve(basedir), opts);
+
+    if ((/^(?:\.\.?(?:\/|$)|\/|([A-Za-z]:)?[/\\])/).test(x)) {
+        var res = path.resolve(absoluteStart, x);
+        if (x === '.' || x === '..' || x.slice(-1) === '/') res += '/';
+        var m = loadAsFileSync(res) || loadAsDirectorySync(res);
+        if (m) return maybeRealpathSync(realpathSync, m, opts);
+    } else if (includeCoreModules && isCore(x)) {
+        return x;
+    } else {
+        var n = loadNodeModulesSync(x, absoluteStart);
+        if (n) return maybeRealpathSync(realpathSync, n, opts);
+    }
+
+    var err = new Error("Cannot find module '" + x + "' from '" + parent + "'");
+    err.code = 'MODULE_NOT_FOUND';
+    throw err;
+
+    function loadAsFileSync(x) {
+        var pkg = loadpkg(path.dirname(x));
+
+        if (pkg && pkg.dir && pkg.pkg && opts.pathFilter) {
+            var rfile = path.relative(pkg.dir, x);
+            var r = opts.pathFilter(pkg.pkg, x, rfile);
+            if (r) {
+                x = path.resolve(pkg.dir, r); // eslint-disable-line no-param-reassign
+            }
+        }
+
+        if (isFile(x)) {
+            return x;
+        }
+
+        for (var i = 0; i < extensions.length; i++) {
+            var file = x + extensions[i];
+            if (isFile(file)) {
+                return file;
+            }
+        }
+    }
+
+    function loadpkg(dir) {
+        if (dir === '' || dir === '/') return;
+        if (process.platform === 'win32' && (/^\w:[/\\]*$/).test(dir)) {
+            return;
+        }
+        if ((/[/\\]node_modules[/\\]*$/).test(dir)) return;
+
+        var pkgfile = path.join(maybeRealpathSync(realpathSync, dir, opts), 'package.json');
+
+        if (!isFile(pkgfile)) {
+            return loadpkg(path.dirname(dir));
+        }
+
+        var pkg = readPackageSync(readFileSync, pkgfile);
+
+        if (pkg && opts.packageFilter) {
+            // v2 will pass pkgfile
+            pkg = opts.packageFilter(pkg, /*pkgfile,*/ dir); // eslint-disable-line spaced-comment
+        }
+
+        return { pkg: pkg, dir: dir };
+    }
+
+    function loadAsDirectorySync(x) {
+        var pkgfile = path.join(maybeRealpathSync(realpathSync, x, opts), '/package.json');
+        if (isFile(pkgfile)) {
+            try {
+                var pkg = readPackageSync(readFileSync, pkgfile);
+            } catch (e) {}
+
+            if (pkg && opts.packageFilter) {
+                // v2 will pass pkgfile
+                pkg = opts.packageFilter(pkg, /*pkgfile,*/ x); // eslint-disable-line spaced-comment
+            }
+
+            if (pkg && pkg.main) {
+                if (typeof pkg.main !== 'string') {
+                    var mainError = new TypeError('package “' + pkg.name + '” `main` must be a string');
+                    mainError.code = 'INVALID_PACKAGE_MAIN';
+                    throw mainError;
+                }
+                if (pkg.main === '.' || pkg.main === './') {
+                    pkg.main = 'index';
+                }
+                try {
+                    var m = loadAsFileSync(path.resolve(x, pkg.main));
+                    if (m) return m;
+                    var n = loadAsDirectorySync(path.resolve(x, pkg.main));
+                    if (n) return n;
+                } catch (e) {}
+            }
+        }
+
+        return loadAsFileSync(path.join(x, '/index'));
+    }
+
+    function loadNodeModulesSync(x, start) {
+        var thunk = function () { return getPackageCandidates(x, start, opts); };
+        var dirs = packageIterator ? packageIterator(x, start, thunk, opts) : thunk();
+
+        for (var i = 0; i < dirs.length; i++) {
+            var dir = dirs[i];
+            if (isDirectory(path.dirname(dir))) {
+                var m = loadAsFileSync(dir);
+                if (m) return m;
+                var n = loadAsDirectorySync(dir);
+                if (n) return n;
+            }
+        }
+    }
+};

node_modules/jest-resolve/node_modules/resolve/package.json

@@ -0,0 +1,72 @@
+{
+	"name": "resolve",
+	"description": "resolve like require.resolve() on behalf of files asynchronously and synchronously",
+	"version": "1.22.8",
+	"repository": {
+		"type": "git",
+		"url": "git://github.com/browserify/resolve.git"
+	},
+	"bin": {
+		"resolve": "./bin/resolve"
+	},
+	"main": "index.js",
+	"keywords": [
+		"resolve",
+		"require",
+		"node",
+		"module"
+	],
+	"scripts": {
+		"prepack": "npmignore --auto --commentLines=autogenerated && cp node_modules/is-core-module/core.json ./lib/ ||:",
+		"prepublishOnly": "safe-publish-latest",
+		"prepublish": "not-in-publish || npm run prepublishOnly",
+		"prelint": "eclint check $(git ls-files | xargs find 2> /dev/null | grep -vE 'node_modules|\\.git')",
+		"lint": "eslint --ext=js,mjs --no-eslintrc -c .eslintrc . 'bin/**'",
+		"pretests-only": "cd ./test/resolver/nested_symlinks && node mylib/sync && node mylib/async",
+		"tests-only": "tape test/*.js",
+		"pretest": "npm run lint",
+		"test": "npm run --silent tests-only",
+		"posttest": "npm run test:multirepo && aud --production",
+		"test:multirepo": "cd ./test/resolver/multirepo && npm install && npm test"
+	},
+	"devDependencies": {
+		"@ljharb/eslint-config": "^21.1.0",
+		"array.prototype.map": "^1.0.6",
+		"aud": "^2.0.3",
+		"copy-dir": "^1.3.0",
+		"eclint": "^2.8.1",
+		"eslint": "=8.8.0",
+		"in-publish": "^2.0.1",
+		"mkdirp": "^0.5.5",
+		"mv": "^2.1.1",
+		"npmignore": "^0.3.0",
+		"object-keys": "^1.1.1",
+		"rimraf": "^2.7.1",
+		"safe-publish-latest": "^2.0.0",
+		"semver": "^6.3.1",
+		"tap": "0.4.13",
+		"tape": "^5.7.0",
+		"tmp": "^0.0.31"
+	},
+	"license": "MIT",
+	"author": {
+		"name": "James Halliday",
+		"email": "mail@substack.net",
+		"url": "http://substack.net"
+	},
+	"funding": {
+		"url": "https://github.com/sponsors/ljharb"
+	},
+	"dependencies": {
+		"is-core-module": "^2.13.0",
+		"path-parse": "^1.0.7",
+		"supports-preserve-symlinks-flag": "^1.0.0"
+	},
+	"publishConfig": {
+		"ignore": [
+			".github/workflows",
+			"appveyor.yml",
+			"test/resolver/malformed_package_json"
+		]
+	}
+}

node_modules/jest-resolve/node_modules/resolve/readme.markdown

@@ -0,0 +1,301 @@
+# resolve <sup>[![Version Badge][2]][1]</sup>
+
+implements the [node `require.resolve()` algorithm](https://nodejs.org/api/modules.html#modules_all_together) such that you can `require.resolve()` on behalf of a file asynchronously and synchronously
+
+[![github actions][actions-image]][actions-url]
+[![coverage][codecov-image]][codecov-url]
+[![dependency status][5]][6]
+[![dev dependency status][7]][8]
+[![License][license-image]][license-url]
+[![Downloads][downloads-image]][downloads-url]
+
+[![npm badge][11]][1]
+
+# example
+
+asynchronously resolve:
+
+```js
+var resolve = require('resolve/async'); // or, require('resolve')
+resolve('tap', { basedir: __dirname }, function (err, res) {
+    if (err) console.error(err);
+    else console.log(res);
+});
+```
+
+```
+$ node example/async.js
+/home/substack/projects/node-resolve/node_modules/tap/lib/main.js
+```
+
+synchronously resolve:
+
+```js
+var resolve = require('resolve/sync'); // or, `require('resolve').sync
+var res = resolve('tap', { basedir: __dirname });
+console.log(res);
+```
+
+```
+$ node example/sync.js
+/home/substack/projects/node-resolve/node_modules/tap/lib/main.js
+```
+
+# methods
+
+```js
+var resolve = require('resolve');
+var async = require('resolve/async');
+var sync = require('resolve/sync');
+```
+
+For both the synchronous and asynchronous methods, errors may have any of the following `err.code` values:
+
+- `MODULE_NOT_FOUND`: the given path string (`id`) could not be resolved to a module
+- `INVALID_BASEDIR`: the specified `opts.basedir` doesn't exist, or is not a directory
+- `INVALID_PACKAGE_MAIN`: a `package.json` was encountered with an invalid `main` property (eg. not a string)
+
+## resolve(id, opts={}, cb)
+
+Asynchronously resolve the module path string `id` into `cb(err, res [, pkg])`, where `pkg` (if defined) is the data from `package.json`.
+
+options are:
+
+* opts.basedir - directory to begin resolving from
+
+* opts.package - `package.json` data applicable to the module being loaded
+
+* opts.extensions - array of file extensions to search in order
+
+* opts.includeCoreModules - set to `false` to exclude node core modules (e.g. `fs`) from the search
+
+* opts.readFile - how to read files asynchronously
+
+* opts.isFile - function to asynchronously test whether a file exists
+
+* opts.isDirectory - function to asynchronously test whether a file exists and is a directory
+
+* opts.realpath - function to asynchronously resolve a potential symlink to its real path
+
+* `opts.readPackage(readFile, pkgfile, cb)` - function to asynchronously read and parse a package.json file
+  * readFile - the passed `opts.readFile` or `fs.readFile` if not specified
+  * pkgfile - path to package.json
+  * cb - callback
+
+* `opts.packageFilter(pkg, pkgfile, dir)` - transform the parsed package.json contents before looking at the "main" field
+  * pkg - package data
+  * pkgfile - path to package.json
+  * dir - directory that contains package.json
+
+* `opts.pathFilter(pkg, path, relativePath)` - transform a path within a package
+  * pkg - package data
+  * path - the path being resolved
+  * relativePath - the path relative from the package.json location
+  * returns - a relative path that will be joined from the package.json location
+
+* opts.paths - require.paths array to use if nothing is found on the normal `node_modules` recursive walk (probably don't use this)
+
+  For advanced users, `paths` can also be a `opts.paths(request, start, opts)` function
+    * request - the import specifier being resolved
+    * start - lookup path
+    * getNodeModulesDirs - a thunk (no-argument function) that returns the paths using standard `node_modules` resolution
+    * opts - the resolution options
+
+* `opts.packageIterator(request, start, opts)` - return the list of candidate paths where the packages sources may be found (probably don't use this)
+    * request - the import specifier being resolved
+    * start - lookup path
+    * getPackageCandidates - a thunk (no-argument function) that returns the paths using standard `node_modules` resolution
+    * opts - the resolution options
+
+* opts.moduleDirectory - directory (or directories) in which to recursively look for modules. default: `"node_modules"`
+
+* opts.preserveSymlinks - if true, doesn't resolve `basedir` to real path before resolving.
+This is the way Node resolves dependencies when executed with the [--preserve-symlinks](https://nodejs.org/api/all.html#cli_preserve_symlinks) flag.
+**Note:** this property is currently `true` by default but it will be changed to
+`false` in the next major version because *Node's resolution algorithm does not preserve symlinks by default*.
+
+default `opts` values:
+
+```js
+{
+    paths: [],
+    basedir: __dirname,
+    extensions: ['.js'],
+    includeCoreModules: true,
+    readFile: fs.readFile,
+    isFile: function isFile(file, cb) {
+        fs.stat(file, function (err, stat) {
+            if (!err) {
+                return cb(null, stat.isFile() || stat.isFIFO());
+            }
+            if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
+            return cb(err);
+        });
+    },
+    isDirectory: function isDirectory(dir, cb) {
+        fs.stat(dir, function (err, stat) {
+            if (!err) {
+                return cb(null, stat.isDirectory());
+            }
+            if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
+            return cb(err);
+        });
+    },
+    realpath: function realpath(file, cb) {
+        var realpath = typeof fs.realpath.native === 'function' ? fs.realpath.native : fs.realpath;
+        realpath(file, function (realPathErr, realPath) {
+            if (realPathErr && realPathErr.code !== 'ENOENT') cb(realPathErr);
+            else cb(null, realPathErr ? file : realPath);
+        });
+    },
+    readPackage: function defaultReadPackage(readFile, pkgfile, cb) {
+        readFile(pkgfile, function (readFileErr, body) {
+            if (readFileErr) cb(readFileErr);
+            else {
+                try {
+                    var pkg = JSON.parse(body);
+                    cb(null, pkg);
+                } catch (jsonErr) {
+                    cb(null);
+                }
+            }
+        });
+    },
+    moduleDirectory: 'node_modules',
+    preserveSymlinks: true
+}
+```
+
+## resolve.sync(id, opts)
+
+Synchronously resolve the module path string `id`, returning the result and
+throwing an error when `id` can't be resolved.
+
+options are:
+
+* opts.basedir - directory to begin resolving from
+
+* opts.extensions - array of file extensions to search in order
+
+* opts.includeCoreModules - set to `false` to exclude node core modules (e.g. `fs`) from the search
+
+* opts.readFileSync - how to read files synchronously
+
+* opts.isFile - function to synchronously test whether a file exists
+
+* opts.isDirectory - function to synchronously test whether a file exists and is a directory
+
+* opts.realpathSync - function to synchronously resolve a potential symlink to its real path
+
+* `opts.readPackageSync(readFileSync, pkgfile)` - function to synchronously read and parse a package.json file
+  * readFileSync - the passed `opts.readFileSync` or `fs.readFileSync` if not specified
+  * pkgfile - path to package.json
+
+* `opts.packageFilter(pkg, dir)` - transform the parsed package.json contents before looking at the "main" field
+  * pkg - package data
+  * dir - directory that contains package.json (Note: the second argument will change to "pkgfile" in v2)
+
+* `opts.pathFilter(pkg, path, relativePath)` - transform a path within a package
+  * pkg - package data
+  * path - the path being resolved
+  * relativePath - the path relative from the package.json location
+  * returns - a relative path that will be joined from the package.json location
+
+* opts.paths - require.paths array to use if nothing is found on the normal `node_modules` recursive walk (probably don't use this)
+
+  For advanced users, `paths` can also be a `opts.paths(request, start, opts)` function
+    * request - the import specifier being resolved
+    * start - lookup path
+    * getNodeModulesDirs - a thunk (no-argument function) that returns the paths using standard `node_modules` resolution
+    * opts - the resolution options
+
+* `opts.packageIterator(request, start, opts)` - return the list of candidate paths where the packages sources may be found (probably don't use this)
+    * request - the import specifier being resolved
+    * start - lookup path
+    * getPackageCandidates - a thunk (no-argument function) that returns the paths using standard `node_modules` resolution
+    * opts - the resolution options
+
+* opts.moduleDirectory - directory (or directories) in which to recursively look for modules. default: `"node_modules"`
+
+* opts.preserveSymlinks - if true, doesn't resolve `basedir` to real path before resolving.
+This is the way Node resolves dependencies when executed with the [--preserve-symlinks](https://nodejs.org/api/all.html#cli_preserve_symlinks) flag.
+**Note:** this property is currently `true` by default but it will be changed to
+`false` in the next major version because *Node's resolution algorithm does not preserve symlinks by default*.
+
+default `opts` values:
+
+```js
+{
+    paths: [],
+    basedir: __dirname,
+    extensions: ['.js'],
+    includeCoreModules: true,
+    readFileSync: fs.readFileSync,
+    isFile: function isFile(file) {
+        try {
+            var stat = fs.statSync(file);
+        } catch (e) {
+            if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return false;
+            throw e;
+        }
+        return stat.isFile() || stat.isFIFO();
+    },
+    isDirectory: function isDirectory(dir) {
+        try {
+            var stat = fs.statSync(dir);
+        } catch (e) {
+            if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return false;
+            throw e;
+        }
+        return stat.isDirectory();
+    },
+    realpathSync: function realpathSync(file) {
+        try {
+            var realpath = typeof fs.realpathSync.native === 'function' ? fs.realpathSync.native : fs.realpathSync;
+            return realpath(file);
+        } catch (realPathErr) {
+            if (realPathErr.code !== 'ENOENT') {
+                throw realPathErr;
+            }
+        }
+        return file;
+    },
+    readPackageSync: function defaultReadPackageSync(readFileSync, pkgfile) {
+        var body = readFileSync(pkgfile);
+        try {
+            var pkg = JSON.parse(body);
+            return pkg;
+        } catch (jsonErr) {}
+    },
+    moduleDirectory: 'node_modules',
+    preserveSymlinks: true
+}
+```
+
+# install
+
+With [npm](https://npmjs.org) do:
+
+```sh
+npm install resolve
+```
+
+# license
+
+MIT
+
+[1]: https://npmjs.org/package/resolve
+[2]: https://versionbadg.es/browserify/resolve.svg
+[5]: https://david-dm.org/browserify/resolve.svg
+[6]: https://david-dm.org/browserify/resolve
+[7]: https://david-dm.org/browserify/resolve/dev-status.svg
+[8]: https://david-dm.org/browserify/resolve#info=devDependencies
+[11]: https://nodei.co/npm/resolve.png?downloads=true&stars=true
+[license-image]: https://img.shields.io/npm/l/resolve.svg
+[license-url]: LICENSE
+[downloads-image]: https://img.shields.io/npm/dm/resolve.svg
+[downloads-url]: https://npm-stat.com/charts.html?package=resolve
+[codecov-image]: https://codecov.io/gh/browserify/resolve/branch/main/graphs/badge.svg
+[codecov-url]: https://app.codecov.io/gh/browserify/resolve/
+[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/browserify/resolve
+[actions-url]: https://github.com/browserify/resolve/actions

node_modules/jest-resolve/node_modules/resolve/sync.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./lib/sync');

node_modules/jest-resolve/node_modules/resolve/test/core.js

@@ -0,0 +1,88 @@
+var test = require('tape');
+var keys = require('object-keys');
+var semver = require('semver');
+
+var resolve = require('../');
+
+var brokenNode = semver.satisfies(process.version, '11.11 - 11.13');
+
+test('core modules', function (t) {
+    t.test('isCore()', function (st) {
+        st.ok(resolve.isCore('fs'));
+        st.ok(resolve.isCore('net'));
+        st.ok(resolve.isCore('http'));
+
+        st.ok(!resolve.isCore('seq'));
+        st.ok(!resolve.isCore('../'));
+
+        st.ok(!resolve.isCore('toString'));
+
+        st.end();
+    });
+
+    t.test('core list', function (st) {
+        var cores = keys(resolve.core);
+        st.plan(cores.length);
+
+        for (var i = 0; i < cores.length; ++i) {
+            var mod = cores[i];
+            // note: this must be require, not require.resolve, due to https://github.com/nodejs/node/issues/43274
+            var requireFunc = function () { require(mod); }; // eslint-disable-line no-loop-func
+            t.comment(mod + ': ' + resolve.core[mod]);
+            if (resolve.core[mod]) {
+                st.doesNotThrow(requireFunc, mod + ' supported; requiring does not throw');
+            } else if (brokenNode) {
+                st.ok(true, 'this version of node is broken: attempting to require things that fail to resolve breaks "home_paths" tests');
+            } else {
+                st.throws(requireFunc, mod + ' not supported; requiring throws');
+            }
+        }
+
+        st.end();
+    });
+
+    t.test('core via repl module', { skip: !resolve.core.repl }, function (st) {
+        var libs = require('repl')._builtinLibs; // eslint-disable-line no-underscore-dangle
+        if (!libs) {
+            st.skip('module.builtinModules does not exist');
+            return st.end();
+        }
+        for (var i = 0; i < libs.length; ++i) {
+            var mod = libs[i];
+            st.ok(resolve.core[mod], mod + ' is a core module');
+            st.doesNotThrow(
+                function () { require(mod); }, // eslint-disable-line no-loop-func
+                'requiring ' + mod + ' does not throw'
+            );
+        }
+        st.end();
+    });
+
+    t.test('core via builtinModules list', { skip: !resolve.core.module }, function (st) {
+        var libs = require('module').builtinModules;
+        if (!libs) {
+            st.skip('module.builtinModules does not exist');
+            return st.end();
+        }
+        var blacklist = [
+            '_debug_agent',
+            'v8/tools/tickprocessor-driver',
+            'v8/tools/SourceMap',
+            'v8/tools/tickprocessor',
+            'v8/tools/profile'
+        ];
+        for (var i = 0; i < libs.length; ++i) {
+            var mod = libs[i];
+            if (blacklist.indexOf(mod) === -1) {
+                st.ok(resolve.core[mod], mod + ' is a core module');
+                st.doesNotThrow(
+                    function () { require(mod); }, // eslint-disable-line no-loop-func
+                    'requiring ' + mod + ' does not throw'
+                );
+            }
+        }
+        st.end();
+    });
+
+    t.end();
+});

node_modules/jest-resolve/node_modules/resolve/test/dotdot.js

@@ -0,0 +1,29 @@
+var path = require('path');
+var test = require('tape');
+var resolve = require('../');
+
+test('dotdot', function (t) {
+    t.plan(4);
+    var dir = path.join(__dirname, '/dotdot/abc');
+
+    resolve('..', { basedir: dir }, function (err, res, pkg) {
+        t.ifError(err);
+        t.equal(res, path.join(__dirname, 'dotdot/index.js'));
+    });
+
+    resolve('.', { basedir: dir }, function (err, res, pkg) {
+        t.ifError(err);
+        t.equal(res, path.join(dir, 'index.js'));
+    });
+});
+
+test('dotdot sync', function (t) {
+    t.plan(2);
+    var dir = path.join(__dirname, '/dotdot/abc');
+
+    var a = resolve.sync('..', { basedir: dir });
+    t.equal(a, path.join(__dirname, 'dotdot/index.js'));
+
+    var b = resolve.sync('.', { basedir: dir });
+    t.equal(b, path.join(dir, 'index.js'));
+});

node_modules/jest-resolve/node_modules/resolve/test/dotdot/abc/index.js

@@ -0,0 +1,2 @@
+var x = require('..');
+console.log(x);

node_modules/jest-resolve/node_modules/resolve/test/dotdot/index.js

@@ -0,0 +1 @@
+module.exports = 'whatever';

node_modules/jest-resolve/node_modules/resolve/test/faulty_basedir.js

@@ -0,0 +1,29 @@
+var test = require('tape');
+var path = require('path');
+var resolve = require('../');
+
+test('faulty basedir must produce error in windows', { skip: process.platform !== 'win32' }, function (t) {
+    t.plan(1);
+
+    var resolverDir = 'C:\\a\\b\\c\\d';
+
+    resolve('tape/lib/test.js', { basedir: resolverDir }, function (err, res, pkg) {
+        t.equal(!!err, true);
+    });
+});
+
+test('non-existent basedir should not throw when preserveSymlinks is false', function (t) {
+    t.plan(2);
+
+    var opts = {
+        basedir: path.join(path.sep, 'unreal', 'path', 'that', 'does', 'not', 'exist'),
+        preserveSymlinks: false
+    };
+
+    var module = './dotdot/abc';
+
+    resolve(module, opts, function (err, res) {
+        t.equal(err.code, 'MODULE_NOT_FOUND');
+        t.equal(res, undefined);
+    });
+});

node_modules/jest-resolve/node_modules/resolve/test/filter.js

@@ -0,0 +1,34 @@
+var path = require('path');
+var test = require('tape');
+var resolve = require('../');
+
+test('filter', function (t) {
+    t.plan(4);
+    var dir = path.join(__dirname, 'resolver');
+    var packageFilterArgs;
+    resolve('./baz', {
+        basedir: dir,
+        packageFilter: function (pkg, pkgfile) {
+            pkg.main = 'doom'; // eslint-disable-line no-param-reassign
+            packageFilterArgs = [pkg, pkgfile];
+            return pkg;
+        }
+    }, function (err, res, pkg) {
+        if (err) t.fail(err);
+
+        t.equal(res, path.join(dir, 'baz/doom.js'), 'changing the package "main" works');
+
+        var packageData = packageFilterArgs[0];
+        t.equal(pkg, packageData, 'first packageFilter argument is "pkg"');
+        t.equal(packageData.main, 'doom', 'package "main" was altered');
+
+        var packageFile = packageFilterArgs[1];
+        t.equal(
+            packageFile,
+            path.join(dir, 'baz/package.json'),
+            'second packageFilter argument is "pkgfile"'
+        );
+
+        t.end();
+    });
+});

node_modules/jest-resolve/node_modules/resolve/test/filter_sync.js

@@ -0,0 +1,33 @@
+var path = require('path');
+var test = require('tape');
+var resolve = require('../');
+
+test('filter', function (t) {
+    var dir = path.join(__dirname, 'resolver');
+    var packageFilterArgs;
+    var res = resolve.sync('./baz', {
+        basedir: dir,
+        // NOTE: in v2.x, this will be `pkg, pkgfile, dir`, but must remain "broken" here in v1.x for compatibility
+        packageFilter: function (pkg, /*pkgfile,*/ dir) { // eslint-disable-line spaced-comment
+            pkg.main = 'doom'; // eslint-disable-line no-param-reassign
+            packageFilterArgs = 'is 1.x' ? [pkg, dir] : [pkg, pkgfile, dir]; // eslint-disable-line no-constant-condition, no-undef
+            return pkg;
+        }
+    });
+
+    t.equal(res, path.join(dir, 'baz/doom.js'), 'changing the package "main" works');
+
+    var packageData = packageFilterArgs[0];
+    t.equal(packageData.main, 'doom', 'package "main" was altered');
+
+    if (!'is 1.x') { // eslint-disable-line no-constant-condition
+        var packageFile = packageFilterArgs[1];
+        t.equal(packageFile, path.join(dir, 'baz', 'package.json'), 'package.json path is correct');
+    }
+
+    var packageDir = packageFilterArgs['is 1.x' ? 1 : 2]; // eslint-disable-line no-constant-condition
+    // eslint-disable-next-line no-constant-condition
+    t.equal(packageDir, path.join(dir, 'baz'), ('is 1.x' ? 'second' : 'third') + ' packageFilter argument is "dir"');
+
+    t.end();
+});

node_modules/jest-resolve/node_modules/resolve/test/home_paths.js

@@ -0,0 +1,127 @@
+'use strict';
+
+var fs = require('fs');
+var homedir = require('../lib/homedir');
+var path = require('path');
+
+var test = require('tape');
+var mkdirp = require('mkdirp');
+var rimraf = require('rimraf');
+var mv = require('mv');
+var copyDir = require('copy-dir');
+var tmp = require('tmp');
+
+var HOME = homedir();
+
+var hnm = path.join(HOME, '.node_modules');
+var hnl = path.join(HOME, '.node_libraries');
+
+var resolve = require('../async');
+
+function makeDir(t, dir, cb) {
+    mkdirp(dir, function (err) {
+        if (err) {
+            cb(err);
+        } else {
+            t.teardown(function cleanup() {
+                rimraf.sync(dir);
+            });
+            cb();
+        }
+    });
+}
+
+function makeTempDir(t, dir, cb) {
+    if (fs.existsSync(dir)) {
+        var tmpResult = tmp.dirSync();
+        t.teardown(tmpResult.removeCallback);
+        var backup = path.join(tmpResult.name, path.basename(dir));
+        mv(dir, backup, function (err) {
+            if (err) {
+                cb(err);
+            } else {
+                t.teardown(function () {
+                    mv(backup, dir, cb);
+                });
+                makeDir(t, dir, cb);
+            }
+        });
+    } else {
+        makeDir(t, dir, cb);
+    }
+}
+
+test('homedir module paths', function (t) {
+    t.plan(7);
+
+    makeTempDir(t, hnm, function (err) {
+        t.error(err, 'no error with HNM temp dir');
+        if (err) {
+            return t.end();
+        }
+
+        var bazHNMDir = path.join(hnm, 'baz');
+        var dotMainDir = path.join(hnm, 'dot_main');
+        copyDir.sync(path.join(__dirname, 'resolver/baz'), bazHNMDir);
+        copyDir.sync(path.join(__dirname, 'resolver/dot_main'), dotMainDir);
+
+        var bazPkg = { name: 'baz', main: 'quux.js' };
+        var dotMainPkg = { main: 'index' };
+
+        var bazHNMmain = path.join(bazHNMDir, 'quux.js');
+        t.equal(require.resolve('baz'), bazHNMmain, 'sanity check: require.resolve finds HNM `baz`');
+        var dotMainMain = path.join(dotMainDir, 'index.js');
+        t.equal(require.resolve('dot_main'), dotMainMain, 'sanity check: require.resolve finds `dot_main`');
+
+        makeTempDir(t, hnl, function (err) {
+            t.error(err, 'no error with HNL temp dir');
+            if (err) {
+                return t.end();
+            }
+            var bazHNLDir = path.join(hnl, 'baz');
+            copyDir.sync(path.join(__dirname, 'resolver/baz'), bazHNLDir);
+
+            var dotSlashMainDir = path.join(hnl, 'dot_slash_main');
+            var dotSlashMainMain = path.join(dotSlashMainDir, 'index.js');
+            var dotSlashMainPkg = { main: 'index' };
+            copyDir.sync(path.join(__dirname, 'resolver/dot_slash_main'), dotSlashMainDir);
+
+            t.equal(require.resolve('baz'), bazHNMmain, 'sanity check: require.resolve finds HNM `baz`');
+            t.equal(require.resolve('dot_slash_main'), dotSlashMainMain, 'sanity check: require.resolve finds HNL `dot_slash_main`');
+
+            t.test('with temp dirs', function (st) {
+                st.plan(3);
+
+                st.test('just in `$HOME/.node_modules`', function (s2t) {
+                    s2t.plan(3);
+
+                    resolve('dot_main', function (err, res, pkg) {
+                        s2t.error(err, 'no error resolving `dot_main`');
+                        s2t.equal(res, dotMainMain, '`dot_main` resolves in `$HOME/.node_modules`');
+                        s2t.deepEqual(pkg, dotMainPkg);
+                    });
+                });
+
+                st.test('just in `$HOME/.node_libraries`', function (s2t) {
+                    s2t.plan(3);
+
+                    resolve('dot_slash_main', function (err, res, pkg) {
+                        s2t.error(err, 'no error resolving `dot_slash_main`');
+                        s2t.equal(res, dotSlashMainMain, '`dot_slash_main` resolves in `$HOME/.node_libraries`');
+                        s2t.deepEqual(pkg, dotSlashMainPkg);
+                    });
+                });
+
+                st.test('in `$HOME/.node_libraries` and `$HOME/.node_modules`', function (s2t) {
+                    s2t.plan(3);
+
+                    resolve('baz', function (err, res, pkg) {
+                        s2t.error(err, 'no error resolving `baz`');
+                        s2t.equal(res, bazHNMmain, '`baz` resolves in `$HOME/.node_modules` when in both');
+                        s2t.deepEqual(pkg, bazPkg);
+                    });
+                });
+            });
+        });
+    });
+});

node_modules/jest-resolve/node_modules/resolve/test/home_paths_sync.js

@@ -0,0 +1,114 @@
+'use strict';
+
+var fs = require('fs');
+var homedir = require('../lib/homedir');
+var path = require('path');
+
+var test = require('tape');
+var mkdirp = require('mkdirp');
+var rimraf = require('rimraf');
+var mv = require('mv');
+var copyDir = require('copy-dir');
+var tmp = require('tmp');
+
+var HOME = homedir();
+
+var hnm = path.join(HOME, '.node_modules');
+var hnl = path.join(HOME, '.node_libraries');
+
+var resolve = require('../sync');
+
+function makeDir(t, dir, cb) {
+    mkdirp(dir, function (err) {
+        if (err) {
+            cb(err);
+        } else {
+            t.teardown(function cleanup() {
+                rimraf.sync(dir);
+            });
+            cb();
+        }
+    });
+}
+
+function makeTempDir(t, dir, cb) {
+    if (fs.existsSync(dir)) {
+        var tmpResult = tmp.dirSync();
+        t.teardown(tmpResult.removeCallback);
+        var backup = path.join(tmpResult.name, path.basename(dir));
+        mv(dir, backup, function (err) {
+            if (err) {
+                cb(err);
+            } else {
+                t.teardown(function () {
+                    mv(backup, dir, cb);
+                });
+                makeDir(t, dir, cb);
+            }
+        });
+    } else {
+        makeDir(t, dir, cb);
+    }
+}
+
+test('homedir module paths', function (t) {
+    t.plan(7);
+
+    makeTempDir(t, hnm, function (err) {
+        t.error(err, 'no error with HNM temp dir');
+        if (err) {
+            return t.end();
+        }
+
+        var bazHNMDir = path.join(hnm, 'baz');
+        var dotMainDir = path.join(hnm, 'dot_main');
+        copyDir.sync(path.join(__dirname, 'resolver/baz'), bazHNMDir);
+        copyDir.sync(path.join(__dirname, 'resolver/dot_main'), dotMainDir);
+
+        var bazHNMmain = path.join(bazHNMDir, 'quux.js');
+        t.equal(require.resolve('baz'), bazHNMmain, 'sanity check: require.resolve finds HNM `baz`');
+        var dotMainMain = path.join(dotMainDir, 'index.js');
+        t.equal(require.resolve('dot_main'), dotMainMain, 'sanity check: require.resolve finds `dot_main`');
+
+        makeTempDir(t, hnl, function (err) {
+            t.error(err, 'no error with HNL temp dir');
+            if (err) {
+                return t.end();
+            }
+            var bazHNLDir = path.join(hnl, 'baz');
+            copyDir.sync(path.join(__dirname, 'resolver/baz'), bazHNLDir);
+
+            var dotSlashMainDir = path.join(hnl, 'dot_slash_main');
+            var dotSlashMainMain = path.join(dotSlashMainDir, 'index.js');
+            copyDir.sync(path.join(__dirname, 'resolver/dot_slash_main'), dotSlashMainDir);
+
+            t.equal(require.resolve('baz'), bazHNMmain, 'sanity check: require.resolve finds HNM `baz`');
+            t.equal(require.resolve('dot_slash_main'), dotSlashMainMain, 'sanity check: require.resolve finds HNL `dot_slash_main`');
+
+            t.test('with temp dirs', function (st) {
+                st.plan(3);
+
+                st.test('just in `$HOME/.node_modules`', function (s2t) {
+                    s2t.plan(1);
+
+                    var res = resolve('dot_main');
+                    s2t.equal(res, dotMainMain, '`dot_main` resolves in `$HOME/.node_modules`');
+                });
+
+                st.test('just in `$HOME/.node_libraries`', function (s2t) {
+                    s2t.plan(1);
+
+                    var res = resolve('dot_slash_main');
+                    s2t.equal(res, dotSlashMainMain, '`dot_slash_main` resolves in `$HOME/.node_libraries`');
+                });
+
+                st.test('in `$HOME/.node_libraries` and `$HOME/.node_modules`', function (s2t) {
+                    s2t.plan(1);
+
+                    var res = resolve('baz');
+                    s2t.equal(res, bazHNMmain, '`baz` resolves in `$HOME/.node_modules` when in both');
+                });
+            });
+        });
+    });
+});

node_modules/jest-resolve/node_modules/resolve/test/mock.js

@@ -0,0 +1,315 @@
+var path = require('path');
+var test = require('tape');
+var resolve = require('../');
+
+test('mock', function (t) {
+    t.plan(8);
+
+    var files = {};
+    files[path.resolve('/foo/bar/baz.js')] = 'beep';
+
+    var dirs = {};
+    dirs[path.resolve('/foo/bar')] = true;
+
+    function opts(basedir) {
+        return {
+            basedir: path.resolve(basedir),
+            isFile: function (file, cb) {
+                cb(null, Object.prototype.hasOwnProperty.call(files, path.resolve(file)));
+            },
+            isDirectory: function (dir, cb) {
+                cb(null, !!dirs[path.resolve(dir)]);
+            },
+            readFile: function (file, cb) {
+                cb(null, files[path.resolve(file)]);
+            },
+            realpath: function (file, cb) {
+                cb(null, file);
+            }
+        };
+    }
+
+    resolve('./baz', opts('/foo/bar'), function (err, res, pkg) {
+        if (err) return t.fail(err);
+        t.equal(res, path.resolve('/foo/bar/baz.js'));
+        t.equal(pkg, undefined);
+    });
+
+    resolve('./baz.js', opts('/foo/bar'), function (err, res, pkg) {
+        if (err) return t.fail(err);
+        t.equal(res, path.resolve('/foo/bar/baz.js'));
+        t.equal(pkg, undefined);
+    });
+
+    resolve('baz', opts('/foo/bar'), function (err, res) {
+        t.equal(err.message, "Cannot find module 'baz' from '" + path.resolve('/foo/bar') + "'");
+        t.equal(err.code, 'MODULE_NOT_FOUND');
+    });
+
+    resolve('../baz', opts('/foo/bar'), function (err, res) {
+        t.equal(err.message, "Cannot find module '../baz' from '" + path.resolve('/foo/bar') + "'");
+        t.equal(err.code, 'MODULE_NOT_FOUND');
+    });
+});
+
+test('mock from package', function (t) {
+    t.plan(8);
+
+    var files = {};
+    files[path.resolve('/foo/bar/baz.js')] = 'beep';
+
+    var dirs = {};
+    dirs[path.resolve('/foo/bar')] = true;
+
+    function opts(basedir) {
+        return {
+            basedir: path.resolve(basedir),
+            isFile: function (file, cb) {
+                cb(null, Object.prototype.hasOwnProperty.call(files, file));
+            },
+            isDirectory: function (dir, cb) {
+                cb(null, !!dirs[path.resolve(dir)]);
+            },
+            'package': { main: 'bar' },
+            readFile: function (file, cb) {
+                cb(null, files[file]);
+            },
+            realpath: function (file, cb) {
+                cb(null, file);
+            }
+        };
+    }
+
+    resolve('./baz', opts('/foo/bar'), function (err, res, pkg) {
+        if (err) return t.fail(err);
+        t.equal(res, path.resolve('/foo/bar/baz.js'));
+        t.equal(pkg && pkg.main, 'bar');
+    });
+
+    resolve('./baz.js', opts('/foo/bar'), function (err, res, pkg) {
+        if (err) return t.fail(err);
+        t.equal(res, path.resolve('/foo/bar/baz.js'));
+        t.equal(pkg && pkg.main, 'bar');
+    });
+
+    resolve('baz', opts('/foo/bar'), function (err, res) {
+        t.equal(err.message, "Cannot find module 'baz' from '" + path.resolve('/foo/bar') + "'");
+        t.equal(err.code, 'MODULE_NOT_FOUND');
+    });
+
+    resolve('../baz', opts('/foo/bar'), function (err, res) {
+        t.equal(err.message, "Cannot find module '../baz' from '" + path.resolve('/foo/bar') + "'");
+        t.equal(err.code, 'MODULE_NOT_FOUND');
+    });
+});
+
+test('mock package', function (t) {
+    t.plan(2);
+
+    var files = {};
+    files[path.resolve('/foo/node_modules/bar/baz.js')] = 'beep';
+    files[path.resolve('/foo/node_modules/bar/package.json')] = JSON.stringify({
+        main: './baz.js'
+    });
+
+    var dirs = {};
+    dirs[path.resolve('/foo')] = true;
+    dirs[path.resolve('/foo/node_modules')] = true;
+
+    function opts(basedir) {
+        return {
+            basedir: path.resolve(basedir),
+            isFile: function (file, cb) {
+                cb(null, Object.prototype.hasOwnProperty.call(files, path.resolve(file)));
+            },
+            isDirectory: function (dir, cb) {
+                cb(null, !!dirs[path.resolve(dir)]);
+            },
+            readFile: function (file, cb) {
+                cb(null, files[path.resolve(file)]);
+            },
+            realpath: function (file, cb) {
+                cb(null, file);
+            }
+        };
+    }
+
+    resolve('bar', opts('/foo'), function (err, res, pkg) {
+        if (err) return t.fail(err);
+        t.equal(res, path.resolve('/foo/node_modules/bar/baz.js'));
+        t.equal(pkg && pkg.main, './baz.js');
+    });
+});
+
+test('mock package from package', function (t) {
+    t.plan(2);
+
+    var files = {};
+    files[path.resolve('/foo/node_modules/bar/baz.js')] = 'beep';
+    files[path.resolve('/foo/node_modules/bar/package.json')] = JSON.stringify({
+        main: './baz.js'
+    });
+
+    var dirs = {};
+    dirs[path.resolve('/foo')] = true;
+    dirs[path.resolve('/foo/node_modules')] = true;
+
+    function opts(basedir) {
+        return {
+            basedir: path.resolve(basedir),
+            isFile: function (file, cb) {
+                cb(null, Object.prototype.hasOwnProperty.call(files, path.resolve(file)));
+            },
+            isDirectory: function (dir, cb) {
+                cb(null, !!dirs[path.resolve(dir)]);
+            },
+            'package': { main: 'bar' },
+            readFile: function (file, cb) {
+                cb(null, files[path.resolve(file)]);
+            },
+            realpath: function (file, cb) {
+                cb(null, file);
+            }
+        };
+    }
+
+    resolve('bar', opts('/foo'), function (err, res, pkg) {
+        if (err) return t.fail(err);
+        t.equal(res, path.resolve('/foo/node_modules/bar/baz.js'));
+        t.equal(pkg && pkg.main, './baz.js');
+    });
+});
+
+test('symlinked', function (t) {
+    t.plan(4);
+
+    var files = {};
+    files[path.resolve('/foo/bar/baz.js')] = 'beep';
+    files[path.resolve('/foo/bar/symlinked/baz.js')] = 'beep';
+
+    var dirs = {};
+    dirs[path.resolve('/foo/bar')] = true;
+    dirs[path.resolve('/foo/bar/symlinked')] = true;
+
+    function opts(basedir) {
+        return {
+            preserveSymlinks: false,
+            basedir: path.resolve(basedir),
+            isFile: function (file, cb) {
+                cb(null, Object.prototype.hasOwnProperty.call(files, path.resolve(file)));
+            },
+            isDirectory: function (dir, cb) {
+                cb(null, !!dirs[path.resolve(dir)]);
+            },
+            readFile: function (file, cb) {
+                cb(null, files[path.resolve(file)]);
+            },
+            realpath: function (file, cb) {
+                var resolved = path.resolve(file);
+
+                if (resolved.indexOf('symlinked') >= 0) {
+                    cb(null, resolved);
+                    return;
+                }
+
+                var ext = path.extname(resolved);
+
+                if (ext) {
+                    var dir = path.dirname(resolved);
+                    var base = path.basename(resolved);
+                    cb(null, path.join(dir, 'symlinked', base));
+                } else {
+                    cb(null, path.join(resolved, 'symlinked'));
+                }
+            }
+        };
+    }
+
+    resolve('./baz', opts('/foo/bar'), function (err, res, pkg) {
+        if (err) return t.fail(err);
+        t.equal(res, path.resolve('/foo/bar/symlinked/baz.js'));
+        t.equal(pkg, undefined);
+    });
+
+    resolve('./baz.js', opts('/foo/bar'), function (err, res, pkg) {
+        if (err) return t.fail(err);
+        t.equal(res, path.resolve('/foo/bar/symlinked/baz.js'));
+        t.equal(pkg, undefined);
+    });
+});
+
+test('readPackage', function (t) {
+    t.plan(3);
+
+    var files = {};
+    files[path.resolve('/foo/node_modules/bar/something-else.js')] = 'beep';
+    files[path.resolve('/foo/node_modules/bar/package.json')] = JSON.stringify({
+        main: './baz.js'
+    });
+    files[path.resolve('/foo/node_modules/bar/baz.js')] = 'boop';
+
+    var dirs = {};
+    dirs[path.resolve('/foo')] = true;
+    dirs[path.resolve('/foo/node_modules')] = true;
+
+    function opts(basedir) {
+        return {
+            basedir: path.resolve(basedir),
+            isFile: function (file, cb) {
+                cb(null, Object.prototype.hasOwnProperty.call(files, path.resolve(file)));
+            },
+            isDirectory: function (dir, cb) {
+                cb(null, !!dirs[path.resolve(dir)]);
+            },
+            'package': { main: 'bar' },
+            readFile: function (file, cb) {
+                cb(null, files[path.resolve(file)]);
+            },
+            realpath: function (file, cb) {
+                cb(null, file);
+            }
+        };
+    }
+
+    t.test('with readFile', function (st) {
+        st.plan(3);
+
+        resolve('bar', opts('/foo'), function (err, res, pkg) {
+            st.error(err);
+            st.equal(res, path.resolve('/foo/node_modules/bar/baz.js'));
+            st.equal(pkg && pkg.main, './baz.js');
+        });
+    });
+
+    var readPackage = function (readFile, file, cb) {
+        var barPackage = path.join('bar', 'package.json');
+        if (file.slice(-barPackage.length) === barPackage) {
+            cb(null, { main: './something-else.js' });
+        } else {
+            cb(null, JSON.parse(files[path.resolve(file)]));
+        }
+    };
+
+    t.test('with readPackage', function (st) {
+        st.plan(3);
+
+        var options = opts('/foo');
+        delete options.readFile;
+        options.readPackage = readPackage;
+        resolve('bar', options, function (err, res, pkg) {
+            st.error(err);
+            st.equal(res, path.resolve('/foo/node_modules/bar/something-else.js'));
+            st.equal(pkg && pkg.main, './something-else.js');
+        });
+    });
+
+    t.test('with readFile and readPackage', function (st) {
+        st.plan(1);
+
+        var options = opts('/foo');
+        options.readPackage = readPackage;
+        resolve('bar', options, function (err) {
+            st.throws(function () { throw err; }, TypeError, 'errors when both readFile and readPackage are provided');
+        });
+    });
+});

node_modules/jest-resolve/node_modules/resolve/test/mock_sync.js

@@ -0,0 +1,214 @@
+var path = require('path');
+var test = require('tape');
+var resolve = require('../');
+
+test('mock', function (t) {
+    t.plan(4);
+
+    var files = {};
+    files[path.resolve('/foo/bar/baz.js')] = 'beep';
+
+    var dirs = {};
+    dirs[path.resolve('/foo/bar')] = true;
+
+    function opts(basedir) {
+        return {
+            basedir: path.resolve(basedir),
+            isFile: function (file) {
+                return Object.prototype.hasOwnProperty.call(files, path.resolve(file));
+            },
+            isDirectory: function (dir) {
+                return !!dirs[path.resolve(dir)];
+            },
+            readFileSync: function (file) {
+                return files[path.resolve(file)];
+            },
+            realpathSync: function (file) {
+                return file;
+            }
+        };
+    }
+
+    t.equal(
+        resolve.sync('./baz', opts('/foo/bar')),
+        path.resolve('/foo/bar/baz.js')
+    );
+
+    t.equal(
+        resolve.sync('./baz.js', opts('/foo/bar')),
+        path.resolve('/foo/bar/baz.js')
+    );
+
+    t.throws(function () {
+        resolve.sync('baz', opts('/foo/bar'));
+    });
+
+    t.throws(function () {
+        resolve.sync('../baz', opts('/foo/bar'));
+    });
+});
+
+test('mock package', function (t) {
+    t.plan(1);
+
+    var files = {};
+    files[path.resolve('/foo/node_modules/bar/baz.js')] = 'beep';
+    files[path.resolve('/foo/node_modules/bar/package.json')] = JSON.stringify({
+        main: './baz.js'
+    });
+
+    var dirs = {};
+    dirs[path.resolve('/foo')] = true;
+    dirs[path.resolve('/foo/node_modules')] = true;
+
+    function opts(basedir) {
+        return {
+            basedir: path.resolve(basedir),
+            isFile: function (file) {
+                return Object.prototype.hasOwnProperty.call(files, path.resolve(file));
+            },
+            isDirectory: function (dir) {
+                return !!dirs[path.resolve(dir)];
+            },
+            readFileSync: function (file) {
+                return files[path.resolve(file)];
+            },
+            realpathSync: function (file) {
+                return file;
+            }
+        };
+    }
+
+    t.equal(
+        resolve.sync('bar', opts('/foo')),
+        path.resolve('/foo/node_modules/bar/baz.js')
+    );
+});
+
+test('symlinked', function (t) {
+    t.plan(2);
+
+    var files = {};
+    files[path.resolve('/foo/bar/baz.js')] = 'beep';
+    files[path.resolve('/foo/bar/symlinked/baz.js')] = 'beep';
+
+    var dirs = {};
+    dirs[path.resolve('/foo/bar')] = true;
+    dirs[path.resolve('/foo/bar/symlinked')] = true;
+
+    function opts(basedir) {
+        return {
+            preserveSymlinks: false,
+            basedir: path.resolve(basedir),
+            isFile: function (file) {
+                return Object.prototype.hasOwnProperty.call(files, path.resolve(file));
+            },
+            isDirectory: function (dir) {
+                return !!dirs[path.resolve(dir)];
+            },
+            readFileSync: function (file) {
+                return files[path.resolve(file)];
+            },
+            realpathSync: function (file) {
+                var resolved = path.resolve(file);
+
+                if (resolved.indexOf('symlinked') >= 0) {
+                    return resolved;
+                }
+
+                var ext = path.extname(resolved);
+
+                if (ext) {
+                    var dir = path.dirname(resolved);
+                    var base = path.basename(resolved);
+                    return path.join(dir, 'symlinked', base);
+                }
+                return path.join(resolved, 'symlinked');
+            }
+        };
+    }
+
+    t.equal(
+        resolve.sync('./baz', opts('/foo/bar')),
+        path.resolve('/foo/bar/symlinked/baz.js')
+    );
+
+    t.equal(
+        resolve.sync('./baz.js', opts('/foo/bar')),
+        path.resolve('/foo/bar/symlinked/baz.js')
+    );
+});
+
+test('readPackageSync', function (t) {
+    t.plan(3);
+
+    var files = {};
+    files[path.resolve('/foo/node_modules/bar/something-else.js')] = 'beep';
+    files[path.resolve('/foo/node_modules/bar/package.json')] = JSON.stringify({
+        main: './baz.js'
+    });
+    files[path.resolve('/foo/node_modules/bar/baz.js')] = 'boop';
+
+    var dirs = {};
+    dirs[path.resolve('/foo')] = true;
+    dirs[path.resolve('/foo/node_modules')] = true;
+
+    function opts(basedir, useReadPackage) {
+        return {
+            basedir: path.resolve(basedir),
+            isFile: function (file) {
+                return Object.prototype.hasOwnProperty.call(files, path.resolve(file));
+            },
+            isDirectory: function (dir) {
+                return !!dirs[path.resolve(dir)];
+            },
+            readFileSync: useReadPackage ? null : function (file) {
+                return files[path.resolve(file)];
+            },
+            realpathSync: function (file) {
+                return file;
+            }
+        };
+    }
+    t.test('with readFile', function (st) {
+        st.plan(1);
+
+        st.equal(
+            resolve.sync('bar', opts('/foo')),
+            path.resolve('/foo/node_modules/bar/baz.js')
+        );
+    });
+
+    var readPackageSync = function (readFileSync, file) {
+        if (file.indexOf(path.join('bar', 'package.json')) >= 0) {
+            return { main: './something-else.js' };
+        }
+        return JSON.parse(files[path.resolve(file)]);
+    };
+
+    t.test('with readPackage', function (st) {
+        st.plan(1);
+
+        var options = opts('/foo');
+        delete options.readFileSync;
+        options.readPackageSync = readPackageSync;
+
+        st.equal(
+            resolve.sync('bar', options),
+            path.resolve('/foo/node_modules/bar/something-else.js')
+        );
+    });
+
+    t.test('with readFile and readPackage', function (st) {
+        st.plan(1);
+
+        var options = opts('/foo');
+        options.readPackageSync = readPackageSync;
+        st.throws(
+            function () { resolve.sync('bar', options); },
+            TypeError,
+            'errors when both readFile and readPackage are provided'
+        );
+    });
+});
+

node_modules/jest-resolve/node_modules/resolve/test/module_dir.js

@@ -0,0 +1,56 @@
+var path = require('path');
+var test = require('tape');
+var resolve = require('../');
+
+test('moduleDirectory strings', function (t) {
+    t.plan(4);
+    var dir = path.join(__dirname, 'module_dir');
+    var xopts = {
+        basedir: dir,
+        moduleDirectory: 'xmodules'
+    };
+    resolve('aaa', xopts, function (err, res, pkg) {
+        t.ifError(err);
+        t.equal(res, path.join(dir, '/xmodules/aaa/index.js'));
+    });
+
+    var yopts = {
+        basedir: dir,
+        moduleDirectory: 'ymodules'
+    };
+    resolve('aaa', yopts, function (err, res, pkg) {
+        t.ifError(err);
+        t.equal(res, path.join(dir, '/ymodules/aaa/index.js'));
+    });
+});
+
+test('moduleDirectory array', function (t) {
+    t.plan(6);
+    var dir = path.join(__dirname, 'module_dir');
+    var aopts = {
+        basedir: dir,
+        moduleDirectory: ['xmodules', 'ymodules', 'zmodules']
+    };
+    resolve('aaa', aopts, function (err, res, pkg) {
+        t.ifError(err);
+        t.equal(res, path.join(dir, '/xmodules/aaa/index.js'));
+    });
+
+    var bopts = {
+        basedir: dir,
+        moduleDirectory: ['zmodules', 'ymodules', 'xmodules']
+    };
+    resolve('aaa', bopts, function (err, res, pkg) {
+        t.ifError(err);
+        t.equal(res, path.join(dir, '/ymodules/aaa/index.js'));
+    });
+
+    var copts = {
+        basedir: dir,
+        moduleDirectory: ['xmodules', 'ymodules', 'zmodules']
+    };
+    resolve('bbb', copts, function (err, res, pkg) {
+        t.ifError(err);
+        t.equal(res, path.join(dir, '/zmodules/bbb/main.js'));
+    });
+});

node_modules/jest-resolve/node_modules/resolve/test/module_dir/xmodules/aaa/index.js

@@ -0,0 +1 @@
+module.exports = function (x) { return x * 100; };

node_modules/jest-resolve/node_modules/resolve/test/module_dir/ymodules/aaa/index.js

@@ -0,0 +1 @@
+module.exports = function (x) { return x + 100; };

node_modules/jest-resolve/node_modules/resolve/test/module_dir/zmodules/bbb/main.js

@@ -0,0 +1 @@
+module.exports = function (n) { return n * 111; };

node_modules/jest-resolve/node_modules/resolve/test/module_dir/zmodules/bbb/package.json

@@ -0,0 +1,3 @@
+{
+  "main": "main.js"
+}

node_modules/jest-resolve/node_modules/resolve/test/node-modules-paths.js

@@ -0,0 +1,143 @@
+var test = require('tape');
+var path = require('path');
+var parse = path.parse || require('path-parse');
+var keys = require('object-keys');
+
+var nodeModulesPaths = require('../lib/node-modules-paths');
+
+var verifyDirs = function verifyDirs(t, start, dirs, moduleDirectories, paths) {
+    var moduleDirs = [].concat(moduleDirectories || 'node_modules');
+    if (paths) {
+        for (var k = 0; k < paths.length; ++k) {
+            moduleDirs.push(path.basename(paths[k]));
+        }
+    }
+
+    var foundModuleDirs = {};
+    var uniqueDirs = {};
+    var parsedDirs = {};
+    for (var i = 0; i < dirs.length; ++i) {
+        var parsed = parse(dirs[i]);
+        if (!foundModuleDirs[parsed.base]) { foundModuleDirs[parsed.base] = 0; }
+        foundModuleDirs[parsed.base] += 1;
+        parsedDirs[parsed.dir] = true;
+        uniqueDirs[dirs[i]] = true;
+    }
+    t.equal(keys(parsedDirs).length >= start.split(path.sep).length, true, 'there are >= dirs than "start" has');
+    var foundModuleDirNames = keys(foundModuleDirs);
+    t.deepEqual(foundModuleDirNames, moduleDirs, 'all desired module dirs were found');
+    t.equal(keys(uniqueDirs).length, dirs.length, 'all dirs provided were unique');
+
+    var counts = {};
+    for (var j = 0; j < foundModuleDirNames.length; ++j) {
+        counts[foundModuleDirs[j]] = true;
+    }
+    t.equal(keys(counts).length, 1, 'all found module directories had the same count');
+};
+
+test('node-modules-paths', function (t) {
+    t.test('no options', function (t) {
+        var start = path.join(__dirname, 'resolver');
+        var dirs = nodeModulesPaths(start);
+
+        verifyDirs(t, start, dirs);
+
+        t.end();
+    });
+
+    t.test('empty options', function (t) {
+        var start = path.join(__dirname, 'resolver');
+        var dirs = nodeModulesPaths(start, {});
+
+        verifyDirs(t, start, dirs);
+
+        t.end();
+    });
+
+    t.test('with paths=array option', function (t) {
+        var start = path.join(__dirname, 'resolver');
+        var paths = ['a', 'b'];
+        var dirs = nodeModulesPaths(start, { paths: paths });
+
+        verifyDirs(t, start, dirs, null, paths);
+
+        t.end();
+    });
+
+    t.test('with paths=function option', function (t) {
+        var paths = function paths(request, absoluteStart, getNodeModulesDirs, opts) {
+            return getNodeModulesDirs().concat(path.join(absoluteStart, 'not node modules', request));
+        };
+
+        var start = path.join(__dirname, 'resolver');
+        var dirs = nodeModulesPaths(start, { paths: paths }, 'pkg');
+
+        verifyDirs(t, start, dirs, null, [path.join(start, 'not node modules', 'pkg')]);
+
+        t.end();
+    });
+
+    t.test('with paths=function skipping node modules resolution', function (t) {
+        var paths = function paths(request, absoluteStart, getNodeModulesDirs, opts) {
+            return [];
+        };
+        var start = path.join(__dirname, 'resolver');
+        var dirs = nodeModulesPaths(start, { paths: paths });
+        t.deepEqual(dirs, [], 'no node_modules was computed');
+        t.end();
+    });
+
+    t.test('with moduleDirectory option', function (t) {
+        var start = path.join(__dirname, 'resolver');
+        var moduleDirectory = 'not node modules';
+        var dirs = nodeModulesPaths(start, { moduleDirectory: moduleDirectory });
+
+        verifyDirs(t, start, dirs, moduleDirectory);
+
+        t.end();
+    });
+
+    t.test('with 1 moduleDirectory and paths options', function (t) {
+        var start = path.join(__dirname, 'resolver');
+        var paths = ['a', 'b'];
+        var moduleDirectory = 'not node modules';
+        var dirs = nodeModulesPaths(start, { paths: paths, moduleDirectory: moduleDirectory });
+
+        verifyDirs(t, start, dirs, moduleDirectory, paths);
+
+        t.end();
+    });
+
+    t.test('with 1+ moduleDirectory and paths options', function (t) {
+        var start = path.join(__dirname, 'resolver');
+        var paths = ['a', 'b'];
+        var moduleDirectories = ['not node modules', 'other modules'];
+        var dirs = nodeModulesPaths(start, { paths: paths, moduleDirectory: moduleDirectories });
+
+        verifyDirs(t, start, dirs, moduleDirectories, paths);
+
+        t.end();
+    });
+
+    t.test('combine paths correctly on Windows', function (t) {
+        var start = 'C:\\Users\\username\\myProject\\src';
+        var paths = [];
+        var moduleDirectories = ['node_modules', start];
+        var dirs = nodeModulesPaths(start, { paths: paths, moduleDirectory: moduleDirectories });
+
+        t.equal(dirs.indexOf(path.resolve(start)) > -1, true, 'should contain start dir');
+
+        t.end();
+    });
+
+    t.test('combine paths correctly on non-Windows', { skip: process.platform === 'win32' }, function (t) {
+        var start = '/Users/username/git/myProject/src';
+        var paths = [];
+        var moduleDirectories = ['node_modules', '/Users/username/git/myProject/src'];
+        var dirs = nodeModulesPaths(start, { paths: paths, moduleDirectory: moduleDirectories });
+
+        t.equal(dirs.indexOf(path.resolve(start)) > -1, true, 'should contain start dir');
+
+        t.end();
+    });
+});

node_modules/jest-resolve/node_modules/resolve/test/node_path.js

@@ -0,0 +1,70 @@
+var fs = require('fs');
+var path = require('path');
+var test = require('tape');
+var resolve = require('../');
+
+test('$NODE_PATH', function (t) {
+    t.plan(8);
+
+    var isDir = function (dir, cb) {
+        if (dir === '/node_path' || dir === 'node_path/x') {
+            return cb(null, true);
+        }
+        fs.stat(dir, function (err, stat) {
+            if (!err) {
+                return cb(null, stat.isDirectory());
+            }
+            if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
+            return cb(err);
+        });
+    };
+
+    resolve('aaa', {
+        paths: [
+            path.join(__dirname, '/node_path/x'),
+            path.join(__dirname, '/node_path/y')
+        ],
+        basedir: __dirname,
+        isDirectory: isDir
+    }, function (err, res) {
+        t.error(err);
+        t.equal(res, path.join(__dirname, '/node_path/x/aaa/index.js'), 'aaa resolves');
+    });
+
+    resolve('bbb', {
+        paths: [
+            path.join(__dirname, '/node_path/x'),
+            path.join(__dirname, '/node_path/y')
+        ],
+        basedir: __dirname,
+        isDirectory: isDir
+    }, function (err, res) {
+        t.error(err);
+        t.equal(res, path.join(__dirname, '/node_path/y/bbb/index.js'), 'bbb resolves');
+    });
+
+    resolve('ccc', {
+        paths: [
+            path.join(__dirname, '/node_path/x'),
+            path.join(__dirname, '/node_path/y')
+        ],
+        basedir: __dirname,
+        isDirectory: isDir
+    }, function (err, res) {
+        t.error(err);
+        t.equal(res, path.join(__dirname, '/node_path/x/ccc/index.js'), 'ccc resolves');
+    });
+
+    // ensure that relative paths still resolve against the regular `node_modules` correctly
+    resolve('tap', {
+        paths: [
+            'node_path'
+        ],
+        basedir: path.join(__dirname, 'node_path/x'),
+        isDirectory: isDir
+    }, function (err, res) {
+        var root = require('tap/package.json').main; // eslint-disable-line global-require
+        t.error(err);
+        t.equal(res, path.resolve(__dirname, '..', 'node_modules/tap', root), 'tap resolves');
+    });
+});

node_modules/jest-resolve/node_modules/resolve/test/node_path/x/aaa/index.js

@@ -0,0 +1 @@
+module.exports = 'A';

node_modules/jest-resolve/node_modules/resolve/test/node_path/x/ccc/index.js

@@ -0,0 +1 @@
+module.exports = 'C';

node_modules/jest-resolve/node_modules/resolve/test/node_path/y/bbb/index.js

@@ -0,0 +1 @@
+module.exports = 'B';

node_modules/jest-resolve/node_modules/resolve/test/node_path/y/ccc/index.js

@@ -0,0 +1 @@
+module.exports = 'CY';

node_modules/jest-resolve/node_modules/resolve/test/nonstring.js

@@ -0,0 +1,9 @@
+var test = require('tape');
+var resolve = require('../');
+
+test('nonstring', function (t) {
+    t.plan(1);
+    resolve(555, function (err, res, pkg) {
+        t.ok(err);
+    });
+});

node_modules/jest-resolve/node_modules/resolve/test/pathfilter.js

@@ -0,0 +1,75 @@
+var path = require('path');
+var test = require('tape');
+var resolve = require('../');
+
+var resolverDir = path.join(__dirname, '/pathfilter/deep_ref');
+
+var pathFilterFactory = function (t) {
+    return function (pkg, x, remainder) {
+        t.equal(pkg.version, '1.2.3');
+        t.equal(x, path.join(resolverDir, 'node_modules/deep/ref'));
+        t.equal(remainder, 'ref');
+        return 'alt';
+    };
+};
+
+test('#62: deep module references and the pathFilter', function (t) {
+    t.test('deep/ref.js', function (st) {
+        st.plan(3);
+
+        resolve('deep/ref', { basedir: resolverDir }, function (err, res, pkg) {
+            if (err) st.fail(err);
+
+            st.equal(pkg.version, '1.2.3');
+            st.equal(res, path.join(resolverDir, 'node_modules/deep/ref.js'));
+        });
+
+        var res = resolve.sync('deep/ref', { basedir: resolverDir });
+        st.equal(res, path.join(resolverDir, 'node_modules/deep/ref.js'));
+    });
+
+    t.test('deep/deeper/ref', function (st) {
+        st.plan(4);
+
+        resolve(
+            'deep/deeper/ref',
+            { basedir: resolverDir },
+            function (err, res, pkg) {
+                if (err) t.fail(err);
+                st.notEqual(pkg, undefined);
+                st.equal(pkg.version, '1.2.3');
+                st.equal(res, path.join(resolverDir, 'node_modules/deep/deeper/ref.js'));
+            }
+        );
+
+        var res = resolve.sync(
+            'deep/deeper/ref',
+            { basedir: resolverDir }
+        );
+        st.equal(res, path.join(resolverDir, 'node_modules/deep/deeper/ref.js'));
+    });
+
+    t.test('deep/ref alt', function (st) {
+        st.plan(8);
+
+        var pathFilter = pathFilterFactory(st);
+
+        var res = resolve.sync(
+            'deep/ref',
+            { basedir: resolverDir, pathFilter: pathFilter }
+        );
+        st.equal(res, path.join(resolverDir, 'node_modules/deep/alt.js'));
+
+        resolve(
+            'deep/ref',
+            { basedir: resolverDir, pathFilter: pathFilter },
+            function (err, res, pkg) {
+                if (err) st.fail(err);
+                st.equal(res, path.join(resolverDir, 'node_modules/deep/alt.js'));
+                st.end();
+            }
+        );
+    });
+
+    t.end();
+});

node_modules/jest-resolve/node_modules/resolve/test/precedence.js

@@ -0,0 +1,23 @@
+var path = require('path');
+var test = require('tape');
+var resolve = require('../');
+
+test('precedence', function (t) {
+    t.plan(3);
+    var dir = path.join(__dirname, 'precedence/aaa');
+
+    resolve('./', { basedir: dir }, function (err, res, pkg) {
+        t.ifError(err);
+        t.equal(res, path.join(dir, 'index.js'));
+        t.equal(pkg.name, 'resolve');
+    });
+});
+
+test('./ should not load ${dir}.js', function (t) { // eslint-disable-line no-template-curly-in-string
+    t.plan(1);
+    var dir = path.join(__dirname, 'precedence/bbb');
+
+    resolve('./', { basedir: dir }, function (err, res, pkg) {
+        t.ok(err);
+    });
+});

node_modules/jest-resolve/node_modules/resolve/test/precedence/aaa.js

@@ -0,0 +1 @@
+module.exports = 'wtf';

node_modules/jest-resolve/node_modules/resolve/test/precedence/aaa/index.js

@@ -0,0 +1 @@
+module.exports = 'okok';

node_modules/jest-resolve/node_modules/resolve/test/precedence/aaa/main.js

@@ -0,0 +1 @@
+console.log(require('./'));

node_modules/jest-resolve/node_modules/resolve/test/precedence/bbb.js

@@ -0,0 +1 @@
+module.exports = '>_<';

node_modules/jest-resolve/node_modules/resolve/test/precedence/bbb/main.js

@@ -0,0 +1 @@
+console.log(require('./')); // should throw

node_modules/jest-resolve/node_modules/resolve/test/resolver.js

@@ -0,0 +1,597 @@
+var path = require('path');
+var fs = require('fs');
+var test = require('tape');
+var resolve = require('../');
+var async = require('../async');
+
+test('`./async` entry point', function (t) {
+    t.equal(resolve, async, '`./async` entry point is the same as `main`');
+    t.end();
+});
+
+test('async foo', function (t) {
+    t.plan(12);
+    var dir = path.join(__dirname, 'resolver');
+
+    resolve('./foo', { basedir: dir }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'foo.js'));
+        t.equal(pkg && pkg.name, 'resolve');
+    });
+
+    resolve('./foo.js', { basedir: dir }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'foo.js'));
+        t.equal(pkg && pkg.name, 'resolve');
+    });
+
+    resolve('./foo', { basedir: dir, 'package': { main: 'resolver' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'foo.js'));
+        t.equal(pkg && pkg.main, 'resolver');
+    });
+
+    resolve('./foo.js', { basedir: dir, 'package': { main: 'resolver' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'foo.js'));
+        t.equal(pkg.main, 'resolver');
+    });
+
+    resolve('./foo', { basedir: dir, filename: path.join(dir, 'baz.js') }, function (err, res) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'foo.js'));
+    });
+
+    resolve('foo', { basedir: dir }, function (err) {
+        t.equal(err.message, "Cannot find module 'foo' from '" + path.resolve(dir) + "'");
+        t.equal(err.code, 'MODULE_NOT_FOUND');
+    });
+
+    // Test that filename is reported as the "from" value when passed.
+    resolve('foo', { basedir: dir, filename: path.join(dir, 'baz.js') }, function (err) {
+        t.equal(err.message, "Cannot find module 'foo' from '" + path.join(dir, 'baz.js') + "'");
+    });
+});
+
+test('bar', function (t) {
+    t.plan(6);
+    var dir = path.join(__dirname, 'resolver');
+
+    resolve('foo', { basedir: dir + '/bar' }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'bar/node_modules/foo/index.js'));
+        t.equal(pkg, undefined);
+    });
+
+    resolve('foo', { basedir: dir + '/bar' }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'bar/node_modules/foo/index.js'));
+        t.equal(pkg, undefined);
+    });
+
+    resolve('foo', { basedir: dir + '/bar', 'package': { main: 'bar' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'bar/node_modules/foo/index.js'));
+        t.equal(pkg.main, 'bar');
+    });
+});
+
+test('baz', function (t) {
+    t.plan(4);
+    var dir = path.join(__dirname, 'resolver');
+
+    resolve('./baz', { basedir: dir }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'baz/quux.js'));
+        t.equal(pkg.main, 'quux.js');
+    });
+
+    resolve('./baz', { basedir: dir, 'package': { main: 'resolver' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'baz/quux.js'));
+        t.equal(pkg.main, 'quux.js');
+    });
+});
+
+test('biz', function (t) {
+    t.plan(24);
+    var dir = path.join(__dirname, 'resolver/biz/node_modules');
+
+    resolve('./grux', { basedir: dir }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'grux/index.js'));
+        t.equal(pkg, undefined);
+    });
+
+    resolve('./grux', { basedir: dir, 'package': { main: 'biz' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'grux/index.js'));
+        t.equal(pkg.main, 'biz');
+    });
+
+    resolve('./garply', { basedir: dir }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'garply/lib/index.js'));
+        t.equal(pkg.main, './lib');
+    });
+
+    resolve('./garply', { basedir: dir, 'package': { main: 'biz' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'garply/lib/index.js'));
+        t.equal(pkg.main, './lib');
+    });
+
+    resolve('tiv', { basedir: dir + '/grux' }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'tiv/index.js'));
+        t.equal(pkg, undefined);
+    });
+
+    resolve('tiv', { basedir: dir + '/grux', 'package': { main: 'grux' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'tiv/index.js'));
+        t.equal(pkg.main, 'grux');
+    });
+
+    resolve('tiv', { basedir: dir + '/garply' }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'tiv/index.js'));
+        t.equal(pkg, undefined);
+    });
+
+    resolve('tiv', { basedir: dir + '/garply', 'package': { main: './lib' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'tiv/index.js'));
+        t.equal(pkg.main, './lib');
+    });
+
+    resolve('grux', { basedir: dir + '/tiv' }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'grux/index.js'));
+        t.equal(pkg, undefined);
+    });
+
+    resolve('grux', { basedir: dir + '/tiv', 'package': { main: 'tiv' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'grux/index.js'));
+        t.equal(pkg.main, 'tiv');
+    });
+
+    resolve('garply', { basedir: dir + '/tiv' }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'garply/lib/index.js'));
+        t.equal(pkg.main, './lib');
+    });
+
+    resolve('garply', { basedir: dir + '/tiv', 'package': { main: 'tiv' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'garply/lib/index.js'));
+        t.equal(pkg.main, './lib');
+    });
+});
+
+test('quux', function (t) {
+    t.plan(2);
+    var dir = path.join(__dirname, 'resolver/quux');
+
+    resolve('./foo', { basedir: dir, 'package': { main: 'quux' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'foo/index.js'));
+        t.equal(pkg.main, 'quux');
+    });
+});
+
+test('normalize', function (t) {
+    t.plan(2);
+    var dir = path.join(__dirname, 'resolver/biz/node_modules/grux');
+
+    resolve('../grux', { basedir: dir }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'index.js'));
+        t.equal(pkg, undefined);
+    });
+});
+
+test('cup', function (t) {
+    t.plan(5);
+    var dir = path.join(__dirname, 'resolver');
+
+    resolve('./cup', { basedir: dir, extensions: ['.js', '.coffee'] }, function (err, res) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'cup.coffee'));
+    });
+
+    resolve('./cup.coffee', { basedir: dir }, function (err, res) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'cup.coffee'));
+    });
+
+    resolve('./cup', { basedir: dir, extensions: ['.js'] }, function (err, res) {
+        t.equal(err.message, "Cannot find module './cup' from '" + path.resolve(dir) + "'");
+        t.equal(err.code, 'MODULE_NOT_FOUND');
+    });
+
+    // Test that filename is reported as the "from" value when passed.
+    resolve('./cup', { basedir: dir, extensions: ['.js'], filename: path.join(dir, 'cupboard.js') }, function (err, res) {
+        t.equal(err.message, "Cannot find module './cup' from '" + path.join(dir, 'cupboard.js') + "'");
+    });
+});
+
+test('mug', function (t) {
+    t.plan(3);
+    var dir = path.join(__dirname, 'resolver');
+
+    resolve('./mug', { basedir: dir }, function (err, res) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'mug.js'));
+    });
+
+    resolve('./mug', { basedir: dir, extensions: ['.coffee', '.js'] }, function (err, res) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, '/mug.coffee'));
+    });
+
+    resolve('./mug', { basedir: dir, extensions: ['.js', '.coffee'] }, function (err, res) {
+        t.equal(res, path.join(dir, '/mug.js'));
+    });
+});
+
+test('other path', function (t) {
+    t.plan(6);
+    var resolverDir = path.join(__dirname, 'resolver');
+    var dir = path.join(resolverDir, 'bar');
+    var otherDir = path.join(resolverDir, 'other_path');
+
+    resolve('root', { basedir: dir, paths: [otherDir] }, function (err, res) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(resolverDir, 'other_path/root.js'));
+    });
+
+    resolve('lib/other-lib', { basedir: dir, paths: [otherDir] }, function (err, res) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(resolverDir, 'other_path/lib/other-lib.js'));
+    });
+
+    resolve('root', { basedir: dir }, function (err, res) {
+        t.equal(err.message, "Cannot find module 'root' from '" + path.resolve(dir) + "'");
+        t.equal(err.code, 'MODULE_NOT_FOUND');
+    });
+
+    resolve('zzz', { basedir: dir, paths: [otherDir] }, function (err, res) {
+        t.equal(err.message, "Cannot find module 'zzz' from '" + path.resolve(dir) + "'");
+        t.equal(err.code, 'MODULE_NOT_FOUND');
+    });
+});
+
+test('path iterator', function (t) {
+    t.plan(2);
+
+    var resolverDir = path.join(__dirname, 'resolver');
+
+    var exactIterator = function (x, start, getPackageCandidates, opts) {
+        return [path.join(resolverDir, x)];
+    };
+
+    resolve('baz', { packageIterator: exactIterator }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(resolverDir, 'baz/quux.js'));
+        t.equal(pkg && pkg.name, 'baz');
+    });
+});
+
+test('incorrect main', function (t) {
+    t.plan(1);
+
+    var resolverDir = path.join(__dirname, 'resolver');
+    var dir = path.join(resolverDir, 'incorrect_main');
+
+    resolve('./incorrect_main', { basedir: resolverDir }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'index.js'));
+    });
+});
+
+test('missing index', function (t) {
+    t.plan(2);
+
+    var resolverDir = path.join(__dirname, 'resolver');
+    resolve('./missing_index', { basedir: resolverDir }, function (err, res, pkg) {
+        t.ok(err instanceof Error);
+        t.equal(err && err.code, 'MODULE_NOT_FOUND', 'error has correct error code');
+    });
+});
+
+test('missing main', function (t) {
+    t.plan(1);
+
+    var resolverDir = path.join(__dirname, 'resolver');
+
+    resolve('./missing_main', { basedir: resolverDir }, function (err, res, pkg) {
+        t.equal(err && err.code, 'MODULE_NOT_FOUND', 'error has correct error code');
+    });
+});
+
+test('null main', function (t) {
+    t.plan(1);
+
+    var resolverDir = path.join(__dirname, 'resolver');
+
+    resolve('./null_main', { basedir: resolverDir }, function (err, res, pkg) {
+        t.equal(err && err.code, 'MODULE_NOT_FOUND', 'error has correct error code');
+    });
+});
+
+test('main: false', function (t) {
+    t.plan(2);
+
+    var basedir = path.join(__dirname, 'resolver');
+    var dir = path.join(basedir, 'false_main');
+    resolve('./false_main', { basedir: basedir }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(
+            res,
+            path.join(dir, 'index.js'),
+            '`"main": false`: resolves to `index.js`'
+        );
+        t.deepEqual(pkg, {
+            name: 'false_main',
+            main: false
+        });
+    });
+});
+
+test('without basedir', function (t) {
+    t.plan(1);
+
+    var dir = path.join(__dirname, 'resolver/without_basedir');
+    var tester = require(path.join(dir, 'main.js')); // eslint-disable-line global-require
+
+    tester(t, function (err, res, pkg) {
+        if (err) {
+            t.fail(err);
+        } else {
+            t.equal(res, path.join(dir, 'node_modules/mymodule.js'));
+        }
+    });
+});
+
+test('#52 - incorrectly resolves module-paths like "./someFolder/" when there is a file of the same name', function (t) {
+    t.plan(2);
+
+    var dir = path.join(__dirname, 'resolver');
+
+    resolve('./foo', { basedir: path.join(dir, 'same_names') }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'same_names/foo.js'));
+    });
+
+    resolve('./foo/', { basedir: path.join(dir, 'same_names') }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'same_names/foo/index.js'));
+    });
+});
+
+test('#211 - incorrectly resolves module-paths like "." when from inside a folder with a sibling file of the same name', function (t) {
+    t.plan(2);
+
+    var dir = path.join(__dirname, 'resolver');
+
+    resolve('./', { basedir: path.join(dir, 'same_names/foo') }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'same_names/foo/index.js'));
+    });
+
+    resolve('.', { basedir: path.join(dir, 'same_names/foo') }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'same_names/foo/index.js'));
+    });
+});
+
+test('async: #121 - treating an existing file as a dir when no basedir', function (t) {
+    var testFile = path.basename(__filename);
+
+    t.test('sanity check', function (st) {
+        st.plan(1);
+        resolve('./' + testFile, function (err, res, pkg) {
+            if (err) t.fail(err);
+            st.equal(res, __filename, 'sanity check');
+        });
+    });
+
+    t.test('with a fake directory', function (st) {
+        st.plan(4);
+
+        resolve('./' + testFile + '/blah', function (err, res, pkg) {
+            st.ok(err, 'there is an error');
+            st.notOk(res, 'no result');
+
+            st.equal(err && err.code, 'MODULE_NOT_FOUND', 'error code matches require.resolve');
+            st.equal(
+                err && err.message,
+                'Cannot find module \'./' + testFile + '/blah\' from \'' + __dirname + '\'',
+                'can not find nonexistent module'
+            );
+            st.end();
+        });
+    });
+
+    t.end();
+});
+
+test('async dot main', function (t) {
+    var start = new Date();
+    t.plan(3);
+    resolve('./resolver/dot_main', function (err, ret) {
+        t.notOk(err);
+        t.equal(ret, path.join(__dirname, 'resolver/dot_main/index.js'));
+        t.ok(new Date() - start < 50, 'resolve.sync timedout');
+        t.end();
+    });
+});
+
+test('async dot slash main', function (t) {
+    var start = new Date();
+    t.plan(3);
+    resolve('./resolver/dot_slash_main', function (err, ret) {
+        t.notOk(err);
+        t.equal(ret, path.join(__dirname, 'resolver/dot_slash_main/index.js'));
+        t.ok(new Date() - start < 50, 'resolve.sync timedout');
+        t.end();
+    });
+});
+
+test('not a directory', function (t) {
+    t.plan(6);
+    var path = './foo';
+    resolve(path, { basedir: __filename }, function (err, res, pkg) {
+        t.ok(err, 'a non-directory errors');
+        t.equal(arguments.length, 1);
+        t.equal(res, undefined);
+        t.equal(pkg, undefined);
+
+        t.equal(err && err.message, 'Cannot find module \'' + path + '\' from \'' + __filename + '\'');
+        t.equal(err && err.code, 'MODULE_NOT_FOUND');
+    });
+});
+
+test('non-string "main" field in package.json', function (t) {
+    t.plan(5);
+
+    var dir = path.join(__dirname, 'resolver');
+    resolve('./invalid_main', { basedir: dir }, function (err, res, pkg) {
+        t.ok(err, 'errors on non-string main');
+        t.equal(err.message, 'package “invalid_main” `main` must be a string');
+        t.equal(err.code, 'INVALID_PACKAGE_MAIN');
+        t.equal(res, undefined, 'res is undefined');
+        t.equal(pkg, undefined, 'pkg is undefined');
+    });
+});
+
+test('non-string "main" field in package.json', function (t) {
+    t.plan(5);
+
+    var dir = path.join(__dirname, 'resolver');
+    resolve('./invalid_main', { basedir: dir }, function (err, res, pkg) {
+        t.ok(err, 'errors on non-string main');
+        t.equal(err.message, 'package “invalid_main” `main` must be a string');
+        t.equal(err.code, 'INVALID_PACKAGE_MAIN');
+        t.equal(res, undefined, 'res is undefined');
+        t.equal(pkg, undefined, 'pkg is undefined');
+    });
+});
+
+test('browser field in package.json', function (t) {
+    t.plan(3);
+
+    var dir = path.join(__dirname, 'resolver');
+    resolve(
+        './browser_field',
+        {
+            basedir: dir,
+            packageFilter: function packageFilter(pkg) {
+                if (pkg.browser) {
+                    pkg.main = pkg.browser; // eslint-disable-line no-param-reassign
+                    delete pkg.browser; // eslint-disable-line no-param-reassign
+                }
+                return pkg;
+            }
+        },
+        function (err, res, pkg) {
+            if (err) t.fail(err);
+            t.equal(res, path.join(dir, 'browser_field', 'b.js'));
+            t.equal(pkg && pkg.main, 'b');
+            t.equal(pkg && pkg.browser, undefined);
+        }
+    );
+});
+
+test('absolute paths', function (t) {
+    t.plan(4);
+
+    var extensionless = __filename.slice(0, -path.extname(__filename).length);
+
+    resolve(__filename, function (err, res) {
+        t.equal(
+            res,
+            __filename,
+            'absolute path to this file resolves'
+        );
+    });
+    resolve(extensionless, function (err, res) {
+        t.equal(
+            res,
+            __filename,
+            'extensionless absolute path to this file resolves'
+        );
+    });
+    resolve(__filename, { basedir: process.cwd() }, function (err, res) {
+        t.equal(
+            res,
+            __filename,
+            'absolute path to this file with a basedir resolves'
+        );
+    });
+    resolve(extensionless, { basedir: process.cwd() }, function (err, res) {
+        t.equal(
+            res,
+            __filename,
+            'extensionless absolute path to this file with a basedir resolves'
+        );
+    });
+});
+
+var malformedDir = path.join(__dirname, 'resolver/malformed_package_json');
+test('malformed package.json', { skip: !fs.existsSync(malformedDir) }, function (t) {
+    /* eslint operator-linebreak: ["error", "before"], function-paren-newline: "off" */
+    t.plan(
+        (3 * 3) // 3 sets of 3 assertions in the final callback
+        + 2 // 1 readPackage call with malformed package.json
+    );
+
+    var basedir = malformedDir;
+    var expected = path.join(basedir, 'index.js');
+
+    resolve('./index.js', { basedir: basedir }, function (err, res, pkg) {
+        t.error(err, 'no error');
+        t.equal(res, expected, 'malformed package.json is silently ignored');
+        t.equal(pkg, undefined, 'malformed package.json gives an undefined `pkg` argument');
+    });
+
+    resolve(
+        './index.js',
+        {
+            basedir: basedir,
+            packageFilter: function (pkg, pkgfile, dir) {
+                t.fail('should not reach here');
+            }
+        },
+        function (err, res, pkg) {
+            t.error(err, 'with packageFilter: no error');
+            t.equal(res, expected, 'with packageFilter: malformed package.json is silently ignored');
+            t.equal(pkg, undefined, 'with packageFilter: malformed package.json gives an undefined `pkg` argument');
+        }
+    );
+
+    resolve(
+        './index.js',
+        {
+            basedir: basedir,
+            readPackage: function (readFile, pkgfile, cb) {
+                t.equal(pkgfile, path.join(basedir, 'package.json'), 'readPackageSync: `pkgfile` is package.json path');
+                readFile(pkgfile, function (err, result) {
+                    try {
+                        cb(null, JSON.parse(result));
+                    } catch (e) {
+                        t.ok(e instanceof SyntaxError, 'readPackage: malformed package.json parses as a syntax error');
+                        cb(null);
+                    }
+                });
+            }
+        },
+        function (err, res, pkg) {
+            t.error(err, 'with readPackage: no error');
+            t.equal(res, expected, 'with readPackage: malformed package.json is silently ignored');
+            t.equal(pkg, undefined, 'with readPackage: malformed package.json gives an undefined `pkg` argument');
+        }
+    );
+});

node_modules/jest-resolve/node_modules/resolve/test/resolver/baz/package.json

@@ -0,0 +1,4 @@
+{
+    "name": "baz",
+    "main": "quux.js"
+}

node_modules/jest-resolve/node_modules/resolve/test/resolver/baz/quux.js

@@ -0,0 +1 @@
+module.exports = 1;

node_modules/jest-resolve/node_modules/resolve/test/resolver/browser_field/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "browser_field",
+  "main": "a",
+  "browser": "b"
+}

node_modules/jest-resolve/node_modules/resolve/test/resolver/cup.coffee

@@ -0,0 +1 @@
+

node_modules/jest-resolve/node_modules/resolve/test/resolver/dot_main/index.js

@@ -0,0 +1 @@
+module.exports = 1;

node_modules/jest-resolve/node_modules/resolve/test/resolver/dot_main/package.json

@@ -0,0 +1,3 @@
+{
+    "main": "."
+}

node_modules/jest-resolve/node_modules/resolve/test/resolver/dot_slash_main/index.js

@@ -0,0 +1 @@
+module.exports = 1;

node_modules/jest-resolve/node_modules/resolve/test/resolver/dot_slash_main/package.json

@@ -0,0 +1,3 @@
+{
+    "main": "./"
+}

node_modules/jest-resolve/node_modules/resolve/test/resolver/false_main/package.json

@@ -0,0 +1,4 @@
+{
+	"name": "false_main",
+	"main": false
+}

node_modules/jest-resolve/node_modules/resolve/test/resolver/foo.js

@@ -0,0 +1 @@
+module.exports = 1;

node_modules/jest-resolve/node_modules/resolve/test/resolver/incorrect_main/index.js

@@ -0,0 +1,2 @@
+// this is the actual main file 'index.js', not 'wrong.js' like the package.json would indicate
+module.exports = 1;

node_modules/jest-resolve/node_modules/resolve/test/resolver/incorrect_main/package.json

@@ -0,0 +1,3 @@
+{
+    "main": "wrong.js"
+}

node_modules/jest-resolve/node_modules/resolve/test/resolver/invalid_main/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "invalid_main",
+  "main": [
+    "why is this a thing",
+    "srsly omg wtf"
+  ]
+}

node_modules/jest-resolve/node_modules/resolve/test/resolver/multirepo/lerna.json

@@ -0,0 +1,6 @@
+{
+  "packages": [
+    "packages/*"
+  ],
+  "version": "0.0.0"
+}

node_modules/jest-resolve/node_modules/resolve/test/resolver/multirepo/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "ljharb-monorepo-symlink-test",
+  "private": true,
+  "version": "0.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "postinstall": "lerna bootstrap",
+    "test": "node packages/package-a"
+  },
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "jquery": "^3.3.1",
+    "resolve": "../../../"
+  },
+  "devDependencies": {
+    "lerna": "^3.4.3"
+  }
+}

node_modules/jest-resolve/node_modules/resolve/test/resolver/multirepo/packages/package-a/index.js

@@ -0,0 +1,35 @@
+'use strict';
+
+var assert = require('assert');
+var path = require('path');
+var resolve = require('resolve');
+
+var basedir = __dirname + '/node_modules/@my-scope/package-b';
+
+var expected = path.join(__dirname, '../../node_modules/jquery/dist/jquery.js');
+
+/*
+ * preserveSymlinks === false
+ * will search NPM package from
+ * - packages/package-b/node_modules
+ * - packages/node_modules
+ * - node_modules
+ */
+assert.equal(resolve.sync('jquery', { basedir: basedir, preserveSymlinks: false }), expected);
+assert.equal(resolve.sync('../../node_modules/jquery', { basedir: basedir, preserveSymlinks: false }), expected);
+
+/*
+ * preserveSymlinks === true
+ * will search NPM package from
+ * - packages/package-a/node_modules/@my-scope/packages/package-b/node_modules
+ * - packages/package-a/node_modules/@my-scope/packages/node_modules
+ * - packages/package-a/node_modules/@my-scope/node_modules
+ * - packages/package-a/node_modules/node_modules
+ * - packages/package-a/node_modules
+ * - packages/node_modules
+ * - node_modules
+ */
+assert.equal(resolve.sync('jquery', { basedir: basedir, preserveSymlinks: true }), expected);
+assert.equal(resolve.sync('../../../../../node_modules/jquery', { basedir: basedir, preserveSymlinks: true }), expected);
+
+console.log(' * all monorepo paths successfully resolved through symlinks');

node_modules/jest-resolve/node_modules/resolve/test/resolver/multirepo/packages/package-a/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@my-scope/package-a",
+  "version": "0.0.0",
+  "private": true,
+  "description": "",
+  "license": "MIT",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: run tests from root\" && exit 1"
+  },
+  "dependencies": {
+    "@my-scope/package-b": "^0.0.0"
+  }
+}

node_modules/jest-resolve/node_modules/resolve/test/resolver/multirepo/packages/package-b/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@my-scope/package-b",
+  "private": true,
+  "version": "0.0.0",
+  "description": "",
+  "license": "MIT",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: run tests from root\" && exit 1"
+  },
+  "dependencies": {
+    "@my-scope/package-a": "^0.0.0"
+  }
+}

node_modules/jest-resolve/node_modules/resolve/test/resolver/nested_symlinks/mylib/async.js

@@ -0,0 +1,26 @@
+var a = require.resolve('buffer/').replace(process.cwd(), '$CWD');
+var b;
+var c;
+
+var test = function test() {
+    console.log(a, ': require.resolve, preserveSymlinks ' + (process.execArgv.indexOf('preserve-symlinks') > -1 ? 'true' : 'false'));
+    console.log(b, ': preserveSymlinks true');
+    console.log(c, ': preserveSymlinks false');
+
+    if (a !== b && a !== c) {
+        throw 'async: no match';
+    }
+    console.log('async: success! a matched either b or c\n');
+};
+
+require('resolve')('buffer/', { preserveSymlinks: true }, function (err, result) {
+    if (err) { throw err; }
+    b = result.replace(process.cwd(), '$CWD');
+    if (b && c) { test(); }
+});
+require('resolve')('buffer/', { preserveSymlinks: false }, function (err, result) {
+    if (err) { throw err; }
+    c = result.replace(process.cwd(), '$CWD');
+    if (b && c) { test(); }
+});
+

node_modules/jest-resolve/node_modules/resolve/test/resolver/nested_symlinks/mylib/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "mylib",
+  "version": "0.0.0",
+  "description": "",
+  "private": true,
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "buffer": "*"
+  }
+}

node_modules/jest-resolve/node_modules/resolve/test/resolver/nested_symlinks/mylib/sync.js

@@ -0,0 +1,12 @@
+var a = require.resolve('buffer/').replace(process.cwd(), '$CWD');
+var b = require('resolve').sync('buffer/', { preserveSymlinks: true }).replace(process.cwd(), '$CWD');
+var c = require('resolve').sync('buffer/', { preserveSymlinks: false }).replace(process.cwd(), '$CWD');
+
+console.log(a, ': require.resolve, preserveSymlinks ' + (process.execArgv.indexOf('preserve-symlinks') > -1 ? 'true' : 'false'));
+console.log(b, ': preserveSymlinks true');
+console.log(c, ': preserveSymlinks false');
+
+if (a !== b && a !== c) {
+    throw 'sync: no match';
+}
+console.log('sync: success! a matched either b or c\n');

node_modules/jest-resolve/node_modules/resolve/test/resolver/quux/foo/index.js

@@ -0,0 +1 @@
+module.exports = 1;

node_modules/jest-resolve/node_modules/resolve/test/resolver/same_names/foo.js

@@ -0,0 +1 @@
+module.exports = 42;

node_modules/jest-resolve/node_modules/resolve/test/resolver/same_names/foo/index.js

@@ -0,0 +1 @@
+module.exports = 1;

node_modules/jest-resolve/node_modules/resolve/test/resolver/symlinked/package/bar.js

@@ -0,0 +1 @@
+module.exports = 'bar';

node_modules/jest-resolve/node_modules/resolve/test/resolver/symlinked/package/package.json

@@ -0,0 +1,3 @@
+{
+    "main": "bar.js"
+}

node_modules/jest-resolve/node_modules/resolve/test/resolver/without_basedir/main.js

@@ -0,0 +1,5 @@
+var resolve = require('../../../');
+
+module.exports = function (t, cb) {
+    resolve('mymodule', null, cb);
+};