Added node_modules for the updating to work properly.

87 files changed, 6422 insertions, 0 deletions

diff --git a/node_modules/@jest/core/build/FailedTestsCache.d.ts b/node_modules/@jest/core/build/FailedTestsCache.d.ts
new file mode 100644
index 0000000..565af37
--- /dev/null
+++ b/node_modules/@jest/core/build/FailedTestsCache.d.ts
@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Test, TestResult } from '@jest/test-result';
+export default class FailedTestsCache {
+    private _enabledTestsMap?;
+    filterTests(tests: Array<Test>): Array<Test>;
+    setTestResults(testResults: Array<TestResult>): void;
+}
diff --git a/node_modules/@jest/core/build/FailedTestsCache.js b/node_modules/@jest/core/build/FailedTestsCache.js
new file mode 100644
index 0000000..389e8b8
--- /dev/null
+++ b/node_modules/@jest/core/build/FailedTestsCache.js
@@ -0,0 +1,59 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+class FailedTestsCache {
+  constructor() {
+    _defineProperty(this, '_enabledTestsMap', void 0);
+  }
+
+  filterTests(tests) {
+    const enabledTestsMap = this._enabledTestsMap;
+
+    if (!enabledTestsMap) {
+      return tests;
+    }
+
+    return tests.filter(testResult => enabledTestsMap[testResult.path]);
+  }
+
+  setTestResults(testResults) {
+    this._enabledTestsMap = (testResults || [])
+      .filter(testResult => testResult.numFailingTests)
+      .reduce((suiteMap, testResult) => {
+        suiteMap[testResult.testFilePath] = testResult.testResults
+          .filter(test => test.status === 'failed')
+          .reduce((testMap, test) => {
+            testMap[test.fullName] = true;
+            return testMap;
+          }, {});
+        return suiteMap;
+      }, {});
+    this._enabledTestsMap = Object.freeze(this._enabledTestsMap);
+  }
+}
+
+exports.default = FailedTestsCache;
diff --git a/node_modules/@jest/core/build/FailedTestsInteractiveMode.d.ts b/node_modules/@jest/core/build/FailedTestsInteractiveMode.d.ts
new file mode 100644
index 0000000..c543c69
--- /dev/null
+++ b/node_modules/@jest/core/build/FailedTestsInteractiveMode.d.ts
@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/// <reference types="node" />
+import type { AggregatedResult, AssertionLocation } from '@jest/test-result';
+declare type RunnerUpdateFunction = (failure?: AssertionLocation) => void;
+export default class FailedTestsInteractiveMode {
+    private _pipe;
+    private _isActive;
+    private _countPaths;
+    private _skippedNum;
+    private _testAssertions;
+    private _updateTestRunnerConfig?;
+    constructor(_pipe: NodeJS.WritableStream);
+    isActive(): boolean;
+    put(key: string): void;
+    run(failedTestAssertions: Array<AssertionLocation>, updateConfig: RunnerUpdateFunction): void;
+    updateWithResults(results: AggregatedResult): void;
+    private _clearTestSummary;
+    private _drawUIDone;
+    private _drawUIDoneWithSkipped;
+    private _drawUIProgress;
+    private _drawUIOverlay;
+    private _run;
+    private abort;
+    private restart;
+}
+export {};
diff --git a/node_modules/@jest/core/build/FailedTestsInteractiveMode.js b/node_modules/@jest/core/build/FailedTestsInteractiveMode.js
new file mode 100644
index 0000000..e9e6534
--- /dev/null
+++ b/node_modules/@jest/core/build/FailedTestsInteractiveMode.js
@@ -0,0 +1,262 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+function _ansiEscapes() {
+  const data = _interopRequireDefault(require('ansi-escapes'));
+
+  _ansiEscapes = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+
+  _chalk = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestWatcher() {
+  const data = require('jest-watcher');
+
+  _jestWatcher = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+const {ARROW, CLEAR} = _jestUtil().specialChars;
+
+function describeKey(key, description) {
+  return `${_chalk().default.dim(
+    ARROW + 'Press'
+  )} ${key} ${_chalk().default.dim(description)}`;
+}
+
+const TestProgressLabel = _chalk().default.bold('Interactive Test Progress');
+
+class FailedTestsInteractiveMode {
+  constructor(_pipe) {
+    _defineProperty(this, '_isActive', false);
+
+    _defineProperty(this, '_countPaths', 0);
+
+    _defineProperty(this, '_skippedNum', 0);
+
+    _defineProperty(this, '_testAssertions', []);
+
+    _defineProperty(this, '_updateTestRunnerConfig', void 0);
+
+    this._pipe = _pipe;
+  }
+
+  isActive() {
+    return this._isActive;
+  }
+
+  put(key) {
+    switch (key) {
+      case 's':
+        if (this._skippedNum === this._testAssertions.length) {
+          break;
+        }
+
+        this._skippedNum += 1; // move skipped test to the end
+
+        this._testAssertions.push(this._testAssertions.shift());
+
+        if (this._testAssertions.length - this._skippedNum > 0) {
+          this._run();
+        } else {
+          this._drawUIDoneWithSkipped();
+        }
+
+        break;
+
+      case 'q':
+      case _jestWatcher().KEYS.ESCAPE:
+        this.abort();
+        break;
+
+      case 'r':
+        this.restart();
+        break;
+
+      case _jestWatcher().KEYS.ENTER:
+        if (this._testAssertions.length === 0) {
+          this.abort();
+        } else {
+          this._run();
+        }
+
+        break;
+
+      default:
+    }
+  }
+
+  run(failedTestAssertions, updateConfig) {
+    if (failedTestAssertions.length === 0) return;
+    this._testAssertions = [...failedTestAssertions];
+    this._countPaths = this._testAssertions.length;
+    this._updateTestRunnerConfig = updateConfig;
+    this._isActive = true;
+
+    this._run();
+  }
+
+  updateWithResults(results) {
+    if (!results.snapshot.failure && results.numFailedTests > 0) {
+      return this._drawUIOverlay();
+    }
+
+    this._testAssertions.shift();
+
+    if (this._testAssertions.length === 0) {
+      return this._drawUIOverlay();
+    } // Go to the next test
+
+    return this._run();
+  }
+
+  _clearTestSummary() {
+    this._pipe.write(_ansiEscapes().default.cursorUp(6));
+
+    this._pipe.write(_ansiEscapes().default.eraseDown);
+  }
+
+  _drawUIDone() {
+    this._pipe.write(CLEAR);
+
+    const messages = [
+      _chalk().default.bold('Watch Usage'),
+      describeKey('Enter', 'to return to watch mode.')
+    ];
+
+    this._pipe.write(messages.join('\n') + '\n');
+  }
+
+  _drawUIDoneWithSkipped() {
+    this._pipe.write(CLEAR);
+
+    let stats = `${(0, _jestUtil().pluralize)(
+      'test',
+      this._countPaths
+    )} reviewed`;
+
+    if (this._skippedNum > 0) {
+      const skippedText = _chalk().default.bold.yellow(
+        (0, _jestUtil().pluralize)('test', this._skippedNum) + ' skipped'
+      );
+
+      stats = `${stats}, ${skippedText}`;
+    }
+
+    const message = [
+      TestProgressLabel,
+      `${ARROW}${stats}`,
+      '\n',
+      _chalk().default.bold('Watch Usage'),
+      describeKey('r', 'to restart Interactive Mode.'),
+      describeKey('q', 'to quit Interactive Mode.'),
+      describeKey('Enter', 'to return to watch mode.')
+    ];
+
+    this._pipe.write(`\n${message.join('\n')}`);
+  }
+
+  _drawUIProgress() {
+    this._clearTestSummary();
+
+    const numPass = this._countPaths - this._testAssertions.length;
+    const numRemaining = this._countPaths - numPass - this._skippedNum;
+    let stats = `${(0, _jestUtil().pluralize)('test', numRemaining)} remaining`;
+
+    if (this._skippedNum > 0) {
+      const skippedText = _chalk().default.bold.yellow(
+        (0, _jestUtil().pluralize)('test', this._skippedNum) + ' skipped'
+      );
+
+      stats = `${stats}, ${skippedText}`;
+    }
+
+    const message = [
+      TestProgressLabel,
+      `${ARROW}${stats}`,
+      '\n',
+      _chalk().default.bold('Watch Usage'),
+      describeKey('s', 'to skip the current test.'),
+      describeKey('q', 'to quit Interactive Mode.'),
+      describeKey('Enter', 'to return to watch mode.')
+    ];
+
+    this._pipe.write(`\n${message.join('\n')}`);
+  }
+
+  _drawUIOverlay() {
+    if (this._testAssertions.length === 0) return this._drawUIDone();
+    return this._drawUIProgress();
+  }
+
+  _run() {
+    if (this._updateTestRunnerConfig) {
+      this._updateTestRunnerConfig(this._testAssertions[0]);
+    }
+  }
+
+  abort() {
+    this._isActive = false;
+    this._skippedNum = 0;
+
+    if (this._updateTestRunnerConfig) {
+      this._updateTestRunnerConfig();
+    }
+  }
+
+  restart() {
+    this._skippedNum = 0;
+    this._countPaths = this._testAssertions.length;
+
+    this._run();
+  }
+}
+
+exports.default = FailedTestsInteractiveMode;
diff --git a/node_modules/@jest/core/build/ReporterDispatcher.d.ts b/node_modules/@jest/core/build/ReporterDispatcher.d.ts
new file mode 100644
index 0000000..ed34a0e
--- /dev/null
+++ b/node_modules/@jest/core/build/ReporterDispatcher.d.ts
@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Reporter, ReporterOnStartOptions } from '@jest/reporters';
+import type { AggregatedResult, Test, TestCaseResult, TestResult } from '@jest/test-result';
+import type { Context } from 'jest-runtime';
+export default class ReporterDispatcher {
+    private _reporters;
+    constructor();
+    register(reporter: Reporter): void;
+    unregister(ReporterClass: Function): void;
+    onTestFileResult(test: Test, testResult: TestResult, results: AggregatedResult): Promise<void>;
+    onTestFileStart(test: Test): Promise<void>;
+    onRunStart(results: AggregatedResult, options: ReporterOnStartOptions): Promise<void>;
+    onTestCaseResult(test: Test, testCaseResult: TestCaseResult): Promise<void>;
+    onRunComplete(contexts: Set<Context>, results: AggregatedResult): Promise<void>;
+    getErrors(): Array<Error>;
+    hasErrors(): boolean;
+}
diff --git a/node_modules/@jest/core/build/ReporterDispatcher.js b/node_modules/@jest/core/build/ReporterDispatcher.js
new file mode 100644
index 0000000..efd6af0
--- /dev/null
+++ b/node_modules/@jest/core/build/ReporterDispatcher.js
@@ -0,0 +1,104 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/* eslint-disable local/ban-types-eventually */
+class ReporterDispatcher {
+  constructor() {
+    _defineProperty(this, '_reporters', void 0);
+
+    this._reporters = [];
+  }
+
+  register(reporter) {
+    this._reporters.push(reporter);
+  }
+
+  unregister(ReporterClass) {
+    this._reporters = this._reporters.filter(
+      reporter => !(reporter instanceof ReporterClass)
+    );
+  }
+
+  async onTestFileResult(test, testResult, results) {
+    for (const reporter of this._reporters) {
+      if (reporter.onTestFileResult) {
+        await reporter.onTestFileResult(test, testResult, results);
+      } else if (reporter.onTestResult) {
+        await reporter.onTestResult(test, testResult, results);
+      }
+    } // Release memory if unused later.
+
+    testResult.coverage = undefined;
+    testResult.console = undefined;
+  }
+
+  async onTestFileStart(test) {
+    for (const reporter of this._reporters) {
+      if (reporter.onTestFileStart) {
+        await reporter.onTestFileStart(test);
+      } else if (reporter.onTestStart) {
+        await reporter.onTestStart(test);
+      }
+    }
+  }
+
+  async onRunStart(results, options) {
+    for (const reporter of this._reporters) {
+      reporter.onRunStart && (await reporter.onRunStart(results, options));
+    }
+  }
+
+  async onTestCaseResult(test, testCaseResult) {
+    for (const reporter of this._reporters) {
+      if (reporter.onTestCaseResult) {
+        await reporter.onTestCaseResult(test, testCaseResult);
+      }
+    }
+  }
+
+  async onRunComplete(contexts, results) {
+    for (const reporter of this._reporters) {
+      if (reporter.onRunComplete) {
+        await reporter.onRunComplete(contexts, results);
+      }
+    }
+  } // Return a list of last errors for every reporter
+
+  getErrors() {
+    return this._reporters.reduce((list, reporter) => {
+      const error = reporter.getLastError && reporter.getLastError();
+      return error ? list.concat(error) : list;
+    }, []);
+  }
+
+  hasErrors() {
+    return this.getErrors().length !== 0;
+  }
+}
+
+exports.default = ReporterDispatcher;
diff --git a/node_modules/@jest/core/build/SearchSource.d.ts b/node_modules/@jest/core/build/SearchSource.d.ts
new file mode 100644
index 0000000..43c8e82
--- /dev/null
+++ b/node_modules/@jest/core/build/SearchSource.d.ts
@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Test } from '@jest/test-result';
+import type { Config } from '@jest/types';
+import type { ChangedFiles } from 'jest-changed-files';
+import type { Context } from 'jest-runtime';
+import type { Filter, Stats } from './types';
+export declare type SearchResult = {
+    noSCM?: boolean;
+    stats?: Stats;
+    collectCoverageFrom?: Set<string>;
+    tests: Array<Test>;
+    total?: number;
+};
+export declare type TestSelectionConfig = {
+    input?: string;
+    findRelatedTests?: boolean;
+    onlyChanged?: boolean;
+    paths?: Array<Config.Path>;
+    shouldTreatInputAsPattern?: boolean;
+    testPathPattern?: string;
+    watch?: boolean;
+};
+export default class SearchSource {
+    private _context;
+    private _dependencyResolver;
+    private _testPathCases;
+    constructor(context: Context);
+    private _getOrBuildDependencyResolver;
+    private _filterTestPathsWithStats;
+    private _getAllTestPaths;
+    isTestFilePath(path: Config.Path): boolean;
+    findMatchingTests(testPathPattern?: string): SearchResult;
+    findRelatedTests(allPaths: Set<Config.Path>, collectCoverage: boolean): Promise<SearchResult>;
+    findTestsByPaths(paths: Array<Config.Path>): SearchResult;
+    findRelatedTestsFromPattern(paths: Array<Config.Path>, collectCoverage: boolean): Promise<SearchResult>;
+    findTestRelatedToChangedFiles(changedFilesInfo: ChangedFiles, collectCoverage: boolean): Promise<SearchResult>;
+    private _getTestPaths;
+    filterPathsWin32(paths: Array<string>): Array<string>;
+    getTestPaths(globalConfig: Config.GlobalConfig, changedFiles: ChangedFiles | undefined, filter?: Filter): Promise<SearchResult>;
+    findRelatedSourcesFromTestsInChangedFiles(changedFilesInfo: ChangedFiles): Promise<Array<string>>;
+}
diff --git a/node_modules/@jest/core/build/SearchSource.js b/node_modules/@jest/core/build/SearchSource.js
new file mode 100644
index 0000000..927f59d
--- /dev/null
+++ b/node_modules/@jest/core/build/SearchSource.js
@@ -0,0 +1,490 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+function os() {
+  const data = _interopRequireWildcard(require('os'));
+
+  os = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function path() {
+  const data = _interopRequireWildcard(require('path'));
+
+  path = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _micromatch() {
+  const data = _interopRequireDefault(require('micromatch'));
+
+  _micromatch = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestConfig() {
+  const data = require('jest-config');
+
+  _jestConfig = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestRegexUtil() {
+  const data = require('jest-regex-util');
+
+  _jestRegexUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestResolveDependencies() {
+  const data = require('jest-resolve-dependencies');
+
+  _jestResolveDependencies = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestSnapshot() {
+  const data = require('jest-snapshot');
+
+  _jestSnapshot = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = 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;
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+const regexToMatcher = testRegex => {
+  const regexes = testRegex.map(testRegex => new RegExp(testRegex));
+  return path =>
+    regexes.some(regex => {
+      const result = regex.test(path); // prevent stateful regexes from breaking, just in case
+
+      regex.lastIndex = 0;
+      return result;
+    });
+};
+
+const toTests = (context, tests) =>
+  tests.map(path => ({
+    context,
+    duration: undefined,
+    path
+  }));
+
+const hasSCM = changedFilesInfo => {
+  const {repos} = changedFilesInfo; // no SCM (git/hg/...) is found in any of the roots.
+
+  const noSCM = Object.values(repos).every(scm => scm.size === 0);
+  return !noSCM;
+};
+
+class SearchSource {
+  constructor(context) {
+    _defineProperty(this, '_context', void 0);
+
+    _defineProperty(this, '_dependencyResolver', void 0);
+
+    _defineProperty(this, '_testPathCases', []);
+
+    const {config} = context;
+    this._context = context;
+    this._dependencyResolver = null;
+    const rootPattern = new RegExp(
+      config.roots
+        .map(dir => (0, _jestRegexUtil().escapePathForRegex)(dir + path().sep))
+        .join('|')
+    );
+
+    this._testPathCases.push({
+      isMatch: path => rootPattern.test(path),
+      stat: 'roots'
+    });
+
+    if (config.testMatch.length) {
+      this._testPathCases.push({
+        isMatch: (0, _jestUtil().globsToMatcher)(config.testMatch),
+        stat: 'testMatch'
+      });
+    }
+
+    if (config.testPathIgnorePatterns.length) {
+      const testIgnorePatternsRegex = new RegExp(
+        config.testPathIgnorePatterns.join('|')
+      );
+
+      this._testPathCases.push({
+        isMatch: path => !testIgnorePatternsRegex.test(path),
+        stat: 'testPathIgnorePatterns'
+      });
+    }
+
+    if (config.testRegex.length) {
+      this._testPathCases.push({
+        isMatch: regexToMatcher(config.testRegex),
+        stat: 'testRegex'
+      });
+    }
+  }
+
+  async _getOrBuildDependencyResolver() {
+    if (!this._dependencyResolver) {
+      this._dependencyResolver =
+        new (_jestResolveDependencies().DependencyResolver)(
+          this._context.resolver,
+          this._context.hasteFS,
+          await (0, _jestSnapshot().buildSnapshotResolver)(this._context.config)
+        );
+    }
+
+    return this._dependencyResolver;
+  }
+
+  _filterTestPathsWithStats(allPaths, testPathPattern) {
+    const data = {
+      stats: {
+        roots: 0,
+        testMatch: 0,
+        testPathIgnorePatterns: 0,
+        testRegex: 0
+      },
+      tests: [],
+      total: allPaths.length
+    };
+    const testCases = Array.from(this._testPathCases); // clone
+
+    if (testPathPattern) {
+      const regex = (0, _jestUtil().testPathPatternToRegExp)(testPathPattern);
+      testCases.push({
+        isMatch: path => regex.test(path),
+        stat: 'testPathPattern'
+      });
+      data.stats.testPathPattern = 0;
+    }
+
+    data.tests = allPaths.filter(test => {
+      let filterResult = true;
+
+      for (const {isMatch, stat} of testCases) {
+        if (isMatch(test.path)) {
+          data.stats[stat]++;
+        } else {
+          filterResult = false;
+        }
+      }
+
+      return filterResult;
+    });
+    return data;
+  }
+
+  _getAllTestPaths(testPathPattern) {
+    return this._filterTestPathsWithStats(
+      toTests(this._context, this._context.hasteFS.getAllFiles()),
+      testPathPattern
+    );
+  }
+
+  isTestFilePath(path) {
+    return this._testPathCases.every(testCase => testCase.isMatch(path));
+  }
+
+  findMatchingTests(testPathPattern) {
+    return this._getAllTestPaths(testPathPattern);
+  }
+
+  async findRelatedTests(allPaths, collectCoverage) {
+    const dependencyResolver = await this._getOrBuildDependencyResolver();
+
+    if (!collectCoverage) {
+      return {
+        tests: toTests(
+          this._context,
+          dependencyResolver.resolveInverse(
+            allPaths,
+            this.isTestFilePath.bind(this),
+            {
+              skipNodeResolution: this._context.config.skipNodeResolution
+            }
+          )
+        )
+      };
+    }
+
+    const testModulesMap = dependencyResolver.resolveInverseModuleMap(
+      allPaths,
+      this.isTestFilePath.bind(this),
+      {
+        skipNodeResolution: this._context.config.skipNodeResolution
+      }
+    );
+    const allPathsAbsolute = Array.from(allPaths).map(p => path().resolve(p));
+    const collectCoverageFrom = new Set();
+    testModulesMap.forEach(testModule => {
+      if (!testModule.dependencies) {
+        return;
+      }
+
+      testModule.dependencies.forEach(p => {
+        if (!allPathsAbsolute.includes(p)) {
+          return;
+        }
+
+        const filename = (0, _jestConfig().replaceRootDirInPath)(
+          this._context.config.rootDir,
+          p
+        );
+        collectCoverageFrom.add(
+          path().isAbsolute(filename)
+            ? path().relative(this._context.config.rootDir, filename)
+            : filename
+        );
+      });
+    });
+    return {
+      collectCoverageFrom,
+      tests: toTests(
+        this._context,
+        testModulesMap.map(testModule => testModule.file)
+      )
+    };
+  }
+
+  findTestsByPaths(paths) {
+    return {
+      tests: toTests(
+        this._context,
+        paths
+          .map(p => path().resolve(this._context.config.cwd, p))
+          .filter(this.isTestFilePath.bind(this))
+      )
+    };
+  }
+
+  async findRelatedTestsFromPattern(paths, collectCoverage) {
+    if (Array.isArray(paths) && paths.length) {
+      const resolvedPaths = paths.map(p =>
+        path().resolve(this._context.config.cwd, p)
+      );
+      return this.findRelatedTests(new Set(resolvedPaths), collectCoverage);
+    }
+
+    return {
+      tests: []
+    };
+  }
+
+  async findTestRelatedToChangedFiles(changedFilesInfo, collectCoverage) {
+    if (!hasSCM(changedFilesInfo)) {
+      return {
+        noSCM: true,
+        tests: []
+      };
+    }
+
+    const {changedFiles} = changedFilesInfo;
+    return this.findRelatedTests(changedFiles, collectCoverage);
+  }
+
+  async _getTestPaths(globalConfig, changedFiles) {
+    if (globalConfig.onlyChanged) {
+      if (!changedFiles) {
+        throw new Error('Changed files must be set when running with -o.');
+      }
+
+      return this.findTestRelatedToChangedFiles(
+        changedFiles,
+        globalConfig.collectCoverage
+      );
+    }
+
+    let paths = globalConfig.nonFlagArgs;
+
+    if (globalConfig.findRelatedTests && 'win32' === os().platform()) {
+      paths = this.filterPathsWin32(paths);
+    }
+
+    if (globalConfig.runTestsByPath && paths && paths.length) {
+      return this.findTestsByPaths(paths);
+    } else if (globalConfig.findRelatedTests && paths && paths.length) {
+      return this.findRelatedTestsFromPattern(
+        paths,
+        globalConfig.collectCoverage
+      );
+    } else if (globalConfig.testPathPattern != null) {
+      return this.findMatchingTests(globalConfig.testPathPattern);
+    } else {
+      return {
+        tests: []
+      };
+    }
+  }
+
+  filterPathsWin32(paths) {
+    const allFiles = this._context.hasteFS.getAllFiles();
+
+    const options = {
+      nocase: true,
+      windows: false
+    };
+
+    function normalizePosix(filePath) {
+      return filePath.replace(/\\/g, '/');
+    }
+
+    paths = paths
+      .map(p => {
+        // micromatch works with forward slashes: https://github.com/micromatch/micromatch#backslashes
+        const normalizedPath = normalizePosix(
+          path().resolve(this._context.config.cwd, p)
+        );
+        const match = (0, _micromatch().default)(
+          allFiles.map(normalizePosix),
+          normalizedPath,
+          options
+        );
+        return match[0];
+      })
+      .filter(Boolean)
+      .map(p => path().resolve(p));
+    return paths;
+  }
+
+  async getTestPaths(globalConfig, changedFiles, filter) {
+    const searchResult = await this._getTestPaths(globalConfig, changedFiles);
+    const filterPath = globalConfig.filter;
+
+    if (filter) {
+      const tests = searchResult.tests;
+      const filterResult = await filter(tests.map(test => test.path));
+
+      if (!Array.isArray(filterResult.filtered)) {
+        throw new Error(
+          `Filter ${filterPath} did not return a valid test list`
+        );
+      }
+
+      const filteredSet = new Set(
+        filterResult.filtered.map(result => result.test)
+      );
+      return {
+        ...searchResult,
+        tests: tests.filter(test => filteredSet.has(test.path))
+      };
+    }
+
+    return searchResult;
+  }
+
+  async findRelatedSourcesFromTestsInChangedFiles(changedFilesInfo) {
+    if (!hasSCM(changedFilesInfo)) {
+      return [];
+    }
+
+    const {changedFiles} = changedFilesInfo;
+    const dependencyResolver = await this._getOrBuildDependencyResolver();
+    const relatedSourcesSet = new Set();
+    changedFiles.forEach(filePath => {
+      if (this.isTestFilePath(filePath)) {
+        const sourcePaths = dependencyResolver.resolve(filePath, {
+          skipNodeResolution: this._context.config.skipNodeResolution
+        });
+        sourcePaths.forEach(sourcePath => relatedSourcesSet.add(sourcePath));
+      }
+    });
+    return Array.from(relatedSourcesSet);
+  }
+}
+
+exports.default = SearchSource;
diff --git a/node_modules/@jest/core/build/SnapshotInteractiveMode.d.ts b/node_modules/@jest/core/build/SnapshotInteractiveMode.d.ts
new file mode 100644
index 0000000..1198a50
--- /dev/null
+++ b/node_modules/@jest/core/build/SnapshotInteractiveMode.d.ts
@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/// <reference types="node" />
+import type { AggregatedResult, AssertionLocation } from '@jest/test-result';
+export default class SnapshotInteractiveMode {
+    private _pipe;
+    private _isActive;
+    private _updateTestRunnerConfig;
+    private _testAssertions;
+    private _countPaths;
+    private _skippedNum;
+    constructor(pipe: NodeJS.WritableStream);
+    isActive(): boolean;
+    getSkippedNum(): number;
+    private _clearTestSummary;
+    private _drawUIProgress;
+    private _drawUIDoneWithSkipped;
+    private _drawUIDone;
+    private _drawUIOverlay;
+    put(key: string): void;
+    abort(): void;
+    restart(): void;
+    updateWithResults(results: AggregatedResult): void;
+    private _run;
+    run(failedSnapshotTestAssertions: Array<AssertionLocation>, onConfigChange: (assertion: AssertionLocation | null, shouldUpdateSnapshot: boolean) => unknown): void;
+}
diff --git a/node_modules/@jest/core/build/SnapshotInteractiveMode.js b/node_modules/@jest/core/build/SnapshotInteractiveMode.js
new file mode 100644
index 0000000..fac34db
--- /dev/null
+++ b/node_modules/@jest/core/build/SnapshotInteractiveMode.js
@@ -0,0 +1,327 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+function _ansiEscapes() {
+  const data = _interopRequireDefault(require('ansi-escapes'));
+
+  _ansiEscapes = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+
+  _chalk = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestWatcher() {
+  const data = require('jest-watcher');
+
+  _jestWatcher = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+const {ARROW, CLEAR} = _jestUtil().specialChars;
+
+class SnapshotInteractiveMode {
+  constructor(pipe) {
+    _defineProperty(this, '_pipe', void 0);
+
+    _defineProperty(this, '_isActive', void 0);
+
+    _defineProperty(this, '_updateTestRunnerConfig', void 0);
+
+    _defineProperty(this, '_testAssertions', void 0);
+
+    _defineProperty(this, '_countPaths', void 0);
+
+    _defineProperty(this, '_skippedNum', void 0);
+
+    this._pipe = pipe;
+    this._isActive = false;
+    this._skippedNum = 0;
+  }
+
+  isActive() {
+    return this._isActive;
+  }
+
+  getSkippedNum() {
+    return this._skippedNum;
+  }
+
+  _clearTestSummary() {
+    this._pipe.write(_ansiEscapes().default.cursorUp(6));
+
+    this._pipe.write(_ansiEscapes().default.eraseDown);
+  }
+
+  _drawUIProgress() {
+    this._clearTestSummary();
+
+    const numPass = this._countPaths - this._testAssertions.length;
+    const numRemaining = this._countPaths - numPass - this._skippedNum;
+
+    let stats = _chalk().default.bold.dim(
+      (0, _jestUtil().pluralize)('snapshot', numRemaining) + ' remaining'
+    );
+
+    if (numPass) {
+      stats +=
+        ', ' +
+        _chalk().default.bold.green(
+          (0, _jestUtil().pluralize)('snapshot', numPass) + ' updated'
+        );
+    }
+
+    if (this._skippedNum) {
+      stats +=
+        ', ' +
+        _chalk().default.bold.yellow(
+          (0, _jestUtil().pluralize)('snapshot', this._skippedNum) + ' skipped'
+        );
+    }
+
+    const messages = [
+      '\n' + _chalk().default.bold('Interactive Snapshot Progress'),
+      ARROW + stats,
+      '\n' + _chalk().default.bold('Watch Usage'),
+      _chalk().default.dim(ARROW + 'Press ') +
+        'u' +
+        _chalk().default.dim(' to update failing snapshots for this test.'),
+      _chalk().default.dim(ARROW + 'Press ') +
+        's' +
+        _chalk().default.dim(' to skip the current test.'),
+      _chalk().default.dim(ARROW + 'Press ') +
+        'q' +
+        _chalk().default.dim(' to quit Interactive Snapshot Mode.'),
+      _chalk().default.dim(ARROW + 'Press ') +
+        'Enter' +
+        _chalk().default.dim(' to trigger a test run.')
+    ];
+
+    this._pipe.write(messages.filter(Boolean).join('\n') + '\n');
+  }
+
+  _drawUIDoneWithSkipped() {
+    this._pipe.write(CLEAR);
+
+    const numPass = this._countPaths - this._testAssertions.length;
+
+    let stats = _chalk().default.bold.dim(
+      (0, _jestUtil().pluralize)('snapshot', this._countPaths) + ' reviewed'
+    );
+
+    if (numPass) {
+      stats +=
+        ', ' +
+        _chalk().default.bold.green(
+          (0, _jestUtil().pluralize)('snapshot', numPass) + ' updated'
+        );
+    }
+
+    if (this._skippedNum) {
+      stats +=
+        ', ' +
+        _chalk().default.bold.yellow(
+          (0, _jestUtil().pluralize)('snapshot', this._skippedNum) + ' skipped'
+        );
+    }
+
+    const messages = [
+      '\n' + _chalk().default.bold('Interactive Snapshot Result'),
+      ARROW + stats,
+      '\n' + _chalk().default.bold('Watch Usage'),
+      _chalk().default.dim(ARROW + 'Press ') +
+        'r' +
+        _chalk().default.dim(' to restart Interactive Snapshot Mode.'),
+      _chalk().default.dim(ARROW + 'Press ') +
+        'q' +
+        _chalk().default.dim(' to quit Interactive Snapshot Mode.')
+    ];
+
+    this._pipe.write(messages.filter(Boolean).join('\n') + '\n');
+  }
+
+  _drawUIDone() {
+    this._pipe.write(CLEAR);
+
+    const numPass = this._countPaths - this._testAssertions.length;
+
+    let stats = _chalk().default.bold.dim(
+      (0, _jestUtil().pluralize)('snapshot', this._countPaths) + ' reviewed'
+    );
+
+    if (numPass) {
+      stats +=
+        ', ' +
+        _chalk().default.bold.green(
+          (0, _jestUtil().pluralize)('snapshot', numPass) + ' updated'
+        );
+    }
+
+    const messages = [
+      '\n' + _chalk().default.bold('Interactive Snapshot Result'),
+      ARROW + stats,
+      '\n' + _chalk().default.bold('Watch Usage'),
+      _chalk().default.dim(ARROW + 'Press ') +
+        'Enter' +
+        _chalk().default.dim(' to return to watch mode.')
+    ];
+
+    this._pipe.write(messages.filter(Boolean).join('\n') + '\n');
+  }
+
+  _drawUIOverlay() {
+    if (this._testAssertions.length === 0) {
+      return this._drawUIDone();
+    }
+
+    if (this._testAssertions.length - this._skippedNum === 0) {
+      return this._drawUIDoneWithSkipped();
+    }
+
+    return this._drawUIProgress();
+  }
+
+  put(key) {
+    switch (key) {
+      case 's':
+        if (this._skippedNum === this._testAssertions.length) break;
+        this._skippedNum += 1; // move skipped test to the end
+
+        this._testAssertions.push(this._testAssertions.shift());
+
+        if (this._testAssertions.length - this._skippedNum > 0) {
+          this._run(false);
+        } else {
+          this._drawUIDoneWithSkipped();
+        }
+
+        break;
+
+      case 'u':
+        this._run(true);
+
+        break;
+
+      case 'q':
+      case _jestWatcher().KEYS.ESCAPE:
+        this.abort();
+        break;
+
+      case 'r':
+        this.restart();
+        break;
+
+      case _jestWatcher().KEYS.ENTER:
+        if (this._testAssertions.length === 0) {
+          this.abort();
+        } else {
+          this._run(false);
+        }
+
+        break;
+
+      default:
+        break;
+    }
+  }
+
+  abort() {
+    this._isActive = false;
+    this._skippedNum = 0;
+
+    this._updateTestRunnerConfig(null, false);
+  }
+
+  restart() {
+    this._skippedNum = 0;
+    this._countPaths = this._testAssertions.length;
+
+    this._run(false);
+  }
+
+  updateWithResults(results) {
+    const hasSnapshotFailure = !!results.snapshot.failure;
+
+    if (hasSnapshotFailure) {
+      this._drawUIOverlay();
+
+      return;
+    }
+
+    this._testAssertions.shift();
+
+    if (this._testAssertions.length - this._skippedNum === 0) {
+      this._drawUIOverlay();
+
+      return;
+    } // Go to the next test
+
+    this._run(false);
+  }
+
+  _run(shouldUpdateSnapshot) {
+    const testAssertion = this._testAssertions[0];
+
+    this._updateTestRunnerConfig(testAssertion, shouldUpdateSnapshot);
+  }
+
+  run(failedSnapshotTestAssertions, onConfigChange) {
+    if (!failedSnapshotTestAssertions.length) {
+      return;
+    }
+
+    this._testAssertions = [...failedSnapshotTestAssertions];
+    this._countPaths = this._testAssertions.length;
+    this._updateTestRunnerConfig = onConfigChange;
+    this._isActive = true;
+
+    this._run(false);
+  }
+}
+
+exports.default = SnapshotInteractiveMode;
diff --git a/node_modules/@jest/core/build/TestNamePatternPrompt.d.ts b/node_modules/@jest/core/build/TestNamePatternPrompt.d.ts
new file mode 100644
index 0000000..c3a187c
--- /dev/null
+++ b/node_modules/@jest/core/build/TestNamePatternPrompt.d.ts
@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/// <reference types="node" />
+import type { TestResult } from '@jest/test-result';
+import { PatternPrompt, Prompt, ScrollOptions } from 'jest-watcher';
+export default class TestNamePatternPrompt extends PatternPrompt {
+    _cachedTestResults: Array<TestResult>;
+    constructor(pipe: NodeJS.WritableStream, prompt: Prompt);
+    _onChange(pattern: string, options: ScrollOptions): void;
+    _printPrompt(pattern: string): void;
+    _getMatchedTests(pattern: string): Array<string>;
+    updateCachedTestResults(testResults?: Array<TestResult>): void;
+}
diff --git a/node_modules/@jest/core/build/TestNamePatternPrompt.js b/node_modules/@jest/core/build/TestNamePatternPrompt.js
new file mode 100644
index 0000000..4d9bb2b
--- /dev/null
+++ b/node_modules/@jest/core/build/TestNamePatternPrompt.js
@@ -0,0 +1,86 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+function _jestWatcher() {
+  const data = require('jest-watcher');
+
+  _jestWatcher = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+// TODO: Make underscored props `private`
+class TestNamePatternPrompt extends _jestWatcher().PatternPrompt {
+  constructor(pipe, prompt) {
+    super(pipe, prompt);
+
+    _defineProperty(this, '_cachedTestResults', void 0);
+
+    this._entityName = 'tests';
+    this._cachedTestResults = [];
+  }
+
+  _onChange(pattern, options) {
+    super._onChange(pattern, options);
+
+    this._printPrompt(pattern);
+  }
+
+  _printPrompt(pattern) {
+    const pipe = this._pipe;
+    (0, _jestWatcher().printPatternCaret)(pattern, pipe);
+    (0, _jestWatcher().printRestoredPatternCaret)(
+      pattern,
+      this._currentUsageRows,
+      pipe
+    );
+  }
+
+  _getMatchedTests(pattern) {
+    let regex;
+
+    try {
+      regex = new RegExp(pattern, 'i');
+    } catch {
+      return [];
+    }
+
+    const matchedTests = [];
+
+    this._cachedTestResults.forEach(({testResults}) =>
+      testResults.forEach(({title}) => {
+        if (regex.test(title)) {
+          matchedTests.push(title);
+        }
+      })
+    );
+
+    return matchedTests;
+  }
+
+  updateCachedTestResults(testResults = []) {
+    this._cachedTestResults = testResults;
+  }
+}
+
+exports.default = TestNamePatternPrompt;
diff --git a/node_modules/@jest/core/build/TestPathPatternPrompt.d.ts b/node_modules/@jest/core/build/TestPathPatternPrompt.d.ts
new file mode 100644
index 0000000..589ee48
--- /dev/null
+++ b/node_modules/@jest/core/build/TestPathPatternPrompt.d.ts
@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/// <reference types="node" />
+import type { Test } from '@jest/test-result';
+import type { Context } from 'jest-runtime';
+import { PatternPrompt, Prompt, ScrollOptions } from 'jest-watcher';
+import type SearchSource from './SearchSource';
+declare type SearchSources = Array<{
+    context: Context;
+    searchSource: SearchSource;
+}>;
+export default class TestPathPatternPrompt extends PatternPrompt {
+    _searchSources?: SearchSources;
+    constructor(pipe: NodeJS.WritableStream, prompt: Prompt);
+    _onChange(pattern: string, options: ScrollOptions): void;
+    _printPrompt(pattern: string): void;
+    _getMatchedTests(pattern: string): Array<Test>;
+    updateSearchSources(searchSources: SearchSources): void;
+}
+export {};
diff --git a/node_modules/@jest/core/build/TestPathPatternPrompt.js b/node_modules/@jest/core/build/TestPathPatternPrompt.js
new file mode 100644
index 0000000..fe0a2bf
--- /dev/null
+++ b/node_modules/@jest/core/build/TestPathPatternPrompt.js
@@ -0,0 +1,81 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+function _jestWatcher() {
+  const data = require('jest-watcher');
+
+  _jestWatcher = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+// TODO: Make underscored props `private`
+class TestPathPatternPrompt extends _jestWatcher().PatternPrompt {
+  constructor(pipe, prompt) {
+    super(pipe, prompt);
+
+    _defineProperty(this, '_searchSources', void 0);
+
+    this._entityName = 'filenames';
+  }
+
+  _onChange(pattern, options) {
+    super._onChange(pattern, options);
+
+    this._printPrompt(pattern);
+  }
+
+  _printPrompt(pattern) {
+    const pipe = this._pipe;
+    (0, _jestWatcher().printPatternCaret)(pattern, pipe);
+    (0, _jestWatcher().printRestoredPatternCaret)(
+      pattern,
+      this._currentUsageRows,
+      pipe
+    );
+  }
+
+  _getMatchedTests(pattern) {
+    let regex;
+
+    try {
+      regex = new RegExp(pattern, 'i');
+    } catch {}
+
+    let tests = [];
+
+    if (regex && this._searchSources) {
+      this._searchSources.forEach(({searchSource}) => {
+        tests = tests.concat(searchSource.findMatchingTests(pattern).tests);
+      });
+    }
+
+    return tests;
+  }
+
+  updateSearchSources(searchSources) {
+    this._searchSources = searchSources;
+  }
+}
+
+exports.default = TestPathPatternPrompt;
diff --git a/node_modules/@jest/core/build/TestScheduler.d.ts b/node_modules/@jest/core/build/TestScheduler.d.ts
new file mode 100644
index 0000000..7cf0c18
--- /dev/null
+++ b/node_modules/@jest/core/build/TestScheduler.d.ts
@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { Reporter } from '@jest/reporters';
+import { AggregatedResult, Test } from '@jest/test-result';
+import type { Config } from '@jest/types';
+import type TestWatcher from './TestWatcher';
+export declare type TestSchedulerOptions = {
+    startRun: (globalConfig: Config.GlobalConfig) => void;
+};
+export declare type TestSchedulerContext = {
+    firstRun: boolean;
+    previousSuccess: boolean;
+    changedFiles?: Set<Config.Path>;
+    sourcesRelatedToTestsInChangedFiles?: Set<Config.Path>;
+};
+export declare function createTestScheduler(globalConfig: Config.GlobalConfig, options: TestSchedulerOptions, context: TestSchedulerContext): Promise<TestScheduler>;
+declare class TestScheduler {
+    private readonly _dispatcher;
+    private readonly _globalConfig;
+    private readonly _options;
+    private readonly _context;
+    constructor(globalConfig: Config.GlobalConfig, options: TestSchedulerOptions, context: TestSchedulerContext);
+    addReporter(reporter: Reporter): void;
+    removeReporter(ReporterClass: Function): void;
+    scheduleTests(tests: Array<Test>, watcher: TestWatcher): Promise<AggregatedResult>;
+    private _partitionTests;
+    private _shouldAddDefaultReporters;
+    _setupReporters(): Promise<void>;
+    private _setupDefaultReporters;
+    private _addCustomReporters;
+    /**
+     * Get properties of a reporter in an object
+     * to make dealing with them less painful.
+     */
+    private _getReporterProps;
+    private _bailIfNeeded;
+}
+export {};
diff --git a/node_modules/@jest/core/build/TestScheduler.js b/node_modules/@jest/core/build/TestScheduler.js
new file mode 100644
index 0000000..fb0d314
--- /dev/null
+++ b/node_modules/@jest/core/build/TestScheduler.js
@@ -0,0 +1,570 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.createTestScheduler = createTestScheduler;
+
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+
+  _chalk = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _exit() {
+  const data = _interopRequireDefault(require('exit'));
+
+  _exit = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _reporters() {
+  const data = require('@jest/reporters');
+
+  _reporters = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _testResult() {
+  const data = require('@jest/test-result');
+
+  _testResult = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _transform() {
+  const data = require('@jest/transform');
+
+  _transform = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestMessageUtil() {
+  const data = require('jest-message-util');
+
+  _jestMessageUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestSnapshot() {
+  const data = _interopRequireDefault(require('jest-snapshot'));
+
+  _jestSnapshot = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _ReporterDispatcher = _interopRequireDefault(
+  require('./ReporterDispatcher')
+);
+
+var _testSchedulerHelper = require('./testSchedulerHelper');
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+async function createTestScheduler(globalConfig, options, context) {
+  const scheduler = new TestScheduler(globalConfig, options, context);
+  await scheduler._setupReporters();
+  return scheduler;
+}
+
+class TestScheduler {
+  constructor(globalConfig, options, context) {
+    _defineProperty(this, '_dispatcher', void 0);
+
+    _defineProperty(this, '_globalConfig', void 0);
+
+    _defineProperty(this, '_options', void 0);
+
+    _defineProperty(this, '_context', void 0);
+
+    this._dispatcher = new _ReporterDispatcher.default();
+    this._globalConfig = globalConfig;
+    this._options = options;
+    this._context = context;
+  }
+
+  addReporter(reporter) {
+    this._dispatcher.register(reporter);
+  }
+
+  removeReporter(ReporterClass) {
+    this._dispatcher.unregister(ReporterClass);
+  }
+
+  async scheduleTests(tests, watcher) {
+    const onTestFileStart = this._dispatcher.onTestFileStart.bind(
+      this._dispatcher
+    );
+
+    const timings = [];
+    const contexts = new Set();
+    tests.forEach(test => {
+      contexts.add(test.context);
+
+      if (test.duration) {
+        timings.push(test.duration);
+      }
+    });
+    const aggregatedResults = createAggregatedResults(tests.length);
+    const estimatedTime = Math.ceil(
+      getEstimatedTime(timings, this._globalConfig.maxWorkers) / 1000
+    );
+    const runInBand = (0, _testSchedulerHelper.shouldRunInBand)(
+      tests,
+      timings,
+      this._globalConfig
+    );
+
+    const onResult = async (test, testResult) => {
+      if (watcher.isInterrupted()) {
+        return Promise.resolve();
+      }
+
+      if (testResult.testResults.length === 0) {
+        const message = 'Your test suite must contain at least one test.';
+        return onFailure(test, {
+          message,
+          stack: new Error(message).stack
+        });
+      } // Throws when the context is leaked after executing a test.
+
+      if (testResult.leaks) {
+        const message =
+          _chalk().default.red.bold('EXPERIMENTAL FEATURE!\n') +
+          'Your test suite is leaking memory. Please ensure all references are cleaned.\n' +
+          '\n' +
+          'There is a number of things that can leak memory:\n' +
+          '  - Async operations that have not finished (e.g. fs.readFile).\n' +
+          '  - Timers not properly mocked (e.g. setInterval, setTimeout).\n' +
+          '  - Keeping references to the global scope.';
+        return onFailure(test, {
+          message,
+          stack: new Error(message).stack
+        });
+      }
+
+      (0, _testResult().addResult)(aggregatedResults, testResult);
+      await this._dispatcher.onTestFileResult(
+        test,
+        testResult,
+        aggregatedResults
+      );
+      return this._bailIfNeeded(contexts, aggregatedResults, watcher);
+    };
+
+    const onFailure = async (test, error) => {
+      if (watcher.isInterrupted()) {
+        return;
+      }
+
+      const testResult = (0, _testResult().buildFailureTestResult)(
+        test.path,
+        error
+      );
+      testResult.failureMessage = (0, _jestMessageUtil().formatExecError)(
+        testResult.testExecError,
+        test.context.config,
+        this._globalConfig,
+        test.path
+      );
+      (0, _testResult().addResult)(aggregatedResults, testResult);
+      await this._dispatcher.onTestFileResult(
+        test,
+        testResult,
+        aggregatedResults
+      );
+    };
+
+    const updateSnapshotState = async () => {
+      const contextsWithSnapshotResolvers = await Promise.all(
+        Array.from(contexts).map(async context => [
+          context,
+          await _jestSnapshot().default.buildSnapshotResolver(context.config)
+        ])
+      );
+      contextsWithSnapshotResolvers.forEach(([context, snapshotResolver]) => {
+        const status = _jestSnapshot().default.cleanup(
+          context.hasteFS,
+          this._globalConfig.updateSnapshot,
+          snapshotResolver,
+          context.config.testPathIgnorePatterns
+        );
+
+        aggregatedResults.snapshot.filesRemoved += status.filesRemoved;
+        aggregatedResults.snapshot.filesRemovedList = (
+          aggregatedResults.snapshot.filesRemovedList || []
+        ).concat(status.filesRemovedList);
+      });
+      const updateAll = this._globalConfig.updateSnapshot === 'all';
+      aggregatedResults.snapshot.didUpdate = updateAll;
+      aggregatedResults.snapshot.failure = !!(
+        !updateAll &&
+        (aggregatedResults.snapshot.unchecked ||
+          aggregatedResults.snapshot.unmatched ||
+          aggregatedResults.snapshot.filesRemoved)
+      );
+    };
+
+    await this._dispatcher.onRunStart(aggregatedResults, {
+      estimatedTime,
+      showStatus: !runInBand
+    });
+    const testRunners = Object.create(null);
+    const contextsByTestRunner = new WeakMap();
+    await Promise.all(
+      Array.from(contexts).map(async context => {
+        const {config} = context;
+
+        if (!testRunners[config.runner]) {
+          var _this$_context, _this$_context2;
+
+          const transformer = await (0, _transform().createScriptTransformer)(
+            config
+          );
+          const Runner = await transformer.requireAndTranspileModule(
+            config.runner
+          );
+          const runner = new Runner(this._globalConfig, {
+            changedFiles:
+              (_this$_context = this._context) === null ||
+              _this$_context === void 0
+                ? void 0
+                : _this$_context.changedFiles,
+            sourcesRelatedToTestsInChangedFiles:
+              (_this$_context2 = this._context) === null ||
+              _this$_context2 === void 0
+                ? void 0
+                : _this$_context2.sourcesRelatedToTestsInChangedFiles
+          });
+          testRunners[config.runner] = runner;
+          contextsByTestRunner.set(runner, context);
+        }
+      })
+    );
+
+    const testsByRunner = this._partitionTests(testRunners, tests);
+
+    if (testsByRunner) {
+      try {
+        for (const runner of Object.keys(testRunners)) {
+          const testRunner = testRunners[runner];
+          const context = contextsByTestRunner.get(testRunner);
+          invariant(context);
+          const tests = testsByRunner[runner];
+          const testRunnerOptions = {
+            serial: runInBand || Boolean(testRunner.isSerial)
+          };
+          /**
+           * Test runners with event emitters are still not supported
+           * for third party test runners.
+           */
+
+          if (testRunner.__PRIVATE_UNSTABLE_API_supportsEventEmitters__) {
+            const unsubscribes = [
+              testRunner.on('test-file-start', ([test]) =>
+                onTestFileStart(test)
+              ),
+              testRunner.on('test-file-success', ([test, testResult]) =>
+                onResult(test, testResult)
+              ),
+              testRunner.on('test-file-failure', ([test, error]) =>
+                onFailure(test, error)
+              ),
+              testRunner.on(
+                'test-case-result',
+                ([testPath, testCaseResult]) => {
+                  const test = {
+                    context,
+                    path: testPath
+                  };
+
+                  this._dispatcher.onTestCaseResult(test, testCaseResult);
+                }
+              )
+            ];
+            await testRunner.runTests(
+              tests,
+              watcher,
+              undefined,
+              undefined,
+              undefined,
+              testRunnerOptions
+            );
+            unsubscribes.forEach(sub => sub());
+          } else {
+            await testRunner.runTests(
+              tests,
+              watcher,
+              onTestFileStart,
+              onResult,
+              onFailure,
+              testRunnerOptions
+            );
+          }
+        }
+      } catch (error) {
+        if (!watcher.isInterrupted()) {
+          throw error;
+        }
+      }
+    }
+
+    await updateSnapshotState();
+    aggregatedResults.wasInterrupted = watcher.isInterrupted();
+    await this._dispatcher.onRunComplete(contexts, aggregatedResults);
+    const anyTestFailures = !(
+      aggregatedResults.numFailedTests === 0 &&
+      aggregatedResults.numRuntimeErrorTestSuites === 0
+    );
+
+    const anyReporterErrors = this._dispatcher.hasErrors();
+
+    aggregatedResults.success = !(
+      anyTestFailures ||
+      aggregatedResults.snapshot.failure ||
+      anyReporterErrors
+    );
+    return aggregatedResults;
+  }
+
+  _partitionTests(testRunners, tests) {
+    if (Object.keys(testRunners).length > 1) {
+      return tests.reduce((testRuns, test) => {
+        const runner = test.context.config.runner;
+
+        if (!testRuns[runner]) {
+          testRuns[runner] = [];
+        }
+
+        testRuns[runner].push(test);
+        return testRuns;
+      }, Object.create(null));
+    } else if (tests.length > 0 && tests[0] != null) {
+      // If there is only one runner, don't partition the tests.
+      return Object.assign(Object.create(null), {
+        [tests[0].context.config.runner]: tests
+      });
+    } else {
+      return null;
+    }
+  }
+
+  _shouldAddDefaultReporters(reporters) {
+    return (
+      !reporters ||
+      !!reporters.find(
+        reporter => this._getReporterProps(reporter).path === 'default'
+      )
+    );
+  }
+
+  async _setupReporters() {
+    const {collectCoverage, notify, reporters} = this._globalConfig;
+
+    const isDefault = this._shouldAddDefaultReporters(reporters);
+
+    if (isDefault) {
+      this._setupDefaultReporters(collectCoverage);
+    }
+
+    if (!isDefault && collectCoverage) {
+      var _this$_context3, _this$_context4;
+
+      this.addReporter(
+        new (_reporters().CoverageReporter)(this._globalConfig, {
+          changedFiles:
+            (_this$_context3 = this._context) === null ||
+            _this$_context3 === void 0
+              ? void 0
+              : _this$_context3.changedFiles,
+          sourcesRelatedToTestsInChangedFiles:
+            (_this$_context4 = this._context) === null ||
+            _this$_context4 === void 0
+              ? void 0
+              : _this$_context4.sourcesRelatedToTestsInChangedFiles
+        })
+      );
+    }
+
+    if (notify) {
+      this.addReporter(
+        new (_reporters().NotifyReporter)(
+          this._globalConfig,
+          this._options.startRun,
+          this._context
+        )
+      );
+    }
+
+    if (reporters && Array.isArray(reporters)) {
+      await this._addCustomReporters(reporters);
+    }
+  }
+
+  _setupDefaultReporters(collectCoverage) {
+    this.addReporter(
+      this._globalConfig.verbose
+        ? new (_reporters().VerboseReporter)(this._globalConfig)
+        : new (_reporters().DefaultReporter)(this._globalConfig)
+    );
+
+    if (collectCoverage) {
+      var _this$_context5, _this$_context6;
+
+      this.addReporter(
+        new (_reporters().CoverageReporter)(this._globalConfig, {
+          changedFiles:
+            (_this$_context5 = this._context) === null ||
+            _this$_context5 === void 0
+              ? void 0
+              : _this$_context5.changedFiles,
+          sourcesRelatedToTestsInChangedFiles:
+            (_this$_context6 = this._context) === null ||
+            _this$_context6 === void 0
+              ? void 0
+              : _this$_context6.sourcesRelatedToTestsInChangedFiles
+        })
+      );
+    }
+
+    this.addReporter(new (_reporters().SummaryReporter)(this._globalConfig));
+  }
+
+  async _addCustomReporters(reporters) {
+    for (const reporter of reporters) {
+      const {options, path} = this._getReporterProps(reporter);
+
+      if (path === 'default') continue;
+
+      try {
+        const Reporter = await (0, _jestUtil().requireOrImportModule)(
+          path,
+          true
+        );
+        this.addReporter(new Reporter(this._globalConfig, options));
+      } catch (error) {
+        error.message =
+          'An error occurred while adding the reporter at path "' +
+          _chalk().default.bold(path) +
+          '".' +
+          error.message;
+        throw error;
+      }
+    }
+  }
+  /**
+   * Get properties of a reporter in an object
+   * to make dealing with them less painful.
+   */
+
+  _getReporterProps(reporter) {
+    if (typeof reporter === 'string') {
+      return {
+        options: this._options,
+        path: reporter
+      };
+    } else if (Array.isArray(reporter)) {
+      const [path, options] = reporter;
+      return {
+        options,
+        path
+      };
+    }
+
+    throw new Error('Reporter should be either a string or an array');
+  }
+
+  async _bailIfNeeded(contexts, aggregatedResults, watcher) {
+    if (
+      this._globalConfig.bail !== 0 &&
+      aggregatedResults.numFailedTests >= this._globalConfig.bail
+    ) {
+      if (watcher.isWatchMode()) {
+        await watcher.setState({
+          interrupted: true
+        });
+        return;
+      }
+
+      try {
+        await this._dispatcher.onRunComplete(contexts, aggregatedResults);
+      } finally {
+        const exitCode = this._globalConfig.testFailureExitCode;
+        (0, _exit().default)(exitCode);
+      }
+    }
+  }
+}
+
+function invariant(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+const createAggregatedResults = numTotalTestSuites => {
+  const result = (0, _testResult().makeEmptyAggregatedTestResult)();
+  result.numTotalTestSuites = numTotalTestSuites;
+  result.startTime = Date.now();
+  result.success = false;
+  return result;
+};
+
+const getEstimatedTime = (timings, workers) => {
+  if (timings.length === 0) {
+    return 0;
+  }
+
+  const max = Math.max(...timings);
+  return timings.length <= workers
+    ? max
+    : Math.max(timings.reduce((sum, time) => sum + time) / workers, max);
+};
diff --git a/node_modules/@jest/core/build/TestWatcher.d.ts b/node_modules/@jest/core/build/TestWatcher.d.ts
new file mode 100644
index 0000000..baceb5e
--- /dev/null
+++ b/node_modules/@jest/core/build/TestWatcher.d.ts
@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import emittery = require('emittery');
+declare type State = {
+    interrupted: boolean;
+};
+export default class TestWatcher extends emittery<{
+    change: State;
+}> {
+    state: State;
+    private _isWatchMode;
+    constructor({ isWatchMode }: {
+        isWatchMode: boolean;
+    });
+    setState(state: State): Promise<void>;
+    isInterrupted(): boolean;
+    isWatchMode(): boolean;
+}
+export {};
diff --git a/node_modules/@jest/core/build/TestWatcher.js b/node_modules/@jest/core/build/TestWatcher.js
new file mode 100644
index 0000000..491279b
--- /dev/null
+++ b/node_modules/@jest/core/build/TestWatcher.js
@@ -0,0 +1,64 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+function _emittery() {
+  const data = _interopRequireDefault(require('emittery'));
+
+  _emittery = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+class TestWatcher extends _emittery().default {
+  constructor({isWatchMode}) {
+    super();
+
+    _defineProperty(this, 'state', void 0);
+
+    _defineProperty(this, '_isWatchMode', void 0);
+
+    this.state = {
+      interrupted: false
+    };
+    this._isWatchMode = isWatchMode;
+  }
+
+  async setState(state) {
+    Object.assign(this.state, state);
+    await this.emit('change', this.state);
+  }
+
+  isInterrupted() {
+    return this.state.interrupted;
+  }
+
+  isWatchMode() {
+    return this._isWatchMode;
+  }
+}
+
+exports.default = TestWatcher;
diff --git a/node_modules/@jest/core/build/assets/jest_logo.png b/node_modules/@jest/core/build/assets/jest_logo.png
new file mode 100644
index 0000000..079356b
--- /dev/null
+++ b/node_modules/@jest/core/build/assets/jest_logo.png
diff --git a/node_modules/@jest/core/build/cli/index.d.ts b/node_modules/@jest/core/build/cli/index.d.ts
new file mode 100644
index 0000000..bfa970e
--- /dev/null
+++ b/node_modules/@jest/core/build/cli/index.d.ts
@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { AggregatedResult } from '@jest/test-result';
+import type { Config } from '@jest/types';
+export declare function runCLI(argv: Config.Argv, projects: Array<Config.Path>): Promise<{
+    results: AggregatedResult;
+    globalConfig: Config.GlobalConfig;
+}>;
diff --git a/node_modules/@jest/core/build/cli/index.js b/node_modules/@jest/core/build/cli/index.js
new file mode 100644
index 0000000..2844390
--- /dev/null
+++ b/node_modules/@jest/core/build/cli/index.js
@@ -0,0 +1,399 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.runCLI = runCLI;
+
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+
+  _chalk = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _exit() {
+  const data = _interopRequireDefault(require('exit'));
+
+  _exit = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _rimraf() {
+  const data = _interopRequireDefault(require('rimraf'));
+
+  _rimraf = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _console() {
+  const data = require('@jest/console');
+
+  _console = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestConfig() {
+  const data = require('jest-config');
+
+  _jestConfig = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestRuntime() {
+  const data = _interopRequireDefault(require('jest-runtime'));
+
+  _jestRuntime = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _TestWatcher = _interopRequireDefault(require('../TestWatcher'));
+
+var _collectHandles = require('../collectHandles');
+
+var _getChangedFilesPromise = _interopRequireDefault(
+  require('../getChangedFilesPromise')
+);
+
+var _getConfigsOfProjectsToRun = _interopRequireDefault(
+  require('../getConfigsOfProjectsToRun')
+);
+
+var _getProjectNamesMissingWarning = _interopRequireDefault(
+  require('../getProjectNamesMissingWarning')
+);
+
+var _getSelectProjectsMessage = _interopRequireDefault(
+  require('../getSelectProjectsMessage')
+);
+
+var _createContext = _interopRequireDefault(require('../lib/createContext'));
+
+var _handleDeprecationWarnings = _interopRequireDefault(
+  require('../lib/handleDeprecationWarnings')
+);
+
+var _logDebugMessages = _interopRequireDefault(
+  require('../lib/logDebugMessages')
+);
+
+var _pluralize = _interopRequireDefault(require('../pluralize'));
+
+var _runJest = _interopRequireDefault(require('../runJest'));
+
+var _watch = _interopRequireDefault(require('../watch'));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const {print: preRunMessagePrint} = _jestUtil().preRunMessage;
+
+async function runCLI(argv, projects) {
+  let results; // If we output a JSON object, we can't write anything to stdout, since
+  // it'll break the JSON structure and it won't be valid.
+
+  const outputStream =
+    argv.json || argv.useStderr ? process.stderr : process.stdout;
+  const {globalConfig, configs, hasDeprecationWarnings} = await (0,
+  _jestConfig().readConfigs)(argv, projects);
+
+  if (argv.debug) {
+    (0, _logDebugMessages.default)(globalConfig, configs, outputStream);
+  }
+
+  if (argv.showConfig) {
+    (0, _logDebugMessages.default)(globalConfig, configs, process.stdout);
+    (0, _exit().default)(0);
+  }
+
+  if (argv.clearCache) {
+    configs.forEach(config => {
+      _rimraf().default.sync(config.cacheDirectory);
+
+      process.stdout.write(`Cleared ${config.cacheDirectory}\n`);
+    });
+    (0, _exit().default)(0);
+  }
+
+  let configsOfProjectsToRun = configs;
+
+  if (argv.selectProjects) {
+    const namesMissingWarning = (0, _getProjectNamesMissingWarning.default)(
+      configs
+    );
+
+    if (namesMissingWarning) {
+      outputStream.write(namesMissingWarning);
+    }
+
+    configsOfProjectsToRun = (0, _getConfigsOfProjectsToRun.default)(
+      argv.selectProjects,
+      configs
+    );
+    outputStream.write(
+      (0, _getSelectProjectsMessage.default)(configsOfProjectsToRun)
+    );
+  }
+
+  await _run10000(
+    globalConfig,
+    configsOfProjectsToRun,
+    hasDeprecationWarnings,
+    outputStream,
+    r => {
+      results = r;
+    }
+  );
+
+  if (argv.watch || argv.watchAll) {
+    // If in watch mode, return the promise that will never resolve.
+    // If the watch mode is interrupted, watch should handle the process
+    // shutdown.
+    return new Promise(() => {});
+  }
+
+  if (!results) {
+    throw new Error(
+      'AggregatedResult must be present after test run is complete'
+    );
+  }
+
+  const {openHandles} = results;
+
+  if (openHandles && openHandles.length) {
+    const formatted = (0, _collectHandles.formatHandleErrors)(
+      openHandles,
+      configs[0]
+    );
+    const openHandlesString = (0, _pluralize.default)(
+      'open handle',
+      formatted.length,
+      's'
+    );
+    const message =
+      _chalk().default.red(
+        `\nJest has detected the following ${openHandlesString} potentially keeping Jest from exiting:\n\n`
+      ) + formatted.join('\n\n');
+    console.error(message);
+  }
+
+  return {
+    globalConfig,
+    results
+  };
+}
+
+const buildContextsAndHasteMaps = async (
+  configs,
+  globalConfig,
+  outputStream
+) => {
+  const hasteMapInstances = Array(configs.length);
+  const contexts = await Promise.all(
+    configs.map(async (config, index) => {
+      (0, _jestUtil().createDirectory)(config.cacheDirectory);
+
+      const hasteMapInstance = _jestRuntime().default.createHasteMap(config, {
+        console: new (_console().CustomConsole)(outputStream, outputStream),
+        maxWorkers: Math.max(
+          1,
+          Math.floor(globalConfig.maxWorkers / configs.length)
+        ),
+        resetCache: !config.cache,
+        watch: globalConfig.watch || globalConfig.watchAll,
+        watchman: globalConfig.watchman
+      });
+
+      hasteMapInstances[index] = hasteMapInstance;
+      return (0, _createContext.default)(
+        config,
+        await hasteMapInstance.build()
+      );
+    })
+  );
+  return {
+    contexts,
+    hasteMapInstances
+  };
+};
+
+const _run10000 = async (
+  globalConfig,
+  configs,
+  hasDeprecationWarnings,
+  outputStream,
+  onComplete
+) => {
+  // Queries to hg/git can take a while, so we need to start the process
+  // as soon as possible, so by the time we need the result it's already there.
+  const changedFilesPromise = (0, _getChangedFilesPromise.default)(
+    globalConfig,
+    configs
+  ); // Filter may need to do an HTTP call or something similar to setup.
+  // We will wait on an async response from this before using the filter.
+
+  let filter;
+
+  if (globalConfig.filter && !globalConfig.skipFilter) {
+    const rawFilter = require(globalConfig.filter);
+
+    let filterSetupPromise;
+
+    if (rawFilter.setup) {
+      // Wrap filter setup Promise to avoid "uncaught Promise" error.
+      // If an error is returned, we surface it in the return value.
+      filterSetupPromise = (async () => {
+        try {
+          await rawFilter.setup();
+        } catch (err) {
+          return err;
+        }
+
+        return undefined;
+      })();
+    }
+
+    filter = async testPaths => {
+      if (filterSetupPromise) {
+        // Expect an undefined return value unless there was an error.
+        const err = await filterSetupPromise;
+
+        if (err) {
+          throw err;
+        }
+      }
+
+      return rawFilter(testPaths);
+    };
+  }
+
+  const {contexts, hasteMapInstances} = await buildContextsAndHasteMaps(
+    configs,
+    globalConfig,
+    outputStream
+  );
+  globalConfig.watch || globalConfig.watchAll
+    ? await runWatch(
+        contexts,
+        configs,
+        hasDeprecationWarnings,
+        globalConfig,
+        outputStream,
+        hasteMapInstances,
+        filter
+      )
+    : await runWithoutWatch(
+        globalConfig,
+        contexts,
+        outputStream,
+        onComplete,
+        changedFilesPromise,
+        filter
+      );
+};
+
+const runWatch = async (
+  contexts,
+  _configs,
+  hasDeprecationWarnings,
+  globalConfig,
+  outputStream,
+  hasteMapInstances,
+  filter
+) => {
+  if (hasDeprecationWarnings) {
+    try {
+      await (0, _handleDeprecationWarnings.default)(
+        outputStream,
+        process.stdin
+      );
+      return (0, _watch.default)(
+        globalConfig,
+        contexts,
+        outputStream,
+        hasteMapInstances,
+        undefined,
+        undefined,
+        filter
+      );
+    } catch {
+      (0, _exit().default)(0);
+    }
+  }
+
+  return (0, _watch.default)(
+    globalConfig,
+    contexts,
+    outputStream,
+    hasteMapInstances,
+    undefined,
+    undefined,
+    filter
+  );
+};
+
+const runWithoutWatch = async (
+  globalConfig,
+  contexts,
+  outputStream,
+  onComplete,
+  changedFilesPromise,
+  filter
+) => {
+  const startRun = async () => {
+    if (!globalConfig.listTests) {
+      preRunMessagePrint(outputStream);
+    }
+
+    return (0, _runJest.default)({
+      changedFilesPromise,
+      contexts,
+      failedTestsCache: undefined,
+      filter,
+      globalConfig,
+      onComplete,
+      outputStream,
+      startRun,
+      testWatcher: new _TestWatcher.default({
+        isWatchMode: false
+      })
+    });
+  };
+
+  return startRun();
+};
diff --git a/node_modules/@jest/core/build/collectHandles.d.ts b/node_modules/@jest/core/build/collectHandles.d.ts
new file mode 100644
index 0000000..7e72c44
--- /dev/null
+++ b/node_modules/@jest/core/build/collectHandles.d.ts
@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+export declare type HandleCollectionResult = () => Promise<Array<Error>>;
+export default function collectHandles(): HandleCollectionResult;
+export declare function formatHandleErrors(errors: Array<Error>, config: Config.ProjectConfig): Array<string>;
diff --git a/node_modules/@jest/core/build/collectHandles.js b/node_modules/@jest/core/build/collectHandles.js
new file mode 100644
index 0000000..6b77f1c
--- /dev/null
+++ b/node_modules/@jest/core/build/collectHandles.js
@@ -0,0 +1,269 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = collectHandles;
+exports.formatHandleErrors = formatHandleErrors;
+
+function asyncHooks() {
+  const data = _interopRequireWildcard(require('async_hooks'));
+
+  asyncHooks = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _util() {
+  const data = require('util');
+
+  _util = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _stripAnsi() {
+  const data = _interopRequireDefault(require('strip-ansi'));
+
+  _stripAnsi = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestMessageUtil() {
+  const data = require('jest-message-util');
+
+  _jestMessageUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = 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) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/* eslint-disable local/ban-types-eventually */
+function stackIsFromUser(stack) {
+  // Either the test file, or something required by it
+  if (stack.includes('Runtime.requireModule')) {
+    return true;
+  } // jest-jasmine it or describe call
+
+  if (stack.includes('asyncJestTest') || stack.includes('asyncJestLifecycle')) {
+    return true;
+  } // An async function call from within circus
+
+  if (stack.includes('callAsyncCircusFn')) {
+    // jest-circus it or describe call
+    return (
+      stack.includes('_callCircusTest') || stack.includes('_callCircusHook')
+    );
+  }
+
+  return false;
+}
+
+const alwaysActive = () => true; // @ts-expect-error: doesn't exist in v10 typings
+
+const hasWeakRef = typeof WeakRef === 'function';
+const asyncSleep = (0, _util().promisify)(setTimeout); // Inspired by https://github.com/mafintosh/why-is-node-running/blob/master/index.js
+// Extracted as we want to format the result ourselves
+
+function collectHandles() {
+  const activeHandles = new Map();
+  const hook = asyncHooks().createHook({
+    destroy(asyncId) {
+      activeHandles.delete(asyncId);
+    },
+
+    init: function initHook(asyncId, type, triggerAsyncId, resource) {
+      // Skip resources that should not generally prevent the process from
+      // exiting, not last a meaningfully long time, or otherwise shouldn't be
+      // tracked.
+      if (
+        type === 'PROMISE' ||
+        type === 'TIMERWRAP' ||
+        type === 'ELDHISTOGRAM' ||
+        type === 'PerformanceObserver' ||
+        type === 'RANDOMBYTESREQUEST' ||
+        type === 'DNSCHANNEL' ||
+        type === 'ZLIB'
+      ) {
+        return;
+      }
+
+      const error = new (_jestUtil().ErrorWithStack)(type, initHook, 100);
+      let fromUser = stackIsFromUser(error.stack || ''); // If the async resource was not directly created by user code, but was
+      // triggered by another async resource from user code, track it and use
+      // the original triggering resource's stack.
+
+      if (!fromUser) {
+        const triggeringHandle = activeHandles.get(triggerAsyncId);
+
+        if (triggeringHandle) {
+          fromUser = true;
+          error.stack = triggeringHandle.error.stack;
+        }
+      }
+
+      if (fromUser) {
+        let isActive;
+
+        if (type === 'Timeout' || type === 'Immediate') {
+          // Timer that supports hasRef (Node v11+)
+          if ('hasRef' in resource) {
+            if (hasWeakRef) {
+              // @ts-expect-error: doesn't exist in v10 typings
+              const ref = new WeakRef(resource);
+
+              isActive = () => {
+                var _ref$deref$hasRef, _ref$deref;
+
+                return (_ref$deref$hasRef =
+                  (_ref$deref = ref.deref()) === null || _ref$deref === void 0
+                    ? void 0
+                    : _ref$deref.hasRef()) !== null &&
+                  _ref$deref$hasRef !== void 0
+                  ? _ref$deref$hasRef
+                  : false;
+              };
+            } else {
+              // @ts-expect-error: doesn't exist in v10 typings
+              isActive = resource.hasRef.bind(resource);
+            }
+          } else {
+            // Timer that doesn't support hasRef
+            isActive = alwaysActive;
+          }
+        } else {
+          // Any other async resource
+          isActive = alwaysActive;
+        }
+
+        activeHandles.set(asyncId, {
+          error,
+          isActive
+        });
+      }
+    }
+  });
+  hook.enable();
+  return async () => {
+    // Wait briefly for any async resources that have been queued for
+    // destruction to actually be destroyed.
+    // For example, Node.js TCP Servers are not destroyed until *after* their
+    // `close` callback runs. If someone finishes a test from the `close`
+    // callback, we will not yet have seen the resource be destroyed here.
+    await asyncSleep(100);
+    hook.disable(); // Get errors for every async resource still referenced at this moment
+
+    const result = Array.from(activeHandles.values())
+      .filter(({isActive}) => isActive())
+      .map(({error}) => error);
+    activeHandles.clear();
+    return result;
+  };
+}
+
+function formatHandleErrors(errors, config) {
+  const stacks = new Set();
+  return (
+    errors
+      .map(err =>
+        (0, _jestMessageUtil().formatExecError)(
+          err,
+          config,
+          {
+            noStackTrace: false
+          },
+          undefined,
+          true
+        )
+      ) // E.g. timeouts might give multiple traces to the same line of code
+      // This hairy filtering tries to remove entries with duplicate stack traces
+      .filter(handle => {
+        const ansiFree = (0, _stripAnsi().default)(handle);
+        const match = ansiFree.match(/\s+at(.*)/);
+
+        if (!match || match.length < 2) {
+          return true;
+        }
+
+        const stack = ansiFree.substr(ansiFree.indexOf(match[1])).trim();
+
+        if (stacks.has(stack)) {
+          return false;
+        }
+
+        stacks.add(stack);
+        return true;
+      })
+  );
+}
diff --git a/node_modules/@jest/core/build/getChangedFilesPromise.d.ts b/node_modules/@jest/core/build/getChangedFilesPromise.d.ts
new file mode 100644
index 0000000..4a42b64
--- /dev/null
+++ b/node_modules/@jest/core/build/getChangedFilesPromise.d.ts
@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+import { ChangedFilesPromise } from 'jest-changed-files';
+export default function getChangedFilesPromise(globalConfig: Config.GlobalConfig, configs: Array<Config.ProjectConfig>): ChangedFilesPromise | undefined;
diff --git a/node_modules/@jest/core/build/getChangedFilesPromise.js b/node_modules/@jest/core/build/getChangedFilesPromise.js
new file mode 100644
index 0000000..c7912af
--- /dev/null
+++ b/node_modules/@jest/core/build/getChangedFilesPromise.js
@@ -0,0 +1,77 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = getChangedFilesPromise;
+
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+
+  _chalk = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestChangedFiles() {
+  const data = require('jest-changed-files');
+
+  _jestChangedFiles = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestMessageUtil() {
+  const data = require('jest-message-util');
+
+  _jestMessageUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+function getChangedFilesPromise(globalConfig, configs) {
+  if (globalConfig.onlyChanged) {
+    const allRootsForAllProjects = configs.reduce((roots, config) => {
+      if (config.roots) {
+        roots.push(...config.roots);
+      }
+
+      return roots;
+    }, []);
+    return (0, _jestChangedFiles().getChangedFilesForRoots)(
+      allRootsForAllProjects,
+      {
+        changedSince: globalConfig.changedSince,
+        lastCommit: globalConfig.lastCommit,
+        withAncestor: globalConfig.changedFilesWithAncestor
+      }
+    ).catch(e => {
+      const message = (0, _jestMessageUtil().formatExecError)(e, configs[0], {
+        noStackTrace: true
+      })
+        .split('\n')
+        .filter(line => !line.includes('Command failed:'))
+        .join('\n');
+      console.error(_chalk().default.red(`\n\n${message}`));
+      process.exit(1);
+    });
+  }
+
+  return undefined;
+}
diff --git a/node_modules/@jest/core/build/getConfigsOfProjectsToRun.d.ts b/node_modules/@jest/core/build/getConfigsOfProjectsToRun.d.ts
new file mode 100644
index 0000000..0a780d4
--- /dev/null
+++ b/node_modules/@jest/core/build/getConfigsOfProjectsToRun.d.ts
@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+export default function getConfigsOfProjectsToRun(namesOfProjectsToRun: Array<string>, projectConfigs: Array<Config.ProjectConfig>): Array<Config.ProjectConfig>;
diff --git a/node_modules/@jest/core/build/getConfigsOfProjectsToRun.js b/node_modules/@jest/core/build/getConfigsOfProjectsToRun.js
new file mode 100644
index 0000000..9326e30
--- /dev/null
+++ b/node_modules/@jest/core/build/getConfigsOfProjectsToRun.js
@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = getConfigsOfProjectsToRun;
+
+var _getProjectDisplayName = _interopRequireDefault(
+  require('./getProjectDisplayName')
+);
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+function getConfigsOfProjectsToRun(namesOfProjectsToRun, projectConfigs) {
+  const setOfProjectsToRun = new Set(namesOfProjectsToRun);
+  return projectConfigs.filter(config => {
+    const name = (0, _getProjectDisplayName.default)(config);
+    return name && setOfProjectsToRun.has(name);
+  });
+}
diff --git a/node_modules/@jest/core/build/getNoTestFound.d.ts b/node_modules/@jest/core/build/getNoTestFound.d.ts
new file mode 100644
index 0000000..4e30581
--- /dev/null
+++ b/node_modules/@jest/core/build/getNoTestFound.d.ts
@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+import type { TestRunData } from './types';
+export default function getNoTestFound(testRunData: TestRunData, globalConfig: Config.GlobalConfig): string;
diff --git a/node_modules/@jest/core/build/getNoTestFound.js b/node_modules/@jest/core/build/getNoTestFound.js
new file mode 100644
index 0000000..bd33d58
--- /dev/null
+++ b/node_modules/@jest/core/build/getNoTestFound.js
@@ -0,0 +1,63 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = getNoTestFound;
+
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+
+  _chalk = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _pluralize = _interopRequireDefault(require('./pluralize'));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+function getNoTestFound(testRunData, globalConfig) {
+  const testFiles = testRunData.reduce(
+    (current, testRun) => current + (testRun.matches.total || 0),
+    0
+  );
+  let dataMessage;
+
+  if (globalConfig.runTestsByPath) {
+    dataMessage = `Files: ${globalConfig.nonFlagArgs
+      .map(p => `"${p}"`)
+      .join(', ')}`;
+  } else {
+    dataMessage = `Pattern: ${_chalk().default.yellow(
+      globalConfig.testPathPattern
+    )} - 0 matches`;
+  }
+
+  return (
+    _chalk().default.bold('No tests found, exiting with code 1') +
+    '\n' +
+    'Run with `--passWithNoTests` to exit with code 0' +
+    '\n' +
+    `In ${_chalk().default.bold(globalConfig.rootDir)}` +
+    '\n' +
+    `  ${(0, _pluralize.default)('file', testFiles, 's')} checked across ${(0,
+    _pluralize.default)(
+      'project',
+      testRunData.length,
+      's'
+    )}. Run with \`--verbose\` for more details.` +
+    '\n' +
+    dataMessage
+  );
+}
diff --git a/node_modules/@jest/core/build/getNoTestFoundFailed.d.ts b/node_modules/@jest/core/build/getNoTestFoundFailed.d.ts
new file mode 100644
index 0000000..16c5fab
--- /dev/null
+++ b/node_modules/@jest/core/build/getNoTestFoundFailed.d.ts
@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+export default function getNoTestFoundFailed(globalConfig: Config.GlobalConfig): string;
diff --git a/node_modules/@jest/core/build/getNoTestFoundFailed.js b/node_modules/@jest/core/build/getNoTestFoundFailed.js
new file mode 100644
index 0000000..a7d404c
--- /dev/null
+++ b/node_modules/@jest/core/build/getNoTestFoundFailed.js
@@ -0,0 +1,51 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = getNoTestFoundFailed;
+
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+
+  _chalk = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+function getNoTestFoundFailed(globalConfig) {
+  let msg = _chalk().default.bold('No failed test found.');
+
+  if (_jestUtil().isInteractive) {
+    msg += _chalk().default.dim(
+      '\n' +
+        (globalConfig.watch
+          ? 'Press `f` to quit "only failed tests" mode.'
+          : 'Run Jest without `--onlyFailures` or with `--all` to run all tests.')
+    );
+  }
+
+  return msg;
+}
diff --git a/node_modules/@jest/core/build/getNoTestFoundPassWithNoTests.d.ts b/node_modules/@jest/core/build/getNoTestFoundPassWithNoTests.d.ts
new file mode 100644
index 0000000..a594ba4
--- /dev/null
+++ b/node_modules/@jest/core/build/getNoTestFoundPassWithNoTests.d.ts
@@ -0,0 +1,7 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export default function getNoTestFoundPassWithNoTests(): string;
diff --git a/node_modules/@jest/core/build/getNoTestFoundPassWithNoTests.js b/node_modules/@jest/core/build/getNoTestFoundPassWithNoTests.js
new file mode 100644
index 0000000..eb279c3
--- /dev/null
+++ b/node_modules/@jest/core/build/getNoTestFoundPassWithNoTests.js
@@ -0,0 +1,30 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = getNoTestFoundPassWithNoTests;
+
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+
+  _chalk = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+function getNoTestFoundPassWithNoTests() {
+  return _chalk().default.bold('No tests found, exiting with code 0');
+}
diff --git a/node_modules/@jest/core/build/getNoTestFoundRelatedToChangedFiles.d.ts b/node_modules/@jest/core/build/getNoTestFoundRelatedToChangedFiles.d.ts
new file mode 100644
index 0000000..53cdefc
--- /dev/null
+++ b/node_modules/@jest/core/build/getNoTestFoundRelatedToChangedFiles.d.ts
@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+export default function getNoTestFoundRelatedToChangedFiles(globalConfig: Config.GlobalConfig): string;
diff --git a/node_modules/@jest/core/build/getNoTestFoundRelatedToChangedFiles.js b/node_modules/@jest/core/build/getNoTestFoundRelatedToChangedFiles.js
new file mode 100644
index 0000000..9571d18
--- /dev/null
+++ b/node_modules/@jest/core/build/getNoTestFoundRelatedToChangedFiles.js
@@ -0,0 +1,57 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = getNoTestFoundRelatedToChangedFiles;
+
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+
+  _chalk = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+function getNoTestFoundRelatedToChangedFiles(globalConfig) {
+  const ref = globalConfig.changedSince
+    ? `"${globalConfig.changedSince}"`
+    : 'last commit';
+
+  let msg = _chalk().default.bold(
+    `No tests found related to files changed since ${ref}.`
+  );
+
+  if (_jestUtil().isInteractive) {
+    msg += _chalk().default.dim(
+      '\n' +
+        (globalConfig.watch
+          ? 'Press `a` to run all tests, or run Jest with `--watchAll`.'
+          : 'Run Jest without `-o` or with `--all` to run all tests.')
+    );
+  }
+
+  return msg;
+}
diff --git a/node_modules/@jest/core/build/getNoTestFoundVerbose.d.ts b/node_modules/@jest/core/build/getNoTestFoundVerbose.d.ts
new file mode 100644
index 0000000..a84572a
--- /dev/null
+++ b/node_modules/@jest/core/build/getNoTestFoundVerbose.d.ts
@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+import type { TestRunData } from './types';
+export default function getNoTestFoundVerbose(testRunData: TestRunData, globalConfig: Config.GlobalConfig): string;
diff --git a/node_modules/@jest/core/build/getNoTestFoundVerbose.js b/node_modules/@jest/core/build/getNoTestFoundVerbose.js
new file mode 100644
index 0000000..8f1359c
--- /dev/null
+++ b/node_modules/@jest/core/build/getNoTestFoundVerbose.js
@@ -0,0 +1,95 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = getNoTestFoundVerbose;
+
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+
+  _chalk = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _pluralize = _interopRequireDefault(require('./pluralize'));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+function getNoTestFoundVerbose(testRunData, globalConfig) {
+  const individualResults = testRunData.map(testRun => {
+    const stats = testRun.matches.stats || {};
+    const config = testRun.context.config;
+    const statsMessage = Object.keys(stats)
+      .map(key => {
+        if (key === 'roots' && config.roots.length === 1) {
+          return null;
+        }
+
+        const value = config[key];
+
+        if (value) {
+          const valueAsString = Array.isArray(value)
+            ? value.join(', ')
+            : String(value);
+          const matches = (0, _pluralize.default)(
+            'match',
+            stats[key] || 0,
+            'es'
+          );
+          return `  ${key}: ${_chalk().default.yellow(
+            valueAsString
+          )} - ${matches}`;
+        }
+
+        return null;
+      })
+      .filter(line => line)
+      .join('\n');
+    return testRun.matches.total
+      ? `In ${_chalk().default.bold(config.rootDir)}\n` +
+          `  ${(0, _pluralize.default)(
+            'file',
+            testRun.matches.total || 0,
+            's'
+          )} checked.\n` +
+          statsMessage
+      : `No files found in ${config.rootDir}.\n` +
+          "Make sure Jest's configuration does not exclude this directory." +
+          '\nTo set up Jest, make sure a package.json file exists.\n' +
+          'Jest Documentation: ' +
+          'https://jestjs.io/docs/configuration';
+  });
+  let dataMessage;
+
+  if (globalConfig.runTestsByPath) {
+    dataMessage = `Files: ${globalConfig.nonFlagArgs
+      .map(p => `"${p}"`)
+      .join(', ')}`;
+  } else {
+    dataMessage = `Pattern: ${_chalk().default.yellow(
+      globalConfig.testPathPattern
+    )} - 0 matches`;
+  }
+
+  return (
+    _chalk().default.bold('No tests found, exiting with code 1') +
+    '\n' +
+    'Run with `--passWithNoTests` to exit with code 0' +
+    '\n' +
+    individualResults.join('\n') +
+    '\n' +
+    dataMessage
+  );
+}
diff --git a/node_modules/@jest/core/build/getNoTestsFoundMessage.d.ts b/node_modules/@jest/core/build/getNoTestsFoundMessage.d.ts
new file mode 100644
index 0000000..910467e
--- /dev/null
+++ b/node_modules/@jest/core/build/getNoTestsFoundMessage.d.ts
@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+import type { TestRunData } from './types';
+export default function getNoTestsFoundMessage(testRunData: TestRunData, globalConfig: Config.GlobalConfig): string;
diff --git a/node_modules/@jest/core/build/getNoTestsFoundMessage.js b/node_modules/@jest/core/build/getNoTestsFoundMessage.js
new file mode 100644
index 0000000..293d092
--- /dev/null
+++ b/node_modules/@jest/core/build/getNoTestsFoundMessage.js
@@ -0,0 +1,52 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = getNoTestsFoundMessage;
+
+var _getNoTestFound = _interopRequireDefault(require('./getNoTestFound'));
+
+var _getNoTestFoundFailed = _interopRequireDefault(
+  require('./getNoTestFoundFailed')
+);
+
+var _getNoTestFoundPassWithNoTests = _interopRequireDefault(
+  require('./getNoTestFoundPassWithNoTests')
+);
+
+var _getNoTestFoundRelatedToChangedFiles = _interopRequireDefault(
+  require('./getNoTestFoundRelatedToChangedFiles')
+);
+
+var _getNoTestFoundVerbose = _interopRequireDefault(
+  require('./getNoTestFoundVerbose')
+);
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+function getNoTestsFoundMessage(testRunData, globalConfig) {
+  if (globalConfig.onlyFailures) {
+    return (0, _getNoTestFoundFailed.default)(globalConfig);
+  }
+
+  if (globalConfig.onlyChanged) {
+    return (0, _getNoTestFoundRelatedToChangedFiles.default)(globalConfig);
+  }
+
+  if (globalConfig.passWithNoTests) {
+    return (0, _getNoTestFoundPassWithNoTests.default)();
+  }
+
+  return testRunData.length === 1 || globalConfig.verbose
+    ? (0, _getNoTestFoundVerbose.default)(testRunData, globalConfig)
+    : (0, _getNoTestFound.default)(testRunData, globalConfig);
+}
diff --git a/node_modules/@jest/core/build/getProjectDisplayName.d.ts b/node_modules/@jest/core/build/getProjectDisplayName.d.ts
new file mode 100644
index 0000000..192e9fe
--- /dev/null
+++ b/node_modules/@jest/core/build/getProjectDisplayName.d.ts
@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+export default function getProjectDisplayName(projectConfig: Config.ProjectConfig): string | undefined;
diff --git a/node_modules/@jest/core/build/getProjectDisplayName.js b/node_modules/@jest/core/build/getProjectDisplayName.js
new file mode 100644
index 0000000..70b7c9e
--- /dev/null
+++ b/node_modules/@jest/core/build/getProjectDisplayName.js
@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = getProjectDisplayName;
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+function getProjectDisplayName(projectConfig) {
+  var _projectConfig$displa;
+
+  return (
+    ((_projectConfig$displa = projectConfig.displayName) === null ||
+    _projectConfig$displa === void 0
+      ? void 0
+      : _projectConfig$displa.name) || undefined
+  );
+}
diff --git a/node_modules/@jest/core/build/getProjectNamesMissingWarning.d.ts b/node_modules/@jest/core/build/getProjectNamesMissingWarning.d.ts
new file mode 100644
index 0000000..b2e17cf
--- /dev/null
+++ b/node_modules/@jest/core/build/getProjectNamesMissingWarning.d.ts
@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+export default function getProjectNamesMissingWarning(projectConfigs: Array<Config.ProjectConfig>): string | undefined;
diff --git a/node_modules/@jest/core/build/getProjectNamesMissingWarning.js b/node_modules/@jest/core/build/getProjectNamesMissingWarning.js
new file mode 100644
index 0000000..32ac1e1
--- /dev/null
+++ b/node_modules/@jest/core/build/getProjectNamesMissingWarning.js
@@ -0,0 +1,49 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = getProjectNamesMissingWarning;
+
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+
+  _chalk = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _getProjectDisplayName = _interopRequireDefault(
+  require('./getProjectDisplayName')
+);
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+function getProjectNamesMissingWarning(projectConfigs) {
+  const numberOfProjectsWithoutAName = projectConfigs.filter(
+    config => !(0, _getProjectDisplayName.default)(config)
+  ).length;
+
+  if (numberOfProjectsWithoutAName === 0) {
+    return undefined;
+  }
+
+  return _chalk().default.yellow(
+    `You provided values for --selectProjects but ${
+      numberOfProjectsWithoutAName === 1
+        ? 'a project does not have a name'
+        : `${numberOfProjectsWithoutAName} projects do not have a name`
+    }.\n` +
+      'Set displayName in the config of all projects in order to disable this warning.\n'
+  );
+}
diff --git a/node_modules/@jest/core/build/getSelectProjectsMessage.d.ts b/node_modules/@jest/core/build/getSelectProjectsMessage.d.ts
new file mode 100644
index 0000000..21a4cd2
--- /dev/null
+++ b/node_modules/@jest/core/build/getSelectProjectsMessage.d.ts
@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+export default function getSelectProjectsMessage(projectConfigs: Array<Config.ProjectConfig>): string;
diff --git a/node_modules/@jest/core/build/getSelectProjectsMessage.js b/node_modules/@jest/core/build/getSelectProjectsMessage.js
new file mode 100644
index 0000000..5607f69
--- /dev/null
+++ b/node_modules/@jest/core/build/getSelectProjectsMessage.js
@@ -0,0 +1,65 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = getSelectProjectsMessage;
+
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+
+  _chalk = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _getProjectDisplayName = _interopRequireDefault(
+  require('./getProjectDisplayName')
+);
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+function getSelectProjectsMessage(projectConfigs) {
+  if (projectConfigs.length === 0) {
+    return getNoSelectionWarning();
+  }
+
+  return getProjectsRunningMessage(projectConfigs);
+}
+
+function getNoSelectionWarning() {
+  return _chalk().default.yellow(
+    'You provided values for --selectProjects but no projects were found matching the selection.\n'
+  );
+}
+
+function getProjectsRunningMessage(projectConfigs) {
+  if (projectConfigs.length === 1) {
+    const name = (0, _getProjectDisplayName.default)(projectConfigs[0]);
+    return `Running one project: ${_chalk().default.bold(name)}\n`;
+  }
+
+  const projectsList = projectConfigs
+    .map(getProjectNameListElement)
+    .sort()
+    .join('\n');
+  return `Running ${projectConfigs.length} projects:\n${projectsList}\n`;
+}
+
+function getProjectNameListElement(projectConfig) {
+  const name = (0, _getProjectDisplayName.default)(projectConfig);
+  const elementContent = name
+    ? _chalk().default.bold(name)
+    : '<unnamed project>';
+  return `- ${elementContent}`;
+}
diff --git a/node_modules/@jest/core/build/jest.d.ts b/node_modules/@jest/core/build/jest.d.ts
new file mode 100644
index 0000000..58b0335
--- /dev/null
+++ b/node_modules/@jest/core/build/jest.d.ts
@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export { default as SearchSource } from './SearchSource';
+export { createTestScheduler } from './TestScheduler';
+export { default as TestWatcher } from './TestWatcher';
+export { runCLI } from './cli';
+export { default as getVersion } from './version';
diff --git a/node_modules/@jest/core/build/jest.js b/node_modules/@jest/core/build/jest.js
new file mode 100644
index 0000000..d320303
--- /dev/null
+++ b/node_modules/@jest/core/build/jest.js
@@ -0,0 +1,49 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+Object.defineProperty(exports, 'SearchSource', {
+  enumerable: true,
+  get: function () {
+    return _SearchSource.default;
+  }
+});
+Object.defineProperty(exports, 'TestWatcher', {
+  enumerable: true,
+  get: function () {
+    return _TestWatcher.default;
+  }
+});
+Object.defineProperty(exports, 'createTestScheduler', {
+  enumerable: true,
+  get: function () {
+    return _TestScheduler.createTestScheduler;
+  }
+});
+Object.defineProperty(exports, 'getVersion', {
+  enumerable: true,
+  get: function () {
+    return _version.default;
+  }
+});
+Object.defineProperty(exports, 'runCLI', {
+  enumerable: true,
+  get: function () {
+    return _cli.runCLI;
+  }
+});
+
+var _SearchSource = _interopRequireDefault(require('./SearchSource'));
+
+var _TestScheduler = require('./TestScheduler');
+
+var _TestWatcher = _interopRequireDefault(require('./TestWatcher'));
+
+var _cli = require('./cli');
+
+var _version = _interopRequireDefault(require('./version'));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
diff --git a/node_modules/@jest/core/build/lib/activeFiltersMessage.d.ts b/node_modules/@jest/core/build/lib/activeFiltersMessage.d.ts
new file mode 100644
index 0000000..15f595a
--- /dev/null
+++ b/node_modules/@jest/core/build/lib/activeFiltersMessage.d.ts
@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+declare const activeFilters: (globalConfig: Config.GlobalConfig, delimiter?: string) => string;
+export default activeFilters;
diff --git a/node_modules/@jest/core/build/lib/activeFiltersMessage.js b/node_modules/@jest/core/build/lib/activeFiltersMessage.js
new file mode 100644
index 0000000..ff63332
--- /dev/null
+++ b/node_modules/@jest/core/build/lib/activeFiltersMessage.js
@@ -0,0 +1,54 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+
+  _chalk = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const activeFilters = (globalConfig, delimiter = '\n') => {
+  const {testNamePattern, testPathPattern} = globalConfig;
+
+  if (testNamePattern || testPathPattern) {
+    const filters = [
+      testPathPattern
+        ? _chalk().default.dim('filename ') +
+          _chalk().default.yellow('/' + testPathPattern + '/')
+        : null,
+      testNamePattern
+        ? _chalk().default.dim('test name ') +
+          _chalk().default.yellow('/' + testNamePattern + '/')
+        : null
+    ]
+      .filter(f => f)
+      .join(', ');
+    const messages = [
+      '\n' + _chalk().default.bold('Active Filters: ') + filters
+    ];
+    return messages.filter(message => !!message).join(delimiter);
+  }
+
+  return '';
+};
+
+var _default = activeFilters;
+exports.default = _default;
diff --git a/node_modules/@jest/core/build/lib/createContext.d.ts b/node_modules/@jest/core/build/lib/createContext.d.ts
new file mode 100644
index 0000000..c98a3ef
--- /dev/null
+++ b/node_modules/@jest/core/build/lib/createContext.d.ts
@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+import type { HasteMapObject } from 'jest-haste-map';
+import { Context } from 'jest-runtime';
+export default function createContext(config: Config.ProjectConfig, { hasteFS, moduleMap }: HasteMapObject): Context;
diff --git a/node_modules/@jest/core/build/lib/createContext.js b/node_modules/@jest/core/build/lib/createContext.js
new file mode 100644
index 0000000..b360e9c
--- /dev/null
+++ b/node_modules/@jest/core/build/lib/createContext.js
@@ -0,0 +1,35 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = createContext;
+
+function _jestRuntime() {
+  const data = _interopRequireDefault(require('jest-runtime'));
+
+  _jestRuntime = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+function createContext(config, {hasteFS, moduleMap}) {
+  return {
+    config,
+    hasteFS,
+    moduleMap,
+    resolver: _jestRuntime().default.createResolver(config, moduleMap)
+  };
+}
diff --git a/node_modules/@jest/core/build/lib/handleDeprecationWarnings.d.ts b/node_modules/@jest/core/build/lib/handleDeprecationWarnings.d.ts
new file mode 100644
index 0000000..8d2151e
--- /dev/null
+++ b/node_modules/@jest/core/build/lib/handleDeprecationWarnings.d.ts
@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/// <reference types="node" />
+export default function handleDeprecationWarnings(pipe: NodeJS.WriteStream, stdin?: NodeJS.ReadStream): Promise<void>;
diff --git a/node_modules/@jest/core/build/lib/handleDeprecationWarnings.js b/node_modules/@jest/core/build/lib/handleDeprecationWarnings.js
new file mode 100644
index 0000000..f0a15d6
--- /dev/null
+++ b/node_modules/@jest/core/build/lib/handleDeprecationWarnings.js
@@ -0,0 +1,72 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = handleDeprecationWarnings;
+
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+
+  _chalk = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestWatcher() {
+  const data = require('jest-watcher');
+
+  _jestWatcher = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+function handleDeprecationWarnings(pipe, stdin = process.stdin) {
+  return new Promise((resolve, reject) => {
+    if (typeof stdin.setRawMode === 'function') {
+      const messages = [
+        _chalk().default.red('There are deprecation warnings.\n'),
+        _chalk().default.dim(' \u203A Press ') +
+          'Enter' +
+          _chalk().default.dim(' to continue.'),
+        _chalk().default.dim(' \u203A Press ') +
+          'Esc' +
+          _chalk().default.dim(' to exit.')
+      ];
+      pipe.write(messages.join('\n'));
+      stdin.setRawMode(true);
+      stdin.resume();
+      stdin.setEncoding('utf8'); // this is a string since we set encoding above
+
+      stdin.on('data', key => {
+        if (key === _jestWatcher().KEYS.ENTER) {
+          resolve();
+        } else if (
+          [
+            _jestWatcher().KEYS.ESCAPE,
+            _jestWatcher().KEYS.CONTROL_C,
+            _jestWatcher().KEYS.CONTROL_D
+          ].indexOf(key) !== -1
+        ) {
+          reject();
+        }
+      });
+    } else {
+      resolve();
+    }
+  });
+}
diff --git a/node_modules/@jest/core/build/lib/isValidPath.d.ts b/node_modules/@jest/core/build/lib/isValidPath.d.ts
new file mode 100644
index 0000000..d81880a
--- /dev/null
+++ b/node_modules/@jest/core/build/lib/isValidPath.d.ts
@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+export default function isValidPath(globalConfig: Config.GlobalConfig, filePath: Config.Path): boolean;
diff --git a/node_modules/@jest/core/build/lib/isValidPath.js b/node_modules/@jest/core/build/lib/isValidPath.js
new file mode 100644
index 0000000..10971d3
--- /dev/null
+++ b/node_modules/@jest/core/build/lib/isValidPath.js
@@ -0,0 +1,29 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = isValidPath;
+
+function _jestSnapshot() {
+  const data = require('jest-snapshot');
+
+  _jestSnapshot = function () {
+    return data;
+  };
+
+  return data;
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+function isValidPath(globalConfig, filePath) {
+  return (
+    !filePath.includes(globalConfig.coverageDirectory) &&
+    !(0, _jestSnapshot().isSnapshotPath)(filePath)
+  );
+}
diff --git a/node_modules/@jest/core/build/lib/logDebugMessages.d.ts b/node_modules/@jest/core/build/lib/logDebugMessages.d.ts
new file mode 100644
index 0000000..b312cd9
--- /dev/null
+++ b/node_modules/@jest/core/build/lib/logDebugMessages.d.ts
@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/// <reference types="node" />
+import type { Config } from '@jest/types';
+export default function logDebugMessages(globalConfig: Config.GlobalConfig, configs: Array<Config.ProjectConfig> | Config.ProjectConfig, outputStream: NodeJS.WriteStream): void;
diff --git a/node_modules/@jest/core/build/lib/logDebugMessages.js b/node_modules/@jest/core/build/lib/logDebugMessages.js
new file mode 100644
index 0000000..9c1f2f5
--- /dev/null
+++ b/node_modules/@jest/core/build/lib/logDebugMessages.js
@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = logDebugMessages;
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const VERSION = require('../../package.json').version; // if the output here changes, update `getConfig` in e2e/runJest.ts
+
+function logDebugMessages(globalConfig, configs, outputStream) {
+  const output = {
+    configs,
+    globalConfig,
+    version: VERSION
+  };
+  outputStream.write(JSON.stringify(output, null, '  ') + '\n');
+}
diff --git a/node_modules/@jest/core/build/lib/updateGlobalConfig.d.ts b/node_modules/@jest/core/build/lib/updateGlobalConfig.d.ts
new file mode 100644
index 0000000..8282936
--- /dev/null
+++ b/node_modules/@jest/core/build/lib/updateGlobalConfig.d.ts
@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+import type { AllowedConfigOptions } from 'jest-watcher';
+declare type ExtraConfigOptions = Partial<Pick<Config.GlobalConfig, 'noSCM' | 'passWithNoTests'>>;
+export default function updateGlobalConfig(globalConfig: Config.GlobalConfig, options?: AllowedConfigOptions & ExtraConfigOptions): Config.GlobalConfig;
+export {};
diff --git a/node_modules/@jest/core/build/lib/updateGlobalConfig.js b/node_modules/@jest/core/build/lib/updateGlobalConfig.js
new file mode 100644
index 0000000..5c49586
--- /dev/null
+++ b/node_modules/@jest/core/build/lib/updateGlobalConfig.js
@@ -0,0 +1,121 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = updateGlobalConfig;
+
+function _jestRegexUtil() {
+  const data = require('jest-regex-util');
+
+  _jestRegexUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+function updateGlobalConfig(globalConfig, options = {}) {
+  const newConfig = {...globalConfig};
+
+  if (options.mode === 'watch') {
+    newConfig.watch = true;
+    newConfig.watchAll = false;
+  } else if (options.mode === 'watchAll') {
+    newConfig.watch = false;
+    newConfig.watchAll = true;
+  }
+
+  if (options.testNamePattern !== undefined) {
+    newConfig.testNamePattern = options.testNamePattern || '';
+  }
+
+  if (options.testPathPattern !== undefined) {
+    newConfig.testPathPattern =
+      (0, _jestRegexUtil().replacePathSepForRegex)(options.testPathPattern) ||
+      '';
+  }
+
+  newConfig.onlyChanged =
+    !newConfig.watchAll &&
+    !newConfig.testNamePattern &&
+    !newConfig.testPathPattern;
+
+  if (typeof options.bail === 'boolean') {
+    newConfig.bail = options.bail ? 1 : 0;
+  } else if (options.bail !== undefined) {
+    newConfig.bail = options.bail;
+  }
+
+  if (options.changedSince !== undefined) {
+    newConfig.changedSince = options.changedSince;
+  }
+
+  if (options.collectCoverage !== undefined) {
+    newConfig.collectCoverage = options.collectCoverage || false;
+  }
+
+  if (options.collectCoverageFrom !== undefined) {
+    newConfig.collectCoverageFrom = options.collectCoverageFrom;
+  }
+
+  if (options.collectCoverageOnlyFrom !== undefined) {
+    newConfig.collectCoverageOnlyFrom = options.collectCoverageOnlyFrom;
+  }
+
+  if (options.coverageDirectory !== undefined) {
+    newConfig.coverageDirectory = options.coverageDirectory;
+  }
+
+  if (options.coverageReporters !== undefined) {
+    newConfig.coverageReporters = options.coverageReporters;
+  }
+
+  if (options.findRelatedTests !== undefined) {
+    newConfig.findRelatedTests = options.findRelatedTests;
+  }
+
+  if (options.nonFlagArgs !== undefined) {
+    newConfig.nonFlagArgs = options.nonFlagArgs;
+  }
+
+  if (options.noSCM) {
+    newConfig.noSCM = true;
+  }
+
+  if (options.notify !== undefined) {
+    newConfig.notify = options.notify || false;
+  }
+
+  if (options.notifyMode !== undefined) {
+    newConfig.notifyMode = options.notifyMode;
+  }
+
+  if (options.onlyFailures !== undefined) {
+    newConfig.onlyFailures = options.onlyFailures || false;
+  }
+
+  if (options.passWithNoTests !== undefined) {
+    newConfig.passWithNoTests = true;
+  }
+
+  if (options.reporters !== undefined) {
+    newConfig.reporters = options.reporters;
+  }
+
+  if (options.updateSnapshot !== undefined) {
+    newConfig.updateSnapshot = options.updateSnapshot;
+  }
+
+  if (options.verbose !== undefined) {
+    newConfig.verbose = options.verbose || false;
+  }
+
+  return Object.freeze(newConfig);
+}
diff --git a/node_modules/@jest/core/build/lib/watchPluginsHelpers.d.ts b/node_modules/@jest/core/build/lib/watchPluginsHelpers.d.ts
new file mode 100644
index 0000000..99e8d7f
--- /dev/null
+++ b/node_modules/@jest/core/build/lib/watchPluginsHelpers.d.ts
@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+import type { UsageData, WatchPlugin } from 'jest-watcher';
+export declare const filterInteractivePlugins: (watchPlugins: Array<WatchPlugin>, globalConfig: Config.GlobalConfig) => Array<WatchPlugin>;
+export declare const getSortedUsageRows: (watchPlugins: Array<WatchPlugin>, globalConfig: Config.GlobalConfig) => Array<UsageData>;
diff --git a/node_modules/@jest/core/build/lib/watchPluginsHelpers.js b/node_modules/@jest/core/build/lib/watchPluginsHelpers.js
new file mode 100644
index 0000000..9f595ce
--- /dev/null
+++ b/node_modules/@jest/core/build/lib/watchPluginsHelpers.js
@@ -0,0 +1,62 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.getSortedUsageRows = exports.filterInteractivePlugins = void 0;
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const filterInteractivePlugins = (watchPlugins, globalConfig) => {
+  const usageInfos = watchPlugins.map(
+    p => p.getUsageInfo && p.getUsageInfo(globalConfig)
+  );
+  return watchPlugins.filter((_plugin, i) => {
+    const usageInfo = usageInfos[i];
+
+    if (usageInfo) {
+      const {key} = usageInfo;
+      return !usageInfos.slice(i + 1).some(u => !!u && key === u.key);
+    }
+
+    return false;
+  });
+};
+
+exports.filterInteractivePlugins = filterInteractivePlugins;
+
+function notEmpty(value) {
+  return value != null;
+}
+
+const getSortedUsageRows = (watchPlugins, globalConfig) =>
+  filterInteractivePlugins(watchPlugins, globalConfig)
+    .sort((a, b) => {
+      if (a.isInternal && b.isInternal) {
+        // internal plugins in the order we specify them
+        return 0;
+      }
+
+      if (a.isInternal !== b.isInternal) {
+        // external plugins afterwards
+        return a.isInternal ? -1 : 1;
+      }
+
+      const usageInfoA = a.getUsageInfo && a.getUsageInfo(globalConfig);
+      const usageInfoB = b.getUsageInfo && b.getUsageInfo(globalConfig);
+
+      if (usageInfoA && usageInfoB) {
+        // external plugins in alphabetical order
+        return usageInfoA.key.localeCompare(usageInfoB.key);
+      }
+
+      return 0;
+    })
+    .map(p => p.getUsageInfo && p.getUsageInfo(globalConfig))
+    .filter(notEmpty);
+
+exports.getSortedUsageRows = getSortedUsageRows;
diff --git a/node_modules/@jest/core/build/plugins/FailedTestsInteractive.d.ts b/node_modules/@jest/core/build/plugins/FailedTestsInteractive.d.ts
new file mode 100644
index 0000000..d696181
--- /dev/null
+++ b/node_modules/@jest/core/build/plugins/FailedTestsInteractive.d.ts
@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+import { BaseWatchPlugin, JestHookSubscriber, UpdateConfigCallback, UsageData } from 'jest-watcher';
+export default class FailedTestsInteractivePlugin extends BaseWatchPlugin {
+    private _failedTestAssertions?;
+    private readonly _manager;
+    apply(hooks: JestHookSubscriber): void;
+    getUsageInfo(): UsageData | null;
+    onKey(key: string): void;
+    run(_: Config.GlobalConfig, updateConfigAndRun: UpdateConfigCallback): Promise<void>;
+    private getFailedTestAssertions;
+}
diff --git a/node_modules/@jest/core/build/plugins/FailedTestsInteractive.js b/node_modules/@jest/core/build/plugins/FailedTestsInteractive.js
new file mode 100644
index 0000000..a830abe
--- /dev/null
+++ b/node_modules/@jest/core/build/plugins/FailedTestsInteractive.js
@@ -0,0 +1,135 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+function _jestWatcher() {
+  const data = require('jest-watcher');
+
+  _jestWatcher = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _FailedTestsInteractiveMode = _interopRequireDefault(
+  require('../FailedTestsInteractiveMode')
+);
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+class FailedTestsInteractivePlugin extends _jestWatcher().BaseWatchPlugin {
+  constructor(...args) {
+    super(...args);
+
+    _defineProperty(this, '_failedTestAssertions', void 0);
+
+    _defineProperty(
+      this,
+      '_manager',
+      new _FailedTestsInteractiveMode.default(this._stdout)
+    );
+  }
+
+  apply(hooks) {
+    hooks.onTestRunComplete(results => {
+      this._failedTestAssertions = this.getFailedTestAssertions(results);
+      if (this._manager.isActive()) this._manager.updateWithResults(results);
+    });
+  }
+
+  getUsageInfo() {
+    var _this$_failedTestAsse;
+
+    if (
+      (_this$_failedTestAsse = this._failedTestAssertions) !== null &&
+      _this$_failedTestAsse !== void 0 &&
+      _this$_failedTestAsse.length
+    ) {
+      return {
+        key: 'i',
+        prompt: 'run failing tests interactively'
+      };
+    }
+
+    return null;
+  }
+
+  onKey(key) {
+    if (this._manager.isActive()) {
+      this._manager.put(key);
+    }
+  }
+
+  run(_, updateConfigAndRun) {
+    return new Promise(resolve => {
+      if (
+        !this._failedTestAssertions ||
+        this._failedTestAssertions.length === 0
+      ) {
+        resolve();
+        return;
+      }
+
+      this._manager.run(this._failedTestAssertions, failure => {
+        updateConfigAndRun({
+          mode: 'watch',
+          testNamePattern: failure ? `^${failure.fullName}$` : '',
+          testPathPattern:
+            (failure === null || failure === void 0 ? void 0 : failure.path) ||
+            ''
+        });
+
+        if (!this._manager.isActive()) {
+          resolve();
+        }
+      });
+    });
+  }
+
+  getFailedTestAssertions(results) {
+    const failedTestPaths = [];
+
+    if (
+      // skip if no failed tests
+      results.numFailedTests === 0 || // skip if missing test results
+      !results.testResults || // skip if unmatched snapshots are present
+      results.snapshot.unmatched
+    ) {
+      return failedTestPaths;
+    }
+
+    results.testResults.forEach(testResult => {
+      testResult.testResults.forEach(result => {
+        if (result.status === 'failed') {
+          failedTestPaths.push({
+            fullName: result.fullName,
+            path: testResult.testFilePath
+          });
+        }
+      });
+    });
+    return failedTestPaths;
+  }
+}
+
+exports.default = FailedTestsInteractivePlugin;
diff --git a/node_modules/@jest/core/build/plugins/Quit.d.ts b/node_modules/@jest/core/build/plugins/Quit.d.ts
new file mode 100644
index 0000000..e865612
--- /dev/null
+++ b/node_modules/@jest/core/build/plugins/Quit.d.ts
@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/// <reference types="node" />
+import { BaseWatchPlugin, UsageData } from 'jest-watcher';
+declare class QuitPlugin extends BaseWatchPlugin {
+    isInternal: true;
+    constructor(options: {
+        stdin: NodeJS.ReadStream;
+        stdout: NodeJS.WriteStream;
+    });
+    run(): Promise<void>;
+    getUsageInfo(): UsageData;
+}
+export default QuitPlugin;
diff --git a/node_modules/@jest/core/build/plugins/Quit.js b/node_modules/@jest/core/build/plugins/Quit.js
new file mode 100644
index 0000000..e643a2b
--- /dev/null
+++ b/node_modules/@jest/core/build/plugins/Quit.js
@@ -0,0 +1,60 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+function _jestWatcher() {
+  const data = require('jest-watcher');
+
+  _jestWatcher = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+class QuitPlugin extends _jestWatcher().BaseWatchPlugin {
+  constructor(options) {
+    super(options);
+
+    _defineProperty(this, 'isInternal', void 0);
+
+    this.isInternal = true;
+  }
+
+  async run() {
+    if (typeof this._stdin.setRawMode === 'function') {
+      this._stdin.setRawMode(false);
+    }
+
+    this._stdout.write('\n');
+
+    process.exit(0);
+  }
+
+  getUsageInfo() {
+    return {
+      key: 'q',
+      prompt: 'quit watch mode'
+    };
+  }
+}
+
+var _default = QuitPlugin;
+exports.default = _default;
diff --git a/node_modules/@jest/core/build/plugins/TestNamePattern.d.ts b/node_modules/@jest/core/build/plugins/TestNamePattern.d.ts
new file mode 100644
index 0000000..dc0409a
--- /dev/null
+++ b/node_modules/@jest/core/build/plugins/TestNamePattern.d.ts
@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/// <reference types="node" />
+import type { Config } from '@jest/types';
+import { BaseWatchPlugin, Prompt, UpdateConfigCallback, UsageData } from 'jest-watcher';
+declare class TestNamePatternPlugin extends BaseWatchPlugin {
+    _prompt: Prompt;
+    isInternal: true;
+    constructor(options: {
+        stdin: NodeJS.ReadStream;
+        stdout: NodeJS.WriteStream;
+    });
+    getUsageInfo(): UsageData;
+    onKey(key: string): void;
+    run(globalConfig: Config.GlobalConfig, updateConfigAndRun: UpdateConfigCallback): Promise<void>;
+}
+export default TestNamePatternPlugin;
diff --git a/node_modules/@jest/core/build/plugins/TestNamePattern.js b/node_modules/@jest/core/build/plugins/TestNamePattern.js
new file mode 100644
index 0000000..ac60851
--- /dev/null
+++ b/node_modules/@jest/core/build/plugins/TestNamePattern.js
@@ -0,0 +1,91 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+function _jestWatcher() {
+  const data = require('jest-watcher');
+
+  _jestWatcher = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _TestNamePatternPrompt = _interopRequireDefault(
+  require('../TestNamePatternPrompt')
+);
+
+var _activeFiltersMessage = _interopRequireDefault(
+  require('../lib/activeFiltersMessage')
+);
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+class TestNamePatternPlugin extends _jestWatcher().BaseWatchPlugin {
+  constructor(options) {
+    super(options);
+
+    _defineProperty(this, '_prompt', void 0);
+
+    _defineProperty(this, 'isInternal', void 0);
+
+    this._prompt = new (_jestWatcher().Prompt)();
+    this.isInternal = true;
+  }
+
+  getUsageInfo() {
+    return {
+      key: 't',
+      prompt: 'filter by a test name regex pattern'
+    };
+  }
+
+  onKey(key) {
+    this._prompt.put(key);
+  }
+
+  run(globalConfig, updateConfigAndRun) {
+    return new Promise((res, rej) => {
+      const testNamePatternPrompt = new _TestNamePatternPrompt.default(
+        this._stdout,
+        this._prompt
+      );
+      testNamePatternPrompt.run(
+        value => {
+          updateConfigAndRun({
+            mode: 'watch',
+            testNamePattern: value
+          });
+          res();
+        },
+        rej,
+        {
+          header: (0, _activeFiltersMessage.default)(globalConfig)
+        }
+      );
+    });
+  }
+}
+
+var _default = TestNamePatternPlugin;
+exports.default = _default;
diff --git a/node_modules/@jest/core/build/plugins/TestPathPattern.d.ts b/node_modules/@jest/core/build/plugins/TestPathPattern.d.ts
new file mode 100644
index 0000000..9eefab9
--- /dev/null
+++ b/node_modules/@jest/core/build/plugins/TestPathPattern.d.ts
@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/// <reference types="node" />
+import type { Config } from '@jest/types';
+import { BaseWatchPlugin, UpdateConfigCallback, UsageData } from 'jest-watcher';
+declare class TestPathPatternPlugin extends BaseWatchPlugin {
+    private _prompt;
+    isInternal: true;
+    constructor(options: {
+        stdin: NodeJS.ReadStream;
+        stdout: NodeJS.WriteStream;
+    });
+    getUsageInfo(): UsageData;
+    onKey(key: string): void;
+    run(globalConfig: Config.GlobalConfig, updateConfigAndRun: UpdateConfigCallback): Promise<void>;
+}
+export default TestPathPatternPlugin;
diff --git a/node_modules/@jest/core/build/plugins/TestPathPattern.js b/node_modules/@jest/core/build/plugins/TestPathPattern.js
new file mode 100644
index 0000000..5c5c4b7
--- /dev/null
+++ b/node_modules/@jest/core/build/plugins/TestPathPattern.js
@@ -0,0 +1,91 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+function _jestWatcher() {
+  const data = require('jest-watcher');
+
+  _jestWatcher = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _TestPathPatternPrompt = _interopRequireDefault(
+  require('../TestPathPatternPrompt')
+);
+
+var _activeFiltersMessage = _interopRequireDefault(
+  require('../lib/activeFiltersMessage')
+);
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+class TestPathPatternPlugin extends _jestWatcher().BaseWatchPlugin {
+  constructor(options) {
+    super(options);
+
+    _defineProperty(this, '_prompt', void 0);
+
+    _defineProperty(this, 'isInternal', void 0);
+
+    this._prompt = new (_jestWatcher().Prompt)();
+    this.isInternal = true;
+  }
+
+  getUsageInfo() {
+    return {
+      key: 'p',
+      prompt: 'filter by a filename regex pattern'
+    };
+  }
+
+  onKey(key) {
+    this._prompt.put(key);
+  }
+
+  run(globalConfig, updateConfigAndRun) {
+    return new Promise((res, rej) => {
+      const testPathPatternPrompt = new _TestPathPatternPrompt.default(
+        this._stdout,
+        this._prompt
+      );
+      testPathPatternPrompt.run(
+        value => {
+          updateConfigAndRun({
+            mode: 'watch',
+            testPathPattern: value
+          });
+          res();
+        },
+        rej,
+        {
+          header: (0, _activeFiltersMessage.default)(globalConfig)
+        }
+      );
+    });
+  }
+}
+
+var _default = TestPathPatternPlugin;
+exports.default = _default;
diff --git a/node_modules/@jest/core/build/plugins/UpdateSnapshots.d.ts b/node_modules/@jest/core/build/plugins/UpdateSnapshots.d.ts
new file mode 100644
index 0000000..3eff4c2
--- /dev/null
+++ b/node_modules/@jest/core/build/plugins/UpdateSnapshots.d.ts
@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/// <reference types="node" />
+import type { Config } from '@jest/types';
+import { BaseWatchPlugin, JestHookSubscriber, UpdateConfigCallback, UsageData } from 'jest-watcher';
+declare class UpdateSnapshotsPlugin extends BaseWatchPlugin {
+    private _hasSnapshotFailure;
+    isInternal: true;
+    constructor(options: {
+        stdin: NodeJS.ReadStream;
+        stdout: NodeJS.WriteStream;
+    });
+    run(_globalConfig: Config.GlobalConfig, updateConfigAndRun: UpdateConfigCallback): Promise<boolean>;
+    apply(hooks: JestHookSubscriber): void;
+    getUsageInfo(): UsageData | null;
+}
+export default UpdateSnapshotsPlugin;
diff --git a/node_modules/@jest/core/build/plugins/UpdateSnapshots.js b/node_modules/@jest/core/build/plugins/UpdateSnapshots.js
new file mode 100644
index 0000000..c2a9de7
--- /dev/null
+++ b/node_modules/@jest/core/build/plugins/UpdateSnapshots.js
@@ -0,0 +1,70 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+function _jestWatcher() {
+  const data = require('jest-watcher');
+
+  _jestWatcher = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+class UpdateSnapshotsPlugin extends _jestWatcher().BaseWatchPlugin {
+  constructor(options) {
+    super(options);
+
+    _defineProperty(this, '_hasSnapshotFailure', void 0);
+
+    _defineProperty(this, 'isInternal', void 0);
+
+    this.isInternal = true;
+    this._hasSnapshotFailure = false;
+  }
+
+  run(_globalConfig, updateConfigAndRun) {
+    updateConfigAndRun({
+      updateSnapshot: 'all'
+    });
+    return Promise.resolve(false);
+  }
+
+  apply(hooks) {
+    hooks.onTestRunComplete(results => {
+      this._hasSnapshotFailure = results.snapshot.failure;
+    });
+  }
+
+  getUsageInfo() {
+    if (this._hasSnapshotFailure) {
+      return {
+        key: 'u',
+        prompt: 'update failing snapshots'
+      };
+    }
+
+    return null;
+  }
+}
+
+var _default = UpdateSnapshotsPlugin;
+exports.default = _default;
diff --git a/node_modules/@jest/core/build/plugins/UpdateSnapshotsInteractive.d.ts b/node_modules/@jest/core/build/plugins/UpdateSnapshotsInteractive.d.ts
new file mode 100644
index 0000000..c6a60e6
--- /dev/null
+++ b/node_modules/@jest/core/build/plugins/UpdateSnapshotsInteractive.d.ts
@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { AggregatedResult, AssertionLocation } from '@jest/test-result';
+import type { Config } from '@jest/types';
+import { BaseWatchPlugin, JestHookSubscriber, UsageData } from 'jest-watcher';
+declare class UpdateSnapshotInteractivePlugin extends BaseWatchPlugin {
+    private _snapshotInteractiveMode;
+    private _failedSnapshotTestAssertions;
+    isInternal: true;
+    getFailedSnapshotTestAssertions(testResults: AggregatedResult): Array<AssertionLocation>;
+    apply(hooks: JestHookSubscriber): void;
+    onKey(key: string): void;
+    run(_globalConfig: Config.GlobalConfig, updateConfigAndRun: Function): Promise<void>;
+    getUsageInfo(): UsageData | null;
+}
+export default UpdateSnapshotInteractivePlugin;
diff --git a/node_modules/@jest/core/build/plugins/UpdateSnapshotsInteractive.js b/node_modules/@jest/core/build/plugins/UpdateSnapshotsInteractive.js
new file mode 100644
index 0000000..5346bc3
--- /dev/null
+++ b/node_modules/@jest/core/build/plugins/UpdateSnapshotsInteractive.js
@@ -0,0 +1,138 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+function _jestWatcher() {
+  const data = require('jest-watcher');
+
+  _jestWatcher = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _SnapshotInteractiveMode = _interopRequireDefault(
+  require('../SnapshotInteractiveMode')
+);
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+class UpdateSnapshotInteractivePlugin extends _jestWatcher().BaseWatchPlugin {
+  constructor(...args) {
+    super(...args);
+
+    _defineProperty(
+      this,
+      '_snapshotInteractiveMode',
+      new _SnapshotInteractiveMode.default(this._stdout)
+    );
+
+    _defineProperty(this, '_failedSnapshotTestAssertions', []);
+
+    _defineProperty(this, 'isInternal', true);
+  }
+
+  getFailedSnapshotTestAssertions(testResults) {
+    const failedTestPaths = [];
+
+    if (testResults.numFailedTests === 0 || !testResults.testResults) {
+      return failedTestPaths;
+    }
+
+    testResults.testResults.forEach(testResult => {
+      if (testResult.snapshot && testResult.snapshot.unmatched) {
+        testResult.testResults.forEach(result => {
+          if (result.status === 'failed') {
+            failedTestPaths.push({
+              fullName: result.fullName,
+              path: testResult.testFilePath
+            });
+          }
+        });
+      }
+    });
+    return failedTestPaths;
+  }
+
+  apply(hooks) {
+    hooks.onTestRunComplete(results => {
+      this._failedSnapshotTestAssertions =
+        this.getFailedSnapshotTestAssertions(results);
+
+      if (this._snapshotInteractiveMode.isActive()) {
+        this._snapshotInteractiveMode.updateWithResults(results);
+      }
+    });
+  }
+
+  onKey(key) {
+    if (this._snapshotInteractiveMode.isActive()) {
+      this._snapshotInteractiveMode.put(key);
+    }
+  }
+
+  run(_globalConfig, updateConfigAndRun) {
+    if (this._failedSnapshotTestAssertions.length) {
+      return new Promise(res => {
+        this._snapshotInteractiveMode.run(
+          this._failedSnapshotTestAssertions,
+          (assertion, shouldUpdateSnapshot) => {
+            updateConfigAndRun({
+              mode: 'watch',
+              testNamePattern: assertion ? `^${assertion.fullName}$` : '',
+              testPathPattern: assertion ? assertion.path : '',
+              updateSnapshot: shouldUpdateSnapshot ? 'all' : 'none'
+            });
+
+            if (!this._snapshotInteractiveMode.isActive()) {
+              res();
+            }
+          }
+        );
+      });
+    } else {
+      return Promise.resolve();
+    }
+  }
+
+  getUsageInfo() {
+    var _this$_failedSnapshot;
+
+    if (
+      ((_this$_failedSnapshot = this._failedSnapshotTestAssertions) === null ||
+      _this$_failedSnapshot === void 0
+        ? void 0
+        : _this$_failedSnapshot.length) > 0
+    ) {
+      return {
+        key: 'i',
+        prompt: 'update failing snapshots interactively'
+      };
+    }
+
+    return null;
+  }
+}
+
+var _default = UpdateSnapshotInteractivePlugin;
+exports.default = _default;
diff --git a/node_modules/@jest/core/build/pluralize.d.ts b/node_modules/@jest/core/build/pluralize.d.ts
new file mode 100644
index 0000000..a4e01ce
--- /dev/null
+++ b/node_modules/@jest/core/build/pluralize.d.ts
@@ -0,0 +1,7 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export default function pluralize(word: string, count: number, ending: string): string;
diff --git a/node_modules/@jest/core/build/pluralize.js b/node_modules/@jest/core/build/pluralize.js
new file mode 100644
index 0000000..08695e5
--- /dev/null
+++ b/node_modules/@jest/core/build/pluralize.js
@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = pluralize;
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+function pluralize(word, count, ending) {
+  return `${count} ${word}${count === 1 ? '' : ending}`;
+}
diff --git a/node_modules/@jest/core/build/runGlobalHook.d.ts b/node_modules/@jest/core/build/runGlobalHook.d.ts
new file mode 100644
index 0000000..726baf0
--- /dev/null
+++ b/node_modules/@jest/core/build/runGlobalHook.d.ts
@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Test } from '@jest/test-result';
+import type { Config } from '@jest/types';
+export default function runGlobalHook({ allTests, globalConfig, moduleName, }: {
+    allTests: Array<Test>;
+    globalConfig: Config.GlobalConfig;
+    moduleName: 'globalSetup' | 'globalTeardown';
+}): Promise<void>;
diff --git a/node_modules/@jest/core/build/runGlobalHook.js b/node_modules/@jest/core/build/runGlobalHook.js
new file mode 100644
index 0000000..c4ebdbd
--- /dev/null
+++ b/node_modules/@jest/core/build/runGlobalHook.js
@@ -0,0 +1,143 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = runGlobalHook;
+
+function util() {
+  const data = _interopRequireWildcard(require('util'));
+
+  util = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _transform() {
+  const data = require('@jest/transform');
+
+  _transform = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _prettyFormat() {
+  const data = _interopRequireDefault(require('pretty-format'));
+
+  _prettyFormat = 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) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+async function runGlobalHook({allTests, globalConfig, moduleName}) {
+  const globalModulePaths = new Set(
+    allTests.map(test => test.context.config[moduleName])
+  );
+
+  if (globalConfig[moduleName]) {
+    globalModulePaths.add(globalConfig[moduleName]);
+  }
+
+  if (globalModulePaths.size > 0) {
+    for (const modulePath of globalModulePaths) {
+      if (!modulePath) {
+        continue;
+      }
+
+      const correctConfig = allTests.find(
+        t => t.context.config[moduleName] === modulePath
+      );
+      const projectConfig = correctConfig
+        ? correctConfig.context.config // Fallback to first config
+        : allTests[0].context.config;
+      const transformer = await (0, _transform().createScriptTransformer)(
+        projectConfig
+      );
+
+      try {
+        await transformer.requireAndTranspileModule(
+          modulePath,
+          async globalModule => {
+            if (typeof globalModule !== 'function') {
+              throw new TypeError(
+                `${moduleName} file must export a function at ${modulePath}`
+              );
+            }
+
+            await globalModule(globalConfig);
+          }
+        );
+      } catch (error) {
+        if (util().types.isNativeError(error)) {
+          error.message = `Jest: Got error running ${moduleName} - ${modulePath}, reason: ${error.message}`;
+          throw error;
+        }
+
+        throw new Error(
+          `Jest: Got error running ${moduleName} - ${modulePath}, reason: ${(0,
+          _prettyFormat().default)(error, {
+            maxDepth: 3
+          })}`
+        );
+      }
+    }
+  }
+}
diff --git a/node_modules/@jest/core/build/runJest.d.ts b/node_modules/@jest/core/build/runJest.d.ts
new file mode 100644
index 0000000..9a8240b
--- /dev/null
+++ b/node_modules/@jest/core/build/runJest.d.ts
@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/// <reference types="node" />
+import { AggregatedResult } from '@jest/test-result';
+import type { Config } from '@jest/types';
+import type { ChangedFilesPromise } from 'jest-changed-files';
+import type { Context } from 'jest-runtime';
+import { JestHookEmitter } from 'jest-watcher';
+import type FailedTestsCache from './FailedTestsCache';
+import type TestWatcher from './TestWatcher';
+import type { Filter } from './types';
+export default function runJest({ contexts, globalConfig, outputStream, testWatcher, jestHooks, startRun, changedFilesPromise, onComplete, failedTestsCache, filter, }: {
+    globalConfig: Config.GlobalConfig;
+    contexts: Array<Context>;
+    outputStream: NodeJS.WriteStream;
+    testWatcher: TestWatcher;
+    jestHooks?: JestHookEmitter;
+    startRun: (globalConfig: Config.GlobalConfig) => void;
+    changedFilesPromise?: ChangedFilesPromise;
+    onComplete: (testResults: AggregatedResult) => void;
+    failedTestsCache?: FailedTestsCache;
+    filter?: Filter;
+}): Promise<void>;
diff --git a/node_modules/@jest/core/build/runJest.js b/node_modules/@jest/core/build/runJest.js
new file mode 100644
index 0000000..24b40ac
--- /dev/null
+++ b/node_modules/@jest/core/build/runJest.js
@@ -0,0 +1,423 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = runJest;
+
+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 _exit() {
+  const data = _interopRequireDefault(require('exit'));
+
+  _exit = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function fs() {
+  const data = _interopRequireWildcard(require('graceful-fs'));
+
+  fs = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _console() {
+  const data = require('@jest/console');
+
+  _console = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _testResult() {
+  const data = require('@jest/test-result');
+
+  _testResult = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestResolve() {
+  const data = _interopRequireDefault(require('jest-resolve'));
+
+  _jestResolve = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestWatcher() {
+  const data = require('jest-watcher');
+
+  _jestWatcher = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _SearchSource = _interopRequireDefault(require('./SearchSource'));
+
+var _TestScheduler = require('./TestScheduler');
+
+var _collectHandles = _interopRequireDefault(require('./collectHandles'));
+
+var _getNoTestsFoundMessage = _interopRequireDefault(
+  require('./getNoTestsFoundMessage')
+);
+
+var _runGlobalHook = _interopRequireDefault(require('./runGlobalHook'));
+
+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) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const getTestPaths = async (
+  globalConfig,
+  source,
+  outputStream,
+  changedFiles,
+  jestHooks,
+  filter
+) => {
+  const data = await source.getTestPaths(globalConfig, changedFiles, filter);
+
+  if (!data.tests.length && globalConfig.onlyChanged && data.noSCM) {
+    new (_console().CustomConsole)(outputStream, outputStream).log(
+      'Jest can only find uncommitted changed files in a git or hg ' +
+        'repository. If you make your project a git or hg ' +
+        'repository (`git init` or `hg init`), Jest will be able ' +
+        'to only run tests related to files changed since the last ' +
+        'commit.'
+    );
+  }
+
+  const shouldTestArray = await Promise.all(
+    data.tests.map(test =>
+      jestHooks.shouldRunTestSuite({
+        config: test.context.config,
+        duration: test.duration,
+        testPath: test.path
+      })
+    )
+  );
+  const filteredTests = data.tests.filter((_test, i) => shouldTestArray[i]);
+  return {...data, allTests: filteredTests.length, tests: filteredTests};
+};
+
+const processResults = async (runResults, options) => {
+  const {
+    outputFile,
+    json: isJSON,
+    onComplete,
+    outputStream,
+    testResultsProcessor,
+    collectHandles
+  } = options;
+
+  if (collectHandles) {
+    runResults.openHandles = await collectHandles();
+  } else {
+    runResults.openHandles = [];
+  }
+
+  if (testResultsProcessor) {
+    const processor = await (0, _jestUtil().requireOrImportModule)(
+      testResultsProcessor
+    );
+    runResults = processor(runResults);
+  }
+
+  if (isJSON) {
+    if (outputFile) {
+      const cwd = (0, _jestUtil().tryRealpath)(process.cwd());
+      const filePath = path().resolve(cwd, outputFile);
+      fs().writeFileSync(
+        filePath,
+        JSON.stringify((0, _testResult().formatTestResults)(runResults))
+      );
+      outputStream.write(
+        `Test results written to: ${path().relative(cwd, filePath)}\n`
+      );
+    } else {
+      process.stdout.write(
+        JSON.stringify((0, _testResult().formatTestResults)(runResults))
+      );
+    }
+  }
+
+  onComplete === null || onComplete === void 0
+    ? void 0
+    : onComplete(runResults);
+};
+
+const testSchedulerContext = {
+  firstRun: true,
+  previousSuccess: true
+};
+
+async function runJest({
+  contexts,
+  globalConfig,
+  outputStream,
+  testWatcher,
+  jestHooks = new (_jestWatcher().JestHook)().getEmitter(),
+  startRun,
+  changedFilesPromise,
+  onComplete,
+  failedTestsCache,
+  filter
+}) {
+  // Clear cache for required modules - there might be different resolutions
+  // from Jest's config loading to running the tests
+  _jestResolve().default.clearDefaultResolverCache();
+
+  const Sequencer = await (0, _jestUtil().requireOrImportModule)(
+    globalConfig.testSequencer
+  );
+  const sequencer = new Sequencer();
+  let allTests = [];
+
+  if (changedFilesPromise && globalConfig.watch) {
+    const {repos} = await changedFilesPromise;
+    const noSCM = Object.keys(repos).every(scm => repos[scm].size === 0);
+
+    if (noSCM) {
+      process.stderr.write(
+        '\n' +
+          _chalk().default.bold('--watch') +
+          ' is not supported without git/hg, please use --watchAll ' +
+          '\n'
+      );
+      (0, _exit().default)(1);
+    }
+  }
+
+  const searchSources = contexts.map(
+    context => new _SearchSource.default(context)
+  );
+  const testRunData = await Promise.all(
+    contexts.map(async (context, index) => {
+      const searchSource = searchSources[index];
+      const matches = await getTestPaths(
+        globalConfig,
+        searchSource,
+        outputStream,
+        changedFilesPromise && (await changedFilesPromise),
+        jestHooks,
+        filter
+      );
+      allTests = allTests.concat(matches.tests);
+      return {
+        context,
+        matches
+      };
+    })
+  );
+  allTests = await sequencer.sort(allTests);
+
+  if (globalConfig.listTests) {
+    const testsPaths = Array.from(new Set(allTests.map(test => test.path)));
+    /* eslint-disable no-console */
+
+    if (globalConfig.json) {
+      console.log(JSON.stringify(testsPaths));
+    } else {
+      console.log(testsPaths.join('\n'));
+    }
+    /* eslint-enable */
+
+    onComplete &&
+      onComplete((0, _testResult().makeEmptyAggregatedTestResult)());
+    return;
+  }
+
+  if (globalConfig.onlyFailures) {
+    if (failedTestsCache) {
+      allTests = failedTestsCache.filterTests(allTests);
+    } else {
+      allTests = await sequencer.allFailedTests(allTests);
+    }
+  }
+
+  const hasTests = allTests.length > 0;
+
+  if (!hasTests) {
+    const noTestsFoundMessage = (0, _getNoTestsFoundMessage.default)(
+      testRunData,
+      globalConfig
+    );
+
+    if (
+      globalConfig.passWithNoTests ||
+      globalConfig.findRelatedTests ||
+      globalConfig.lastCommit ||
+      globalConfig.onlyChanged
+    ) {
+      new (_console().CustomConsole)(outputStream, outputStream).log(
+        noTestsFoundMessage
+      );
+    } else {
+      new (_console().CustomConsole)(outputStream, outputStream).error(
+        noTestsFoundMessage
+      );
+      (0, _exit().default)(1);
+    }
+  } else if (
+    allTests.length === 1 &&
+    globalConfig.silent !== true &&
+    globalConfig.verbose !== false
+  ) {
+    const newConfig = {...globalConfig, verbose: true};
+    globalConfig = Object.freeze(newConfig);
+  }
+
+  let collectHandles;
+
+  if (globalConfig.detectOpenHandles) {
+    collectHandles = (0, _collectHandles.default)();
+  }
+
+  if (hasTests) {
+    await (0, _runGlobalHook.default)({
+      allTests,
+      globalConfig,
+      moduleName: 'globalSetup'
+    });
+  }
+
+  if (changedFilesPromise) {
+    const changedFilesInfo = await changedFilesPromise;
+
+    if (changedFilesInfo.changedFiles) {
+      testSchedulerContext.changedFiles = changedFilesInfo.changedFiles;
+      const sourcesRelatedToTestsInChangedFilesArray = (
+        await Promise.all(
+          contexts.map(async (_, index) => {
+            const searchSource = searchSources[index];
+            return searchSource.findRelatedSourcesFromTestsInChangedFiles(
+              changedFilesInfo
+            );
+          })
+        )
+      ).reduce((total, paths) => total.concat(paths), []);
+      testSchedulerContext.sourcesRelatedToTestsInChangedFiles = new Set(
+        sourcesRelatedToTestsInChangedFilesArray
+      );
+    }
+  }
+
+  const scheduler = await (0, _TestScheduler.createTestScheduler)(
+    globalConfig,
+    {
+      startRun
+    },
+    testSchedulerContext
+  );
+  const results = await scheduler.scheduleTests(allTests, testWatcher);
+  await sequencer.cacheResults(allTests, results);
+
+  if (hasTests) {
+    await (0, _runGlobalHook.default)({
+      allTests,
+      globalConfig,
+      moduleName: 'globalTeardown'
+    });
+  }
+
+  await processResults(results, {
+    collectHandles,
+    json: globalConfig.json,
+    onComplete,
+    outputFile: globalConfig.outputFile,
+    outputStream,
+    testResultsProcessor: globalConfig.testResultsProcessor
+  });
+}
diff --git a/node_modules/@jest/core/build/testSchedulerHelper.d.ts b/node_modules/@jest/core/build/testSchedulerHelper.d.ts
new file mode 100644
index 0000000..d49d44f
--- /dev/null
+++ b/node_modules/@jest/core/build/testSchedulerHelper.d.ts
@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Test } from '@jest/test-result';
+import type { Config } from '@jest/types';
+export declare function shouldRunInBand(tests: Array<Test>, timings: Array<number>, { detectOpenHandles, maxWorkers, watch, watchAll }: Config.GlobalConfig): boolean;
diff --git a/node_modules/@jest/core/build/testSchedulerHelper.js b/node_modules/@jest/core/build/testSchedulerHelper.js
new file mode 100644
index 0000000..78cf48c
--- /dev/null
+++ b/node_modules/@jest/core/build/testSchedulerHelper.js
@@ -0,0 +1,51 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.shouldRunInBand = shouldRunInBand;
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const SLOW_TEST_TIME = 1000;
+
+function shouldRunInBand(
+  tests,
+  timings,
+  {detectOpenHandles, maxWorkers, watch, watchAll}
+) {
+  // detectOpenHandles makes no sense without runInBand, because it cannot detect leaks in workers
+  if (detectOpenHandles) {
+    return true;
+  }
+  /*
+   * Run in band if we only have one test or one worker available, unless we
+   * are using the watch mode, in which case the TTY has to be responsive and
+   * we cannot schedule anything in the main thread. Same logic applies to
+   * watchAll.
+   * Also, if we are confident from previous runs that the tests will finish
+   * quickly we also run in band to reduce the overhead of spawning workers.
+   * Finally, the user can provide the runInBand argument in the CLI to
+   * force running in band.
+   * https://github.com/facebook/jest/blob/700e0dadb85f5dc8ff5dac6c7e98956690049734/packages/jest-config/src/getMaxWorkers.js#L14-L17
+   */
+
+  const isWatchMode = watch || watchAll;
+  const areFastTests = timings.every(timing => timing < SLOW_TEST_TIME);
+  const oneWorkerOrLess = maxWorkers <= 1;
+  const oneTestOrLess = tests.length <= 1;
+
+  if (isWatchMode) {
+    return oneWorkerOrLess || (oneTestOrLess && areFastTests);
+  }
+
+  return (
+    oneWorkerOrLess ||
+    oneTestOrLess ||
+    (tests.length <= 20 && timings.length > 0 && areFastTests)
+  );
+}
diff --git a/node_modules/@jest/core/build/types.d.ts b/node_modules/@jest/core/build/types.d.ts
new file mode 100644
index 0000000..877941c
--- /dev/null
+++ b/node_modules/@jest/core/build/types.d.ts
@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Test } from '@jest/test-result';
+import type { Config } from '@jest/types';
+import type { Context } from 'jest-runtime';
+export declare type Stats = {
+    roots: number;
+    testMatch: number;
+    testPathIgnorePatterns: number;
+    testRegex: number;
+    testPathPattern?: number;
+};
+export declare type TestRunData = Array<{
+    context: Context;
+    matches: {
+        allTests: number;
+        tests: Array<Test>;
+        total?: number;
+        stats?: Stats;
+    };
+}>;
+export declare type TestPathCases = Array<{
+    stat: keyof Stats;
+    isMatch: (path: Config.Path) => boolean;
+}>;
+export declare type TestPathCasesWithPathPattern = TestPathCases & {
+    testPathPattern: (path: Config.Path) => boolean;
+};
+export declare type FilterResult = {
+    test: string;
+    message: string;
+};
+export declare type Filter = (testPaths: Array<string>) => Promise<{
+    filtered: Array<FilterResult>;
+}>;
diff --git a/node_modules/@jest/core/build/types.js b/node_modules/@jest/core/build/types.js
new file mode 100644
index 0000000..ad9a93a
--- /dev/null
+++ b/node_modules/@jest/core/build/types.js
@@ -0,0 +1 @@
+'use strict';
diff --git a/node_modules/@jest/core/build/version.d.ts b/node_modules/@jest/core/build/version.d.ts
new file mode 100644
index 0000000..8646731
--- /dev/null
+++ b/node_modules/@jest/core/build/version.d.ts
@@ -0,0 +1,7 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export default function getVersion(): string;
diff --git a/node_modules/@jest/core/build/version.js b/node_modules/@jest/core/build/version.js
new file mode 100644
index 0000000..1bcd800
--- /dev/null
+++ b/node_modules/@jest/core/build/version.js
@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = getVersion;
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+// Cannot be `import` as it's not under TS root dir
+const {version: VERSION} = require('../package.json');
+
+function getVersion() {
+  return VERSION;
+}
diff --git a/node_modules/@jest/core/build/watch.d.ts b/node_modules/@jest/core/build/watch.d.ts
new file mode 100644
index 0000000..d8df910
--- /dev/null
+++ b/node_modules/@jest/core/build/watch.d.ts
@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/// <reference types="node" />
+import type { Config } from '@jest/types';
+import type { default as HasteMap } from 'jest-haste-map';
+import type { Context } from 'jest-runtime';
+import { JestHook } from 'jest-watcher';
+import type { Filter } from './types';
+export default function watch(initialGlobalConfig: Config.GlobalConfig, contexts: Array<Context>, outputStream: NodeJS.WriteStream, hasteMapInstances: Array<HasteMap>, stdin?: NodeJS.ReadStream, hooks?: JestHook, filter?: Filter): Promise<void>;
diff --git a/node_modules/@jest/core/build/watch.js b/node_modules/@jest/core/build/watch.js
new file mode 100644
index 0000000..cffb811
--- /dev/null
+++ b/node_modules/@jest/core/build/watch.js
@@ -0,0 +1,769 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = watch;
+
+function path() {
+  const data = _interopRequireWildcard(require('path'));
+
+  path = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _ansiEscapes() {
+  const data = _interopRequireDefault(require('ansi-escapes'));
+
+  _ansiEscapes = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+
+  _chalk = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _exit() {
+  const data = _interopRequireDefault(require('exit'));
+
+  _exit = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _slash() {
+  const data = _interopRequireDefault(require('slash'));
+
+  _slash = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestMessageUtil() {
+  const data = require('jest-message-util');
+
+  _jestMessageUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestValidate() {
+  const data = require('jest-validate');
+
+  _jestValidate = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestWatcher() {
+  const data = require('jest-watcher');
+
+  _jestWatcher = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _FailedTestsCache = _interopRequireDefault(require('./FailedTestsCache'));
+
+var _SearchSource = _interopRequireDefault(require('./SearchSource'));
+
+var _TestWatcher = _interopRequireDefault(require('./TestWatcher'));
+
+var _getChangedFilesPromise = _interopRequireDefault(
+  require('./getChangedFilesPromise')
+);
+
+var _activeFiltersMessage = _interopRequireDefault(
+  require('./lib/activeFiltersMessage')
+);
+
+var _createContext = _interopRequireDefault(require('./lib/createContext'));
+
+var _isValidPath = _interopRequireDefault(require('./lib/isValidPath'));
+
+var _updateGlobalConfig = _interopRequireDefault(
+  require('./lib/updateGlobalConfig')
+);
+
+var _watchPluginsHelpers = require('./lib/watchPluginsHelpers');
+
+var _FailedTestsInteractive = _interopRequireDefault(
+  require('./plugins/FailedTestsInteractive')
+);
+
+var _Quit = _interopRequireDefault(require('./plugins/Quit'));
+
+var _TestNamePattern = _interopRequireDefault(
+  require('./plugins/TestNamePattern')
+);
+
+var _TestPathPattern = _interopRequireDefault(
+  require('./plugins/TestPathPattern')
+);
+
+var _UpdateSnapshots = _interopRequireDefault(
+  require('./plugins/UpdateSnapshots')
+);
+
+var _UpdateSnapshotsInteractive = _interopRequireDefault(
+  require('./plugins/UpdateSnapshotsInteractive')
+);
+
+var _runJest = _interopRequireDefault(require('./runJest'));
+
+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) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const {print: preRunMessagePrint} = _jestUtil().preRunMessage;
+
+let hasExitListener = false;
+const INTERNAL_PLUGINS = [
+  _FailedTestsInteractive.default,
+  _TestPathPattern.default,
+  _TestNamePattern.default,
+  _UpdateSnapshots.default,
+  _UpdateSnapshotsInteractive.default,
+  _Quit.default
+];
+const RESERVED_KEY_PLUGINS = new Map([
+  [
+    _UpdateSnapshots.default,
+    {
+      forbiddenOverwriteMessage: 'updating snapshots',
+      key: 'u'
+    }
+  ],
+  [
+    _UpdateSnapshotsInteractive.default,
+    {
+      forbiddenOverwriteMessage: 'updating snapshots interactively',
+      key: 'i'
+    }
+  ],
+  [
+    _Quit.default,
+    {
+      forbiddenOverwriteMessage: 'quitting watch mode'
+    }
+  ]
+]);
+
+async function watch(
+  initialGlobalConfig,
+  contexts,
+  outputStream,
+  hasteMapInstances,
+  stdin = process.stdin,
+  hooks = new (_jestWatcher().JestHook)(),
+  filter
+) {
+  // `globalConfig` will be constantly updated and reassigned as a result of
+  // watch mode interactions.
+  let globalConfig = initialGlobalConfig;
+  let activePlugin;
+  globalConfig = (0, _updateGlobalConfig.default)(globalConfig, {
+    mode: globalConfig.watch ? 'watch' : 'watchAll',
+    passWithNoTests: true
+  });
+
+  const updateConfigAndRun = ({
+    bail,
+    changedSince,
+    collectCoverage,
+    collectCoverageFrom,
+    collectCoverageOnlyFrom,
+    coverageDirectory,
+    coverageReporters,
+    findRelatedTests,
+    mode,
+    nonFlagArgs,
+    notify,
+    notifyMode,
+    onlyFailures,
+    reporters,
+    testNamePattern,
+    testPathPattern,
+    updateSnapshot,
+    verbose
+  } = {}) => {
+    const previousUpdateSnapshot = globalConfig.updateSnapshot;
+    globalConfig = (0, _updateGlobalConfig.default)(globalConfig, {
+      bail,
+      changedSince,
+      collectCoverage,
+      collectCoverageFrom,
+      collectCoverageOnlyFrom,
+      coverageDirectory,
+      coverageReporters,
+      findRelatedTests,
+      mode,
+      nonFlagArgs,
+      notify,
+      notifyMode,
+      onlyFailures,
+      reporters,
+      testNamePattern,
+      testPathPattern,
+      updateSnapshot,
+      verbose
+    });
+    startRun(globalConfig);
+    globalConfig = (0, _updateGlobalConfig.default)(globalConfig, {
+      // updateSnapshot is not sticky after a run.
+      updateSnapshot:
+        previousUpdateSnapshot === 'all' ? 'none' : previousUpdateSnapshot
+    });
+  };
+
+  const watchPlugins = INTERNAL_PLUGINS.map(
+    InternalPlugin =>
+      new InternalPlugin({
+        stdin,
+        stdout: outputStream
+      })
+  );
+  watchPlugins.forEach(plugin => {
+    const hookSubscriber = hooks.getSubscriber();
+
+    if (plugin.apply) {
+      plugin.apply(hookSubscriber);
+    }
+  });
+
+  if (globalConfig.watchPlugins != null) {
+    const watchPluginKeys = new Map();
+
+    for (const plugin of watchPlugins) {
+      const reservedInfo = RESERVED_KEY_PLUGINS.get(plugin.constructor) || {};
+      const key = reservedInfo.key || getPluginKey(plugin, globalConfig);
+
+      if (!key) {
+        continue;
+      }
+
+      const {forbiddenOverwriteMessage} = reservedInfo;
+      watchPluginKeys.set(key, {
+        forbiddenOverwriteMessage,
+        overwritable: forbiddenOverwriteMessage == null,
+        plugin
+      });
+    }
+
+    for (const pluginWithConfig of globalConfig.watchPlugins) {
+      let plugin;
+
+      try {
+        const ThirdPartyPlugin = await (0, _jestUtil().requireOrImportModule)(
+          pluginWithConfig.path
+        );
+        plugin = new ThirdPartyPlugin({
+          config: pluginWithConfig.config,
+          stdin,
+          stdout: outputStream
+        });
+      } catch (error) {
+        const errorWithContext = new Error(
+          `Failed to initialize watch plugin "${_chalk().default.bold(
+            (0, _slash().default)(
+              path().relative(process.cwd(), pluginWithConfig.path)
+            )
+          )}":\n\n${(0, _jestMessageUtil().formatExecError)(
+            error,
+            contexts[0].config,
+            {
+              noStackTrace: false
+            }
+          )}`
+        );
+        delete errorWithContext.stack;
+        return Promise.reject(errorWithContext);
+      }
+
+      checkForConflicts(watchPluginKeys, plugin, globalConfig);
+      const hookSubscriber = hooks.getSubscriber();
+
+      if (plugin.apply) {
+        plugin.apply(hookSubscriber);
+      }
+
+      watchPlugins.push(plugin);
+    }
+  }
+
+  const failedTestsCache = new _FailedTestsCache.default();
+  let searchSources = contexts.map(context => ({
+    context,
+    searchSource: new _SearchSource.default(context)
+  }));
+  let isRunning = false;
+  let testWatcher;
+  let shouldDisplayWatchUsage = true;
+  let isWatchUsageDisplayed = false;
+
+  const emitFileChange = () => {
+    if (hooks.isUsed('onFileChange')) {
+      const projects = searchSources.map(({context, searchSource}) => ({
+        config: context.config,
+        testPaths: searchSource.findMatchingTests('').tests.map(t => t.path)
+      }));
+      hooks.getEmitter().onFileChange({
+        projects
+      });
+    }
+  };
+
+  emitFileChange();
+  hasteMapInstances.forEach((hasteMapInstance, index) => {
+    hasteMapInstance.on('change', ({eventsQueue, hasteFS, moduleMap}) => {
+      const validPaths = eventsQueue.filter(({filePath}) =>
+        (0, _isValidPath.default)(globalConfig, filePath)
+      );
+
+      if (validPaths.length) {
+        const context = (contexts[index] = (0, _createContext.default)(
+          contexts[index].config,
+          {
+            hasteFS,
+            moduleMap
+          }
+        ));
+        activePlugin = null;
+        searchSources = searchSources.slice();
+        searchSources[index] = {
+          context,
+          searchSource: new _SearchSource.default(context)
+        };
+        emitFileChange();
+        startRun(globalConfig);
+      }
+    });
+  });
+
+  if (!hasExitListener) {
+    hasExitListener = true;
+    process.on('exit', () => {
+      if (activePlugin) {
+        outputStream.write(_ansiEscapes().default.cursorDown());
+        outputStream.write(_ansiEscapes().default.eraseDown);
+      }
+    });
+  }
+
+  const startRun = globalConfig => {
+    if (isRunning) {
+      return Promise.resolve(null);
+    }
+
+    testWatcher = new _TestWatcher.default({
+      isWatchMode: true
+    });
+    _jestUtil().isInteractive &&
+      outputStream.write(_jestUtil().specialChars.CLEAR);
+    preRunMessagePrint(outputStream);
+    isRunning = true;
+    const configs = contexts.map(context => context.config);
+    const changedFilesPromise = (0, _getChangedFilesPromise.default)(
+      globalConfig,
+      configs
+    );
+    return (0, _runJest.default)({
+      changedFilesPromise,
+      contexts,
+      failedTestsCache,
+      filter,
+      globalConfig,
+      jestHooks: hooks.getEmitter(),
+      onComplete: results => {
+        isRunning = false;
+        hooks.getEmitter().onTestRunComplete(results); // Create a new testWatcher instance so that re-runs won't be blocked.
+        // The old instance that was passed to Jest will still be interrupted
+        // and prevent test runs from the previous run.
+
+        testWatcher = new _TestWatcher.default({
+          isWatchMode: true
+        }); // Do not show any Watch Usage related stuff when running in a
+        // non-interactive environment
+
+        if (_jestUtil().isInteractive) {
+          if (shouldDisplayWatchUsage) {
+            outputStream.write(usage(globalConfig, watchPlugins));
+            shouldDisplayWatchUsage = false; // hide Watch Usage after first run
+
+            isWatchUsageDisplayed = true;
+          } else {
+            outputStream.write(showToggleUsagePrompt());
+            shouldDisplayWatchUsage = false;
+            isWatchUsageDisplayed = false;
+          }
+        } else {
+          outputStream.write('\n');
+        }
+
+        failedTestsCache.setTestResults(results.testResults);
+      },
+      outputStream,
+      startRun,
+      testWatcher
+    }).catch(
+      (
+        error // Errors thrown inside `runJest`, e.g. by resolvers, are caught here for
+      ) =>
+        // continuous watch mode execution. We need to reprint them to the
+        // terminal and give just a little bit of extra space so they fit below
+        // `preRunMessagePrint` message nicely.
+        console.error(
+          '\n\n' +
+            (0, _jestMessageUtil().formatExecError)(error, contexts[0].config, {
+              noStackTrace: false
+            })
+        )
+    );
+  };
+
+  const onKeypress = key => {
+    if (
+      key === _jestWatcher().KEYS.CONTROL_C ||
+      key === _jestWatcher().KEYS.CONTROL_D
+    ) {
+      if (typeof stdin.setRawMode === 'function') {
+        stdin.setRawMode(false);
+      }
+
+      outputStream.write('\n');
+      (0, _exit().default)(0);
+      return;
+    }
+
+    if (activePlugin != null && activePlugin.onKey) {
+      // if a plugin is activate, Jest should let it handle keystrokes, so ignore
+      // them here
+      activePlugin.onKey(key);
+      return;
+    } // Abort test run
+
+    const pluginKeys = (0, _watchPluginsHelpers.getSortedUsageRows)(
+      watchPlugins,
+      globalConfig
+    ).map(usage => Number(usage.key).toString(16));
+
+    if (
+      isRunning &&
+      testWatcher &&
+      ['q', _jestWatcher().KEYS.ENTER, 'a', 'o', 'f']
+        .concat(pluginKeys)
+        .includes(key)
+    ) {
+      testWatcher.setState({
+        interrupted: true
+      });
+      return;
+    }
+
+    const matchingWatchPlugin = (0,
+    _watchPluginsHelpers.filterInteractivePlugins)(
+      watchPlugins,
+      globalConfig
+    ).find(plugin => getPluginKey(plugin, globalConfig) === key);
+
+    if (matchingWatchPlugin != null) {
+      if (isRunning) {
+        testWatcher.setState({
+          interrupted: true
+        });
+        return;
+      } // "activate" the plugin, which has jest ignore keystrokes so the plugin
+      // can handle them
+
+      activePlugin = matchingWatchPlugin;
+
+      if (activePlugin.run) {
+        activePlugin.run(globalConfig, updateConfigAndRun).then(
+          shouldRerun => {
+            activePlugin = null;
+
+            if (shouldRerun) {
+              updateConfigAndRun();
+            }
+          },
+          () => {
+            activePlugin = null;
+            onCancelPatternPrompt();
+          }
+        );
+      } else {
+        activePlugin = null;
+      }
+    }
+
+    switch (key) {
+      case _jestWatcher().KEYS.ENTER:
+        startRun(globalConfig);
+        break;
+
+      case 'a':
+        globalConfig = (0, _updateGlobalConfig.default)(globalConfig, {
+          mode: 'watchAll',
+          testNamePattern: '',
+          testPathPattern: ''
+        });
+        startRun(globalConfig);
+        break;
+
+      case 'c':
+        updateConfigAndRun({
+          mode: 'watch',
+          testNamePattern: '',
+          testPathPattern: ''
+        });
+        break;
+
+      case 'f':
+        globalConfig = (0, _updateGlobalConfig.default)(globalConfig, {
+          onlyFailures: !globalConfig.onlyFailures
+        });
+        startRun(globalConfig);
+        break;
+
+      case 'o':
+        globalConfig = (0, _updateGlobalConfig.default)(globalConfig, {
+          mode: 'watch',
+          testNamePattern: '',
+          testPathPattern: ''
+        });
+        startRun(globalConfig);
+        break;
+
+      case '?':
+        break;
+
+      case 'w':
+        if (!shouldDisplayWatchUsage && !isWatchUsageDisplayed) {
+          outputStream.write(_ansiEscapes().default.cursorUp());
+          outputStream.write(_ansiEscapes().default.eraseDown);
+          outputStream.write(usage(globalConfig, watchPlugins));
+          isWatchUsageDisplayed = true;
+          shouldDisplayWatchUsage = false;
+        }
+
+        break;
+    }
+  };
+
+  const onCancelPatternPrompt = () => {
+    outputStream.write(_ansiEscapes().default.cursorHide);
+    outputStream.write(_jestUtil().specialChars.CLEAR);
+    outputStream.write(usage(globalConfig, watchPlugins));
+    outputStream.write(_ansiEscapes().default.cursorShow);
+  };
+
+  if (typeof stdin.setRawMode === 'function') {
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding('utf8');
+    stdin.on('data', onKeypress);
+  }
+
+  startRun(globalConfig);
+  return Promise.resolve();
+}
+
+const checkForConflicts = (watchPluginKeys, plugin, globalConfig) => {
+  const key = getPluginKey(plugin, globalConfig);
+
+  if (!key) {
+    return;
+  }
+
+  const conflictor = watchPluginKeys.get(key);
+
+  if (!conflictor || conflictor.overwritable) {
+    watchPluginKeys.set(key, {
+      overwritable: false,
+      plugin
+    });
+    return;
+  }
+
+  let error;
+
+  if (conflictor.forbiddenOverwriteMessage) {
+    error = `
+  Watch plugin ${_chalk().default.bold.red(
+    getPluginIdentifier(plugin)
+  )} attempted to register key ${_chalk().default.bold.red(`<${key}>`)},
+  that is reserved internally for ${_chalk().default.bold.red(
+    conflictor.forbiddenOverwriteMessage
+  )}.
+  Please change the configuration key for this plugin.`.trim();
+  } else {
+    const plugins = [conflictor.plugin, plugin]
+      .map(p => _chalk().default.bold.red(getPluginIdentifier(p)))
+      .join(' and ');
+    error = `
+  Watch plugins ${plugins} both attempted to register key ${_chalk().default.bold.red(
+      `<${key}>`
+    )}.
+  Please change the key configuration for one of the conflicting plugins to avoid overlap.`.trim();
+  }
+
+  throw new (_jestValidate().ValidationError)(
+    'Watch plugin configuration error',
+    error
+  );
+};
+
+const getPluginIdentifier = (
+  plugin // This breaks as `displayName` is not defined as a static, but since
+) =>
+  // WatchPlugin is an interface, and it is my understanding interface
+  // static fields are not definable anymore, no idea how to circumvent
+  // this :-(
+  // @ts-expect-error: leave `displayName` be.
+  plugin.constructor.displayName || plugin.constructor.name;
+
+const getPluginKey = (plugin, globalConfig) => {
+  if (typeof plugin.getUsageInfo === 'function') {
+    return (
+      plugin.getUsageInfo(globalConfig) || {
+        key: null
+      }
+    ).key;
+  }
+
+  return null;
+};
+
+const usage = (globalConfig, watchPlugins, delimiter = '\n') => {
+  const messages = [
+    (0, _activeFiltersMessage.default)(globalConfig),
+    globalConfig.testPathPattern || globalConfig.testNamePattern
+      ? _chalk().default.dim(' \u203A Press ') +
+        'c' +
+        _chalk().default.dim(' to clear filters.')
+      : null,
+    '\n' + _chalk().default.bold('Watch Usage'),
+    globalConfig.watch
+      ? _chalk().default.dim(' \u203A Press ') +
+        'a' +
+        _chalk().default.dim(' to run all tests.')
+      : null,
+    globalConfig.onlyFailures
+      ? _chalk().default.dim(' \u203A Press ') +
+        'f' +
+        _chalk().default.dim(' to quit "only failed tests" mode.')
+      : _chalk().default.dim(' \u203A Press ') +
+        'f' +
+        _chalk().default.dim(' to run only failed tests.'),
+    (globalConfig.watchAll ||
+      globalConfig.testPathPattern ||
+      globalConfig.testNamePattern) &&
+    !globalConfig.noSCM
+      ? _chalk().default.dim(' \u203A Press ') +
+        'o' +
+        _chalk().default.dim(' to only run tests related to changed files.')
+      : null,
+    ...(0, _watchPluginsHelpers.getSortedUsageRows)(
+      watchPlugins,
+      globalConfig
+    ).map(
+      plugin =>
+        _chalk().default.dim(' \u203A Press') +
+        ' ' +
+        plugin.key +
+        ' ' +
+        _chalk().default.dim(`to ${plugin.prompt}.`)
+    ),
+    _chalk().default.dim(' \u203A Press ') +
+      'Enter' +
+      _chalk().default.dim(' to trigger a test run.')
+  ];
+  return messages.filter(message => !!message).join(delimiter) + '\n';
+};
+
+const showToggleUsagePrompt = () =>
+  '\n' +
+  _chalk().default.bold('Watch Usage: ') +
+  _chalk().default.dim('Press ') +
+  'w' +
+  _chalk().default.dim(' to show more.');