8 files changed, 1062 insertions, 0 deletions
diff --git a/node_modules/jest-runner/build/index.d.ts b/node_modules/jest-runner/build/index.d.ts
new file mode 100644
index 0000000..310f542
--- /dev/null
+++ b/node_modules/jest-runner/build/index.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.
+ */
+import Emittery = require('emittery');
+import type { Test, TestEvents } from '@jest/test-result';
+import type { Config } from '@jest/types';
+import type { OnTestFailure, OnTestStart, OnTestSuccess, TestRunnerContext, TestRunnerOptions, TestWatcher } from './types';
+export type { Test, TestFileEvent, TestEvents } from '@jest/test-result';
+export type { OnTestFailure, OnTestStart, OnTestSuccess, TestWatcher, TestRunnerContext, TestRunnerOptions, } from './types';
+export default class TestRunner {
+    private readonly _globalConfig;
+    private readonly _context;
+    private readonly eventEmitter;
+    readonly __PRIVATE_UNSTABLE_API_supportsEventEmitters__: boolean;
+    readonly isSerial?: boolean;
+    constructor(globalConfig: Config.GlobalConfig, context?: TestRunnerContext);
+    runTests(tests: Array<Test>, watcher: TestWatcher, onStart: OnTestStart | undefined, onResult: OnTestSuccess | undefined, onFailure: OnTestFailure | undefined, options: TestRunnerOptions): Promise<void>;
+    private _createInBandTestRun;
+    private _createParallelTestRun;
+    on<Name extends keyof TestEvents>(eventName: Name, listener: (eventData: TestEvents[Name]) => void | Promise<void>): Emittery.UnsubscribeFn;
+}
diff --git a/node_modules/jest-runner/build/index.js b/node_modules/jest-runner/build/index.js
new file mode 100644
index 0000000..c4d926b
--- /dev/null
+++ b/node_modules/jest-runner/build/index.js
@@ -0,0 +1,300 @@
+'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 _emittery() {
+  const data = _interopRequireDefault(require('emittery'));
+
+  _emittery = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _throat() {
+  const data = _interopRequireDefault(require('throat'));
+
+  _throat = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestWorker() {
+  const data = require('jest-worker');
+
+  _jestWorker = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _runTest = _interopRequireDefault(require('./runTest'));
+
+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 TEST_WORKER_PATH = require.resolve('./testWorker');
+
+class TestRunner {
+  constructor(globalConfig, context) {
+    _defineProperty(this, '_globalConfig', void 0);
+
+    _defineProperty(this, '_context', void 0);
+
+    _defineProperty(this, 'eventEmitter', new (_emittery().default)());
+
+    _defineProperty(
+      this,
+      '__PRIVATE_UNSTABLE_API_supportsEventEmitters__',
+      true
+    );
+
+    _defineProperty(this, 'isSerial', void 0);
+
+    this._globalConfig = globalConfig;
+    this._context = context || {};
+  }
+
+  async runTests(tests, watcher, onStart, onResult, onFailure, options) {
+    return await (options.serial
+      ? this._createInBandTestRun(tests, watcher, onStart, onResult, onFailure)
+      : this._createParallelTestRun(
+          tests,
+          watcher,
+          onStart,
+          onResult,
+          onFailure
+        ));
+  }
+
+  async _createInBandTestRun(tests, watcher, onStart, onResult, onFailure) {
+    process.env.JEST_WORKER_ID = '1';
+    const mutex = (0, _throat().default)(1);
+    return tests.reduce(
+      (promise, test) =>
+        mutex(() =>
+          promise
+            .then(async () => {
+              if (watcher.isInterrupted()) {
+                throw new CancelRun();
+              } // Remove `if(onStart)` in Jest 27
+
+              if (onStart) {
+                await onStart(test);
+                return (0, _runTest.default)(
+                  test.path,
+                  this._globalConfig,
+                  test.context.config,
+                  test.context.resolver,
+                  this._context,
+                  undefined
+                );
+              } // `deepCyclicCopy` used here to avoid mem-leak
+
+              const sendMessageToJest = (eventName, args) =>
+                this.eventEmitter.emit(
+                  eventName,
+                  (0, _jestUtil().deepCyclicCopy)(args, {
+                    keepPrototype: false
+                  })
+                );
+
+              await this.eventEmitter.emit('test-file-start', [test]);
+              return (0, _runTest.default)(
+                test.path,
+                this._globalConfig,
+                test.context.config,
+                test.context.resolver,
+                this._context,
+                sendMessageToJest
+              );
+            })
+            .then(result => {
+              if (onResult) {
+                return onResult(test, result);
+              }
+
+              return this.eventEmitter.emit('test-file-success', [
+                test,
+                result
+              ]);
+            })
+            .catch(err => {
+              if (onFailure) {
+                return onFailure(test, err);
+              }
+
+              return this.eventEmitter.emit('test-file-failure', [test, err]);
+            })
+        ),
+      Promise.resolve()
+    );
+  }
+
+  async _createParallelTestRun(tests, watcher, onStart, onResult, onFailure) {
+    const resolvers = new Map();
+
+    for (const test of tests) {
+      if (!resolvers.has(test.context.config.name)) {
+        resolvers.set(test.context.config.name, {
+          config: test.context.config,
+          serializableModuleMap: test.context.moduleMap.toJSON()
+        });
+      }
+    }
+
+    const worker = new (_jestWorker().Worker)(TEST_WORKER_PATH, {
+      exposedMethods: ['worker'],
+      forkOptions: {
+        stdio: 'pipe'
+      },
+      maxRetries: 3,
+      numWorkers: this._globalConfig.maxWorkers,
+      setupArgs: [
+        {
+          serializableResolvers: Array.from(resolvers.values())
+        }
+      ]
+    });
+    if (worker.getStdout()) worker.getStdout().pipe(process.stdout);
+    if (worker.getStderr()) worker.getStderr().pipe(process.stderr);
+    const mutex = (0, _throat().default)(this._globalConfig.maxWorkers); // Send test suites to workers continuously instead of all at once to track
+    // the start time of individual tests.
+
+    const runTestInWorker = test =>
+      mutex(async () => {
+        if (watcher.isInterrupted()) {
+          return Promise.reject();
+        } // Remove `if(onStart)` in Jest 27
+
+        if (onStart) {
+          await onStart(test);
+        } else {
+          await this.eventEmitter.emit('test-file-start', [test]);
+        }
+
+        const promise = worker.worker({
+          config: test.context.config,
+          context: {
+            ...this._context,
+            changedFiles:
+              this._context.changedFiles &&
+              Array.from(this._context.changedFiles),
+            sourcesRelatedToTestsInChangedFiles:
+              this._context.sourcesRelatedToTestsInChangedFiles &&
+              Array.from(this._context.sourcesRelatedToTestsInChangedFiles)
+          },
+          globalConfig: this._globalConfig,
+          path: test.path
+        });
+
+        if (promise.UNSTABLE_onCustomMessage) {
+          // TODO: Get appropriate type for `onCustomMessage`
+          promise.UNSTABLE_onCustomMessage(([event, payload]) => {
+            this.eventEmitter.emit(event, payload);
+          });
+        }
+
+        return promise;
+      });
+
+    const onInterrupt = new Promise((_, reject) => {
+      watcher.on('change', state => {
+        if (state.interrupted) {
+          reject(new CancelRun());
+        }
+      });
+    });
+    const runAllTests = Promise.all(
+      tests.map(test =>
+        runTestInWorker(test)
+          .then(result => {
+            if (onResult) {
+              return onResult(test, result);
+            }
+
+            return this.eventEmitter.emit('test-file-success', [test, result]);
+          })
+          .catch(error => {
+            if (onFailure) {
+              return onFailure(test, error);
+            }
+
+            return this.eventEmitter.emit('test-file-failure', [test, error]);
+          })
+      )
+    );
+
+    const cleanup = async () => {
+      const {forceExited} = await worker.end();
+
+      if (forceExited) {
+        console.error(
+          _chalk().default.yellow(
+            'A worker process has failed to exit gracefully and has been force exited. ' +
+              'This is likely caused by tests leaking due to improper teardown. ' +
+              'Try running with --detectOpenHandles to find leaks. ' +
+              'Active timers can also cause this, ensure that .unref() was called on them.'
+          )
+        );
+      }
+    };
+
+    return Promise.race([runAllTests, onInterrupt]).then(cleanup, cleanup);
+  }
+
+  on(eventName, listener) {
+    return this.eventEmitter.on(eventName, listener);
+  }
+}
+
+exports.default = TestRunner;
+
+class CancelRun extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'CancelRun';
+  }
+}
diff --git a/node_modules/jest-runner/build/runTest.d.ts b/node_modules/jest-runner/build/runTest.d.ts
new file mode 100644
index 0000000..e7fb746
--- /dev/null
+++ b/node_modules/jest-runner/build/runTest.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 { TestFileEvent, TestResult } from '@jest/test-result';
+import type { Config } from '@jest/types';
+import Resolver from 'jest-resolve';
+import type { TestRunnerContext } from './types';
+export default function runTest(path: Config.Path, globalConfig: Config.GlobalConfig, config: Config.ProjectConfig, resolver: Resolver, context?: TestRunnerContext, sendMessageToJest?: TestFileEvent): Promise<TestResult>;
diff --git a/node_modules/jest-runner/build/runTest.js b/node_modules/jest-runner/build/runTest.js
new file mode 100644
index 0000000..1631e75
--- /dev/null
+++ b/node_modules/jest-runner/build/runTest.js
@@ -0,0 +1,494 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = runTest;
+
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+
+  _chalk = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function fs() {
+  const data = _interopRequireWildcard(require('graceful-fs'));
+
+  fs = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _sourceMapSupport() {
+  const data = _interopRequireDefault(require('source-map-support'));
+
+  _sourceMapSupport = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _console() {
+  const data = require('@jest/console');
+
+  _console = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _transform() {
+  const data = require('@jest/transform');
+
+  _transform = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function docblock() {
+  const data = _interopRequireWildcard(require('jest-docblock'));
+
+  docblock = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestLeakDetector() {
+  const data = _interopRequireDefault(require('jest-leak-detector'));
+
+  _jestLeakDetector = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestMessageUtil() {
+  const data = require('jest-message-util');
+
+  _jestMessageUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestResolve() {
+  const data = require('jest-resolve');
+
+  _jestResolve = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== 'function') return null;
+  var cacheBabelInterop = new WeakMap();
+  var cacheNodeInterop = new WeakMap();
+  return (_getRequireWildcardCache = function (nodeInterop) {
+    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+
+function _interopRequireWildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
+    return {default: obj};
+  }
+  var cache = _getRequireWildcardCache(nodeInterop);
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor
+        ? Object.getOwnPropertyDescriptor(obj, key)
+        : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+
+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 freezeConsole(testConsole, config) {
+  // @ts-expect-error: `_log` is `private` - we should figure out some proper API here
+  testConsole._log = function fakeConsolePush(_type, message) {
+    const error = new (_jestUtil().ErrorWithStack)(
+      `${_chalk().default.red(
+        `${_chalk().default.bold(
+          'Cannot log after tests are done.'
+        )} Did you forget to wait for something async in your test?`
+      )}\nAttempted to log "${message}".`,
+      fakeConsolePush
+    );
+    const formattedError = (0, _jestMessageUtil().formatExecError)(
+      error,
+      config,
+      {
+        noStackTrace: false
+      },
+      undefined,
+      true
+    );
+    process.stderr.write('\n' + formattedError + '\n');
+    process.exitCode = 1;
+  };
+} // Keeping the core of "runTest" as a separate function (as "runTestInternal")
+// is key to be able to detect memory leaks. Since all variables are local to
+// the function, when "runTestInternal" finishes its execution, they can all be
+// freed, UNLESS something else is leaking them (and that's why we can detect
+// the leak!).
+//
+// If we had all the code in a single function, we should manually nullify all
+// references to verify if there is a leak, which is not maintainable and error
+// prone. That's why "runTestInternal" CANNOT be inlined inside "runTest".
+
+async function runTestInternal(
+  path,
+  globalConfig,
+  config,
+  resolver,
+  context,
+  sendMessageToJest
+) {
+  const testSource = fs().readFileSync(path, 'utf8');
+  const docblockPragmas = docblock().parse(docblock().extract(testSource));
+  const customEnvironment = docblockPragmas['jest-environment'];
+  let testEnvironment = config.testEnvironment;
+
+  if (customEnvironment) {
+    if (Array.isArray(customEnvironment)) {
+      throw new Error(
+        `You can only define a single test environment through docblocks, got "${customEnvironment.join(
+          ', '
+        )}"`
+      );
+    }
+
+    testEnvironment = (0, _jestResolve().resolveTestEnvironment)({
+      ...config,
+      requireResolveFunction: require.resolve,
+      testEnvironment: customEnvironment
+    });
+  }
+
+  const cacheFS = new Map([[path, testSource]]);
+  const transformer = await (0, _transform().createScriptTransformer)(
+    config,
+    cacheFS
+  );
+  const TestEnvironment = await transformer.requireAndTranspileModule(
+    testEnvironment
+  );
+  const testFramework = await transformer.requireAndTranspileModule(
+    process.env.JEST_JASMINE === '1'
+      ? require.resolve('jest-jasmine2')
+      : config.testRunner
+  );
+  const Runtime = (0, _jestUtil().interopRequireDefault)(
+    config.moduleLoader ? require(config.moduleLoader) : require('jest-runtime')
+  ).default;
+  const consoleOut = globalConfig.useStderr ? process.stderr : process.stdout;
+
+  const consoleFormatter = (type, message) =>
+    (0, _console().getConsoleOutput)(
+      // 4 = the console call is buried 4 stack frames deep
+      _console().BufferedConsole.write([], type, message, 4),
+      config,
+      globalConfig
+    );
+
+  let testConsole;
+
+  if (globalConfig.silent) {
+    testConsole = new (_console().NullConsole)(
+      consoleOut,
+      consoleOut,
+      consoleFormatter
+    );
+  } else if (globalConfig.verbose) {
+    testConsole = new (_console().CustomConsole)(
+      consoleOut,
+      consoleOut,
+      consoleFormatter
+    );
+  } else {
+    testConsole = new (_console().BufferedConsole)();
+  }
+
+  const environment = new TestEnvironment(config, {
+    console: testConsole,
+    docblockPragmas,
+    testPath: path
+  });
+
+  if (typeof environment.getVmContext !== 'function') {
+    console.error(
+      `Test environment found at "${testEnvironment}" does not export a "getVmContext" method, which is mandatory from Jest 27. This method is a replacement for "runScript".`
+    );
+    process.exit(1);
+  }
+
+  const leakDetector = config.detectLeaks
+    ? new (_jestLeakDetector().default)(environment)
+    : null;
+  (0, _jestUtil().setGlobal)(environment.global, 'console', testConsole);
+  const runtime = new Runtime(
+    config,
+    environment,
+    resolver,
+    transformer,
+    cacheFS,
+    {
+      changedFiles:
+        context === null || context === void 0 ? void 0 : context.changedFiles,
+      collectCoverage: globalConfig.collectCoverage,
+      collectCoverageFrom: globalConfig.collectCoverageFrom,
+      collectCoverageOnlyFrom: globalConfig.collectCoverageOnlyFrom,
+      coverageProvider: globalConfig.coverageProvider,
+      sourcesRelatedToTestsInChangedFiles:
+        context === null || context === void 0
+          ? void 0
+          : context.sourcesRelatedToTestsInChangedFiles
+    },
+    path
+  );
+  const start = Date.now();
+
+  for (const path of config.setupFiles) {
+    const esm = runtime.unstable_shouldLoadAsEsm(path);
+
+    if (esm) {
+      await runtime.unstable_importModule(path);
+    } else {
+      runtime.requireModule(path);
+    }
+  }
+
+  const sourcemapOptions = {
+    environment: 'node',
+    handleUncaughtExceptions: false,
+    retrieveSourceMap: source => {
+      var _runtime$getSourceMap;
+
+      const sourceMapSource =
+        (_runtime$getSourceMap = runtime.getSourceMaps()) === null ||
+        _runtime$getSourceMap === void 0
+          ? void 0
+          : _runtime$getSourceMap.get(source);
+
+      if (sourceMapSource) {
+        try {
+          return {
+            map: JSON.parse(fs().readFileSync(sourceMapSource, 'utf8')),
+            url: source
+          };
+        } catch {}
+      }
+
+      return null;
+    }
+  }; // For tests
+
+  runtime
+    .requireInternalModule(
+      require.resolve('source-map-support'),
+      'source-map-support'
+    )
+    .install(sourcemapOptions); // For runtime errors
+
+  _sourceMapSupport().default.install(sourcemapOptions);
+
+  if (
+    environment.global &&
+    environment.global.process &&
+    environment.global.process.exit
+  ) {
+    const realExit = environment.global.process.exit;
+
+    environment.global.process.exit = function exit(...args) {
+      const error = new (_jestUtil().ErrorWithStack)(
+        `process.exit called with "${args.join(', ')}"`,
+        exit
+      );
+      const formattedError = (0, _jestMessageUtil().formatExecError)(
+        error,
+        config,
+        {
+          noStackTrace: false
+        },
+        undefined,
+        true
+      );
+      process.stderr.write(formattedError);
+      return realExit(...args);
+    };
+  } // if we don't have `getVmContext` on the env skip coverage
+
+  const collectV8Coverage =
+    globalConfig.coverageProvider === 'v8' &&
+    typeof environment.getVmContext === 'function';
+
+  try {
+    await environment.setup();
+    let result;
+
+    try {
+      if (collectV8Coverage) {
+        await runtime.collectV8Coverage();
+      }
+
+      result = await testFramework(
+        globalConfig,
+        config,
+        environment,
+        runtime,
+        path,
+        sendMessageToJest
+      );
+    } catch (err) {
+      // Access stack before uninstalling sourcemaps
+      err.stack;
+      throw err;
+    } finally {
+      if (collectV8Coverage) {
+        await runtime.stopCollectingV8Coverage();
+      }
+    }
+
+    freezeConsole(testConsole, config);
+    const testCount =
+      result.numPassingTests +
+      result.numFailingTests +
+      result.numPendingTests +
+      result.numTodoTests;
+    const end = Date.now();
+    const testRuntime = end - start;
+    result.perfStats = {
+      end,
+      runtime: testRuntime,
+      slow: testRuntime / 1000 > config.slowTestThreshold,
+      start
+    };
+    result.testFilePath = path;
+    result.console = testConsole.getBuffer();
+    result.skipped = testCount === result.numPendingTests;
+    result.displayName = config.displayName;
+    const coverage = runtime.getAllCoverageInfoCopy();
+
+    if (coverage) {
+      const coverageKeys = Object.keys(coverage);
+
+      if (coverageKeys.length) {
+        result.coverage = coverage;
+      }
+    }
+
+    if (collectV8Coverage) {
+      const v8Coverage = runtime.getAllV8CoverageInfoCopy();
+
+      if (v8Coverage && v8Coverage.length > 0) {
+        result.v8Coverage = v8Coverage;
+      }
+    }
+
+    if (globalConfig.logHeapUsage) {
+      if (global.gc) {
+        global.gc();
+      }
+
+      result.memoryUsage = process.memoryUsage().heapUsed;
+    } // Delay the resolution to allow log messages to be output.
+
+    return new Promise(resolve => {
+      setImmediate(() =>
+        resolve({
+          leakDetector,
+          result
+        })
+      );
+    });
+  } finally {
+    runtime.teardown();
+    await environment.teardown();
+
+    _sourceMapSupport().default.resetRetrieveHandlers();
+  }
+}
+
+async function runTest(
+  path,
+  globalConfig,
+  config,
+  resolver,
+  context,
+  sendMessageToJest
+) {
+  const {leakDetector, result} = await runTestInternal(
+    path,
+    globalConfig,
+    config,
+    resolver,
+    context,
+    sendMessageToJest
+  );
+
+  if (leakDetector) {
+    // We wanna allow a tiny but time to pass to allow last-minute cleanup
+    await new Promise(resolve => setTimeout(resolve, 100)); // Resolve leak detector, outside the "runTestInternal" closure.
+
+    result.leaks = await leakDetector.isLeaking();
+  } else {
+    result.leaks = false;
+  }
+
+  return result;
+}
diff --git a/node_modules/jest-runner/build/testWorker.d.ts b/node_modules/jest-runner/build/testWorker.d.ts
new file mode 100644
index 0000000..a74bb88
--- /dev/null
+++ b/node_modules/jest-runner/build/testWorker.d.ts
@@ -0,0 +1,26 @@
+/**
+ * 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 { TestResult } from '@jest/test-result';
+import type { Config } from '@jest/types';
+import { SerializableModuleMap } from 'jest-haste-map';
+import type { TestRunnerSerializedContext } from './types';
+export declare type SerializableResolver = {
+    config: Config.ProjectConfig;
+    serializableModuleMap: SerializableModuleMap;
+};
+declare type WorkerData = {
+    config: Config.ProjectConfig;
+    globalConfig: Config.GlobalConfig;
+    path: Config.Path;
+    context?: TestRunnerSerializedContext;
+};
+export declare function setup(setupData: {
+    serializableResolvers: Array<SerializableResolver>;
+}): void;
+export declare function worker({ config, globalConfig, path, context, }: WorkerData): Promise<TestResult>;
+export {};
diff --git a/node_modules/jest-runner/build/testWorker.js b/node_modules/jest-runner/build/testWorker.js
new file mode 100644
index 0000000..2345443
--- /dev/null
+++ b/node_modules/jest-runner/build/testWorker.js
@@ -0,0 +1,150 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.setup = setup;
+exports.worker = worker;
+
+function _exit() {
+  const data = _interopRequireDefault(require('exit'));
+
+  _exit = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestHasteMap() {
+  const data = _interopRequireDefault(require('jest-haste-map'));
+
+  _jestHasteMap = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestMessageUtil() {
+  const data = require('jest-message-util');
+
+  _jestMessageUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestRuntime() {
+  const data = _interopRequireDefault(require('jest-runtime'));
+
+  _jestRuntime = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestWorker() {
+  const data = require('jest-worker');
+
+  _jestWorker = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _runTest = _interopRequireDefault(require('./runTest'));
+
+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.
+ *
+ */
+// Make sure uncaught errors are logged before we exit.
+process.on('uncaughtException', err => {
+  console.error(err.stack);
+  (0, _exit().default)(1);
+});
+
+const formatError = error => {
+  if (typeof error === 'string') {
+    const {message, stack} = (0, _jestMessageUtil().separateMessageFromStack)(
+      error
+    );
+    return {
+      message,
+      stack,
+      type: 'Error'
+    };
+  }
+
+  return {
+    code: error.code || undefined,
+    message: error.message,
+    stack: error.stack,
+    type: 'Error'
+  };
+};
+
+const resolvers = new Map();
+
+const getResolver = config => {
+  const resolver = resolvers.get(config.name);
+
+  if (!resolver) {
+    throw new Error('Cannot find resolver for: ' + config.name);
+  }
+
+  return resolver;
+};
+
+function setup(setupData) {
+  // Module maps that will be needed for the test runs are passed.
+  for (const {
+    config,
+    serializableModuleMap
+  } of setupData.serializableResolvers) {
+    const moduleMap = _jestHasteMap()
+      .default.getStatic(config)
+      .getModuleMapFromJSON(serializableModuleMap);
+
+    resolvers.set(
+      config.name,
+      _jestRuntime().default.createResolver(config, moduleMap)
+    );
+  }
+}
+
+const sendMessageToJest = (eventName, args) => {
+  (0, _jestWorker().messageParent)([eventName, args]);
+};
+
+async function worker({config, globalConfig, path, context}) {
+  try {
+    return await (0, _runTest.default)(
+      path,
+      globalConfig,
+      config,
+      getResolver(config),
+      context && {
+        ...context,
+        changedFiles: context.changedFiles && new Set(context.changedFiles),
+        sourcesRelatedToTestsInChangedFiles:
+          context.sourcesRelatedToTestsInChangedFiles &&
+          new Set(context.sourcesRelatedToTestsInChangedFiles)
+      },
+      sendMessageToJest
+    );
+  } catch (error) {
+    throw formatError(error);
+  }
+}
diff --git a/node_modules/jest-runner/build/types.d.ts b/node_modules/jest-runner/build/types.d.ts
new file mode 100644
index 0000000..d972415
--- /dev/null
+++ b/node_modules/jest-runner/build/types.d.ts
@@ -0,0 +1,41 @@
+/**
+ * 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');
+import type { JestEnvironment } from '@jest/environment';
+import type { SerializableError, Test, TestFileEvent, TestResult } from '@jest/test-result';
+import type { Config } from '@jest/types';
+import type RuntimeType from 'jest-runtime';
+export declare type ErrorWithCode = Error & {
+    code?: string;
+};
+export declare type OnTestStart = (test: Test) => Promise<void>;
+export declare type OnTestFailure = (test: Test, serializableError: SerializableError) => Promise<void>;
+export declare type OnTestSuccess = (test: Test, testResult: TestResult) => Promise<void>;
+export declare type TestFramework = (globalConfig: Config.GlobalConfig, config: Config.ProjectConfig, environment: JestEnvironment, runtime: RuntimeType, testPath: string, sendMessageToJest?: TestFileEvent) => Promise<TestResult>;
+export declare type TestRunnerOptions = {
+    serial: boolean;
+};
+export declare type TestRunnerContext = {
+    changedFiles?: Set<Config.Path>;
+    sourcesRelatedToTestsInChangedFiles?: Set<Config.Path>;
+};
+export declare type TestRunnerSerializedContext = {
+    changedFiles?: Array<Config.Path>;
+    sourcesRelatedToTestsInChangedFiles?: Array<Config.Path>;
+};
+declare type WatcherState = {
+    interrupted: boolean;
+};
+export interface TestWatcher extends Emittery<{
+    change: WatcherState;
+}> {
+    state: WatcherState;
+    setState(state: WatcherState): void;
+    isInterrupted(): boolean;
+    isWatchMode(): boolean;
+}
+export {};
diff --git a/node_modules/jest-runner/build/types.js b/node_modules/jest-runner/build/types.js
new file mode 100644
index 0000000..9ddbe87
--- /dev/null
+++ b/node_modules/jest-runner/build/types.js
@@ -0,0 +1,15 @@
+'use strict';
+
+function _emittery() {
+  const data = _interopRequireDefault(require('emittery'));
+
+  _emittery = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}