Added node_modules for the updating to work properly.

10 files changed, 1129 insertions, 0 deletions

diff --git a/node_modules/jest-worker/build/workers/ChildProcessWorker.d.ts b/node_modules/jest-worker/build/workers/ChildProcessWorker.d.ts
new file mode 100644
index 0000000..4a8dcf1
--- /dev/null
+++ b/node_modules/jest-worker/build/workers/ChildProcessWorker.d.ts
@@ -0,0 +1,51 @@
+/**
+ * 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 { ChildMessage, OnCustomMessage, OnEnd, OnStart, WorkerInterface, WorkerOptions } from '../types';
+/**
+ * This class wraps the child process and provides a nice interface to
+ * communicate with. It takes care of:
+ *
+ *  - Re-spawning the process if it dies.
+ *  - Queues calls while the worker is busy.
+ *  - Re-sends the requests if the worker blew up.
+ *
+ * The reason for queueing them here (since childProcess.send also has an
+ * internal queue) is because the worker could be doing asynchronous work, and
+ * this would lead to the child process to read its receiving buffer and start a
+ * second call. By queueing calls here, we don't send the next call to the
+ * children until we receive the result of the previous one.
+ *
+ * As soon as a request starts to be processed by a worker, its "processed"
+ * field is changed to "true", so that other workers which might encounter the
+ * same call skip it.
+ */
+export default class ChildProcessWorker implements WorkerInterface {
+    private _child;
+    private _options;
+    private _request;
+    private _retries;
+    private _onProcessEnd;
+    private _onCustomMessage;
+    private _fakeStream;
+    private _stdout;
+    private _stderr;
+    private _exitPromise;
+    private _resolveExitPromise;
+    constructor(options: WorkerOptions);
+    initialize(): void;
+    private _shutdown;
+    private _onMessage;
+    private _onExit;
+    send(request: ChildMessage, onProcessStart: OnStart, onProcessEnd: OnEnd, onCustomMessage: OnCustomMessage): void;
+    waitForExit(): Promise<void>;
+    forceExit(): void;
+    getWorkerId(): number;
+    getStdout(): NodeJS.ReadableStream | null;
+    getStderr(): NodeJS.ReadableStream | null;
+    private _getFakeStream;
+}
diff --git a/node_modules/jest-worker/build/workers/ChildProcessWorker.js b/node_modules/jest-worker/build/workers/ChildProcessWorker.js
new file mode 100644
index 0000000..f8a42c9
--- /dev/null
+++ b/node_modules/jest-worker/build/workers/ChildProcessWorker.js
@@ -0,0 +1,333 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+function _child_process() {
+  const data = require('child_process');
+
+  _child_process = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _stream() {
+  const data = require('stream');
+
+  _stream = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _mergeStream() {
+  const data = _interopRequireDefault(require('merge-stream'));
+
+  _mergeStream = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _supportsColor() {
+  const data = require('supports-color');
+
+  _supportsColor = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _types = require('../types');
+
+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 SIGNAL_BASE_EXIT_CODE = 128;
+const SIGKILL_EXIT_CODE = SIGNAL_BASE_EXIT_CODE + 9;
+const SIGTERM_EXIT_CODE = SIGNAL_BASE_EXIT_CODE + 15; // How long to wait after SIGTERM before sending SIGKILL
+
+const SIGKILL_DELAY = 500;
+/**
+ * This class wraps the child process and provides a nice interface to
+ * communicate with. It takes care of:
+ *
+ *  - Re-spawning the process if it dies.
+ *  - Queues calls while the worker is busy.
+ *  - Re-sends the requests if the worker blew up.
+ *
+ * The reason for queueing them here (since childProcess.send also has an
+ * internal queue) is because the worker could be doing asynchronous work, and
+ * this would lead to the child process to read its receiving buffer and start a
+ * second call. By queueing calls here, we don't send the next call to the
+ * children until we receive the result of the previous one.
+ *
+ * As soon as a request starts to be processed by a worker, its "processed"
+ * field is changed to "true", so that other workers which might encounter the
+ * same call skip it.
+ */
+
+class ChildProcessWorker {
+  constructor(options) {
+    _defineProperty(this, '_child', void 0);
+
+    _defineProperty(this, '_options', void 0);
+
+    _defineProperty(this, '_request', void 0);
+
+    _defineProperty(this, '_retries', void 0);
+
+    _defineProperty(this, '_onProcessEnd', void 0);
+
+    _defineProperty(this, '_onCustomMessage', void 0);
+
+    _defineProperty(this, '_fakeStream', void 0);
+
+    _defineProperty(this, '_stdout', void 0);
+
+    _defineProperty(this, '_stderr', void 0);
+
+    _defineProperty(this, '_exitPromise', void 0);
+
+    _defineProperty(this, '_resolveExitPromise', void 0);
+
+    this._options = options;
+    this._request = null;
+    this._fakeStream = null;
+    this._stdout = null;
+    this._stderr = null;
+    this._exitPromise = new Promise(resolve => {
+      this._resolveExitPromise = resolve;
+    });
+    this.initialize();
+  }
+
+  initialize() {
+    const forceColor = _supportsColor().stdout
+      ? {
+          FORCE_COLOR: '1'
+        }
+      : {};
+    const child = (0, _child_process().fork)(
+      require.resolve('./processChild'),
+      [],
+      {
+        cwd: process.cwd(),
+        env: {
+          ...process.env,
+          JEST_WORKER_ID: String(this._options.workerId + 1),
+          // 0-indexed workerId, 1-indexed JEST_WORKER_ID
+          ...forceColor
+        },
+        // Suppress --debug / --inspect flags while preserving others (like --harmony).
+        execArgv: process.execArgv.filter(v => !/^--(debug|inspect)/.test(v)),
+        silent: true,
+        ...this._options.forkOptions
+      }
+    );
+
+    if (child.stdout) {
+      if (!this._stdout) {
+        // We need to add a permanent stream to the merged stream to prevent it
+        // from ending when the subprocess stream ends
+        this._stdout = (0, _mergeStream().default)(this._getFakeStream());
+      }
+
+      this._stdout.add(child.stdout);
+    }
+
+    if (child.stderr) {
+      if (!this._stderr) {
+        // We need to add a permanent stream to the merged stream to prevent it
+        // from ending when the subprocess stream ends
+        this._stderr = (0, _mergeStream().default)(this._getFakeStream());
+      }
+
+      this._stderr.add(child.stderr);
+    }
+
+    child.on('message', this._onMessage.bind(this));
+    child.on('exit', this._onExit.bind(this));
+    child.send([
+      _types.CHILD_MESSAGE_INITIALIZE,
+      false,
+      this._options.workerPath,
+      this._options.setupArgs
+    ]);
+    this._child = child;
+    this._retries++; // If we exceeded the amount of retries, we will emulate an error reply
+    // coming from the child. This avoids code duplication related with cleaning
+    // the queue, and scheduling the next call.
+
+    if (this._retries > this._options.maxRetries) {
+      const error = new Error(
+        `Jest worker encountered ${this._retries} child process exceptions, exceeding retry limit`
+      );
+
+      this._onMessage([
+        _types.PARENT_MESSAGE_CLIENT_ERROR,
+        error.name,
+        error.message,
+        error.stack,
+        {
+          type: 'WorkerError'
+        }
+      ]);
+    }
+  }
+
+  _shutdown() {
+    // End the temporary streams so the merged streams end too
+    if (this._fakeStream) {
+      this._fakeStream.end();
+
+      this._fakeStream = null;
+    }
+
+    this._resolveExitPromise();
+  }
+
+  _onMessage(response) {
+    // TODO: Add appropriate type check
+    let error;
+
+    switch (response[0]) {
+      case _types.PARENT_MESSAGE_OK:
+        this._onProcessEnd(null, response[1]);
+
+        break;
+
+      case _types.PARENT_MESSAGE_CLIENT_ERROR:
+        error = response[4];
+
+        if (error != null && typeof error === 'object') {
+          const extra = error; // @ts-expect-error: no index
+
+          const NativeCtor = global[response[1]];
+          const Ctor = typeof NativeCtor === 'function' ? NativeCtor : Error;
+          error = new Ctor(response[2]);
+          error.type = response[1];
+          error.stack = response[3];
+
+          for (const key in extra) {
+            error[key] = extra[key];
+          }
+        }
+
+        this._onProcessEnd(error, null);
+
+        break;
+
+      case _types.PARENT_MESSAGE_SETUP_ERROR:
+        error = new Error('Error when calling setup: ' + response[2]);
+        error.type = response[1];
+        error.stack = response[3];
+
+        this._onProcessEnd(error, null);
+
+        break;
+
+      case _types.PARENT_MESSAGE_CUSTOM:
+        this._onCustomMessage(response[1]);
+
+        break;
+
+      default:
+        throw new TypeError('Unexpected response from worker: ' + response[0]);
+    }
+  }
+
+  _onExit(exitCode) {
+    if (
+      exitCode !== 0 &&
+      exitCode !== null &&
+      exitCode !== SIGTERM_EXIT_CODE &&
+      exitCode !== SIGKILL_EXIT_CODE
+    ) {
+      this.initialize();
+
+      if (this._request) {
+        this._child.send(this._request);
+      }
+    } else {
+      this._shutdown();
+    }
+  }
+
+  send(request, onProcessStart, onProcessEnd, onCustomMessage) {
+    onProcessStart(this);
+
+    this._onProcessEnd = (...args) => {
+      // Clean the request to avoid sending past requests to workers that fail
+      // while waiting for a new request (timers, unhandled rejections...)
+      this._request = null;
+      return onProcessEnd(...args);
+    };
+
+    this._onCustomMessage = (...arg) => onCustomMessage(...arg);
+
+    this._request = request;
+    this._retries = 0;
+
+    this._child.send(request, () => {});
+  }
+
+  waitForExit() {
+    return this._exitPromise;
+  }
+
+  forceExit() {
+    this._child.kill('SIGTERM');
+
+    const sigkillTimeout = setTimeout(
+      () => this._child.kill('SIGKILL'),
+      SIGKILL_DELAY
+    );
+
+    this._exitPromise.then(() => clearTimeout(sigkillTimeout));
+  }
+
+  getWorkerId() {
+    return this._options.workerId;
+  }
+
+  getStdout() {
+    return this._stdout;
+  }
+
+  getStderr() {
+    return this._stderr;
+  }
+
+  _getFakeStream() {
+    if (!this._fakeStream) {
+      this._fakeStream = new (_stream().PassThrough)();
+    }
+
+    return this._fakeStream;
+  }
+}
+
+exports.default = ChildProcessWorker;
diff --git a/node_modules/jest-worker/build/workers/NodeThreadsWorker.d.ts b/node_modules/jest-worker/build/workers/NodeThreadsWorker.d.ts
new file mode 100644
index 0000000..4696ecc
--- /dev/null
+++ b/node_modules/jest-worker/build/workers/NodeThreadsWorker.d.ts
@@ -0,0 +1,34 @@
+/**
+ * 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 { ChildMessage, OnCustomMessage, OnEnd, OnStart, WorkerInterface, WorkerOptions } from '../types';
+export default class ExperimentalWorker implements WorkerInterface {
+    private _worker;
+    private _options;
+    private _request;
+    private _retries;
+    private _onProcessEnd;
+    private _onCustomMessage;
+    private _fakeStream;
+    private _stdout;
+    private _stderr;
+    private _exitPromise;
+    private _resolveExitPromise;
+    private _forceExited;
+    constructor(options: WorkerOptions);
+    initialize(): void;
+    private _shutdown;
+    private _onMessage;
+    private _onExit;
+    waitForExit(): Promise<void>;
+    forceExit(): void;
+    send(request: ChildMessage, onProcessStart: OnStart, onProcessEnd: OnEnd | null, onCustomMessage: OnCustomMessage): void;
+    getWorkerId(): number;
+    getStdout(): NodeJS.ReadableStream | null;
+    getStderr(): NodeJS.ReadableStream | null;
+    private _getFakeStream;
+}
diff --git a/node_modules/jest-worker/build/workers/NodeThreadsWorker.js b/node_modules/jest-worker/build/workers/NodeThreadsWorker.js
new file mode 100644
index 0000000..21b7dd2
--- /dev/null
+++ b/node_modules/jest-worker/build/workers/NodeThreadsWorker.js
@@ -0,0 +1,344 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+function path() {
+  const data = _interopRequireWildcard(require('path'));
+
+  path = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _stream() {
+  const data = require('stream');
+
+  _stream = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _worker_threads() {
+  const data = require('worker_threads');
+
+  _worker_threads = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _mergeStream() {
+  const data = _interopRequireDefault(require('merge-stream'));
+
+  _mergeStream = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _types = require('../types');
+
+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;
+}
+
+class ExperimentalWorker {
+  constructor(options) {
+    _defineProperty(this, '_worker', void 0);
+
+    _defineProperty(this, '_options', void 0);
+
+    _defineProperty(this, '_request', void 0);
+
+    _defineProperty(this, '_retries', void 0);
+
+    _defineProperty(this, '_onProcessEnd', void 0);
+
+    _defineProperty(this, '_onCustomMessage', void 0);
+
+    _defineProperty(this, '_fakeStream', void 0);
+
+    _defineProperty(this, '_stdout', void 0);
+
+    _defineProperty(this, '_stderr', void 0);
+
+    _defineProperty(this, '_exitPromise', void 0);
+
+    _defineProperty(this, '_resolveExitPromise', void 0);
+
+    _defineProperty(this, '_forceExited', void 0);
+
+    this._options = options;
+    this._request = null;
+    this._fakeStream = null;
+    this._stdout = null;
+    this._stderr = null;
+    this._exitPromise = new Promise(resolve => {
+      this._resolveExitPromise = resolve;
+    });
+    this._forceExited = false;
+    this.initialize();
+  }
+
+  initialize() {
+    this._worker = new (_worker_threads().Worker)(
+      path().resolve(__dirname, './threadChild.js'),
+      {
+        eval: false,
+        // @ts-expect-error: added in newer versions
+        resourceLimits: this._options.resourceLimits,
+        stderr: true,
+        stdout: true,
+        workerData: this._options.workerData,
+        ...this._options.forkOptions
+      }
+    );
+
+    if (this._worker.stdout) {
+      if (!this._stdout) {
+        // We need to add a permanent stream to the merged stream to prevent it
+        // from ending when the subprocess stream ends
+        this._stdout = (0, _mergeStream().default)(this._getFakeStream());
+      }
+
+      this._stdout.add(this._worker.stdout);
+    }
+
+    if (this._worker.stderr) {
+      if (!this._stderr) {
+        // We need to add a permanent stream to the merged stream to prevent it
+        // from ending when the subprocess stream ends
+        this._stderr = (0, _mergeStream().default)(this._getFakeStream());
+      }
+
+      this._stderr.add(this._worker.stderr);
+    }
+
+    this._worker.on('message', this._onMessage.bind(this));
+
+    this._worker.on('exit', this._onExit.bind(this));
+
+    this._worker.postMessage([
+      _types.CHILD_MESSAGE_INITIALIZE,
+      false,
+      this._options.workerPath,
+      this._options.setupArgs,
+      String(this._options.workerId + 1) // 0-indexed workerId, 1-indexed JEST_WORKER_ID
+    ]);
+
+    this._retries++; // If we exceeded the amount of retries, we will emulate an error reply
+    // coming from the child. This avoids code duplication related with cleaning
+    // the queue, and scheduling the next call.
+
+    if (this._retries > this._options.maxRetries) {
+      const error = new Error('Call retries were exceeded');
+
+      this._onMessage([
+        _types.PARENT_MESSAGE_CLIENT_ERROR,
+        error.name,
+        error.message,
+        error.stack,
+        {
+          type: 'WorkerError'
+        }
+      ]);
+    }
+  }
+
+  _shutdown() {
+    // End the permanent stream so the merged stream end too
+    if (this._fakeStream) {
+      this._fakeStream.end();
+
+      this._fakeStream = null;
+    }
+
+    this._resolveExitPromise();
+  }
+
+  _onMessage(response) {
+    let error;
+
+    switch (response[0]) {
+      case _types.PARENT_MESSAGE_OK:
+        this._onProcessEnd(null, response[1]);
+
+        break;
+
+      case _types.PARENT_MESSAGE_CLIENT_ERROR:
+        error = response[4];
+
+        if (error != null && typeof error === 'object') {
+          const extra = error; // @ts-expect-error: no index
+
+          const NativeCtor = global[response[1]];
+          const Ctor = typeof NativeCtor === 'function' ? NativeCtor : Error;
+          error = new Ctor(response[2]);
+          error.type = response[1];
+          error.stack = response[3];
+
+          for (const key in extra) {
+            // @ts-expect-error: no index
+            error[key] = extra[key];
+          }
+        }
+
+        this._onProcessEnd(error, null);
+
+        break;
+
+      case _types.PARENT_MESSAGE_SETUP_ERROR:
+        error = new Error('Error when calling setup: ' + response[2]); // @ts-expect-error: adding custom properties to errors.
+
+        error.type = response[1];
+        error.stack = response[3];
+
+        this._onProcessEnd(error, null);
+
+        break;
+
+      case _types.PARENT_MESSAGE_CUSTOM:
+        this._onCustomMessage(response[1]);
+
+        break;
+
+      default:
+        throw new TypeError('Unexpected response from worker: ' + response[0]);
+    }
+  }
+
+  _onExit(exitCode) {
+    if (exitCode !== 0 && !this._forceExited) {
+      this.initialize();
+
+      if (this._request) {
+        this._worker.postMessage(this._request);
+      }
+    } else {
+      this._shutdown();
+    }
+  }
+
+  waitForExit() {
+    return this._exitPromise;
+  }
+
+  forceExit() {
+    this._forceExited = true;
+
+    this._worker.terminate();
+  }
+
+  send(request, onProcessStart, onProcessEnd, onCustomMessage) {
+    onProcessStart(this);
+
+    this._onProcessEnd = (...args) => {
+      var _onProcessEnd;
+
+      // Clean the request to avoid sending past requests to workers that fail
+      // while waiting for a new request (timers, unhandled rejections...)
+      this._request = null;
+      const res =
+        (_onProcessEnd = onProcessEnd) === null || _onProcessEnd === void 0
+          ? void 0
+          : _onProcessEnd(...args); // Clean up the reference so related closures can be garbage collected.
+
+      onProcessEnd = null;
+      return res;
+    };
+
+    this._onCustomMessage = (...arg) => onCustomMessage(...arg);
+
+    this._request = request;
+    this._retries = 0;
+
+    this._worker.postMessage(request);
+  }
+
+  getWorkerId() {
+    return this._options.workerId;
+  }
+
+  getStdout() {
+    return this._stdout;
+  }
+
+  getStderr() {
+    return this._stderr;
+  }
+
+  _getFakeStream() {
+    if (!this._fakeStream) {
+      this._fakeStream = new (_stream().PassThrough)();
+    }
+
+    return this._fakeStream;
+  }
+}
+
+exports.default = ExperimentalWorker;
diff --git a/node_modules/jest-worker/build/workers/messageParent.d.ts b/node_modules/jest-worker/build/workers/messageParent.d.ts
new file mode 100644
index 0000000..795bb35
--- /dev/null
+++ b/node_modules/jest-worker/build/workers/messageParent.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 messageParent(message: unknown, parentProcess?: NodeJS.Process): void;
diff --git a/node_modules/jest-worker/build/workers/messageParent.js b/node_modules/jest-worker/build/workers/messageParent.js
new file mode 100644
index 0000000..51765ff
--- /dev/null
+++ b/node_modules/jest-worker/build/workers/messageParent.js
@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = messageParent;
+
+var _types = require('../types');
+
+/**
+ * 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 isWorkerThread = (() => {
+  try {
+    // `Require` here to support Node v10
+    const {isMainThread, parentPort} = require('worker_threads');
+
+    return !isMainThread && parentPort != null;
+  } catch {
+    return false;
+  }
+})();
+
+function messageParent(message, parentProcess = process) {
+  if (isWorkerThread) {
+    // `Require` here to support Node v10
+    const {parentPort} = require('worker_threads'); // ! is safe due to `null` check in `isWorkerThread`
+
+    parentPort.postMessage([_types.PARENT_MESSAGE_CUSTOM, message]);
+  } else if (typeof parentProcess.send === 'function') {
+    parentProcess.send([_types.PARENT_MESSAGE_CUSTOM, message]);
+  } else {
+    throw new Error('"messageParent" can only be used inside a worker');
+  }
+}
diff --git a/node_modules/jest-worker/build/workers/processChild.d.ts b/node_modules/jest-worker/build/workers/processChild.d.ts
new file mode 100644
index 0000000..fac0c7e
--- /dev/null
+++ b/node_modules/jest-worker/build/workers/processChild.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 {};
diff --git a/node_modules/jest-worker/build/workers/processChild.js b/node_modules/jest-worker/build/workers/processChild.js
new file mode 100644
index 0000000..fdf766e
--- /dev/null
+++ b/node_modules/jest-worker/build/workers/processChild.js
@@ -0,0 +1,148 @@
+'use strict';
+
+var _types = require('../types');
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+let file = null;
+let setupArgs = [];
+let initialized = false;
+/**
+ * This file is a small bootstrapper for workers. It sets up the communication
+ * between the worker and the parent process, interpreting parent messages and
+ * sending results back.
+ *
+ * The file loaded will be lazily initialized the first time any of the workers
+ * is called. This is done for optimal performance: if the farm is initialized,
+ * but no call is made to it, child Node processes will be consuming the least
+ * possible amount of memory.
+ *
+ * If an invalid message is detected, the child will exit (by throwing) with a
+ * non-zero exit code.
+ */
+
+const messageListener = request => {
+  switch (request[0]) {
+    case _types.CHILD_MESSAGE_INITIALIZE:
+      const init = request;
+      file = init[2];
+      setupArgs = request[3];
+      break;
+
+    case _types.CHILD_MESSAGE_CALL:
+      const call = request;
+      execMethod(call[2], call[3]);
+      break;
+
+    case _types.CHILD_MESSAGE_END:
+      end();
+      break;
+
+    default:
+      throw new TypeError(
+        'Unexpected request from parent process: ' + request[0]
+      );
+  }
+};
+
+process.on('message', messageListener);
+
+function reportSuccess(result) {
+  if (!process || !process.send) {
+    throw new Error('Child can only be used on a forked process');
+  }
+
+  process.send([_types.PARENT_MESSAGE_OK, result]);
+}
+
+function reportClientError(error) {
+  return reportError(error, _types.PARENT_MESSAGE_CLIENT_ERROR);
+}
+
+function reportInitializeError(error) {
+  return reportError(error, _types.PARENT_MESSAGE_SETUP_ERROR);
+}
+
+function reportError(error, type) {
+  if (!process || !process.send) {
+    throw new Error('Child can only be used on a forked process');
+  }
+
+  if (error == null) {
+    error = new Error('"null" or "undefined" thrown');
+  }
+
+  process.send([
+    type,
+    error.constructor && error.constructor.name,
+    error.message,
+    error.stack,
+    typeof error === 'object' ? {...error} : error
+  ]);
+}
+
+function end() {
+  const main = require(file);
+
+  if (!main.teardown) {
+    exitProcess();
+    return;
+  }
+
+  execFunction(main.teardown, main, [], exitProcess, exitProcess);
+}
+
+function exitProcess() {
+  // Clean up open handles so the process ideally exits gracefully
+  process.removeListener('message', messageListener);
+}
+
+function execMethod(method, args) {
+  const main = require(file);
+
+  let fn;
+
+  if (method === 'default') {
+    fn = main.__esModule ? main['default'] : main;
+  } else {
+    fn = main[method];
+  }
+
+  function execHelper() {
+    execFunction(fn, main, args, reportSuccess, reportClientError);
+  }
+
+  if (initialized || !main.setup) {
+    execHelper();
+    return;
+  }
+
+  initialized = true;
+  execFunction(main.setup, main, setupArgs, execHelper, reportInitializeError);
+}
+
+const isPromise = obj =>
+  !!obj &&
+  (typeof obj === 'object' || typeof obj === 'function') &&
+  typeof obj.then === 'function';
+
+function execFunction(fn, ctx, args, onResult, onError) {
+  let result;
+
+  try {
+    result = fn.apply(ctx, args);
+  } catch (err) {
+    onError(err);
+    return;
+  }
+
+  if (isPromise(result)) {
+    result.then(onResult, onError);
+  } else {
+    onResult(result);
+  }
+}
diff --git a/node_modules/jest-worker/build/workers/threadChild.d.ts b/node_modules/jest-worker/build/workers/threadChild.d.ts
new file mode 100644
index 0000000..fac0c7e
--- /dev/null
+++ b/node_modules/jest-worker/build/workers/threadChild.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 {};
diff --git a/node_modules/jest-worker/build/workers/threadChild.js b/node_modules/jest-worker/build/workers/threadChild.js
new file mode 100644
index 0000000..dae1e64
--- /dev/null
+++ b/node_modules/jest-worker/build/workers/threadChild.js
@@ -0,0 +1,159 @@
+'use strict';
+
+function _worker_threads() {
+  const data = require('worker_threads');
+
+  _worker_threads = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _types = require('../types');
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+let file = null;
+let setupArgs = [];
+let initialized = false;
+/**
+ * This file is a small bootstrapper for workers. It sets up the communication
+ * between the worker and the parent process, interpreting parent messages and
+ * sending results back.
+ *
+ * The file loaded will be lazily initialized the first time any of the workers
+ * is called. This is done for optimal performance: if the farm is initialized,
+ * but no call is made to it, child Node processes will be consuming the least
+ * possible amount of memory.
+ *
+ * If an invalid message is detected, the child will exit (by throwing) with a
+ * non-zero exit code.
+ */
+
+const messageListener = request => {
+  switch (request[0]) {
+    case _types.CHILD_MESSAGE_INITIALIZE:
+      const init = request;
+      file = init[2];
+      setupArgs = request[3];
+      process.env.JEST_WORKER_ID = request[4];
+      break;
+
+    case _types.CHILD_MESSAGE_CALL:
+      const call = request;
+      execMethod(call[2], call[3]);
+      break;
+
+    case _types.CHILD_MESSAGE_END:
+      end();
+      break;
+
+    default:
+      throw new TypeError(
+        'Unexpected request from parent process: ' + request[0]
+      );
+  }
+};
+
+_worker_threads().parentPort.on('message', messageListener);
+
+function reportSuccess(result) {
+  if (_worker_threads().isMainThread) {
+    throw new Error('Child can only be used on a forked process');
+  }
+
+  _worker_threads().parentPort.postMessage([_types.PARENT_MESSAGE_OK, result]);
+}
+
+function reportClientError(error) {
+  return reportError(error, _types.PARENT_MESSAGE_CLIENT_ERROR);
+}
+
+function reportInitializeError(error) {
+  return reportError(error, _types.PARENT_MESSAGE_SETUP_ERROR);
+}
+
+function reportError(error, type) {
+  if (_worker_threads().isMainThread) {
+    throw new Error('Child can only be used on a forked process');
+  }
+
+  if (error == null) {
+    error = new Error('"null" or "undefined" thrown');
+  }
+
+  _worker_threads().parentPort.postMessage([
+    type,
+    error.constructor && error.constructor.name,
+    error.message,
+    error.stack,
+    typeof error === 'object' ? {...error} : error
+  ]);
+}
+
+function end() {
+  const main = require(file);
+
+  if (!main.teardown) {
+    exitProcess();
+    return;
+  }
+
+  execFunction(main.teardown, main, [], exitProcess, exitProcess);
+}
+
+function exitProcess() {
+  // Clean up open handles so the worker ideally exits gracefully
+  _worker_threads().parentPort.removeListener('message', messageListener);
+}
+
+function execMethod(method, args) {
+  const main = require(file);
+
+  let fn;
+
+  if (method === 'default') {
+    fn = main.__esModule ? main['default'] : main;
+  } else {
+    fn = main[method];
+  }
+
+  function execHelper() {
+    execFunction(fn, main, args, reportSuccess, reportClientError);
+  }
+
+  if (initialized || !main.setup) {
+    execHelper();
+    return;
+  }
+
+  initialized = true;
+  execFunction(main.setup, main, setupArgs, execHelper, reportInitializeError);
+}
+
+const isPromise = obj =>
+  !!obj &&
+  (typeof obj === 'object' || typeof obj === 'function') &&
+  typeof obj.then === 'function';
+
+function execFunction(fn, ctx, args, onResult, onError) {
+  let result;
+
+  try {
+    result = fn.apply(ctx, args);
+  } catch (err) {
+    onError(err);
+    return;
+  }
+
+  if (isPromise(result)) {
+    result.then(onResult, onError);
+  } else {
+    onResult(result);
+  }
+}