First commit

node_modules/@jest/reporters/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/reporters/build/BaseReporter.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { AggregatedResult, TestCaseResult, TestResult } from '@jest/test-result';
+import type { Context, Reporter, ReporterOnStartOptions, Test } from './types';
+export default class BaseReporter implements Reporter {
+    private _error?;
+    log(message: string): void;
+    onRunStart(_results?: AggregatedResult, _options?: ReporterOnStartOptions): void;
+    onTestCaseResult(_test: Test, _testCaseResult: TestCaseResult): void;
+    onTestResult(_test?: Test, _testResult?: TestResult, _results?: AggregatedResult): void;
+    onTestStart(_test?: Test): void;
+    onRunComplete(_contexts?: Set<Context>, _aggregatedResults?: AggregatedResult): Promise<void> | void;
+    protected _setError(error: Error): void;
+    getLastError(): Error | undefined;
+}

node_modules/@jest/reporters/build/BaseReporter.js

@@ -0,0 +1,65 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+function _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+const {remove: preRunMessageRemove} = _jestUtil().preRunMessage;
+
+class BaseReporter {
+  constructor() {
+    _defineProperty(this, '_error', void 0);
+  }
+
+  log(message) {
+    process.stderr.write(message + '\n');
+  }
+
+  onRunStart(_results, _options) {
+    preRunMessageRemove(process.stderr);
+  }
+
+  onTestCaseResult(_test, _testCaseResult) {}
+
+  onTestResult(_test, _testResult, _results) {}
+
+  onTestStart(_test) {}
+
+  onRunComplete(_contexts, _aggregatedResults) {}
+
+  _setError(error) {
+    this._error = error;
+  } // Return an error that occurred during reporting. This error will
+  // define whether the test run was successful or failed.
+
+  getLastError() {
+    return this._error;
+  }
+}
+
+exports.default = BaseReporter;

node_modules/@jest/reporters/build/CoverageReporter.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { AggregatedResult, TestResult } from '@jest/test-result';
+import type { Config } from '@jest/types';
+import BaseReporter from './BaseReporter';
+import type { Context, CoverageReporterOptions, Test } from './types';
+export default class CoverageReporter extends BaseReporter {
+    private _coverageMap;
+    private _globalConfig;
+    private _sourceMapStore;
+    private _options;
+    private _v8CoverageResults;
+    constructor(globalConfig: Config.GlobalConfig, options?: CoverageReporterOptions);
+    onTestResult(_test: Test, testResult: TestResult): void;
+    onRunComplete(contexts: Set<Context>, aggregatedResults: AggregatedResult): Promise<void>;
+    private _addUntestedFiles;
+    private _checkThreshold;
+    private _getCoverageResult;
+}

node_modules/@jest/reporters/build/CoverageReporter.js

@@ -0,0 +1,662 @@
+'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 _v8Coverage() {
+  const data = require('@bcoe/v8-coverage');
+
+  _v8Coverage = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+
+  _chalk = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _glob() {
+  const data = _interopRequireDefault(require('glob'));
+
+  _glob = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function fs() {
+  const data = _interopRequireWildcard(require('graceful-fs'));
+
+  fs = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _istanbulLibCoverage() {
+  const data = _interopRequireDefault(require('istanbul-lib-coverage'));
+
+  _istanbulLibCoverage = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _istanbulLibReport() {
+  const data = _interopRequireDefault(require('istanbul-lib-report'));
+
+  _istanbulLibReport = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _istanbulLibSourceMaps() {
+  const data = _interopRequireDefault(require('istanbul-lib-source-maps'));
+
+  _istanbulLibSourceMaps = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _istanbulReports() {
+  const data = _interopRequireDefault(require('istanbul-reports'));
+
+  _istanbulReports = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _v8ToIstanbul() {
+  const data = _interopRequireDefault(require('v8-to-istanbul'));
+
+  _v8ToIstanbul = 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 _BaseReporter = _interopRequireDefault(require('./BaseReporter'));
+
+var _getWatermarks = _interopRequireDefault(require('./getWatermarks'));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+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 _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 FAIL_COLOR = _chalk().default.bold.red;
+
+const RUNNING_TEST_COLOR = _chalk().default.bold.dim;
+
+class CoverageReporter extends _BaseReporter.default {
+  constructor(globalConfig, options) {
+    super();
+
+    _defineProperty(this, '_coverageMap', void 0);
+
+    _defineProperty(this, '_globalConfig', void 0);
+
+    _defineProperty(this, '_sourceMapStore', void 0);
+
+    _defineProperty(this, '_options', void 0);
+
+    _defineProperty(this, '_v8CoverageResults', void 0);
+
+    this._coverageMap = _istanbulLibCoverage().default.createCoverageMap({});
+    this._globalConfig = globalConfig;
+    this._sourceMapStore = _istanbulLibSourceMaps().default.createSourceMapStore();
+    this._v8CoverageResults = [];
+    this._options = options || {};
+  }
+
+  onTestResult(_test, testResult) {
+    if (testResult.v8Coverage) {
+      this._v8CoverageResults.push(testResult.v8Coverage);
+
+      return;
+    }
+
+    if (testResult.coverage) {
+      this._coverageMap.merge(testResult.coverage);
+    }
+  }
+
+  async onRunComplete(contexts, aggregatedResults) {
+    await this._addUntestedFiles(contexts);
+    const {map, reportContext} = await this._getCoverageResult();
+
+    try {
+      const coverageReporters = this._globalConfig.coverageReporters || [];
+
+      if (!this._globalConfig.useStderr && coverageReporters.length < 1) {
+        coverageReporters.push('text-summary');
+      }
+
+      coverageReporters.forEach(reporter => {
+        let additionalOptions = {};
+
+        if (Array.isArray(reporter)) {
+          [reporter, additionalOptions] = reporter;
+        }
+
+        _istanbulReports()
+          .default.create(reporter, {
+            maxCols: process.stdout.columns || Infinity,
+            ...additionalOptions
+          }) // @ts-expect-error
+          .execute(reportContext);
+      });
+      aggregatedResults.coverageMap = map;
+    } catch (e) {
+      console.error(
+        _chalk().default.red(`
+        Failed to write coverage reports:
+        ERROR: ${e.toString()}
+        STACK: ${e.stack}
+      `)
+      );
+    }
+
+    this._checkThreshold(map);
+  }
+
+  async _addUntestedFiles(contexts) {
+    const files = [];
+    contexts.forEach(context => {
+      const config = context.config;
+
+      if (
+        this._globalConfig.collectCoverageFrom &&
+        this._globalConfig.collectCoverageFrom.length
+      ) {
+        context.hasteFS
+          .matchFilesWithGlob(
+            this._globalConfig.collectCoverageFrom,
+            config.rootDir
+          )
+          .forEach(filePath =>
+            files.push({
+              config,
+              path: filePath
+            })
+          );
+      }
+    });
+
+    if (!files.length) {
+      return;
+    }
+
+    if (_jestUtil().isInteractive) {
+      process.stderr.write(
+        RUNNING_TEST_COLOR('Running coverage on untested files...')
+      );
+    }
+
+    let worker;
+
+    if (this._globalConfig.maxWorkers <= 1) {
+      worker = require('./CoverageWorker');
+    } else {
+      worker = new (_jestWorker().default)(
+        require.resolve('./CoverageWorker'),
+        {
+          exposedMethods: ['worker'],
+          maxRetries: 2,
+          numWorkers: this._globalConfig.maxWorkers
+        }
+      );
+    }
+
+    const instrumentation = files.map(async fileObj => {
+      const filename = fileObj.path;
+      const config = fileObj.config;
+
+      const hasCoverageData = this._v8CoverageResults.some(v8Res =>
+        v8Res.some(innerRes => innerRes.result.url === filename)
+      );
+
+      if (
+        !hasCoverageData &&
+        !this._coverageMap.data[filename] &&
+        'worker' in worker
+      ) {
+        try {
+          const result = await worker.worker({
+            config,
+            globalConfig: this._globalConfig,
+            options: {
+              ...this._options,
+              changedFiles:
+                this._options.changedFiles &&
+                Array.from(this._options.changedFiles),
+              sourcesRelatedToTestsInChangedFiles:
+                this._options.sourcesRelatedToTestsInChangedFiles &&
+                Array.from(this._options.sourcesRelatedToTestsInChangedFiles)
+            },
+            path: filename
+          });
+
+          if (result) {
+            if (result.kind === 'V8Coverage') {
+              this._v8CoverageResults.push([
+                {
+                  codeTransformResult: undefined,
+                  result: result.result
+                }
+              ]);
+            } else {
+              this._coverageMap.addFileCoverage(result.coverage);
+            }
+          }
+        } catch (error) {
+          console.error(
+            _chalk().default.red(
+              [
+                `Failed to collect coverage from ${filename}`,
+                `ERROR: ${error.message}`,
+                `STACK: ${error.stack}`
+              ].join('\n')
+            )
+          );
+        }
+      }
+    });
+
+    try {
+      await Promise.all(instrumentation);
+    } catch {
+      // Do nothing; errors were reported earlier to the console.
+    }
+
+    if (_jestUtil().isInteractive) {
+      (0, _jestUtil().clearLine)(process.stderr);
+    }
+
+    if (worker && 'end' in worker && typeof worker.end === 'function') {
+      await worker.end();
+    }
+  }
+
+  _checkThreshold(map) {
+    const {coverageThreshold} = this._globalConfig;
+
+    if (coverageThreshold) {
+      function check(name, thresholds, actuals) {
+        return ['statements', 'branches', 'lines', 'functions'].reduce(
+          (errors, key) => {
+            const actual = actuals[key].pct;
+            const actualUncovered = actuals[key].total - actuals[key].covered;
+            const threshold = thresholds[key];
+
+            if (threshold !== undefined) {
+              if (threshold < 0) {
+                if (threshold * -1 < actualUncovered) {
+                  errors.push(
+                    `Jest: Uncovered count for ${key} (${actualUncovered}) ` +
+                      `exceeds ${name} threshold (${-1 * threshold})`
+                  );
+                }
+              } else if (actual < threshold) {
+                errors.push(
+                  `Jest: "${name}" coverage threshold for ${key} (${threshold}%) not met: ${actual}%`
+                );
+              }
+            }
+
+            return errors;
+          },
+          []
+        );
+      }
+
+      const THRESHOLD_GROUP_TYPES = {
+        GLOB: 'glob',
+        GLOBAL: 'global',
+        PATH: 'path'
+      };
+      const coveredFiles = map.files();
+      const thresholdGroups = Object.keys(coverageThreshold);
+      const groupTypeByThresholdGroup = {};
+      const filesByGlob = {};
+      const coveredFilesSortedIntoThresholdGroup = coveredFiles.reduce(
+        (files, file) => {
+          const pathOrGlobMatches = thresholdGroups.reduce(
+            (agg, thresholdGroup) => {
+              const absoluteThresholdGroup = path().resolve(thresholdGroup); // The threshold group might be a path:
+
+              if (file.indexOf(absoluteThresholdGroup) === 0) {
+                groupTypeByThresholdGroup[thresholdGroup] =
+                  THRESHOLD_GROUP_TYPES.PATH;
+                return agg.concat([[file, thresholdGroup]]);
+              } // If the threshold group is not a path it might be a glob:
+              // Note: glob.sync is slow. By memoizing the files matching each glob
+              // (rather than recalculating it for each covered file) we save a tonne
+              // of execution time.
+
+              if (filesByGlob[absoluteThresholdGroup] === undefined) {
+                filesByGlob[absoluteThresholdGroup] = _glob()
+                  .default.sync(absoluteThresholdGroup)
+                  .map(filePath => path().resolve(filePath));
+              }
+
+              if (filesByGlob[absoluteThresholdGroup].indexOf(file) > -1) {
+                groupTypeByThresholdGroup[thresholdGroup] =
+                  THRESHOLD_GROUP_TYPES.GLOB;
+                return agg.concat([[file, thresholdGroup]]);
+              }
+
+              return agg;
+            },
+            []
+          );
+
+          if (pathOrGlobMatches.length > 0) {
+            return files.concat(pathOrGlobMatches);
+          } // Neither a glob or a path? Toss it in global if there's a global threshold:
+
+          if (thresholdGroups.indexOf(THRESHOLD_GROUP_TYPES.GLOBAL) > -1) {
+            groupTypeByThresholdGroup[THRESHOLD_GROUP_TYPES.GLOBAL] =
+              THRESHOLD_GROUP_TYPES.GLOBAL;
+            return files.concat([[file, THRESHOLD_GROUP_TYPES.GLOBAL]]);
+          } // A covered file that doesn't have a threshold:
+
+          return files.concat([[file, undefined]]);
+        },
+        []
+      );
+
+      const getFilesInThresholdGroup = thresholdGroup =>
+        coveredFilesSortedIntoThresholdGroup
+          .filter(fileAndGroup => fileAndGroup[1] === thresholdGroup)
+          .map(fileAndGroup => fileAndGroup[0]);
+
+      function combineCoverage(filePaths) {
+        return filePaths
+          .map(filePath => map.fileCoverageFor(filePath))
+          .reduce((combinedCoverage, nextFileCoverage) => {
+            if (combinedCoverage === undefined || combinedCoverage === null) {
+              return nextFileCoverage.toSummary();
+            }
+
+            return combinedCoverage.merge(nextFileCoverage.toSummary());
+          }, undefined);
+      }
+
+      let errors = [];
+      thresholdGroups.forEach(thresholdGroup => {
+        switch (groupTypeByThresholdGroup[thresholdGroup]) {
+          case THRESHOLD_GROUP_TYPES.GLOBAL: {
+            const coverage = combineCoverage(
+              getFilesInThresholdGroup(THRESHOLD_GROUP_TYPES.GLOBAL)
+            );
+
+            if (coverage) {
+              errors = errors.concat(
+                check(
+                  thresholdGroup,
+                  coverageThreshold[thresholdGroup],
+                  coverage
+                )
+              );
+            }
+
+            break;
+          }
+
+          case THRESHOLD_GROUP_TYPES.PATH: {
+            const coverage = combineCoverage(
+              getFilesInThresholdGroup(thresholdGroup)
+            );
+
+            if (coverage) {
+              errors = errors.concat(
+                check(
+                  thresholdGroup,
+                  coverageThreshold[thresholdGroup],
+                  coverage
+                )
+              );
+            }
+
+            break;
+          }
+
+          case THRESHOLD_GROUP_TYPES.GLOB:
+            getFilesInThresholdGroup(thresholdGroup).forEach(
+              fileMatchingGlob => {
+                errors = errors.concat(
+                  check(
+                    fileMatchingGlob,
+                    coverageThreshold[thresholdGroup],
+                    map.fileCoverageFor(fileMatchingGlob).toSummary()
+                  )
+                );
+              }
+            );
+            break;
+
+          default:
+            // If the file specified by path is not found, error is returned.
+            if (thresholdGroup !== THRESHOLD_GROUP_TYPES.GLOBAL) {
+              errors = errors.concat(
+                `Jest: Coverage data for ${thresholdGroup} was not found.`
+              );
+            }
+
+          // Sometimes all files in the coverage data are matched by
+          // PATH and GLOB threshold groups in which case, don't error when
+          // the global threshold group doesn't match any files.
+        }
+      });
+      errors = errors.filter(
+        err => err !== undefined && err !== null && err.length > 0
+      );
+
+      if (errors.length > 0) {
+        this.log(`${FAIL_COLOR(errors.join('\n'))}`);
+
+        this._setError(new Error(errors.join('\n')));
+      }
+    }
+  }
+
+  async _getCoverageResult() {
+    if (this._globalConfig.coverageProvider === 'v8') {
+      const mergedCoverages = (0, _v8Coverage().mergeProcessCovs)(
+        this._v8CoverageResults.map(cov => ({
+          result: cov.map(r => r.result)
+        }))
+      );
+      const fileTransforms = new Map();
+
+      this._v8CoverageResults.forEach(res =>
+        res.forEach(r => {
+          if (r.codeTransformResult && !fileTransforms.has(r.result.url)) {
+            fileTransforms.set(r.result.url, r.codeTransformResult);
+          }
+        })
+      );
+
+      const transformedCoverage = await Promise.all(
+        mergedCoverages.result.map(async res => {
+          var _fileTransform$wrappe;
+
+          const fileTransform = fileTransforms.get(res.url);
+          let sourcemapContent = undefined;
+
+          if (
+            fileTransform &&
+            fileTransform.sourceMapPath &&
+            fs().existsSync(fileTransform.sourceMapPath)
+          ) {
+            sourcemapContent = JSON.parse(
+              fs().readFileSync(fileTransform.sourceMapPath, 'utf8')
+            );
+          }
+
+          const converter = (0, _v8ToIstanbul().default)(
+            res.url,
+            (_fileTransform$wrappe =
+              fileTransform === null || fileTransform === void 0
+                ? void 0
+                : fileTransform.wrapperLength) !== null &&
+              _fileTransform$wrappe !== void 0
+              ? _fileTransform$wrappe
+              : 0,
+            fileTransform && sourcemapContent
+              ? {
+                  originalSource: fileTransform.originalCode,
+                  source: fileTransform.code,
+                  sourceMap: {
+                    sourcemap: sourcemapContent
+                  }
+                }
+              : {
+                  source: fs().readFileSync(res.url, 'utf8')
+                }
+          );
+          await converter.load();
+          converter.applyCoverage(res.functions);
+          return converter.toIstanbul();
+        })
+      );
+
+      const map = _istanbulLibCoverage().default.createCoverageMap({});
+
+      transformedCoverage.forEach(res => map.merge(res));
+
+      const reportContext = _istanbulLibReport().default.createContext({
+        coverageMap: map,
+        dir: this._globalConfig.coverageDirectory,
+        watermarks: (0, _getWatermarks.default)(this._globalConfig)
+      });
+
+      return {
+        map,
+        reportContext
+      };
+    }
+
+    const map = await this._sourceMapStore.transformCoverage(this._coverageMap);
+
+    const reportContext = _istanbulLibReport().default.createContext({
+      coverageMap: map,
+      dir: this._globalConfig.coverageDirectory,
+      sourceFinder: this._sourceMapStore.sourceFinder,
+      watermarks: (0, _getWatermarks.default)(this._globalConfig)
+    });
+
+    return {
+      map,
+      reportContext
+    };
+  }
+}
+
+exports.default = CoverageReporter;

node_modules/@jest/reporters/build/CoverageWorker.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+import { CoverageWorkerResult } from './generateEmptyCoverage';
+import type { CoverageReporterSerializedOptions } from './types';
+export declare type CoverageWorkerData = {
+    globalConfig: Config.GlobalConfig;
+    config: Config.ProjectConfig;
+    path: Config.Path;
+    options?: CoverageReporterSerializedOptions;
+};
+export type { CoverageWorkerResult };
+export declare function worker({ config, globalConfig, path, options, }: CoverageWorkerData): CoverageWorkerResult | null;

node_modules/@jest/reporters/build/CoverageWorker.js

@@ -0,0 +1,103 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.worker = worker;
+
+function _exit() {
+  const data = _interopRequireDefault(require('exit'));
+
+  _exit = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function fs() {
+  const data = _interopRequireWildcard(require('graceful-fs'));
+
+  fs = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _generateEmptyCoverage = _interopRequireDefault(
+  require('./generateEmptyCoverage')
+);
+
+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.
+ */
+// Make sure uncaught errors are logged before we exit.
+process.on('uncaughtException', err => {
+  console.error(err.stack);
+  (0, _exit().default)(1);
+});
+
+function worker({config, globalConfig, path, options}) {
+  return (0, _generateEmptyCoverage.default)(
+    fs().readFileSync(path, 'utf8'),
+    path,
+    globalConfig,
+    config,
+    (options === null || options === void 0 ? void 0 : options.changedFiles) &&
+      new Set(options.changedFiles),
+    (options === null || options === void 0
+      ? void 0
+      : options.sourcesRelatedToTestsInChangedFiles) &&
+      new Set(options.sourcesRelatedToTestsInChangedFiles)
+  );
+}

node_modules/@jest/reporters/build/DefaultReporter.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { AggregatedResult, TestCaseResult, TestResult } from '@jest/test-result';
+import type { Config } from '@jest/types';
+import BaseReporter from './BaseReporter';
+import type { ReporterOnStartOptions, Test } from './types';
+export default class DefaultReporter extends BaseReporter {
+    private _clear;
+    private _err;
+    protected _globalConfig: Config.GlobalConfig;
+    private _out;
+    private _status;
+    private _bufferedOutput;
+    constructor(globalConfig: Config.GlobalConfig);
+    private _wrapStdio;
+    forceFlushBufferedOutput(): void;
+    private _clearStatus;
+    private _printStatus;
+    onRunStart(aggregatedResults: AggregatedResult, options: ReporterOnStartOptions): void;
+    onTestStart(test: Test): void;
+    onTestCaseResult(test: Test, testCaseResult: TestCaseResult): void;
+    onRunComplete(): void;
+    onTestResult(test: Test, testResult: TestResult, aggregatedResults: AggregatedResult): void;
+    testFinished(config: Config.ProjectConfig, testResult: TestResult, aggregatedResults: AggregatedResult): void;
+    printTestFileHeader(_testPath: Config.Path, config: Config.ProjectConfig, result: TestResult): void;
+    printTestFileFailureMessage(_testPath: Config.Path, _config: Config.ProjectConfig, result: TestResult): void;
+}

node_modules/@jest/reporters/build/DefaultReporter.js

@@ -0,0 +1,254 @@
+'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 _console() {
+  const data = require('@jest/console');
+
+  _console = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _BaseReporter = _interopRequireDefault(require('./BaseReporter'));
+
+var _Status = _interopRequireDefault(require('./Status'));
+
+var _getResultHeader = _interopRequireDefault(require('./getResultHeader'));
+
+var _getSnapshotStatus = _interopRequireDefault(require('./getSnapshotStatus'));
+
+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 TITLE_BULLET = _chalk().default.bold('\u25cf ');
+
+class DefaultReporter extends _BaseReporter.default {
+  // ANSI clear sequence for the last printed status
+  constructor(globalConfig) {
+    super();
+
+    _defineProperty(this, '_clear', void 0);
+
+    _defineProperty(this, '_err', void 0);
+
+    _defineProperty(this, '_globalConfig', void 0);
+
+    _defineProperty(this, '_out', void 0);
+
+    _defineProperty(this, '_status', void 0);
+
+    _defineProperty(this, '_bufferedOutput', void 0);
+
+    this._globalConfig = globalConfig;
+    this._clear = '';
+    this._out = process.stdout.write.bind(process.stdout);
+    this._err = process.stderr.write.bind(process.stderr);
+    this._status = new _Status.default();
+    this._bufferedOutput = new Set();
+
+    this._wrapStdio(process.stdout);
+
+    this._wrapStdio(process.stderr);
+
+    this._status.onChange(() => {
+      this._clearStatus();
+
+      this._printStatus();
+    });
+  }
+
+  _wrapStdio(stream) {
+    const originalWrite = stream.write;
+    let buffer = [];
+    let timeout = null;
+
+    const flushBufferedOutput = () => {
+      const string = buffer.join('');
+      buffer = []; // This is to avoid conflicts between random output and status text
+
+      this._clearStatus();
+
+      if (string) {
+        originalWrite.call(stream, string);
+      }
+
+      this._printStatus();
+
+      this._bufferedOutput.delete(flushBufferedOutput);
+    };
+
+    this._bufferedOutput.add(flushBufferedOutput);
+
+    const debouncedFlush = () => {
+      // If the process blows up no errors would be printed.
+      // There should be a smart way to buffer stderr, but for now
+      // we just won't buffer it.
+      if (stream === process.stderr) {
+        flushBufferedOutput();
+      } else {
+        if (!timeout) {
+          timeout = setTimeout(() => {
+            flushBufferedOutput();
+            timeout = null;
+          }, 100);
+        }
+      }
+    };
+
+    stream.write = chunk => {
+      buffer.push(chunk);
+      debouncedFlush();
+      return true;
+    };
+  } // Don't wait for the debounced call and flush all output immediately.
+
+  forceFlushBufferedOutput() {
+    for (const flushBufferedOutput of this._bufferedOutput) {
+      flushBufferedOutput();
+    }
+  }
+
+  _clearStatus() {
+    if (_jestUtil().isInteractive) {
+      if (this._globalConfig.useStderr) {
+        this._err(this._clear);
+      } else {
+        this._out(this._clear);
+      }
+    }
+  }
+
+  _printStatus() {
+    const {content, clear} = this._status.get();
+
+    this._clear = clear;
+
+    if (_jestUtil().isInteractive) {
+      if (this._globalConfig.useStderr) {
+        this._err(content);
+      } else {
+        this._out(content);
+      }
+    }
+  }
+
+  onRunStart(aggregatedResults, options) {
+    this._status.runStarted(aggregatedResults, options);
+  }
+
+  onTestStart(test) {
+    this._status.testStarted(test.path, test.context.config);
+  }
+
+  onTestCaseResult(test, testCaseResult) {
+    this._status.addTestCaseResult(test, testCaseResult);
+  }
+
+  onRunComplete() {
+    this.forceFlushBufferedOutput();
+
+    this._status.runFinished();
+
+    process.stdout.write = this._out;
+    process.stderr.write = this._err;
+    (0, _jestUtil().clearLine)(process.stderr);
+  }
+
+  onTestResult(test, testResult, aggregatedResults) {
+    this.testFinished(test.context.config, testResult, aggregatedResults);
+
+    if (!testResult.skipped) {
+      this.printTestFileHeader(
+        testResult.testFilePath,
+        test.context.config,
+        testResult
+      );
+      this.printTestFileFailureMessage(
+        testResult.testFilePath,
+        test.context.config,
+        testResult
+      );
+    }
+
+    this.forceFlushBufferedOutput();
+  }
+
+  testFinished(config, testResult, aggregatedResults) {
+    this._status.testFinished(config, testResult, aggregatedResults);
+  }
+
+  printTestFileHeader(_testPath, config, result) {
+    this.log((0, _getResultHeader.default)(result, this._globalConfig, config));
+
+    if (result.console) {
+      this.log(
+        '  ' +
+          TITLE_BULLET +
+          'Console\n\n' +
+          (0, _console().getConsoleOutput)(
+            config.cwd,
+            !!this._globalConfig.verbose,
+            result.console,
+            config,
+            this._globalConfig
+          )
+      );
+    }
+  }
+
+  printTestFileFailureMessage(_testPath, _config, result) {
+    if (result.failureMessage) {
+      this.log(result.failureMessage);
+    }
+
+    const didUpdate = this._globalConfig.updateSnapshot === 'all';
+    const snapshotStatuses = (0, _getSnapshotStatus.default)(
+      result.snapshot,
+      didUpdate
+    );
+    snapshotStatuses.forEach(this.log);
+  }
+}
+
+exports.default = DefaultReporter;

node_modules/@jest/reporters/build/NotifyReporter.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { AggregatedResult } from '@jest/test-result';
+import type { Config } from '@jest/types';
+import BaseReporter from './BaseReporter';
+import type { Context, TestSchedulerContext } from './types';
+export default class NotifyReporter extends BaseReporter {
+    private _notifier;
+    private _startRun;
+    private _globalConfig;
+    private _context;
+    constructor(globalConfig: Config.GlobalConfig, startRun: (globalConfig: Config.GlobalConfig) => unknown, context: TestSchedulerContext);
+    onRunComplete(contexts: Set<Context>, result: AggregatedResult): void;
+}

node_modules/@jest/reporters/build/NotifyReporter.js

@@ -0,0 +1,254 @@
+'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 util() {
+  const data = _interopRequireWildcard(require('util'));
+
+  util = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _exit() {
+  const data = _interopRequireDefault(require('exit'));
+
+  _exit = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _BaseReporter = _interopRequireDefault(require('./BaseReporter'));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+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 _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 isDarwin = process.platform === 'darwin';
+const icon = path().resolve(__dirname, '../assets/jest_logo.png');
+
+class NotifyReporter extends _BaseReporter.default {
+  constructor(globalConfig, startRun, context) {
+    super();
+
+    _defineProperty(this, '_notifier', loadNotifier());
+
+    _defineProperty(this, '_startRun', void 0);
+
+    _defineProperty(this, '_globalConfig', void 0);
+
+    _defineProperty(this, '_context', void 0);
+
+    this._globalConfig = globalConfig;
+    this._startRun = startRun;
+    this._context = context;
+  }
+
+  onRunComplete(contexts, result) {
+    const success =
+      result.numFailedTests === 0 && result.numRuntimeErrorTestSuites === 0;
+    const firstContext = contexts.values().next();
+    const hasteFS =
+      firstContext && firstContext.value && firstContext.value.hasteFS;
+    let packageName;
+
+    if (hasteFS != null) {
+      // assuming root package.json is the first one
+      const [filePath] = hasteFS.matchFiles('package.json');
+      packageName =
+        filePath != null
+          ? hasteFS.getModuleName(filePath)
+          : this._globalConfig.rootDir;
+    } else {
+      packageName = this._globalConfig.rootDir;
+    }
+
+    packageName = packageName != null ? `${packageName} - ` : '';
+    const notifyMode = this._globalConfig.notifyMode;
+    const statusChanged =
+      this._context.previousSuccess !== success || this._context.firstRun;
+    const testsHaveRun = result.numTotalTests !== 0;
+
+    if (
+      testsHaveRun &&
+      success &&
+      (notifyMode === 'always' ||
+        notifyMode === 'success' ||
+        notifyMode === 'success-change' ||
+        (notifyMode === 'change' && statusChanged) ||
+        (notifyMode === 'failure-change' && statusChanged))
+    ) {
+      const title = util().format('%s%d%% Passed', packageName, 100);
+      const message = `${isDarwin ? '\u2705 ' : ''}${(0, _jestUtil().pluralize)(
+        'test',
+        result.numPassedTests
+      )} passed`;
+
+      this._notifier.notify({
+        icon,
+        message,
+        timeout: false,
+        title
+      });
+    } else if (
+      testsHaveRun &&
+      !success &&
+      (notifyMode === 'always' ||
+        notifyMode === 'failure' ||
+        notifyMode === 'failure-change' ||
+        (notifyMode === 'change' && statusChanged) ||
+        (notifyMode === 'success-change' && statusChanged))
+    ) {
+      const failed = result.numFailedTests / result.numTotalTests;
+      const title = util().format(
+        '%s%d%% Failed',
+        packageName,
+        Math.ceil(Number.isNaN(failed) ? 0 : failed * 100)
+      );
+      const message = util().format(
+        (isDarwin ? '\u26D4\uFE0F ' : '') + '%d of %d tests failed',
+        result.numFailedTests,
+        result.numTotalTests
+      );
+      const watchMode = this._globalConfig.watch || this._globalConfig.watchAll;
+      const restartAnswer = 'Run again';
+      const quitAnswer = 'Exit tests';
+
+      if (!watchMode) {
+        this._notifier.notify({
+          icon,
+          message,
+          timeout: false,
+          title
+        });
+      } else {
+        this._notifier.notify(
+          {
+            actions: [restartAnswer, quitAnswer],
+            closeLabel: 'Close',
+            icon,
+            message,
+            timeout: false,
+            title
+          },
+          (err, _, metadata) => {
+            if (err || !metadata) {
+              return;
+            }
+
+            if (metadata.activationValue === quitAnswer) {
+              (0, _exit().default)(0);
+              return;
+            }
+
+            if (metadata.activationValue === restartAnswer) {
+              this._startRun(this._globalConfig);
+            }
+          }
+        );
+      }
+    }
+
+    this._context.previousSuccess = success;
+    this._context.firstRun = false;
+  }
+}
+
+exports.default = NotifyReporter;
+
+function loadNotifier() {
+  try {
+    return require('node-notifier');
+  } catch (err) {
+    if (err.code !== 'MODULE_NOT_FOUND') {
+      throw err;
+    } else {
+      throw Error(
+        'notify reporter requires optional dependeny node-notifier but it was not found'
+      );
+    }
+  }
+}

node_modules/@jest/reporters/build/Status.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { AggregatedResult, TestCaseResult, TestResult } from '@jest/test-result';
+import type { Config } from '@jest/types';
+import type { ReporterOnStartOptions, Test } from './types';
+declare type Cache = {
+    content: string;
+    clear: string;
+};
+/**
+ * A class that generates the CLI status of currently running tests
+ * and also provides an ANSI escape sequence to remove status lines
+ * from the terminal.
+ */
+export default class Status {
+    private _cache;
+    private _callback?;
+    private _currentTests;
+    private _currentTestCases;
+    private _done;
+    private _emitScheduled;
+    private _estimatedTime;
+    private _interval?;
+    private _aggregatedResults?;
+    private _showStatus;
+    constructor();
+    onChange(callback: () => void): void;
+    runStarted(aggregatedResults: AggregatedResult, options: ReporterOnStartOptions): void;
+    runFinished(): void;
+    addTestCaseResult(test: Test, testCaseResult: TestCaseResult): void;
+    testStarted(testPath: Config.Path, config: Config.ProjectConfig): void;
+    testFinished(_config: Config.ProjectConfig, testResult: TestResult, aggregatedResults: AggregatedResult): void;
+    get(): Cache;
+    private _emit;
+    private _debouncedEmit;
+    private _tick;
+}
+export {};

node_modules/@jest/reporters/build/Status.js

@@ -0,0 +1,272 @@
+'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 _stringLength() {
+  const data = _interopRequireDefault(require('string-length'));
+
+  _stringLength = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _utils = require('./utils');
+
+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 RUNNING_TEXT = ' RUNS ';
+const RUNNING = _chalk().default.reset.inverse.yellow.bold(RUNNING_TEXT) + ' ';
+/**
+ * This class is a perf optimization for sorting the list of currently
+ * running tests. It tries to keep tests in the same positions without
+ * shifting the whole list.
+ */
+
+class CurrentTestList {
+  constructor() {
+    _defineProperty(this, '_array', void 0);
+
+    this._array = [];
+  }
+
+  add(testPath, config) {
+    const index = this._array.indexOf(null);
+
+    const record = {
+      config,
+      testPath
+    };
+
+    if (index !== -1) {
+      this._array[index] = record;
+    } else {
+      this._array.push(record);
+    }
+  }
+
+  delete(testPath) {
+    const record = this._array.find(
+      record => record !== null && record.testPath === testPath
+    );
+
+    this._array[this._array.indexOf(record || null)] = null;
+  }
+
+  get() {
+    return this._array;
+  }
+}
+
+/**
+ * A class that generates the CLI status of currently running tests
+ * and also provides an ANSI escape sequence to remove status lines
+ * from the terminal.
+ */
+class Status {
+  constructor() {
+    _defineProperty(this, '_cache', void 0);
+
+    _defineProperty(this, '_callback', void 0);
+
+    _defineProperty(this, '_currentTests', void 0);
+
+    _defineProperty(this, '_currentTestCases', void 0);
+
+    _defineProperty(this, '_done', void 0);
+
+    _defineProperty(this, '_emitScheduled', void 0);
+
+    _defineProperty(this, '_estimatedTime', void 0);
+
+    _defineProperty(this, '_interval', void 0);
+
+    _defineProperty(this, '_aggregatedResults', void 0);
+
+    _defineProperty(this, '_showStatus', void 0);
+
+    this._cache = null;
+    this._currentTests = new CurrentTestList();
+    this._currentTestCases = [];
+    this._done = false;
+    this._emitScheduled = false;
+    this._estimatedTime = 0;
+    this._showStatus = false;
+  }
+
+  onChange(callback) {
+    this._callback = callback;
+  }
+
+  runStarted(aggregatedResults, options) {
+    this._estimatedTime = (options && options.estimatedTime) || 0;
+    this._showStatus = options && options.showStatus;
+    this._interval = setInterval(() => this._tick(), 1000);
+    this._aggregatedResults = aggregatedResults;
+
+    this._debouncedEmit();
+  }
+
+  runFinished() {
+    this._done = true;
+    if (this._interval) clearInterval(this._interval);
+
+    this._emit();
+  }
+
+  addTestCaseResult(test, testCaseResult) {
+    this._currentTestCases.push({
+      test,
+      testCaseResult
+    });
+
+    if (!this._showStatus) {
+      this._emit();
+    } else {
+      this._debouncedEmit();
+    }
+  }
+
+  testStarted(testPath, config) {
+    this._currentTests.add(testPath, config);
+
+    if (!this._showStatus) {
+      this._emit();
+    } else {
+      this._debouncedEmit();
+    }
+  }
+
+  testFinished(_config, testResult, aggregatedResults) {
+    const {testFilePath} = testResult;
+    this._aggregatedResults = aggregatedResults;
+
+    this._currentTests.delete(testFilePath);
+
+    this._currentTestCases = this._currentTestCases.filter(({test}) => {
+      if (_config !== test.context.config) {
+        return true;
+      }
+
+      return test.path !== testFilePath;
+    });
+
+    this._debouncedEmit();
+  }
+
+  get() {
+    if (this._cache) {
+      return this._cache;
+    }
+
+    if (this._done) {
+      return {
+        clear: '',
+        content: ''
+      };
+    }
+
+    const width = process.stdout.columns;
+    let content = '\n';
+
+    this._currentTests.get().forEach(record => {
+      if (record) {
+        const {config, testPath} = record;
+        const projectDisplayName = config.displayName
+          ? (0, _utils.printDisplayName)(config) + ' '
+          : '';
+        const prefix = RUNNING + projectDisplayName;
+        content +=
+          (0, _utils.wrapAnsiString)(
+            prefix +
+              (0, _utils.trimAndFormatPath)(
+                (0, _stringLength().default)(prefix),
+                config,
+                testPath,
+                width
+              ),
+            width
+          ) + '\n';
+      }
+    });
+
+    if (this._showStatus && this._aggregatedResults) {
+      content +=
+        '\n' +
+        (0, _utils.getSummary)(this._aggregatedResults, {
+          currentTestCases: this._currentTestCases,
+          estimatedTime: this._estimatedTime,
+          roundTime: true,
+          width
+        });
+    }
+
+    let height = 0;
+
+    for (let i = 0; i < content.length; i++) {
+      if (content[i] === '\n') {
+        height++;
+      }
+    }
+
+    const clear = '\r\x1B[K\r\x1B[1A'.repeat(height);
+    return (this._cache = {
+      clear,
+      content
+    });
+  }
+
+  _emit() {
+    this._cache = null;
+    if (this._callback) this._callback();
+  }
+
+  _debouncedEmit() {
+    if (!this._emitScheduled) {
+      // Perf optimization to avoid two separate renders When
+      // one test finishes and another test starts executing.
+      this._emitScheduled = true;
+      setTimeout(() => {
+        this._emit();
+
+        this._emitScheduled = false;
+      }, 100);
+    }
+  }
+
+  _tick() {
+    this._debouncedEmit();
+  }
+}
+
+exports.default = Status;

node_modules/@jest/reporters/build/SummaryReporter.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { AggregatedResult } from '@jest/test-result';
+import type { Config } from '@jest/types';
+import BaseReporter from './BaseReporter';
+import type { Context, ReporterOnStartOptions } from './types';
+export default class SummaryReporter extends BaseReporter {
+    private _estimatedTime;
+    private _globalConfig;
+    constructor(globalConfig: Config.GlobalConfig);
+    private _write;
+    onRunStart(aggregatedResults: AggregatedResult, options: ReporterOnStartOptions): void;
+    onRunComplete(contexts: Set<Context>, aggregatedResults: AggregatedResult): void;
+    private _printSnapshotSummary;
+    private _printSummary;
+    private _getTestSummary;
+}

node_modules/@jest/reporters/build/SummaryReporter.js

@@ -0,0 +1,272 @@
+'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 _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _BaseReporter = _interopRequireDefault(require('./BaseReporter'));
+
+var _getResultHeader = _interopRequireDefault(require('./getResultHeader'));
+
+var _getSnapshotSummary = _interopRequireDefault(
+  require('./getSnapshotSummary')
+);
+
+var _utils = require('./utils');
+
+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_SUMMARY_THRESHOLD = 20;
+const NPM_EVENTS = new Set([
+  'prepublish',
+  'publish',
+  'postpublish',
+  'preinstall',
+  'install',
+  'postinstall',
+  'preuninstall',
+  'uninstall',
+  'postuninstall',
+  'preversion',
+  'version',
+  'postversion',
+  'pretest',
+  'test',
+  'posttest',
+  'prestop',
+  'stop',
+  'poststop',
+  'prestart',
+  'start',
+  'poststart',
+  'prerestart',
+  'restart',
+  'postrestart'
+]);
+const {
+  npm_config_user_agent,
+  npm_lifecycle_event,
+  npm_lifecycle_script
+} = process.env;
+
+class SummaryReporter extends _BaseReporter.default {
+  constructor(globalConfig) {
+    super();
+
+    _defineProperty(this, '_estimatedTime', void 0);
+
+    _defineProperty(this, '_globalConfig', void 0);
+
+    this._globalConfig = globalConfig;
+    this._estimatedTime = 0;
+  } // If we write more than one character at a time it is possible that
+  // Node.js exits in the middle of printing the result. This was first observed
+  // in Node.js 0.10 and still persists in Node.js 6.7+.
+  // Let's print the test failure summary character by character which is safer
+  // when hundreds of tests are failing.
+
+  _write(string) {
+    for (let i = 0; i < string.length; i++) {
+      process.stderr.write(string.charAt(i));
+    }
+  }
+
+  onRunStart(aggregatedResults, options) {
+    super.onRunStart(aggregatedResults, options);
+    this._estimatedTime = options.estimatedTime;
+  }
+
+  onRunComplete(contexts, aggregatedResults) {
+    const {numTotalTestSuites, testResults, wasInterrupted} = aggregatedResults;
+
+    if (numTotalTestSuites) {
+      const lastResult = testResults[testResults.length - 1]; // Print a newline if the last test did not fail to line up newlines
+      // similar to when an error would have been thrown in the test.
+
+      if (
+        !this._globalConfig.verbose &&
+        lastResult &&
+        !lastResult.numFailingTests &&
+        !lastResult.testExecError
+      ) {
+        this.log('');
+      }
+
+      this._printSummary(aggregatedResults, this._globalConfig);
+
+      this._printSnapshotSummary(
+        aggregatedResults.snapshot,
+        this._globalConfig
+      );
+
+      if (numTotalTestSuites) {
+        let message = (0, _utils.getSummary)(aggregatedResults, {
+          estimatedTime: this._estimatedTime
+        });
+
+        if (!this._globalConfig.silent) {
+          message +=
+            '\n' +
+            (wasInterrupted
+              ? _chalk().default.bold.red('Test run was interrupted.')
+              : this._getTestSummary(contexts, this._globalConfig));
+        }
+
+        this.log(message);
+      }
+    }
+  }
+
+  _printSnapshotSummary(snapshots, globalConfig) {
+    if (
+      snapshots.added ||
+      snapshots.filesRemoved ||
+      snapshots.unchecked ||
+      snapshots.unmatched ||
+      snapshots.updated
+    ) {
+      let updateCommand;
+      const event = npm_lifecycle_event || '';
+      const prefix = NPM_EVENTS.has(event) ? '' : 'run ';
+      const isYarn =
+        typeof npm_config_user_agent === 'string' &&
+        npm_config_user_agent.includes('yarn');
+      const client = isYarn ? 'yarn' : 'npm';
+      const scriptUsesJest =
+        typeof npm_lifecycle_script === 'string' &&
+        npm_lifecycle_script.includes('jest');
+
+      if (globalConfig.watch || globalConfig.watchAll) {
+        updateCommand = 'press `u`';
+      } else if (event && scriptUsesJest) {
+        updateCommand = `run \`${
+          client + ' ' + prefix + event + (isYarn ? '' : ' --')
+        } -u\``;
+      } else {
+        updateCommand = 're-run jest with `-u`';
+      }
+
+      const snapshotSummary = (0, _getSnapshotSummary.default)(
+        snapshots,
+        globalConfig,
+        updateCommand
+      );
+      snapshotSummary.forEach(this.log);
+      this.log(''); // print empty line
+    }
+  }
+
+  _printSummary(aggregatedResults, globalConfig) {
+    // If there were any failing tests and there was a large number of tests
+    // executed, re-print the failing results at the end of execution output.
+    const failedTests = aggregatedResults.numFailedTests;
+    const runtimeErrors = aggregatedResults.numRuntimeErrorTestSuites;
+
+    if (
+      failedTests + runtimeErrors > 0 &&
+      aggregatedResults.numTotalTestSuites > TEST_SUMMARY_THRESHOLD
+    ) {
+      this.log(_chalk().default.bold('Summary of all failing tests'));
+      aggregatedResults.testResults.forEach(testResult => {
+        const {failureMessage} = testResult;
+
+        if (failureMessage) {
+          this._write(
+            (0, _getResultHeader.default)(testResult, globalConfig) +
+              '\n' +
+              failureMessage +
+              '\n'
+          );
+        }
+      });
+      this.log(''); // print empty line
+    }
+  }
+
+  _getTestSummary(contexts, globalConfig) {
+    const getMatchingTestsInfo = () => {
+      const prefix = globalConfig.findRelatedTests
+        ? ' related to files matching '
+        : ' matching ';
+      return (
+        _chalk().default.dim(prefix) +
+        (0, _jestUtil().testPathPatternToRegExp)(
+          globalConfig.testPathPattern
+        ).toString()
+      );
+    };
+
+    let testInfo = '';
+
+    if (globalConfig.runTestsByPath) {
+      testInfo = _chalk().default.dim(' within paths');
+    } else if (globalConfig.onlyChanged) {
+      testInfo = _chalk().default.dim(' related to changed files');
+    } else if (globalConfig.testPathPattern) {
+      testInfo = getMatchingTestsInfo();
+    }
+
+    let nameInfo = '';
+
+    if (globalConfig.runTestsByPath) {
+      nameInfo = ' ' + globalConfig.nonFlagArgs.map(p => `"${p}"`).join(', ');
+    } else if (globalConfig.testNamePattern) {
+      nameInfo =
+        _chalk().default.dim(' with tests matching ') +
+        `"${globalConfig.testNamePattern}"`;
+    }
+
+    const contextInfo =
+      contexts.size > 1
+        ? _chalk().default.dim(' in ') +
+          contexts.size +
+          _chalk().default.dim(' projects')
+        : '';
+    return (
+      _chalk().default.dim('Ran all test suites') +
+      testInfo +
+      nameInfo +
+      contextInfo +
+      _chalk().default.dim('.')
+    );
+  }
+}
+
+exports.default = SummaryReporter;

node_modules/@jest/reporters/build/VerboseReporter.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 type { AggregatedResult, AssertionResult, Suite, TestResult } from '@jest/test-result';
+import type { Config } from '@jest/types';
+import DefaultReporter from './DefaultReporter';
+import type { Test } from './types';
+export default class VerboseReporter extends DefaultReporter {
+    protected _globalConfig: Config.GlobalConfig;
+    constructor(globalConfig: Config.GlobalConfig);
+    static filterTestResults(testResults: Array<AssertionResult>): Array<AssertionResult>;
+    static groupTestsBySuites(testResults: Array<AssertionResult>): Suite;
+    onTestResult(test: Test, result: TestResult, aggregatedResults: AggregatedResult): void;
+    private _logTestResults;
+    private _logSuite;
+    private _getIcon;
+    private _logTest;
+    private _logTests;
+    private _logTodoOrPendingTest;
+    private _logLine;
+}

node_modules/@jest/reporters/build/VerboseReporter.js

@@ -0,0 +1,209 @@
+'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 _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _DefaultReporter = _interopRequireDefault(require('./DefaultReporter'));
+
+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 {ICONS} = _jestUtil().specialChars;
+
+class VerboseReporter extends _DefaultReporter.default {
+  constructor(globalConfig) {
+    super(globalConfig);
+
+    _defineProperty(this, '_globalConfig', void 0);
+
+    this._globalConfig = globalConfig;
+  }
+
+  static filterTestResults(testResults) {
+    return testResults.filter(({status}) => status !== 'pending');
+  }
+
+  static groupTestsBySuites(testResults) {
+    const root = {
+      suites: [],
+      tests: [],
+      title: ''
+    };
+    testResults.forEach(testResult => {
+      let targetSuite = root; // Find the target suite for this test,
+      // creating nested suites as necessary.
+
+      for (const title of testResult.ancestorTitles) {
+        let matchingSuite = targetSuite.suites.find(s => s.title === title);
+
+        if (!matchingSuite) {
+          matchingSuite = {
+            suites: [],
+            tests: [],
+            title
+          };
+          targetSuite.suites.push(matchingSuite);
+        }
+
+        targetSuite = matchingSuite;
+      }
+
+      targetSuite.tests.push(testResult);
+    });
+    return root;
+  }
+
+  onTestResult(test, result, aggregatedResults) {
+    super.testFinished(test.context.config, result, aggregatedResults);
+
+    if (!result.skipped) {
+      this.printTestFileHeader(
+        result.testFilePath,
+        test.context.config,
+        result
+      );
+
+      if (!result.testExecError && !result.skipped) {
+        this._logTestResults(result.testResults);
+      }
+
+      this.printTestFileFailureMessage(
+        result.testFilePath,
+        test.context.config,
+        result
+      );
+    }
+
+    super.forceFlushBufferedOutput();
+  }
+
+  _logTestResults(testResults) {
+    this._logSuite(VerboseReporter.groupTestsBySuites(testResults), 0);
+
+    this._logLine();
+  }
+
+  _logSuite(suite, indentLevel) {
+    if (suite.title) {
+      this._logLine(suite.title, indentLevel);
+    }
+
+    this._logTests(suite.tests, indentLevel + 1);
+
+    suite.suites.forEach(suite => this._logSuite(suite, indentLevel + 1));
+  }
+
+  _getIcon(status) {
+    if (status === 'failed') {
+      return _chalk().default.red(ICONS.failed);
+    } else if (status === 'pending') {
+      return _chalk().default.yellow(ICONS.pending);
+    } else if (status === 'todo') {
+      return _chalk().default.magenta(ICONS.todo);
+    } else {
+      return _chalk().default.green(ICONS.success);
+    }
+  }
+
+  _logTest(test, indentLevel) {
+    const status = this._getIcon(test.status);
+
+    const time = test.duration
+      ? ` (${(0, _jestUtil().formatTime)(Math.round(test.duration))})`
+      : '';
+
+    this._logLine(
+      status + ' ' + _chalk().default.dim(test.title + time),
+      indentLevel
+    );
+  }
+
+  _logTests(tests, indentLevel) {
+    if (this._globalConfig.expand) {
+      tests.forEach(test => this._logTest(test, indentLevel));
+    } else {
+      const summedTests = tests.reduce(
+        (result, test) => {
+          if (test.status === 'pending') {
+            result.pending.push(test);
+          } else if (test.status === 'todo') {
+            result.todo.push(test);
+          } else {
+            this._logTest(test, indentLevel);
+          }
+
+          return result;
+        },
+        {
+          pending: [],
+          todo: []
+        }
+      );
+
+      if (summedTests.pending.length > 0) {
+        summedTests.pending.forEach(this._logTodoOrPendingTest(indentLevel));
+      }
+
+      if (summedTests.todo.length > 0) {
+        summedTests.todo.forEach(this._logTodoOrPendingTest(indentLevel));
+      }
+    }
+  }
+
+  _logTodoOrPendingTest(indentLevel) {
+    return test => {
+      const printedTestStatus =
+        test.status === 'pending' ? 'skipped' : test.status;
+
+      const icon = this._getIcon(test.status);
+
+      const text = _chalk().default.dim(`${printedTestStatus} ${test.title}`);
+
+      this._logLine(`${icon} ${text}`, indentLevel);
+    };
+  }
+
+  _logLine(str, indentLevel) {
+    const indentation = '  '.repeat(indentLevel || 0);
+    this.log(indentation + (str || ''));
+  }
+}
+
+exports.default = VerboseReporter;

node_modules/@jest/reporters/build/generateEmptyCoverage.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 { V8Coverage } from 'collect-v8-coverage';
+import { FileCoverage } from 'istanbul-lib-coverage';
+import type { Config } from '@jest/types';
+declare type SingleV8Coverage = V8Coverage[number];
+export declare type CoverageWorkerResult = {
+    kind: 'BabelCoverage';
+    coverage: FileCoverage;
+} | {
+    kind: 'V8Coverage';
+    result: SingleV8Coverage;
+};
+export default function (source: string, filename: Config.Path, globalConfig: Config.GlobalConfig, config: Config.ProjectConfig, changedFiles?: Set<Config.Path>, sourcesRelatedToTestsInChangedFiles?: Set<Config.Path>): CoverageWorkerResult | null;
+export {};

node_modules/@jest/reporters/build/generateEmptyCoverage.js

@@ -0,0 +1,158 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = _default;
+
+function fs() {
+  const data = _interopRequireWildcard(require('graceful-fs'));
+
+  fs = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _istanbulLibCoverage() {
+  const data = require('istanbul-lib-coverage');
+
+  _istanbulLibCoverage = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _istanbulLibInstrument() {
+  const data = require('istanbul-lib-instrument');
+
+  _istanbulLibInstrument = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _transform() {
+  const data = require('@jest/transform');
+
+  _transform = 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;
+}
+
+/**
+ * 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 _default(
+  source,
+  filename,
+  globalConfig,
+  config,
+  changedFiles,
+  sourcesRelatedToTestsInChangedFiles
+) {
+  const coverageOptions = {
+    changedFiles,
+    collectCoverage: globalConfig.collectCoverage,
+    collectCoverageFrom: globalConfig.collectCoverageFrom,
+    collectCoverageOnlyFrom: globalConfig.collectCoverageOnlyFrom,
+    coverageProvider: globalConfig.coverageProvider,
+    sourcesRelatedToTestsInChangedFiles
+  };
+  let coverageWorkerResult = null;
+
+  if ((0, _transform().shouldInstrument)(filename, coverageOptions, config)) {
+    if (coverageOptions.coverageProvider === 'v8') {
+      const stat = fs().statSync(filename);
+      return {
+        kind: 'V8Coverage',
+        result: {
+          functions: [
+            {
+              functionName: '(empty-report)',
+              isBlockCoverage: true,
+              ranges: [
+                {
+                  count: 0,
+                  endOffset: stat.size,
+                  startOffset: 0
+                }
+              ]
+            }
+          ],
+          scriptId: '0',
+          url: filename
+        }
+      };
+    } // Transform file with instrumentation to make sure initial coverage data is well mapped to original code.
+
+    const {code} = new (_transform().ScriptTransformer)(config).transformSource(
+      filename,
+      source,
+      true
+    ); // TODO: consider passing AST
+
+    const extracted = (0, _istanbulLibInstrument().readInitialCoverage)(code); // Check extracted initial coverage is not null, this can happen when using /* istanbul ignore file */
+
+    if (extracted) {
+      coverageWorkerResult = {
+        coverage: (0, _istanbulLibCoverage().createFileCoverage)(
+          extracted.coverageData
+        ),
+        kind: 'BabelCoverage'
+      };
+    }
+  }
+
+  return coverageWorkerResult;
+}

node_modules/@jest/reporters/build/getResultHeader.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { TestResult } from '@jest/test-result';
+import type { Config } from '@jest/types';
+declare const _default: (result: TestResult, globalConfig: Config.GlobalConfig, projectConfig?: Config.ProjectConfig | undefined) => string;
+export default _default;

node_modules/@jest/reporters/build/getResultHeader.js

@@ -0,0 +1,107 @@
+'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 _terminalLink() {
+  const data = _interopRequireDefault(require('terminal-link'));
+
+  _terminalLink = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _utils = require('./utils');
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const LONG_TEST_COLOR = _chalk().default.reset.bold.bgRed; // Explicitly reset for these messages since they can get written out in the
+// middle of error logging
+
+const FAIL_TEXT = 'FAIL';
+const PASS_TEXT = 'PASS';
+const FAIL = _chalk().default.supportsColor
+  ? _chalk().default.reset.inverse.bold.red(` ${FAIL_TEXT} `)
+  : FAIL_TEXT;
+const PASS = _chalk().default.supportsColor
+  ? _chalk().default.reset.inverse.bold.green(` ${PASS_TEXT} `)
+  : PASS_TEXT;
+
+var _default = (result, globalConfig, projectConfig) => {
+  var _result$perfStats;
+
+  const testPath = result.testFilePath;
+  const formattedTestPath = (0, _utils.formatTestPath)(
+    projectConfig ? projectConfig : globalConfig,
+    testPath
+  );
+  const fileLink = (0, _terminalLink().default)(
+    formattedTestPath,
+    `file://${testPath}`,
+    {
+      fallback: () => formattedTestPath
+    }
+  );
+  const status =
+    result.numFailingTests > 0 || result.testExecError ? FAIL : PASS;
+  const testDetail = [];
+
+  if (
+    (_result$perfStats = result.perfStats) === null ||
+    _result$perfStats === void 0
+      ? void 0
+      : _result$perfStats.slow
+  ) {
+    const runTime = result.perfStats.runtime / 1000;
+    testDetail.push(LONG_TEST_COLOR((0, _jestUtil().formatTime)(runTime, 0)));
+  }
+
+  if (result.memoryUsage) {
+    const toMB = bytes => Math.floor(bytes / 1024 / 1024);
+
+    testDetail.push(`${toMB(result.memoryUsage)} MB heap size`);
+  }
+
+  const projectDisplayName =
+    projectConfig && projectConfig.displayName
+      ? (0, _utils.printDisplayName)(projectConfig) + ' '
+      : '';
+  return (
+    `${status} ${projectDisplayName}${fileLink}` +
+    (testDetail.length ? ` (${testDetail.join(', ')})` : '')
+  );
+};
+
+exports.default = _default;

node_modules/@jest/reporters/build/getSnapshotStatus.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { TestResult } from '@jest/test-result';
+declare const _default: (snapshot: TestResult['snapshot'], afterUpdate: boolean) => Array<string>;
+export default _default;

node_modules/@jest/reporters/build/getSnapshotStatus.js

@@ -0,0 +1,113 @@
+'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 _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const ARROW = ' \u203A ';
+const DOT = ' \u2022 ';
+
+const FAIL_COLOR = _chalk().default.bold.red;
+
+const SNAPSHOT_ADDED = _chalk().default.bold.green;
+
+const SNAPSHOT_UPDATED = _chalk().default.bold.green;
+
+const SNAPSHOT_OUTDATED = _chalk().default.bold.yellow;
+
+var _default = (snapshot, afterUpdate) => {
+  const statuses = [];
+
+  if (snapshot.added) {
+    statuses.push(
+      SNAPSHOT_ADDED(
+        ARROW +
+          (0, _jestUtil().pluralize)('snapshot', snapshot.added) +
+          ' written.'
+      )
+    );
+  }
+
+  if (snapshot.updated) {
+    statuses.push(
+      SNAPSHOT_UPDATED(
+        ARROW +
+          (0, _jestUtil().pluralize)('snapshot', snapshot.updated) +
+          ' updated.'
+      )
+    );
+  }
+
+  if (snapshot.unmatched) {
+    statuses.push(
+      FAIL_COLOR(
+        ARROW +
+          (0, _jestUtil().pluralize)('snapshot', snapshot.unmatched) +
+          ' failed.'
+      )
+    );
+  }
+
+  if (snapshot.unchecked) {
+    if (afterUpdate) {
+      statuses.push(
+        SNAPSHOT_UPDATED(
+          ARROW +
+            (0, _jestUtil().pluralize)('snapshot', snapshot.unchecked) +
+            ' removed.'
+        )
+      );
+    } else {
+      statuses.push(
+        SNAPSHOT_OUTDATED(
+          ARROW +
+            (0, _jestUtil().pluralize)('snapshot', snapshot.unchecked) +
+            ' obsolete'
+        ) + '.'
+      );
+    }
+
+    snapshot.uncheckedKeys.forEach(key => {
+      statuses.push(`  ${DOT}${key}`);
+    });
+  }
+
+  if (snapshot.fileDeleted) {
+    statuses.push(SNAPSHOT_UPDATED(ARROW + 'snapshot file removed.'));
+  }
+
+  return statuses;
+};
+
+exports.default = _default;

node_modules/@jest/reporters/build/getSnapshotSummary.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { SnapshotSummary } from '@jest/test-result';
+import type { Config } from '@jest/types';
+declare const _default: (snapshots: SnapshotSummary, globalConfig: Config.GlobalConfig, updateCommand: string) => Array<string>;
+export default _default;

node_modules/@jest/reporters/build/getSnapshotSummary.js

@@ -0,0 +1,205 @@
+'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 _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _utils = require('./utils');
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const ARROW = ' \u203A ';
+const DOWN_ARROW = ' \u21B3 ';
+const DOT = ' \u2022 ';
+
+const FAIL_COLOR = _chalk().default.bold.red;
+
+const OBSOLETE_COLOR = _chalk().default.bold.yellow;
+
+const SNAPSHOT_ADDED = _chalk().default.bold.green;
+
+const SNAPSHOT_NOTE = _chalk().default.dim;
+
+const SNAPSHOT_REMOVED = _chalk().default.bold.green;
+
+const SNAPSHOT_SUMMARY = _chalk().default.bold;
+
+const SNAPSHOT_UPDATED = _chalk().default.bold.green;
+
+var _default = (snapshots, globalConfig, updateCommand) => {
+  const summary = [];
+  summary.push(SNAPSHOT_SUMMARY('Snapshot Summary'));
+
+  if (snapshots.added) {
+    summary.push(
+      SNAPSHOT_ADDED(
+        ARROW +
+          (0, _jestUtil().pluralize)('snapshot', snapshots.added) +
+          ' written '
+      ) +
+        `from ${(0, _jestUtil().pluralize)(
+          'test suite',
+          snapshots.filesAdded
+        )}.`
+    );
+  }
+
+  if (snapshots.unmatched) {
+    summary.push(
+      FAIL_COLOR(
+        `${ARROW}${(0, _jestUtil().pluralize)(
+          'snapshot',
+          snapshots.unmatched
+        )} failed`
+      ) +
+        ` from ${(0, _jestUtil().pluralize)(
+          'test suite',
+          snapshots.filesUnmatched
+        )}. ` +
+        SNAPSHOT_NOTE(
+          'Inspect your code changes or ' + updateCommand + ' to update them.'
+        )
+    );
+  }
+
+  if (snapshots.updated) {
+    summary.push(
+      SNAPSHOT_UPDATED(
+        ARROW +
+          (0, _jestUtil().pluralize)('snapshot', snapshots.updated) +
+          ' updated '
+      ) +
+        `from ${(0, _jestUtil().pluralize)(
+          'test suite',
+          snapshots.filesUpdated
+        )}.`
+    );
+  }
+
+  if (snapshots.filesRemoved) {
+    if (snapshots.didUpdate) {
+      summary.push(
+        SNAPSHOT_REMOVED(
+          `${ARROW}${(0, _jestUtil().pluralize)(
+            'snapshot file',
+            snapshots.filesRemoved
+          )} removed `
+        ) +
+          `from ${(0, _jestUtil().pluralize)(
+            'test suite',
+            snapshots.filesRemoved
+          )}.`
+      );
+    } else {
+      summary.push(
+        OBSOLETE_COLOR(
+          `${ARROW}${(0, _jestUtil().pluralize)(
+            'snapshot file',
+            snapshots.filesRemoved
+          )} obsolete `
+        ) +
+          `from ${(0, _jestUtil().pluralize)(
+            'test suite',
+            snapshots.filesRemoved
+          )}. ` +
+          SNAPSHOT_NOTE(
+            `To remove ${
+              snapshots.filesRemoved === 1 ? 'it' : 'them all'
+            }, ${updateCommand}.`
+          )
+      );
+    }
+  }
+
+  if (snapshots.filesRemovedList && snapshots.filesRemovedList.length) {
+    const [head, ...tail] = snapshots.filesRemovedList;
+    summary.push(
+      `  ${DOWN_ARROW} ${DOT}${(0, _utils.formatTestPath)(globalConfig, head)}`
+    );
+    tail.forEach(key => {
+      summary.push(
+        `      ${DOT}${(0, _utils.formatTestPath)(globalConfig, key)}`
+      );
+    });
+  }
+
+  if (snapshots.unchecked) {
+    if (snapshots.didUpdate) {
+      summary.push(
+        SNAPSHOT_REMOVED(
+          `${ARROW}${(0, _jestUtil().pluralize)(
+            'snapshot',
+            snapshots.unchecked
+          )} removed `
+        ) +
+          `from ${(0, _jestUtil().pluralize)(
+            'test suite',
+            snapshots.uncheckedKeysByFile.length
+          )}.`
+      );
+    } else {
+      summary.push(
+        OBSOLETE_COLOR(
+          `${ARROW}${(0, _jestUtil().pluralize)(
+            'snapshot',
+            snapshots.unchecked
+          )} obsolete `
+        ) +
+          `from ${(0, _jestUtil().pluralize)(
+            'test suite',
+            snapshots.uncheckedKeysByFile.length
+          )}. ` +
+          SNAPSHOT_NOTE(
+            `To remove ${
+              snapshots.unchecked === 1 ? 'it' : 'them all'
+            }, ${updateCommand}.`
+          )
+      );
+    }
+
+    snapshots.uncheckedKeysByFile.forEach(uncheckedFile => {
+      summary.push(
+        `  ${DOWN_ARROW}${(0, _utils.formatTestPath)(
+          globalConfig,
+          uncheckedFile.filePath
+        )}`
+      );
+      uncheckedFile.keys.forEach(key => {
+        summary.push(`      ${DOT}${key}`);
+      });
+    });
+  }
+
+  return summary;
+};
+
+exports.default = _default;

node_modules/@jest/reporters/build/getWatermarks.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import istanbulReport = require('istanbul-lib-report');
+import type { Config } from '@jest/types';
+export default function getWatermarks(config: Config.GlobalConfig): istanbulReport.Watermarks;

node_modules/@jest/reporters/build/getWatermarks.js

@@ -0,0 +1,47 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = getWatermarks;
+
+function _istanbulLibReport() {
+  const data = _interopRequireDefault(require('istanbul-lib-report'));
+
+  _istanbulLibReport = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+function getWatermarks(config) {
+  const defaultWatermarks = _istanbulLibReport().default.getDefaultWatermarks();
+
+  const {coverageThreshold} = config;
+
+  if (!coverageThreshold || !coverageThreshold.global) {
+    return defaultWatermarks;
+  }
+
+  const keys = ['branches', 'functions', 'lines', 'statements'];
+  return keys.reduce((watermarks, key) => {
+    const value = coverageThreshold.global[key];
+
+    if (value !== undefined) {
+      watermarks[key][1] = value;
+    }
+
+    return watermarks;
+  }, defaultWatermarks);
+}

node_modules/@jest/reporters/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.
+ */
+export type { Config } from '@jest/types';
+export type { AggregatedResult, SnapshotSummary, TestResult, } from '@jest/test-result';
+export { default as BaseReporter } from './BaseReporter';
+export { default as CoverageReporter } from './CoverageReporter';
+export { default as DefaultReporter } from './DefaultReporter';
+export { default as NotifyReporter } from './NotifyReporter';
+export { default as SummaryReporter } from './SummaryReporter';
+export { default as VerboseReporter } from './VerboseReporter';
+export type { Context, Reporter, ReporterOnStartOptions, SummaryOptions, Test, } from './types';
+export declare const utils: {
+    formatTestPath: (config: import("@jest/types/build/Config").GlobalConfig | import("@jest/types/build/Config").ProjectConfig, testPath: string) => string;
+    printDisplayName: (config: import("@jest/types/build/Config").ProjectConfig) => string;
+    relativePath: (config: import("@jest/types/build/Config").GlobalConfig | import("@jest/types/build/Config").ProjectConfig, testPath: string) => {
+        basename: string;
+        dirname: string;
+    };
+    trimAndFormatPath: (pad: number, config: import("@jest/types/build/Config").GlobalConfig | import("@jest/types/build/Config").ProjectConfig, testPath: string, columns: number) => string;
+};

node_modules/@jest/reporters/build/index.js

@@ -0,0 +1,74 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+Object.defineProperty(exports, 'BaseReporter', {
+  enumerable: true,
+  get: function () {
+    return _BaseReporter.default;
+  }
+});
+Object.defineProperty(exports, 'CoverageReporter', {
+  enumerable: true,
+  get: function () {
+    return _CoverageReporter.default;
+  }
+});
+Object.defineProperty(exports, 'DefaultReporter', {
+  enumerable: true,
+  get: function () {
+    return _DefaultReporter.default;
+  }
+});
+Object.defineProperty(exports, 'NotifyReporter', {
+  enumerable: true,
+  get: function () {
+    return _NotifyReporter.default;
+  }
+});
+Object.defineProperty(exports, 'SummaryReporter', {
+  enumerable: true,
+  get: function () {
+    return _SummaryReporter.default;
+  }
+});
+Object.defineProperty(exports, 'VerboseReporter', {
+  enumerable: true,
+  get: function () {
+    return _VerboseReporter.default;
+  }
+});
+exports.utils = void 0;
+
+var _utils = require('./utils');
+
+var _BaseReporter = _interopRequireDefault(require('./BaseReporter'));
+
+var _CoverageReporter = _interopRequireDefault(require('./CoverageReporter'));
+
+var _DefaultReporter = _interopRequireDefault(require('./DefaultReporter'));
+
+var _NotifyReporter = _interopRequireDefault(require('./NotifyReporter'));
+
+var _SummaryReporter = _interopRequireDefault(require('./SummaryReporter'));
+
+var _VerboseReporter = _interopRequireDefault(require('./VerboseReporter'));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const utils = {
+  formatTestPath: _utils.formatTestPath,
+  printDisplayName: _utils.printDisplayName,
+  relativePath: _utils.relativePath,
+  trimAndFormatPath: _utils.trimAndFormatPath
+};
+exports.utils = utils;

node_modules/@jest/reporters/build/types.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { AggregatedResult, SerializableError, TestCaseResult, 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 { worker } from './CoverageWorker';
+export declare type ReporterOnStartOptions = {
+    estimatedTime: number;
+    showStatus: boolean;
+};
+export declare type Context = {
+    config: Config.ProjectConfig;
+    hasteFS: HasteFS;
+    moduleMap: ModuleMap;
+    resolver: ResolverType;
+};
+export declare type Test = {
+    context: Context;
+    duration?: number;
+    path: Config.Path;
+};
+export declare type CoverageWorker = {
+    worker: typeof worker;
+};
+export declare type CoverageReporterOptions = {
+    changedFiles?: Set<Config.Path>;
+    sourcesRelatedToTestsInChangedFiles?: Set<Config.Path>;
+};
+export declare type CoverageReporterSerializedOptions = {
+    changedFiles?: Array<Config.Path>;
+    sourcesRelatedToTestsInChangedFiles?: Array<Config.Path>;
+};
+export declare type OnTestStart = (test: Test) => Promise<void>;
+export declare type OnTestFailure = (test: Test, error: SerializableError) => Promise<unknown>;
+export declare type OnTestSuccess = (test: Test, result: TestResult) => Promise<unknown>;
+export interface Reporter {
+    readonly onTestResult?: (test: Test, testResult: TestResult, aggregatedResult: AggregatedResult) => Promise<void> | void;
+    readonly onTestFileResult?: (test: Test, testResult: TestResult, aggregatedResult: AggregatedResult) => Promise<void> | void;
+    readonly onTestCaseResult?: (test: Test, testCaseResult: TestCaseResult) => Promise<void> | void;
+    readonly onRunStart: (results: AggregatedResult, options: ReporterOnStartOptions) => Promise<void> | void;
+    readonly onTestStart?: (test: Test) => Promise<void> | void;
+    readonly onTestFileStart?: (test: Test) => Promise<void> | void;
+    readonly onRunComplete: (contexts: Set<Context>, results: AggregatedResult) => Promise<void> | void;
+    readonly getLastError: () => Error | void;
+}
+export declare type SummaryOptions = {
+    currentTestCases?: Array<{
+        test: Test;
+        testCaseResult: TestCaseResult;
+    }>;
+    estimatedTime?: number;
+    roundTime?: boolean;
+    width?: number;
+};
+export declare type TestRunnerOptions = {
+    serial: boolean;
+};
+export declare type TestRunData = Array<{
+    context: Context;
+    matches: {
+        allTests: number;
+        tests: Array<Test>;
+        total: number;
+    };
+}>;
+export declare type TestSchedulerContext = {
+    firstRun: boolean;
+    previousSuccess: boolean;
+    changedFiles?: Set<Config.Path>;
+};

node_modules/@jest/reporters/build/types.js

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

node_modules/@jest/reporters/build/utils.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { AggregatedResult } from '@jest/test-result';
+import type { Config } from '@jest/types';
+import type { SummaryOptions } from './types';
+export declare const printDisplayName: (config: Config.ProjectConfig) => string;
+export declare const trimAndFormatPath: (pad: number, config: Config.ProjectConfig | Config.GlobalConfig, testPath: Config.Path, columns: number) => string;
+export declare const formatTestPath: (config: Config.GlobalConfig | Config.ProjectConfig, testPath: Config.Path) => string;
+export declare const relativePath: (config: Config.GlobalConfig | Config.ProjectConfig, testPath: Config.Path) => {
+    basename: string;
+    dirname: string;
+};
+export declare const getSummary: (aggregatedResults: AggregatedResult, options?: SummaryOptions | undefined) => string;
+export declare const wrapAnsiString: (string: string, terminalWidth: number) => string;

node_modules/@jest/reporters/build/utils.js

@@ -0,0 +1,429 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.wrapAnsiString = exports.getSummary = exports.relativePath = exports.formatTestPath = exports.trimAndFormatPath = exports.printDisplayName = void 0;
+
+function path() {
+  const data = _interopRequireWildcard(require('path'));
+
+  path = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+
+  _chalk = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _slash() {
+  const data = _interopRequireDefault(require('slash'));
+
+  _slash = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+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;
+}
+
+/**
+ * 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 PROGRESS_BAR_WIDTH = 40;
+
+const printDisplayName = config => {
+  const {displayName} = config;
+
+  const white = _chalk().default.reset.inverse.white;
+
+  if (!displayName) {
+    return '';
+  }
+
+  const {name, color} = displayName;
+  const chosenColor = _chalk().default.reset.inverse[color]
+    ? _chalk().default.reset.inverse[color]
+    : white;
+  return _chalk().default.supportsColor ? chosenColor(` ${name} `) : name;
+};
+
+exports.printDisplayName = printDisplayName;
+
+const trimAndFormatPath = (pad, config, testPath, columns) => {
+  const maxLength = columns - pad;
+  const relative = relativePath(config, testPath);
+  const {basename} = relative;
+  let {dirname} = relative; // length is ok
+
+  if ((dirname + path().sep + basename).length <= maxLength) {
+    return (0, _slash().default)(
+      _chalk().default.dim(dirname + path().sep) +
+        _chalk().default.bold(basename)
+    );
+  } // we can fit trimmed dirname and full basename
+
+  const basenameLength = basename.length;
+
+  if (basenameLength + 4 < maxLength) {
+    const dirnameLength = maxLength - 4 - basenameLength;
+    dirname =
+      '...' + dirname.slice(dirname.length - dirnameLength, dirname.length);
+    return (0, _slash().default)(
+      _chalk().default.dim(dirname + path().sep) +
+        _chalk().default.bold(basename)
+    );
+  }
+
+  if (basenameLength + 4 === maxLength) {
+    return (0, _slash().default)(
+      _chalk().default.dim('...' + path().sep) + _chalk().default.bold(basename)
+    );
+  } // can't fit dirname, but can fit trimmed basename
+
+  return (0, _slash().default)(
+    _chalk().default.bold(
+      '...' + basename.slice(basename.length - maxLength - 4, basename.length)
+    )
+  );
+};
+
+exports.trimAndFormatPath = trimAndFormatPath;
+
+const formatTestPath = (config, testPath) => {
+  const {dirname, basename} = relativePath(config, testPath);
+  return (0, _slash().default)(
+    _chalk().default.dim(dirname + path().sep) + _chalk().default.bold(basename)
+  );
+};
+
+exports.formatTestPath = formatTestPath;
+
+const relativePath = (config, testPath) => {
+  // this function can be called with ProjectConfigs or GlobalConfigs. GlobalConfigs
+  // do not have config.cwd, only config.rootDir. Try using config.cwd, fallback
+  // to config.rootDir. (Also, some unit just use config.rootDir, which is ok)
+  testPath = path().relative(config.cwd || config.rootDir, testPath);
+  const dirname = path().dirname(testPath);
+  const basename = path().basename(testPath);
+  return {
+    basename,
+    dirname
+  };
+};
+
+exports.relativePath = relativePath;
+
+const getValuesCurrentTestCases = (currentTestCases = []) => {
+  let numFailingTests = 0;
+  let numPassingTests = 0;
+  let numPendingTests = 0;
+  let numTodoTests = 0;
+  let numTotalTests = 0;
+  currentTestCases.forEach(testCase => {
+    switch (testCase.testCaseResult.status) {
+      case 'failed': {
+        numFailingTests++;
+        break;
+      }
+
+      case 'passed': {
+        numPassingTests++;
+        break;
+      }
+
+      case 'skipped': {
+        numPendingTests++;
+        break;
+      }
+
+      case 'todo': {
+        numTodoTests++;
+        break;
+      }
+    }
+
+    numTotalTests++;
+  });
+  return {
+    numFailingTests,
+    numPassingTests,
+    numPendingTests,
+    numTodoTests,
+    numTotalTests
+  };
+};
+
+const getSummary = (aggregatedResults, options) => {
+  let runTime = (Date.now() - aggregatedResults.startTime) / 1000;
+
+  if (options && options.roundTime) {
+    runTime = Math.floor(runTime);
+  }
+
+  const valuesForCurrentTestCases = getValuesCurrentTestCases(
+    options === null || options === void 0 ? void 0 : options.currentTestCases
+  );
+  const estimatedTime = (options && options.estimatedTime) || 0;
+  const snapshotResults = aggregatedResults.snapshot;
+  const snapshotsAdded = snapshotResults.added;
+  const snapshotsFailed = snapshotResults.unmatched;
+  const snapshotsOutdated = snapshotResults.unchecked;
+  const snapshotsFilesRemoved = snapshotResults.filesRemoved;
+  const snapshotsDidUpdate = snapshotResults.didUpdate;
+  const snapshotsPassed = snapshotResults.matched;
+  const snapshotsTotal = snapshotResults.total;
+  const snapshotsUpdated = snapshotResults.updated;
+  const suitesFailed = aggregatedResults.numFailedTestSuites;
+  const suitesPassed = aggregatedResults.numPassedTestSuites;
+  const suitesPending = aggregatedResults.numPendingTestSuites;
+  const suitesRun = suitesFailed + suitesPassed;
+  const suitesTotal = aggregatedResults.numTotalTestSuites;
+  const testsFailed = aggregatedResults.numFailedTests;
+  const testsPassed = aggregatedResults.numPassedTests;
+  const testsPending = aggregatedResults.numPendingTests;
+  const testsTodo = aggregatedResults.numTodoTests;
+  const testsTotal = aggregatedResults.numTotalTests;
+  const width = (options && options.width) || 0;
+  const suites =
+    _chalk().default.bold('Test Suites: ') +
+    (suitesFailed
+      ? _chalk().default.bold.red(`${suitesFailed} failed`) + ', '
+      : '') +
+    (suitesPending
+      ? _chalk().default.bold.yellow(`${suitesPending} skipped`) + ', '
+      : '') +
+    (suitesPassed
+      ? _chalk().default.bold.green(`${suitesPassed} passed`) + ', '
+      : '') +
+    (suitesRun !== suitesTotal
+      ? suitesRun + ' of ' + suitesTotal
+      : suitesTotal) +
+    ` total`;
+  const updatedTestsFailed =
+    testsFailed + valuesForCurrentTestCases.numFailingTests;
+  const updatedTestsPending =
+    testsPending + valuesForCurrentTestCases.numPendingTests;
+  const updatedTestsTodo = testsTodo + valuesForCurrentTestCases.numTodoTests;
+  const updatedTestsPassed =
+    testsPassed + valuesForCurrentTestCases.numPassingTests;
+  const updatedTestsTotal =
+    testsTotal + valuesForCurrentTestCases.numTotalTests;
+  const tests =
+    _chalk().default.bold('Tests:       ') +
+    (updatedTestsFailed > 0
+      ? _chalk().default.bold.red(`${updatedTestsFailed} failed`) + ', '
+      : '') +
+    (updatedTestsPending > 0
+      ? _chalk().default.bold.yellow(`${updatedTestsPending} skipped`) + ', '
+      : '') +
+    (updatedTestsTodo > 0
+      ? _chalk().default.bold.magenta(`${updatedTestsTodo} todo`) + ', '
+      : '') +
+    (updatedTestsPassed > 0
+      ? _chalk().default.bold.green(`${updatedTestsPassed} passed`) + ', '
+      : '') +
+    `${updatedTestsTotal} total`;
+  const snapshots =
+    _chalk().default.bold('Snapshots:   ') +
+    (snapshotsFailed
+      ? _chalk().default.bold.red(`${snapshotsFailed} failed`) + ', '
+      : '') +
+    (snapshotsOutdated && !snapshotsDidUpdate
+      ? _chalk().default.bold.yellow(`${snapshotsOutdated} obsolete`) + ', '
+      : '') +
+    (snapshotsOutdated && snapshotsDidUpdate
+      ? _chalk().default.bold.green(`${snapshotsOutdated} removed`) + ', '
+      : '') +
+    (snapshotsFilesRemoved && !snapshotsDidUpdate
+      ? _chalk().default.bold.yellow(
+          (0, _jestUtil().pluralize)('file', snapshotsFilesRemoved) +
+            ' obsolete'
+        ) + ', '
+      : '') +
+    (snapshotsFilesRemoved && snapshotsDidUpdate
+      ? _chalk().default.bold.green(
+          (0, _jestUtil().pluralize)('file', snapshotsFilesRemoved) + ' removed'
+        ) + ', '
+      : '') +
+    (snapshotsUpdated
+      ? _chalk().default.bold.green(`${snapshotsUpdated} updated`) + ', '
+      : '') +
+    (snapshotsAdded
+      ? _chalk().default.bold.green(`${snapshotsAdded} written`) + ', '
+      : '') +
+    (snapshotsPassed
+      ? _chalk().default.bold.green(`${snapshotsPassed} passed`) + ', '
+      : '') +
+    `${snapshotsTotal} total`;
+  const time = renderTime(runTime, estimatedTime, width);
+  return [suites, tests, snapshots, time].join('\n');
+};
+
+exports.getSummary = getSummary;
+
+const renderTime = (runTime, estimatedTime, width) => {
+  // If we are more than one second over the estimated time, highlight it.
+  const renderedTime =
+    estimatedTime && runTime >= estimatedTime + 1
+      ? _chalk().default.bold.yellow((0, _jestUtil().formatTime)(runTime, 0))
+      : (0, _jestUtil().formatTime)(runTime, 0);
+  let time = _chalk().default.bold(`Time:`) + `        ${renderedTime}`;
+
+  if (runTime < estimatedTime) {
+    time += `, estimated ${(0, _jestUtil().formatTime)(estimatedTime, 0)}`;
+  } // Only show a progress bar if the test run is actually going to take
+  // some time.
+
+  if (estimatedTime > 2 && runTime < estimatedTime && width) {
+    const availableWidth = Math.min(PROGRESS_BAR_WIDTH, width);
+    const length = Math.min(
+      Math.floor((runTime / estimatedTime) * availableWidth),
+      availableWidth
+    );
+
+    if (availableWidth >= 2) {
+      time +=
+        '\n' +
+        _chalk().default.green('█').repeat(length) +
+        _chalk()
+          .default.white('█')
+          .repeat(availableWidth - length);
+    }
+  }
+
+  return time;
+}; // word-wrap a string that contains ANSI escape sequences.
+// ANSI escape sequences do not add to the string length.
+
+const wrapAnsiString = (string, terminalWidth) => {
+  if (terminalWidth === 0) {
+    // if the terminal width is zero, don't bother word-wrapping
+    return string;
+  }
+
+  const ANSI_REGEXP = /[\u001b\u009b]\[\d{1,2}m/g;
+  const tokens = [];
+  let lastIndex = 0;
+  let match;
+
+  while ((match = ANSI_REGEXP.exec(string))) {
+    const ansi = match[0];
+    const index = match['index'];
+
+    if (index != lastIndex) {
+      tokens.push(['string', string.slice(lastIndex, index)]);
+    }
+
+    tokens.push(['ansi', ansi]);
+    lastIndex = index + ansi.length;
+  }
+
+  if (lastIndex != string.length - 1) {
+    tokens.push(['string', string.slice(lastIndex, string.length)]);
+  }
+
+  let lastLineLength = 0;
+  return tokens
+    .reduce(
+      (lines, [kind, token]) => {
+        if (kind === 'string') {
+          if (lastLineLength + token.length > terminalWidth) {
+            while (token.length) {
+              const chunk = token.slice(0, terminalWidth - lastLineLength);
+              const remaining = token.slice(
+                terminalWidth - lastLineLength,
+                token.length
+              );
+              lines[lines.length - 1] += chunk;
+              lastLineLength += chunk.length;
+              token = remaining;
+
+              if (token.length) {
+                lines.push('');
+                lastLineLength = 0;
+              }
+            }
+          } else {
+            lines[lines.length - 1] += token;
+            lastLineLength += token.length;
+          }
+        } else {
+          lines[lines.length - 1] += token;
+        }
+
+        return lines;
+      },
+      ['']
+    )
+    .join('\n');
+};
+
+exports.wrapAnsiString = wrapAnsiString;

node_modules/@jest/reporters/node_modules/.bin/semver

@@ -0,0 +1 @@
+../semver/bin/semver.js

node_modules/@jest/reporters/node_modules/ansi-styles/index.d.ts

@@ -0,0 +1,345 @@
+declare type CSSColor =
+	| 'aliceblue'
+	| 'antiquewhite'
+	| 'aqua'
+	| 'aquamarine'
+	| 'azure'
+	| 'beige'
+	| 'bisque'
+	| 'black'
+	| 'blanchedalmond'
+	| 'blue'
+	| 'blueviolet'
+	| 'brown'
+	| 'burlywood'
+	| 'cadetblue'
+	| 'chartreuse'
+	| 'chocolate'
+	| 'coral'
+	| 'cornflowerblue'
+	| 'cornsilk'
+	| 'crimson'
+	| 'cyan'
+	| 'darkblue'
+	| 'darkcyan'
+	| 'darkgoldenrod'
+	| 'darkgray'
+	| 'darkgreen'
+	| 'darkgrey'
+	| 'darkkhaki'
+	| 'darkmagenta'
+	| 'darkolivegreen'
+	| 'darkorange'
+	| 'darkorchid'
+	| 'darkred'
+	| 'darksalmon'
+	| 'darkseagreen'
+	| 'darkslateblue'
+	| 'darkslategray'
+	| 'darkslategrey'
+	| 'darkturquoise'
+	| 'darkviolet'
+	| 'deeppink'
+	| 'deepskyblue'
+	| 'dimgray'
+	| 'dimgrey'
+	| 'dodgerblue'
+	| 'firebrick'
+	| 'floralwhite'
+	| 'forestgreen'
+	| 'fuchsia'
+	| 'gainsboro'
+	| 'ghostwhite'
+	| 'gold'
+	| 'goldenrod'
+	| 'gray'
+	| 'green'
+	| 'greenyellow'
+	| 'grey'
+	| 'honeydew'
+	| 'hotpink'
+	| 'indianred'
+	| 'indigo'
+	| 'ivory'
+	| 'khaki'
+	| 'lavender'
+	| 'lavenderblush'
+	| 'lawngreen'
+	| 'lemonchiffon'
+	| 'lightblue'
+	| 'lightcoral'
+	| 'lightcyan'
+	| 'lightgoldenrodyellow'
+	| 'lightgray'
+	| 'lightgreen'
+	| 'lightgrey'
+	| 'lightpink'
+	| 'lightsalmon'
+	| 'lightseagreen'
+	| 'lightskyblue'
+	| 'lightslategray'
+	| 'lightslategrey'
+	| 'lightsteelblue'
+	| 'lightyellow'
+	| 'lime'
+	| 'limegreen'
+	| 'linen'
+	| 'magenta'
+	| 'maroon'
+	| 'mediumaquamarine'
+	| 'mediumblue'
+	| 'mediumorchid'
+	| 'mediumpurple'
+	| 'mediumseagreen'
+	| 'mediumslateblue'
+	| 'mediumspringgreen'
+	| 'mediumturquoise'
+	| 'mediumvioletred'
+	| 'midnightblue'
+	| 'mintcream'
+	| 'mistyrose'
+	| 'moccasin'
+	| 'navajowhite'
+	| 'navy'
+	| 'oldlace'
+	| 'olive'
+	| 'olivedrab'
+	| 'orange'
+	| 'orangered'
+	| 'orchid'
+	| 'palegoldenrod'
+	| 'palegreen'
+	| 'paleturquoise'
+	| 'palevioletred'
+	| 'papayawhip'
+	| 'peachpuff'
+	| 'peru'
+	| 'pink'
+	| 'plum'
+	| 'powderblue'
+	| 'purple'
+	| 'rebeccapurple'
+	| 'red'
+	| 'rosybrown'
+	| 'royalblue'
+	| 'saddlebrown'
+	| 'salmon'
+	| 'sandybrown'
+	| 'seagreen'
+	| 'seashell'
+	| 'sienna'
+	| 'silver'
+	| 'skyblue'
+	| 'slateblue'
+	| 'slategray'
+	| 'slategrey'
+	| 'snow'
+	| 'springgreen'
+	| 'steelblue'
+	| 'tan'
+	| 'teal'
+	| 'thistle'
+	| 'tomato'
+	| 'turquoise'
+	| 'violet'
+	| 'wheat'
+	| 'white'
+	| 'whitesmoke'
+	| 'yellow'
+	| 'yellowgreen';
+
+declare namespace ansiStyles {
+	interface ColorConvert {
+		/**
+		The RGB color space.
+
+		@param red - (`0`-`255`)
+		@param green - (`0`-`255`)
+		@param blue - (`0`-`255`)
+		*/
+		rgb(red: number, green: number, blue: number): string;
+
+		/**
+		The RGB HEX color space.
+
+		@param hex - A hexadecimal string containing RGB data.
+		*/
+		hex(hex: string): string;
+
+		/**
+		@param keyword - A CSS color name.
+		*/
+		keyword(keyword: CSSColor): string;
+
+		/**
+		The HSL color space.
+
+		@param hue - (`0`-`360`)
+		@param saturation - (`0`-`100`)
+		@param lightness - (`0`-`100`)
+		*/
+		hsl(hue: number, saturation: number, lightness: number): string;
+
+		/**
+		The HSV color space.
+
+		@param hue - (`0`-`360`)
+		@param saturation - (`0`-`100`)
+		@param value - (`0`-`100`)
+		*/
+		hsv(hue: number, saturation: number, value: number): string;
+
+		/**
+		The HSV color space.
+
+		@param hue - (`0`-`360`)
+		@param whiteness - (`0`-`100`)
+		@param blackness - (`0`-`100`)
+		*/
+		hwb(hue: number, whiteness: number, blackness: number): string;
+
+		/**
+		Use a [4-bit unsigned number](https://en.wikipedia.org/wiki/ANSI_escape_code#3/4-bit) to set text color.
+		*/
+		ansi(ansi: number): string;
+
+		/**
+		Use an [8-bit unsigned number](https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit) to set text color.
+		*/
+		ansi256(ansi: number): string;
+	}
+
+	interface CSPair {
+		/**
+		The ANSI terminal control sequence for starting this style.
+		*/
+		readonly open: string;
+
+		/**
+		The ANSI terminal control sequence for ending this style.
+		*/
+		readonly close: string;
+	}
+
+	interface ColorBase {
+		readonly ansi: ColorConvert;
+		readonly ansi256: ColorConvert;
+		readonly ansi16m: ColorConvert;
+
+		/**
+		The ANSI terminal control sequence for ending this color.
+		*/
+		readonly close: string;
+	}
+
+	interface Modifier {
+		/**
+		Resets the current color chain.
+		*/
+		readonly reset: CSPair;
+
+		/**
+		Make text bold.
+		*/
+		readonly bold: CSPair;
+
+		/**
+		Emitting only a small amount of light.
+		*/
+		readonly dim: CSPair;
+
+		/**
+		Make text italic. (Not widely supported)
+		*/
+		readonly italic: CSPair;
+
+		/**
+		Make text underline. (Not widely supported)
+		*/
+		readonly underline: CSPair;
+
+		/**
+		Inverse background and foreground colors.
+		*/
+		readonly inverse: CSPair;
+
+		/**
+		Prints the text, but makes it invisible.
+		*/
+		readonly hidden: CSPair;
+
+		/**
+		Puts a horizontal line through the center of the text. (Not widely supported)
+		*/
+		readonly strikethrough: CSPair;
+	}
+
+	interface ForegroundColor {
+		readonly black: CSPair;
+		readonly red: CSPair;
+		readonly green: CSPair;
+		readonly yellow: CSPair;
+		readonly blue: CSPair;
+		readonly cyan: CSPair;
+		readonly magenta: CSPair;
+		readonly white: CSPair;
+
+		/**
+		Alias for `blackBright`.
+		*/
+		readonly gray: CSPair;
+
+		/**
+		Alias for `blackBright`.
+		*/
+		readonly grey: CSPair;
+
+		readonly blackBright: CSPair;
+		readonly redBright: CSPair;
+		readonly greenBright: CSPair;
+		readonly yellowBright: CSPair;
+		readonly blueBright: CSPair;
+		readonly cyanBright: CSPair;
+		readonly magentaBright: CSPair;
+		readonly whiteBright: CSPair;
+	}
+
+	interface BackgroundColor {
+		readonly bgBlack: CSPair;
+		readonly bgRed: CSPair;
+		readonly bgGreen: CSPair;
+		readonly bgYellow: CSPair;
+		readonly bgBlue: CSPair;
+		readonly bgCyan: CSPair;
+		readonly bgMagenta: CSPair;
+		readonly bgWhite: CSPair;
+
+		/**
+		Alias for `bgBlackBright`.
+		*/
+		readonly bgGray: CSPair;
+
+		/**
+		Alias for `bgBlackBright`.
+		*/
+		readonly bgGrey: CSPair;
+
+		readonly bgBlackBright: CSPair;
+		readonly bgRedBright: CSPair;
+		readonly bgGreenBright: CSPair;
+		readonly bgYellowBright: CSPair;
+		readonly bgBlueBright: CSPair;
+		readonly bgCyanBright: CSPair;
+		readonly bgMagentaBright: CSPair;
+		readonly bgWhiteBright: CSPair;
+	}
+}
+
+declare const ansiStyles: {
+	readonly modifier: ansiStyles.Modifier;
+	readonly color: ansiStyles.ForegroundColor & ansiStyles.ColorBase;
+	readonly bgColor: ansiStyles.BackgroundColor & ansiStyles.ColorBase;
+	readonly codes: ReadonlyMap<number, number>;
+} & ansiStyles.BackgroundColor & ansiStyles.ForegroundColor & ansiStyles.Modifier;
+
+export = ansiStyles;

node_modules/@jest/reporters/node_modules/ansi-styles/index.js

@@ -0,0 +1,163 @@
+'use strict';
+
+const wrapAnsi16 = (fn, offset) => (...args) => {
+	const code = fn(...args);
+	return `\u001B[${code + offset}m`;
+};
+
+const wrapAnsi256 = (fn, offset) => (...args) => {
+	const code = fn(...args);
+	return `\u001B[${38 + offset};5;${code}m`;
+};
+
+const wrapAnsi16m = (fn, offset) => (...args) => {
+	const rgb = fn(...args);
+	return `\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+};
+
+const ansi2ansi = n => n;
+const rgb2rgb = (r, g, b) => [r, g, b];
+
+const setLazyProperty = (object, property, get) => {
+	Object.defineProperty(object, property, {
+		get: () => {
+			const value = get();
+
+			Object.defineProperty(object, property, {
+				value,
+				enumerable: true,
+				configurable: true
+			});
+
+			return value;
+		},
+		enumerable: true,
+		configurable: true
+	});
+};
+
+/** @type {typeof import('color-convert')} */
+let colorConvert;
+const makeDynamicStyles = (wrap, targetSpace, identity, isBackground) => {
+	if (colorConvert === undefined) {
+		colorConvert = require('color-convert');
+	}
+
+	const offset = isBackground ? 10 : 0;
+	const styles = {};
+
+	for (const [sourceSpace, suite] of Object.entries(colorConvert)) {
+		const name = sourceSpace === 'ansi16' ? 'ansi' : sourceSpace;
+		if (sourceSpace === targetSpace) {
+			styles[name] = wrap(identity, offset);
+		} else if (typeof suite === 'object') {
+			styles[name] = wrap(suite[targetSpace], offset);
+		}
+	}
+
+	return styles;
+};
+
+function assembleStyles() {
+	const codes = new Map();
+	const styles = {
+		modifier: {
+			reset: [0, 0],
+			// 21 isn't widely supported and 22 does the same thing
+			bold: [1, 22],
+			dim: [2, 22],
+			italic: [3, 23],
+			underline: [4, 24],
+			inverse: [7, 27],
+			hidden: [8, 28],
+			strikethrough: [9, 29]
+		},
+		color: {
+			black: [30, 39],
+			red: [31, 39],
+			green: [32, 39],
+			yellow: [33, 39],
+			blue: [34, 39],
+			magenta: [35, 39],
+			cyan: [36, 39],
+			white: [37, 39],
+
+			// Bright color
+			blackBright: [90, 39],
+			redBright: [91, 39],
+			greenBright: [92, 39],
+			yellowBright: [93, 39],
+			blueBright: [94, 39],
+			magentaBright: [95, 39],
+			cyanBright: [96, 39],
+			whiteBright: [97, 39]
+		},
+		bgColor: {
+			bgBlack: [40, 49],
+			bgRed: [41, 49],
+			bgGreen: [42, 49],
+			bgYellow: [43, 49],
+			bgBlue: [44, 49],
+			bgMagenta: [45, 49],
+			bgCyan: [46, 49],
+			bgWhite: [47, 49],
+
+			// Bright color
+			bgBlackBright: [100, 49],
+			bgRedBright: [101, 49],
+			bgGreenBright: [102, 49],
+			bgYellowBright: [103, 49],
+			bgBlueBright: [104, 49],
+			bgMagentaBright: [105, 49],
+			bgCyanBright: [106, 49],
+			bgWhiteBright: [107, 49]
+		}
+	};
+
+	// Alias bright black as gray (and grey)
+	styles.color.gray = styles.color.blackBright;
+	styles.bgColor.bgGray = styles.bgColor.bgBlackBright;
+	styles.color.grey = styles.color.blackBright;
+	styles.bgColor.bgGrey = styles.bgColor.bgBlackBright;
+
+	for (const [groupName, group] of Object.entries(styles)) {
+		for (const [styleName, style] of Object.entries(group)) {
+			styles[styleName] = {
+				open: `\u001B[${style[0]}m`,
+				close: `\u001B[${style[1]}m`
+			};
+
+			group[styleName] = styles[styleName];
+
+			codes.set(style[0], style[1]);
+		}
+
+		Object.defineProperty(styles, groupName, {
+			value: group,
+			enumerable: false
+		});
+	}
+
+	Object.defineProperty(styles, 'codes', {
+		value: codes,
+		enumerable: false
+	});
+
+	styles.color.close = '\u001B[39m';
+	styles.bgColor.close = '\u001B[49m';
+
+	setLazyProperty(styles.color, 'ansi', () => makeDynamicStyles(wrapAnsi16, 'ansi16', ansi2ansi, false));
+	setLazyProperty(styles.color, 'ansi256', () => makeDynamicStyles(wrapAnsi256, 'ansi256', ansi2ansi, false));
+	setLazyProperty(styles.color, 'ansi16m', () => makeDynamicStyles(wrapAnsi16m, 'rgb', rgb2rgb, false));
+	setLazyProperty(styles.bgColor, 'ansi', () => makeDynamicStyles(wrapAnsi16, 'ansi16', ansi2ansi, true));
+	setLazyProperty(styles.bgColor, 'ansi256', () => makeDynamicStyles(wrapAnsi256, 'ansi256', ansi2ansi, true));
+	setLazyProperty(styles.bgColor, 'ansi16m', () => makeDynamicStyles(wrapAnsi16m, 'rgb', rgb2rgb, true));
+
+	return styles;
+}
+
+// Make the export immutable
+Object.defineProperty(module, 'exports', {
+	enumerable: true,
+	get: assembleStyles
+});

node_modules/@jest/reporters/node_modules/ansi-styles/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+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/reporters/node_modules/ansi-styles/package.json

@@ -0,0 +1,56 @@
+{
+	"name": "ansi-styles",
+	"version": "4.3.0",
+	"description": "ANSI escape codes for styling strings in the terminal",
+	"license": "MIT",
+	"repository": "chalk/ansi-styles",
+	"funding": "https://github.com/chalk/ansi-styles?sponsor=1",
+	"author": {
+		"name": "Sindre Sorhus",
+		"email": "sindresorhus@gmail.com",
+		"url": "sindresorhus.com"
+	},
+	"engines": {
+		"node": ">=8"
+	},
+	"scripts": {
+		"test": "xo && ava && tsd",
+		"screenshot": "svg-term --command='node screenshot' --out=screenshot.svg --padding=3 --width=55 --height=3 --at=1000 --no-cursor"
+	},
+	"files": [
+		"index.js",
+		"index.d.ts"
+	],
+	"keywords": [
+		"ansi",
+		"styles",
+		"color",
+		"colour",
+		"colors",
+		"terminal",
+		"console",
+		"cli",
+		"string",
+		"tty",
+		"escape",
+		"formatting",
+		"rgb",
+		"256",
+		"shell",
+		"xterm",
+		"log",
+		"logging",
+		"command-line",
+		"text"
+	],
+	"dependencies": {
+		"color-convert": "^2.0.1"
+	},
+	"devDependencies": {
+		"@types/color-convert": "^1.9.0",
+		"ava": "^2.3.0",
+		"svg-term-cli": "^2.1.1",
+		"tsd": "^0.11.0",
+		"xo": "^0.25.3"
+	}
+}

node_modules/@jest/reporters/node_modules/ansi-styles/readme.md

@@ -0,0 +1,152 @@
+# ansi-styles [![Build Status](https://travis-ci.org/chalk/ansi-styles.svg?branch=master)](https://travis-ci.org/chalk/ansi-styles)
+
+> [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors_and_Styles) for styling strings in the terminal
+
+You probably want the higher-level [chalk](https://github.com/chalk/chalk) module for styling your strings.
+
+<img src="screenshot.svg" width="900">
+
+## Install
+
+```
+$ npm install ansi-styles
+```
+
+## Usage
+
+```js
+const style = require('ansi-styles');
+
+console.log(`${style.green.open}Hello world!${style.green.close}`);
+
+
+// Color conversion between 16/256/truecolor
+// NOTE: If conversion goes to 16 colors or 256 colors, the original color
+//       may be degraded to fit that color palette. This means terminals
+//       that do not support 16 million colors will best-match the
+//       original color.
+console.log(style.bgColor.ansi.hsl(120, 80, 72) + 'Hello world!' + style.bgColor.close);
+console.log(style.color.ansi256.rgb(199, 20, 250) + 'Hello world!' + style.color.close);
+console.log(style.color.ansi16m.hex('#abcdef') + 'Hello world!' + style.color.close);
+```
+
+## API
+
+Each style has an `open` and `close` property.
+
+## Styles
+
+### Modifiers
+
+- `reset`
+- `bold`
+- `dim`
+- `italic` *(Not widely supported)*
+- `underline`
+- `inverse`
+- `hidden`
+- `strikethrough` *(Not widely supported)*
+
+### Colors
+
+- `black`
+- `red`
+- `green`
+- `yellow`
+- `blue`
+- `magenta`
+- `cyan`
+- `white`
+- `blackBright` (alias: `gray`, `grey`)
+- `redBright`
+- `greenBright`
+- `yellowBright`
+- `blueBright`
+- `magentaBright`
+- `cyanBright`
+- `whiteBright`
+
+### Background colors
+
+- `bgBlack`
+- `bgRed`
+- `bgGreen`
+- `bgYellow`
+- `bgBlue`
+- `bgMagenta`
+- `bgCyan`
+- `bgWhite`
+- `bgBlackBright` (alias: `bgGray`, `bgGrey`)
+- `bgRedBright`
+- `bgGreenBright`
+- `bgYellowBright`
+- `bgBlueBright`
+- `bgMagentaBright`
+- `bgCyanBright`
+- `bgWhiteBright`
+
+## Advanced usage
+
+By default, you get a map of styles, but the styles are also available as groups. They are non-enumerable so they don't show up unless you access them explicitly. This makes it easier to expose only a subset in a higher-level module.
+
+- `style.modifier`
+- `style.color`
+- `style.bgColor`
+
+###### Example
+
+```js
+console.log(style.color.green.open);
+```
+
+Raw escape codes (i.e. without the CSI escape prefix `\u001B[` and render mode postfix `m`) are available under `style.codes`, which returns a `Map` with the open codes as keys and close codes as values.
+
+###### Example
+
+```js
+console.log(style.codes.get(36));
+//=> 39
+```
+
+## [256 / 16 million (TrueColor) support](https://gist.github.com/XVilka/8346728)
+
+`ansi-styles` uses the [`color-convert`](https://github.com/Qix-/color-convert) package to allow for converting between various colors and ANSI escapes, with support for 256 and 16 million colors.
+
+The following color spaces from `color-convert` are supported:
+
+- `rgb`
+- `hex`
+- `keyword`
+- `hsl`
+- `hsv`
+- `hwb`
+- `ansi`
+- `ansi256`
+
+To use these, call the associated conversion function with the intended output, for example:
+
+```js
+style.color.ansi.rgb(100, 200, 15); // RGB to 16 color ansi foreground code
+style.bgColor.ansi.rgb(100, 200, 15); // RGB to 16 color ansi background code
+
+style.color.ansi256.hsl(120, 100, 60); // HSL to 256 color ansi foreground code
+style.bgColor.ansi256.hsl(120, 100, 60); // HSL to 256 color ansi foreground code
+
+style.color.ansi16m.hex('#C0FFEE'); // Hex (RGB) to 16 million color foreground code
+style.bgColor.ansi16m.hex('#C0FFEE'); // Hex (RGB) to 16 million color background code
+```
+
+## Related
+
+- [ansi-escapes](https://github.com/sindresorhus/ansi-escapes) - ANSI escape codes for manipulating the terminal
+
+## Maintainers
+
+- [Sindre Sorhus](https://github.com/sindresorhus)
+- [Josh Junon](https://github.com/qix-)
+
+## For enterprise
+
+Available as part of the Tidelift Subscription.
+
+The maintainers of `ansi-styles` and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/npm-ansi-styles?utm_source=npm-ansi-styles&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)

node_modules/@jest/reporters/node_modules/chalk/index.d.ts

@@ -0,0 +1,415 @@
+/**
+Basic foreground colors.
+
+[More colors here.](https://github.com/chalk/chalk/blob/master/readme.md#256-and-truecolor-color-support)
+*/
+declare type ForegroundColor =
+	| 'black'
+	| 'red'
+	| 'green'
+	| 'yellow'
+	| 'blue'
+	| 'magenta'
+	| 'cyan'
+	| 'white'
+	| 'gray'
+	| 'grey'
+	| 'blackBright'
+	| 'redBright'
+	| 'greenBright'
+	| 'yellowBright'
+	| 'blueBright'
+	| 'magentaBright'
+	| 'cyanBright'
+	| 'whiteBright';
+
+/**
+Basic background colors.
+
+[More colors here.](https://github.com/chalk/chalk/blob/master/readme.md#256-and-truecolor-color-support)
+*/
+declare type BackgroundColor =
+	| 'bgBlack'
+	| 'bgRed'
+	| 'bgGreen'
+	| 'bgYellow'
+	| 'bgBlue'
+	| 'bgMagenta'
+	| 'bgCyan'
+	| 'bgWhite'
+	| 'bgGray'
+	| 'bgGrey'
+	| 'bgBlackBright'
+	| 'bgRedBright'
+	| 'bgGreenBright'
+	| 'bgYellowBright'
+	| 'bgBlueBright'
+	| 'bgMagentaBright'
+	| 'bgCyanBright'
+	| 'bgWhiteBright';
+
+/**
+Basic colors.
+
+[More colors here.](https://github.com/chalk/chalk/blob/master/readme.md#256-and-truecolor-color-support)
+*/
+declare type Color = ForegroundColor | BackgroundColor;
+
+declare type Modifiers =
+	| 'reset'
+	| 'bold'
+	| 'dim'
+	| 'italic'
+	| 'underline'
+	| 'inverse'
+	| 'hidden'
+	| 'strikethrough'
+	| 'visible';
+
+declare namespace chalk {
+	/**
+	Levels:
+	- `0` - All colors disabled.
+	- `1` - Basic 16 colors support.
+	- `2` - ANSI 256 colors support.
+	- `3` - Truecolor 16 million colors support.
+	*/
+	type Level = 0 | 1 | 2 | 3;
+
+	interface Options {
+		/**
+		Specify the color support for Chalk.
+
+		By default, color support is automatically detected based on the environment.
+
+		Levels:
+		- `0` - All colors disabled.
+		- `1` - Basic 16 colors support.
+		- `2` - ANSI 256 colors support.
+		- `3` - Truecolor 16 million colors support.
+		*/
+		level?: Level;
+	}
+
+	/**
+	Return a new Chalk instance.
+	*/
+	type Instance = new (options?: Options) => Chalk;
+
+	/**
+	Detect whether the terminal supports color.
+	*/
+	interface ColorSupport {
+		/**
+		The color level used by Chalk.
+		*/
+		level: Level;
+
+		/**
+		Return whether Chalk supports basic 16 colors.
+		*/
+		hasBasic: boolean;
+
+		/**
+		Return whether Chalk supports ANSI 256 colors.
+		*/
+		has256: boolean;
+
+		/**
+		Return whether Chalk supports Truecolor 16 million colors.
+		*/
+		has16m: boolean;
+	}
+
+	interface ChalkFunction {
+		/**
+		Use a template string.
+
+		@remarks Template literals are unsupported for nested calls (see [issue #341](https://github.com/chalk/chalk/issues/341))
+
+		@example
+		```
+		import chalk = require('chalk');
+
+		log(chalk`
+		CPU: {red ${cpu.totalPercent}%}
+		RAM: {green ${ram.used / ram.total * 100}%}
+		DISK: {rgb(255,131,0) ${disk.used / disk.total * 100}%}
+		`);
+		```
+
+		@example
+		```
+		import chalk = require('chalk');
+
+		log(chalk.red.bgBlack`2 + 3 = {bold ${2 + 3}}`)
+		```
+		*/
+		(text: TemplateStringsArray, ...placeholders: unknown[]): string;
+
+		(...text: unknown[]): string;
+	}
+
+	interface Chalk extends ChalkFunction {
+		/**
+		Return a new Chalk instance.
+		*/
+		Instance: Instance;
+
+		/**
+		The color support for Chalk.
+
+		By default, color support is automatically detected based on the environment.
+
+		Levels:
+		- `0` - All colors disabled.
+		- `1` - Basic 16 colors support.
+		- `2` - ANSI 256 colors support.
+		- `3` - Truecolor 16 million colors support.
+		*/
+		level: Level;
+
+		/**
+		Use HEX value to set text color.
+
+		@param color - Hexadecimal value representing the desired color.
+
+		@example
+		```
+		import chalk = require('chalk');
+
+		chalk.hex('#DEADED');
+		```
+		*/
+		hex(color: string): Chalk;
+
+		/**
+		Use keyword color value to set text color.
+
+		@param color - Keyword value representing the desired color.
+
+		@example
+		```
+		import chalk = require('chalk');
+
+		chalk.keyword('orange');
+		```
+		*/
+		keyword(color: string): Chalk;
+
+		/**
+		Use RGB values to set text color.
+		*/
+		rgb(red: number, green: number, blue: number): Chalk;
+
+		/**
+		Use HSL values to set text color.
+		*/
+		hsl(hue: number, saturation: number, lightness: number): Chalk;
+
+		/**
+		Use HSV values to set text color.
+		*/
+		hsv(hue: number, saturation: number, value: number): Chalk;
+
+		/**
+		Use HWB values to set text color.
+		*/
+		hwb(hue: number, whiteness: number, blackness: number): Chalk;
+
+		/**
+		Use a [Select/Set Graphic Rendition](https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_parameters) (SGR) [color code number](https://en.wikipedia.org/wiki/ANSI_escape_code#3/4_bit) to set text color.
+
+		30 <= code && code < 38 || 90 <= code && code < 98
+		For example, 31 for red, 91 for redBright.
+		*/
+		ansi(code: number): Chalk;
+
+		/**
+		Use a [8-bit unsigned number](https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit) to set text color.
+		*/
+		ansi256(index: number): Chalk;
+
+		/**
+		Use HEX value to set background color.
+
+		@param color - Hexadecimal value representing the desired color.
+
+		@example
+		```
+		import chalk = require('chalk');
+
+		chalk.bgHex('#DEADED');
+		```
+		*/
+		bgHex(color: string): Chalk;
+
+		/**
+		Use keyword color value to set background color.
+
+		@param color - Keyword value representing the desired color.
+
+		@example
+		```
+		import chalk = require('chalk');
+
+		chalk.bgKeyword('orange');
+		```
+		*/
+		bgKeyword(color: string): Chalk;
+
+		/**
+		Use RGB values to set background color.
+		*/
+		bgRgb(red: number, green: number, blue: number): Chalk;
+
+		/**
+		Use HSL values to set background color.
+		*/
+		bgHsl(hue: number, saturation: number, lightness: number): Chalk;
+
+		/**
+		Use HSV values to set background color.
+		*/
+		bgHsv(hue: number, saturation: number, value: number): Chalk;
+
+		/**
+		Use HWB values to set background color.
+		*/
+		bgHwb(hue: number, whiteness: number, blackness: number): Chalk;
+
+		/**
+		Use a [Select/Set Graphic Rendition](https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_parameters) (SGR) [color code number](https://en.wikipedia.org/wiki/ANSI_escape_code#3/4_bit) to set background color.
+
+		30 <= code && code < 38 || 90 <= code && code < 98
+		For example, 31 for red, 91 for redBright.
+		Use the foreground code, not the background code (for example, not 41, nor 101).
+		*/
+		bgAnsi(code: number): Chalk;
+
+		/**
+		Use a [8-bit unsigned number](https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit) to set background color.
+		*/
+		bgAnsi256(index: number): Chalk;
+
+		/**
+		Modifier: Resets the current color chain.
+		*/
+		readonly reset: Chalk;
+
+		/**
+		Modifier: Make text bold.
+		*/
+		readonly bold: Chalk;
+
+		/**
+		Modifier: Emitting only a small amount of light.
+		*/
+		readonly dim: Chalk;
+
+		/**
+		Modifier: Make text italic. (Not widely supported)
+		*/
+		readonly italic: Chalk;
+
+		/**
+		Modifier: Make text underline. (Not widely supported)
+		*/
+		readonly underline: Chalk;
+
+		/**
+		Modifier: Inverse background and foreground colors.
+		*/
+		readonly inverse: Chalk;
+
+		/**
+		Modifier: Prints the text, but makes it invisible.
+		*/
+		readonly hidden: Chalk;
+
+		/**
+		Modifier: Puts a horizontal line through the center of the text. (Not widely supported)
+		*/
+		readonly strikethrough: Chalk;
+
+		/**
+		Modifier: Prints the text only when Chalk has a color support level > 0.
+		Can be useful for things that are purely cosmetic.
+		*/
+		readonly visible: Chalk;
+
+		readonly black: Chalk;
+		readonly red: Chalk;
+		readonly green: Chalk;
+		readonly yellow: Chalk;
+		readonly blue: Chalk;
+		readonly magenta: Chalk;
+		readonly cyan: Chalk;
+		readonly white: Chalk;
+
+		/*
+		Alias for `blackBright`.
+		*/
+		readonly gray: Chalk;
+
+		/*
+		Alias for `blackBright`.
+		*/
+		readonly grey: Chalk;
+
+		readonly blackBright: Chalk;
+		readonly redBright: Chalk;
+		readonly greenBright: Chalk;
+		readonly yellowBright: Chalk;
+		readonly blueBright: Chalk;
+		readonly magentaBright: Chalk;
+		readonly cyanBright: Chalk;
+		readonly whiteBright: Chalk;
+
+		readonly bgBlack: Chalk;
+		readonly bgRed: Chalk;
+		readonly bgGreen: Chalk;
+		readonly bgYellow: Chalk;
+		readonly bgBlue: Chalk;
+		readonly bgMagenta: Chalk;
+		readonly bgCyan: Chalk;
+		readonly bgWhite: Chalk;
+
+		/*
+		Alias for `bgBlackBright`.
+		*/
+		readonly bgGray: Chalk;
+
+		/*
+		Alias for `bgBlackBright`.
+		*/
+		readonly bgGrey: Chalk;
+
+		readonly bgBlackBright: Chalk;
+		readonly bgRedBright: Chalk;
+		readonly bgGreenBright: Chalk;
+		readonly bgYellowBright: Chalk;
+		readonly bgBlueBright: Chalk;
+		readonly bgMagentaBright: Chalk;
+		readonly bgCyanBright: Chalk;
+		readonly bgWhiteBright: Chalk;
+	}
+}
+
+/**
+Main Chalk object that allows to chain styles together.
+Call the last one as a method with a string argument.
+Order doesn't matter, and later styles take precedent in case of a conflict.
+This simply means that `chalk.red.yellow.green` is equivalent to `chalk.green`.
+*/
+declare const chalk: chalk.Chalk & chalk.ChalkFunction & {
+	supportsColor: chalk.ColorSupport | false;
+	Level: chalk.Level;
+	Color: Color;
+	ForegroundColor: ForegroundColor;
+	BackgroundColor: BackgroundColor;
+	Modifiers: Modifiers;
+	stderr: chalk.Chalk & {supportsColor: chalk.ColorSupport | false};
+};
+
+export = chalk;

node_modules/@jest/reporters/node_modules/chalk/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+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/reporters/node_modules/chalk/package.json

@@ -0,0 +1,68 @@
+{
+	"name": "chalk",
+	"version": "4.1.2",
+	"description": "Terminal string styling done right",
+	"license": "MIT",
+	"repository": "chalk/chalk",
+	"funding": "https://github.com/chalk/chalk?sponsor=1",
+	"main": "source",
+	"engines": {
+		"node": ">=10"
+	},
+	"scripts": {
+		"test": "xo && nyc ava && tsd",
+		"bench": "matcha benchmark.js"
+	},
+	"files": [
+		"source",
+		"index.d.ts"
+	],
+	"keywords": [
+		"color",
+		"colour",
+		"colors",
+		"terminal",
+		"console",
+		"cli",
+		"string",
+		"str",
+		"ansi",
+		"style",
+		"styles",
+		"tty",
+		"formatting",
+		"rgb",
+		"256",
+		"shell",
+		"xterm",
+		"log",
+		"logging",
+		"command-line",
+		"text"
+	],
+	"dependencies": {
+		"ansi-styles": "^4.1.0",
+		"supports-color": "^7.1.0"
+	},
+	"devDependencies": {
+		"ava": "^2.4.0",
+		"coveralls": "^3.0.7",
+		"execa": "^4.0.0",
+		"import-fresh": "^3.1.0",
+		"matcha": "^0.7.0",
+		"nyc": "^15.0.0",
+		"resolve-from": "^5.0.0",
+		"tsd": "^0.7.4",
+		"xo": "^0.28.2"
+	},
+	"xo": {
+		"rules": {
+			"unicorn/prefer-string-slice": "off",
+			"unicorn/prefer-includes": "off",
+			"@typescript-eslint/member-ordering": "off",
+			"no-redeclare": "off",
+			"unicorn/string-content": "off",
+			"unicorn/better-regex": "off"
+		}
+	}
+}

node_modules/@jest/reporters/node_modules/chalk/readme.md

@@ -0,0 +1,341 @@
+<h1 align="center">
+	<br>
+	<br>
+	<img width="320" src="media/logo.svg" alt="Chalk">
+	<br>
+	<br>
+	<br>
+</h1>
+
+> Terminal string styling done right
+
+[![Build Status](https://travis-ci.org/chalk/chalk.svg?branch=master)](https://travis-ci.org/chalk/chalk) [![Coverage Status](https://coveralls.io/repos/github/chalk/chalk/badge.svg?branch=master)](https://coveralls.io/github/chalk/chalk?branch=master) [![npm dependents](https://badgen.net/npm/dependents/chalk)](https://www.npmjs.com/package/chalk?activeTab=dependents) [![Downloads](https://badgen.net/npm/dt/chalk)](https://www.npmjs.com/package/chalk) [![](https://img.shields.io/badge/unicorn-approved-ff69b4.svg)](https://www.youtube.com/watch?v=9auOCbH5Ns4) [![XO code style](https://img.shields.io/badge/code_style-XO-5ed9c7.svg)](https://github.com/xojs/xo) ![TypeScript-ready](https://img.shields.io/npm/types/chalk.svg) [![run on repl.it](https://repl.it/badge/github/chalk/chalk)](https://repl.it/github/chalk/chalk)
+
+<img src="https://cdn.jsdelivr.net/gh/chalk/ansi-styles@8261697c95bf34b6c7767e2cbe9941a851d59385/screenshot.svg" width="900">
+
+<br>
+
+---
+
+<div align="center">
+	<p>
+		<p>
+			<sup>
+				Sindre Sorhus' open source work is supported by the community on <a href="https://github.com/sponsors/sindresorhus">GitHub Sponsors</a> and <a href="https://stakes.social/0x44d871aebF0126Bf646753E2C976Aa7e68A66c15">Dev</a>
+			</sup>
+		</p>
+		<sup>Special thanks to:</sup>
+		<br>
+		<br>
+		<a href="https://standardresume.co/tech">
+			<img src="https://sindresorhus.com/assets/thanks/standard-resume-logo.svg" width="160"/>
+		</a>
+		<br>
+		<br>
+		<a href="https://retool.com/?utm_campaign=sindresorhus">
+			<img src="https://sindresorhus.com/assets/thanks/retool-logo.svg" width="230"/>
+		</a>
+		<br>
+		<br>
+		<a href="https://doppler.com/?utm_campaign=github_repo&utm_medium=referral&utm_content=chalk&utm_source=github">
+			<div>
+				<img src="https://dashboard.doppler.com/imgs/logo-long.svg" width="240" alt="Doppler">
+			</div>
+			<b>All your environment variables, in one place</b>
+			<div>
+				<span>Stop struggling with scattered API keys, hacking together home-brewed tools,</span>
+				<br>
+				<span>and avoiding access controls. Keep your team and servers in sync with Doppler.</span>
+			</div>
+		</a>
+		<br>
+		<a href="https://uibakery.io/?utm_source=chalk&utm_medium=sponsor&utm_campaign=github">
+			<div>
+				<img src="https://sindresorhus.com/assets/thanks/uibakery-logo.jpg" width="270" alt="UI Bakery">
+			</div>
+		</a>
+	</p>
+</div>
+
+---
+
+<br>
+
+## Highlights
+
+- Expressive API
+- Highly performant
+- Ability to nest styles
+- [256/Truecolor color support](#256-and-truecolor-color-support)
+- Auto-detects color support
+- Doesn't extend `String.prototype`
+- Clean and focused
+- Actively maintained
+- [Used by ~50,000 packages](https://www.npmjs.com/browse/depended/chalk) as of January 1, 2020
+
+## Install
+
+```console
+$ npm install chalk
+```
+
+## Usage
+
+```js
+const chalk = require('chalk');
+
+console.log(chalk.blue('Hello world!'));
+```
+
+Chalk comes with an easy to use composable API where you just chain and nest the styles you want.
+
+```js
+const chalk = require('chalk');
+const log = console.log;
+
+// Combine styled and normal strings
+log(chalk.blue('Hello') + ' World' + chalk.red('!'));
+
+// Compose multiple styles using the chainable API
+log(chalk.blue.bgRed.bold('Hello world!'));
+
+// Pass in multiple arguments
+log(chalk.blue('Hello', 'World!', 'Foo', 'bar', 'biz', 'baz'));
+
+// Nest styles
+log(chalk.red('Hello', chalk.underline.bgBlue('world') + '!'));
+
+// Nest styles of the same type even (color, underline, background)
+log(chalk.green(
+	'I am a green line ' +
+	chalk.blue.underline.bold('with a blue substring') +
+	' that becomes green again!'
+));
+
+// ES2015 template literal
+log(`
+CPU: ${chalk.red('90%')}
+RAM: ${chalk.green('40%')}
+DISK: ${chalk.yellow('70%')}
+`);
+
+// ES2015 tagged template literal
+log(chalk`
+CPU: {red ${cpu.totalPercent}%}
+RAM: {green ${ram.used / ram.total * 100}%}
+DISK: {rgb(255,131,0) ${disk.used / disk.total * 100}%}
+`);
+
+// Use RGB colors in terminal emulators that support it.
+log(chalk.keyword('orange')('Yay for orange colored text!'));
+log(chalk.rgb(123, 45, 67).underline('Underlined reddish color'));
+log(chalk.hex('#DEADED').bold('Bold gray!'));
+```
+
+Easily define your own themes:
+
+```js
+const chalk = require('chalk');
+
+const error = chalk.bold.red;
+const warning = chalk.keyword('orange');
+
+console.log(error('Error!'));
+console.log(warning('Warning!'));
+```
+
+Take advantage of console.log [string substitution](https://nodejs.org/docs/latest/api/console.html#console_console_log_data_args):
+
+```js
+const name = 'Sindre';
+console.log(chalk.green('Hello %s'), name);
+//=> 'Hello Sindre'
+```
+
+## API
+
+### chalk.`<style>[.<style>...](string, [string...])`
+
+Example: `chalk.red.bold.underline('Hello', 'world');`
+
+Chain [styles](#styles) and call the last one as a method with a string argument. Order doesn't matter, and later styles take precedent in case of a conflict. This simply means that `chalk.red.yellow.green` is equivalent to `chalk.green`.
+
+Multiple arguments will be separated by space.
+
+### chalk.level
+
+Specifies the level of color support.
+
+Color support is automatically detected, but you can override it by setting the `level` property. You should however only do this in your own code as it applies globally to all Chalk consumers.
+
+If you need to change this in a reusable module, create a new instance:
+
+```js
+const ctx = new chalk.Instance({level: 0});
+```
+
+| Level | Description |
+| :---: | :--- |
+| `0` | All colors disabled |
+| `1` | Basic color support (16 colors) |
+| `2` | 256 color support |
+| `3` | Truecolor support (16 million colors) |
+
+### chalk.supportsColor
+
+Detect whether the terminal [supports color](https://github.com/chalk/supports-color). Used internally and handled for you, but exposed for convenience.
+
+Can be overridden by the user with the flags `--color` and `--no-color`. For situations where using `--color` is not possible, use the environment variable `FORCE_COLOR=1` (level 1), `FORCE_COLOR=2` (level 2), or `FORCE_COLOR=3` (level 3) to forcefully enable color, or `FORCE_COLOR=0` to forcefully disable. The use of `FORCE_COLOR` overrides all other color support checks.
+
+Explicit 256/Truecolor mode can be enabled using the `--color=256` and `--color=16m` flags, respectively.
+
+### chalk.stderr and chalk.stderr.supportsColor
+
+`chalk.stderr` contains a separate instance configured with color support detected for `stderr` stream instead of `stdout`. Override rules from `chalk.supportsColor` apply to this too. `chalk.stderr.supportsColor` is exposed for convenience.
+
+## Styles
+
+### Modifiers
+
+- `reset` - Resets the current color chain.
+- `bold` - Make text bold.
+- `dim` - Emitting only a small amount of light.
+- `italic` - Make text italic. *(Not widely supported)*
+- `underline` - Make text underline. *(Not widely supported)*
+- `inverse`- Inverse background and foreground colors.
+- `hidden` - Prints the text, but makes it invisible.
+- `strikethrough` - Puts a horizontal line through the center of the text. *(Not widely supported)*
+- `visible`- Prints the text only when Chalk has a color level > 0. Can be useful for things that are purely cosmetic.
+
+### Colors
+
+- `black`
+- `red`
+- `green`
+- `yellow`
+- `blue`
+- `magenta`
+- `cyan`
+- `white`
+- `blackBright` (alias: `gray`, `grey`)
+- `redBright`
+- `greenBright`
+- `yellowBright`
+- `blueBright`
+- `magentaBright`
+- `cyanBright`
+- `whiteBright`
+
+### Background colors
+
+- `bgBlack`
+- `bgRed`
+- `bgGreen`
+- `bgYellow`
+- `bgBlue`
+- `bgMagenta`
+- `bgCyan`
+- `bgWhite`
+- `bgBlackBright` (alias: `bgGray`, `bgGrey`)
+- `bgRedBright`
+- `bgGreenBright`
+- `bgYellowBright`
+- `bgBlueBright`
+- `bgMagentaBright`
+- `bgCyanBright`
+- `bgWhiteBright`
+
+## Tagged template literal
+
+Chalk can be used as a [tagged template literal](https://exploringjs.com/es6/ch_template-literals.html#_tagged-template-literals).
+
+```js
+const chalk = require('chalk');
+
+const miles = 18;
+const calculateFeet = miles => miles * 5280;
+
+console.log(chalk`
+	There are {bold 5280 feet} in a mile.
+	In {bold ${miles} miles}, there are {green.bold ${calculateFeet(miles)} feet}.
+`);
+```
+
+Blocks are delimited by an opening curly brace (`{`), a style, some content, and a closing curly brace (`}`).
+
+Template styles are chained exactly like normal Chalk styles. The following three statements are equivalent:
+
+```js
+console.log(chalk.bold.rgb(10, 100, 200)('Hello!'));
+console.log(chalk.bold.rgb(10, 100, 200)`Hello!`);
+console.log(chalk`{bold.rgb(10,100,200) Hello!}`);
+```
+
+Note that function styles (`rgb()`, `hsl()`, `keyword()`, etc.) may not contain spaces between parameters.
+
+All interpolated values (`` chalk`${foo}` ``) are converted to strings via the `.toString()` method. All curly braces (`{` and `}`) in interpolated value strings are escaped.
+
+## 256 and Truecolor color support
+
+Chalk supports 256 colors and [Truecolor](https://gist.github.com/XVilka/8346728) (16 million colors) on supported terminal apps.
+
+Colors are downsampled from 16 million RGB values to an ANSI color format that is supported by the terminal emulator (or by specifying `{level: n}` as a Chalk option). For example, Chalk configured to run at level 1 (basic color support) will downsample an RGB value of #FF0000 (red) to 31 (ANSI escape for red).
+
+Examples:
+
+- `chalk.hex('#DEADED').underline('Hello, world!')`
+- `chalk.keyword('orange')('Some orange text')`
+- `chalk.rgb(15, 100, 204).inverse('Hello!')`
+
+Background versions of these models are prefixed with `bg` and the first level of the module capitalized (e.g. `keyword` for foreground colors and `bgKeyword` for background colors).
+
+- `chalk.bgHex('#DEADED').underline('Hello, world!')`
+- `chalk.bgKeyword('orange')('Some orange text')`
+- `chalk.bgRgb(15, 100, 204).inverse('Hello!')`
+
+The following color models can be used:
+
+- [`rgb`](https://en.wikipedia.org/wiki/RGB_color_model) - Example: `chalk.rgb(255, 136, 0).bold('Orange!')`
+- [`hex`](https://en.wikipedia.org/wiki/Web_colors#Hex_triplet) - Example: `chalk.hex('#FF8800').bold('Orange!')`
+- [`keyword`](https://www.w3.org/wiki/CSS/Properties/color/keywords) (CSS keywords) - Example: `chalk.keyword('orange').bold('Orange!')`
+- [`hsl`](https://en.wikipedia.org/wiki/HSL_and_HSV) - Example: `chalk.hsl(32, 100, 50).bold('Orange!')`
+- [`hsv`](https://en.wikipedia.org/wiki/HSL_and_HSV) - Example: `chalk.hsv(32, 100, 100).bold('Orange!')`
+- [`hwb`](https://en.wikipedia.org/wiki/HWB_color_model) - Example: `chalk.hwb(32, 0, 50).bold('Orange!')`
+- [`ansi`](https://en.wikipedia.org/wiki/ANSI_escape_code#3/4_bit) - Example: `chalk.ansi(31).bgAnsi(93)('red on yellowBright')`
+- [`ansi256`](https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit) - Example: `chalk.bgAnsi256(194)('Honeydew, more or less')`
+
+## Windows
+
+If you're on Windows, do yourself a favor and use [Windows Terminal](https://github.com/microsoft/terminal) instead of `cmd.exe`.
+
+## Origin story
+
+[colors.js](https://github.com/Marak/colors.js) used to be the most popular string styling module, but it has serious deficiencies like extending `String.prototype` which causes all kinds of [problems](https://github.com/yeoman/yo/issues/68) and the package is unmaintained. Although there are other packages, they either do too much or not enough. Chalk is a clean and focused alternative.
+
+## chalk for enterprise
+
+Available as part of the Tidelift Subscription.
+
+The maintainers of chalk and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/npm-chalk?utm_source=npm-chalk&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)
+
+## Related
+
+- [chalk-cli](https://github.com/chalk/chalk-cli) - CLI for this module
+- [ansi-styles](https://github.com/chalk/ansi-styles) - ANSI escape codes for styling strings in the terminal
+- [supports-color](https://github.com/chalk/supports-color) - Detect whether a terminal supports color
+- [strip-ansi](https://github.com/chalk/strip-ansi) - Strip ANSI escape codes
+- [strip-ansi-stream](https://github.com/chalk/strip-ansi-stream) - Strip ANSI escape codes from a stream
+- [has-ansi](https://github.com/chalk/has-ansi) - Check if a string has ANSI escape codes
+- [ansi-regex](https://github.com/chalk/ansi-regex) - Regular expression for matching ANSI escape codes
+- [wrap-ansi](https://github.com/chalk/wrap-ansi) - Wordwrap a string with ANSI escape codes
+- [slice-ansi](https://github.com/chalk/slice-ansi) - Slice a string with ANSI escape codes
+- [color-convert](https://github.com/qix-/color-convert) - Converts colors between different models
+- [chalk-animation](https://github.com/bokub/chalk-animation) - Animate strings in the terminal
+- [gradient-string](https://github.com/bokub/gradient-string) - Apply color gradients to strings
+- [chalk-pipe](https://github.com/LitoMore/chalk-pipe) - Create chalk style schemes with simpler style strings
+- [terminal-link](https://github.com/sindresorhus/terminal-link) - Create clickable links in the terminal
+
+## Maintainers
+
+- [Sindre Sorhus](https://github.com/sindresorhus)
+- [Josh Junon](https://github.com/qix-)

node_modules/@jest/reporters/node_modules/chalk/source/index.js

@@ -0,0 +1,229 @@
+'use strict';
+const ansiStyles = require('ansi-styles');
+const {stdout: stdoutColor, stderr: stderrColor} = require('supports-color');
+const {
+	stringReplaceAll,
+	stringEncaseCRLFWithFirstIndex
+} = require('./util');
+
+const {isArray} = Array;
+
+// `supportsColor.level` → `ansiStyles.color[name]` mapping
+const levelMapping = [
+	'ansi',
+	'ansi',
+	'ansi256',
+	'ansi16m'
+];
+
+const styles = Object.create(null);
+
+const applyOptions = (object, options = {}) => {
+	if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+		throw new Error('The `level` option should be an integer from 0 to 3');
+	}
+
+	// Detect level if not set manually
+	const colorLevel = stdoutColor ? stdoutColor.level : 0;
+	object.level = options.level === undefined ? colorLevel : options.level;
+};
+
+class ChalkClass {
+	constructor(options) {
+		// eslint-disable-next-line no-constructor-return
+		return chalkFactory(options);
+	}
+}
+
+const chalkFactory = options => {
+	const chalk = {};
+	applyOptions(chalk, options);
+
+	chalk.template = (...arguments_) => chalkTag(chalk.template, ...arguments_);
+
+	Object.setPrototypeOf(chalk, Chalk.prototype);
+	Object.setPrototypeOf(chalk.template, chalk);
+
+	chalk.template.constructor = () => {
+		throw new Error('`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.');
+	};
+
+	chalk.template.Instance = ChalkClass;
+
+	return chalk.template;
+};
+
+function Chalk(options) {
+	return chalkFactory(options);
+}
+
+for (const [styleName, style] of Object.entries(ansiStyles)) {
+	styles[styleName] = {
+		get() {
+			const builder = createBuilder(this, createStyler(style.open, style.close, this._styler), this._isEmpty);
+			Object.defineProperty(this, styleName, {value: builder});
+			return builder;
+		}
+	};
+}
+
+styles.visible = {
+	get() {
+		const builder = createBuilder(this, this._styler, true);
+		Object.defineProperty(this, 'visible', {value: builder});
+		return builder;
+	}
+};
+
+const usedModels = ['rgb', 'hex', 'keyword', 'hsl', 'hsv', 'hwb', 'ansi', 'ansi256'];
+
+for (const model of usedModels) {
+	styles[model] = {
+		get() {
+			const {level} = this;
+			return function (...arguments_) {
+				const styler = createStyler(ansiStyles.color[levelMapping[level]][model](...arguments_), ansiStyles.color.close, this._styler);
+				return createBuilder(this, styler, this._isEmpty);
+			};
+		}
+	};
+}
+
+for (const model of usedModels) {
+	const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
+	styles[bgModel] = {
+		get() {
+			const {level} = this;
+			return function (...arguments_) {
+				const styler = createStyler(ansiStyles.bgColor[levelMapping[level]][model](...arguments_), ansiStyles.bgColor.close, this._styler);
+				return createBuilder(this, styler, this._isEmpty);
+			};
+		}
+	};
+}
+
+const proto = Object.defineProperties(() => {}, {
+	...styles,
+	level: {
+		enumerable: true,
+		get() {
+			return this._generator.level;
+		},
+		set(level) {
+			this._generator.level = level;
+		}
+	}
+});
+
+const createStyler = (open, close, parent) => {
+	let openAll;
+	let closeAll;
+	if (parent === undefined) {
+		openAll = open;
+		closeAll = close;
+	} else {
+		openAll = parent.openAll + open;
+		closeAll = close + parent.closeAll;
+	}
+
+	return {
+		open,
+		close,
+		openAll,
+		closeAll,
+		parent
+	};
+};
+
+const createBuilder = (self, _styler, _isEmpty) => {
+	const builder = (...arguments_) => {
+		if (isArray(arguments_[0]) && isArray(arguments_[0].raw)) {
+			// Called as a template literal, for example: chalk.red`2 + 3 = {bold ${2+3}}`
+			return applyStyle(builder, chalkTag(builder, ...arguments_));
+		}
+
+		// Single argument is hot path, implicit coercion is faster than anything
+		// eslint-disable-next-line no-implicit-coercion
+		return applyStyle(builder, (arguments_.length === 1) ? ('' + arguments_[0]) : arguments_.join(' '));
+	};
+
+	// We alter the prototype because we must return a function, but there is
+	// no way to create a function with a different prototype
+	Object.setPrototypeOf(builder, proto);
+
+	builder._generator = self;
+	builder._styler = _styler;
+	builder._isEmpty = _isEmpty;
+
+	return builder;
+};
+
+const applyStyle = (self, string) => {
+	if (self.level <= 0 || !string) {
+		return self._isEmpty ? '' : string;
+	}
+
+	let styler = self._styler;
+
+	if (styler === undefined) {
+		return string;
+	}
+
+	const {openAll, closeAll} = styler;
+	if (string.indexOf('\u001B') !== -1) {
+		while (styler !== undefined) {
+			// Replace any instances already present with a re-opening code
+			// otherwise only the part of the string until said closing code
+			// will be colored, and the rest will simply be 'plain'.
+			string = stringReplaceAll(string, styler.close, styler.open);
+
+			styler = styler.parent;
+		}
+	}
+
+	// We can move both next actions out of loop, because remaining actions in loop won't have
+	// any/visible effect on parts we add here. Close the styling before a linebreak and reopen
+	// after next line to fix a bleed issue on macOS: https://github.com/chalk/chalk/pull/92
+	const lfIndex = string.indexOf('\n');
+	if (lfIndex !== -1) {
+		string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+	}
+
+	return openAll + string + closeAll;
+};
+
+let template;
+const chalkTag = (chalk, ...strings) => {
+	const [firstString] = strings;
+
+	if (!isArray(firstString) || !isArray(firstString.raw)) {
+		// If chalk() was called by itself or with a string,
+		// return the string itself as a string.
+		return strings.join(' ');
+	}
+
+	const arguments_ = strings.slice(1);
+	const parts = [firstString.raw[0]];
+
+	for (let i = 1; i < firstString.length; i++) {
+		parts.push(
+			String(arguments_[i - 1]).replace(/[{}\\]/g, '\\$&'),
+			String(firstString.raw[i])
+		);
+	}
+
+	if (template === undefined) {
+		template = require('./templates');
+	}
+
+	return template(chalk, parts.join(''));
+};
+
+Object.defineProperties(Chalk.prototype, styles);
+
+const chalk = Chalk(); // eslint-disable-line new-cap
+chalk.supportsColor = stdoutColor;
+chalk.stderr = Chalk({level: stderrColor ? stderrColor.level : 0}); // eslint-disable-line new-cap
+chalk.stderr.supportsColor = stderrColor;
+
+module.exports = chalk;

node_modules/@jest/reporters/node_modules/chalk/source/templates.js

@@ -0,0 +1,134 @@
+'use strict';
+const TEMPLATE_REGEX = /(?:\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
+const STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
+const STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
+const ESCAPE_REGEX = /\\(u(?:[a-f\d]{4}|{[a-f\d]{1,6}})|x[a-f\d]{2}|.)|([^\\])/gi;
+
+const ESCAPES = new Map([
+	['n', '\n'],
+	['r', '\r'],
+	['t', '\t'],
+	['b', '\b'],
+	['f', '\f'],
+	['v', '\v'],
+	['0', '\0'],
+	['\\', '\\'],
+	['e', '\u001B'],
+	['a', '\u0007']
+]);
+
+function unescape(c) {
+	const u = c[0] === 'u';
+	const bracket = c[1] === '{';
+
+	if ((u && !bracket && c.length === 5) || (c[0] === 'x' && c.length === 3)) {
+		return String.fromCharCode(parseInt(c.slice(1), 16));
+	}
+
+	if (u && bracket) {
+		return String.fromCodePoint(parseInt(c.slice(2, -1), 16));
+	}
+
+	return ESCAPES.get(c) || c;
+}
+
+function parseArguments(name, arguments_) {
+	const results = [];
+	const chunks = arguments_.trim().split(/\s*,\s*/g);
+	let matches;
+
+	for (const chunk of chunks) {
+		const number = Number(chunk);
+		if (!Number.isNaN(number)) {
+			results.push(number);
+		} else if ((matches = chunk.match(STRING_REGEX))) {
+			results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, character) => escape ? unescape(escape) : character));
+		} else {
+			throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
+		}
+	}
+
+	return results;
+}
+
+function parseStyle(style) {
+	STYLE_REGEX.lastIndex = 0;
+
+	const results = [];
+	let matches;
+
+	while ((matches = STYLE_REGEX.exec(style)) !== null) {
+		const name = matches[1];
+
+		if (matches[2]) {
+			const args = parseArguments(name, matches[2]);
+			results.push([name].concat(args));
+		} else {
+			results.push([name]);
+		}
+	}
+
+	return results;
+}
+
+function buildStyle(chalk, styles) {
+	const enabled = {};
+
+	for (const layer of styles) {
+		for (const style of layer.styles) {
+			enabled[style[0]] = layer.inverse ? null : style.slice(1);
+		}
+	}
+
+	let current = chalk;
+	for (const [styleName, styles] of Object.entries(enabled)) {
+		if (!Array.isArray(styles)) {
+			continue;
+		}
+
+		if (!(styleName in current)) {
+			throw new Error(`Unknown Chalk style: ${styleName}`);
+		}
+
+		current = styles.length > 0 ? current[styleName](...styles) : current[styleName];
+	}
+
+	return current;
+}
+
+module.exports = (chalk, temporary) => {
+	const styles = [];
+	const chunks = [];
+	let chunk = [];
+
+	// eslint-disable-next-line max-params
+	temporary.replace(TEMPLATE_REGEX, (m, escapeCharacter, inverse, style, close, character) => {
+		if (escapeCharacter) {
+			chunk.push(unescape(escapeCharacter));
+		} else if (style) {
+			const string = chunk.join('');
+			chunk = [];
+			chunks.push(styles.length === 0 ? string : buildStyle(chalk, styles)(string));
+			styles.push({inverse, styles: parseStyle(style)});
+		} else if (close) {
+			if (styles.length === 0) {
+				throw new Error('Found extraneous } in Chalk template literal');
+			}
+
+			chunks.push(buildStyle(chalk, styles)(chunk.join('')));
+			chunk = [];
+			styles.pop();
+		} else {
+			chunk.push(character);
+		}
+	});
+
+	chunks.push(chunk.join(''));
+
+	if (styles.length > 0) {
+		const errMessage = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? '' : 's'} (\`}\`)`;
+		throw new Error(errMessage);
+	}
+
+	return chunks.join('');
+};

node_modules/@jest/reporters/node_modules/chalk/source/util.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const stringReplaceAll = (string, substring, replacer) => {
+	let index = string.indexOf(substring);
+	if (index === -1) {
+		return string;
+	}
+
+	const substringLength = substring.length;
+	let endIndex = 0;
+	let returnValue = '';
+	do {
+		returnValue += string.substr(endIndex, index - endIndex) + substring + replacer;
+		endIndex = index + substringLength;
+		index = string.indexOf(substring, endIndex);
+	} while (index !== -1);
+
+	returnValue += string.substr(endIndex);
+	return returnValue;
+};
+
+const stringEncaseCRLFWithFirstIndex = (string, prefix, postfix, index) => {
+	let endIndex = 0;
+	let returnValue = '';
+	do {
+		const gotCR = string[index - 1] === '\r';
+		returnValue += string.substr(endIndex, (gotCR ? index - 1 : index) - endIndex) + prefix + (gotCR ? '\r\n' : '\n') + postfix;
+		endIndex = index + 1;
+		index = string.indexOf('\n', endIndex);
+	} while (index !== -1);
+
+	returnValue += string.substr(endIndex);
+	return returnValue;
+};
+
+module.exports = {
+	stringReplaceAll,
+	stringEncaseCRLFWithFirstIndex
+};

node_modules/@jest/reporters/node_modules/color-convert/CHANGELOG.md

@@ -0,0 +1,54 @@
+# 1.0.0 - 2016-01-07
+
+- Removed: unused speed test
+- Added: Automatic routing between previously unsupported conversions
+([#27](https://github.com/Qix-/color-convert/pull/27))
+- Removed: `xxx2xxx()` and `xxx2xxxRaw()` functions
+([#27](https://github.com/Qix-/color-convert/pull/27))
+- Removed: `convert()` class
+([#27](https://github.com/Qix-/color-convert/pull/27))
+- Changed: all functions to lookup dictionary
+([#27](https://github.com/Qix-/color-convert/pull/27))
+- Changed: `ansi` to `ansi256`
+([#27](https://github.com/Qix-/color-convert/pull/27))
+- Fixed: argument grouping for functions requiring only one argument
+([#27](https://github.com/Qix-/color-convert/pull/27))
+
+# 0.6.0 - 2015-07-23
+
+- Added: methods to handle
+[ANSI](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors) 16/256 colors:
+  - rgb2ansi16
+  - rgb2ansi
+  - hsl2ansi16
+  - hsl2ansi
+  - hsv2ansi16
+  - hsv2ansi
+  - hwb2ansi16
+  - hwb2ansi
+  - cmyk2ansi16
+  - cmyk2ansi
+  - keyword2ansi16
+  - keyword2ansi
+  - ansi162rgb
+  - ansi162hsl
+  - ansi162hsv
+  - ansi162hwb
+  - ansi162cmyk
+  - ansi162keyword
+  - ansi2rgb
+  - ansi2hsl
+  - ansi2hsv
+  - ansi2hwb
+  - ansi2cmyk
+  - ansi2keyword
+([#18](https://github.com/harthur/color-convert/pull/18))
+
+# 0.5.3 - 2015-06-02
+
+- Fixed: hsl2hsv does not return `NaN` anymore when using `[0,0,0]`
+([#15](https://github.com/harthur/color-convert/issues/15))
+
+---
+
+Check out commit logs for older releases

node_modules/@jest/reporters/node_modules/color-convert/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2011-2016 Heather Arthur <fayearthur@gmail.com>
+
+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/reporters/node_modules/color-convert/README.md

@@ -0,0 +1,68 @@
+# color-convert
+
+[![Build Status](https://travis-ci.org/Qix-/color-convert.svg?branch=master)](https://travis-ci.org/Qix-/color-convert)
+
+Color-convert is a color conversion library for JavaScript and node.
+It converts all ways between `rgb`, `hsl`, `hsv`, `hwb`, `cmyk`, `ansi`, `ansi16`, `hex` strings, and CSS `keyword`s (will round to closest):
+
+```js
+var convert = require('color-convert');
+
+convert.rgb.hsl(140, 200, 100);             // [96, 48, 59]
+convert.keyword.rgb('blue');                // [0, 0, 255]
+
+var rgbChannels = convert.rgb.channels;     // 3
+var cmykChannels = convert.cmyk.channels;   // 4
+var ansiChannels = convert.ansi16.channels; // 1
+```
+
+# Install
+
+```console
+$ npm install color-convert
+```
+
+# API
+
+Simply get the property of the _from_ and _to_ conversion that you're looking for.
+
+All functions have a rounded and unrounded variant. By default, return values are rounded. To get the unrounded (raw) results, simply tack on `.raw` to the function.
+
+All 'from' functions have a hidden property called `.channels` that indicates the number of channels the function expects (not including alpha).
+
+```js
+var convert = require('color-convert');
+
+// Hex to LAB
+convert.hex.lab('DEADBF');         // [ 76, 21, -2 ]
+convert.hex.lab.raw('DEADBF');     // [ 75.56213190997677, 20.653827952644754, -2.290532499330533 ]
+
+// RGB to CMYK
+convert.rgb.cmyk(167, 255, 4);     // [ 35, 0, 98, 0 ]
+convert.rgb.cmyk.raw(167, 255, 4); // [ 34.509803921568626, 0, 98.43137254901961, 0 ]
+```
+
+### Arrays
+All functions that accept multiple arguments also support passing an array.
+
+Note that this does **not** apply to functions that convert from a color that only requires one value (e.g. `keyword`, `ansi256`, `hex`, etc.)
+
+```js
+var convert = require('color-convert');
+
+convert.rgb.hex(123, 45, 67);      // '7B2D43'
+convert.rgb.hex([123, 45, 67]);    // '7B2D43'
+```
+
+## Routing
+
+Conversions that don't have an _explicitly_ defined conversion (in [conversions.js](conversions.js)), but can be converted by means of sub-conversions (e.g. XYZ -> **RGB** -> CMYK), are automatically routed together. This allows just about any color model supported by `color-convert` to be converted to any other model, so long as a sub-conversion path exists. This is also true for conversions requiring more than one step in between (e.g. LCH -> **LAB** -> **XYZ** -> **RGB** -> Hex).
+
+Keep in mind that extensive conversions _may_ result in a loss of precision, and exist only to be complete. For a list of "direct" (single-step) conversions, see [conversions.js](conversions.js).
+
+# Contribute
+
+If there is a new model you would like to support, or want to add a direct conversion between two existing models, please send us a pull request.
+
+# License
+Copyright © 2011-2016, Heather Arthur and Josh Junon. Licensed under the [MIT License](LICENSE).

node_modules/@jest/reporters/node_modules/color-convert/conversions.js

@@ -0,0 +1,839 @@
+/* MIT license */
+/* eslint-disable no-mixed-operators */
+const cssKeywords = require('color-name');
+
+// NOTE: conversions should only return primitive values (i.e. arrays, or
+//       values that give correct `typeof` results).
+//       do not use box values types (i.e. Number(), String(), etc.)
+
+const reverseKeywords = {};
+for (const key of Object.keys(cssKeywords)) {
+	reverseKeywords[cssKeywords[key]] = key;
+}
+
+const convert = {
+	rgb: {channels: 3, labels: 'rgb'},
+	hsl: {channels: 3, labels: 'hsl'},
+	hsv: {channels: 3, labels: 'hsv'},
+	hwb: {channels: 3, labels: 'hwb'},
+	cmyk: {channels: 4, labels: 'cmyk'},
+	xyz: {channels: 3, labels: 'xyz'},
+	lab: {channels: 3, labels: 'lab'},
+	lch: {channels: 3, labels: 'lch'},
+	hex: {channels: 1, labels: ['hex']},
+	keyword: {channels: 1, labels: ['keyword']},
+	ansi16: {channels: 1, labels: ['ansi16']},
+	ansi256: {channels: 1, labels: ['ansi256']},
+	hcg: {channels: 3, labels: ['h', 'c', 'g']},
+	apple: {channels: 3, labels: ['r16', 'g16', 'b16']},
+	gray: {channels: 1, labels: ['gray']}
+};
+
+module.exports = convert;
+
+// Hide .channels and .labels properties
+for (const model of Object.keys(convert)) {
+	if (!('channels' in convert[model])) {
+		throw new Error('missing channels property: ' + model);
+	}
+
+	if (!('labels' in convert[model])) {
+		throw new Error('missing channel labels property: ' + model);
+	}
+
+	if (convert[model].labels.length !== convert[model].channels) {
+		throw new Error('channel and label counts mismatch: ' + model);
+	}
+
+	const {channels, labels} = convert[model];
+	delete convert[model].channels;
+	delete convert[model].labels;
+	Object.defineProperty(convert[model], 'channels', {value: channels});
+	Object.defineProperty(convert[model], 'labels', {value: labels});
+}
+
+convert.rgb.hsl = function (rgb) {
+	const r = rgb[0] / 255;
+	const g = rgb[1] / 255;
+	const b = rgb[2] / 255;
+	const min = Math.min(r, g, b);
+	const max = Math.max(r, g, b);
+	const delta = max - min;
+	let h;
+	let s;
+
+	if (max === min) {
+		h = 0;
+	} else if (r === max) {
+		h = (g - b) / delta;
+	} else if (g === max) {
+		h = 2 + (b - r) / delta;
+	} else if (b === max) {
+		h = 4 + (r - g) / delta;
+	}
+
+	h = Math.min(h * 60, 360);
+
+	if (h < 0) {
+		h += 360;
+	}
+
+	const l = (min + max) / 2;
+
+	if (max === min) {
+		s = 0;
+	} else if (l <= 0.5) {
+		s = delta / (max + min);
+	} else {
+		s = delta / (2 - max - min);
+	}
+
+	return [h, s * 100, l * 100];
+};
+
+convert.rgb.hsv = function (rgb) {
+	let rdif;
+	let gdif;
+	let bdif;
+	let h;
+	let s;
+
+	const r = rgb[0] / 255;
+	const g = rgb[1] / 255;
+	const b = rgb[2] / 255;
+	const v = Math.max(r, g, b);
+	const diff = v - Math.min(r, g, b);
+	const diffc = function (c) {
+		return (v - c) / 6 / diff + 1 / 2;
+	};
+
+	if (diff === 0) {
+		h = 0;
+		s = 0;
+	} else {
+		s = diff / v;
+		rdif = diffc(r);
+		gdif = diffc(g);
+		bdif = diffc(b);
+
+		if (r === v) {
+			h = bdif - gdif;
+		} else if (g === v) {
+			h = (1 / 3) + rdif - bdif;
+		} else if (b === v) {
+			h = (2 / 3) + gdif - rdif;
+		}
+
+		if (h < 0) {
+			h += 1;
+		} else if (h > 1) {
+			h -= 1;
+		}
+	}
+
+	return [
+		h * 360,
+		s * 100,
+		v * 100
+	];
+};
+
+convert.rgb.hwb = function (rgb) {
+	const r = rgb[0];
+	const g = rgb[1];
+	let b = rgb[2];
+	const h = convert.rgb.hsl(rgb)[0];
+	const w = 1 / 255 * Math.min(r, Math.min(g, b));
+
+	b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
+
+	return [h, w * 100, b * 100];
+};
+
+convert.rgb.cmyk = function (rgb) {
+	const r = rgb[0] / 255;
+	const g = rgb[1] / 255;
+	const b = rgb[2] / 255;
+
+	const k = Math.min(1 - r, 1 - g, 1 - b);
+	const c = (1 - r - k) / (1 - k) || 0;
+	const m = (1 - g - k) / (1 - k) || 0;
+	const y = (1 - b - k) / (1 - k) || 0;
+
+	return [c * 100, m * 100, y * 100, k * 100];
+};
+
+function comparativeDistance(x, y) {
+	/*
+		See https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance
+	*/
+	return (
+		((x[0] - y[0]) ** 2) +
+		((x[1] - y[1]) ** 2) +
+		((x[2] - y[2]) ** 2)
+	);
+}
+
+convert.rgb.keyword = function (rgb) {
+	const reversed = reverseKeywords[rgb];
+	if (reversed) {
+		return reversed;
+	}
+
+	let currentClosestDistance = Infinity;
+	let currentClosestKeyword;
+
+	for (const keyword of Object.keys(cssKeywords)) {
+		const value = cssKeywords[keyword];
+
+		// Compute comparative distance
+		const distance = comparativeDistance(rgb, value);
+
+		// Check if its less, if so set as closest
+		if (distance < currentClosestDistance) {
+			currentClosestDistance = distance;
+			currentClosestKeyword = keyword;
+		}
+	}
+
+	return currentClosestKeyword;
+};
+
+convert.keyword.rgb = function (keyword) {
+	return cssKeywords[keyword];
+};
+
+convert.rgb.xyz = function (rgb) {
+	let r = rgb[0] / 255;
+	let g = rgb[1] / 255;
+	let b = rgb[2] / 255;
+
+	// Assume sRGB
+	r = r > 0.04045 ? (((r + 0.055) / 1.055) ** 2.4) : (r / 12.92);
+	g = g > 0.04045 ? (((g + 0.055) / 1.055) ** 2.4) : (g / 12.92);
+	b = b > 0.04045 ? (((b + 0.055) / 1.055) ** 2.4) : (b / 12.92);
+
+	const x = (r * 0.4124) + (g * 0.3576) + (b * 0.1805);
+	const y = (r * 0.2126) + (g * 0.7152) + (b * 0.0722);
+	const z = (r * 0.0193) + (g * 0.1192) + (b * 0.9505);
+
+	return [x * 100, y * 100, z * 100];
+};
+
+convert.rgb.lab = function (rgb) {
+	const xyz = convert.rgb.xyz(rgb);
+	let x = xyz[0];
+	let y = xyz[1];
+	let z = xyz[2];
+
+	x /= 95.047;
+	y /= 100;
+	z /= 108.883;
+
+	x = x > 0.008856 ? (x ** (1 / 3)) : (7.787 * x) + (16 / 116);
+	y = y > 0.008856 ? (y ** (1 / 3)) : (7.787 * y) + (16 / 116);
+	z = z > 0.008856 ? (z ** (1 / 3)) : (7.787 * z) + (16 / 116);
+
+	const l = (116 * y) - 16;
+	const a = 500 * (x - y);
+	const b = 200 * (y - z);
+
+	return [l, a, b];
+};
+
+convert.hsl.rgb = function (hsl) {
+	const h = hsl[0] / 360;
+	const s = hsl[1] / 100;
+	const l = hsl[2] / 100;
+	let t2;
+	let t3;
+	let val;
+
+	if (s === 0) {
+		val = l * 255;
+		return [val, val, val];
+	}
+
+	if (l < 0.5) {
+		t2 = l * (1 + s);
+	} else {
+		t2 = l + s - l * s;
+	}
+
+	const t1 = 2 * l - t2;
+
+	const rgb = [0, 0, 0];
+	for (let i = 0; i < 3; i++) {
+		t3 = h + 1 / 3 * -(i - 1);
+		if (t3 < 0) {
+			t3++;
+		}
+
+		if (t3 > 1) {
+			t3--;
+		}
+
+		if (6 * t3 < 1) {
+			val = t1 + (t2 - t1) * 6 * t3;
+		} else if (2 * t3 < 1) {
+			val = t2;
+		} else if (3 * t3 < 2) {
+			val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
+		} else {
+			val = t1;
+		}
+
+		rgb[i] = val * 255;
+	}
+
+	return rgb;
+};
+
+convert.hsl.hsv = function (hsl) {
+	const h = hsl[0];
+	let s = hsl[1] / 100;
+	let l = hsl[2] / 100;
+	let smin = s;
+	const lmin = Math.max(l, 0.01);
+
+	l *= 2;
+	s *= (l <= 1) ? l : 2 - l;
+	smin *= lmin <= 1 ? lmin : 2 - lmin;
+	const v = (l + s) / 2;
+	const sv = l === 0 ? (2 * smin) / (lmin + smin) : (2 * s) / (l + s);
+
+	return [h, sv * 100, v * 100];
+};
+
+convert.hsv.rgb = function (hsv) {
+	const h = hsv[0] / 60;
+	const s = hsv[1] / 100;
+	let v = hsv[2] / 100;
+	const hi = Math.floor(h) % 6;
+
+	const f = h - Math.floor(h);
+	const p = 255 * v * (1 - s);
+	const q = 255 * v * (1 - (s * f));
+	const t = 255 * v * (1 - (s * (1 - f)));
+	v *= 255;
+
+	switch (hi) {
+		case 0:
+			return [v, t, p];
+		case 1:
+			return [q, v, p];
+		case 2:
+			return [p, v, t];
+		case 3:
+			return [p, q, v];
+		case 4:
+			return [t, p, v];
+		case 5:
+			return [v, p, q];
+	}
+};
+
+convert.hsv.hsl = function (hsv) {
+	const h = hsv[0];
+	const s = hsv[1] / 100;
+	const v = hsv[2] / 100;
+	const vmin = Math.max(v, 0.01);
+	let sl;
+	let l;
+
+	l = (2 - s) * v;
+	const lmin = (2 - s) * vmin;
+	sl = s * vmin;
+	sl /= (lmin <= 1) ? lmin : 2 - lmin;
+	sl = sl || 0;
+	l /= 2;
+
+	return [h, sl * 100, l * 100];
+};
+
+// http://dev.w3.org/csswg/css-color/#hwb-to-rgb
+convert.hwb.rgb = function (hwb) {
+	const h = hwb[0] / 360;
+	let wh = hwb[1] / 100;
+	let bl = hwb[2] / 100;
+	const ratio = wh + bl;
+	let f;
+
+	// Wh + bl cant be > 1
+	if (ratio > 1) {
+		wh /= ratio;
+		bl /= ratio;
+	}
+
+	const i = Math.floor(6 * h);
+	const v = 1 - bl;
+	f = 6 * h - i;
+
+	if ((i & 0x01) !== 0) {
+		f = 1 - f;
+	}
+
+	const n = wh + f * (v - wh); // Linear interpolation
+
+	let r;
+	let g;
+	let b;
+	/* eslint-disable max-statements-per-line,no-multi-spaces */
+	switch (i) {
+		default:
+		case 6:
+		case 0: r = v;  g = n;  b = wh; break;
+		case 1: r = n;  g = v;  b = wh; break;
+		case 2: r = wh; g = v;  b = n; break;
+		case 3: r = wh; g = n;  b = v; break;
+		case 4: r = n;  g = wh; b = v; break;
+		case 5: r = v;  g = wh; b = n; break;
+	}
+	/* eslint-enable max-statements-per-line,no-multi-spaces */
+
+	return [r * 255, g * 255, b * 255];
+};
+
+convert.cmyk.rgb = function (cmyk) {
+	const c = cmyk[0] / 100;
+	const m = cmyk[1] / 100;
+	const y = cmyk[2] / 100;
+	const k = cmyk[3] / 100;
+
+	const r = 1 - Math.min(1, c * (1 - k) + k);
+	const g = 1 - Math.min(1, m * (1 - k) + k);
+	const b = 1 - Math.min(1, y * (1 - k) + k);
+
+	return [r * 255, g * 255, b * 255];
+};
+
+convert.xyz.rgb = function (xyz) {
+	const x = xyz[0] / 100;
+	const y = xyz[1] / 100;
+	const z = xyz[2] / 100;
+	let r;
+	let g;
+	let b;
+
+	r = (x * 3.2406) + (y * -1.5372) + (z * -0.4986);
+	g = (x * -0.9689) + (y * 1.8758) + (z * 0.0415);
+	b = (x * 0.0557) + (y * -0.2040) + (z * 1.0570);
+
+	// Assume sRGB
+	r = r > 0.0031308
+		? ((1.055 * (r ** (1.0 / 2.4))) - 0.055)
+		: r * 12.92;
+
+	g = g > 0.0031308
+		? ((1.055 * (g ** (1.0 / 2.4))) - 0.055)
+		: g * 12.92;
+
+	b = b > 0.0031308
+		? ((1.055 * (b ** (1.0 / 2.4))) - 0.055)
+		: b * 12.92;
+
+	r = Math.min(Math.max(0, r), 1);
+	g = Math.min(Math.max(0, g), 1);
+	b = Math.min(Math.max(0, b), 1);
+
+	return [r * 255, g * 255, b * 255];
+};
+
+convert.xyz.lab = function (xyz) {
+	let x = xyz[0];
+	let y = xyz[1];
+	let z = xyz[2];
+
+	x /= 95.047;
+	y /= 100;
+	z /= 108.883;
+
+	x = x > 0.008856 ? (x ** (1 / 3)) : (7.787 * x) + (16 / 116);
+	y = y > 0.008856 ? (y ** (1 / 3)) : (7.787 * y) + (16 / 116);
+	z = z > 0.008856 ? (z ** (1 / 3)) : (7.787 * z) + (16 / 116);
+
+	const l = (116 * y) - 16;
+	const a = 500 * (x - y);
+	const b = 200 * (y - z);
+
+	return [l, a, b];
+};
+
+convert.lab.xyz = function (lab) {
+	const l = lab[0];
+	const a = lab[1];
+	const b = lab[2];
+	let x;
+	let y;
+	let z;
+
+	y = (l + 16) / 116;
+	x = a / 500 + y;
+	z = y - b / 200;
+
+	const y2 = y ** 3;
+	const x2 = x ** 3;
+	const z2 = z ** 3;
+	y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787;
+	x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787;
+	z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787;
+
+	x *= 95.047;
+	y *= 100;
+	z *= 108.883;
+
+	return [x, y, z];
+};
+
+convert.lab.lch = function (lab) {
+	const l = lab[0];
+	const a = lab[1];
+	const b = lab[2];
+	let h;
+
+	const hr = Math.atan2(b, a);
+	h = hr * 360 / 2 / Math.PI;
+
+	if (h < 0) {
+		h += 360;
+	}
+
+	const c = Math.sqrt(a * a + b * b);
+
+	return [l, c, h];
+};
+
+convert.lch.lab = function (lch) {
+	const l = lch[0];
+	const c = lch[1];
+	const h = lch[2];
+
+	const hr = h / 360 * 2 * Math.PI;
+	const a = c * Math.cos(hr);
+	const b = c * Math.sin(hr);
+
+	return [l, a, b];
+};
+
+convert.rgb.ansi16 = function (args, saturation = null) {
+	const [r, g, b] = args;
+	let value = saturation === null ? convert.rgb.hsv(args)[2] : saturation; // Hsv -> ansi16 optimization
+
+	value = Math.round(value / 50);
+
+	if (value === 0) {
+		return 30;
+	}
+
+	let ansi = 30
+		+ ((Math.round(b / 255) << 2)
+		| (Math.round(g / 255) << 1)
+		| Math.round(r / 255));
+
+	if (value === 2) {
+		ansi += 60;
+	}
+
+	return ansi;
+};
+
+convert.hsv.ansi16 = function (args) {
+	// Optimization here; we already know the value and don't need to get
+	// it converted for us.
+	return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);
+};
+
+convert.rgb.ansi256 = function (args) {
+	const r = args[0];
+	const g = args[1];
+	const b = args[2];
+
+	// We use the extended greyscale palette here, with the exception of
+	// black and white. normal palette only has 4 greyscale shades.
+	if (r === g && g === b) {
+		if (r < 8) {
+			return 16;
+		}
+
+		if (r > 248) {
+			return 231;
+		}
+
+		return Math.round(((r - 8) / 247) * 24) + 232;
+	}
+
+	const ansi = 16
+		+ (36 * Math.round(r / 255 * 5))
+		+ (6 * Math.round(g / 255 * 5))
+		+ Math.round(b / 255 * 5);
+
+	return ansi;
+};
+
+convert.ansi16.rgb = function (args) {
+	let color = args % 10;
+
+	// Handle greyscale
+	if (color === 0 || color === 7) {
+		if (args > 50) {
+			color += 3.5;
+		}
+
+		color = color / 10.5 * 255;
+
+		return [color, color, color];
+	}
+
+	const mult = (~~(args > 50) + 1) * 0.5;
+	const r = ((color & 1) * mult) * 255;
+	const g = (((color >> 1) & 1) * mult) * 255;
+	const b = (((color >> 2) & 1) * mult) * 255;
+
+	return [r, g, b];
+};
+
+convert.ansi256.rgb = function (args) {
+	// Handle greyscale
+	if (args >= 232) {
+		const c = (args - 232) * 10 + 8;
+		return [c, c, c];
+	}
+
+	args -= 16;
+
+	let rem;
+	const r = Math.floor(args / 36) / 5 * 255;
+	const g = Math.floor((rem = args % 36) / 6) / 5 * 255;
+	const b = (rem % 6) / 5 * 255;
+
+	return [r, g, b];
+};
+
+convert.rgb.hex = function (args) {
+	const integer = ((Math.round(args[0]) & 0xFF) << 16)
+		+ ((Math.round(args[1]) & 0xFF) << 8)
+		+ (Math.round(args[2]) & 0xFF);
+
+	const string = integer.toString(16).toUpperCase();
+	return '000000'.substring(string.length) + string;
+};
+
+convert.hex.rgb = function (args) {
+	const match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
+	if (!match) {
+		return [0, 0, 0];
+	}
+
+	let colorString = match[0];
+
+	if (match[0].length === 3) {
+		colorString = colorString.split('').map(char => {
+			return char + char;
+		}).join('');
+	}
+
+	const integer = parseInt(colorString, 16);
+	const r = (integer >> 16) & 0xFF;
+	const g = (integer >> 8) & 0xFF;
+	const b = integer & 0xFF;
+
+	return [r, g, b];
+};
+
+convert.rgb.hcg = function (rgb) {
+	const r = rgb[0] / 255;
+	const g = rgb[1] / 255;
+	const b = rgb[2] / 255;
+	const max = Math.max(Math.max(r, g), b);
+	const min = Math.min(Math.min(r, g), b);
+	const chroma = (max - min);
+	let grayscale;
+	let hue;
+
+	if (chroma < 1) {
+		grayscale = min / (1 - chroma);
+	} else {
+		grayscale = 0;
+	}
+
+	if (chroma <= 0) {
+		hue = 0;
+	} else
+	if (max === r) {
+		hue = ((g - b) / chroma) % 6;
+	} else
+	if (max === g) {
+		hue = 2 + (b - r) / chroma;
+	} else {
+		hue = 4 + (r - g) / chroma;
+	}
+
+	hue /= 6;
+	hue %= 1;
+
+	return [hue * 360, chroma * 100, grayscale * 100];
+};
+
+convert.hsl.hcg = function (hsl) {
+	const s = hsl[1] / 100;
+	const l = hsl[2] / 100;
+
+	const c = l < 0.5 ? (2.0 * s * l) : (2.0 * s * (1.0 - l));
+
+	let f = 0;
+	if (c < 1.0) {
+		f = (l - 0.5 * c) / (1.0 - c);
+	}
+
+	return [hsl[0], c * 100, f * 100];
+};
+
+convert.hsv.hcg = function (hsv) {
+	const s = hsv[1] / 100;
+	const v = hsv[2] / 100;
+
+	const c = s * v;
+	let f = 0;
+
+	if (c < 1.0) {
+		f = (v - c) / (1 - c);
+	}
+
+	return [hsv[0], c * 100, f * 100];
+};
+
+convert.hcg.rgb = function (hcg) {
+	const h = hcg[0] / 360;
+	const c = hcg[1] / 100;
+	const g = hcg[2] / 100;
+
+	if (c === 0.0) {
+		return [g * 255, g * 255, g * 255];
+	}
+
+	const pure = [0, 0, 0];
+	const hi = (h % 1) * 6;
+	const v = hi % 1;
+	const w = 1 - v;
+	let mg = 0;
+
+	/* eslint-disable max-statements-per-line */
+	switch (Math.floor(hi)) {
+		case 0:
+			pure[0] = 1; pure[1] = v; pure[2] = 0; break;
+		case 1:
+			pure[0] = w; pure[1] = 1; pure[2] = 0; break;
+		case 2:
+			pure[0] = 0; pure[1] = 1; pure[2] = v; break;
+		case 3:
+			pure[0] = 0; pure[1] = w; pure[2] = 1; break;
+		case 4:
+			pure[0] = v; pure[1] = 0; pure[2] = 1; break;
+		default:
+			pure[0] = 1; pure[1] = 0; pure[2] = w;
+	}
+	/* eslint-enable max-statements-per-line */
+
+	mg = (1.0 - c) * g;
+
+	return [
+		(c * pure[0] + mg) * 255,
+		(c * pure[1] + mg) * 255,
+		(c * pure[2] + mg) * 255
+	];
+};
+
+convert.hcg.hsv = function (hcg) {
+	const c = hcg[1] / 100;
+	const g = hcg[2] / 100;
+
+	const v = c + g * (1.0 - c);
+	let f = 0;
+
+	if (v > 0.0) {
+		f = c / v;
+	}
+
+	return [hcg[0], f * 100, v * 100];
+};
+
+convert.hcg.hsl = function (hcg) {
+	const c = hcg[1] / 100;
+	const g = hcg[2] / 100;
+
+	const l = g * (1.0 - c) + 0.5 * c;
+	let s = 0;
+
+	if (l > 0.0 && l < 0.5) {
+		s = c / (2 * l);
+	} else
+	if (l >= 0.5 && l < 1.0) {
+		s = c / (2 * (1 - l));
+	}
+
+	return [hcg[0], s * 100, l * 100];
+};
+
+convert.hcg.hwb = function (hcg) {
+	const c = hcg[1] / 100;
+	const g = hcg[2] / 100;
+	const v = c + g * (1.0 - c);
+	return [hcg[0], (v - c) * 100, (1 - v) * 100];
+};
+
+convert.hwb.hcg = function (hwb) {
+	const w = hwb[1] / 100;
+	const b = hwb[2] / 100;
+	const v = 1 - b;
+	const c = v - w;
+	let g = 0;
+
+	if (c < 1) {
+		g = (v - c) / (1 - c);
+	}
+
+	return [hwb[0], c * 100, g * 100];
+};
+
+convert.apple.rgb = function (apple) {
+	return [(apple[0] / 65535) * 255, (apple[1] / 65535) * 255, (apple[2] / 65535) * 255];
+};
+
+convert.rgb.apple = function (rgb) {
+	return [(rgb[0] / 255) * 65535, (rgb[1] / 255) * 65535, (rgb[2] / 255) * 65535];
+};
+
+convert.gray.rgb = function (args) {
+	return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
+};
+
+convert.gray.hsl = function (args) {
+	return [0, 0, args[0]];
+};
+
+convert.gray.hsv = convert.gray.hsl;
+
+convert.gray.hwb = function (gray) {
+	return [0, 100, gray[0]];
+};
+
+convert.gray.cmyk = function (gray) {
+	return [0, 0, 0, gray[0]];
+};
+
+convert.gray.lab = function (gray) {
+	return [gray[0], 0, 0];
+};
+
+convert.gray.hex = function (gray) {
+	const val = Math.round(gray[0] / 100 * 255) & 0xFF;
+	const integer = (val << 16) + (val << 8) + val;
+
+	const string = integer.toString(16).toUpperCase();
+	return '000000'.substring(string.length) + string;
+};
+
+convert.rgb.gray = function (rgb) {
+	const val = (rgb[0] + rgb[1] + rgb[2]) / 3;
+	return [val / 255 * 100];
+};

node_modules/@jest/reporters/node_modules/color-convert/index.js

@@ -0,0 +1,81 @@
+const conversions = require('./conversions');
+const route = require('./route');
+
+const convert = {};
+
+const models = Object.keys(conversions);
+
+function wrapRaw(fn) {
+	const wrappedFn = function (...args) {
+		const arg0 = args[0];
+		if (arg0 === undefined || arg0 === null) {
+			return arg0;
+		}
+
+		if (arg0.length > 1) {
+			args = arg0;
+		}
+
+		return fn(args);
+	};
+
+	// Preserve .conversion property if there is one
+	if ('conversion' in fn) {
+		wrappedFn.conversion = fn.conversion;
+	}
+
+	return wrappedFn;
+}
+
+function wrapRounded(fn) {
+	const wrappedFn = function (...args) {
+		const arg0 = args[0];
+
+		if (arg0 === undefined || arg0 === null) {
+			return arg0;
+		}
+
+		if (arg0.length > 1) {
+			args = arg0;
+		}
+
+		const result = fn(args);
+
+		// We're assuming the result is an array here.
+		// see notice in conversions.js; don't use box types
+		// in conversion functions.
+		if (typeof result === 'object') {
+			for (let len = result.length, i = 0; i < len; i++) {
+				result[i] = Math.round(result[i]);
+			}
+		}
+
+		return result;
+	};
+
+	// Preserve .conversion property if there is one
+	if ('conversion' in fn) {
+		wrappedFn.conversion = fn.conversion;
+	}
+
+	return wrappedFn;
+}
+
+models.forEach(fromModel => {
+	convert[fromModel] = {};
+
+	Object.defineProperty(convert[fromModel], 'channels', {value: conversions[fromModel].channels});
+	Object.defineProperty(convert[fromModel], 'labels', {value: conversions[fromModel].labels});
+
+	const routes = route(fromModel);
+	const routeModels = Object.keys(routes);
+
+	routeModels.forEach(toModel => {
+		const fn = routes[toModel];
+
+		convert[fromModel][toModel] = wrapRounded(fn);
+		convert[fromModel][toModel].raw = wrapRaw(fn);
+	});
+});
+
+module.exports = convert;

node_modules/@jest/reporters/node_modules/color-convert/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "color-convert",
+  "description": "Plain color conversion functions",
+  "version": "2.0.1",
+  "author": "Heather Arthur <fayearthur@gmail.com>",
+  "license": "MIT",
+  "repository": "Qix-/color-convert",
+  "scripts": {
+    "pretest": "xo",
+    "test": "node test/basic.js"
+  },
+  "engines": {
+    "node": ">=7.0.0"
+  },
+  "keywords": [
+    "color",
+    "colour",
+    "convert",
+    "converter",
+    "conversion",
+    "rgb",
+    "hsl",
+    "hsv",
+    "hwb",
+    "cmyk",
+    "ansi",
+    "ansi16"
+  ],
+  "files": [
+    "index.js",
+    "conversions.js",
+    "route.js"
+  ],
+  "xo": {
+    "rules": {
+      "default-case": 0,
+      "no-inline-comments": 0,
+      "operator-linebreak": 0
+    }
+  },
+  "devDependencies": {
+    "chalk": "^2.4.2",
+    "xo": "^0.24.0"
+  },
+  "dependencies": {
+    "color-name": "~1.1.4"
+  }
+}

node_modules/@jest/reporters/node_modules/color-convert/route.js

@@ -0,0 +1,97 @@
+const conversions = require('./conversions');
+
+/*
+	This function routes a model to all other models.
+
+	all functions that are routed have a property `.conversion` attached
+	to the returned synthetic function. This property is an array
+	of strings, each with the steps in between the 'from' and 'to'
+	color models (inclusive).
+
+	conversions that are not possible simply are not included.
+*/
+
+function buildGraph() {
+	const graph = {};
+	// https://jsperf.com/object-keys-vs-for-in-with-closure/3
+	const models = Object.keys(conversions);
+
+	for (let len = models.length, i = 0; i < len; i++) {
+		graph[models[i]] = {
+			// http://jsperf.com/1-vs-infinity
+			// micro-opt, but this is simple.
+			distance: -1,
+			parent: null
+		};
+	}
+
+	return graph;
+}
+
+// https://en.wikipedia.org/wiki/Breadth-first_search
+function deriveBFS(fromModel) {
+	const graph = buildGraph();
+	const queue = [fromModel]; // Unshift -> queue -> pop
+
+	graph[fromModel].distance = 0;
+
+	while (queue.length) {
+		const current = queue.pop();
+		const adjacents = Object.keys(conversions[current]);
+
+		for (let len = adjacents.length, i = 0; i < len; i++) {
+			const adjacent = adjacents[i];
+			const node = graph[adjacent];
+
+			if (node.distance === -1) {
+				node.distance = graph[current].distance + 1;
+				node.parent = current;
+				queue.unshift(adjacent);
+			}
+		}
+	}
+
+	return graph;
+}
+
+function link(from, to) {
+	return function (args) {
+		return to(from(args));
+	};
+}
+
+function wrapConversion(toModel, graph) {
+	const path = [graph[toModel].parent, toModel];
+	let fn = conversions[graph[toModel].parent][toModel];
+
+	let cur = graph[toModel].parent;
+	while (graph[cur].parent) {
+		path.unshift(graph[cur].parent);
+		fn = link(conversions[graph[cur].parent][cur], fn);
+		cur = graph[cur].parent;
+	}
+
+	fn.conversion = path;
+	return fn;
+}
+
+module.exports = function (fromModel) {
+	const graph = deriveBFS(fromModel);
+	const conversion = {};
+
+	const models = Object.keys(graph);
+	for (let len = models.length, i = 0; i < len; i++) {
+		const toModel = models[i];
+		const node = graph[toModel];
+
+		if (node.parent === null) {
+			// No possible conversion, or this node is the source model.
+			continue;
+		}
+
+		conversion[toModel] = wrapConversion(toModel, graph);
+	}
+
+	return conversion;
+};
+

node_modules/@jest/reporters/node_modules/color-name/LICENSE

@@ -0,0 +1,8 @@
+The MIT License (MIT)
+Copyright (c) 2015 Dmitry Ivanov
+
+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/reporters/node_modules/color-name/README.md

@@ -0,0 +1,11 @@
+A JSON with color names and its values. Based on http://dev.w3.org/csswg/css-color/#named-colors.
+
+[![NPM](https://nodei.co/npm/color-name.png?mini=true)](https://nodei.co/npm/color-name/)
+
+
+```js
+var colors = require('color-name');
+colors.red //[255,0,0]
+```
+
+<a href="LICENSE"><img src="https://upload.wikimedia.org/wikipedia/commons/0/0c/MIT_logo.svg" width="120"/></a>

node_modules/@jest/reporters/node_modules/color-name/index.js

@@ -0,0 +1,152 @@
+'use strict'
+
+module.exports = {
+	"aliceblue": [240, 248, 255],
+	"antiquewhite": [250, 235, 215],
+	"aqua": [0, 255, 255],
+	"aquamarine": [127, 255, 212],
+	"azure": [240, 255, 255],
+	"beige": [245, 245, 220],
+	"bisque": [255, 228, 196],
+	"black": [0, 0, 0],
+	"blanchedalmond": [255, 235, 205],
+	"blue": [0, 0, 255],
+	"blueviolet": [138, 43, 226],
+	"brown": [165, 42, 42],
+	"burlywood": [222, 184, 135],
+	"cadetblue": [95, 158, 160],
+	"chartreuse": [127, 255, 0],
+	"chocolate": [210, 105, 30],
+	"coral": [255, 127, 80],
+	"cornflowerblue": [100, 149, 237],
+	"cornsilk": [255, 248, 220],
+	"crimson": [220, 20, 60],
+	"cyan": [0, 255, 255],
+	"darkblue": [0, 0, 139],
+	"darkcyan": [0, 139, 139],
+	"darkgoldenrod": [184, 134, 11],
+	"darkgray": [169, 169, 169],
+	"darkgreen": [0, 100, 0],
+	"darkgrey": [169, 169, 169],
+	"darkkhaki": [189, 183, 107],
+	"darkmagenta": [139, 0, 139],
+	"darkolivegreen": [85, 107, 47],
+	"darkorange": [255, 140, 0],
+	"darkorchid": [153, 50, 204],
+	"darkred": [139, 0, 0],
+	"darksalmon": [233, 150, 122],
+	"darkseagreen": [143, 188, 143],
+	"darkslateblue": [72, 61, 139],
+	"darkslategray": [47, 79, 79],
+	"darkslategrey": [47, 79, 79],
+	"darkturquoise": [0, 206, 209],
+	"darkviolet": [148, 0, 211],
+	"deeppink": [255, 20, 147],
+	"deepskyblue": [0, 191, 255],
+	"dimgray": [105, 105, 105],
+	"dimgrey": [105, 105, 105],
+	"dodgerblue": [30, 144, 255],
+	"firebrick": [178, 34, 34],
+	"floralwhite": [255, 250, 240],
+	"forestgreen": [34, 139, 34],
+	"fuchsia": [255, 0, 255],
+	"gainsboro": [220, 220, 220],
+	"ghostwhite": [248, 248, 255],
+	"gold": [255, 215, 0],
+	"goldenrod": [218, 165, 32],
+	"gray": [128, 128, 128],
+	"green": [0, 128, 0],
+	"greenyellow": [173, 255, 47],
+	"grey": [128, 128, 128],
+	"honeydew": [240, 255, 240],
+	"hotpink": [255, 105, 180],
+	"indianred": [205, 92, 92],
+	"indigo": [75, 0, 130],
+	"ivory": [255, 255, 240],
+	"khaki": [240, 230, 140],
+	"lavender": [230, 230, 250],
+	"lavenderblush": [255, 240, 245],
+	"lawngreen": [124, 252, 0],
+	"lemonchiffon": [255, 250, 205],
+	"lightblue": [173, 216, 230],
+	"lightcoral": [240, 128, 128],
+	"lightcyan": [224, 255, 255],
+	"lightgoldenrodyellow": [250, 250, 210],
+	"lightgray": [211, 211, 211],
+	"lightgreen": [144, 238, 144],
+	"lightgrey": [211, 211, 211],
+	"lightpink": [255, 182, 193],
+	"lightsalmon": [255, 160, 122],
+	"lightseagreen": [32, 178, 170],
+	"lightskyblue": [135, 206, 250],
+	"lightslategray": [119, 136, 153],
+	"lightslategrey": [119, 136, 153],
+	"lightsteelblue": [176, 196, 222],
+	"lightyellow": [255, 255, 224],
+	"lime": [0, 255, 0],
+	"limegreen": [50, 205, 50],
+	"linen": [250, 240, 230],
+	"magenta": [255, 0, 255],
+	"maroon": [128, 0, 0],
+	"mediumaquamarine": [102, 205, 170],
+	"mediumblue": [0, 0, 205],
+	"mediumorchid": [186, 85, 211],
+	"mediumpurple": [147, 112, 219],
+	"mediumseagreen": [60, 179, 113],
+	"mediumslateblue": [123, 104, 238],
+	"mediumspringgreen": [0, 250, 154],
+	"mediumturquoise": [72, 209, 204],
+	"mediumvioletred": [199, 21, 133],
+	"midnightblue": [25, 25, 112],
+	"mintcream": [245, 255, 250],
+	"mistyrose": [255, 228, 225],
+	"moccasin": [255, 228, 181],
+	"navajowhite": [255, 222, 173],
+	"navy": [0, 0, 128],
+	"oldlace": [253, 245, 230],
+	"olive": [128, 128, 0],
+	"olivedrab": [107, 142, 35],
+	"orange": [255, 165, 0],
+	"orangered": [255, 69, 0],
+	"orchid": [218, 112, 214],
+	"palegoldenrod": [238, 232, 170],
+	"palegreen": [152, 251, 152],
+	"paleturquoise": [175, 238, 238],
+	"palevioletred": [219, 112, 147],
+	"papayawhip": [255, 239, 213],
+	"peachpuff": [255, 218, 185],
+	"peru": [205, 133, 63],
+	"pink": [255, 192, 203],
+	"plum": [221, 160, 221],
+	"powderblue": [176, 224, 230],
+	"purple": [128, 0, 128],
+	"rebeccapurple": [102, 51, 153],
+	"red": [255, 0, 0],
+	"rosybrown": [188, 143, 143],
+	"royalblue": [65, 105, 225],
+	"saddlebrown": [139, 69, 19],
+	"salmon": [250, 128, 114],
+	"sandybrown": [244, 164, 96],
+	"seagreen": [46, 139, 87],
+	"seashell": [255, 245, 238],
+	"sienna": [160, 82, 45],
+	"silver": [192, 192, 192],
+	"skyblue": [135, 206, 235],
+	"slateblue": [106, 90, 205],
+	"slategray": [112, 128, 144],
+	"slategrey": [112, 128, 144],
+	"snow": [255, 250, 250],
+	"springgreen": [0, 255, 127],
+	"steelblue": [70, 130, 180],
+	"tan": [210, 180, 140],
+	"teal": [0, 128, 128],
+	"thistle": [216, 191, 216],
+	"tomato": [255, 99, 71],
+	"turquoise": [64, 224, 208],
+	"violet": [238, 130, 238],
+	"wheat": [245, 222, 179],
+	"white": [255, 255, 255],
+	"whitesmoke": [245, 245, 245],
+	"yellow": [255, 255, 0],
+	"yellowgreen": [154, 205, 50]
+};

node_modules/@jest/reporters/node_modules/color-name/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "color-name",
+  "version": "1.1.4",
+  "description": "A list of color names and its values",
+  "main": "index.js",
+  "files": [
+    "index.js"
+  ],
+  "scripts": {
+    "test": "node test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:colorjs/color-name.git"
+  },
+  "keywords": [
+    "color-name",
+    "color",
+    "color-keyword",
+    "keyword"
+  ],
+  "author": "DY <dfcreative@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/colorjs/color-name/issues"
+  },
+  "homepage": "https://github.com/colorjs/color-name"
+}

node_modules/@jest/reporters/node_modules/has-flag/index.d.ts

@@ -0,0 +1,39 @@
+/**
+Check if [`argv`](https://nodejs.org/docs/latest/api/process.html#process_process_argv) has a specific flag.
+
+@param flag - CLI flag to look for. The `--` prefix is optional.
+@param argv - CLI arguments. Default: `process.argv`.
+@returns Whether the flag exists.
+
+@example
+```
+// $ ts-node foo.ts -f --unicorn --foo=bar -- --rainbow
+
+// foo.ts
+import hasFlag = require('has-flag');
+
+hasFlag('unicorn');
+//=> true
+
+hasFlag('--unicorn');
+//=> true
+
+hasFlag('f');
+//=> true
+
+hasFlag('-f');
+//=> true
+
+hasFlag('foo=bar');
+//=> true
+
+hasFlag('foo');
+//=> false
+
+hasFlag('rainbow');
+//=> false
+```
+*/
+declare function hasFlag(flag: string, argv?: string[]): boolean;
+
+export = hasFlag;

node_modules/@jest/reporters/node_modules/has-flag/index.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = (flag, argv = process.argv) => {
+	const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
+	const position = argv.indexOf(prefix + flag);
+	const terminatorPosition = argv.indexOf('--');
+	return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+};

node_modules/@jest/reporters/node_modules/has-flag/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+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/reporters/node_modules/has-flag/package.json

@@ -0,0 +1,46 @@
+{
+	"name": "has-flag",
+	"version": "4.0.0",
+	"description": "Check if argv has a specific flag",
+	"license": "MIT",
+	"repository": "sindresorhus/has-flag",
+	"author": {
+		"name": "Sindre Sorhus",
+		"email": "sindresorhus@gmail.com",
+		"url": "sindresorhus.com"
+	},
+	"engines": {
+		"node": ">=8"
+	},
+	"scripts": {
+		"test": "xo && ava && tsd"
+	},
+	"files": [
+		"index.js",
+		"index.d.ts"
+	],
+	"keywords": [
+		"has",
+		"check",
+		"detect",
+		"contains",
+		"find",
+		"flag",
+		"cli",
+		"command-line",
+		"argv",
+		"process",
+		"arg",
+		"args",
+		"argument",
+		"arguments",
+		"getopt",
+		"minimist",
+		"optimist"
+	],
+	"devDependencies": {
+		"ava": "^1.4.1",
+		"tsd": "^0.7.2",
+		"xo": "^0.24.0"
+	}
+}

node_modules/@jest/reporters/node_modules/has-flag/readme.md

@@ -0,0 +1,89 @@
+# has-flag [![Build Status](https://travis-ci.org/sindresorhus/has-flag.svg?branch=master)](https://travis-ci.org/sindresorhus/has-flag)
+
+> Check if [`argv`](https://nodejs.org/docs/latest/api/process.html#process_process_argv) has a specific flag
+
+Correctly stops looking after an `--` argument terminator.
+
+---
+
+<div align="center">
+	<b>
+		<a href="https://tidelift.com/subscription/pkg/npm-has-flag?utm_source=npm-has-flag&utm_medium=referral&utm_campaign=readme">Get professional support for this package with a Tidelift subscription</a>
+	</b>
+	<br>
+	<sub>
+		Tidelift helps make open source sustainable for maintainers while giving companies<br>assurances about security, maintenance, and licensing for their dependencies.
+	</sub>
+</div>
+
+---
+
+
+## Install
+
+```
+$ npm install has-flag
+```
+
+
+## Usage
+
+```js
+// foo.js
+const hasFlag = require('has-flag');
+
+hasFlag('unicorn');
+//=> true
+
+hasFlag('--unicorn');
+//=> true
+
+hasFlag('f');
+//=> true
+
+hasFlag('-f');
+//=> true
+
+hasFlag('foo=bar');
+//=> true
+
+hasFlag('foo');
+//=> false
+
+hasFlag('rainbow');
+//=> false
+```
+
+```
+$ node foo.js -f --unicorn --foo=bar -- --rainbow
+```
+
+
+## API
+
+### hasFlag(flag, [argv])
+
+Returns a boolean for whether the flag exists.
+
+#### flag
+
+Type: `string`
+
+CLI flag to look for. The `--` prefix is optional.
+
+#### argv
+
+Type: `string[]`<br>
+Default: `process.argv`
+
+CLI arguments.
+
+
+## Security
+
+To report a security vulnerability, please use the [Tidelift security contact](https://tidelift.com/security). Tidelift will coordinate the fix and disclosure.
+
+
+## License
+
+MIT © [Sindre Sorhus](https://sindresorhus.com)

node_modules/@jest/reporters/node_modules/istanbul-lib-instrument/CHANGELOG.md

@@ -0,0 +1,571 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+## [4.0.3](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@4.0.2...istanbul-lib-instrument@4.0.3) (2020-05-09)
+
+
+### Bug Fixes
+
+* Prevent readInitialCoverage from reading babel config ([#562](https://github.com/istanbuljs/istanbuljs/issues/562)) ([49b4745](https://github.com/istanbuljs/istanbuljs/commit/49b474525c15e703642916011bd86f663aca0c3d))
+
+
+
+
+
+## [4.0.2](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@4.0.1...istanbul-lib-instrument@4.0.2) (2020-05-06)
+
+
+### Bug Fixes
+
+* Add ts-ignore to reassignment of generated function ([#557](https://github.com/istanbuljs/istanbuljs/issues/557)) ([817efb0](https://github.com/istanbuljs/istanbuljs/commit/817efb04fc161efae426b2231a0221606b09f559))
+* Use @babel/core for all babel imports. ([#555](https://github.com/istanbuljs/istanbuljs/issues/555)) ([a99a13e](https://github.com/istanbuljs/istanbuljs/commit/a99a13ee6931fc124a2a723c3f511cdbcb0aa81d))
+
+
+
+
+
+## [4.0.1](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@4.0.0...istanbul-lib-instrument@4.0.1) (2020-02-03)
+
+
+### Bug Fixes
+
+* Always call coverage initialization function ([#524](https://github.com/istanbuljs/istanbuljs/issues/524)) ([c6536c1](https://github.com/istanbuljs/istanbuljs/commit/c6536c14bf0663ca7e0493dd40ea132b05352594))
+
+
+
+
+
+# [4.0.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@4.0.0-alpha.3...istanbul-lib-instrument@4.0.0) (2019-12-20)
+
+**Note:** Version bump only for package istanbul-lib-instrument
+
+
+
+
+
+# [4.0.0-alpha.3](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@4.0.0-alpha.2...istanbul-lib-instrument@4.0.0-alpha.3) (2019-12-07)
+
+**Note:** Version bump only for package istanbul-lib-instrument
+
+
+
+
+
+# [4.0.0-alpha.2](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@4.0.0-alpha.1...istanbul-lib-instrument@4.0.0-alpha.2) (2019-11-01)
+
+
+### Bug Fixes
+
+* Produce properly merged source-maps when inputSourceMap is provided ([#487](https://github.com/istanbuljs/istanbuljs/issues/487)) ([8f8c88e](https://github.com/istanbuljs/istanbuljs/commit/8f8c88e3a2add4c08729e41e356aa7981dc69d4d))
+
+
+
+
+
+# [4.0.0-alpha.1](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@4.0.0-alpha.0...istanbul-lib-instrument@4.0.0-alpha.1) (2019-10-06)
+
+
+### Bug Fixes
+
+* Eliminate babel hoisting of the coverage variable ([#481](https://github.com/istanbuljs/istanbuljs/issues/481)) ([8dfbcba](https://github.com/istanbuljs/istanbuljs/commit/8dfbcba)), closes [#92](https://github.com/istanbuljs/istanbuljs/issues/92)
+* Honor ignore hints in chained if statements ([#469](https://github.com/istanbuljs/istanbuljs/issues/469)) ([a629770](https://github.com/istanbuljs/istanbuljs/commit/a629770)), closes [#468](https://github.com/istanbuljs/istanbuljs/issues/468)
+* Populate lastFileCoverage for already instrumented files ([#470](https://github.com/istanbuljs/istanbuljs/issues/470)) ([ea6d779](https://github.com/istanbuljs/istanbuljs/commit/ea6d779)), closes [istanbuljs/nyc#594](https://github.com/istanbuljs/nyc/issues/594)
+
+
+### Features
+
+* Use @istanbuljs/schema to pull defaults ([#485](https://github.com/istanbuljs/istanbuljs/issues/485)) ([87e27f3](https://github.com/istanbuljs/istanbuljs/commit/87e27f3)), closes [#460](https://github.com/istanbuljs/istanbuljs/issues/460)
+
+
+### BREAKING CHANGES
+
+* The defaults for `autoWrap`, `preserveComments`,
+`esModules` and `produceSourceMap` are now true.  This applies only to
+the stand-alone instrumenter, the visitor does not use these options.
+* The `flow` and `jsx` parser plugins are no longer
+enabled by default.  This applies only to the stand-alone instrumenter,
+the visitor does not use this option.
+* The `plugins` option of the stand-alone instrumenter
+has been renamed to `parserPlugins` to match nyc.
+
+
+
+
+
+# [4.0.0-alpha.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@3.3.0...istanbul-lib-instrument@4.0.0-alpha.0) (2019-06-19)
+
+
+### Features
+
+* Update dependencies, require Node.js 8 ([#401](https://github.com/istanbuljs/istanbuljs/issues/401)) ([bf3a539](https://github.com/istanbuljs/istanbuljs/commit/bf3a539))
+
+
+### BREAKING CHANGES
+
+* Node.js 8 is now required
+
+
+
+
+
+# [3.3.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@3.2.0...istanbul-lib-instrument@3.3.0) (2019-04-24)
+
+
+### Features
+
+* Enable classProperties and classPrivateProperties parsers and coverage. ([#379](https://github.com/istanbuljs/istanbuljs/issues/379)) ([c09dc38](https://github.com/istanbuljs/istanbuljs/commit/c09dc38))
+
+
+
+
+
+# [3.2.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@3.1.2...istanbul-lib-instrument@3.2.0) (2019-04-09)
+
+
+### Features
+
+* Add bigInt and importMeta to default parser plugins. ([#356](https://github.com/istanbuljs/istanbuljs/issues/356)) ([fb4d6ed](https://github.com/istanbuljs/istanbuljs/commit/fb4d6ed)), closes [#338](https://github.com/istanbuljs/istanbuljs/issues/338)
+
+
+
+
+
+## [3.1.2](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@3.1.1...istanbul-lib-instrument@3.1.2) (2019-04-03)
+
+
+### Bug Fixes
+
+* Be more friendly to ts-node. ([#352](https://github.com/istanbuljs/istanbuljs/issues/352)) ([40d15f5](https://github.com/istanbuljs/istanbuljs/commit/40d15f5)), closes [#336](https://github.com/istanbuljs/istanbuljs/issues/336)
+
+
+
+
+
+## [3.1.1](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@3.1.0...istanbul-lib-instrument@3.1.1) (2019-03-12)
+
+
+### Bug Fixes
+
+* Honor istanbul ignore next hints placed before export statement. ([#298](https://github.com/istanbuljs/istanbuljs/issues/298)) ([f24795d](https://github.com/istanbuljs/istanbuljs/commit/f24795d)), closes [#297](https://github.com/istanbuljs/istanbuljs/issues/297)
+
+
+
+
+
+# [3.1.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@3.0.1...istanbul-lib-instrument@3.1.0) (2019-01-26)
+
+
+### Features
+
+* dont skip for loop initialization instrumentation ([#188](https://github.com/istanbuljs/istanbuljs/issues/188)) ([2e0258e](https://github.com/istanbuljs/istanbuljs/commit/2e0258e))
+* New options coverageGlobalScope and coverageGlobalScopeFunc. ([#200](https://github.com/istanbuljs/istanbuljs/issues/200)) ([25509c7](https://github.com/istanbuljs/istanbuljs/commit/25509c7)), closes [#199](https://github.com/istanbuljs/istanbuljs/issues/199)
+
+
+
+
+
+<a name="3.0.1"></a>
+## [3.0.1](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@3.0.0...istanbul-lib-instrument@3.0.1) (2018-12-25)
+
+
+
+
+**Note:** Version bump only for package istanbul-lib-instrument
+
+<a name="3.0.0"></a>
+# [3.0.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@2.3.2...istanbul-lib-instrument@3.0.0) (2018-09-06)
+
+
+### Chores
+
+* Update test for babel 7. ([#218](https://github.com/istanbuljs/istanbuljs/issues/218)) ([9cf4d43](https://github.com/istanbuljs/istanbuljs/commit/9cf4d43)), closes [#205](https://github.com/istanbuljs/istanbuljs/issues/205)
+
+
+### Features
+
+* Add option plugins ([#205](https://github.com/istanbuljs/istanbuljs/issues/205)) ([312f81f](https://github.com/istanbuljs/istanbuljs/commit/312f81f))
+* Update babel to 7.0.0. ([#215](https://github.com/istanbuljs/istanbuljs/issues/215)) ([8a96613](https://github.com/istanbuljs/istanbuljs/commit/8a96613))
+
+
+### BREAKING CHANGES
+
+* was added which requires an option for the `decorators`
+plugin.  Add it to get tests working again, commit updated api.md.
+
+
+
+
+<a name="2.3.2"></a>
+## [2.3.2](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@2.3.1...istanbul-lib-instrument@2.3.2) (2018-07-24)
+
+
+
+
+**Note:** Version bump only for package istanbul-lib-instrument
+
+<a name="2.3.1"></a>
+## [2.3.1](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@2.3.0...istanbul-lib-instrument@2.3.1) (2018-07-07)
+
+
+### Bug Fixes
+
+* Don't ignore src/visitor.js for self test. ([#194](https://github.com/istanbuljs/istanbuljs/issues/194)) ([71b815d](https://github.com/istanbuljs/istanbuljs/commit/71b815d))
+
+
+
+
+<a name="2.3.0"></a>
+# [2.3.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@2.2.1...istanbul-lib-instrument@2.3.0) (2018-06-27)
+
+
+### Features
+
+* update pinned babel version to latest release. ([#189](https://github.com/istanbuljs/istanbuljs/issues/189)) ([ac8ec07](https://github.com/istanbuljs/istanbuljs/commit/ac8ec07))
+
+
+
+
+<a name="2.2.1"></a>
+## [2.2.1](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@2.2.0...istanbul-lib-instrument@2.2.1) (2018-06-26)
+
+
+### Bug Fixes
+
+* Instrument ObjectMethod's. ([#182](https://github.com/istanbuljs/istanbuljs/issues/182)) ([126f09d](https://github.com/istanbuljs/istanbuljs/commit/126f09d))
+* update default args test guard to work on supported versions. ([#185](https://github.com/istanbuljs/istanbuljs/issues/185)) ([955511a](https://github.com/istanbuljs/istanbuljs/commit/955511a))
+
+
+
+
+<a name="2.2.0"></a>
+# [2.2.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@2.0.2...istanbul-lib-instrument@2.2.0) (2018-06-06)
+
+
+### Features
+
+* add support for optional catch binding ([#175](https://github.com/istanbuljs/istanbuljs/issues/175)) ([088dd9f](https://github.com/istanbuljs/istanbuljs/commit/088dd9f))
+
+
+
+
+<a name="2.1.0"></a>
+# [2.1.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@2.0.2...istanbul-lib-instrument@2.1.0) (2018-05-31)
+
+
+### Features
+
+* add support for optional catch binding ([#175](https://github.com/istanbuljs/istanbuljs/issues/175)) ([088dd9f](https://github.com/istanbuljs/istanbuljs/commit/088dd9f))
+
+
+
+
+<a name="2.0.2"></a>
+## [2.0.2](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@2.0.1...istanbul-lib-instrument@2.0.2) (2018-05-31)
+
+
+
+
+**Note:** Version bump only for package istanbul-lib-instrument
+
+<a name="2.0.1"></a>
+## [2.0.1](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@2.0.0...istanbul-lib-instrument@2.0.1) (2018-05-31)
+
+
+### Bug Fixes
+
+* should import [@babel](https://github.com/babel)/template ([85a0d1a](https://github.com/istanbuljs/istanbuljs/commit/85a0d1a))
+
+
+
+
+<a name="2.0.0"></a>
+# [2.0.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.10.1...istanbul-lib-instrument@2.0.0) (2018-05-31)
+
+
+### Bug Fixes
+
+* parenthesize superClass on non-idetifier case ([#158](https://github.com/istanbuljs/istanbuljs/issues/158)) ([6202c88](https://github.com/istanbuljs/istanbuljs/commit/6202c88))
+
+
+### Chores
+
+* upgrade babel in instrumenter ([#174](https://github.com/istanbuljs/istanbuljs/issues/174)) ([ce23e91](https://github.com/istanbuljs/istanbuljs/commit/ce23e91))
+
+
+### BREAKING CHANGES
+
+* babel@7 drops Node@4 support
+
+
+
+
+<a name="1.10.1"></a>
+## [1.10.1](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.10.0...istanbul-lib-instrument@1.10.1) (2018-03-09)
+
+
+### Bug Fixes
+
+* default value for ignorelassMethods ([#151](https://github.com/istanbuljs/istanbuljs/issues/151)) ([5dd88e8](https://github.com/istanbuljs/istanbuljs/commit/5dd88e8))
+
+
+
+
+<a name="1.10.0"></a>
+# [1.10.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.9.2...istanbul-lib-instrument@1.10.0) (2018-03-04)
+
+
+### Features
+
+* allows an array of ignored method names to be provided ([#127](https://github.com/istanbuljs/istanbuljs/issues/127)) ([67918e2](https://github.com/istanbuljs/istanbuljs/commit/67918e2))
+
+
+
+
+<a name="1.9.2"></a>
+## [1.9.2](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.9.1...istanbul-lib-instrument@1.9.2) (2018-02-13)
+
+
+### Bug Fixes
+
+* compatibility with babel 7 ([#135](https://github.com/istanbuljs/istanbuljs/issues/135)) ([6cac849](https://github.com/istanbuljs/istanbuljs/commit/6cac849))
+* handle instrumentation when a function is called Function ([#131](https://github.com/istanbuljs/istanbuljs/issues/131)) ([b12a07e](https://github.com/istanbuljs/istanbuljs/commit/b12a07e))
+* proper passing of the preserveComments option to babel ([#122](https://github.com/istanbuljs/istanbuljs/issues/122)) ([470bb0e](https://github.com/istanbuljs/istanbuljs/commit/470bb0e))
+* update instrument, account for lack of arrow expression ([#119](https://github.com/istanbuljs/istanbuljs/issues/119)) ([#125](https://github.com/istanbuljs/istanbuljs/issues/125)) ([0968206](https://github.com/istanbuljs/istanbuljs/commit/0968206))
+
+
+
+
+<a name="1.9.1"></a>
+## [1.9.1](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.9.0...istanbul-lib-instrument@1.9.1) (2017-10-22)
+
+
+### Bug Fixes
+
+* address issue with class instrumentation ([#111](https://github.com/istanbuljs/istanbuljs/issues/111)) ([cbd1c14](https://github.com/istanbuljs/istanbuljs/commit/cbd1c14))
+
+
+
+
+<a name="1.9.0"></a>
+# [1.9.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.8.0...istanbul-lib-instrument@1.9.0) (2017-10-21)
+
+
+### Bug Fixes
+
+* support conditional expression for superClass ([#106](https://github.com/istanbuljs/istanbuljs/issues/106)) ([aae256f](https://github.com/istanbuljs/istanbuljs/commit/aae256f))
+
+
+### Features
+
+* add support for ignoring entire files ([#108](https://github.com/istanbuljs/istanbuljs/issues/108)) ([f12da65](https://github.com/istanbuljs/istanbuljs/commit/f12da65))
+
+
+
+
+<a name="1.8.0"></a>
+# [1.8.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.7.5...istanbul-lib-instrument@1.8.0) (2017-09-05)
+
+
+### Features
+
+* add support for object-spread syntax ([#82](https://github.com/istanbuljs/istanbuljs/issues/82)) ([28d5566](https://github.com/istanbuljs/istanbuljs/commit/28d5566))
+
+
+
+
+<a name="1.7.5"></a>
+## [1.7.5](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.7.4...istanbul-lib-instrument@1.7.5) (2017-08-23)
+
+
+### Bug Fixes
+
+* name of function is now preserved or named exports ([#79](https://github.com/istanbuljs/istanbuljs/issues/79)) ([2ce8974](https://github.com/istanbuljs/istanbuljs/commit/2ce8974))
+
+
+
+
+<a name="1.7.4"></a>
+## [1.7.4](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.7.3...istanbul-lib-instrument@1.7.4) (2017-07-16)
+
+
+### Bug Fixes
+
+* update increment operator to appropriate expression type ([#74](https://github.com/istanbuljs/istanbuljs/issues/74)) ([dc69e66](https://github.com/istanbuljs/istanbuljs/commit/dc69e66))
+
+
+
+
+<a name="1.7.3"></a>
+## [1.7.3](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.7.2...istanbul-lib-instrument@1.7.3) (2017-06-25)
+
+
+
+
+<a name="1.7.2"></a>
+## [1.7.2](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.7.1...istanbul-lib-instrument@1.7.2) (2017-05-27)
+
+
+### Bug Fixes
+
+* hoist statement counter for class variables, so that name is preserved ([#60](https://github.com/istanbuljs/istanbuljs/issues/60)) ([120d221](https://github.com/istanbuljs/istanbuljs/commit/120d221))
+
+
+
+
+<a name="1.7.1"></a>
+## [1.7.1](https://github.com/istanbuljs/istanbul-lib-instrument/compare/istanbul-lib-instrument@1.7.0...istanbul-lib-instrument@1.7.1) (2017-04-29)
+
+
+### Bug Fixes
+
+* don't instrument a file if it has already been instrumented ([#38](https://github.com/istanbuljs/istanbuljs/issues/38)) ([9c38e4e](https://github.com/istanbuljs/istanbul-lib-instrument/commit/9c38e4e))
+
+
+
+
+<a name="1.7.0"></a>
+# [1.7.0](https://github.com/istanbuljs/istanbul-lib-instrument/compare/istanbul-lib-instrument@1.6.2...istanbul-lib-instrument@1.7.0) (2017-03-27)
+
+
+### Features
+
+* use extended babylon support; adding features such as jsx ([#22](https://github.com/istanbuljs/istanbuljs/issues/22)) ([11c2438](https://github.com/istanbuljs/istanbul-lib-instrument/commit/11c2438))
+
+<a name="1.6.2"></a>
+## [1.6.2](https://github.com/istanbuljs/istanbul-lib-instrument/compare/istanbul-lib-instrument@1.6.1...istanbul-lib-instrument@1.6.2) (2017-03-22)
+
+
+### Bug Fixes
+
+* loc is sometimes not defined, so loc.start fails see [#99](https://github.com/istanbuljs/istanbuljs/issues/99) ([#18](https://github.com/istanbuljs/istanbuljs/issues/18)) ([df85ba6](https://github.com/istanbuljs/istanbul-lib-instrument/commit/df85ba6))
+
+<a name="1.6.1"></a>
+## [1.6.1](https://github.com/istanbuljs/istanbul-lib-instrument/compare/istanbul-lib-instrument@1.6.0...istanbul-lib-instrument@1.6.1) (2017-03-21)
+
+<a name="1.6.0"></a>
+# [1.6.0](https://github.com/istanbuljs/istanbul-lib-instrument/compare/istanbul-lib-instrument@1.4.2...istanbul-lib-instrument@1.6.0) (2017-03-21)
+
+
+### Features
+
+* adds line number property back to coverage.json ([b03b927](https://github.com/istanbuljs/istanbul-lib-instrument/commit/b03b927))
+
+<a name="1.4.2"></a>
+## [1.4.2](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.4.1...v1.4.2) (2017-01-04)
+
+
+### Bug Fixes
+
+* only hoist counter for a smaller subset of function declarations ([9f8931e](https://github.com/istanbuljs/istanbul-lib-instrument/commit/9f8931e))
+
+
+
+<a name="1.4.1"></a>
+## [1.4.1](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.4.0...v1.4.1) (2017-01-04)
+
+
+### Bug Fixes
+
+* address regression discussed in https://github.com/istanbuljs/babel-plugin-istanbul/issues/78 ([#40](https://github.com/istanbuljs/istanbul-lib-instrument/issues/40)) ([7f458a3](https://github.com/istanbuljs/istanbul-lib-instrument/commit/7f458a3))
+
+
+
+<a name="1.4.0"></a>
+# [1.4.0](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.3.1...v1.4.0) (2017-01-02)
+
+
+### Features
+
+* preserve inferred function names ([#38](https://github.com/istanbuljs/istanbul-lib-instrument/issues/38)) ([312666e](https://github.com/istanbuljs/istanbul-lib-instrument/commit/312666e))
+
+
+
+<a name="1.3.1"></a>
+## [1.3.1](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.3.0...v1.3.1) (2016-12-27)
+
+
+### Bug Fixes
+
+* function declaration assignment now retains function name ([#33](https://github.com/istanbuljs/istanbul-lib-instrument/issues/33)) ([2d781da](https://github.com/istanbuljs/istanbul-lib-instrument/commit/2d781da))
+
+
+
+<a name="1.3.0"></a>
+# [1.3.0](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.2.0...v1.3.0) (2016-11-10)
+
+
+### Features
+
+* allow an input source-map to be passed to instrumentSync()  ([#23](https://github.com/istanbuljs/istanbul-lib-instrument/issues/23)) ([b08e4f5](https://github.com/istanbuljs/istanbul-lib-instrument/commit/b08e4f5))
+
+
+
+<a name="1.2.0"></a>
+# [1.2.0](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.1.4...v1.2.0) (2016-10-25)
+
+
+### Features
+
+* implement function to extract empty coverage data from an instrumented file ([#28](https://github.com/istanbuljs/istanbul-lib-instrument/issues/28)) ([06d0ef6](https://github.com/istanbuljs/istanbul-lib-instrument/commit/06d0ef6))
+
+
+
+<a name="1.1.4"></a>
+## [1.1.4](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.1.3...v1.1.4) (2016-10-17)
+
+
+### Bug Fixes
+
+* hoist coverage variable to very top of file ([#26](https://github.com/istanbuljs/istanbul-lib-instrument/issues/26)) ([0225e8c](https://github.com/istanbuljs/istanbul-lib-instrument/commit/0225e8c))
+
+
+
+<a name="1.1.3"></a>
+## [1.1.3](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.1.2...v1.1.3) (2016-09-13)
+
+
+### Performance Improvements
+
+* simplify coverage variable naming https://github.com/istanbuljs/istanbul-lib-instrument/pull/24 ([7252aae](https://github.com/istanbuljs/istanbul-lib-instrument/commit/7252aae))
+
+
+
+<a name="1.1.2"></a>
+## [1.1.2](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.1.1...v1.1.2) (2016-09-08)
+
+
+### Performance Improvements
+
+* use zero-based numeric indices for much faster instrumented code ([#22](https://github.com/istanbuljs/istanbul-lib-instrument/issues/22)) ([5b401f5](https://github.com/istanbuljs/istanbul-lib-instrument/commit/5b401f5))
+
+
+
+<a name="1.1.1"></a>
+## [1.1.1](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.1.0...v1.1.1) (2016-08-30)
+
+
+### Bug Fixes
+
+* upgrade istanbul-lib-coverage ([eb9b1f6](https://github.com/istanbuljs/istanbul-lib-instrument/commit/eb9b1f6))
+
+
+
+<a name="1.1.0"></a>
+# [1.1.0](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.1.0-alpha.4...v1.1.0) (2016-08-11)
+
+
+### Bug Fixes
+
+* guard against invalid loc ([#16](https://github.com/istanbuljs/istanbul-lib-instrument/issues/16)) ([23ebfc3](https://github.com/istanbuljs/istanbul-lib-instrument/commit/23ebfc3))
+
+
+
+<a name="1.1.0-alpha.4"></a>
+# [1.1.0-alpha.4](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.0.0-alpha.5...v1.1.0-alpha.4) (2016-07-20)
+
+
+### Bug Fixes
+
+* require more performant babel-generator ([#15](https://github.com/istanbuljs/istanbul-lib-instrument/issues/15)) ([21b2563](https://github.com/istanbuljs/istanbul-lib-instrument/commit/21b2563))

node_modules/@jest/reporters/node_modules/istanbul-lib-instrument/LICENSE

@@ -0,0 +1,24 @@
+Copyright 2012-2015 Yahoo! Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Yahoo! Inc. nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL YAHOO! INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

node_modules/@jest/reporters/node_modules/istanbul-lib-instrument/README.md

@@ -0,0 +1,21 @@
+## istanbul-lib-instrument
+
+[![Build Status](https://travis-ci.org/istanbuljs/istanbul-lib-instrument.svg?branch=master)](https://travis-ci.org/istanbuljs/istanbul-lib-instrument)
+
+Istanbul instrumenter library.
+
+Version 1.1.x now implements instrumentation using `Babel`. The implementation is inspired
+by prior art by @dtinth as demonstrated in the `__coverage__` babel plugin.
+
+It provides 2 "modes" of instrumentation.
+
+-   The old API that is mostly unchanged (except for incompatibilities noted) and
+    performs the instrumentation using babel as a library.
+
+-   A `programVisitor` function for the Babel AST that can be used by a Babel plugin
+    to emit instrumentation for ES6 code directly without any source map
+    processing. This is the preferred path for babel users. The Babel plugin is
+    called `babel-plugin-istanbul`.
+
+Incompatibilities and changes to instrumentation behavior can be found in
+[v0-changes.md](v0-changes.md).

node_modules/@jest/reporters/node_modules/istanbul-lib-instrument/dist/constants.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MAGIC_VALUE = exports.MAGIC_KEY = exports.SHA = void 0;
+
+var _crypto = require("crypto");
+
+var _semver = require("semver");
+
+var _package = require("../package.json");
+
+// function to use for creating hashes
+const SHA = 'sha1'; // name of coverage data magic key
+
+exports.SHA = SHA;
+const MAGIC_KEY = '_coverageSchema'; // name of coverage data magic value
+
+exports.MAGIC_KEY = MAGIC_KEY;
+const MAGIC_VALUE = (0, _crypto.createHash)(SHA).update(_package.name + '@' + (0, _semver.major)(_package.version)).digest('hex');
+exports.MAGIC_VALUE = MAGIC_VALUE;

node_modules/@jest/reporters/node_modules/istanbul-lib-instrument/dist/index.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createInstrumenter = createInstrumenter;
+Object.defineProperty(exports, "programVisitor", {
+  enumerable: true,
+  get: function () {
+    return _visitor.default;
+  }
+});
+Object.defineProperty(exports, "readInitialCoverage", {
+  enumerable: true,
+  get: function () {
+    return _readCoverage.default;
+  }
+});
+exports.defaultOpts = void 0;
+
+var _schema = require("@istanbuljs/schema");
+
+var _instrumenter = _interopRequireDefault(require("./instrumenter"));
+
+var _visitor = _interopRequireDefault(require("./visitor"));
+
+var _readCoverage = _interopRequireDefault(require("./read-coverage"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * createInstrumenter creates a new instrumenter with the
+ * supplied options.
+ * @param {Object} opts - instrumenter options. See the documentation
+ * for the Instrumenter class.
+ */
+function createInstrumenter(opts) {
+  return new _instrumenter.default(opts);
+}
+
+const defaultOpts = _schema.defaults.instrumenter;
+exports.defaultOpts = defaultOpts;

node_modules/@jest/reporters/node_modules/istanbul-lib-instrument/dist/instrumenter.js

@@ -0,0 +1,182 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _core = require("@babel/core");
+
+var _schema = require("@istanbuljs/schema");
+
+var _visitor = _interopRequireDefault(require("./visitor"));
+
+var _readCoverage = _interopRequireDefault(require("./read-coverage"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/*
+ Copyright 2012-2015, Yahoo Inc.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+
+/**
+ * Instrumenter is the public API for the instrument library.
+ * It is typically used for ES5 code. For ES6 code that you
+ * are already running under `babel` use the coverage plugin
+ * instead.
+ * @param {Object} opts optional.
+ * @param {string} [opts.coverageVariable=__coverage__] name of global coverage variable.
+ * @param {boolean} [opts.preserveComments=false] preserve comments in output
+ * @param {boolean} [opts.compact=true] generate compact code.
+ * @param {boolean} [opts.esModules=false] set to true to instrument ES6 modules.
+ * @param {boolean} [opts.autoWrap=false] set to true to allow `return` statements outside of functions.
+ * @param {boolean} [opts.produceSourceMap=false] set to true to produce a source map for the instrumented code.
+ * @param {Array} [opts.ignoreClassMethods=[]] set to array of class method names to ignore for coverage.
+ * @param {Function} [opts.sourceMapUrlCallback=null] a callback function that is called when a source map URL
+ *     is found in the original code. This function is called with the source file name and the source map URL.
+ * @param {boolean} [opts.debug=false] - turn debugging on
+ * @param {array} [opts.parserPlugins] - set babel parser plugins, see @istanbuljs/schema for defaults.
+ */
+class Instrumenter {
+  constructor(opts = {}) {
+    this.opts = { ..._schema.defaults.instrumenter,
+      ...opts
+    };
+    this.fileCoverage = null;
+    this.sourceMap = null;
+  }
+  /**
+   * instrument the supplied code and track coverage against the supplied
+   * filename. It throws if invalid code is passed to it. ES5 and ES6 syntax
+   * is supported. To instrument ES6 modules, make sure that you set the
+   * `esModules` property to `true` when creating the instrumenter.
+   *
+   * @param {string} code - the code to instrument
+   * @param {string} filename - the filename against which to track coverage.
+   * @param {object} [inputSourceMap] - the source map that maps the not instrumented code back to it's original form.
+   * Is assigned to the coverage object and therefore, is available in the json output and can be used to remap the
+   * coverage to the untranspiled source.
+   * @returns {string} the instrumented code.
+   */
+
+
+  instrumentSync(code, filename, inputSourceMap) {
+    if (typeof code !== 'string') {
+      throw new Error('Code must be a string');
+    }
+
+    filename = filename || String(new Date().getTime()) + '.js';
+    const {
+      opts
+    } = this;
+    let output = {};
+    const babelOpts = {
+      configFile: false,
+      babelrc: false,
+      ast: true,
+      filename: filename || String(new Date().getTime()) + '.js',
+      inputSourceMap,
+      sourceMaps: opts.produceSourceMap,
+      compact: opts.compact,
+      comments: opts.preserveComments,
+      parserOpts: {
+        allowReturnOutsideFunction: opts.autoWrap,
+        sourceType: opts.esModules ? 'module' : 'script',
+        plugins: opts.parserPlugins
+      },
+      plugins: [[({
+        types
+      }) => {
+        const ee = (0, _visitor.default)(types, filename, {
+          coverageVariable: opts.coverageVariable,
+          coverageGlobalScope: opts.coverageGlobalScope,
+          coverageGlobalScopeFunc: opts.coverageGlobalScopeFunc,
+          ignoreClassMethods: opts.ignoreClassMethods,
+          inputSourceMap
+        });
+        return {
+          visitor: {
+            Program: {
+              enter: ee.enter,
+
+              exit(path) {
+                output = ee.exit(path);
+              }
+
+            }
+          }
+        };
+      }]]
+    };
+    const codeMap = (0, _core.transformSync)(code, babelOpts);
+
+    if (!output || !output.fileCoverage) {
+      const initialCoverage = (0, _readCoverage.default)(codeMap.ast) ||
+      /* istanbul ignore next: paranoid check */
+      {};
+      this.fileCoverage = initialCoverage.coverageData;
+      this.sourceMap = inputSourceMap;
+      return code;
+    }
+
+    this.fileCoverage = output.fileCoverage;
+    this.sourceMap = codeMap.map;
+    const cb = this.opts.sourceMapUrlCallback;
+
+    if (cb && output.sourceMappingURL) {
+      cb(filename, output.sourceMappingURL);
+    }
+
+    return codeMap.code;
+  }
+  /**
+   * callback-style instrument method that calls back with an error
+   * as opposed to throwing one. Note that in the current implementation,
+   * the callback will be called in the same process tick and is not asynchronous.
+   *
+   * @param {string} code - the code to instrument
+   * @param {string} filename - the filename against which to track coverage.
+   * @param {Function} callback - the callback
+   * @param {Object} inputSourceMap - the source map that maps the not instrumented code back to it's original form.
+   * Is assigned to the coverage object and therefore, is available in the json output and can be used to remap the
+   * coverage to the untranspiled source.
+   */
+
+
+  instrument(code, filename, callback, inputSourceMap) {
+    if (!callback && typeof filename === 'function') {
+      callback = filename;
+      filename = null;
+    }
+
+    try {
+      const out = this.instrumentSync(code, filename, inputSourceMap);
+      callback(null, out);
+    } catch (ex) {
+      callback(ex);
+    }
+  }
+  /**
+   * returns the file coverage object for the last file instrumented.
+   * @returns {Object} the file coverage object.
+   */
+
+
+  lastFileCoverage() {
+    return this.fileCoverage;
+  }
+  /**
+   * returns the source map produced for the last file instrumented.
+   * @returns {null|Object} the source map object.
+   */
+
+
+  lastSourceMap() {
+    return this.sourceMap;
+  }
+
+}
+
+var _default = Instrumenter;
+exports.default = _default;

node_modules/@jest/reporters/node_modules/istanbul-lib-instrument/dist/read-coverage.js

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = readInitialCoverage;
+
+var _core = require("@babel/core");
+
+var _schema = require("@istanbuljs/schema");
+
+var _constants = require("./constants");
+
+function getAst(code) {
+  if (typeof code === 'object' && typeof code.type === 'string') {
+    // Assume code is already a babel ast.
+    return code;
+  }
+
+  if (typeof code !== 'string') {
+    throw new Error('Code must be a string');
+  } // Parse as leniently as possible
+
+
+  return (0, _core.parseSync)(code, {
+    babelrc: false,
+    configFile: false,
+    parserOpts: {
+      allowImportExportEverywhere: true,
+      allowReturnOutsideFunction: true,
+      allowSuperOutsideMethod: true,
+      sourceType: 'script',
+      plugins: _schema.defaults.instrumenter.parserPlugins
+    }
+  });
+}
+
+function readInitialCoverage(code) {
+  const ast = getAst(code);
+  let covScope;
+  (0, _core.traverse)(ast, {
+    ObjectProperty(path) {
+      const {
+        node
+      } = path;
+
+      if (!node.computed && path.get('key').isIdentifier() && node.key.name === _constants.MAGIC_KEY) {
+        const magicValue = path.get('value').evaluate();
+
+        if (!magicValue.confident || magicValue.value !== _constants.MAGIC_VALUE) {
+          return;
+        }
+
+        covScope = path.scope.getFunctionParent() || path.scope.getProgramParent();
+        path.stop();
+      }
+    }
+
+  });
+
+  if (!covScope) {
+    return null;
+  }
+
+  const result = {};
+
+  for (const key of ['path', 'hash', 'gcv', 'coverageData']) {
+    const binding = covScope.getOwnBinding(key);
+
+    if (!binding) {
+      return null;
+    }
+
+    const valuePath = binding.path.get('init');
+    const value = valuePath.evaluate();
+
+    if (!value.confident) {
+      return null;
+    }
+
+    result[key] = value.value;
+  }
+
+  delete result.coverageData[_constants.MAGIC_KEY];
+  delete result.coverageData.hash;
+  return result;
+}

node_modules/@jest/reporters/node_modules/istanbul-lib-instrument/dist/source-coverage.js

@@ -0,0 +1,121 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SourceCoverage = void 0;
+
+var _istanbulLibCoverage = require("istanbul-lib-coverage");
+
+function cloneLocation(loc) {
+  return {
+    start: {
+      line: loc && loc.start.line,
+      column: loc && loc.start.column
+    },
+    end: {
+      line: loc && loc.end.line,
+      column: loc && loc.end.column
+    }
+  };
+}
+/**
+ * SourceCoverage provides mutation methods to manipulate the structure of
+ * a file coverage object. Used by the instrumenter to create a full coverage
+ * object for a file incrementally.
+ *
+ * @private
+ * @param pathOrObj {String|Object} - see the argument for {@link FileCoverage}
+ * @extends FileCoverage
+ * @constructor
+ */
+
+
+class SourceCoverage extends _istanbulLibCoverage.classes.FileCoverage {
+  constructor(pathOrObj) {
+    super(pathOrObj);
+    this.meta = {
+      last: {
+        s: 0,
+        f: 0,
+        b: 0
+      }
+    };
+  }
+
+  newStatement(loc) {
+    const s = this.meta.last.s;
+    this.data.statementMap[s] = cloneLocation(loc);
+    this.data.s[s] = 0;
+    this.meta.last.s += 1;
+    return s;
+  }
+
+  newFunction(name, decl, loc) {
+    const f = this.meta.last.f;
+    name = name || '(anonymous_' + f + ')';
+    this.data.fnMap[f] = {
+      name,
+      decl: cloneLocation(decl),
+      loc: cloneLocation(loc),
+      // DEPRECATED: some legacy reports require this info.
+      line: loc && loc.start.line
+    };
+    this.data.f[f] = 0;
+    this.meta.last.f += 1;
+    return f;
+  }
+
+  newBranch(type, loc) {
+    const b = this.meta.last.b;
+    this.data.b[b] = [];
+    this.data.branchMap[b] = {
+      loc: cloneLocation(loc),
+      type,
+      locations: [],
+      // DEPRECATED: some legacy reports require this info.
+      line: loc && loc.start.line
+    };
+    this.meta.last.b += 1;
+    return b;
+  }
+
+  addBranchPath(name, location) {
+    const bMeta = this.data.branchMap[name];
+    const counts = this.data.b[name];
+    /* istanbul ignore if: paranoid check */
+
+    if (!bMeta) {
+      throw new Error('Invalid branch ' + name);
+    }
+
+    bMeta.locations.push(cloneLocation(location));
+    counts.push(0);
+    return counts.length - 1;
+  }
+  /**
+   * Assigns an input source map to the coverage that can be used
+   * to remap the coverage output to the original source
+   * @param sourceMap {object} the source map
+   */
+
+
+  inputSourceMap(sourceMap) {
+    this.data.inputSourceMap = sourceMap;
+  }
+
+  freeze() {
+    // prune empty branches
+    const map = this.data.branchMap;
+    const branches = this.data.b;
+    Object.keys(map).forEach(b => {
+      if (map[b].locations.length === 0) {
+        delete map[b];
+        delete branches[b];
+      }
+    });
+  }
+
+}
+
+exports.SourceCoverage = SourceCoverage;

node_modules/@jest/reporters/node_modules/istanbul-lib-instrument/dist/visitor.js

@@ -0,0 +1,683 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _crypto = require("crypto");
+
+var _core = require("@babel/core");
+
+var _schema = require("@istanbuljs/schema");
+
+var _sourceCoverage = require("./source-coverage");
+
+var _constants = require("./constants");
+
+// pattern for istanbul to ignore a section
+const COMMENT_RE = /^\s*istanbul\s+ignore\s+(if|else|next)(?=\W|$)/; // pattern for istanbul to ignore the whole file
+
+const COMMENT_FILE_RE = /^\s*istanbul\s+ignore\s+(file)(?=\W|$)/; // source map URL pattern
+
+const SOURCE_MAP_RE = /[#@]\s*sourceMappingURL=(.*)\s*$/m; // generate a variable name from hashing the supplied file path
+
+function genVar(filename) {
+  const hash = (0, _crypto.createHash)(_constants.SHA);
+  hash.update(filename);
+  return 'cov_' + parseInt(hash.digest('hex').substr(0, 12), 16).toString(36);
+} // VisitState holds the state of the visitor, provides helper functions
+// and is the `this` for the individual coverage visitors.
+
+
+class VisitState {
+  constructor(types, sourceFilePath, inputSourceMap, ignoreClassMethods = []) {
+    this.varName = genVar(sourceFilePath);
+    this.attrs = {};
+    this.nextIgnore = null;
+    this.cov = new _sourceCoverage.SourceCoverage(sourceFilePath);
+
+    if (typeof inputSourceMap !== 'undefined') {
+      this.cov.inputSourceMap(inputSourceMap);
+    }
+
+    this.ignoreClassMethods = ignoreClassMethods;
+    this.types = types;
+    this.sourceMappingURL = null;
+  } // should we ignore the node? Yes, if specifically ignoring
+  // or if the node is generated.
+
+
+  shouldIgnore(path) {
+    return this.nextIgnore || !path.node.loc;
+  } // extract the ignore comment hint (next|if|else) or null
+
+
+  hintFor(node) {
+    let hint = null;
+
+    if (node.leadingComments) {
+      node.leadingComments.forEach(c => {
+        const v = (c.value ||
+        /* istanbul ignore next: paranoid check */
+        '').trim();
+        const groups = v.match(COMMENT_RE);
+
+        if (groups) {
+          hint = groups[1];
+        }
+      });
+    }
+
+    return hint;
+  } // extract a source map URL from comments and keep track of it
+
+
+  maybeAssignSourceMapURL(node) {
+    const extractURL = comments => {
+      if (!comments) {
+        return;
+      }
+
+      comments.forEach(c => {
+        const v = (c.value ||
+        /* istanbul ignore next: paranoid check */
+        '').trim();
+        const groups = v.match(SOURCE_MAP_RE);
+
+        if (groups) {
+          this.sourceMappingURL = groups[1];
+        }
+      });
+    };
+
+    extractURL(node.leadingComments);
+    extractURL(node.trailingComments);
+  } // for these expressions the statement counter needs to be hoisted, so
+  // function name inference can be preserved
+
+
+  counterNeedsHoisting(path) {
+    return path.isFunctionExpression() || path.isArrowFunctionExpression() || path.isClassExpression();
+  } // all the generic stuff that needs to be done on enter for every node
+
+
+  onEnter(path) {
+    const n = path.node;
+    this.maybeAssignSourceMapURL(n); // if already ignoring, nothing more to do
+
+    if (this.nextIgnore !== null) {
+      return;
+    } // check hint to see if ignore should be turned on
+
+
+    const hint = this.hintFor(n);
+
+    if (hint === 'next') {
+      this.nextIgnore = n;
+      return;
+    } // else check custom node attribute set by a prior visitor
+
+
+    if (this.getAttr(path.node, 'skip-all') !== null) {
+      this.nextIgnore = n;
+    } // else check for ignored class methods
+
+
+    if (path.isFunctionExpression() && this.ignoreClassMethods.some(name => path.node.id && name === path.node.id.name)) {
+      this.nextIgnore = n;
+      return;
+    }
+
+    if (path.isClassMethod() && this.ignoreClassMethods.some(name => name === path.node.key.name)) {
+      this.nextIgnore = n;
+      return;
+    }
+  } // all the generic stuff on exit of a node,
+  // including reseting ignores and custom node attrs
+
+
+  onExit(path) {
+    // restore ignore status, if needed
+    if (path.node === this.nextIgnore) {
+      this.nextIgnore = null;
+    } // nuke all attributes for the node
+
+
+    delete path.node.__cov__;
+  } // set a node attribute for the supplied node
+
+
+  setAttr(node, name, value) {
+    node.__cov__ = node.__cov__ || {};
+    node.__cov__[name] = value;
+  } // retrieve a node attribute for the supplied node or null
+
+
+  getAttr(node, name) {
+    const c = node.__cov__;
+
+    if (!c) {
+      return null;
+    }
+
+    return c[name];
+  } //
+
+
+  increase(type, id, index) {
+    const T = this.types;
+    const wrap = index !== null ? // If `index` present, turn `x` into `x[index]`.
+    x => T.memberExpression(x, T.numericLiteral(index), true) : x => x;
+    return T.updateExpression('++', wrap(T.memberExpression(T.memberExpression(T.callExpression(T.identifier(this.varName), []), T.identifier(type)), T.numericLiteral(id), true)));
+  }
+
+  insertCounter(path, increment) {
+    const T = this.types;
+
+    if (path.isBlockStatement()) {
+      path.node.body.unshift(T.expressionStatement(increment));
+    } else if (path.isStatement()) {
+      path.insertBefore(T.expressionStatement(increment));
+    } else if (this.counterNeedsHoisting(path) && T.isVariableDeclarator(path.parentPath)) {
+      // make an attempt to hoist the statement counter, so that
+      // function names are maintained.
+      const parent = path.parentPath.parentPath;
+
+      if (parent && T.isExportNamedDeclaration(parent.parentPath)) {
+        parent.parentPath.insertBefore(T.expressionStatement(increment));
+      } else if (parent && (T.isProgram(parent.parentPath) || T.isBlockStatement(parent.parentPath))) {
+        parent.insertBefore(T.expressionStatement(increment));
+      } else {
+        path.replaceWith(T.sequenceExpression([increment, path.node]));
+      }
+    }
+    /* istanbul ignore else: not expected */
+    else if (path.isExpression()) {
+        path.replaceWith(T.sequenceExpression([increment, path.node]));
+      } else {
+        console.error('Unable to insert counter for node type:', path.node.type);
+      }
+  }
+
+  insertStatementCounter(path) {
+    /* istanbul ignore if: paranoid check */
+    if (!(path.node && path.node.loc)) {
+      return;
+    }
+
+    const index = this.cov.newStatement(path.node.loc);
+    const increment = this.increase('s', index, null);
+    this.insertCounter(path, increment);
+  }
+
+  insertFunctionCounter(path) {
+    const T = this.types;
+    /* istanbul ignore if: paranoid check */
+
+    if (!(path.node && path.node.loc)) {
+      return;
+    }
+
+    const n = path.node;
+    let dloc = null; // get location for declaration
+
+    switch (n.type) {
+      case 'FunctionDeclaration':
+        /* istanbul ignore else: paranoid check */
+        if (n.id) {
+          dloc = n.id.loc;
+        }
+
+        break;
+
+      case 'FunctionExpression':
+        if (n.id) {
+          dloc = n.id.loc;
+        }
+
+        break;
+    }
+
+    if (!dloc) {
+      dloc = {
+        start: n.loc.start,
+        end: {
+          line: n.loc.start.line,
+          column: n.loc.start.column + 1
+        }
+      };
+    }
+
+    const name = path.node.id ? path.node.id.name : path.node.name;
+    const index = this.cov.newFunction(name, dloc, path.node.body.loc);
+    const increment = this.increase('f', index, null);
+    const body = path.get('body');
+    /* istanbul ignore else: not expected */
+
+    if (body.isBlockStatement()) {
+      body.node.body.unshift(T.expressionStatement(increment));
+    } else {
+      console.error('Unable to process function body node type:', path.node.type);
+    }
+  }
+
+  getBranchIncrement(branchName, loc) {
+    const index = this.cov.addBranchPath(branchName, loc);
+    return this.increase('b', branchName, index);
+  }
+
+  insertBranchCounter(path, branchName, loc) {
+    const increment = this.getBranchIncrement(branchName, loc || path.node.loc);
+    this.insertCounter(path, increment);
+  }
+
+  findLeaves(node, accumulator, parent, property) {
+    if (!node) {
+      return;
+    }
+
+    if (node.type === 'LogicalExpression') {
+      const hint = this.hintFor(node);
+
+      if (hint !== 'next') {
+        this.findLeaves(node.left, accumulator, node, 'left');
+        this.findLeaves(node.right, accumulator, node, 'right');
+      }
+    } else {
+      accumulator.push({
+        node,
+        parent,
+        property
+      });
+    }
+  }
+
+} // generic function that takes a set of visitor methods and
+// returns a visitor object with `enter` and `exit` properties,
+// such that:
+//
+// * standard entry processing is done
+// * the supplied visitors are called only when ignore is not in effect
+//   This relieves them from worrying about ignore states and generated nodes.
+// * standard exit processing is done
+//
+
+
+function entries(...enter) {
+  // the enter function
+  const wrappedEntry = function (path, node) {
+    this.onEnter(path);
+
+    if (this.shouldIgnore(path)) {
+      return;
+    }
+
+    enter.forEach(e => {
+      e.call(this, path, node);
+    });
+  };
+
+  const exit = function (path, node) {
+    this.onExit(path, node);
+  };
+
+  return {
+    enter: wrappedEntry,
+    exit
+  };
+}
+
+function coverStatement(path) {
+  this.insertStatementCounter(path);
+}
+/* istanbul ignore next: no node.js support */
+
+
+function coverAssignmentPattern(path) {
+  const n = path.node;
+  const b = this.cov.newBranch('default-arg', n.loc);
+  this.insertBranchCounter(path.get('right'), b);
+}
+
+function coverFunction(path) {
+  this.insertFunctionCounter(path);
+}
+
+function coverVariableDeclarator(path) {
+  this.insertStatementCounter(path.get('init'));
+}
+
+function coverClassPropDeclarator(path) {
+  this.insertStatementCounter(path.get('value'));
+}
+
+function makeBlock(path) {
+  const T = this.types;
+
+  if (!path.node) {
+    path.replaceWith(T.blockStatement([]));
+  }
+
+  if (!path.isBlockStatement()) {
+    path.replaceWith(T.blockStatement([path.node]));
+    path.node.loc = path.node.body[0].loc;
+    path.node.body[0].leadingComments = path.node.leadingComments;
+    path.node.leadingComments = undefined;
+  }
+}
+
+function blockProp(prop) {
+  return function (path) {
+    makeBlock.call(this, path.get(prop));
+  };
+}
+
+function makeParenthesizedExpressionForNonIdentifier(path) {
+  const T = this.types;
+
+  if (path.node && !path.isIdentifier()) {
+    path.replaceWith(T.parenthesizedExpression(path.node));
+  }
+}
+
+function parenthesizedExpressionProp(prop) {
+  return function (path) {
+    makeParenthesizedExpressionForNonIdentifier.call(this, path.get(prop));
+  };
+}
+
+function convertArrowExpression(path) {
+  const n = path.node;
+  const T = this.types;
+
+  if (!T.isBlockStatement(n.body)) {
+    const bloc = n.body.loc;
+
+    if (n.expression === true) {
+      n.expression = false;
+    }
+
+    n.body = T.blockStatement([T.returnStatement(n.body)]); // restore body location
+
+    n.body.loc = bloc; // set up the location for the return statement so it gets
+    // instrumented
+
+    n.body.body[0].loc = bloc;
+  }
+}
+
+function coverIfBranches(path) {
+  const n = path.node;
+  const hint = this.hintFor(n);
+  const ignoreIf = hint === 'if';
+  const ignoreElse = hint === 'else';
+  const branch = this.cov.newBranch('if', n.loc);
+
+  if (ignoreIf) {
+    this.setAttr(n.consequent, 'skip-all', true);
+  } else {
+    this.insertBranchCounter(path.get('consequent'), branch, n.loc);
+  }
+
+  if (ignoreElse) {
+    this.setAttr(n.alternate, 'skip-all', true);
+  } else {
+    this.insertBranchCounter(path.get('alternate'), branch, n.loc);
+  }
+}
+
+function createSwitchBranch(path) {
+  const b = this.cov.newBranch('switch', path.node.loc);
+  this.setAttr(path.node, 'branchName', b);
+}
+
+function coverSwitchCase(path) {
+  const T = this.types;
+  const b = this.getAttr(path.parentPath.node, 'branchName');
+  /* istanbul ignore if: paranoid check */
+
+  if (b === null) {
+    throw new Error('Unable to get switch branch name');
+  }
+
+  const increment = this.getBranchIncrement(b, path.node.loc);
+  path.node.consequent.unshift(T.expressionStatement(increment));
+}
+
+function coverTernary(path) {
+  const n = path.node;
+  const branch = this.cov.newBranch('cond-expr', path.node.loc);
+  const cHint = this.hintFor(n.consequent);
+  const aHint = this.hintFor(n.alternate);
+
+  if (cHint !== 'next') {
+    this.insertBranchCounter(path.get('consequent'), branch);
+  }
+
+  if (aHint !== 'next') {
+    this.insertBranchCounter(path.get('alternate'), branch);
+  }
+}
+
+function coverLogicalExpression(path) {
+  const T = this.types;
+
+  if (path.parentPath.node.type === 'LogicalExpression') {
+    return; // already processed
+  }
+
+  const leaves = [];
+  this.findLeaves(path.node, leaves);
+  const b = this.cov.newBranch('binary-expr', path.node.loc);
+
+  for (let i = 0; i < leaves.length; i += 1) {
+    const leaf = leaves[i];
+    const hint = this.hintFor(leaf.node);
+
+    if (hint === 'next') {
+      continue;
+    }
+
+    const increment = this.getBranchIncrement(b, leaf.node.loc);
+
+    if (!increment) {
+      continue;
+    }
+
+    leaf.parent[leaf.property] = T.sequenceExpression([increment, leaf.node]);
+  }
+}
+
+const codeVisitor = {
+  ArrowFunctionExpression: entries(convertArrowExpression, coverFunction),
+  AssignmentPattern: entries(coverAssignmentPattern),
+  BlockStatement: entries(),
+  // ignore processing only
+  ExportDefaultDeclaration: entries(),
+  // ignore processing only
+  ExportNamedDeclaration: entries(),
+  // ignore processing only
+  ClassMethod: entries(coverFunction),
+  ClassDeclaration: entries(parenthesizedExpressionProp('superClass')),
+  ClassProperty: entries(coverClassPropDeclarator),
+  ClassPrivateProperty: entries(coverClassPropDeclarator),
+  ObjectMethod: entries(coverFunction),
+  ExpressionStatement: entries(coverStatement),
+  BreakStatement: entries(coverStatement),
+  ContinueStatement: entries(coverStatement),
+  DebuggerStatement: entries(coverStatement),
+  ReturnStatement: entries(coverStatement),
+  ThrowStatement: entries(coverStatement),
+  TryStatement: entries(coverStatement),
+  VariableDeclaration: entries(),
+  // ignore processing only
+  VariableDeclarator: entries(coverVariableDeclarator),
+  IfStatement: entries(blockProp('consequent'), blockProp('alternate'), coverStatement, coverIfBranches),
+  ForStatement: entries(blockProp('body'), coverStatement),
+  ForInStatement: entries(blockProp('body'), coverStatement),
+  ForOfStatement: entries(blockProp('body'), coverStatement),
+  WhileStatement: entries(blockProp('body'), coverStatement),
+  DoWhileStatement: entries(blockProp('body'), coverStatement),
+  SwitchStatement: entries(createSwitchBranch, coverStatement),
+  SwitchCase: entries(coverSwitchCase),
+  WithStatement: entries(blockProp('body'), coverStatement),
+  FunctionDeclaration: entries(coverFunction),
+  FunctionExpression: entries(coverFunction),
+  LabeledStatement: entries(coverStatement),
+  ConditionalExpression: entries(coverTernary),
+  LogicalExpression: entries(coverLogicalExpression)
+};
+const globalTemplateAlteredFunction = (0, _core.template)(`
+        var Function = (function(){}).constructor;
+        var global = (new Function(GLOBAL_COVERAGE_SCOPE))();
+`);
+const globalTemplateFunction = (0, _core.template)(`
+        var global = (new Function(GLOBAL_COVERAGE_SCOPE))();
+`);
+const globalTemplateVariable = (0, _core.template)(`
+        var global = GLOBAL_COVERAGE_SCOPE;
+`); // the template to insert at the top of the program.
+
+const coverageTemplate = (0, _core.template)(`
+    function COVERAGE_FUNCTION () {
+        var path = PATH;
+        var hash = HASH;
+        GLOBAL_COVERAGE_TEMPLATE
+        var gcv = GLOBAL_COVERAGE_VAR;
+        var coverageData = INITIAL;
+        var coverage = global[gcv] || (global[gcv] = {});
+        if (!coverage[path] || coverage[path].hash !== hash) {
+            coverage[path] = coverageData;
+        }
+
+        var actualCoverage = coverage[path];
+        {
+            // @ts-ignore
+            COVERAGE_FUNCTION = function () {
+                return actualCoverage;
+            }
+        }
+
+        return actualCoverage;
+    }
+`, {
+  preserveComments: true
+}); // the rewire plugin (and potentially other babel middleware)
+// may cause files to be instrumented twice, see:
+// https://github.com/istanbuljs/babel-plugin-istanbul/issues/94
+// we should only instrument code for coverage the first time
+// it's run through istanbul-lib-instrument.
+
+function alreadyInstrumented(path, visitState) {
+  return path.scope.hasBinding(visitState.varName);
+}
+
+function shouldIgnoreFile(programNode) {
+  return programNode.parent && programNode.parent.comments.some(c => COMMENT_FILE_RE.test(c.value));
+}
+/**
+ * programVisitor is a `babel` adaptor for instrumentation.
+ * It returns an object with two methods `enter` and `exit`.
+ * These should be assigned to or called from `Program` entry and exit functions
+ * in a babel visitor.
+ * These functions do not make assumptions about the state set by Babel and thus
+ * can be used in a context other than a Babel plugin.
+ *
+ * The exit function returns an object that currently has the following keys:
+ *
+ * `fileCoverage` - the file coverage object created for the source file.
+ * `sourceMappingURL` - any source mapping URL found when processing the file.
+ *
+ * @param {Object} types - an instance of babel-types
+ * @param {string} sourceFilePath - the path to source file
+ * @param {Object} opts - additional options
+ * @param {string} [opts.coverageVariable=__coverage__] the global coverage variable name.
+ * @param {string} [opts.coverageGlobalScope=this] the global coverage variable scope.
+ * @param {boolean} [opts.coverageGlobalScopeFunc=true] use an evaluated function to find coverageGlobalScope.
+ * @param {Array} [opts.ignoreClassMethods=[]] names of methods to ignore by default on classes.
+ * @param {object} [opts.inputSourceMap=undefined] the input source map, that maps the uninstrumented code back to the
+ * original code.
+ */
+
+
+function programVisitor(types, sourceFilePath = 'unknown.js', opts = {}) {
+  const T = types;
+  opts = { ..._schema.defaults.instrumentVisitor,
+    ...opts
+  };
+  const visitState = new VisitState(types, sourceFilePath, opts.inputSourceMap, opts.ignoreClassMethods);
+  return {
+    enter(path) {
+      if (shouldIgnoreFile(path.find(p => p.isProgram()))) {
+        return;
+      }
+
+      if (alreadyInstrumented(path, visitState)) {
+        return;
+      }
+
+      path.traverse(codeVisitor, visitState);
+    },
+
+    exit(path) {
+      if (alreadyInstrumented(path, visitState)) {
+        return;
+      }
+
+      visitState.cov.freeze();
+      const coverageData = visitState.cov.toJSON();
+
+      if (shouldIgnoreFile(path.find(p => p.isProgram()))) {
+        return {
+          fileCoverage: coverageData,
+          sourceMappingURL: visitState.sourceMappingURL
+        };
+      }
+
+      coverageData[_constants.MAGIC_KEY] = _constants.MAGIC_VALUE;
+      const hash = (0, _crypto.createHash)(_constants.SHA).update(JSON.stringify(coverageData)).digest('hex');
+      coverageData.hash = hash;
+      const coverageNode = T.valueToNode(coverageData);
+      delete coverageData[_constants.MAGIC_KEY];
+      delete coverageData.hash;
+      let gvTemplate;
+
+      if (opts.coverageGlobalScopeFunc) {
+        if (path.scope.getBinding('Function')) {
+          gvTemplate = globalTemplateAlteredFunction({
+            GLOBAL_COVERAGE_SCOPE: T.stringLiteral('return ' + opts.coverageGlobalScope)
+          });
+        } else {
+          gvTemplate = globalTemplateFunction({
+            GLOBAL_COVERAGE_SCOPE: T.stringLiteral('return ' + opts.coverageGlobalScope)
+          });
+        }
+      } else {
+        gvTemplate = globalTemplateVariable({
+          GLOBAL_COVERAGE_SCOPE: opts.coverageGlobalScope
+        });
+      }
+
+      const cv = coverageTemplate({
+        GLOBAL_COVERAGE_VAR: T.stringLiteral(opts.coverageVariable),
+        GLOBAL_COVERAGE_TEMPLATE: gvTemplate,
+        COVERAGE_FUNCTION: T.identifier(visitState.varName),
+        PATH: T.stringLiteral(sourceFilePath),
+        INITIAL: coverageNode,
+        HASH: T.stringLiteral(hash)
+      }); // explicitly call this.varName to ensure coverage is always initialized
+
+      path.node.body.unshift(T.expressionStatement(T.callExpression(T.identifier(visitState.varName), [])));
+      path.node.body.unshift(cv);
+      return {
+        fileCoverage: coverageData,
+        sourceMappingURL: visitState.sourceMappingURL
+      };
+    }
+
+  };
+}
+
+var _default = programVisitor;
+exports.default = _default;

node_modules/@jest/reporters/node_modules/istanbul-lib-instrument/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "istanbul-lib-instrument",
+  "version": "4.0.3",
+  "description": "Core istanbul API for JS code coverage",
+  "author": "Krishnan Anantheswaran <kananthmail-github@yahoo.com>",
+  "main": "dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "release": "babel src --out-dir dist && documentation build -f md -o api.md src",
+    "test": "nyc --nycrc-path=../../monorepo-per-package-nycrc.json --require=@babel/register --include=src mocha",
+    "prepublish": "npm run release"
+  },
+  "dependencies": {
+    "@babel/core": "^7.7.5",
+    "@istanbuljs/schema": "^0.1.2",
+    "istanbul-lib-coverage": "^3.0.0",
+    "semver": "^6.3.0"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.7.5",
+    "@babel/plugin-transform-modules-commonjs": "^7.7.5",
+    "@babel/register": "^7.7.4",
+    "chai": "^4.2.0",
+    "clone": "^2.1.2",
+    "debug": "^4.1.1",
+    "documentation": "^12.1.4",
+    "js-yaml": "^3.13.1",
+    "mocha": "^6.2.2",
+    "nopt": "^4.0.1",
+    "nyc": "^15.0.0-beta.2"
+  },
+  "license": "BSD-3-Clause",
+  "bugs": {
+    "url": "https://github.com/istanbuljs/istanbuljs/issues"
+  },
+  "homepage": "https://istanbul.js.org/",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/istanbuljs/istanbuljs.git",
+    "directory": "packages/istanbul-lib-instrument"
+  },
+  "keywords": [
+    "coverage",
+    "istanbul",
+    "js",
+    "instrumentation"
+  ],
+  "engines": {
+    "node": ">=8"
+  },
+  "gitHead": "2c6f0e24680d050503d404de0ebff53467fefbff"
+}

node_modules/@jest/reporters/node_modules/jest-resolve/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/reporters/node_modules/jest-resolve/build/ModuleNotFoundError.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+export default class ModuleNotFoundError extends Error {
+    code: string;
+    hint?: string;
+    requireStack?: Array<Config.Path>;
+    siblingWithSimilarExtensionFound?: boolean;
+    moduleName?: string;
+    private _originalMessage?;
+    constructor(message: string, moduleName?: string);
+    buildMessage(rootDir: Config.Path): void;
+    static duckType(error: ModuleNotFoundError): ModuleNotFoundError;
+}

node_modules/@jest/reporters/node_modules/jest-resolve/build/ModuleNotFoundError.js

@@ -0,0 +1,147 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+function path() {
+  const data = _interopRequireWildcard(require('path'));
+
+  path = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _slash() {
+  const data = _interopRequireDefault(require('slash'));
+
+  _slash = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+function _getRequireWildcardCache() {
+  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 _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 ModuleNotFoundError extends Error {
+  constructor(message, moduleName) {
+    super(message);
+
+    _defineProperty(this, 'code', 'MODULE_NOT_FOUND');
+
+    _defineProperty(this, 'hint', void 0);
+
+    _defineProperty(this, 'requireStack', void 0);
+
+    _defineProperty(this, 'siblingWithSimilarExtensionFound', void 0);
+
+    _defineProperty(this, 'moduleName', void 0);
+
+    _defineProperty(this, '_originalMessage', void 0);
+
+    this._originalMessage = message;
+    this.moduleName = moduleName;
+  }
+
+  buildMessage(rootDir) {
+    var _this$requireStack;
+
+    if (!this._originalMessage) {
+      this._originalMessage = this.message || '';
+    }
+
+    let message = this._originalMessage;
+
+    if (
+      ((_this$requireStack = this.requireStack) === null ||
+      _this$requireStack === void 0
+        ? void 0
+        : _this$requireStack.length) &&
+      this.requireStack.length > 1
+    ) {
+      message += `
+
+Require stack:
+  ${this.requireStack
+    .map(p => p.replace(`${rootDir}${path().sep}`, ''))
+    .map(_slash().default)
+    .join('\n  ')}
+`;
+    }
+
+    if (this.hint) {
+      message += this.hint;
+    }
+
+    this.message = message;
+  }
+
+  static duckType(error) {
+    error.buildMessage = ModuleNotFoundError.prototype.buildMessage;
+    return error;
+  }
+}
+
+exports.default = ModuleNotFoundError;

node_modules/@jest/reporters/node_modules/jest-resolve/build/defaultResolver.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 { Opts as ResolveOpts } from 'resolve';
+import type { Config } from '@jest/types';
+declare type ResolverOptions = {
+    allowPnp?: boolean;
+    basedir: Config.Path;
+    browser?: boolean;
+    defaultResolver: typeof defaultResolver;
+    extensions?: Array<string>;
+    moduleDirectory?: Array<string>;
+    paths?: Array<Config.Path>;
+    rootDir?: Config.Path;
+    packageFilter?: ResolveOpts['packageFilter'];
+};
+declare global {
+    namespace NodeJS {
+        interface ProcessVersions {
+            pnp?: unknown;
+        }
+    }
+}
+export default function defaultResolver(path: Config.Path, options: ResolverOptions): Config.Path;
+export declare function clearDefaultResolverCache(): void;
+export {};

node_modules/@jest/reporters/node_modules/jest-resolve/build/defaultResolver.js

@@ -0,0 +1,201 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = defaultResolver;
+exports.clearDefaultResolverCache = clearDefaultResolverCache;
+
+function fs() {
+  const data = _interopRequireWildcard(require('graceful-fs'));
+
+  fs = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestPnpResolver() {
+  const data = _interopRequireDefault(require('jest-pnp-resolver'));
+
+  _jestPnpResolver = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _resolve() {
+  const data = require('resolve');
+
+  _resolve = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+function _getRequireWildcardCache() {
+  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;
+}
+
+/**
+ * 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 defaultResolver(path, options) {
+  if (process.versions.pnp && options.allowPnp !== false) {
+    return (0, _jestPnpResolver().default)(path, options);
+  }
+
+  const result = (0, _resolve().sync)(path, {
+    basedir: options.basedir,
+    extensions: options.extensions,
+    isDirectory,
+    isFile,
+    moduleDirectory: options.moduleDirectory,
+    packageFilter: options.packageFilter,
+    paths: options.paths,
+    preserveSymlinks: false,
+    realpathSync
+  }); // Dereference symlinks to ensure we don't create a separate
+  // module instance depending on how it was referenced.
+
+  return realpathSync(result);
+}
+
+function clearDefaultResolverCache() {
+  checkedPaths.clear();
+  checkedRealpathPaths.clear();
+}
+
+var IPathType;
+
+(function (IPathType) {
+  IPathType[(IPathType['FILE'] = 1)] = 'FILE';
+  IPathType[(IPathType['DIRECTORY'] = 2)] = 'DIRECTORY';
+  IPathType[(IPathType['OTHER'] = 3)] = 'OTHER';
+})(IPathType || (IPathType = {}));
+
+const checkedPaths = new Map();
+
+function statSyncCached(path) {
+  const result = checkedPaths.get(path);
+
+  if (result !== undefined) {
+    return result;
+  }
+
+  let stat;
+
+  try {
+    stat = fs().statSync(path);
+  } catch (e) {
+    if (!(e && (e.code === 'ENOENT' || e.code === 'ENOTDIR'))) {
+      throw e;
+    }
+  }
+
+  if (stat) {
+    if (stat.isFile() || stat.isFIFO()) {
+      checkedPaths.set(path, IPathType.FILE);
+      return IPathType.FILE;
+    } else if (stat.isDirectory()) {
+      checkedPaths.set(path, IPathType.DIRECTORY);
+      return IPathType.DIRECTORY;
+    }
+  }
+
+  checkedPaths.set(path, IPathType.OTHER);
+  return IPathType.OTHER;
+}
+
+const checkedRealpathPaths = new Map();
+
+function realpathCached(path) {
+  let result = checkedRealpathPaths.get(path);
+
+  if (result !== undefined) {
+    return result;
+  }
+
+  result = (0, _jestUtil().tryRealpath)(path);
+  checkedRealpathPaths.set(path, result);
+
+  if (path !== result) {
+    // also cache the result in case it's ever referenced directly - no reason to `realpath` that as well
+    checkedRealpathPaths.set(result, result);
+  }
+
+  return result;
+}
+/*
+ * helper functions
+ */
+
+function isFile(file) {
+  return statSyncCached(file) === IPathType.FILE;
+}
+
+function isDirectory(dir) {
+  return statSyncCached(dir) === IPathType.DIRECTORY;
+}
+
+function realpathSync(file) {
+  return realpathCached(file);
+}

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

@@ -0,0 +1,60 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+import type { ModuleMap } from 'jest-haste-map';
+import ModuleNotFoundError from './ModuleNotFoundError';
+import shouldLoadAsEsm from './shouldLoadAsEsm';
+import type { ResolverConfig } from './types';
+declare type FindNodeModuleConfig = {
+    basedir: Config.Path;
+    browser?: boolean;
+    extensions?: Array<string>;
+    moduleDirectory?: Array<string>;
+    paths?: Array<Config.Path>;
+    resolver?: Config.Path | null;
+    rootDir?: Config.Path;
+    throwIfNotFound?: boolean;
+};
+declare type BooleanObject = Record<string, boolean>;
+declare namespace Resolver {
+    type ResolveModuleConfig = {
+        skipNodeResolution?: boolean;
+        paths?: Array<Config.Path>;
+    };
+    type ResolverType = Resolver;
+}
+declare class Resolver {
+    private readonly _options;
+    private readonly _moduleMap;
+    private readonly _moduleIDCache;
+    private readonly _moduleNameCache;
+    private readonly _modulePathCache;
+    private readonly _supportsNativePlatform;
+    constructor(moduleMap: ModuleMap, options: ResolverConfig);
+    static ModuleNotFoundError: typeof ModuleNotFoundError;
+    static tryCastModuleNotFoundError(error: unknown): ModuleNotFoundError | null;
+    static clearDefaultResolverCache(): void;
+    static findNodeModule(path: Config.Path, options: FindNodeModuleConfig): Config.Path | null;
+    static unstable_shouldLoadAsEsm: typeof shouldLoadAsEsm;
+    resolveModuleFromDirIfExists(dirname: Config.Path, moduleName: string, options?: Resolver.ResolveModuleConfig): Config.Path | null;
+    resolveModule(from: Config.Path, moduleName: string, options?: Resolver.ResolveModuleConfig): Config.Path;
+    private _isAliasModule;
+    isCoreModule(moduleName: string): boolean;
+    getModule(name: string): Config.Path | null;
+    getModulePath(from: Config.Path, moduleName: string): Config.Path;
+    getPackage(name: string): Config.Path | null;
+    getMockModule(from: Config.Path, name: string): Config.Path | null;
+    getModulePaths(from: Config.Path): Array<Config.Path>;
+    getModuleID(virtualMocks: BooleanObject, from: Config.Path, _moduleName?: string): string;
+    private _getModuleType;
+    private _getAbsolutePath;
+    private _getMockPath;
+    private _getVirtualMockPath;
+    private _isModuleResolved;
+    resolveStubModuleName(from: Config.Path, moduleName: string): Config.Path | null;
+}
+export = Resolver;

node_modules/@jest/reporters/node_modules/jest-resolve/build/index.js

@@ -0,0 +1,569 @@
+'use strict';
+
+function path() {
+  const data = _interopRequireWildcard(require('path'));
+
+  path = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+
+  _chalk = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _slash() {
+  const data = _interopRequireDefault(require('slash'));
+
+  _slash = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _ModuleNotFoundError = _interopRequireDefault(
+  require('./ModuleNotFoundError')
+);
+
+var _defaultResolver = _interopRequireWildcard(require('./defaultResolver'));
+
+var _isBuiltinModule = _interopRequireDefault(require('./isBuiltinModule'));
+
+var _nodeModulesPaths = _interopRequireDefault(require('./nodeModulesPaths'));
+
+var _shouldLoadAsEsm = _interopRequireWildcard(require('./shouldLoadAsEsm'));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+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 _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 NATIVE_PLATFORM = 'native'; // We might be inside a symlink.
+
+const resolvedCwd = (0, _jestUtil().tryRealpath)(process.cwd());
+const {NODE_PATH} = process.env;
+const nodePaths = NODE_PATH
+  ? NODE_PATH.split(path().delimiter)
+      .filter(Boolean) // The resolver expects absolute paths.
+      .map(p => path().resolve(resolvedCwd, p))
+  : undefined;
+
+class Resolver {
+  constructor(moduleMap, options) {
+    _defineProperty(this, '_options', void 0);
+
+    _defineProperty(this, '_moduleMap', void 0);
+
+    _defineProperty(this, '_moduleIDCache', void 0);
+
+    _defineProperty(this, '_moduleNameCache', void 0);
+
+    _defineProperty(this, '_modulePathCache', void 0);
+
+    _defineProperty(this, '_supportsNativePlatform', void 0);
+
+    this._options = {
+      defaultPlatform: options.defaultPlatform,
+      extensions: options.extensions,
+      hasCoreModules:
+        options.hasCoreModules === undefined ? true : options.hasCoreModules,
+      moduleDirectories: options.moduleDirectories || ['node_modules'],
+      moduleNameMapper: options.moduleNameMapper,
+      modulePaths: options.modulePaths,
+      platforms: options.platforms,
+      resolver: options.resolver,
+      rootDir: options.rootDir
+    };
+    this._supportsNativePlatform = options.platforms
+      ? options.platforms.includes(NATIVE_PLATFORM)
+      : false;
+    this._moduleMap = moduleMap;
+    this._moduleIDCache = new Map();
+    this._moduleNameCache = new Map();
+    this._modulePathCache = new Map();
+  }
+
+  static tryCastModuleNotFoundError(error) {
+    if (error instanceof _ModuleNotFoundError.default) {
+      return error;
+    }
+
+    const casted = error;
+
+    if (casted.code === 'MODULE_NOT_FOUND') {
+      return _ModuleNotFoundError.default.duckType(casted);
+    }
+
+    return null;
+  }
+
+  static clearDefaultResolverCache() {
+    (0, _defaultResolver.clearDefaultResolverCache)();
+    (0, _shouldLoadAsEsm.clearCachedLookups)();
+  }
+
+  static findNodeModule(path, options) {
+    const resolver = options.resolver
+      ? require(options.resolver)
+      : _defaultResolver.default;
+    const paths = options.paths;
+
+    try {
+      return resolver(path, {
+        basedir: options.basedir,
+        browser: options.browser,
+        defaultResolver: _defaultResolver.default,
+        extensions: options.extensions,
+        moduleDirectory: options.moduleDirectory,
+        paths: paths ? (nodePaths || []).concat(paths) : nodePaths,
+        rootDir: options.rootDir
+      });
+    } catch (e) {
+      if (options.throwIfNotFound) {
+        throw e;
+      }
+    }
+
+    return null;
+  } // unstable as it should be replaced by https://github.com/nodejs/modules/issues/393, and we don't want people to use it
+
+  resolveModuleFromDirIfExists(dirname, moduleName, options) {
+    const paths = (options && options.paths) || this._options.modulePaths;
+    const moduleDirectory = this._options.moduleDirectories;
+    const key = dirname + path().delimiter + moduleName;
+    const defaultPlatform = this._options.defaultPlatform;
+
+    const extensions = this._options.extensions.slice();
+
+    let module;
+
+    if (this._supportsNativePlatform) {
+      extensions.unshift(
+        ...this._options.extensions.map(ext => '.' + NATIVE_PLATFORM + ext)
+      );
+    }
+
+    if (defaultPlatform) {
+      extensions.unshift(
+        ...this._options.extensions.map(ext => '.' + defaultPlatform + ext)
+      );
+    } // 1. If we have already resolved this module for this directory name,
+    // return a value from the cache.
+
+    const cacheResult = this._moduleNameCache.get(key);
+
+    if (cacheResult) {
+      return cacheResult;
+    } // 2. Check if the module is a haste module.
+
+    module = this.getModule(moduleName);
+
+    if (module) {
+      this._moduleNameCache.set(key, module);
+
+      return module;
+    } // 3. Check if the module is a node module and resolve it based on
+    // the node module resolution algorithm. If skipNodeResolution is given we
+    // ignore all modules that look like node modules (ie. are not relative
+    // requires). This enables us to speed up resolution when we build a
+    // dependency graph because we don't have to look at modules that may not
+    // exist and aren't mocked.
+
+    const skipResolution =
+      options && options.skipNodeResolution && !moduleName.includes(path().sep);
+
+    const resolveNodeModule = (name, throwIfNotFound = false) =>
+      Resolver.findNodeModule(name, {
+        basedir: dirname,
+        extensions,
+        moduleDirectory,
+        paths,
+        resolver: this._options.resolver,
+        rootDir: this._options.rootDir,
+        throwIfNotFound
+      });
+
+    if (!skipResolution) {
+      module = resolveNodeModule(moduleName, Boolean(process.versions.pnp));
+
+      if (module) {
+        this._moduleNameCache.set(key, module);
+
+        return module;
+      }
+    } // 4. Resolve "haste packages" which are `package.json` files outside of
+    // `node_modules` folders anywhere in the file system.
+
+    const parts = moduleName.split('/');
+    const hastePackage = this.getPackage(parts.shift());
+
+    if (hastePackage) {
+      try {
+        const module = path().join.apply(
+          path(),
+          [path().dirname(hastePackage)].concat(parts)
+        ); // try resolving with custom resolver first to support extensions,
+        // then fallback to require.resolve
+
+        const resolvedModule =
+          resolveNodeModule(module) || require.resolve(module);
+
+        this._moduleNameCache.set(key, resolvedModule);
+
+        return resolvedModule;
+      } catch {}
+    }
+
+    return null;
+  }
+
+  resolveModule(from, moduleName, options) {
+    const dirname = path().dirname(from);
+    const module =
+      this.resolveStubModuleName(from, moduleName) ||
+      this.resolveModuleFromDirIfExists(dirname, moduleName, options);
+    if (module) return module; // 5. Throw an error if the module could not be found. `resolve.sync` only
+    // produces an error based on the dirname but we have the actual current
+    // module name available.
+
+    const relativePath =
+      (0, _slash().default)(path().relative(this._options.rootDir, from)) ||
+      '.';
+    throw new _ModuleNotFoundError.default(
+      `Cannot find module '${moduleName}' from '${relativePath}'`,
+      moduleName
+    );
+  }
+
+  _isAliasModule(moduleName) {
+    const moduleNameMapper = this._options.moduleNameMapper;
+
+    if (!moduleNameMapper) {
+      return false;
+    }
+
+    return moduleNameMapper.some(({regex}) => regex.test(moduleName));
+  }
+
+  isCoreModule(moduleName) {
+    return (
+      this._options.hasCoreModules &&
+      (0, _isBuiltinModule.default)(moduleName) &&
+      !this._isAliasModule(moduleName)
+    );
+  }
+
+  getModule(name) {
+    return this._moduleMap.getModule(
+      name,
+      this._options.defaultPlatform,
+      this._supportsNativePlatform
+    );
+  }
+
+  getModulePath(from, moduleName) {
+    if (moduleName[0] !== '.' || path().isAbsolute(moduleName)) {
+      return moduleName;
+    }
+
+    return path().normalize(path().dirname(from) + '/' + moduleName);
+  }
+
+  getPackage(name) {
+    return this._moduleMap.getPackage(
+      name,
+      this._options.defaultPlatform,
+      this._supportsNativePlatform
+    );
+  }
+
+  getMockModule(from, name) {
+    const mock = this._moduleMap.getMockModule(name);
+
+    if (mock) {
+      return mock;
+    } else {
+      const moduleName = this.resolveStubModuleName(from, name);
+
+      if (moduleName) {
+        return this.getModule(moduleName) || moduleName;
+      }
+    }
+
+    return null;
+  }
+
+  getModulePaths(from) {
+    const cachedModule = this._modulePathCache.get(from);
+
+    if (cachedModule) {
+      return cachedModule;
+    }
+
+    const moduleDirectory = this._options.moduleDirectories;
+    const paths = (0, _nodeModulesPaths.default)(from, {
+      moduleDirectory
+    });
+
+    if (paths[paths.length - 1] === undefined) {
+      // circumvent node-resolve bug that adds `undefined` as last item.
+      paths.pop();
+    }
+
+    this._modulePathCache.set(from, paths);
+
+    return paths;
+  }
+
+  getModuleID(virtualMocks, from, _moduleName) {
+    const moduleName = _moduleName || '';
+    const key = from + path().delimiter + moduleName;
+
+    const cachedModuleID = this._moduleIDCache.get(key);
+
+    if (cachedModuleID) {
+      return cachedModuleID;
+    }
+
+    const moduleType = this._getModuleType(moduleName);
+
+    const absolutePath = this._getAbsolutePath(virtualMocks, from, moduleName);
+
+    const mockPath = this._getMockPath(from, moduleName);
+
+    const sep = path().delimiter;
+    const id =
+      moduleType +
+      sep +
+      (absolutePath ? absolutePath + sep : '') +
+      (mockPath ? mockPath + sep : '');
+
+    this._moduleIDCache.set(key, id);
+
+    return id;
+  }
+
+  _getModuleType(moduleName) {
+    return this.isCoreModule(moduleName) ? 'node' : 'user';
+  }
+
+  _getAbsolutePath(virtualMocks, from, moduleName) {
+    if (this.isCoreModule(moduleName)) {
+      return moduleName;
+    }
+
+    return this._isModuleResolved(from, moduleName)
+      ? this.getModule(moduleName)
+      : this._getVirtualMockPath(virtualMocks, from, moduleName);
+  }
+
+  _getMockPath(from, moduleName) {
+    return !this.isCoreModule(moduleName)
+      ? this.getMockModule(from, moduleName)
+      : null;
+  }
+
+  _getVirtualMockPath(virtualMocks, from, moduleName) {
+    const virtualMockPath = this.getModulePath(from, moduleName);
+    return virtualMocks[virtualMockPath]
+      ? virtualMockPath
+      : moduleName
+      ? this.resolveModule(from, moduleName)
+      : from;
+  }
+
+  _isModuleResolved(from, moduleName) {
+    return !!(
+      this.getModule(moduleName) || this.getMockModule(from, moduleName)
+    );
+  }
+
+  resolveStubModuleName(from, moduleName) {
+    const dirname = path().dirname(from);
+    const paths = this._options.modulePaths;
+
+    const extensions = this._options.extensions.slice();
+
+    const moduleDirectory = this._options.moduleDirectories;
+    const moduleNameMapper = this._options.moduleNameMapper;
+    const resolver = this._options.resolver;
+    const defaultPlatform = this._options.defaultPlatform;
+
+    if (this._supportsNativePlatform) {
+      extensions.unshift(
+        ...this._options.extensions.map(ext => '.' + NATIVE_PLATFORM + ext)
+      );
+    }
+
+    if (defaultPlatform) {
+      extensions.unshift(
+        ...this._options.extensions.map(ext => '.' + defaultPlatform + ext)
+      );
+    }
+
+    if (moduleNameMapper) {
+      for (const {moduleName: mappedModuleName, regex} of moduleNameMapper) {
+        if (regex.test(moduleName)) {
+          // Note: once a moduleNameMapper matches the name, it must result
+          // in a module, or else an error is thrown.
+          const matches = moduleName.match(regex);
+          const mapModuleName = matches
+            ? moduleName =>
+                moduleName.replace(
+                  /\$([0-9]+)/g,
+                  (_, index) => matches[parseInt(index, 10)]
+                )
+            : moduleName => moduleName;
+          const possibleModuleNames = Array.isArray(mappedModuleName)
+            ? mappedModuleName
+            : [mappedModuleName];
+          let module = null;
+
+          for (const possibleModuleName of possibleModuleNames) {
+            const updatedName = mapModuleName(possibleModuleName);
+            module =
+              this.getModule(updatedName) ||
+              Resolver.findNodeModule(updatedName, {
+                basedir: dirname,
+                extensions,
+                moduleDirectory,
+                paths,
+                resolver,
+                rootDir: this._options.rootDir
+              });
+
+            if (module) {
+              break;
+            }
+          }
+
+          if (!module) {
+            throw createNoMappedModuleFoundError(
+              moduleName,
+              mapModuleName,
+              mappedModuleName,
+              regex,
+              resolver
+            );
+          }
+
+          return module;
+        }
+      }
+    }
+
+    return null;
+  }
+}
+
+_defineProperty(Resolver, 'ModuleNotFoundError', _ModuleNotFoundError.default);
+
+_defineProperty(Resolver, 'unstable_shouldLoadAsEsm', _shouldLoadAsEsm.default);
+
+const createNoMappedModuleFoundError = (
+  moduleName,
+  mapModuleName,
+  mappedModuleName,
+  regex,
+  resolver
+) => {
+  const mappedAs = Array.isArray(mappedModuleName)
+    ? JSON.stringify(mappedModuleName.map(mapModuleName), null, 2)
+    : mappedModuleName;
+  const original = Array.isArray(mappedModuleName)
+    ? JSON.stringify(mappedModuleName, null, 6) // using 6 because of misalignment when nested below
+        .slice(0, -1) + '    ]' /// align last bracket correctly as well
+    : mappedModuleName;
+  const error = new Error(
+    _chalk().default.red(`${_chalk().default.bold('Configuration error')}:
+
+Could not locate module ${_chalk().default.bold(moduleName)} mapped as:
+${_chalk().default.bold(mappedAs)}.
+
+Please check your configuration for these entries:
+{
+  "moduleNameMapper": {
+    "${regex.toString()}": "${_chalk().default.bold(original)}"
+  },
+  "resolver": ${_chalk().default.bold(String(resolver))}
+}`)
+  );
+  error.name = '';
+  return error;
+};
+
+module.exports = Resolver;

node_modules/@jest/reporters/node_modules/jest-resolve/build/isBuiltinModule.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export default function isBuiltinModule(module: string): boolean;

node_modules/@jest/reporters/node_modules/jest-resolve/build/isBuiltinModule.js

@@ -0,0 +1,39 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = isBuiltinModule;
+
+function _module() {
+  const data = _interopRequireDefault(require('module'));
+
+  _module = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) 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 EXPERIMENTAL_MODULES = ['worker_threads'];
+const BUILTIN_MODULES = new Set(
+  _module().default.builtinModules
+    ? _module().default.builtinModules.concat(EXPERIMENTAL_MODULES)
+    : Object.keys(process.binding('natives'))
+        .filter(module => !/^internal\//.test(module))
+        .concat(EXPERIMENTAL_MODULES)
+);
+
+function isBuiltinModule(module) {
+  return BUILTIN_MODULES.has(module);
+}

node_modules/@jest/reporters/node_modules/jest-resolve/build/nodeModulesPaths.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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.
+ *
+ * Adapted from: https://github.com/substack/node-resolve
+ */
+import type { Config } from '@jest/types';
+declare type NodeModulesPathsOptions = {
+    moduleDirectory?: Array<string>;
+    paths?: Array<Config.Path>;
+};
+export default function nodeModulesPaths(basedir: Config.Path, options: NodeModulesPathsOptions): Array<Config.Path>;
+export {};

node_modules/@jest/reporters/node_modules/jest-resolve/build/nodeModulesPaths.js

@@ -0,0 +1,128 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = nodeModulesPaths;
+
+function path() {
+  const data = _interopRequireWildcard(require('path'));
+
+  path = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _getRequireWildcardCache() {
+  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;
+}
+
+/**
+ * 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.
+ *
+ * Adapted from: https://github.com/substack/node-resolve
+ */
+function nodeModulesPaths(basedir, options) {
+  const modules =
+    options && options.moduleDirectory
+      ? Array.from(options.moduleDirectory)
+      : ['node_modules']; // ensure that `basedir` is an absolute path at this point,
+  // resolving against the process' current working directory
+
+  const basedirAbs = path().resolve(basedir);
+  let prefix = '/';
+
+  if (/^([A-Za-z]:)/.test(basedirAbs)) {
+    prefix = '';
+  } else if (/^\\\\/.test(basedirAbs)) {
+    prefix = '\\\\';
+  } // The node resolution algorithm (as implemented by NodeJS and TypeScript)
+  // traverses parents of the physical path, not the symlinked path
+
+  let physicalBasedir;
+
+  try {
+    physicalBasedir = (0, _jestUtil().tryRealpath)(basedirAbs);
+  } catch {
+    // realpath can throw, e.g. on mapped drives
+    physicalBasedir = basedirAbs;
+  }
+
+  const paths = [physicalBasedir];
+  let parsed = path().parse(physicalBasedir);
+
+  while (parsed.dir !== paths[paths.length - 1]) {
+    paths.push(parsed.dir);
+    parsed = path().parse(parsed.dir);
+  }
+
+  const dirs = paths
+    .reduce(
+      (dirs, aPath) =>
+        dirs.concat(
+          modules.map(moduleDir =>
+            path().isAbsolute(moduleDir)
+              ? aPath === basedirAbs
+                ? moduleDir
+                : ''
+              : path().join(prefix, aPath, moduleDir)
+          )
+        ),
+      []
+    )
+    .filter(dir => dir !== '');
+  return options.paths ? dirs.concat(options.paths) : dirs;
+}

node_modules/@jest/reporters/node_modules/jest-resolve/build/shouldLoadAsEsm.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+export declare function clearCachedLookups(): void;
+export default function cachedShouldLoadAsEsm(path: Config.Path): boolean;

node_modules/@jest/reporters/node_modules/jest-resolve/build/shouldLoadAsEsm.js

@@ -0,0 +1,113 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.clearCachedLookups = clearCachedLookups;
+exports.default = cachedShouldLoadAsEsm;
+
+function _path() {
+  const data = require('path');
+
+  _path = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _vm() {
+  const data = require('vm');
+
+  _vm = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _readPkgUp() {
+  const data = _interopRequireDefault(require('read-pkg-up'));
+
+  _readPkgUp = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+// @ts-expect-error: experimental, not added to the types
+const runtimeSupportsVmModules = typeof _vm().SyntheticModule === 'function';
+const cachedFileLookups = new Map();
+const cachedDirLookups = new Map();
+
+function clearCachedLookups() {
+  cachedFileLookups.clear();
+  cachedDirLookups.clear();
+}
+
+function cachedShouldLoadAsEsm(path) {
+  let cachedLookup = cachedFileLookups.get(path);
+
+  if (cachedLookup === undefined) {
+    cachedLookup = shouldLoadAsEsm(path);
+    cachedFileLookups.set(path, cachedLookup);
+  }
+
+  return cachedLookup;
+} // this is a bad version of what https://github.com/nodejs/modules/issues/393 would provide
+
+function shouldLoadAsEsm(path) {
+  if (!runtimeSupportsVmModules) {
+    return false;
+  }
+
+  const extension = (0, _path().extname)(path);
+
+  if (extension === '.mjs') {
+    return true;
+  }
+
+  if (extension === '.cjs') {
+    return false;
+  } // this isn't correct - we might wanna load any file as a module (using synthetic module)
+  // do we need an option to Jest so people can opt in to ESM for non-js?
+
+  if (extension !== '.js') {
+    return false;
+  }
+
+  const cwd = (0, _path().dirname)(path);
+  let cachedLookup = cachedDirLookups.get(cwd);
+
+  if (cachedLookup === undefined) {
+    cachedLookup = cachedPkgCheck(cwd);
+    cachedFileLookups.set(cwd, cachedLookup);
+  }
+
+  return cachedLookup;
+}
+
+function cachedPkgCheck(cwd) {
+  // TODO: can we cache lookups somehow?
+  const pkg = _readPkgUp().default.sync({
+    cwd,
+    normalize: false
+  });
+
+  if (!pkg) {
+    return false;
+  }
+
+  return pkg.packageJson.type === 'module';
+}

node_modules/@jest/reporters/node_modules/jest-resolve/build/types.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+export declare type ResolverConfig = {
+    defaultPlatform?: string | null;
+    extensions: Array<string>;
+    hasCoreModules: boolean;
+    moduleDirectories: Array<string>;
+    moduleNameMapper?: Array<ModuleNameMapperConfig> | null;
+    modulePaths?: Array<Config.Path>;
+    platforms?: Array<string>;
+    resolver?: Config.Path | null;
+    rootDir: Config.Path;
+};
+declare type ModuleNameMapperConfig = {
+    regex: RegExp;
+    moduleName: string | Array<string>;
+};
+export {};

node_modules/@jest/reporters/node_modules/jest-resolve/build/types.js

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

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

@@ -0,0 +1,34 @@
+{
+  "name": "jest-resolve",
+  "version": "26.6.2",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/facebook/jest.git",
+    "directory": "packages/jest-resolve"
+  },
+  "license": "MIT",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "dependencies": {
+    "@jest/types": "^26.6.2",
+    "chalk": "^4.0.0",
+    "graceful-fs": "^4.2.4",
+    "jest-pnp-resolver": "^1.2.2",
+    "jest-util": "^26.6.2",
+    "read-pkg-up": "^7.0.1",
+    "resolve": "^1.18.1",
+    "slash": "^3.0.0"
+  },
+  "devDependencies": {
+    "@types/graceful-fs": "^4.1.3",
+    "@types/resolve": "^1.17.0",
+    "jest-haste-map": "^26.6.2"
+  },
+  "engines": {
+    "node": ">= 10.14.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "4c46930615602cbf983fb7e8e82884c282a624d5"
+}

node_modules/@jest/reporters/node_modules/jest-worker/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/reporters/node_modules/jest-worker/README.md

@@ -0,0 +1,231 @@
+# jest-worker
+
+Module for executing heavy tasks under forked processes in parallel, by providing a `Promise` based interface, minimum overhead, and bound workers.
+
+The module works by providing an absolute path of the module to be loaded in all forked processes. Files relative to a node module are also accepted. All methods are exposed on the parent process as promises, so they can be `await`'ed. Child (worker) methods can either be synchronous or asynchronous.
+
+The module also implements support for bound workers. Binding a worker means that, based on certain parameters, the same task will always be executed by the same worker. The way bound workers work is by using the returned string of the `computeWorkerKey` method. If the string was used before for a task, the call will be queued to the related worker that processed the task earlier; if not, it will be executed by the first available worker, then sticked to the worker that executed it; so the next time it will be processed by the same worker. If you have no preference on the worker executing the task, but you have defined a `computeWorkerKey` method because you want _some_ of the tasks to be sticked, you can return `null` from it.
+
+The list of exposed methods can be explicitly provided via the `exposedMethods` option. If it is not provided, it will be obtained by requiring the child module into the main process, and analyzed via reflection. Check the "minimal example" section for a valid one.
+
+## Install
+
+```sh
+$ yarn add jest-worker
+```
+
+## Example
+
+This example covers the minimal usage:
+
+### File `parent.js`
+
+```javascript
+import JestWorker from 'jest-worker';
+
+async function main() {
+  const worker = new JestWorker(require.resolve('./Worker'));
+  const result = await worker.hello('Alice'); // "Hello, Alice"
+}
+
+main();
+```
+
+### File `worker.js`
+
+```javascript
+export function hello(param) {
+  return 'Hello, ' + param;
+}
+```
+
+## Experimental worker
+
+Node 10 shipped with [worker-threads](https://nodejs.org/api/worker_threads.html), a "threading API" that uses SharedArrayBuffers to communicate between the main process and its child threads. This experimental Node feature can significantly improve the communication time between parent and child processes in `jest-worker`.
+
+Since `worker_threads` are considered experimental in Node, you have to opt-in to this behavior by passing `enableWorkerThreads: true` when instantiating the worker. While the feature was unflagged in Node 11.7.0, you'll need to run the Node process with the `--experimental-worker` flag for Node 10.
+
+## API
+
+The only exposed method is a constructor (`JestWorker`) that is initialized by passing the worker path, plus an options object.
+
+### `workerPath: string` (required)
+
+Node module name or absolute path of the file to be loaded in the child processes. Use `require.resolve` to transform a relative path into an absolute one.
+
+### `options: Object` (optional)
+
+#### `exposedMethods: $ReadOnlyArray<string>` (optional)
+
+List of method names that can be called on the child processes from the parent process. You cannot expose any method named like a public `Worker` method, or starting with `_`. If you use method auto-discovery, then these methods will not be exposed, even if they exist.
+
+#### `numWorkers: number` (optional)
+
+Amount of workers to spawn. Defaults to the number of CPUs minus 1.
+
+#### `maxRetries: number` (optional)
+
+Maximum amount of times that a dead child can be re-spawned, per call. Defaults to `3`, pass `Infinity` to allow endless retries.
+
+#### `forkOptions: Object` (optional)
+
+Allow customizing all options passed to `childProcess.fork`. By default, some values are set (`cwd`, `env` and `execArgv`), but you can override them and customize the rest. For a list of valid values, check [the Node documentation](https://nodejs.org/api/child_process.html#child_process_child_process_fork_modulepath_args_options).
+
+#### `computeWorkerKey: (method: string, ...args: Array<any>) => ?string` (optional)
+
+Every time a method exposed via the API is called, `computeWorkerKey` is also called in order to bound the call to a worker. This is useful for workers that are able to cache the result or part of it. You bound calls to a worker by making `computeWorkerKey` return the same identifier for all different calls. If you do not want to bind the call to any worker, return `null`.
+
+The callback you provide is called with the method name, plus all the rest of the arguments of the call. Thus, you have full control to decide what to return. Check a practical example on bound workers under the "bound worker usage" section.
+
+By default, no process is bound to any worker.
+
+#### `setupArgs: Array<mixed>` (optional)
+
+The arguments that will be passed to the `setup` method during initialization.
+
+#### `WorkerPool: (workerPath: string, options?: WorkerPoolOptions) => WorkerPoolInterface` (optional)
+
+Provide a custom worker pool to be used for spawning child processes. By default, Jest will use a node thread pool if available and fall back to child process threads.
+
+#### `enableWorkerThreads: boolean` (optional)
+
+`jest-worker` will automatically detect if `worker_threads` are available, but will not use them unless passed `enableWorkerThreads: true`.
+
+## JestWorker
+
+### Methods
+
+The returned `JestWorker` instance has all the exposed methods, plus some additional ones to interact with the workers itself:
+
+#### `getStdout(): Readable`
+
+Returns a `ReadableStream` where the standard output of all workers is piped. Note that the `silent` option of the child workers must be set to `true` to make it work. This is the default set by `jest-worker`, but keep it in mind when overriding options through `forkOptions`.
+
+#### `getStderr(): Readable`
+
+Returns a `ReadableStream` where the standard error of all workers is piped. Note that the `silent` option of the child workers must be set to `true` to make it work. This is the default set by `jest-worker`, but keep it in mind when overriding options through `forkOptions`.
+
+#### `end()`
+
+Finishes the workers by killing all workers. No further calls can be done to the `Worker` instance.
+
+Returns a Promise that resolves with `{ forceExited: boolean }` once all workers are dead. If `forceExited` is `true`, at least one of the workers did not exit gracefully, which likely happened because it executed a leaky task that left handles open. This should be avoided, force exiting workers is a last resort to prevent creating lots of orphans.
+
+**Note:**
+
+`await`ing the `end()` Promise immediately after the workers are no longer needed before proceeding to do other useful things in your program may not be a good idea. If workers have to be force exited, `jest-worker` may go through multiple stages of force exiting (e.g. SIGTERM, later SIGKILL) and give the worker overall around 1 second time to exit on its own. During this time, your program will wait, even though it may not be necessary that all workers are dead before continuing execution.
+
+Consider deliberately leaving this Promise floating (unhandled resolution). After your program has done the rest of its work and is about to exit, the Node process will wait for the Promise to resolve after all workers are dead as the last event loop task. That way you parallelized computation time of your program and waiting time and you didn't delay the outputs of your program unnecessarily.
+
+### Worker IDs
+
+Each worker has a unique id (index that starts with `1`), which is available inside the worker as `process.env.JEST_WORKER_ID`.
+
+## Setting up and tearing down the child process
+
+The child process can define two special methods (both of them can be asynchronous):
+
+- `setup()`: If defined, it's executed before the first call to any method in the child.
+- `teardown()`: If defined, it's executed when the farm ends.
+
+# More examples
+
+## Standard usage
+
+This example covers the standard usage:
+
+### File `parent.js`
+
+```javascript
+import JestWorker from 'jest-worker';
+
+async function main() {
+  const myWorker = new JestWorker(require.resolve('./Worker'), {
+    exposedMethods: ['foo', 'bar', 'getWorkerId'],
+    numWorkers: 4,
+  });
+
+  console.log(await myWorker.foo('Alice')); // "Hello from foo: Alice"
+  console.log(await myWorker.bar('Bob')); // "Hello from bar: Bob"
+  console.log(await myWorker.getWorkerId()); // "3" -> this message has sent from the 3rd worker
+
+  const {forceExited} = await myWorker.end();
+  if (forceExited) {
+    console.error('Workers failed to exit gracefully');
+  }
+}
+
+main();
+```
+
+### File `worker.js`
+
+```javascript
+export function foo(param) {
+  return 'Hello from foo: ' + param;
+}
+
+export function bar(param) {
+  return 'Hello from bar: ' + param;
+}
+
+export function getWorkerId() {
+  return process.env.JEST_WORKER_ID;
+}
+```
+
+## Bound worker usage:
+
+This example covers the usage with a `computeWorkerKey` method:
+
+### File `parent.js`
+
+```javascript
+import JestWorker from 'jest-worker';
+
+async function main() {
+  const myWorker = new JestWorker(require.resolve('./Worker'), {
+    computeWorkerKey: (method, filename) => filename,
+  });
+
+  // Transform the given file, within the first available worker.
+  console.log(await myWorker.transform('/tmp/foo.js'));
+
+  // Wait a bit.
+  await sleep(10000);
+
+  // Transform the same file again. Will immediately return because the
+  // transformed file is cached in the worker, and `computeWorkerKey` ensures
+  // the same worker that processed the file the first time will process it now.
+  console.log(await myWorker.transform('/tmp/foo.js'));
+
+  const {forceExited} = await myWorker.end();
+  if (forceExited) {
+    console.error('Workers failed to exit gracefully');
+  }
+}
+
+main();
+```
+
+### File `worker.js`
+
+```javascript
+import babel from '@babel/core';
+
+const cache = Object.create(null);
+
+export function transform(filename) {
+  if (cache[filename]) {
+    return cache[filename];
+  }
+
+  // jest-worker can handle both immediate results and thenables. If a
+  // thenable is returned, it will be await'ed until it resolves.
+  return babel.transformFileAsync(filename).then(result => {
+    cache[filename] = result;
+
+    return result;
+  });
+}
+```

node_modules/@jest/reporters/node_modules/jest-worker/build/Farm.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 { FarmOptions, PromiseWithCustomMessage } from './types';
+export default class Farm {
+    private _computeWorkerKey;
+    private _cacheKeys;
+    private _callback;
+    private _last;
+    private _locks;
+    private _numOfWorkers;
+    private _offset;
+    private _queue;
+    constructor(numOfWorkers: number, callback: Function, computeWorkerKey?: FarmOptions['computeWorkerKey']);
+    doWork(method: string, ...args: Array<unknown>): PromiseWithCustomMessage<unknown>;
+    private _getNextTask;
+    private _process;
+    private _enqueue;
+    private _push;
+    private _lock;
+    private _unlock;
+    private _isLocked;
+}

node_modules/@jest/reporters/node_modules/jest-worker/build/Farm.js

@@ -0,0 +1,203 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+var _types = require('./types');
+
+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 Farm {
+  constructor(numOfWorkers, callback, computeWorkerKey) {
+    _defineProperty(this, '_computeWorkerKey', void 0);
+
+    _defineProperty(this, '_cacheKeys', void 0);
+
+    _defineProperty(this, '_callback', void 0);
+
+    _defineProperty(this, '_last', void 0);
+
+    _defineProperty(this, '_locks', void 0);
+
+    _defineProperty(this, '_numOfWorkers', void 0);
+
+    _defineProperty(this, '_offset', void 0);
+
+    _defineProperty(this, '_queue', void 0);
+
+    this._cacheKeys = Object.create(null);
+    this._callback = callback;
+    this._last = [];
+    this._locks = [];
+    this._numOfWorkers = numOfWorkers;
+    this._offset = 0;
+    this._queue = [];
+
+    if (computeWorkerKey) {
+      this._computeWorkerKey = computeWorkerKey;
+    }
+  }
+
+  doWork(method, ...args) {
+    const customMessageListeners = new Set();
+
+    const addCustomMessageListener = listener => {
+      customMessageListeners.add(listener);
+      return () => {
+        customMessageListeners.delete(listener);
+      };
+    };
+
+    const onCustomMessage = message => {
+      customMessageListeners.forEach(listener => listener(message));
+    };
+
+    const promise = new Promise((resolve, reject) => {
+      const computeWorkerKey = this._computeWorkerKey;
+      const request = [_types.CHILD_MESSAGE_CALL, false, method, args];
+      let worker = null;
+      let hash = null;
+
+      if (computeWorkerKey) {
+        hash = computeWorkerKey.call(this, method, ...args);
+        worker = hash == null ? null : this._cacheKeys[hash];
+      }
+
+      const onStart = worker => {
+        if (hash != null) {
+          this._cacheKeys[hash] = worker;
+        }
+      };
+
+      const onEnd = (error, result) => {
+        customMessageListeners.clear();
+
+        if (error) {
+          reject(error);
+        } else {
+          resolve(result);
+        }
+      };
+
+      const task = {
+        onCustomMessage,
+        onEnd,
+        onStart,
+        request
+      };
+
+      if (worker) {
+        this._enqueue(task, worker.getWorkerId());
+      } else {
+        this._push(task);
+      }
+    });
+    promise.UNSTABLE_onCustomMessage = addCustomMessageListener;
+    return promise;
+  }
+
+  _getNextTask(workerId) {
+    let queueHead = this._queue[workerId];
+
+    while (queueHead && queueHead.task.request[1]) {
+      queueHead = queueHead.next || null;
+    }
+
+    this._queue[workerId] = queueHead;
+    return queueHead && queueHead.task;
+  }
+
+  _process(workerId) {
+    if (this._isLocked(workerId)) {
+      return this;
+    }
+
+    const task = this._getNextTask(workerId);
+
+    if (!task) {
+      return this;
+    }
+
+    const onEnd = (error, result) => {
+      task.onEnd(error, result);
+
+      this._unlock(workerId);
+
+      this._process(workerId);
+    };
+
+    task.request[1] = true;
+
+    this._lock(workerId);
+
+    this._callback(
+      workerId,
+      task.request,
+      task.onStart,
+      onEnd,
+      task.onCustomMessage
+    );
+
+    return this;
+  }
+
+  _enqueue(task, workerId) {
+    const item = {
+      next: null,
+      task
+    };
+
+    if (task.request[1]) {
+      return this;
+    }
+
+    if (this._queue[workerId]) {
+      this._last[workerId].next = item;
+    } else {
+      this._queue[workerId] = item;
+    }
+
+    this._last[workerId] = item;
+
+    this._process(workerId);
+
+    return this;
+  }
+
+  _push(task) {
+    for (let i = 0; i < this._numOfWorkers; i++) {
+      this._enqueue(task, (this._offset + i) % this._numOfWorkers);
+    }
+
+    this._offset++;
+    return this;
+  }
+
+  _lock(workerId) {
+    this._locks[workerId] = true;
+  }
+
+  _unlock(workerId) {
+    this._locks[workerId] = false;
+  }
+
+  _isLocked(workerId) {
+    return this._locks[workerId];
+  }
+}
+
+exports.default = Farm;

node_modules/@jest/reporters/node_modules/jest-worker/build/WorkerPool.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import BaseWorkerPool from './base/BaseWorkerPool';
+import type { ChildMessage, OnCustomMessage, OnEnd, OnStart, WorkerInterface, WorkerOptions, WorkerPoolInterface } from './types';
+declare class WorkerPool extends BaseWorkerPool implements WorkerPoolInterface {
+    send(workerId: number, request: ChildMessage, onStart: OnStart, onEnd: OnEnd, onCustomMessage: OnCustomMessage): void;
+    createWorker(workerOptions: WorkerOptions): WorkerInterface;
+}
+export default WorkerPool;

node_modules/@jest/reporters/node_modules/jest-worker/build/WorkerPool.js

@@ -0,0 +1,49 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+var _BaseWorkerPool = _interopRequireDefault(require('./base/BaseWorkerPool'));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const canUseWorkerThreads = () => {
+  try {
+    require('worker_threads');
+
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+class WorkerPool extends _BaseWorkerPool.default {
+  send(workerId, request, onStart, onEnd, onCustomMessage) {
+    this.getWorkerById(workerId).send(request, onStart, onEnd, onCustomMessage);
+  }
+
+  createWorker(workerOptions) {
+    let Worker;
+
+    if (this._options.enableWorkerThreads && canUseWorkerThreads()) {
+      Worker = require('./workers/NodeThreadsWorker').default;
+    } else {
+      Worker = require('./workers/ChildProcessWorker').default;
+    }
+
+    return new Worker(workerOptions);
+  }
+}
+
+var _default = WorkerPool;
+exports.default = _default;

node_modules/@jest/reporters/node_modules/jest-worker/build/base/BaseWorkerPool.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/// <reference types="node" />
+import { PoolExitResult, WorkerInterface, WorkerOptions, WorkerPoolOptions } from '../types';
+export default class BaseWorkerPool {
+    private readonly _stderr;
+    private readonly _stdout;
+    protected readonly _options: WorkerPoolOptions;
+    private readonly _workers;
+    constructor(workerPath: string, options: WorkerPoolOptions);
+    getStderr(): NodeJS.ReadableStream;
+    getStdout(): NodeJS.ReadableStream;
+    getWorkers(): Array<WorkerInterface>;
+    getWorkerById(workerId: number): WorkerInterface;
+    createWorker(_workerOptions: WorkerOptions): WorkerInterface;
+    end(): Promise<PoolExitResult>;
+}

node_modules/@jest/reporters/node_modules/jest-worker/build/base/BaseWorkerPool.js

@@ -0,0 +1,209 @@
+'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 _mergeStream() {
+  const data = _interopRequireDefault(require('merge-stream'));
+
+  _mergeStream = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _types() {
+  const data = require('../types');
+
+  _types = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+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 _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;
+}
+
+// How long to wait for the child process to terminate
+// after CHILD_MESSAGE_END before sending force exiting.
+const FORCE_EXIT_DELAY = 500;
+/* istanbul ignore next */
+
+const emptyMethod = () => {};
+
+class BaseWorkerPool {
+  constructor(workerPath, options) {
+    _defineProperty(this, '_stderr', void 0);
+
+    _defineProperty(this, '_stdout', void 0);
+
+    _defineProperty(this, '_options', void 0);
+
+    _defineProperty(this, '_workers', void 0);
+
+    this._options = options;
+    this._workers = new Array(options.numWorkers);
+
+    if (!path().isAbsolute(workerPath)) {
+      workerPath = require.resolve(workerPath);
+    }
+
+    const stdout = (0, _mergeStream().default)();
+    const stderr = (0, _mergeStream().default)();
+    const {forkOptions, maxRetries, resourceLimits, setupArgs} = options;
+
+    for (let i = 0; i < options.numWorkers; i++) {
+      const workerOptions = {
+        forkOptions,
+        maxRetries,
+        resourceLimits,
+        setupArgs,
+        workerId: i,
+        workerPath
+      };
+      const worker = this.createWorker(workerOptions);
+      const workerStdout = worker.getStdout();
+      const workerStderr = worker.getStderr();
+
+      if (workerStdout) {
+        stdout.add(workerStdout);
+      }
+
+      if (workerStderr) {
+        stderr.add(workerStderr);
+      }
+
+      this._workers[i] = worker;
+    }
+
+    this._stdout = stdout;
+    this._stderr = stderr;
+  }
+
+  getStderr() {
+    return this._stderr;
+  }
+
+  getStdout() {
+    return this._stdout;
+  }
+
+  getWorkers() {
+    return this._workers;
+  }
+
+  getWorkerById(workerId) {
+    return this._workers[workerId];
+  }
+
+  createWorker(_workerOptions) {
+    throw Error('Missing method createWorker in WorkerPool');
+  }
+
+  async end() {
+    // We do not cache the request object here. If so, it would only be only
+    // processed by one of the workers, and we want them all to close.
+    const workerExitPromises = this._workers.map(async worker => {
+      worker.send(
+        [_types().CHILD_MESSAGE_END, false],
+        emptyMethod,
+        emptyMethod,
+        emptyMethod
+      ); // Schedule a force exit in case worker fails to exit gracefully so
+      // await worker.waitForExit() never takes longer than FORCE_EXIT_DELAY
+
+      let forceExited = false;
+      const forceExitTimeout = setTimeout(() => {
+        worker.forceExit();
+        forceExited = true;
+      }, FORCE_EXIT_DELAY);
+      await worker.waitForExit(); // Worker ideally exited gracefully, don't send force exit then
+
+      clearTimeout(forceExitTimeout);
+      return forceExited;
+    });
+
+    const workerExits = await Promise.all(workerExitPromises);
+    return workerExits.reduce(
+      (result, forceExited) => ({
+        forceExited: result.forceExited || forceExited
+      }),
+      {
+        forceExited: false
+      }
+    );
+  }
+}
+
+exports.default = BaseWorkerPool;

node_modules/@jest/reporters/node_modules/jest-worker/build/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * 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 { FarmOptions, PoolExitResult, PromiseWithCustomMessage } from './types';
+export { default as messageParent } from './workers/messageParent';
+/**
+ * The Jest farm (publicly called "Worker") is a class that allows you to queue
+ * methods across multiple child processes, in order to parallelize work. This
+ * is done by providing an absolute path to a module that will be loaded on each
+ * of the child processes, and bridged to the main process.
+ *
+ * Bridged methods are specified by using the "exposedMethods" property of the
+ * "options" object. This is an array of strings, where each of them corresponds
+ * to the exported name in the loaded module.
+ *
+ * You can also control the amount of workers by using the "numWorkers" property
+ * of the "options" object, and the settings passed to fork the process through
+ * the "forkOptions" property. The amount of workers defaults to the amount of
+ * CPUS minus one.
+ *
+ * Queueing calls can be done in two ways:
+ *   - Standard method: calls will be redirected to the first available worker,
+ *     so they will get executed as soon as they can.
+ *
+ *   - Sticky method: if a "computeWorkerKey" method is provided within the
+ *     config, the resulting string of this method will be used as a key.
+ *     Every time this key is returned, it is guaranteed that your job will be
+ *     processed by the same worker. This is specially useful if your workers
+ *     are caching results.
+ */
+export default class JestWorker {
+    private _ending;
+    private _farm;
+    private _options;
+    private _workerPool;
+    constructor(workerPath: string, options?: FarmOptions);
+    private _bindExposedWorkerMethods;
+    private _callFunctionWithArgs;
+    getStderr(): NodeJS.ReadableStream;
+    getStdout(): NodeJS.ReadableStream;
+    end(): Promise<PoolExitResult>;
+}
+export type { PromiseWithCustomMessage };

node_modules/@jest/reporters/node_modules/jest-worker/build/index.js

@@ -0,0 +1,203 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+Object.defineProperty(exports, 'messageParent', {
+  enumerable: true,
+  get: function () {
+    return _messageParent.default;
+  }
+});
+exports.default = void 0;
+
+function _os() {
+  const data = require('os');
+
+  _os = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _Farm = _interopRequireDefault(require('./Farm'));
+
+var _WorkerPool = _interopRequireDefault(require('./WorkerPool'));
+
+var _messageParent = _interopRequireDefault(require('./workers/messageParent'));
+
+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;
+}
+
+function getExposedMethods(workerPath, options) {
+  let exposedMethods = options.exposedMethods; // If no methods list is given, try getting it by auto-requiring the module.
+
+  if (!exposedMethods) {
+    const module = require(workerPath);
+
+    exposedMethods = Object.keys(module).filter(
+      // @ts-expect-error: no index
+      name => typeof module[name] === 'function'
+    );
+
+    if (typeof module === 'function') {
+      exposedMethods = [...exposedMethods, 'default'];
+    }
+  }
+
+  return exposedMethods;
+}
+/**
+ * The Jest farm (publicly called "Worker") is a class that allows you to queue
+ * methods across multiple child processes, in order to parallelize work. This
+ * is done by providing an absolute path to a module that will be loaded on each
+ * of the child processes, and bridged to the main process.
+ *
+ * Bridged methods are specified by using the "exposedMethods" property of the
+ * "options" object. This is an array of strings, where each of them corresponds
+ * to the exported name in the loaded module.
+ *
+ * You can also control the amount of workers by using the "numWorkers" property
+ * of the "options" object, and the settings passed to fork the process through
+ * the "forkOptions" property. The amount of workers defaults to the amount of
+ * CPUS minus one.
+ *
+ * Queueing calls can be done in two ways:
+ *   - Standard method: calls will be redirected to the first available worker,
+ *     so they will get executed as soon as they can.
+ *
+ *   - Sticky method: if a "computeWorkerKey" method is provided within the
+ *     config, the resulting string of this method will be used as a key.
+ *     Every time this key is returned, it is guaranteed that your job will be
+ *     processed by the same worker. This is specially useful if your workers
+ *     are caching results.
+ */
+
+class JestWorker {
+  constructor(workerPath, options) {
+    var _this$_options$enable,
+      _this$_options$forkOp,
+      _this$_options$maxRet,
+      _this$_options$numWor,
+      _this$_options$resour,
+      _this$_options$setupA;
+
+    _defineProperty(this, '_ending', void 0);
+
+    _defineProperty(this, '_farm', void 0);
+
+    _defineProperty(this, '_options', void 0);
+
+    _defineProperty(this, '_workerPool', void 0);
+
+    this._options = {...options};
+    this._ending = false;
+    const workerPoolOptions = {
+      enableWorkerThreads:
+        (_this$_options$enable = this._options.enableWorkerThreads) !== null &&
+        _this$_options$enable !== void 0
+          ? _this$_options$enable
+          : false,
+      forkOptions:
+        (_this$_options$forkOp = this._options.forkOptions) !== null &&
+        _this$_options$forkOp !== void 0
+          ? _this$_options$forkOp
+          : {},
+      maxRetries:
+        (_this$_options$maxRet = this._options.maxRetries) !== null &&
+        _this$_options$maxRet !== void 0
+          ? _this$_options$maxRet
+          : 3,
+      numWorkers:
+        (_this$_options$numWor = this._options.numWorkers) !== null &&
+        _this$_options$numWor !== void 0
+          ? _this$_options$numWor
+          : Math.max((0, _os().cpus)().length - 1, 1),
+      resourceLimits:
+        (_this$_options$resour = this._options.resourceLimits) !== null &&
+        _this$_options$resour !== void 0
+          ? _this$_options$resour
+          : {},
+      setupArgs:
+        (_this$_options$setupA = this._options.setupArgs) !== null &&
+        _this$_options$setupA !== void 0
+          ? _this$_options$setupA
+          : []
+    };
+
+    if (this._options.WorkerPool) {
+      // @ts-expect-error: constructor target any?
+      this._workerPool = new this._options.WorkerPool(
+        workerPath,
+        workerPoolOptions
+      );
+    } else {
+      this._workerPool = new _WorkerPool.default(workerPath, workerPoolOptions);
+    }
+
+    this._farm = new _Farm.default(
+      workerPoolOptions.numWorkers,
+      this._workerPool.send.bind(this._workerPool),
+      this._options.computeWorkerKey
+    );
+
+    this._bindExposedWorkerMethods(workerPath, this._options);
+  }
+
+  _bindExposedWorkerMethods(workerPath, options) {
+    getExposedMethods(workerPath, options).forEach(name => {
+      if (name.startsWith('_')) {
+        return;
+      }
+
+      if (this.constructor.prototype.hasOwnProperty(name)) {
+        throw new TypeError('Cannot define a method called ' + name);
+      } // @ts-expect-error: dynamic extension of the class instance is expected.
+
+      this[name] = this._callFunctionWithArgs.bind(this, name);
+    });
+  }
+
+  _callFunctionWithArgs(method, ...args) {
+    if (this._ending) {
+      throw new Error('Farm is ended, no more calls can be done to it');
+    }
+
+    return this._farm.doWork(method, ...args);
+  }
+
+  getStderr() {
+    return this._workerPool.getStderr();
+  }
+
+  getStdout() {
+    return this._workerPool.getStdout();
+  }
+
+  async end() {
+    if (this._ending) {
+      throw new Error('Farm is ended, no more calls can be done to it');
+    }
+
+    this._ending = true;
+    return this._workerPool.end();
+  }
+}
+
+exports.default = JestWorker;

node_modules/@jest/reporters/node_modules/jest-worker/build/types.d.ts

@@ -0,0 +1,128 @@
+/**
+ * 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 { ForkOptions } from 'child_process';
+import type { EventEmitter } from 'events';
+export interface ResourceLimits {
+    maxYoungGenerationSizeMb?: number;
+    maxOldGenerationSizeMb?: number;
+    codeRangeSizeMb?: number;
+}
+export declare const CHILD_MESSAGE_INITIALIZE: 0;
+export declare const CHILD_MESSAGE_CALL: 1;
+export declare const CHILD_MESSAGE_END: 2;
+export declare const PARENT_MESSAGE_OK: 0;
+export declare const PARENT_MESSAGE_CLIENT_ERROR: 1;
+export declare const PARENT_MESSAGE_SETUP_ERROR: 2;
+export declare const PARENT_MESSAGE_CUSTOM: 3;
+export declare type PARENT_MESSAGE_ERROR = typeof PARENT_MESSAGE_CLIENT_ERROR | typeof PARENT_MESSAGE_SETUP_ERROR;
+export interface WorkerPoolInterface {
+    getStderr(): NodeJS.ReadableStream;
+    getStdout(): NodeJS.ReadableStream;
+    getWorkers(): Array<WorkerInterface>;
+    createWorker(options: WorkerOptions): WorkerInterface;
+    send(workerId: number, request: ChildMessage, onStart: OnStart, onEnd: OnEnd, onCustomMessage: OnCustomMessage): void;
+    end(): Promise<PoolExitResult>;
+}
+export interface WorkerInterface {
+    send(request: ChildMessage, onProcessStart: OnStart, onProcessEnd: OnEnd, onCustomMessage: OnCustomMessage): void;
+    waitForExit(): Promise<void>;
+    forceExit(): void;
+    getWorkerId(): number;
+    getStderr(): NodeJS.ReadableStream | null;
+    getStdout(): NodeJS.ReadableStream | null;
+}
+export declare type PoolExitResult = {
+    forceExited: boolean;
+};
+export interface PromiseWithCustomMessage<T> extends Promise<T> {
+    UNSTABLE_onCustomMessage?: (listener: OnCustomMessage) => () => void;
+}
+export type { ForkOptions };
+export declare type FarmOptions = {
+    computeWorkerKey?: (method: string, ...args: Array<unknown>) => string | null;
+    exposedMethods?: ReadonlyArray<string>;
+    forkOptions?: ForkOptions;
+    resourceLimits?: ResourceLimits;
+    setupArgs?: Array<unknown>;
+    maxRetries?: number;
+    numWorkers?: number;
+    WorkerPool?: (workerPath: string, options?: WorkerPoolOptions) => WorkerPoolInterface;
+    enableWorkerThreads?: boolean;
+};
+export declare type WorkerPoolOptions = {
+    setupArgs: Array<unknown>;
+    forkOptions: ForkOptions;
+    resourceLimits: ResourceLimits;
+    maxRetries: number;
+    numWorkers: number;
+    enableWorkerThreads: boolean;
+};
+export declare type WorkerOptions = {
+    forkOptions: ForkOptions;
+    resourceLimits: ResourceLimits;
+    setupArgs: Array<unknown>;
+    maxRetries: number;
+    workerId: number;
+    workerPath: string;
+};
+export declare type MessagePort = typeof EventEmitter & {
+    postMessage(message: unknown): void;
+};
+export declare type MessageChannel = {
+    port1: MessagePort;
+    port2: MessagePort;
+};
+export declare type ChildMessageInitialize = [
+    typeof CHILD_MESSAGE_INITIALIZE,
+    boolean,
+    string,
+    // file
+    Array<unknown> | undefined,
+    // setupArgs
+    MessagePort | undefined
+];
+export declare type ChildMessageCall = [
+    typeof CHILD_MESSAGE_CALL,
+    boolean,
+    string,
+    Array<unknown>
+];
+export declare type ChildMessageEnd = [
+    typeof CHILD_MESSAGE_END,
+    boolean
+];
+export declare type ChildMessage = ChildMessageInitialize | ChildMessageCall | ChildMessageEnd;
+export declare type ParentMessageCustom = [
+    typeof PARENT_MESSAGE_CUSTOM,
+    unknown
+];
+export declare type ParentMessageOk = [
+    typeof PARENT_MESSAGE_OK,
+    unknown
+];
+export declare type ParentMessageError = [
+    PARENT_MESSAGE_ERROR,
+    string,
+    string,
+    string,
+    unknown
+];
+export declare type ParentMessage = ParentMessageOk | ParentMessageError | ParentMessageCustom;
+export declare type OnStart = (worker: WorkerInterface) => void;
+export declare type OnEnd = (err: Error | null, result: unknown) => void;
+export declare type OnCustomMessage = (message: Array<unknown> | unknown) => void;
+export declare type QueueChildMessage = {
+    request: ChildMessage;
+    onStart: OnStart;
+    onEnd: OnEnd;
+    onCustomMessage: OnCustomMessage;
+};
+export declare type QueueItem = {
+    task: QueueChildMessage;
+    next: QueueItem | null;
+};

node_modules/@jest/reporters/node_modules/jest-worker/build/types.js

@@ -0,0 +1,32 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.PARENT_MESSAGE_CUSTOM = exports.PARENT_MESSAGE_SETUP_ERROR = exports.PARENT_MESSAGE_CLIENT_ERROR = exports.PARENT_MESSAGE_OK = exports.CHILD_MESSAGE_END = exports.CHILD_MESSAGE_CALL = exports.CHILD_MESSAGE_INITIALIZE = void 0;
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+// import type {ResourceLimits} from 'worker_threads';
+// This is not present in the Node 12 typings
+// Because of the dynamic nature of a worker communication process, all messages
+// coming from any of the other processes cannot be typed. Thus, many types
+// include "unknown" as a TS type, which is (unfortunately) correct here.
+const CHILD_MESSAGE_INITIALIZE = 0;
+exports.CHILD_MESSAGE_INITIALIZE = CHILD_MESSAGE_INITIALIZE;
+const CHILD_MESSAGE_CALL = 1;
+exports.CHILD_MESSAGE_CALL = CHILD_MESSAGE_CALL;
+const CHILD_MESSAGE_END = 2;
+exports.CHILD_MESSAGE_END = CHILD_MESSAGE_END;
+const PARENT_MESSAGE_OK = 0;
+exports.PARENT_MESSAGE_OK = PARENT_MESSAGE_OK;
+const PARENT_MESSAGE_CLIENT_ERROR = 1;
+exports.PARENT_MESSAGE_CLIENT_ERROR = PARENT_MESSAGE_CLIENT_ERROR;
+const PARENT_MESSAGE_SETUP_ERROR = 2;
+exports.PARENT_MESSAGE_SETUP_ERROR = PARENT_MESSAGE_SETUP_ERROR;
+const PARENT_MESSAGE_CUSTOM = 3;
+exports.PARENT_MESSAGE_CUSTOM = PARENT_MESSAGE_CUSTOM;