Add node modules and compiled JavaScript from main

node_modules/jest-runner/LICENSE

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

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

@@ -0,0 +1,35 @@
+/**
+ * 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 { Config } from '@jest/types';
+import type { OnTestFailure as JestOnTestFailure, OnTestStart as JestOnTestStart, OnTestSuccess as JestOnTestSuccess, Test as JestTest, TestEvents as JestTestEvents, TestFileEvent as JestTestFileEvent, TestRunnerContext as JestTestRunnerContext, TestRunnerOptions as JestTestRunnerOptions, TestWatcher as JestTestWatcher } from './types';
+declare namespace TestRunner {
+    type Test = JestTest;
+    type OnTestFailure = JestOnTestFailure;
+    type OnTestStart = JestOnTestStart;
+    type OnTestSuccess = JestOnTestSuccess;
+    type TestWatcher = JestTestWatcher;
+    type TestRunnerContext = JestTestRunnerContext;
+    type TestRunnerOptions = JestTestRunnerOptions;
+    type TestFileEvent = JestTestFileEvent;
+}
+declare 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?: JestTestRunnerContext);
+    runTests(tests: Array<JestTest>, watcher: JestTestWatcher, onStart: JestOnTestStart | undefined, onResult: JestOnTestSuccess | undefined, onFailure: JestOnTestFailure | undefined, options: JestTestRunnerOptions): Promise<void>;
+    private _createInBandTestRun;
+    private _createParallelTestRun;
+    on: {
+        <Name extends "test-file-start" | "test-file-success" | "test-file-failure" | "test-case-result">(eventName: Name, listener: (eventData: JestTestEvents[Name]) => void): Emittery.UnsubscribeFn;
+        <Name_1 extends never>(eventName: Name_1, listener: () => void): Emittery.UnsubscribeFn;
+    };
+}
+export = TestRunner;

node_modules/jest-runner/build/index.js

@@ -0,0 +1,319 @@
+'use strict';
+
+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 _exit() {
+  const data = _interopRequireDefault(require('exit'));
+
+  _exit = 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 = _interopRequireDefault(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.Typed)());
+
+    _defineProperty(
+      this,
+      '__PRIVATE_UNSTABLE_API_supportsEventEmitters__',
+      true
+    );
+
+    _defineProperty(this, 'isSerial', void 0);
+
+    _defineProperty(this, 'on', this.eventEmitter.on.bind(this.eventEmitter));
+
+    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();
+              }
+
+              let sendMessageToJest; // 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
+                );
+              } else {
+                // `deepCyclicCopy` used here to avoid mem-leak
+                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);
+              } else {
+                return this.eventEmitter.emit('test-file-success', [
+                  test,
+                  result
+                ]);
+              }
+            })
+            .catch(err => {
+              if (onFailure) {
+                return onFailure(test, err);
+              } else {
+                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().default)(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 onError = async (err, test) => {
+      // Remove `if(onFailure)` in Jest 27
+      if (onFailure) {
+        await onFailure(test, err);
+      } else {
+        await this.eventEmitter.emit('test-file-failure', [test, err]);
+      }
+
+      if (err.type === 'ProcessTerminatedError') {
+        console.error(
+          'A worker process has quit unexpectedly! ' +
+            'Most likely this is an initialization error.'
+        );
+        (0, _exit().default)(1);
+      }
+    };
+
+    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);
+            } else {
+              return this.eventEmitter.emit('test-file-success', [
+                test,
+                result
+              ]);
+            }
+          })
+          .catch(error => onError(error, test))
+      )
+    );
+
+    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.'
+          )
+        );
+      }
+    };
+
+    return Promise.race([runAllTests, onInterrupt]).then(cleanup, cleanup);
+  }
+}
+
+class CancelRun extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'CancelRun';
+  }
+}
+
+module.exports = TestRunner;

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 { TestResult } from '@jest/test-result';
+import type { Config } from '@jest/types';
+import type { ResolverType } from 'jest-resolve';
+import type { TestFileEvent, TestRunnerContext } from './types';
+export default function runTest(path: Config.Path, globalConfig: Config.GlobalConfig, config: Config.ProjectConfig, resolver: ResolverType, context?: TestRunnerContext, sendMessageToJest?: TestFileEvent): Promise<TestResult>;

node_modules/jest-runner/build/runTest.js

@@ -0,0 +1,491 @@
+'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 _jestConfig() {
+  const data = require('jest-config');
+
+  _jestConfig = 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 _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;
+}
+
+function _getRequireWildcardCache() {
+  if (typeof WeakMap !== 'function') return null;
+  var cache = new WeakMap();
+  _getRequireWildcardCache = function () {
+    return cache;
+  };
+  return cache;
+}
+
+function _interopRequireWildcard(obj) {
+  if (obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
+    return {default: obj};
+  }
+  var cache = _getRequireWildcardCache();
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor
+        ? Object.getOwnPropertyDescriptor(obj, key)
+        : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+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'); // TODO: set exit code in Jest 25
+    // 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, _jestConfig().getTestEnvironment)({
+      ...config,
+      testEnvironment: customEnvironment
+    });
+  }
+
+  const TestEnvironment = (0, _jestUtil().interopRequireDefault)(
+    require(testEnvironment)
+  ).default;
+  const testFramework = (0, _jestUtil().interopRequireDefault)(
+    process.env.JEST_CIRCUS === '1' // eslint-disable-next-line import/no-extraneous-dependencies
+      ? require('jest-circus/runner')
+      : require(config.testRunner)
+  ).default;
+  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)(
+      config.cwd,
+      !!globalConfig.verbose, // 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
+  });
+  const leakDetector = config.detectLeaks
+    ? new (_jestLeakDetector().default)(environment)
+    : null;
+  const cacheFS = {
+    [path]: testSource
+  };
+  (0, _jestUtil().setGlobal)(environment.global, 'console', testConsole);
+  const runtime = new Runtime(
+    config,
+    environment,
+    resolver,
+    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) {
+    var _runtime$unstable_sho;
+
+    // TODO: remove ? in Jest 26
+    const esm =
+      (_runtime$unstable_sho = runtime.unstable_shouldLoadAsEsm) === null ||
+      _runtime$unstable_sho === void 0
+        ? void 0
+        : _runtime$unstable_sho.call(runtime, path);
+
+    if (esm) {
+      await runtime.unstable_importModule(path);
+    } else {
+      runtime.requireModule(path);
+    }
+  }
+
+  const sourcemapOptions = {
+    environment: 'node',
+    handleUncaughtExceptions: false,
+    retrieveSourceMap: source => {
+      const sourceMaps = runtime.getSourceMaps();
+      const sourceMapSource = sourceMaps && sourceMaps[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 {
+    var _runtime$teardown;
+
+    await environment.teardown(); // TODO: this function might be missing, remove ? in Jest 26
+
+    (_runtime$teardown = runtime.teardown) === null ||
+    _runtime$teardown === void 0
+      ? void 0
+      : _runtime$teardown.call(runtime);
+
+    _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;
+}

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 HasteMap = require('jest-haste-map');
+import type { TestRunnerSerializedContext } from './types';
+export declare type SerializableResolver = {
+    config: Config.ProjectConfig;
+    serializableModuleMap: HasteMap.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 {};

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.ModuleMap.fromJSON(
+      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);
+  }
+}

node_modules/jest-runner/build/types.d.ts

@@ -0,0 +1,59 @@
+/**
+ * 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 { EventEmitter } from 'events';
+import type { JestEnvironment } from '@jest/environment';
+import type { AssertionResult, SerializableError, TestResult } from '@jest/test-result';
+import type { Config } from '@jest/types';
+import type { FS as HasteFS, ModuleMap } from 'jest-haste-map';
+import type { ResolverType } from 'jest-resolve';
+import type { RuntimeType } from 'jest-runtime';
+export declare type ErrorWithCode = Error & {
+    code?: string;
+};
+export declare type Test = {
+    context: Context;
+    duration?: number;
+    path: Config.Path;
+};
+export declare type Context = {
+    config: Config.ProjectConfig;
+    hasteFS: HasteFS;
+    moduleMap: ModuleMap;
+    resolver: ResolverType;
+};
+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 TestEvents = {
+    'test-file-start': [Test];
+    'test-file-success': [Test, TestResult];
+    'test-file-failure': [Test, SerializableError];
+    'test-case-result': [Config.Path, AssertionResult];
+};
+export declare type TestFileEvent<T extends keyof TestEvents = keyof TestEvents> = (eventName: T, args: TestEvents[T]) => unknown;
+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>;
+};
+export declare type WatcherState = {
+    interrupted: boolean;
+};
+export interface TestWatcher extends EventEmitter {
+    state: WatcherState;
+    setState(state: WatcherState): void;
+    isInterrupted(): boolean;
+    isWatchMode(): boolean;
+}

node_modules/jest-runner/build/types.js

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

node_modules/jest-runner/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "jest-runner",
+  "version": "26.6.3",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/facebook/jest.git",
+    "directory": "packages/jest-runner"
+  },
+  "license": "MIT",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "dependencies": {
+    "@jest/console": "^26.6.2",
+    "@jest/environment": "^26.6.2",
+    "@jest/test-result": "^26.6.2",
+    "@jest/types": "^26.6.2",
+    "@types/node": "*",
+    "chalk": "^4.0.0",
+    "emittery": "^0.7.1",
+    "exit": "^0.1.2",
+    "graceful-fs": "^4.2.4",
+    "jest-config": "^26.6.3",
+    "jest-docblock": "^26.0.0",
+    "jest-haste-map": "^26.6.2",
+    "jest-leak-detector": "^26.6.2",
+    "jest-message-util": "^26.6.2",
+    "jest-resolve": "^26.6.2",
+    "jest-runtime": "^26.6.3",
+    "jest-util": "^26.6.2",
+    "jest-worker": "^26.6.2",
+    "source-map-support": "^0.5.6",
+    "throat": "^5.0.0"
+  },
+  "devDependencies": {
+    "@types/exit": "^0.1.30",
+    "@types/graceful-fs": "^4.1.2",
+    "@types/source-map-support": "^0.5.0",
+    "jest-circus": "^26.6.3"
+  },
+  "engines": {
+    "node": ">= 10.14.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "2f6931e91d5ab126de70caf150c68709752e7f6c"
+}