0.2.0 - Mid migration

web/node_modules/jest-config/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.

web/node_modules/jest-config/build/Defaults.d.ts

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

web/node_modules/jest-config/build/Defaults.js

@@ -0,0 +1,107 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+function _path() {
+  const data = require('path');
+
+  _path = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestRegexUtil() {
+  const data = require('jest-regex-util');
+
+  _jestRegexUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _constants = require('./constants');
+
+var _getCacheDirectory = _interopRequireDefault(require('./getCacheDirectory'));
+
+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 NODE_MODULES_REGEXP = (0, _jestRegexUtil().replacePathSepForRegex)(
+  _constants.NODE_MODULES
+);
+const defaultOptions = {
+  automock: false,
+  bail: 0,
+  cache: true,
+  cacheDirectory: (0, _getCacheDirectory.default)(),
+  changedFilesWithAncestor: false,
+  clearMocks: false,
+  collectCoverage: false,
+  coveragePathIgnorePatterns: [NODE_MODULES_REGEXP],
+  coverageProvider: 'babel',
+  coverageReporters: ['json', 'text', 'lcov', 'clover'],
+  errorOnDeprecated: false,
+  expand: false,
+  forceCoverageMatch: [],
+  globals: {},
+  haste: {
+    computeSha1: false,
+    throwOnModuleCollision: false
+  },
+  injectGlobals: true,
+  maxConcurrency: 5,
+  maxWorkers: '50%',
+  moduleDirectories: ['node_modules'],
+  moduleFileExtensions: ['js', 'json', 'jsx', 'ts', 'tsx', 'node'],
+  moduleNameMapper: {},
+  modulePathIgnorePatterns: [],
+  noStackTrace: false,
+  notify: false,
+  notifyMode: 'failure-change',
+  prettierPath: 'prettier',
+  resetMocks: false,
+  resetModules: false,
+  restoreMocks: false,
+  roots: ['<rootDir>'],
+  runTestsByPath: false,
+  runner: 'jest-runner',
+  setupFiles: [],
+  setupFilesAfterEnv: [],
+  skipFilter: false,
+  slowTestThreshold: 5,
+  snapshotSerializers: [],
+  testEnvironment: 'jest-environment-jsdom',
+  testEnvironmentOptions: {},
+  testFailureExitCode: 1,
+  testLocationInResults: false,
+  testMatch: ['**/__tests__/**/*.[jt]s?(x)', '**/?(*.)+(spec|test).[tj]s?(x)'],
+  testPathIgnorePatterns: [NODE_MODULES_REGEXP],
+  testRegex: [],
+  testRunner: 'jasmine2',
+  testSequencer: '@jest/test-sequencer',
+  testURL: 'http://localhost',
+  timers: 'real',
+  transformIgnorePatterns: [
+    NODE_MODULES_REGEXP,
+    `\\.pnp\\.[^\\${_path().sep}]+$`
+  ],
+  useStderr: false,
+  watch: false,
+  watchPathIgnorePatterns: [],
+  watchman: true
+};
+var _default = defaultOptions;
+exports.default = _default;

web/node_modules/jest-config/build/Deprecated.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 { DeprecatedOptions } from 'jest-validate';
+declare const deprecatedOptions: DeprecatedOptions;
+export default deprecatedOptions;

web/node_modules/jest-config/build/Deprecated.js

@@ -0,0 +1,108 @@
+'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 _prettyFormat() {
+  const data = _interopRequireDefault(require('pretty-format'));
+
+  _prettyFormat = 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 format = value =>
+  (0, _prettyFormat().default)(value, {
+    min: true
+  });
+
+const deprecatedOptions = {
+  browser: () => `  Option ${_chalk().default.bold(
+    '"browser"'
+  )} has been deprecated. Please install "browser-resolve" and use the "resolver" option in Jest configuration as follows:
+  {
+    ${_chalk().default.bold('"resolver"')}: ${_chalk().default.bold(
+    '"browser-resolve"'
+  )}
+  }
+  `,
+  mapCoverage: () => `  Option ${_chalk().default.bold(
+    '"mapCoverage"'
+  )} has been removed, as it's no longer necessary.
+
+  Please update your configuration.`,
+  preprocessorIgnorePatterns: options => `  Option ${_chalk().default.bold(
+    '"preprocessorIgnorePatterns"'
+  )} was replaced by ${_chalk().default.bold(
+    '"transformIgnorePatterns"'
+  )}, which support multiple preprocessors.
+
+  Jest now treats your current configuration as:
+  {
+    ${_chalk().default.bold(
+      '"transformIgnorePatterns"'
+    )}: ${_chalk().default.bold(format(options.preprocessorIgnorePatterns))}
+  }
+
+  Please update your configuration.`,
+  scriptPreprocessor: options => `  Option ${_chalk().default.bold(
+    '"scriptPreprocessor"'
+  )} was replaced by ${_chalk().default.bold(
+    '"transform"'
+  )}, which support multiple preprocessors.
+
+  Jest now treats your current configuration as:
+  {
+    ${_chalk().default.bold('"transform"')}: ${_chalk().default.bold(
+    `{".*": ${format(options.scriptPreprocessor)}}`
+  )}
+  }
+
+  Please update your configuration.`,
+  setupTestFrameworkScriptFile: _options => `  Option ${_chalk().default.bold(
+    '"setupTestFrameworkScriptFile"'
+  )} was replaced by configuration ${_chalk().default.bold(
+    '"setupFilesAfterEnv"'
+  )}, which supports multiple paths.
+
+  Please update your configuration.`,
+  testPathDirs: options => `  Option ${_chalk().default.bold(
+    '"testPathDirs"'
+  )} was replaced by ${_chalk().default.bold('"roots"')}.
+
+  Jest now treats your current configuration as:
+  {
+    ${_chalk().default.bold('"roots"')}: ${_chalk().default.bold(
+    format(options.testPathDirs)
+  )}
+  }
+
+  Please update your configuration.
+  `
+};
+var _default = deprecatedOptions;
+exports.default = _default;

web/node_modules/jest-config/build/Descriptions.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+declare const descriptions: {
+    [key in keyof Config.InitialOptions]: string;
+};
+export default descriptions;

web/node_modules/jest-config/build/Descriptions.js

@@ -0,0 +1,105 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const descriptions = {
+  automock: 'All imported modules in your tests should be mocked automatically',
+  bail: 'Stop running tests after `n` failures',
+  cacheDirectory:
+    'The directory where Jest should store its cached dependency information',
+  clearMocks: 'Automatically clear mock calls and instances between every test',
+  collectCoverage:
+    'Indicates whether the coverage information should be collected while executing the test',
+  collectCoverageFrom:
+    'An array of glob patterns indicating a set of files for which coverage information should be collected',
+  coverageDirectory:
+    'The directory where Jest should output its coverage files',
+  coveragePathIgnorePatterns:
+    'An array of regexp pattern strings used to skip coverage collection',
+  coverageProvider:
+    'Indicates which provider should be used to instrument code for coverage',
+  coverageReporters:
+    'A list of reporter names that Jest uses when writing coverage reports',
+  coverageThreshold:
+    'An object that configures minimum threshold enforcement for coverage results',
+  dependencyExtractor: 'A path to a custom dependency extractor',
+  errorOnDeprecated:
+    'Make calling deprecated APIs throw helpful error messages',
+  forceCoverageMatch:
+    'Force coverage collection from ignored files using an array of glob patterns',
+  globalSetup:
+    'A path to a module which exports an async function that is triggered once before all test suites',
+  globalTeardown:
+    'A path to a module which exports an async function that is triggered once after all test suites',
+  globals:
+    'A set of global variables that need to be available in all test environments',
+  maxWorkers:
+    'The maximum amount of workers used to run your tests. Can be specified as % or a number. E.g. maxWorkers: 10% will use 10% of your CPU amount + 1 as the maximum worker number. maxWorkers: 2 will use a maximum of 2 workers.',
+  moduleDirectories:
+    "An array of directory names to be searched recursively up from the requiring module's location",
+  moduleFileExtensions: 'An array of file extensions your modules use',
+  moduleNameMapper:
+    'A map from regular expressions to module names or to arrays of module names that allow to stub out resources with a single module',
+  modulePathIgnorePatterns:
+    "An array of regexp pattern strings, matched against all module paths before considered 'visible' to the module loader",
+  notify: 'Activates notifications for test results',
+  notifyMode:
+    'An enum that specifies notification mode. Requires { notify: true }',
+  preset: "A preset that is used as a base for Jest's configuration",
+  projects: 'Run tests from one or more projects',
+  reporters: 'Use this configuration option to add custom reporters to Jest',
+  resetMocks: 'Automatically reset mock state between every test',
+  resetModules: 'Reset the module registry before running each individual test',
+  resolver: 'A path to a custom resolver',
+  restoreMocks: 'Automatically restore mock state between every test',
+  rootDir:
+    'The root directory that Jest should scan for tests and modules within',
+  roots:
+    'A list of paths to directories that Jest should use to search for files in',
+  runner:
+    "Allows you to use a custom runner instead of Jest's default test runner",
+  setupFiles:
+    'The paths to modules that run some code to configure or set up the testing environment before each test',
+  setupFilesAfterEnv:
+    'A list of paths to modules that run some code to configure or set up the testing framework before each test',
+  slowTestThreshold:
+    'The number of seconds after which a test is considered as slow and reported as such in the results.',
+  snapshotSerializers:
+    'A list of paths to snapshot serializer modules Jest should use for snapshot testing',
+  testEnvironment: 'The test environment that will be used for testing',
+  testEnvironmentOptions: 'Options that will be passed to the testEnvironment',
+  testLocationInResults: 'Adds a location field to test results',
+  testMatch: 'The glob patterns Jest uses to detect test files',
+  testPathIgnorePatterns:
+    'An array of regexp pattern strings that are matched against all test paths, matched tests are skipped',
+  testRegex:
+    'The regexp pattern or array of patterns that Jest uses to detect test files',
+  testResultsProcessor:
+    'This option allows the use of a custom results processor',
+  testRunner: 'This option allows use of a custom test runner',
+  testURL:
+    'This option sets the URL for the jsdom environment. It is reflected in properties such as location.href',
+  timers:
+    'Setting this value to "fake" allows the use of fake timers for functions such as "setTimeout"',
+  transform: 'A map from regular expressions to paths to transformers',
+  transformIgnorePatterns:
+    'An array of regexp pattern strings that are matched against all source file paths, matched files will skip transformation',
+  unmockedModulePathPatterns:
+    'An array of regexp pattern strings that are matched against all modules before the module loader will automatically return a mock for them',
+  verbose:
+    'Indicates whether each individual test should be reported during the run',
+  watchPathIgnorePatterns:
+    'An array of regexp patterns that are matched against all source file paths before re-running tests in watch mode',
+  watchman: 'Whether to use watchman for file crawling'
+};
+var _default = descriptions;
+exports.default = _default;

web/node_modules/jest-config/build/ReporterValidationErrors.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 { Config } from '@jest/types';
+import { ValidationError } from 'jest-validate';
+/**
+ * Reporter Validation Error is thrown if the given arguments
+ * within the reporter are not valid.
+ *
+ * This is a highly specific reporter error and in the future will be
+ * merged with jest-validate. Till then, we can make use of it. It works
+ * and that's what counts most at this time.
+ */
+export declare function createReporterError(reporterIndex: number, reporterValue: Array<Config.ReporterConfig> | string): ValidationError;
+export declare function createArrayReporterError(arrayReporter: Config.ReporterConfig, reporterIndex: number, valueIndex: number, value: string | Record<string, unknown>, expectedType: string, valueName: string): ValidationError;
+export declare function validateReporters(reporterConfig: Array<Config.ReporterConfig | string>): boolean;

web/node_modules/jest-config/build/ReporterValidationErrors.js

@@ -0,0 +1,138 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.createReporterError = createReporterError;
+exports.createArrayReporterError = createArrayReporterError;
+exports.validateReporters = validateReporters;
+
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+
+  _chalk = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestGetType() {
+  const data = _interopRequireDefault(require('jest-get-type'));
+
+  _jestGetType = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestValidate() {
+  const data = require('jest-validate');
+
+  _jestValidate = 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 validReporterTypes = ['array', 'string'];
+const ERROR = `${_utils.BULLET}Reporter Validation Error`;
+/**
+ * Reporter Validation Error is thrown if the given arguments
+ * within the reporter are not valid.
+ *
+ * This is a highly specific reporter error and in the future will be
+ * merged with jest-validate. Till then, we can make use of it. It works
+ * and that's what counts most at this time.
+ */
+
+function createReporterError(reporterIndex, reporterValue) {
+  const errorMessage =
+    `  Reporter at index ${reporterIndex} must be of type:\n` +
+    `    ${_chalk().default.bold.green(validReporterTypes.join(' or '))}\n` +
+    `  but instead received:\n` +
+    `    ${_chalk().default.bold.red(
+      (0, _jestGetType().default)(reporterValue)
+    )}`;
+  return new (_jestValidate().ValidationError)(
+    ERROR,
+    errorMessage,
+    _utils.DOCUMENTATION_NOTE
+  );
+}
+
+function createArrayReporterError(
+  arrayReporter,
+  reporterIndex,
+  valueIndex,
+  value,
+  expectedType,
+  valueName
+) {
+  const errorMessage =
+    `  Unexpected value for ${valueName} ` +
+    `at index ${valueIndex} of reporter at index ${reporterIndex}\n` +
+    '  Expected:\n' +
+    `    ${_chalk().default.bold.red(expectedType)}\n` +
+    '  Got:\n' +
+    `    ${_chalk().default.bold.green((0, _jestGetType().default)(value))}\n` +
+    `  Reporter configuration:\n` +
+    `    ${_chalk().default.bold.green(
+      JSON.stringify(arrayReporter, null, 2).split('\n').join('\n    ')
+    )}`;
+  return new (_jestValidate().ValidationError)(
+    ERROR,
+    errorMessage,
+    _utils.DOCUMENTATION_NOTE
+  );
+}
+
+function validateReporters(reporterConfig) {
+  return reporterConfig.every((reporter, index) => {
+    if (Array.isArray(reporter)) {
+      validateArrayReporter(reporter, index);
+    } else if (typeof reporter !== 'string') {
+      throw createReporterError(index, reporter);
+    }
+
+    return true;
+  });
+}
+
+function validateArrayReporter(arrayReporter, reporterIndex) {
+  const [path, options] = arrayReporter;
+
+  if (typeof path !== 'string') {
+    throw createArrayReporterError(
+      arrayReporter,
+      reporterIndex,
+      0,
+      path,
+      'string',
+      'Path'
+    );
+  } else if (typeof options !== 'object') {
+    throw createArrayReporterError(
+      arrayReporter,
+      reporterIndex,
+      1,
+      options,
+      'object',
+      'Reporter Configuration'
+    );
+  }
+}

web/node_modules/jest-config/build/ValidConfig.d.ts

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

web/node_modules/jest-config/build/ValidConfig.js

@@ -0,0 +1,180 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+function _jestRegexUtil() {
+  const data = require('jest-regex-util');
+
+  _jestRegexUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestValidate() {
+  const data = require('jest-validate');
+
+  _jestValidate = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _constants = require('./constants');
+
+/**
+ * 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 NODE_MODULES_REGEXP = (0, _jestRegexUtil().replacePathSepForRegex)(
+  _constants.NODE_MODULES
+);
+const initialOptions = {
+  automock: false,
+  bail: (0, _jestValidate().multipleValidOptions)(false, 0),
+  cache: true,
+  cacheDirectory: '/tmp/user/jest',
+  changedFilesWithAncestor: false,
+  changedSince: 'master',
+  clearMocks: false,
+  collectCoverage: true,
+  collectCoverageFrom: ['src', '!public'],
+  collectCoverageOnlyFrom: {
+    '<rootDir>/this-directory-is-covered/Covered.js': true
+  },
+  coverageDirectory: 'coverage',
+  coveragePathIgnorePatterns: [NODE_MODULES_REGEXP],
+  coverageProvider: 'v8',
+  coverageReporters: ['json', 'text', 'lcov', 'clover'],
+  coverageThreshold: {
+    global: {
+      branches: 50,
+      functions: 100,
+      lines: 100,
+      statements: 100
+    }
+  },
+  dependencyExtractor: '<rootDir>/dependencyExtractor.js',
+  displayName: (0, _jestValidate().multipleValidOptions)('test-config', {
+    color: 'blue',
+    name: 'test-config'
+  }),
+  errorOnDeprecated: false,
+  expand: false,
+  extraGlobals: [],
+  filter: '<rootDir>/filter.js',
+  forceCoverageMatch: ['**/*.t.js'],
+  forceExit: false,
+  globalSetup: 'setup.js',
+  globalTeardown: 'teardown.js',
+  globals: {
+    __DEV__: true
+  },
+  haste: {
+    computeSha1: true,
+    defaultPlatform: 'ios',
+    hasteImplModulePath: '<rootDir>/haste_impl.js',
+    platforms: ['ios', 'android'],
+    throwOnModuleCollision: false
+  },
+  injectGlobals: true,
+  json: false,
+  lastCommit: false,
+  logHeapUsage: true,
+  maxConcurrency: 5,
+  maxWorkers: '50%',
+  moduleDirectories: ['node_modules'],
+  moduleFileExtensions: ['js', 'json', 'jsx', 'ts', 'tsx', 'node'],
+  moduleLoader: '<rootDir>',
+  moduleNameMapper: {
+    '^React$': '<rootDir>/node_modules/react'
+  },
+  modulePathIgnorePatterns: ['<rootDir>/build/'],
+  modulePaths: ['/shared/vendor/modules'],
+  name: 'string',
+  noStackTrace: false,
+  notify: false,
+  notifyMode: 'failure-change',
+  onlyChanged: false,
+  onlyFailures: false,
+  preset: 'react-native',
+  prettierPath: '<rootDir>/node_modules/prettier',
+  projects: ['project-a', 'project-b/'],
+  reporters: [
+    'default',
+    'custom-reporter-1',
+    [
+      'custom-reporter-2',
+      {
+        configValue: true
+      }
+    ]
+  ],
+  resetMocks: false,
+  resetModules: false,
+  resolver: '<rootDir>/resolver.js',
+  restoreMocks: false,
+  rootDir: '/',
+  roots: ['<rootDir>'],
+  runTestsByPath: false,
+  runner: 'jest-runner',
+  setupFiles: ['<rootDir>/setup.js'],
+  setupFilesAfterEnv: ['<rootDir>/testSetupFile.js'],
+  silent: true,
+  skipFilter: false,
+  skipNodeResolution: false,
+  slowTestThreshold: 5,
+  snapshotResolver: '<rootDir>/snapshotResolver.js',
+  snapshotSerializers: ['my-serializer-module'],
+  testEnvironment: 'jest-environment-jsdom',
+  testEnvironmentOptions: {
+    userAgent: 'Agent/007'
+  },
+  testFailureExitCode: 1,
+  testLocationInResults: false,
+  testMatch: ['**/__tests__/**/*.[jt]s?(x)', '**/?(*.)+(spec|test).[jt]s?(x)'],
+  testNamePattern: 'test signature',
+  testPathIgnorePatterns: [NODE_MODULES_REGEXP],
+  testRegex: (0,
+  _jestValidate()
+    .multipleValidOptions)('(/__tests__/.*|(\\.|/)(test|spec))\\.[jt]sx?$', [
+    '/__tests__/\\.test\\.[jt]sx?$',
+    '/__tests__/\\.spec\\.[jt]sx?$'
+  ]),
+  testResultsProcessor: 'processor-node-module',
+  testRunner: 'jasmine2',
+  testSequencer: '@jest/test-sequencer',
+  testTimeout: 5000,
+  testURL: 'http://localhost',
+  timers: 'real',
+  transform: {
+    '\\.js$': '<rootDir>/preprocessor.js'
+  },
+  transformIgnorePatterns: [NODE_MODULES_REGEXP],
+  unmockedModulePathPatterns: ['mock'],
+  updateSnapshot: true,
+  useStderr: false,
+  verbose: false,
+  watch: false,
+  watchPathIgnorePatterns: ['<rootDir>/e2e/'],
+  watchPlugins: [
+    'path/to/yourWatchPlugin',
+    [
+      'jest-watch-typeahead/filename',
+      {
+        key: 'k',
+        prompt: 'do something with my custom prompt'
+      }
+    ]
+  ],
+  watchman: true
+};
+var _default = initialOptions;
+exports.default = _default;

web/node_modules/jest-config/build/color.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 { ForegroundColor } from 'chalk';
+declare type Color = typeof ForegroundColor;
+export declare const getDisplayNameColor: (seed?: string | undefined) => Color;
+export {};

web/node_modules/jest-config/build/color.js

@@ -0,0 +1,37 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.getDisplayNameColor = void 0;
+
+function _crypto() {
+  const data = require('crypto');
+
+  _crypto = function () {
+    return data;
+  };
+
+  return data;
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const colors = ['red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white'];
+
+const getDisplayNameColor = seed => {
+  if (seed === undefined) {
+    return 'white';
+  }
+
+  const hash = (0, _crypto().createHash)('sha256');
+  hash.update(seed);
+  const num = hash.digest().readUInt32LE(0);
+  return colors[num % colors.length];
+};
+
+exports.getDisplayNameColor = getDisplayNameColor;

web/node_modules/jest-config/build/constants.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.
+ */
+export declare const NODE_MODULES: string;
+export declare const DEFAULT_JS_PATTERN = "\\.[jt]sx?$";
+export declare const DEFAULT_REPORTER_LABEL = "default";
+export declare const PACKAGE_JSON = "package.json";
+export declare const JEST_CONFIG_BASE_NAME = "jest.config";
+export declare const JEST_CONFIG_EXT_CJS = ".cjs";
+export declare const JEST_CONFIG_EXT_MJS = ".mjs";
+export declare const JEST_CONFIG_EXT_JS = ".js";
+export declare const JEST_CONFIG_EXT_TS = ".ts";
+export declare const JEST_CONFIG_EXT_JSON = ".json";
+export declare const JEST_CONFIG_EXT_ORDER: readonly string[];

web/node_modules/jest-config/build/constants.js

@@ -0,0 +1,93 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.JEST_CONFIG_EXT_ORDER = exports.JEST_CONFIG_EXT_JSON = exports.JEST_CONFIG_EXT_TS = exports.JEST_CONFIG_EXT_JS = exports.JEST_CONFIG_EXT_MJS = exports.JEST_CONFIG_EXT_CJS = exports.JEST_CONFIG_BASE_NAME = exports.PACKAGE_JSON = exports.DEFAULT_REPORTER_LABEL = exports.DEFAULT_JS_PATTERN = exports.NODE_MODULES = void 0;
+
+function path() {
+  const data = _interopRequireWildcard(require('path'));
+
+  path = 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.
+ */
+const NODE_MODULES = path().sep + 'node_modules' + path().sep;
+exports.NODE_MODULES = NODE_MODULES;
+const DEFAULT_JS_PATTERN = '\\.[jt]sx?$';
+exports.DEFAULT_JS_PATTERN = DEFAULT_JS_PATTERN;
+const DEFAULT_REPORTER_LABEL = 'default';
+exports.DEFAULT_REPORTER_LABEL = DEFAULT_REPORTER_LABEL;
+const PACKAGE_JSON = 'package.json';
+exports.PACKAGE_JSON = PACKAGE_JSON;
+const JEST_CONFIG_BASE_NAME = 'jest.config';
+exports.JEST_CONFIG_BASE_NAME = JEST_CONFIG_BASE_NAME;
+const JEST_CONFIG_EXT_CJS = '.cjs';
+exports.JEST_CONFIG_EXT_CJS = JEST_CONFIG_EXT_CJS;
+const JEST_CONFIG_EXT_MJS = '.mjs';
+exports.JEST_CONFIG_EXT_MJS = JEST_CONFIG_EXT_MJS;
+const JEST_CONFIG_EXT_JS = '.js';
+exports.JEST_CONFIG_EXT_JS = JEST_CONFIG_EXT_JS;
+const JEST_CONFIG_EXT_TS = '.ts';
+exports.JEST_CONFIG_EXT_TS = JEST_CONFIG_EXT_TS;
+const JEST_CONFIG_EXT_JSON = '.json';
+exports.JEST_CONFIG_EXT_JSON = JEST_CONFIG_EXT_JSON;
+const JEST_CONFIG_EXT_ORDER = Object.freeze([
+  JEST_CONFIG_EXT_JS,
+  JEST_CONFIG_EXT_TS,
+  JEST_CONFIG_EXT_MJS,
+  JEST_CONFIG_EXT_CJS,
+  JEST_CONFIG_EXT_JSON
+]);
+exports.JEST_CONFIG_EXT_ORDER = JEST_CONFIG_EXT_ORDER;

web/node_modules/jest-config/build/getCacheDirectory.d.ts

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

web/node_modules/jest-config/build/getCacheDirectory.js

@@ -0,0 +1,104 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+function _os() {
+  const data = require('os');
+
+  _os = function () {
+    return data;
+  };
+
+  return data;
+}
+
+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.
+ */
+const getCacheDirectory = () => {
+  const {getuid} = process;
+  const tmpdirPath = path().join(
+    (0, _jestUtil().tryRealpath)((0, _os().tmpdir)()),
+    'jest'
+  );
+
+  if (getuid == null) {
+    return tmpdirPath;
+  } else {
+    // On some platforms tmpdir() is `/tmp`, causing conflicts between different
+    // users and permission issues. Adding an additional subdivision by UID can
+    // help.
+    return `${tmpdirPath}_${getuid.call(process).toString(36)}`;
+  }
+};
+
+var _default = getCacheDirectory;
+exports.default = _default;

web/node_modules/jest-config/build/getMaxWorkers.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+export default function getMaxWorkers(argv: Partial<Pick<Config.Argv, 'maxWorkers' | 'runInBand' | 'watch' | 'watchAll'>>, defaultOptions?: Partial<Pick<Config.Argv, 'maxWorkers'>>): number;

web/node_modules/jest-config/build/getMaxWorkers.js

@@ -0,0 +1,57 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = getMaxWorkers;
+
+function _os() {
+  const data = require('os');
+
+  _os = function () {
+    return data;
+  };
+
+  return data;
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+function getMaxWorkers(argv, defaultOptions) {
+  if (argv.runInBand) {
+    return 1;
+  } else if (argv.maxWorkers) {
+    return parseWorkers(argv.maxWorkers);
+  } else if (defaultOptions && defaultOptions.maxWorkers) {
+    return parseWorkers(defaultOptions.maxWorkers);
+  } else {
+    // In watch mode, Jest should be unobtrusive and not use all available CPUs.
+    const numCpus = (0, _os().cpus)() ? (0, _os().cpus)().length : 1;
+    const isWatchModeEnabled = argv.watch || argv.watchAll;
+    return Math.max(
+      isWatchModeEnabled ? Math.floor(numCpus / 2) : numCpus - 1,
+      1
+    );
+  }
+}
+
+const parseWorkers = maxWorkers => {
+  const parsed = parseInt(maxWorkers.toString(), 10);
+
+  if (
+    typeof maxWorkers === 'string' &&
+    maxWorkers.trim().endsWith('%') &&
+    parsed > 0 &&
+    parsed <= 100
+  ) {
+    const numCpus = (0, _os().cpus)().length;
+    const workers = Math.floor((parsed / 100) * numCpus);
+    return workers >= 1 ? workers : 1;
+  }
+
+  return parsed > 0 ? parsed : 1;
+};

web/node_modules/jest-config/build/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+import * as constants from './constants';
+export { getTestEnvironment, isJSONString } from './utils';
+export { default as normalize } from './normalize';
+export { default as deprecationEntries } from './Deprecated';
+export { replaceRootDirInPath } from './utils';
+export { default as defaults } from './Defaults';
+export { default as descriptions } from './Descriptions';
+export { constants };
+declare type ReadConfig = {
+    configPath: Config.Path | null | undefined;
+    globalConfig: Config.GlobalConfig;
+    hasDeprecationWarnings: boolean;
+    projectConfig: Config.ProjectConfig;
+};
+export declare function readConfig(argv: Config.Argv, packageRootOrConfig: Config.Path | Config.InitialOptions, skipArgvConfigOption?: boolean, parentConfigPath?: Config.Path | null, projectIndex?: number): Promise<ReadConfig>;
+export declare function readConfigs(argv: Config.Argv, projectPaths: Array<Config.Path>): Promise<{
+    globalConfig: Config.GlobalConfig;
+    configs: Array<Config.ProjectConfig>;
+    hasDeprecationWarnings: boolean;
+}>;

web/node_modules/jest-config/build/index.js

@@ -0,0 +1,479 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.readConfig = readConfig;
+exports.readConfigs = readConfigs;
+Object.defineProperty(exports, 'normalize', {
+  enumerable: true,
+  get: function () {
+    return _normalize.default;
+  }
+});
+Object.defineProperty(exports, 'getTestEnvironment', {
+  enumerable: true,
+  get: function () {
+    return _utils.getTestEnvironment;
+  }
+});
+Object.defineProperty(exports, 'isJSONString', {
+  enumerable: true,
+  get: function () {
+    return _utils.isJSONString;
+  }
+});
+Object.defineProperty(exports, 'replaceRootDirInPath', {
+  enumerable: true,
+  get: function () {
+    return _utils.replaceRootDirInPath;
+  }
+});
+Object.defineProperty(exports, 'deprecationEntries', {
+  enumerable: true,
+  get: function () {
+    return _Deprecated.default;
+  }
+});
+Object.defineProperty(exports, 'defaults', {
+  enumerable: true,
+  get: function () {
+    return _Defaults.default;
+  }
+});
+Object.defineProperty(exports, 'descriptions', {
+  enumerable: true,
+  get: function () {
+    return _Descriptions.default;
+  }
+});
+exports.constants = 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 fs() {
+  const data = _interopRequireWildcard(require('graceful-fs'));
+
+  fs = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var constants = _interopRequireWildcard(require('./constants'));
+
+exports.constants = constants;
+
+var _normalize = _interopRequireDefault(require('./normalize'));
+
+var _readConfigFileAndSetRootDir = _interopRequireDefault(
+  require('./readConfigFileAndSetRootDir')
+);
+
+var _resolveConfigPath = _interopRequireDefault(require('./resolveConfigPath'));
+
+var _utils = require('./utils');
+
+var _Deprecated = _interopRequireDefault(require('./Deprecated'));
+
+var _Defaults = _interopRequireDefault(require('./Defaults'));
+
+var _Descriptions = _interopRequireDefault(require('./Descriptions'));
+
+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.
+ */
+async function readConfig(
+  argv,
+  packageRootOrConfig, // Whether it needs to look into `--config` arg passed to CLI.
+  // It only used to read initial config. If the initial config contains
+  // `project` property, we don't want to read `--config` value and rather
+  // read individual configs for every project.
+  skipArgvConfigOption,
+  parentConfigPath,
+  projectIndex = Infinity
+) {
+  let rawOptions;
+  let configPath = null;
+
+  if (typeof packageRootOrConfig !== 'string') {
+    if (parentConfigPath) {
+      const parentConfigDirname = path().dirname(parentConfigPath);
+      rawOptions = packageRootOrConfig;
+      rawOptions.rootDir = rawOptions.rootDir
+        ? (0, _utils.replaceRootDirInPath)(
+            parentConfigDirname,
+            rawOptions.rootDir
+          )
+        : parentConfigDirname;
+    } else {
+      throw new Error(
+        'Jest: Cannot use configuration as an object without a file path.'
+      );
+    }
+  } else if ((0, _utils.isJSONString)(argv.config)) {
+    // A JSON string was passed to `--config` argument and we can parse it
+    // and use as is.
+    let config;
+
+    try {
+      config = JSON.parse(argv.config);
+    } catch {
+      throw new Error(
+        'There was an error while parsing the `--config` argument as a JSON string.'
+      );
+    } // NOTE: we might need to resolve this dir to an absolute path in the future
+
+    config.rootDir = config.rootDir || packageRootOrConfig;
+    rawOptions = config; // A string passed to `--config`, which is either a direct path to the config
+    // or a path to directory containing `package.json`, `jest.config.js` or `jest.config.ts`
+  } else if (!skipArgvConfigOption && typeof argv.config == 'string') {
+    configPath = (0, _resolveConfigPath.default)(argv.config, process.cwd());
+    rawOptions = await (0, _readConfigFileAndSetRootDir.default)(configPath);
+  } else {
+    // Otherwise just try to find config in the current rootDir.
+    configPath = (0, _resolveConfigPath.default)(
+      packageRootOrConfig,
+      process.cwd()
+    );
+    rawOptions = await (0, _readConfigFileAndSetRootDir.default)(configPath);
+  }
+
+  if (typeof rawOptions === 'function') {
+    rawOptions = await rawOptions();
+  }
+
+  const {options, hasDeprecationWarnings} = (0, _normalize.default)(
+    rawOptions,
+    argv,
+    configPath,
+    projectIndex
+  );
+  const {globalConfig, projectConfig} = groupOptions(options);
+  return {
+    configPath,
+    globalConfig,
+    hasDeprecationWarnings,
+    projectConfig
+  };
+}
+
+const groupOptions = options => ({
+  globalConfig: Object.freeze({
+    bail: options.bail,
+    changedFilesWithAncestor: options.changedFilesWithAncestor,
+    changedSince: options.changedSince,
+    collectCoverage: options.collectCoverage,
+    collectCoverageFrom: options.collectCoverageFrom,
+    collectCoverageOnlyFrom: options.collectCoverageOnlyFrom,
+    coverageDirectory: options.coverageDirectory,
+    coverageProvider: options.coverageProvider,
+    coverageReporters: options.coverageReporters,
+    coverageThreshold: options.coverageThreshold,
+    detectLeaks: options.detectLeaks,
+    detectOpenHandles: options.detectOpenHandles,
+    enabledTestsMap: options.enabledTestsMap,
+    errorOnDeprecated: options.errorOnDeprecated,
+    expand: options.expand,
+    filter: options.filter,
+    findRelatedTests: options.findRelatedTests,
+    forceExit: options.forceExit,
+    globalSetup: options.globalSetup,
+    globalTeardown: options.globalTeardown,
+    json: options.json,
+    lastCommit: options.lastCommit,
+    listTests: options.listTests,
+    logHeapUsage: options.logHeapUsage,
+    maxConcurrency: options.maxConcurrency,
+    maxWorkers: options.maxWorkers,
+    noSCM: undefined,
+    noStackTrace: options.noStackTrace,
+    nonFlagArgs: options.nonFlagArgs,
+    notify: options.notify,
+    notifyMode: options.notifyMode,
+    onlyChanged: options.onlyChanged,
+    onlyFailures: options.onlyFailures,
+    outputFile: options.outputFile,
+    passWithNoTests: options.passWithNoTests,
+    projects: options.projects,
+    replname: options.replname,
+    reporters: options.reporters,
+    rootDir: options.rootDir,
+    runTestsByPath: options.runTestsByPath,
+    silent: options.silent,
+    skipFilter: options.skipFilter,
+    testFailureExitCode: options.testFailureExitCode,
+    testNamePattern: options.testNamePattern,
+    testPathPattern: options.testPathPattern,
+    testResultsProcessor: options.testResultsProcessor,
+    testSequencer: options.testSequencer,
+    testTimeout: options.testTimeout,
+    updateSnapshot: options.updateSnapshot,
+    useStderr: options.useStderr,
+    verbose: options.verbose,
+    watch: options.watch,
+    watchAll: options.watchAll,
+    watchPlugins: options.watchPlugins,
+    watchman: options.watchman
+  }),
+  projectConfig: Object.freeze({
+    automock: options.automock,
+    cache: options.cache,
+    cacheDirectory: options.cacheDirectory,
+    clearMocks: options.clearMocks,
+    coveragePathIgnorePatterns: options.coveragePathIgnorePatterns,
+    cwd: options.cwd,
+    dependencyExtractor: options.dependencyExtractor,
+    detectLeaks: options.detectLeaks,
+    detectOpenHandles: options.detectOpenHandles,
+    displayName: options.displayName,
+    errorOnDeprecated: options.errorOnDeprecated,
+    extraGlobals: options.extraGlobals,
+    filter: options.filter,
+    forceCoverageMatch: options.forceCoverageMatch,
+    globalSetup: options.globalSetup,
+    globalTeardown: options.globalTeardown,
+    globals: options.globals,
+    haste: options.haste,
+    injectGlobals: options.injectGlobals,
+    moduleDirectories: options.moduleDirectories,
+    moduleFileExtensions: options.moduleFileExtensions,
+    moduleLoader: options.moduleLoader,
+    moduleNameMapper: options.moduleNameMapper,
+    modulePathIgnorePatterns: options.modulePathIgnorePatterns,
+    modulePaths: options.modulePaths,
+    name: options.name,
+    prettierPath: options.prettierPath,
+    resetMocks: options.resetMocks,
+    resetModules: options.resetModules,
+    resolver: options.resolver,
+    restoreMocks: options.restoreMocks,
+    rootDir: options.rootDir,
+    roots: options.roots,
+    runner: options.runner,
+    setupFiles: options.setupFiles,
+    setupFilesAfterEnv: options.setupFilesAfterEnv,
+    skipFilter: options.skipFilter,
+    skipNodeResolution: options.skipNodeResolution,
+    slowTestThreshold: options.slowTestThreshold,
+    snapshotResolver: options.snapshotResolver,
+    snapshotSerializers: options.snapshotSerializers,
+    testEnvironment: options.testEnvironment,
+    testEnvironmentOptions: options.testEnvironmentOptions,
+    testLocationInResults: options.testLocationInResults,
+    testMatch: options.testMatch,
+    testPathIgnorePatterns: options.testPathIgnorePatterns,
+    testRegex: options.testRegex,
+    testRunner: options.testRunner,
+    testURL: options.testURL,
+    timers: options.timers,
+    transform: options.transform,
+    transformIgnorePatterns: options.transformIgnorePatterns,
+    unmockedModulePathPatterns: options.unmockedModulePathPatterns,
+    watchPathIgnorePatterns: options.watchPathIgnorePatterns
+  })
+});
+
+const ensureNoDuplicateConfigs = (parsedConfigs, projects) => {
+  if (projects.length <= 1) {
+    return;
+  }
+
+  const configPathMap = new Map();
+
+  for (const config of parsedConfigs) {
+    const {configPath} = config;
+
+    if (configPathMap.has(configPath)) {
+      const message = `Whoops! Two projects resolved to the same config path: ${_chalk().default.bold(
+        String(configPath)
+      )}:
+
+  Project 1: ${_chalk().default.bold(
+    projects[parsedConfigs.findIndex(x => x === config)]
+  )}
+  Project 2: ${_chalk().default.bold(
+    projects[parsedConfigs.findIndex(x => x === configPathMap.get(configPath))]
+  )}
+
+This usually means that your ${_chalk().default.bold(
+        '"projects"'
+      )} config includes a directory that doesn't have any configuration recognizable by Jest. Please fix it.
+`;
+      throw new Error(message);
+    }
+
+    if (configPath !== null) {
+      configPathMap.set(configPath, config);
+    }
+  }
+}; // Possible scenarios:
+//  1. jest --config config.json
+//  2. jest --projects p1 p2
+//  3. jest --projects p1 p2 --config config.json
+//  4. jest --projects p1
+//  5. jest
+//
+// If no projects are specified, process.cwd() will be used as the default
+// (and only) project.
+
+async function readConfigs(argv, projectPaths) {
+  let globalConfig;
+  let hasDeprecationWarnings;
+  let configs = [];
+  let projects = projectPaths;
+  let configPath;
+
+  if (projectPaths.length === 1) {
+    const parsedConfig = await readConfig(argv, projects[0]);
+    configPath = parsedConfig.configPath;
+    hasDeprecationWarnings = parsedConfig.hasDeprecationWarnings;
+    globalConfig = parsedConfig.globalConfig;
+    configs = [parsedConfig.projectConfig];
+
+    if (globalConfig.projects && globalConfig.projects.length) {
+      // Even though we had one project in CLI args, there might be more
+      // projects defined in the config.
+      // In other words, if this was a single project,
+      // and its config has `projects` settings, use that value instead.
+      projects = globalConfig.projects;
+    }
+  }
+
+  if (projects.length > 0) {
+    const projectIsCwd =
+      process.platform === 'win32'
+        ? projects[0] === (0, _jestUtil().tryRealpath)(process.cwd())
+        : projects[0] === process.cwd();
+    const parsedConfigs = await Promise.all(
+      projects
+        .filter(root => {
+          // Ignore globbed files that cannot be `require`d.
+          if (
+            typeof root === 'string' &&
+            fs().existsSync(root) &&
+            !fs().lstatSync(root).isDirectory() &&
+            !constants.JEST_CONFIG_EXT_ORDER.some(ext => root.endsWith(ext))
+          ) {
+            return false;
+          }
+
+          return true;
+        })
+        .map((root, projectIndex) => {
+          const projectIsTheOnlyProject =
+            projectIndex === 0 && projects.length === 1;
+          const skipArgvConfigOption = !(
+            projectIsTheOnlyProject && projectIsCwd
+          );
+          return readConfig(
+            argv,
+            root,
+            skipArgvConfigOption,
+            configPath,
+            projectIndex
+          );
+        })
+    );
+    ensureNoDuplicateConfigs(parsedConfigs, projects);
+    configs = parsedConfigs.map(({projectConfig}) => projectConfig);
+
+    if (!hasDeprecationWarnings) {
+      hasDeprecationWarnings = parsedConfigs.some(
+        ({hasDeprecationWarnings}) => !!hasDeprecationWarnings
+      );
+    } // If no config was passed initially, use the one from the first project
+
+    if (!globalConfig) {
+      globalConfig = parsedConfigs[0].globalConfig;
+    }
+  }
+
+  if (!globalConfig || !configs.length) {
+    throw new Error('jest: No configuration found for any project.');
+  }
+
+  return {
+    configs,
+    globalConfig,
+    hasDeprecationWarnings: !!hasDeprecationWarnings
+  };
+}

web/node_modules/jest-config/build/normalize.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+declare type AllOptions = Config.ProjectConfig & Config.GlobalConfig;
+export default function normalize(initialOptions: Config.InitialOptions, argv: Config.Argv, configPath?: Config.Path | null, projectIndex?: number): {
+    hasDeprecationWarnings: boolean;
+    options: AllOptions;
+};
+export {};

web/node_modules/jest-config/build/readConfigFileAndSetRootDir.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+export default function readConfigFileAndSetRootDir(configPath: Config.Path): Promise<Config.InitialOptions>;

web/node_modules/jest-config/build/readConfigFileAndSetRootDir.js

@@ -0,0 +1,211 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = readConfigFileAndSetRootDir;
+
+function path() {
+  const data = _interopRequireWildcard(require('path'));
+
+  path = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _url() {
+  const data = require('url');
+
+  _url = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function fs() {
+  const data = _interopRequireWildcard(require('graceful-fs'));
+
+  fs = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _constants = require('./constants');
+
+var _jsonlint = _interopRequireDefault(require('./vendor/jsonlint'));
+
+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.
+ */
+// @ts-expect-error: vendored
+// Read the configuration and set its `rootDir`
+// 1. If it's a `package.json` file, we look into its "jest" property
+// 2. If it's a `jest.config.ts` file, we use `ts-node` to transpile & require it
+// 3. For any other file, we just require it. If we receive an 'ERR_REQUIRE_ESM'
+//    from node, perform a dynamic import instead.
+async function readConfigFileAndSetRootDir(configPath) {
+  const isTS = configPath.endsWith(_constants.JEST_CONFIG_EXT_TS);
+  const isJSON = configPath.endsWith(_constants.JEST_CONFIG_EXT_JSON);
+  let configObject;
+
+  try {
+    if (isTS) {
+      configObject = await loadTSConfigFile(configPath);
+    } else {
+      configObject = require(configPath);
+    }
+  } catch (error) {
+    if (error.code === 'ERR_REQUIRE_ESM') {
+      try {
+        const configUrl = (0, _url().pathToFileURL)(configPath); // node `import()` supports URL, but TypeScript doesn't know that
+
+        const importedConfig = await import(configUrl.href);
+
+        if (!importedConfig.default) {
+          throw new Error(
+            `Jest: Failed to load mjs config file ${configPath} - did you use a default export?`
+          );
+        }
+
+        configObject = importedConfig.default;
+      } catch (innerError) {
+        if (innerError.message === 'Not supported') {
+          throw new Error(
+            `Jest: Your version of Node does not support dynamic import - please enable it or use a .cjs file extension for file ${configPath}`
+          );
+        }
+
+        throw innerError;
+      }
+    } else if (isJSON) {
+      throw new Error(
+        `Jest: Failed to parse config file ${configPath}\n` +
+          `  ${_jsonlint.default.errors(fs().readFileSync(configPath, 'utf8'))}`
+      );
+    } else if (isTS) {
+      throw new Error(
+        `Jest: Failed to parse the TypeScript config file ${configPath}\n` +
+          `  ${error}`
+      );
+    } else {
+      throw error;
+    }
+  }
+
+  if (configPath.endsWith(_constants.PACKAGE_JSON)) {
+    // Event if there's no "jest" property in package.json we will still use
+    // an empty object.
+    configObject = configObject.jest || {};
+  }
+
+  if (configObject.rootDir) {
+    // We don't touch it if it has an absolute path specified
+    if (!path().isAbsolute(configObject.rootDir)) {
+      // otherwise, we'll resolve it relative to the file's __dirname
+      configObject.rootDir = path().resolve(
+        path().dirname(configPath),
+        configObject.rootDir
+      );
+    }
+  } else {
+    // If rootDir is not there, we'll set it to this file's __dirname
+    configObject.rootDir = path().dirname(configPath);
+  }
+
+  return configObject;
+} // Load the TypeScript configuration
+
+const loadTSConfigFile = async configPath => {
+  let registerer; // Register TypeScript compiler instance
+
+  try {
+    registerer = require('ts-node').register({
+      compilerOptions: {
+        module: 'CommonJS'
+      }
+    });
+  } catch (e) {
+    if (e.code === 'MODULE_NOT_FOUND') {
+      throw new Error(
+        `Jest: 'ts-node' is required for the TypeScript configuration files. Make sure it is installed\nError: ${e.message}`
+      );
+    }
+
+    throw e;
+  }
+
+  registerer.enabled(true);
+  let configObject = (0, _jestUtil().interopRequireDefault)(require(configPath))
+    .default; // In case the config is a function which imports more Typescript code
+
+  if (typeof configObject === 'function') {
+    configObject = await configObject();
+  }
+
+  registerer.enabled(false);
+  return configObject;
+};

web/node_modules/jest-config/build/resolveConfigPath.d.ts

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

web/node_modules/jest-config/build/resolveConfigPath.js

@@ -0,0 +1,153 @@
+'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 fs() {
+  const data = _interopRequireWildcard(require('graceful-fs'));
+
+  fs = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _constants = require('./constants');
+
+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 isFile = filePath =>
+  fs().existsSync(filePath) && !fs().lstatSync(filePath).isDirectory();
+
+const getConfigFilename = ext => _constants.JEST_CONFIG_BASE_NAME + ext;
+
+var _default = (pathToResolve, cwd) => {
+  if (!path().isAbsolute(cwd)) {
+    throw new Error(`"cwd" must be an absolute path. cwd: ${cwd}`);
+  }
+
+  const absolutePath = path().isAbsolute(pathToResolve)
+    ? pathToResolve
+    : path().resolve(cwd, pathToResolve);
+
+  if (isFile(absolutePath)) {
+    return absolutePath;
+  } // This is a guard against passing non existing path as a project/config,
+  // that will otherwise result in a very confusing situation.
+  // e.g.
+  // With a directory structure like this:
+  //   my_project/
+  //     packcage.json
+  //
+  // Passing a `my_project/some_directory_that_doesnt_exist` as a project
+  // name will resolve into a (possibly empty) `my_project/package.json` and
+  // try to run all tests it finds under `my_project` directory.
+
+  if (!fs().existsSync(absolutePath)) {
+    throw new Error(
+      `Can't find a root directory while resolving a config file path.\n` +
+        `Provided path to resolve: ${pathToResolve}\n` +
+        `cwd: ${cwd}`
+    );
+  }
+
+  return resolveConfigPathByTraversing(absolutePath, pathToResolve, cwd);
+};
+
+exports.default = _default;
+
+const resolveConfigPathByTraversing = (pathToResolve, initialPath, cwd) => {
+  const jestConfig = _constants.JEST_CONFIG_EXT_ORDER.map(ext =>
+    path().resolve(pathToResolve, getConfigFilename(ext))
+  ).find(isFile);
+
+  if (jestConfig) {
+    return jestConfig;
+  }
+
+  const packageJson = path().resolve(pathToResolve, _constants.PACKAGE_JSON);
+
+  if (isFile(packageJson)) {
+    return packageJson;
+  } // This is the system root.
+  // We tried everything, config is nowhere to be found ¯\_(ツ)_/¯
+
+  if (pathToResolve === path().dirname(pathToResolve)) {
+    throw new Error(makeResolutionErrorMessage(initialPath, cwd));
+  } // go up a level and try it again
+
+  return resolveConfigPathByTraversing(
+    path().dirname(pathToResolve),
+    initialPath,
+    cwd
+  );
+};
+
+const makeResolutionErrorMessage = (initialPath, cwd) =>
+  'Could not find a config file based on provided values:\n' +
+  `path: "${initialPath}"\n` +
+  `cwd: "${cwd}"\n` +
+  'Config paths must be specified by either a direct path to a config\n' +
+  'file, or a path to a directory. If directory is given, Jest will try to\n' +
+  `traverse directory tree up, until it finds one of those files in exact order: ${_constants.JEST_CONFIG_EXT_ORDER.map(
+    ext => `"${getConfigFilename(ext)}"`
+  ).join(' or ')}.`;

web/node_modules/jest-config/build/setFromArgv.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+export default function setFromArgv(options: Config.InitialOptions, argv: Config.Argv): Config.InitialOptions;

web/node_modules/jest-config/build/setFromArgv.js

@@ -0,0 +1,67 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = setFromArgv;
+
+var _utils = require('./utils');
+
+/**
+ * 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 specialArgs = ['_', '$0', 'h', 'help', 'config'];
+
+function setFromArgv(options, argv) {
+  const argvToOptions = Object.keys(argv)
+    .filter(key => argv[key] !== undefined && specialArgs.indexOf(key) === -1)
+    .reduce((options, key) => {
+      switch (key) {
+        case 'coverage':
+          options.collectCoverage = argv[key];
+          break;
+
+        case 'json':
+          options.useStderr = argv[key];
+          break;
+
+        case 'watchAll':
+          options.watch = false;
+          options.watchAll = argv[key];
+          break;
+
+        case 'env':
+          options.testEnvironment = argv[key];
+          break;
+
+        case 'config':
+          break;
+
+        case 'coverageThreshold':
+        case 'globals':
+        case 'moduleNameMapper':
+        case 'transform':
+        case 'haste':
+          const str = argv[key];
+
+          if ((0, _utils.isJSONString)(str)) {
+            options[key] = JSON.parse(str);
+          }
+
+          break;
+
+        default:
+          options[key] = argv[key];
+      }
+
+      return options;
+    }, {});
+  return {
+    ...options,
+    ...((0, _utils.isJSONString)(argv.config) ? JSON.parse(argv.config) : null),
+    ...argvToOptions
+  };
+}

web/node_modules/jest-config/build/utils.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+declare type ResolveOptions = {
+    rootDir: Config.Path;
+    key: string;
+    filePath: Config.Path;
+    optional?: boolean;
+};
+export declare const BULLET: string;
+export declare const DOCUMENTATION_NOTE: string;
+export declare const resolve: (resolver: string | null | undefined, { key, filePath, rootDir, optional }: ResolveOptions) => string;
+export declare const escapeGlobCharacters: (path: Config.Path) => Config.Glob;
+export declare const replaceRootDirInPath: (rootDir: Config.Path, filePath: Config.Path) => string;
+declare type OrArray<T> = T | Array<T>;
+declare type ReplaceRootDirConfigObj = Record<string, Config.Path>;
+declare type ReplaceRootDirConfigValues = OrArray<ReplaceRootDirConfigObj> | OrArray<RegExp> | OrArray<Config.Path>;
+export declare const _replaceRootDirTags: <T extends ReplaceRootDirConfigValues>(rootDir: Config.Path, config: T) => T;
+export declare const resolveWithPrefix: (resolver: string | undefined | null, { filePath, humanOptionName, optionName, prefix, rootDir, }: {
+    filePath: string;
+    humanOptionName: string;
+    optionName: string;
+    prefix: string;
+    rootDir: Config.Path;
+}) => string;
+/**
+ * Finds the test environment to use:
+ *
+ * 1. looks for jest-environment-<name> relative to project.
+ * 1. looks for jest-environment-<name> relative to Jest.
+ * 1. looks for <name> relative to project.
+ * 1. looks for <name> relative to Jest.
+ */
+export declare const getTestEnvironment: ({ rootDir, testEnvironment: filePath, }: {
+    rootDir: Config.Path;
+    testEnvironment: string;
+}) => string;
+/**
+ * Finds the watch plugins to use:
+ *
+ * 1. looks for jest-watch-<name> relative to project.
+ * 1. looks for jest-watch-<name> relative to Jest.
+ * 1. looks for <name> relative to project.
+ * 1. looks for <name> relative to Jest.
+ */
+export declare const getWatchPlugin: (resolver: string | undefined | null, { filePath, rootDir }: {
+    filePath: string;
+    rootDir: Config.Path;
+}) => string;
+/**
+ * Finds the runner to use:
+ *
+ * 1. looks for jest-runner-<name> relative to project.
+ * 1. looks for jest-runner-<name> relative to Jest.
+ * 1. looks for <name> relative to project.
+ * 1. looks for <name> relative to Jest.
+ */
+export declare const getRunner: (resolver: string | undefined | null, { filePath, rootDir }: {
+    filePath: string;
+    rootDir: Config.Path;
+}) => string;
+declare type JSONString = string & {
+    readonly $$type: never;
+};
+export declare const isJSONString: (text?: string | JSONString | undefined) => text is JSONString;
+export declare const getSequencer: (resolver: string | undefined | null, { filePath, rootDir }: {
+    filePath: string;
+    rootDir: Config.Path;
+}) => string;
+export {};

web/node_modules/jest-config/build/utils.js

@@ -0,0 +1,313 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.getSequencer = exports.isJSONString = exports.getRunner = exports.getWatchPlugin = exports.getTestEnvironment = exports.resolveWithPrefix = exports._replaceRootDirTags = exports.replaceRootDirInPath = exports.escapeGlobCharacters = exports.resolve = exports.DOCUMENTATION_NOTE = exports.BULLET = 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 _jestResolve() {
+  const data = _interopRequireDefault(require('jest-resolve'));
+
+  _jestResolve = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestValidate() {
+  const data = require('jest-validate');
+
+  _jestValidate = 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 BULLET = _chalk().default.bold('\u25cf ');
+
+exports.BULLET = BULLET;
+const DOCUMENTATION_NOTE = `  ${_chalk().default.bold(
+  'Configuration Documentation:'
+)}
+  https://jestjs.io/docs/configuration.html
+`;
+exports.DOCUMENTATION_NOTE = DOCUMENTATION_NOTE;
+
+const createValidationError = message =>
+  new (_jestValidate().ValidationError)(
+    `${BULLET}Validation Error`,
+    message,
+    DOCUMENTATION_NOTE
+  );
+
+const resolve = (resolver, {key, filePath, rootDir, optional}) => {
+  const module = _jestResolve().default.findNodeModule(
+    replaceRootDirInPath(rootDir, filePath),
+    {
+      basedir: rootDir,
+      resolver: resolver || undefined
+    }
+  );
+
+  if (!module && !optional) {
+    throw createValidationError(`  Module ${_chalk().default.bold(
+      filePath
+    )} in the ${_chalk().default.bold(key)} option was not found.
+         ${_chalk().default.bold('<rootDir>')} is: ${rootDir}`);
+  } /// can cast as string since nulls will be thrown
+
+  return module;
+};
+
+exports.resolve = resolve;
+
+const escapeGlobCharacters = path => path.replace(/([()*{}\[\]!?\\])/g, '\\$1');
+
+exports.escapeGlobCharacters = escapeGlobCharacters;
+
+const replaceRootDirInPath = (rootDir, filePath) => {
+  if (!/^<rootDir>/.test(filePath)) {
+    return filePath;
+  }
+
+  return path().resolve(
+    rootDir,
+    path().normalize('./' + filePath.substr('<rootDir>'.length))
+  );
+};
+
+exports.replaceRootDirInPath = replaceRootDirInPath;
+
+const _replaceRootDirInObject = (rootDir, config) => {
+  const newConfig = {};
+
+  for (const configKey in config) {
+    newConfig[configKey] =
+      configKey === 'rootDir'
+        ? config[configKey]
+        : _replaceRootDirTags(rootDir, config[configKey]);
+  }
+
+  return newConfig;
+};
+
+const _replaceRootDirTags = (rootDir, config) => {
+  if (config == null) {
+    return config;
+  }
+
+  switch (typeof config) {
+    case 'object':
+      if (Array.isArray(config)) {
+        /// can be string[] or {}[]
+        return config.map(item => _replaceRootDirTags(rootDir, item));
+      }
+
+      if (config instanceof RegExp) {
+        return config;
+      }
+
+      return _replaceRootDirInObject(rootDir, config);
+
+    case 'string':
+      return replaceRootDirInPath(rootDir, config);
+  }
+
+  return config;
+};
+
+exports._replaceRootDirTags = _replaceRootDirTags;
+
+const resolveWithPrefix = (
+  resolver,
+  {filePath, humanOptionName, optionName, prefix, rootDir}
+) => {
+  const fileName = replaceRootDirInPath(rootDir, filePath);
+
+  let module = _jestResolve().default.findNodeModule(`${prefix}${fileName}`, {
+    basedir: rootDir,
+    resolver: resolver || undefined
+  });
+
+  if (module) {
+    return module;
+  }
+
+  try {
+    return require.resolve(`${prefix}${fileName}`);
+  } catch {}
+
+  module = _jestResolve().default.findNodeModule(fileName, {
+    basedir: rootDir,
+    resolver: resolver || undefined
+  });
+
+  if (module) {
+    return module;
+  }
+
+  try {
+    return require.resolve(fileName);
+  } catch {}
+
+  throw createValidationError(
+    `  ${humanOptionName} ${_chalk().default.bold(
+      fileName
+    )} cannot be found. Make sure the ${_chalk().default.bold(
+      optionName
+    )} configuration option points to an existing node module.`
+  );
+};
+/**
+ * Finds the test environment to use:
+ *
+ * 1. looks for jest-environment-<name> relative to project.
+ * 1. looks for jest-environment-<name> relative to Jest.
+ * 1. looks for <name> relative to project.
+ * 1. looks for <name> relative to Jest.
+ */
+
+exports.resolveWithPrefix = resolveWithPrefix;
+
+const getTestEnvironment = ({rootDir, testEnvironment: filePath}) =>
+  resolveWithPrefix(undefined, {
+    filePath,
+    humanOptionName: 'Test environment',
+    optionName: 'testEnvironment',
+    prefix: 'jest-environment-',
+    rootDir
+  });
+/**
+ * Finds the watch plugins to use:
+ *
+ * 1. looks for jest-watch-<name> relative to project.
+ * 1. looks for jest-watch-<name> relative to Jest.
+ * 1. looks for <name> relative to project.
+ * 1. looks for <name> relative to Jest.
+ */
+
+exports.getTestEnvironment = getTestEnvironment;
+
+const getWatchPlugin = (resolver, {filePath, rootDir}) =>
+  resolveWithPrefix(resolver, {
+    filePath,
+    humanOptionName: 'Watch plugin',
+    optionName: 'watchPlugins',
+    prefix: 'jest-watch-',
+    rootDir
+  });
+/**
+ * Finds the runner to use:
+ *
+ * 1. looks for jest-runner-<name> relative to project.
+ * 1. looks for jest-runner-<name> relative to Jest.
+ * 1. looks for <name> relative to project.
+ * 1. looks for <name> relative to Jest.
+ */
+
+exports.getWatchPlugin = getWatchPlugin;
+
+const getRunner = (resolver, {filePath, rootDir}) =>
+  resolveWithPrefix(resolver, {
+    filePath,
+    humanOptionName: 'Jest Runner',
+    optionName: 'runner',
+    prefix: 'jest-runner-',
+    rootDir
+  });
+
+exports.getRunner = getRunner;
+
+// newtype
+const isJSONString = text =>
+  text != null &&
+  typeof text === 'string' &&
+  text.startsWith('{') &&
+  text.endsWith('}');
+
+exports.isJSONString = isJSONString;
+
+const getSequencer = (resolver, {filePath, rootDir}) =>
+  resolveWithPrefix(resolver, {
+    filePath,
+    humanOptionName: 'Jest Sequencer',
+    optionName: 'testSequencer',
+    prefix: 'jest-sequencer-',
+    rootDir
+  });
+
+exports.getSequencer = getSequencer;

web/node_modules/jest-config/build/validatePattern.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 validatePattern(pattern?: string): boolean;

web/node_modules/jest-config/build/validatePattern.js

@@ -0,0 +1,25 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = validatePattern;
+
+/**
+ * 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 validatePattern(pattern) {
+  if (pattern) {
+    try {
+      // eslint-disable-next-line no-new
+      new RegExp(pattern, 'i');
+    } catch {
+      return false;
+    }
+  }
+
+  return true;
+}

web/node_modules/jest-config/build/vendor/jsonlint.js

@@ -0,0 +1,917 @@
+'use strict';
+
+// From: https://github.com/zaach/jsonlint
+// Vendored in Jest to avoid jsonlint's transitive dependencies.
+
+/* eslint-disable */
+var jsonlint = (function () {
+  var parser = {
+    trace: function trace() {},
+    yy: {},
+    symbols_: {
+      error: 2,
+      JSONString: 3,
+      STRING: 4,
+      JSONNumber: 5,
+      NUMBER: 6,
+      JSONNullLiteral: 7,
+      NULL: 8,
+      JSONBooleanLiteral: 9,
+      TRUE: 10,
+      FALSE: 11,
+      JSONText: 12,
+      JSONValue: 13,
+      EOF: 14,
+      JSONObject: 15,
+      JSONArray: 16,
+      '{': 17,
+      '}': 18,
+      JSONMemberList: 19,
+      JSONMember: 20,
+      ':': 21,
+      ',': 22,
+      '[': 23,
+      ']': 24,
+      JSONElementList: 25,
+      $accept: 0,
+      $end: 1
+    },
+    terminals_: {
+      2: 'error',
+      4: 'STRING',
+      6: 'NUMBER',
+      8: 'NULL',
+      10: 'TRUE',
+      11: 'FALSE',
+      14: 'EOF',
+      17: '{',
+      18: '}',
+      21: ':',
+      22: ',',
+      23: '[',
+      24: ']'
+    },
+    productions_: [
+      0,
+      [3, 1],
+      [5, 1],
+      [7, 1],
+      [9, 1],
+      [9, 1],
+      [12, 2],
+      [13, 1],
+      [13, 1],
+      [13, 1],
+      [13, 1],
+      [13, 1],
+      [13, 1],
+      [15, 2],
+      [15, 3],
+      [20, 3],
+      [19, 1],
+      [19, 3],
+      [16, 2],
+      [16, 3],
+      [25, 1],
+      [25, 3]
+    ],
+    performAction: function anonymous(
+      yytext,
+      yyleng,
+      yylineno,
+      yy,
+      yystate,
+      $$,
+      _$
+    ) {
+      var $0 = $$.length - 1;
+
+      switch (yystate) {
+        case 1:
+          // replace escaped characters with actual character
+          this.$ = yytext
+            .replace(/\\(\\|")/g, '$' + '1')
+            .replace(/\\n/g, '\n')
+            .replace(/\\r/g, '\r')
+            .replace(/\\t/g, '\t')
+            .replace(/\\v/g, '\v')
+            .replace(/\\f/g, '\f')
+            .replace(/\\b/g, '\b');
+          break;
+
+        case 2:
+          this.$ = Number(yytext);
+          break;
+
+        case 3:
+          this.$ = null;
+          break;
+
+        case 4:
+          this.$ = true;
+          break;
+
+        case 5:
+          this.$ = false;
+          break;
+
+        case 6:
+          return (this.$ = $$[$0 - 1]);
+          break;
+
+        case 13:
+          this.$ = {};
+          break;
+
+        case 14:
+          this.$ = $$[$0 - 1];
+          break;
+
+        case 15:
+          this.$ = [$$[$0 - 2], $$[$0]];
+          break;
+
+        case 16:
+          this.$ = {};
+          this.$[$$[$0][0]] = $$[$0][1];
+          break;
+
+        case 17:
+          this.$ = $$[$0 - 2];
+          $$[$0 - 2][$$[$0][0]] = $$[$0][1];
+          break;
+
+        case 18:
+          this.$ = [];
+          break;
+
+        case 19:
+          this.$ = $$[$0 - 1];
+          break;
+
+        case 20:
+          this.$ = [$$[$0]];
+          break;
+
+        case 21:
+          this.$ = $$[$0 - 2];
+          $$[$0 - 2].push($$[$0]);
+          break;
+      }
+    },
+    table: [
+      {
+        3: 5,
+        4: [1, 12],
+        5: 6,
+        6: [1, 13],
+        7: 3,
+        8: [1, 9],
+        9: 4,
+        10: [1, 10],
+        11: [1, 11],
+        12: 1,
+        13: 2,
+        15: 7,
+        16: 8,
+        17: [1, 14],
+        23: [1, 15]
+      },
+      {
+        1: [3]
+      },
+      {
+        14: [1, 16]
+      },
+      {
+        14: [2, 7],
+        18: [2, 7],
+        22: [2, 7],
+        24: [2, 7]
+      },
+      {
+        14: [2, 8],
+        18: [2, 8],
+        22: [2, 8],
+        24: [2, 8]
+      },
+      {
+        14: [2, 9],
+        18: [2, 9],
+        22: [2, 9],
+        24: [2, 9]
+      },
+      {
+        14: [2, 10],
+        18: [2, 10],
+        22: [2, 10],
+        24: [2, 10]
+      },
+      {
+        14: [2, 11],
+        18: [2, 11],
+        22: [2, 11],
+        24: [2, 11]
+      },
+      {
+        14: [2, 12],
+        18: [2, 12],
+        22: [2, 12],
+        24: [2, 12]
+      },
+      {
+        14: [2, 3],
+        18: [2, 3],
+        22: [2, 3],
+        24: [2, 3]
+      },
+      {
+        14: [2, 4],
+        18: [2, 4],
+        22: [2, 4],
+        24: [2, 4]
+      },
+      {
+        14: [2, 5],
+        18: [2, 5],
+        22: [2, 5],
+        24: [2, 5]
+      },
+      {
+        14: [2, 1],
+        18: [2, 1],
+        21: [2, 1],
+        22: [2, 1],
+        24: [2, 1]
+      },
+      {
+        14: [2, 2],
+        18: [2, 2],
+        22: [2, 2],
+        24: [2, 2]
+      },
+      {
+        3: 20,
+        4: [1, 12],
+        18: [1, 17],
+        19: 18,
+        20: 19
+      },
+      {
+        3: 5,
+        4: [1, 12],
+        5: 6,
+        6: [1, 13],
+        7: 3,
+        8: [1, 9],
+        9: 4,
+        10: [1, 10],
+        11: [1, 11],
+        13: 23,
+        15: 7,
+        16: 8,
+        17: [1, 14],
+        23: [1, 15],
+        24: [1, 21],
+        25: 22
+      },
+      {
+        1: [2, 6]
+      },
+      {
+        14: [2, 13],
+        18: [2, 13],
+        22: [2, 13],
+        24: [2, 13]
+      },
+      {
+        18: [1, 24],
+        22: [1, 25]
+      },
+      {
+        18: [2, 16],
+        22: [2, 16]
+      },
+      {
+        21: [1, 26]
+      },
+      {
+        14: [2, 18],
+        18: [2, 18],
+        22: [2, 18],
+        24: [2, 18]
+      },
+      {
+        22: [1, 28],
+        24: [1, 27]
+      },
+      {
+        22: [2, 20],
+        24: [2, 20]
+      },
+      {
+        14: [2, 14],
+        18: [2, 14],
+        22: [2, 14],
+        24: [2, 14]
+      },
+      {
+        3: 20,
+        4: [1, 12],
+        20: 29
+      },
+      {
+        3: 5,
+        4: [1, 12],
+        5: 6,
+        6: [1, 13],
+        7: 3,
+        8: [1, 9],
+        9: 4,
+        10: [1, 10],
+        11: [1, 11],
+        13: 30,
+        15: 7,
+        16: 8,
+        17: [1, 14],
+        23: [1, 15]
+      },
+      {
+        14: [2, 19],
+        18: [2, 19],
+        22: [2, 19],
+        24: [2, 19]
+      },
+      {
+        3: 5,
+        4: [1, 12],
+        5: 6,
+        6: [1, 13],
+        7: 3,
+        8: [1, 9],
+        9: 4,
+        10: [1, 10],
+        11: [1, 11],
+        13: 31,
+        15: 7,
+        16: 8,
+        17: [1, 14],
+        23: [1, 15]
+      },
+      {
+        18: [2, 17],
+        22: [2, 17]
+      },
+      {
+        18: [2, 15],
+        22: [2, 15]
+      },
+      {
+        22: [2, 21],
+        24: [2, 21]
+      }
+    ],
+    defaultActions: {
+      16: [2, 6]
+    },
+    parseError: function parseError(str, hash) {
+      throw new Error(str);
+    },
+    parse: function parse(input) {
+      var self = this,
+        stack = [0],
+        vstack = [null],
+        // semantic value stack
+        lstack = [],
+        // location stack
+        table = this.table,
+        yytext = '',
+        yylineno = 0,
+        yyleng = 0,
+        recovering = 0,
+        TERROR = 2,
+        EOF = 1; //this.reductionCount = this.shiftCount = 0;
+
+      this.lexer.setInput(input);
+      this.lexer.yy = this.yy;
+      this.yy.lexer = this.lexer;
+      if (typeof this.lexer.yylloc == 'undefined') this.lexer.yylloc = {};
+      var yyloc = this.lexer.yylloc;
+      lstack.push(yyloc);
+      if (typeof this.yy.parseError === 'function')
+        this.parseError = this.yy.parseError;
+
+      function popStack(n) {
+        stack.length = stack.length - 2 * n;
+        vstack.length = vstack.length - n;
+        lstack.length = lstack.length - n;
+      }
+
+      function lex() {
+        var token;
+        token = self.lexer.lex() || 1; // $end = 1
+        // if token isn't its numeric value, convert
+
+        if (typeof token !== 'number') {
+          token = self.symbols_[token] || token;
+        }
+
+        return token;
+      }
+
+      var symbol,
+        preErrorSymbol,
+        state,
+        action,
+        a,
+        r,
+        yyval = {},
+        p,
+        len,
+        newState,
+        expected;
+
+      while (true) {
+        // retrieve state number from top of stack
+        state = stack[stack.length - 1]; // use default actions if available
+
+        if (this.defaultActions[state]) {
+          action = this.defaultActions[state];
+        } else {
+          if (symbol == null) symbol = lex(); // read action for current state and first input
+
+          action = table[state] && table[state][symbol];
+        } // handle parse error
+
+        _handle_error: if (
+          typeof action === 'undefined' ||
+          !action.length ||
+          !action[0]
+        ) {
+          if (!recovering) {
+            // Report error
+            expected = [];
+
+            for (p in table[state])
+              if (this.terminals_[p] && p > 2) {
+                expected.push("'" + this.terminals_[p] + "'");
+              }
+
+            var errStr = '';
+
+            if (this.lexer.showPosition) {
+              errStr =
+                'Parse error on line ' +
+                (yylineno + 1) +
+                ':\n' +
+                this.lexer.showPosition() +
+                '\nExpecting ' +
+                expected.join(', ') +
+                ", got '" +
+                this.terminals_[symbol] +
+                "'";
+            } else {
+              errStr =
+                'Parse error on line ' +
+                (yylineno + 1) +
+                ': Unexpected ' +
+                (symbol == 1
+                  ? /*EOF*/
+                    'end of input'
+                  : "'" + (this.terminals_[symbol] || symbol) + "'");
+            }
+
+            this.parseError(errStr, {
+              text: this.lexer.match,
+              token: this.terminals_[symbol] || symbol,
+              line: this.lexer.yylineno,
+              loc: yyloc,
+              expected: expected
+            });
+          } // just recovered from another error
+
+          if (recovering == 3) {
+            if (symbol == EOF) {
+              throw new Error(errStr || 'Parsing halted.');
+            } // discard current lookahead and grab another
+
+            yyleng = this.lexer.yyleng;
+            yytext = this.lexer.yytext;
+            yylineno = this.lexer.yylineno;
+            yyloc = this.lexer.yylloc;
+            symbol = lex();
+          } // try to recover from error
+
+          while (1) {
+            // check for error recovery rule in this state
+            if (TERROR.toString() in table[state]) {
+              break;
+            }
+
+            if (state == 0) {
+              throw new Error(errStr || 'Parsing halted.');
+            }
+
+            popStack(1);
+            state = stack[stack.length - 1];
+          }
+
+          preErrorSymbol = symbol; // save the lookahead token
+
+          symbol = TERROR; // insert generic error symbol as new lookahead
+
+          state = stack[stack.length - 1];
+          action = table[state] && table[state][TERROR];
+          recovering = 3; // allow 3 real symbols to be shifted before reporting a new error
+        } // this shouldn't happen, unless resolve defaults are off
+
+        if (action[0] instanceof Array && action.length > 1) {
+          throw new Error(
+            'Parse Error: multiple actions possible at state: ' +
+              state +
+              ', token: ' +
+              symbol
+          );
+        }
+
+        switch (action[0]) {
+          case 1:
+            // shift
+            //this.shiftCount++;
+            stack.push(symbol);
+            vstack.push(this.lexer.yytext);
+            lstack.push(this.lexer.yylloc);
+            stack.push(action[1]); // push state
+
+            symbol = null;
+
+            if (!preErrorSymbol) {
+              // normal execution/no error
+              yyleng = this.lexer.yyleng;
+              yytext = this.lexer.yytext;
+              yylineno = this.lexer.yylineno;
+              yyloc = this.lexer.yylloc;
+              if (recovering > 0) recovering--;
+            } else {
+              // error just occurred, resume old lookahead f/ before error
+              symbol = preErrorSymbol;
+              preErrorSymbol = null;
+            }
+
+            break;
+
+          case 2:
+            // reduce
+            //this.reductionCount++;
+            len = this.productions_[action[1]][1]; // perform semantic action
+
+            yyval.$ = vstack[vstack.length - len]; // default to $$ = $1
+            // default location, uses first token for firsts, last for lasts
+
+            yyval._$ = {
+              first_line: lstack[lstack.length - (len || 1)].first_line,
+              last_line: lstack[lstack.length - 1].last_line,
+              first_column: lstack[lstack.length - (len || 1)].first_column,
+              last_column: lstack[lstack.length - 1].last_column
+            };
+            r = this.performAction.call(
+              yyval,
+              yytext,
+              yyleng,
+              yylineno,
+              this.yy,
+              action[1],
+              vstack,
+              lstack
+            );
+
+            if (typeof r !== 'undefined') {
+              return r;
+            } // pop off stack
+
+            if (len) {
+              stack = stack.slice(0, -1 * len * 2);
+              vstack = vstack.slice(0, -1 * len);
+              lstack = lstack.slice(0, -1 * len);
+            }
+
+            stack.push(this.productions_[action[1]][0]); // push nonterminal (reduce)
+
+            vstack.push(yyval.$);
+            lstack.push(yyval._$); // goto new state = table[STATE][NONTERMINAL]
+
+            newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
+            stack.push(newState);
+            break;
+
+          case 3:
+            // accept
+            return true;
+        }
+      }
+
+      return true;
+    }
+  };
+  /* Jison generated lexer */
+
+  var lexer = (function () {
+    var lexer = {
+      EOF: 1,
+      parseError: function parseError(str, hash) {
+        if (this.yy.parseError) {
+          this.yy.parseError(str, hash);
+        } else {
+          throw new Error(str);
+        }
+      },
+      setInput: function (input) {
+        this._input = input;
+        this._more = this._less = this.done = false;
+        this.yylineno = this.yyleng = 0;
+        this.yytext = this.matched = this.match = '';
+        this.conditionStack = ['INITIAL'];
+        this.yylloc = {
+          first_line: 1,
+          first_column: 0,
+          last_line: 1,
+          last_column: 0
+        };
+        return this;
+      },
+      input: function () {
+        var ch = this._input[0];
+        this.yytext += ch;
+        this.yyleng++;
+        this.match += ch;
+        this.matched += ch;
+        var lines = ch.match(/\n/);
+        if (lines) this.yylineno++;
+        this._input = this._input.slice(1);
+        return ch;
+      },
+      unput: function (ch) {
+        this._input = ch + this._input;
+        return this;
+      },
+      more: function () {
+        this._more = true;
+        return this;
+      },
+      less: function (n) {
+        this._input = this.match.slice(n) + this._input;
+      },
+      pastInput: function () {
+        var past = this.matched.substr(
+          0,
+          this.matched.length - this.match.length
+        );
+        return (
+          (past.length > 20 ? '...' : '') + past.substr(-20).replace(/\n/g, '')
+        );
+      },
+      upcomingInput: function () {
+        var next = this.match;
+
+        if (next.length < 20) {
+          next += this._input.substr(0, 20 - next.length);
+        }
+
+        return (next.substr(0, 20) + (next.length > 20 ? '...' : '')).replace(
+          /\n/g,
+          ''
+        );
+      },
+      showPosition: function () {
+        var pre = this.pastInput();
+        var c = new Array(pre.length + 1).join('-');
+        return pre + this.upcomingInput() + '\n' + c + '^';
+      },
+      next: function () {
+        if (this.done) {
+          return this.EOF;
+        }
+
+        if (!this._input) this.done = true;
+        var token, match, tempMatch, index, col, lines;
+
+        if (!this._more) {
+          this.yytext = '';
+          this.match = '';
+        }
+
+        var rules = this._currentRules();
+
+        for (var i = 0; i < rules.length; i++) {
+          tempMatch = this._input.match(this.rules[rules[i]]);
+
+          if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
+            match = tempMatch;
+            index = i;
+            if (!this.options.flex) break;
+          }
+        }
+
+        if (match) {
+          lines = match[0].match(/\n.*/g);
+          if (lines) this.yylineno += lines.length;
+          this.yylloc = {
+            first_line: this.yylloc.last_line,
+            last_line: this.yylineno + 1,
+            first_column: this.yylloc.last_column,
+            last_column: lines
+              ? lines[lines.length - 1].length - 1
+              : this.yylloc.last_column + match[0].length
+          };
+          this.yytext += match[0];
+          this.match += match[0];
+          this.yyleng = this.yytext.length;
+          this._more = false;
+          this._input = this._input.slice(match[0].length);
+          this.matched += match[0];
+          token = this.performAction.call(
+            this,
+            this.yy,
+            this,
+            rules[index],
+            this.conditionStack[this.conditionStack.length - 1]
+          );
+          if (this.done && this._input) this.done = false;
+          if (token) return token;
+          else return;
+        }
+
+        if (this._input === '') {
+          return this.EOF;
+        } else {
+          this.parseError(
+            'Lexical error on line ' +
+              (this.yylineno + 1) +
+              '. Unrecognized text.\n' +
+              this.showPosition(),
+            {
+              text: '',
+              token: null,
+              line: this.yylineno
+            }
+          );
+        }
+      },
+      lex: function lex() {
+        var r = this.next();
+
+        if (typeof r !== 'undefined') {
+          return r;
+        } else {
+          return this.lex();
+        }
+      },
+      begin: function begin(condition) {
+        this.conditionStack.push(condition);
+      },
+      popState: function popState() {
+        return this.conditionStack.pop();
+      },
+      _currentRules: function _currentRules() {
+        return this.conditions[
+          this.conditionStack[this.conditionStack.length - 1]
+        ].rules;
+      },
+      topState: function () {
+        return this.conditionStack[this.conditionStack.length - 2];
+      },
+      pushState: function begin(condition) {
+        this.begin(condition);
+      }
+    };
+    lexer.options = {};
+
+    lexer.performAction = function anonymous(
+      yy,
+      yy_,
+      $avoiding_name_collisions,
+      YY_START
+    ) {
+      var YYSTATE = YY_START;
+
+      switch ($avoiding_name_collisions) {
+        case 0:
+          /* skip whitespace */
+          break;
+
+        case 1:
+          return 6;
+          break;
+
+        case 2:
+          yy_.yytext = yy_.yytext.substr(1, yy_.yyleng - 2);
+          return 4;
+          break;
+
+        case 3:
+          return 17;
+          break;
+
+        case 4:
+          return 18;
+          break;
+
+        case 5:
+          return 23;
+          break;
+
+        case 6:
+          return 24;
+          break;
+
+        case 7:
+          return 22;
+          break;
+
+        case 8:
+          return 21;
+          break;
+
+        case 9:
+          return 10;
+          break;
+
+        case 10:
+          return 11;
+          break;
+
+        case 11:
+          return 8;
+          break;
+
+        case 12:
+          return 14;
+          break;
+
+        case 13:
+          return 'INVALID';
+          break;
+      }
+    };
+
+    lexer.rules = [
+      /^(?:\s+)/,
+      /^(?:(-?([0-9]|[1-9][0-9]+))(\.[0-9]+)?([eE][-+]?[0-9]+)?\b)/,
+      /^(?:"(?:\\[\\"bfnrt/]|\\u[a-fA-F0-9]{4}|[^\\\0-\x09\x0a-\x1f"])*")/,
+      /^(?:\{)/,
+      /^(?:\})/,
+      /^(?:\[)/,
+      /^(?:\])/,
+      /^(?:,)/,
+      /^(?::)/,
+      /^(?:true\b)/,
+      /^(?:false\b)/,
+      /^(?:null\b)/,
+      /^(?:$)/,
+      /^(?:.)/
+    ];
+    lexer.conditions = {
+      INITIAL: {
+        rules: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13],
+        inclusive: true
+      }
+    };
+    return lexer;
+  })();
+
+  parser.lexer = lexer;
+  return parser;
+})();
+
+exports.parser = jsonlint;
+
+exports.errors = function (input) {
+  try {
+    this.parse(input);
+  } catch (e) {
+    return e.stack;
+  }
+};
+
+exports.parse = function () {
+  return jsonlint.parse.apply(jsonlint, arguments);
+};
+
+exports.main = function commonjsMain(args) {
+  if (!args[1]) throw new Error('Usage: ' + args[0] + ' FILE');
+
+  if (typeof process !== 'undefined') {
+    var source = require('fs').readFileSync(
+      require('path').join(process.cwd(), args[1]),
+      'utf8'
+    );
+  } else {
+    var cwd = require('file').path(require('file').cwd());
+
+    var source = cwd.join(args[1]).read({
+      charset: 'utf-8'
+    });
+  }
+
+  return exports.parser.parse(source);
+};

web/node_modules/jest-config/node_modules/@jest/types/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.

web/node_modules/jest-config/node_modules/@jest/types/build/Circus.d.ts

@@ -0,0 +1,191 @@
+/**
+ * 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 * as Global from './Global';
+declare type Process = NodeJS.Process;
+export declare type DoneFn = Global.DoneFn;
+export declare type BlockFn = Global.BlockFn;
+export declare type BlockName = Global.BlockName;
+export declare type BlockMode = void | 'skip' | 'only' | 'todo';
+export declare type TestMode = BlockMode;
+export declare type TestName = Global.TestName;
+export declare type TestFn = Global.TestFn;
+export declare type HookFn = Global.HookFn;
+export declare type AsyncFn = TestFn | HookFn;
+export declare type SharedHookType = 'afterAll' | 'beforeAll';
+export declare type HookType = SharedHookType | 'afterEach' | 'beforeEach';
+export declare type TestContext = Record<string, unknown>;
+export declare type Exception = any;
+export declare type FormattedError = string;
+export declare type Hook = {
+    asyncError: Error;
+    fn: HookFn;
+    type: HookType;
+    parent: DescribeBlock;
+    timeout: number | undefined | null;
+};
+export interface EventHandler {
+    (event: AsyncEvent, state: State): void | Promise<void>;
+    (event: SyncEvent, state: State): void;
+}
+export declare type Event = SyncEvent | AsyncEvent;
+interface JestGlobals extends Global.TestFrameworkGlobals {
+    expect: unknown;
+}
+export declare type SyncEvent = {
+    asyncError: Error;
+    mode: BlockMode;
+    name: 'start_describe_definition';
+    blockName: BlockName;
+} | {
+    mode: BlockMode;
+    name: 'finish_describe_definition';
+    blockName: BlockName;
+} | {
+    asyncError: Error;
+    name: 'add_hook';
+    hookType: HookType;
+    fn: HookFn;
+    timeout: number | undefined;
+} | {
+    asyncError: Error;
+    name: 'add_test';
+    testName: TestName;
+    fn: TestFn;
+    mode?: TestMode;
+    timeout: number | undefined;
+} | {
+    name: 'error';
+    error: Exception;
+};
+export declare type AsyncEvent = {
+    name: 'setup';
+    testNamePattern?: string;
+    runtimeGlobals: JestGlobals;
+    parentProcess: Process;
+} | {
+    name: 'include_test_location_in_result';
+} | {
+    name: 'hook_start';
+    hook: Hook;
+} | {
+    name: 'hook_success';
+    describeBlock?: DescribeBlock;
+    test?: TestEntry;
+    hook: Hook;
+} | {
+    name: 'hook_failure';
+    error: string | Exception;
+    describeBlock?: DescribeBlock;
+    test?: TestEntry;
+    hook: Hook;
+} | {
+    name: 'test_fn_start';
+    test: TestEntry;
+} | {
+    name: 'test_fn_success';
+    test: TestEntry;
+} | {
+    name: 'test_fn_failure';
+    error: Exception;
+    test: TestEntry;
+} | {
+    name: 'test_retry';
+    test: TestEntry;
+} | {
+    name: 'test_start';
+    test: TestEntry;
+} | {
+    name: 'test_skip';
+    test: TestEntry;
+} | {
+    name: 'test_todo';
+    test: TestEntry;
+} | {
+    name: 'test_done';
+    test: TestEntry;
+} | {
+    name: 'run_describe_start';
+    describeBlock: DescribeBlock;
+} | {
+    name: 'run_describe_finish';
+    describeBlock: DescribeBlock;
+} | {
+    name: 'run_start';
+} | {
+    name: 'run_finish';
+} | {
+    name: 'teardown';
+};
+export declare type MatcherResults = {
+    actual: unknown;
+    expected: unknown;
+    name: string;
+    pass: boolean;
+};
+export declare type TestStatus = 'skip' | 'done' | 'todo';
+export declare type TestResult = {
+    duration?: number | null;
+    errors: Array<FormattedError>;
+    errorsDetailed: Array<MatcherResults | unknown>;
+    invocations: number;
+    status: TestStatus;
+    location?: {
+        column: number;
+        line: number;
+    } | null;
+    testPath: Array<TestName | BlockName>;
+};
+export declare type RunResult = {
+    unhandledErrors: Array<FormattedError>;
+    testResults: TestResults;
+};
+export declare type TestResults = Array<TestResult>;
+export declare type GlobalErrorHandlers = {
+    uncaughtException: Array<(exception: Exception) => void>;
+    unhandledRejection: Array<(exception: Exception, promise: Promise<unknown>) => void>;
+};
+export declare type State = {
+    currentDescribeBlock: DescribeBlock;
+    currentlyRunningTest?: TestEntry | null;
+    expand?: boolean;
+    hasFocusedTests: boolean;
+    hasStarted: boolean;
+    originalGlobalErrorHandlers?: GlobalErrorHandlers;
+    parentProcess: Process | null;
+    rootDescribeBlock: DescribeBlock;
+    testNamePattern?: RegExp | null;
+    testTimeout: number;
+    unhandledErrors: Array<Exception>;
+    includeTestLocationInResult: boolean;
+};
+export declare type DescribeBlock = {
+    type: 'describeBlock';
+    children: Array<DescribeBlock | TestEntry>;
+    hooks: Array<Hook>;
+    mode: BlockMode;
+    name: BlockName;
+    parent?: DescribeBlock;
+    /** @deprecated Please get from `children` array instead */
+    tests: Array<TestEntry>;
+};
+export declare type TestError = Exception | [Exception | undefined, Exception];
+export declare type TestEntry = {
+    type: 'test';
+    asyncError: Exception;
+    errors: Array<TestError>;
+    fn: TestFn;
+    invocations: number;
+    mode: TestMode;
+    name: TestName;
+    parent: DescribeBlock;
+    startedAt?: number | null;
+    duration?: number | null;
+    status?: TestStatus | null;
+    timeout?: number;
+};
+export {};

web/node_modules/jest-config/node_modules/@jest/types/build/Circus.js

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

web/node_modules/jest-config/node_modules/@jest/types/build/Config.d.ts

@@ -0,0 +1,433 @@
+/**
+ * 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 { ForegroundColor } from 'chalk';
+import type { ReportOptions } from 'istanbul-reports';
+import type { Arguments } from 'yargs';
+declare type CoverageProvider = 'babel' | 'v8';
+declare type Timers = 'real' | 'fake' | 'modern' | 'legacy';
+export declare type Path = string;
+export declare type Glob = string;
+export declare type HasteConfig = {
+    /** Whether to hash files using SHA-1. */
+    computeSha1?: boolean;
+    /** The platform to use as the default, e.g. 'ios'. */
+    defaultPlatform?: string | null;
+    /** Path to a custom implementation of Haste. */
+    hasteImplModulePath?: string;
+    /** All platforms to target, e.g ['ios', 'android']. */
+    platforms?: Array<string>;
+    /** Whether to throw on error on module collision. */
+    throwOnModuleCollision?: boolean;
+};
+export declare type CoverageReporterName = keyof ReportOptions;
+export declare type CoverageReporterWithOptions<K = CoverageReporterName> = K extends CoverageReporterName ? ReportOptions[K] extends never ? never : [K, Partial<ReportOptions[K]>] : never;
+export declare type CoverageReporters = Array<CoverageReporterName | CoverageReporterWithOptions>;
+export declare type ReporterConfig = [string, Record<string, unknown>];
+export declare type TransformerConfig = [string, Record<string, unknown>];
+export interface ConfigGlobals {
+    [K: string]: unknown;
+}
+export declare type DefaultOptions = {
+    automock: boolean;
+    bail: number;
+    cache: boolean;
+    cacheDirectory: Path;
+    changedFilesWithAncestor: boolean;
+    clearMocks: boolean;
+    collectCoverage: boolean;
+    coveragePathIgnorePatterns: Array<string>;
+    coverageReporters: Array<CoverageReporterName>;
+    coverageProvider: CoverageProvider;
+    errorOnDeprecated: boolean;
+    expand: boolean;
+    forceCoverageMatch: Array<Glob>;
+    globals: ConfigGlobals;
+    haste: HasteConfig;
+    injectGlobals: boolean;
+    maxConcurrency: number;
+    maxWorkers: number | string;
+    moduleDirectories: Array<string>;
+    moduleFileExtensions: Array<string>;
+    moduleNameMapper: Record<string, string | Array<string>>;
+    modulePathIgnorePatterns: Array<string>;
+    noStackTrace: boolean;
+    notify: boolean;
+    notifyMode: NotifyMode;
+    prettierPath: string;
+    resetMocks: boolean;
+    resetModules: boolean;
+    restoreMocks: boolean;
+    roots: Array<Path>;
+    runTestsByPath: boolean;
+    runner: 'jest-runner';
+    setupFiles: Array<Path>;
+    setupFilesAfterEnv: Array<Path>;
+    skipFilter: boolean;
+    slowTestThreshold: number;
+    snapshotSerializers: Array<Path>;
+    testEnvironment: string;
+    testEnvironmentOptions: Record<string, unknown>;
+    testFailureExitCode: string | number;
+    testLocationInResults: boolean;
+    testMatch: Array<Glob>;
+    testPathIgnorePatterns: Array<string>;
+    testRegex: Array<string>;
+    testRunner: string;
+    testSequencer: string;
+    testURL: string;
+    timers: Timers;
+    transformIgnorePatterns: Array<Glob>;
+    useStderr: boolean;
+    watch: boolean;
+    watchPathIgnorePatterns: Array<string>;
+    watchman: boolean;
+};
+export declare type DisplayName = {
+    name: string;
+    color: typeof ForegroundColor;
+};
+export declare type InitialOptionsWithRootDir = InitialOptions & Required<Pick<InitialOptions, 'rootDir'>>;
+export declare type InitialOptions = Partial<{
+    automock: boolean;
+    bail: boolean | number;
+    cache: boolean;
+    cacheDirectory: Path;
+    clearMocks: boolean;
+    changedFilesWithAncestor: boolean;
+    changedSince: string;
+    collectCoverage: boolean;
+    collectCoverageFrom: Array<Glob>;
+    collectCoverageOnlyFrom: {
+        [key: string]: boolean;
+    };
+    coverageDirectory: string;
+    coveragePathIgnorePatterns: Array<string>;
+    coverageProvider: CoverageProvider;
+    coverageReporters: CoverageReporters;
+    coverageThreshold: {
+        global: {
+            [key: string]: number;
+        };
+    };
+    dependencyExtractor: string;
+    detectLeaks: boolean;
+    detectOpenHandles: boolean;
+    displayName: string | DisplayName;
+    expand: boolean;
+    extraGlobals: Array<string>;
+    filter: Path;
+    findRelatedTests: boolean;
+    forceCoverageMatch: Array<Glob>;
+    forceExit: boolean;
+    json: boolean;
+    globals: ConfigGlobals;
+    globalSetup: string | null | undefined;
+    globalTeardown: string | null | undefined;
+    haste: HasteConfig;
+    injectGlobals: boolean;
+    reporters: Array<string | ReporterConfig>;
+    logHeapUsage: boolean;
+    lastCommit: boolean;
+    listTests: boolean;
+    mapCoverage: boolean;
+    maxConcurrency: number;
+    maxWorkers: number | string;
+    moduleDirectories: Array<string>;
+    moduleFileExtensions: Array<string>;
+    moduleLoader: Path;
+    moduleNameMapper: {
+        [key: string]: string | Array<string>;
+    };
+    modulePathIgnorePatterns: Array<string>;
+    modulePaths: Array<string>;
+    name: string;
+    noStackTrace: boolean;
+    notify: boolean;
+    notifyMode: string;
+    onlyChanged: boolean;
+    onlyFailures: boolean;
+    outputFile: Path;
+    passWithNoTests: boolean;
+    preprocessorIgnorePatterns: Array<Glob>;
+    preset: string | null | undefined;
+    prettierPath: string | null | undefined;
+    projects: Array<Glob>;
+    replname: string | null | undefined;
+    resetMocks: boolean;
+    resetModules: boolean;
+    resolver: Path | null | undefined;
+    restoreMocks: boolean;
+    rootDir: Path;
+    roots: Array<Path>;
+    runner: string;
+    runTestsByPath: boolean;
+    scriptPreprocessor: string;
+    setupFiles: Array<Path>;
+    setupTestFrameworkScriptFile: Path;
+    setupFilesAfterEnv: Array<Path>;
+    silent: boolean;
+    skipFilter: boolean;
+    skipNodeResolution: boolean;
+    slowTestThreshold: number;
+    snapshotResolver: Path;
+    snapshotSerializers: Array<Path>;
+    errorOnDeprecated: boolean;
+    testEnvironment: string;
+    testEnvironmentOptions: Record<string, unknown>;
+    testFailureExitCode: string | number;
+    testLocationInResults: boolean;
+    testMatch: Array<Glob>;
+    testNamePattern: string;
+    testPathDirs: Array<Path>;
+    testPathIgnorePatterns: Array<string>;
+    testRegex: string | Array<string>;
+    testResultsProcessor: string;
+    testRunner: string;
+    testSequencer: string;
+    testURL: string;
+    testTimeout: number;
+    timers: Timers;
+    transform: {
+        [regex: string]: Path | TransformerConfig;
+    };
+    transformIgnorePatterns: Array<Glob>;
+    watchPathIgnorePatterns: Array<string>;
+    unmockedModulePathPatterns: Array<string>;
+    updateSnapshot: boolean;
+    useStderr: boolean;
+    verbose?: boolean;
+    watch: boolean;
+    watchAll: boolean;
+    watchman: boolean;
+    watchPlugins: Array<string | [string, Record<string, unknown>]>;
+}>;
+export declare type SnapshotUpdateState = 'all' | 'new' | 'none';
+declare type NotifyMode = 'always' | 'failure' | 'success' | 'change' | 'success-change' | 'failure-change';
+export declare type CoverageThresholdValue = {
+    branches?: number;
+    functions?: number;
+    lines?: number;
+    statements?: number;
+};
+declare type CoverageThreshold = {
+    [path: string]: CoverageThresholdValue;
+    global: CoverageThresholdValue;
+};
+export declare type GlobalConfig = {
+    bail: number;
+    changedSince?: string;
+    changedFilesWithAncestor: boolean;
+    collectCoverage: boolean;
+    collectCoverageFrom: Array<Glob>;
+    collectCoverageOnlyFrom?: {
+        [key: string]: boolean;
+    };
+    coverageDirectory: string;
+    coveragePathIgnorePatterns?: Array<string>;
+    coverageProvider: CoverageProvider;
+    coverageReporters: CoverageReporters;
+    coverageThreshold?: CoverageThreshold;
+    detectLeaks: boolean;
+    detectOpenHandles: boolean;
+    enabledTestsMap?: {
+        [key: string]: {
+            [key: string]: boolean;
+        };
+    };
+    expand: boolean;
+    filter?: Path;
+    findRelatedTests: boolean;
+    forceExit: boolean;
+    json: boolean;
+    globalSetup?: string;
+    globalTeardown?: string;
+    lastCommit: boolean;
+    logHeapUsage: boolean;
+    listTests: boolean;
+    maxConcurrency: number;
+    maxWorkers: number;
+    noStackTrace: boolean;
+    nonFlagArgs: Array<string>;
+    noSCM?: boolean;
+    notify: boolean;
+    notifyMode: NotifyMode;
+    outputFile?: Path;
+    onlyChanged: boolean;
+    onlyFailures: boolean;
+    passWithNoTests: boolean;
+    projects: Array<Glob>;
+    replname?: string;
+    reporters?: Array<string | ReporterConfig>;
+    runTestsByPath: boolean;
+    rootDir: Path;
+    silent?: boolean;
+    skipFilter: boolean;
+    errorOnDeprecated: boolean;
+    testFailureExitCode: number;
+    testNamePattern?: string;
+    testPathPattern: string;
+    testResultsProcessor?: string;
+    testSequencer: string;
+    testTimeout?: number;
+    updateSnapshot: SnapshotUpdateState;
+    useStderr: boolean;
+    verbose?: boolean;
+    watch: boolean;
+    watchAll: boolean;
+    watchman: boolean;
+    watchPlugins?: Array<{
+        path: string;
+        config: Record<string, unknown>;
+    }> | null;
+};
+export declare type ProjectConfig = {
+    automock: boolean;
+    cache: boolean;
+    cacheDirectory: Path;
+    clearMocks: boolean;
+    coveragePathIgnorePatterns: Array<string>;
+    cwd: Path;
+    dependencyExtractor?: string;
+    detectLeaks: boolean;
+    detectOpenHandles: boolean;
+    displayName?: DisplayName;
+    errorOnDeprecated: boolean;
+    extraGlobals: Array<keyof NodeJS.Global>;
+    filter?: Path;
+    forceCoverageMatch: Array<Glob>;
+    globalSetup?: string;
+    globalTeardown?: string;
+    globals: ConfigGlobals;
+    haste: HasteConfig;
+    injectGlobals: boolean;
+    moduleDirectories: Array<string>;
+    moduleFileExtensions: Array<string>;
+    moduleLoader?: Path;
+    moduleNameMapper: Array<[string, string]>;
+    modulePathIgnorePatterns: Array<string>;
+    modulePaths?: Array<string>;
+    name: string;
+    prettierPath: string;
+    resetMocks: boolean;
+    resetModules: boolean;
+    resolver?: Path;
+    restoreMocks: boolean;
+    rootDir: Path;
+    roots: Array<Path>;
+    runner: string;
+    setupFiles: Array<Path>;
+    setupFilesAfterEnv: Array<Path>;
+    skipFilter: boolean;
+    skipNodeResolution?: boolean;
+    slowTestThreshold: number;
+    snapshotResolver?: Path;
+    snapshotSerializers: Array<Path>;
+    testEnvironment: string;
+    testEnvironmentOptions: Record<string, unknown>;
+    testMatch: Array<Glob>;
+    testLocationInResults: boolean;
+    testPathIgnorePatterns: Array<string>;
+    testRegex: Array<string | RegExp>;
+    testRunner: string;
+    testURL: string;
+    timers: Timers;
+    transform: Array<[string, Path, Record<string, unknown>]>;
+    transformIgnorePatterns: Array<Glob>;
+    watchPathIgnorePatterns: Array<string>;
+    unmockedModulePathPatterns?: Array<string>;
+};
+export declare type Argv = Arguments<Partial<{
+    all: boolean;
+    automock: boolean;
+    bail: boolean | number;
+    cache: boolean;
+    cacheDirectory: string;
+    changedFilesWithAncestor: boolean;
+    changedSince: string;
+    ci: boolean;
+    clearCache: boolean;
+    clearMocks: boolean;
+    collectCoverage: boolean;
+    collectCoverageFrom: string;
+    collectCoverageOnlyFrom: Array<string>;
+    color: boolean;
+    colors: boolean;
+    config: string;
+    coverage: boolean;
+    coverageDirectory: string;
+    coveragePathIgnorePatterns: Array<string>;
+    coverageReporters: Array<string>;
+    coverageThreshold: string;
+    debug: boolean;
+    env: string;
+    expand: boolean;
+    findRelatedTests: boolean;
+    forceExit: boolean;
+    globals: string;
+    globalSetup: string | null | undefined;
+    globalTeardown: string | null | undefined;
+    haste: string;
+    init: boolean;
+    injectGlobals: boolean;
+    json: boolean;
+    lastCommit: boolean;
+    logHeapUsage: boolean;
+    maxWorkers: number | string;
+    moduleDirectories: Array<string>;
+    moduleFileExtensions: Array<string>;
+    moduleNameMapper: string;
+    modulePathIgnorePatterns: Array<string>;
+    modulePaths: Array<string>;
+    noStackTrace: boolean;
+    notify: boolean;
+    notifyMode: string;
+    onlyChanged: boolean;
+    onlyFailures: boolean;
+    outputFile: string;
+    preset: string | null | undefined;
+    projects: Array<string>;
+    prettierPath: string | null | undefined;
+    resetMocks: boolean;
+    resetModules: boolean;
+    resolver: string | null | undefined;
+    restoreMocks: boolean;
+    rootDir: string;
+    roots: Array<string>;
+    runInBand: boolean;
+    selectProjects: Array<string>;
+    setupFiles: Array<string>;
+    setupFilesAfterEnv: Array<string>;
+    showConfig: boolean;
+    silent: boolean;
+    snapshotSerializers: Array<string>;
+    testEnvironment: string;
+    testFailureExitCode: string | null | undefined;
+    testMatch: Array<string>;
+    testNamePattern: string;
+    testPathIgnorePatterns: Array<string>;
+    testPathPattern: Array<string>;
+    testRegex: string | Array<string>;
+    testResultsProcessor: string;
+    testRunner: string;
+    testSequencer: string;
+    testURL: string;
+    testTimeout: number | null | undefined;
+    timers: string;
+    transform: string;
+    transformIgnorePatterns: Array<string>;
+    unmockedModulePathPatterns: Array<string> | null | undefined;
+    updateSnapshot: boolean;
+    useStderr: boolean;
+    verbose: boolean;
+    version: boolean;
+    watch: boolean;
+    watchAll: boolean;
+    watchman: boolean;
+    watchPathIgnorePatterns: Array<string>;
+}>>;
+export {};

web/node_modules/jest-config/node_modules/@jest/types/build/Config.js

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

web/node_modules/jest-config/node_modules/@jest/types/build/Global.d.ts

@@ -0,0 +1,88 @@
+/**
+ * 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 { CoverageMapData } from 'istanbul-lib-coverage';
+export declare type DoneFn = (reason?: string | Error) => void;
+export declare type TestName = string;
+export declare type TestFn = (done?: DoneFn) => Promise<void | undefined | unknown> | void | undefined;
+export declare type ConcurrentTestFn = (done?: DoneFn) => Promise<void | undefined | unknown>;
+export declare type BlockFn = () => void;
+export declare type BlockName = string;
+export declare type HookFn = TestFn;
+export declare type Col = unknown;
+export declare type Row = Array<Col>;
+export declare type Table = Array<Row>;
+export declare type ArrayTable = Table | Row;
+export declare type TemplateTable = TemplateStringsArray;
+export declare type TemplateData = Array<unknown>;
+export declare type EachTable = ArrayTable | TemplateTable;
+export declare type TestCallback = BlockFn | TestFn | ConcurrentTestFn;
+export declare type EachTestFn<EachCallback extends TestCallback> = (...args: Array<any>) => ReturnType<EachCallback>;
+declare type Jasmine = {
+    _DEFAULT_TIMEOUT_INTERVAL?: number;
+    addMatchers: (matchers: Record<string, unknown>) => void;
+};
+declare type Each<EachCallback extends TestCallback> = ((table: EachTable, ...taggedTemplateData: Array<unknown>) => (title: string, test: EachTestFn<EachCallback>, timeout?: number) => void) | (() => () => void);
+export interface HookBase {
+    (fn: HookFn, timeout?: number): void;
+}
+export interface ItBase {
+    (testName: TestName, fn: TestFn, timeout?: number): void;
+    each: Each<TestFn>;
+}
+export interface It extends ItBase {
+    only: ItBase;
+    skip: ItBase;
+    todo: (testName: TestName) => void;
+}
+export interface ItConcurrentBase {
+    (testName: string, testFn: ConcurrentTestFn, timeout?: number): void;
+    each: Each<ConcurrentTestFn>;
+}
+export interface ItConcurrentExtended extends ItConcurrentBase {
+    only: ItConcurrentBase;
+    skip: ItConcurrentBase;
+}
+export interface ItConcurrent extends It {
+    concurrent: ItConcurrentExtended;
+}
+export interface DescribeBase {
+    (blockName: BlockName, blockFn: BlockFn): void;
+    each: Each<BlockFn>;
+}
+export interface Describe extends DescribeBase {
+    only: DescribeBase;
+    skip: DescribeBase;
+}
+export interface TestFrameworkGlobals {
+    it: ItConcurrent;
+    test: ItConcurrent;
+    fit: ItBase & {
+        concurrent?: ItConcurrentBase;
+    };
+    xit: ItBase;
+    xtest: ItBase;
+    describe: Describe;
+    xdescribe: DescribeBase;
+    fdescribe: DescribeBase;
+    beforeAll: HookBase;
+    beforeEach: HookBase;
+    afterEach: HookBase;
+    afterAll: HookBase;
+}
+export interface GlobalAdditions extends TestFrameworkGlobals {
+    __coverage__: CoverageMapData;
+    jasmine: Jasmine;
+    fail: () => void;
+    pending: () => void;
+    spyOn: () => void;
+    spyOnProperty: () => void;
+}
+export interface Global extends GlobalAdditions, Omit<NodeJS.Global, keyof GlobalAdditions> {
+    [extras: string]: unknown;
+}
+export {};

web/node_modules/jest-config/node_modules/@jest/types/build/Global.js

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

web/node_modules/jest-config/node_modules/@jest/types/build/TestResult.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.
+ */
+export declare type Milliseconds = number;
+declare type Status = 'passed' | 'failed' | 'skipped' | 'pending' | 'todo' | 'disabled';
+declare type Callsite = {
+    column: number;
+    line: number;
+};
+export declare type AssertionResult = {
+    ancestorTitles: Array<string>;
+    duration?: Milliseconds | null;
+    failureDetails: Array<unknown>;
+    failureMessages: Array<string>;
+    fullName: string;
+    invocations?: number;
+    location?: Callsite | null;
+    numPassingAsserts: number;
+    status: Status;
+    title: string;
+};
+export declare type SerializableError = {
+    code?: unknown;
+    message: string;
+    stack: string | null | undefined;
+    type?: string;
+};
+export {};

web/node_modules/jest-config/node_modules/@jest/types/build/TestResult.js

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

web/node_modules/jest-config/node_modules/@jest/types/build/Transform.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export declare type TransformResult = {
+    code: string;
+    originalCode: string;
+    mapCoverage?: boolean;
+    sourceMapPath: string | null;
+};

web/node_modules/jest-config/node_modules/@jest/types/build/Transform.js

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

web/node_modules/jest-config/node_modules/@jest/types/build/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type * as Circus from './Circus';
+import type * as Config from './Config';
+import type * as Global from './Global';
+import type * as TestResult from './TestResult';
+import type * as TransformTypes from './Transform';
+export type { Circus, Config, Global, TestResult, TransformTypes };

web/node_modules/jest-config/node_modules/@jest/types/build/index.js

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

web/node_modules/jest-config/node_modules/@jest/types/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@jest/types",
+  "version": "26.6.2",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/facebook/jest.git",
+    "directory": "packages/jest-types"
+  },
+  "engines": {
+    "node": ">= 10.14.2"
+  },
+  "license": "MIT",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "dependencies": {
+    "@types/istanbul-lib-coverage": "^2.0.0",
+    "@types/istanbul-reports": "^3.0.0",
+    "@types/node": "*",
+    "@types/yargs": "^15.0.0",
+    "chalk": "^4.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "4c46930615602cbf983fb7e8e82884c282a624d5"
+}

web/node_modules/jest-config/node_modules/@types/yargs/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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

web/node_modules/jest-config/node_modules/@types/yargs/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/yargs`
+
+# Summary
+This package contains type definitions for yargs (https://github.com/chevex/yargs).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/yargs/v15.
+
+### Additional Details
+ * Last updated: Fri, 02 Jul 2021 16:32:05 GMT
+ * Dependencies: [@types/yargs-parser](https://npmjs.com/package/@types/yargs-parser)
+ * Global values: none
+
+# Credits
+These definitions were written by [Martin Poelstra](https://github.com/poelstra), [Mizunashi Mana](https://github.com/mizunashi-mana), [Jeffery Grajkowski](https://github.com/pushplay), [Jimi (Dimitris) Charalampidis](https://github.com/JimiC), [Steffen Viken Valvåg](https://github.com/steffenvv), [Emily Marigold Klassen](https://github.com/forivall), [ExE Boss](https://github.com/ExE-Boss), and [Aankhen](https://github.com/Aankhen).

web/node_modules/jest-config/node_modules/@types/yargs/index.d.ts

@@ -0,0 +1,836 @@
+// Type definitions for yargs 15.0
+// Project: https://github.com/chevex/yargs, https://yargs.js.org
+// Definitions by: Martin Poelstra <https://github.com/poelstra>
+//                 Mizunashi Mana <https://github.com/mizunashi-mana>
+//                 Jeffery Grajkowski <https://github.com/pushplay>
+//                 Jimi (Dimitris) Charalampidis <https://github.com/JimiC>
+//                 Steffen Viken Valvåg <https://github.com/steffenvv>
+//                 Emily Marigold Klassen <https://github.com/forivall>
+//                 ExE Boss <https://github.com/ExE-Boss>
+//                 Aankhen <https://github.com/Aankhen>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 3.0
+
+// The following TSLint rules have been disabled:
+// unified-signatures: Because there is useful information in the argument names of the overloaded signatures
+
+// Convention:
+// Use 'union types' when:
+//  - parameter types have similar signature type (i.e. 'string | ReadonlyArray<string>')
+//  - parameter names have the same semantic meaning (i.e. ['command', 'commands'] , ['key', 'keys'])
+//    An example for not using 'union types' is the declaration of 'env' where `prefix` and `enable` parameters
+//    have different semantics. On the other hand, in the declaration of 'usage', a `command: string` parameter
+//    has the same semantic meaning with declaring an overload method by using `commands: ReadonlyArray<string>`,
+//    thus it's preferred to use `command: string | ReadonlyArray<string>`
+// Use parameterless declaration instead of declaring all parameters optional,
+// when all parameters are optional and more than one
+
+import { DetailedArguments, Configuration } from 'yargs-parser';
+
+declare namespace yargs {
+    type BuilderCallback<T, R> = ((args: Argv<T>) => PromiseLike<Argv<R>>) | ((args: Argv<T>) => Argv<R>) | ((args: Argv<T>) => void);
+
+    type ParserConfigurationOptions = Configuration & {
+        /** Sort commands alphabetically. Default is `false` */
+        'sort-commands': boolean;
+    };
+
+    /**
+     * The type parameter `T` is the expected shape of the parsed options.
+     * `Arguments<T>` is those options plus `_` and `$0`, and an indexer falling
+     * back to `unknown` for unknown options.
+     *
+     * For the return type / `argv` property, we create a mapped type over
+     * `Arguments<T>` to simplify the inferred type signature in client code.
+     */
+    interface Argv<T = {}> {
+        (): { [key in keyof Arguments<T>]: Arguments<T>[key] };
+        (args: ReadonlyArray<string>, cwd?: string): Argv<T>;
+
+        /**
+         * Set key names as equivalent such that updates to a key will propagate to aliases and vice-versa.
+         *
+         * Optionally `.alias()` can take an object that maps keys to aliases.
+         * Each key of this object should be the canonical version of the option, and each value should be a string or an array of strings.
+         */
+        // Aliases for previously declared options can inherit the types of those options.
+        alias<K1 extends keyof T, K2 extends string>(shortName: K1, longName: K2 | ReadonlyArray<K2>): Argv<T & { [key in K2]: T[K1] }>;
+        alias<K1 extends keyof T, K2 extends string>(shortName: K2, longName: K1 | ReadonlyArray<K1>): Argv<T & { [key in K2]: T[K1] }>;
+        alias(shortName: string | ReadonlyArray<string>, longName: string | ReadonlyArray<string>): Argv<T>;
+        alias(aliases: { [shortName: string]: string | ReadonlyArray<string> }): Argv<T>;
+
+        /**
+         * Get the arguments as a plain old object.
+         *
+         * Arguments without a corresponding flag show up in the `argv._` array.
+         *
+         * The script name or node command is available at `argv.$0` similarly to how `$0` works in bash or perl.
+         *
+         * If `yargs` is executed in an environment that embeds node and there's no script name (e.g. Electron or nw.js),
+         * it will ignore the first parameter since it expects it to be the script name. In order to override
+         * this behavior, use `.parse(process.argv.slice(1))` instead of .argv and the first parameter won't be ignored.
+         */
+        argv: { [key in keyof Arguments<T>]: Arguments<T>[key] };
+
+        /**
+         * Tell the parser to interpret `key` as an array.
+         * If `.array('foo')` is set, `--foo foo bar` will be parsed as `['foo', 'bar']` rather than as `'foo'`.
+         * Also, if you use the option multiple times all the values will be flattened in one array so `--foo foo --foo bar` will be parsed as `['foo', 'bar']`
+         *
+         * When the option is used with a positional, use `--` to tell `yargs` to stop adding values to the array.
+         */
+        array<K extends keyof T>(key: K | ReadonlyArray<K>): Argv<Omit<T, K> & { [key in K]: ToArray<T[key]> }>;
+        array<K extends string>(key: K | ReadonlyArray<K>): Argv<T & { [key in K]: Array<string | number> | undefined }>;
+
+        /**
+         * Interpret `key` as a boolean. If a non-flag option follows `key` in `process.argv`, that string won't get set as the value of `key`.
+         *
+         * `key` will default to `false`, unless a `default(key, undefined)` is explicitly set.
+         *
+         * If `key` is an array, interpret all the elements as booleans.
+         */
+        boolean<K extends keyof T>(key: K | ReadonlyArray<K>): Argv<Omit<T, K> & { [key in K]: boolean | undefined }>;
+        boolean<K extends string>(key: K | ReadonlyArray<K>): Argv<T & { [key in K]: boolean | undefined }>;
+
+        /**
+         * Check that certain conditions are met in the provided arguments.
+         * @param func Called with two arguments, the parsed `argv` hash and an array of options and their aliases.
+         * If `func` throws or returns a non-truthy value, show the thrown error, usage information, and exit.
+         * @param global Indicates whether `check()` should be enabled both at the top-level and for each sub-command.
+         */
+        check(func: (argv: Arguments<T>, aliases: { [alias: string]: string }) => any, global?: boolean): Argv<T>;
+
+        /**
+         * Limit valid values for key to a predefined set of choices, given as an array or as an individual value.
+         * If this method is called multiple times, all enumerated values will be merged together.
+         * Choices are generally strings or numbers, and value matching is case-sensitive.
+         *
+         * Optionally `.choices()` can take an object that maps multiple keys to their choices.
+         *
+         * Choices can also be specified as choices in the object given to `option()`.
+         */
+        choices<K extends keyof T, C extends ReadonlyArray<any>>(key: K, values: C): Argv<Omit<T, K> & { [key in K]: C[number] | undefined }>;
+        choices<K extends string, C extends ReadonlyArray<any>>(key: K, values: C): Argv<T & { [key in K]: C[number] | undefined }>;
+        choices<C extends { [key: string]: ReadonlyArray<any> }>(choices: C): Argv<Omit<T, keyof C> & { [key in keyof C]: C[key][number] | undefined }>;
+
+        /**
+         * Provide a synchronous function to coerce or transform the value(s) given on the command line for `key`.
+         *
+         * The coercion function should accept one argument, representing the parsed value from the command line, and should return a new value or throw an error.
+         * The returned value will be used as the value for `key` (or one of its aliases) in `argv`.
+         *
+         * If the function throws, the error will be treated as a validation failure, delegating to either a custom `.fail()` handler or printing the error message in the console.
+         *
+         * Coercion will be applied to a value after all other modifications, such as `.normalize()`.
+         *
+         * Optionally `.coerce()` can take an object that maps several keys to their respective coercion function.
+         *
+         * You can also map the same function to several keys at one time. Just pass an array of keys as the first argument to `.coerce()`.
+         *
+         * If you are using dot-notion or arrays, .e.g., `user.email` and `user.password`, coercion will be applied to the final object that has been parsed
+         */
+        coerce<K extends keyof T, V>(key: K | ReadonlyArray<K>, func: (arg: any) => V): Argv<Omit<T, K> & { [key in K]: V | undefined }>;
+        coerce<K extends string, V>(key: K | ReadonlyArray<K>, func: (arg: any) => V): Argv<T & { [key in K]: V | undefined }>;
+        coerce<O extends { [key: string]: (arg: any) => any }>(opts: O): Argv<Omit<T, keyof O> & { [key in keyof O]: ReturnType<O[key]> | undefined }>;
+
+        /**
+         * Define the commands exposed by your application.
+         * @param command Should be a string representing the command or an array of strings representing the command and its aliases.
+         * @param description Use to provide a description for each command your application accepts (the values stored in `argv._`).
+         * Set `description` to false to create a hidden command. Hidden commands don't show up in the help output and aren't available for completion.
+         * @param [builder] Object to give hints about the options that your command accepts.
+         * Can also be a function. This function is executed with a yargs instance, and can be used to provide advanced command specific help.
+         *
+         * Note that when `void` is returned, the handler `argv` object type will not include command-specific arguments.
+         * @param [handler] Function, which will be executed with the parsed `argv` object.
+         */
+        command<U = T>(
+            command: string | ReadonlyArray<string>,
+            description: string,
+            builder?: BuilderCallback<T, U>,
+            handler?: (args: Arguments<U>) => void,
+            middlewares?: MiddlewareFunction[],
+            deprecated?: boolean | string,
+        ): Argv<U>;
+        command<O extends { [key: string]: Options }>(
+            command: string | ReadonlyArray<string>,
+            description: string,
+            builder?: O,
+            handler?: (args: Arguments<InferredOptionTypes<O>>) => void,
+            middlewares?: MiddlewareFunction[],
+            deprecated?: boolean | string,
+        ): Argv<T>;
+        command<U>(command: string | ReadonlyArray<string>, description: string, module: CommandModule<T, U>): Argv<U>;
+        command<U = T>(
+            command: string | ReadonlyArray<string>,
+            showInHelp: false,
+            builder?: BuilderCallback<T, U>,
+            handler?: (args: Arguments<U>) => void,
+            middlewares?: MiddlewareFunction[],
+            deprecated?: boolean | string,
+        ): Argv<T>;
+        command<O extends { [key: string]: Options }>(
+            command: string | ReadonlyArray<string>,
+            showInHelp: false,
+            builder?: O,
+            handler?: (args: Arguments<InferredOptionTypes<O>>) => void,
+        ): Argv<T>;
+        command<U>(command: string | ReadonlyArray<string>, showInHelp: false, module: CommandModule<T, U>): Argv<U>;
+        command<U>(module: CommandModule<T, U>): Argv<U>;
+
+        // Advanced API
+        /** Apply command modules from a directory relative to the module calling this method. */
+        commandDir(dir: string, opts?: RequireDirectoryOptions): Argv<T>;
+
+        /**
+         * Enable bash/zsh-completion shortcuts for commands and options.
+         *
+         * If invoked without parameters, `.completion()` will make completion the command to output the completion script.
+         *
+         * @param [cmd] When present in `argv._`, will result in the `.bashrc` or `.zshrc` completion script being outputted.
+         * To enable bash/zsh completions, concat the generated script to your `.bashrc` or `.bash_profile` (or `.zshrc` for zsh).
+         * @param [description] Provide a description in your usage instructions for the command that generates the completion scripts.
+         * @param [func] Rather than relying on yargs' default completion functionality, which shiver me timbers is pretty awesome, you can provide your own completion method.
+         */
+        completion(): Argv<T>;
+        completion(cmd: string, func?: AsyncCompletionFunction): Argv<T>;
+        completion(cmd: string, func?: SyncCompletionFunction): Argv<T>;
+        completion(cmd: string, func?: PromiseCompletionFunction): Argv<T>;
+        completion(cmd: string, description?: string | false, func?: AsyncCompletionFunction): Argv<T>;
+        completion(cmd: string, description?: string | false, func?: SyncCompletionFunction): Argv<T>;
+        completion(cmd: string, description?: string | false, func?: PromiseCompletionFunction): Argv<T>;
+
+        /**
+         * Tells the parser that if the option specified by `key` is passed in, it should be interpreted as a path to a JSON config file.
+         * The file is loaded and parsed, and its properties are set as arguments.
+         * Because the file is loaded using Node's require(), the filename MUST end in `.json` to be interpreted correctly.
+         *
+         * If invoked without parameters, `.config()` will make --config the option to pass the JSON config file.
+         *
+         * @param [description] Provided to customize the config (`key`) option in the usage string.
+         * @param [explicitConfigurationObject] An explicit configuration `object`
+         */
+        config(): Argv<T>;
+        config(key: string | ReadonlyArray<string>, description?: string, parseFn?: (configPath: string) => object): Argv<T>;
+        config(key: string | ReadonlyArray<string>, parseFn: (configPath: string) => object): Argv<T>;
+        config(explicitConfigurationObject: object): Argv<T>;
+
+        /**
+         * Given the key `x` is set, the key `y` must not be set. `y` can either be a single string or an array of argument names that `x` conflicts with.
+         *
+         * Optionally `.conflicts()` can accept an object specifying multiple conflicting keys.
+         */
+        conflicts(key: string, value: string | ReadonlyArray<string>): Argv<T>;
+        conflicts(conflicts: { [key: string]: string | ReadonlyArray<string> }): Argv<T>;
+
+        /**
+         * Interpret `key` as a boolean flag, but set its parsed value to the number of flag occurrences rather than `true` or `false`. Default value is thus `0`.
+         */
+        count<K extends keyof T>(key: K | ReadonlyArray<K>): Argv<Omit<T, K> & { [key in K]: number }>;
+        count<K extends string>(key: K | ReadonlyArray<K>): Argv<T & { [key in K]: number }>;
+
+        /**
+         * Set `argv[key]` to `value` if no option was specified in `process.argv`.
+         *
+         * Optionally `.default()` can take an object that maps keys to default values.
+         *
+         * The default value can be a `function` which returns a value. The name of the function will be used in the usage string.
+         *
+         * Optionally, `description` can also be provided and will take precedence over displaying the value in the usage instructions.
+         */
+        default<K extends keyof T, V>(key: K, value: V, description?: string): Argv<Omit<T, K> & { [key in K]: V }>;
+        default<K extends string, V>(key: K, value: V, description?: string): Argv<T & { [key in K]: V }>;
+        default<D extends { [key: string]: any }>(defaults: D, description?: string): Argv<Omit<T, keyof D> & D>;
+
+        /**
+         * @deprecated since version 6.6.0
+         * Use '.demandCommand()' or '.demandOption()' instead
+         */
+        demand<K extends keyof T>(key: K | ReadonlyArray<K>, msg?: string | true): Argv<Defined<T, K>>;
+        demand<K extends string>(key: K | ReadonlyArray<K>, msg?: string | true): Argv<T & { [key in K]: unknown }>;
+        demand(key: string | ReadonlyArray<string>, required?: boolean): Argv<T>;
+        demand(positionals: number, msg: string): Argv<T>;
+        demand(positionals: number, required?: boolean): Argv<T>;
+        demand(positionals: number, max: number, msg?: string): Argv<T>;
+
+        /**
+         * @param key If is a string, show the usage information and exit if key wasn't specified in `process.argv`.
+         * If is an array, demand each element.
+         * @param msg If string is given, it will be printed when the argument is missing, instead of the standard error message.
+         * @param demand Controls whether the option is demanded; this is useful when using .options() to specify command line parameters.
+         */
+        demandOption<K extends keyof T>(key: K | ReadonlyArray<K>, msg?: string | true): Argv<Defined<T, K>>;
+        demandOption<K extends string>(key: K | ReadonlyArray<K>, msg?: string | true): Argv<T & { [key in K]: unknown }>;
+        demandOption(key: string | ReadonlyArray<string>, demand?: boolean): Argv<T>;
+
+        /**
+         * Demand in context of commands.
+         * You can demand a minimum and a maximum number a user can have within your program, as well as provide corresponding error messages if either of the demands is not met.
+         */
+        demandCommand(): Argv<T>;
+        demandCommand(min: number, minMsg?: string): Argv<T>;
+        demandCommand(min: number, max?: number, minMsg?: string, maxMsg?: string): Argv<T>;
+
+        /**
+         * Shows a [deprecated] notice in front of the option
+         */
+        deprecateOption(option: string, msg?: string): Argv<T>;
+
+        /**
+         * Describe a `key` for the generated usage information.
+         *
+         * Optionally `.describe()` can take an object that maps keys to descriptions.
+         */
+        describe(key: string | ReadonlyArray<string>, description: string): Argv<T>;
+        describe(descriptions: { [key: string]: string }): Argv<T>;
+
+        /** Should yargs attempt to detect the os' locale? Defaults to `true`. */
+        detectLocale(detect: boolean): Argv<T>;
+
+        /**
+         * Tell yargs to parse environment variables matching the given prefix and apply them to argv as though they were command line arguments.
+         *
+         * Use the "__" separator in the environment variable to indicate nested options. (e.g. prefix_nested__foo => nested.foo)
+         *
+         * If this method is called with no argument or with an empty string or with true, then all env vars will be applied to argv.
+         *
+         * Program arguments are defined in this order of precedence:
+         * 1. Command line args
+         * 2. Env vars
+         * 3. Config file/objects
+         * 4. Configured defaults
+         *
+         * Env var parsing is disabled by default, but you can also explicitly disable it by calling `.env(false)`, e.g. if you need to undo previous configuration.
+         */
+        env(): Argv<T>;
+        env(prefix: string): Argv<T>;
+        env(enable: boolean): Argv<T>;
+
+        /** A message to print at the end of the usage instructions */
+        epilog(msg: string): Argv<T>;
+        /** A message to print at the end of the usage instructions */
+        epilogue(msg: string): Argv<T>;
+
+        /**
+         * Give some example invocations of your program.
+         * Inside `cmd`, the string `$0` will get interpolated to the current script name or node command for the present script similar to how `$0` works in bash or perl.
+         * Examples will be printed out as part of the help message.
+         */
+        example(command: string, description: string): Argv<T>;
+        example(command: ReadonlyArray<[string, string?]>): Argv<T>;
+
+        /** Manually indicate that the program should exit, and provide context about why we wanted to exit. Follows the behavior set by `.exitProcess().` */
+        exit(code: number, err: Error): void;
+
+        /**
+         * By default, yargs exits the process when the user passes a help flag, the user uses the `.version` functionality, validation fails, or the command handler fails.
+         * Calling `.exitProcess(false)` disables this behavior, enabling further actions after yargs have been validated.
+         */
+        exitProcess(enabled: boolean): Argv<T>;
+
+        /**
+         * Method to execute when a failure occurs, rather than printing the failure message.
+         * @param func Is called with the failure message that would have been printed, the Error instance originally thrown and yargs state when the failure occurred.
+         */
+        fail(func: (msg: string, err: Error, yargs: Argv<T>) => any): Argv<T>;
+
+        /**
+         * Allows to programmatically get completion choices for any line.
+         * @param args An array of the words in the command line to complete.
+         * @param done The callback to be called with the resulting completions.
+         */
+        getCompletion(args: ReadonlyArray<string>, done: (completions: ReadonlyArray<string>) => void): Argv<T>;
+
+        /**
+         * Indicate that an option (or group of options) should not be reset when a command is executed
+         *
+         * Options default to being global.
+         */
+        global(key: string | ReadonlyArray<string>): Argv<T>;
+
+        /** Given a key, or an array of keys, places options under an alternative heading when displaying usage instructions */
+        group(key: string | ReadonlyArray<string>, groupName: string): Argv<T>;
+
+        /** Hides a key from the generated usage information. Unless a `--show-hidden` option is also passed with `--help` (see `showHidden()`). */
+        hide(key: string): Argv<T>;
+
+        /**
+         * Configure an (e.g. `--help`) and implicit command that displays the usage string and exits the process.
+         * By default yargs enables help on the `--help` option.
+         *
+         * Note that any multi-char aliases (e.g. `help`) used for the help option will also be used for the implicit command.
+         * If there are no multi-char aliases (e.g. `h`), then all single-char aliases will be used for the command.
+         *
+         * If invoked without parameters, `.help()` will use `--help` as the option and help as the implicit command to trigger help output.
+         *
+         * @param [description] Customizes the description of the help option in the usage string.
+         * @param [enableExplicit] If `false` is provided, it will disable --help.
+         */
+        help(): Argv<T>;
+        help(enableExplicit: boolean): Argv<T>;
+        help(option: string, enableExplicit: boolean): Argv<T>;
+        help(option: string, description?: string, enableExplicit?: boolean): Argv<T>;
+
+        /**
+         * Given the key `x` is set, it is required that the key `y` is set.
+         * y` can either be the name of an argument to imply, a number indicating the position of an argument or an array of multiple implications to associate with `x`.
+         *
+         * Optionally `.implies()` can accept an object specifying multiple implications.
+         */
+        implies(key: string, value: string | ReadonlyArray<string>): Argv<T>;
+        implies(implies: { [key: string]: string | ReadonlyArray<string> }): Argv<T>;
+
+        /**
+         * Return the locale that yargs is currently using.
+         *
+         * By default, yargs will auto-detect the operating system's locale so that yargs-generated help content will display in the user's language.
+         */
+        locale(): string;
+        /**
+         * Override the auto-detected locale from the user's operating system with a static locale.
+         * Note that the OS locale can be modified by setting/exporting the `LC_ALL` environment variable.
+         */
+        locale(loc: string): Argv<T>;
+
+        /**
+         * Define global middleware functions to be called first, in list order, for all cli command.
+         * @param callbacks Can be a function or a list of functions. Each callback gets passed a reference to argv.
+         * @param [applyBeforeValidation] Set to `true` to apply middleware before validation. This will execute the middleware prior to validation checks, but after parsing.
+         */
+        middleware(callbacks: MiddlewareFunction<T> | ReadonlyArray<MiddlewareFunction<T>>, applyBeforeValidation?: boolean): Argv<T>;
+
+        /**
+         * The number of arguments that should be consumed after a key. This can be a useful hint to prevent parsing ambiguity.
+         *
+         * Optionally `.nargs()` can take an object of `key`/`narg` pairs.
+         */
+        nargs(key: string, count: number): Argv<T>;
+        nargs(nargs: { [key: string]: number }): Argv<T>;
+
+        /** The key provided represents a path and should have `path.normalize()` applied. */
+        normalize<K extends keyof T>(key: K | ReadonlyArray<K>): Argv<Omit<T, K> & { [key in K]: ToString<T[key]> }>;
+        normalize<K extends string>(key: K | ReadonlyArray<K>): Argv<T & { [key in K]: string | undefined }>;
+
+        /**
+         * Tell the parser to always interpret key as a number.
+         *
+         * If `key` is an array, all elements will be parsed as numbers.
+         *
+         * If the option is given on the command line without a value, `argv` will be populated with `undefined`.
+         *
+         * If the value given on the command line cannot be parsed as a number, `argv` will be populated with `NaN`.
+         *
+         * Note that decimals, hexadecimals, and scientific notation are all accepted.
+         */
+        number<K extends keyof T>(key: K | ReadonlyArray<K>): Argv<Omit<T, K> & { [key in K]: ToNumber<T[key]> }>;
+        number<K extends string>(key: K | ReadonlyArray<K>): Argv<T & { [key in K]: number | undefined }>;
+
+        /**
+         * Method to execute when a command finishes successfully.
+         * @param func Is called with the successful result of the command that finished.
+         */
+        onFinishCommand(func: (result: any) => void): Argv<T>;
+
+        /**
+         * This method can be used to make yargs aware of options that could exist.
+         * You can also pass an opt object which can hold further customization, like `.alias()`, `.demandOption()` etc. for that option.
+         */
+        option<K extends keyof T, O extends Options>(key: K, options: O): Argv<Omit<T, K> & { [key in K]: InferredOptionType<O> }>;
+        option<K extends string, O extends Options>(key: K, options: O): Argv<T & { [key in K]: InferredOptionType<O> }>;
+        option<O extends { [key: string]: Options }>(options: O): Argv<Omit<T, keyof O> & InferredOptionTypes<O>>;
+
+        /**
+         * This method can be used to make yargs aware of options that could exist.
+         * You can also pass an opt object which can hold further customization, like `.alias()`, `.demandOption()` etc. for that option.
+         */
+        options<K extends keyof T, O extends Options>(key: K, options: O): Argv<Omit<T, K> & { [key in K]: InferredOptionType<O> }>;
+        options<K extends string, O extends Options>(key: K, options: O): Argv<T & { [key in K]: InferredOptionType<O> }>;
+        options<O extends { [key: string]: Options }>(options: O): Argv<Omit<T, keyof O> & InferredOptionTypes<O>>;
+
+        /**
+         * Parse `args` instead of `process.argv`. Returns the `argv` object. `args` may either be a pre-processed argv array, or a raw argument string.
+         *
+         * Note: Providing a callback to parse() disables the `exitProcess` setting until after the callback is invoked.
+         * @param [context]  Provides a useful mechanism for passing state information to commands
+         */
+        parse(): { [key in keyof Arguments<T>]: Arguments<T>[key] };
+        parse(arg: string | ReadonlyArray<string>, context?: object, parseCallback?: ParseCallback<T>): { [key in keyof Arguments<T>]: Arguments<T>[key] };
+
+        /**
+         * If the arguments have not been parsed, this property is `false`.
+         *
+         * If the arguments have been parsed, this contain detailed parsed arguments.
+         */
+        parsed: DetailedArguments | false;
+
+        /** Allows to configure advanced yargs features. */
+        parserConfiguration(configuration: Partial<ParserConfigurationOptions>): Argv<T>;
+
+        /**
+         * Similar to `config()`, indicates that yargs should interpret the object from the specified key in package.json as a configuration object.
+         * @param [cwd] If provided, the package.json will be read from this location
+         */
+        pkgConf(key: string | ReadonlyArray<string>, cwd?: string): Argv<T>;
+
+        /**
+         * Allows you to configure a command's positional arguments with an API similar to `.option()`.
+         * `.positional()` should be called in a command's builder function, and is not available on the top-level yargs instance. If so, it will throw an error.
+         */
+        positional<K extends keyof T, O extends PositionalOptions>(key: K, opt: O): Argv<Omit<T, K> & { [key in K]: InferredOptionType<O> }>;
+        positional<K extends string, O extends PositionalOptions>(key: K, opt: O): Argv<T & { [key in K]: InferredOptionType<O> }>;
+
+        /** Should yargs provide suggestions regarding similar commands if no matching command is found? */
+        recommendCommands(): Argv<T>;
+
+        /**
+         * @deprecated since version 6.6.0
+         * Use '.demandCommand()' or '.demandOption()' instead
+         */
+        require<K extends keyof T>(key: K | ReadonlyArray<K>, msg?: string | true): Argv<Defined<T, K>>;
+        require(key: string, msg: string): Argv<T>;
+        require(key: string, required: boolean): Argv<T>;
+        require(keys: ReadonlyArray<number>, msg: string): Argv<T>;
+        require(keys: ReadonlyArray<number>, required: boolean): Argv<T>;
+        require(positionals: number, required: boolean): Argv<T>;
+        require(positionals: number, msg: string): Argv<T>;
+
+        /**
+         * @deprecated since version 6.6.0
+         * Use '.demandCommand()' or '.demandOption()' instead
+         */
+        required<K extends keyof T>(key: K | ReadonlyArray<K>, msg?: string | true): Argv<Defined<T, K>>;
+        required(key: string, msg: string): Argv<T>;
+        required(key: string, required: boolean): Argv<T>;
+        required(keys: ReadonlyArray<number>, msg: string): Argv<T>;
+        required(keys: ReadonlyArray<number>, required: boolean): Argv<T>;
+        required(positionals: number, required: boolean): Argv<T>;
+        required(positionals: number, msg: string): Argv<T>;
+
+        requiresArg(key: string | ReadonlyArray<string>): Argv<T>;
+
+        /**
+         * @deprecated since version 6.6.0
+         * Use '.global()' instead
+         */
+        reset(): Argv<T>;
+
+        /** Set the name of your script ($0). Default is the base filename executed by node (`process.argv[1]`) */
+        scriptName($0: string): Argv<T>;
+
+        /**
+         * Generate a bash completion script.
+         * Users of your application can install this script in their `.bashrc`, and yargs will provide completion shortcuts for commands and options.
+         */
+        showCompletionScript(): Argv<T>;
+
+        /**
+         * Configure the `--show-hidden` option that displays the hidden keys (see `hide()`).
+         * @param option If `boolean`, it enables/disables this option altogether. i.e. hidden keys will be permanently hidden if first argument is `false`.
+         * If `string` it changes the key name ("--show-hidden").
+         * @param description Changes the default description ("Show hidden options")
+         */
+        showHidden(option?: string | boolean): Argv<T>;
+        showHidden(option: string, description?: string): Argv<T>;
+
+        /**
+         * Print the usage data using the console function consoleLevel for printing.
+         * @param [consoleLevel='error']
+         */
+        showHelp(consoleLevel?: string): Argv<T>;
+
+        /**
+         * Provide the usage data as a string.
+         * @param printCallback a function with a single argument.
+         */
+        showHelp(printCallback: (s: string) => void): Argv<T>;
+
+        /**
+         * By default, yargs outputs a usage string if any error is detected.
+         * Use the `.showHelpOnFail()` method to customize this behavior.
+         * @param enable If `false`, the usage string is not output.
+         * @param [message] Message that is output after the error message.
+         */
+        showHelpOnFail(enable: boolean, message?: string): Argv<T>;
+
+        /** Specifies either a single option key (string), or an array of options. If any of the options is present, yargs validation is skipped. */
+        skipValidation(key: string | ReadonlyArray<string>): Argv<T>;
+
+        /**
+         * Any command-line argument given that is not demanded, or does not have a corresponding description, will be reported as an error.
+         *
+         * Unrecognized commands will also be reported as errors.
+         */
+        strict(): Argv<T>;
+        strict(enabled: boolean): Argv<T>;
+
+        /**
+         * Similar to .strict(), except that it only applies to unrecognized commands.
+         * A user can still provide arbitrary options, but unknown positional commands
+         * will raise an error.
+         */
+        strictCommands(): Argv<T>;
+        strictCommands(enabled: boolean): Argv<T>;
+
+        /**
+         * Tell the parser logic not to interpret `key` as a number or boolean. This can be useful if you need to preserve leading zeros in an input.
+         *
+         * If `key` is an array, interpret all the elements as strings.
+         *
+         * `.string('_')` will result in non-hyphenated arguments being interpreted as strings, regardless of whether they resemble numbers.
+         */
+        string<K extends keyof T>(key: K | ReadonlyArray<K>): Argv<Omit<T, K> & { [key in K]: ToString<T[key]> }>;
+        string<K extends string>(key: K | ReadonlyArray<K>): Argv<T & { [key in K]: string | undefined }>;
+
+        // Intended to be used with '.wrap()'
+        terminalWidth(): number;
+
+        updateLocale(obj: { [key: string]: string }): Argv<T>;
+
+        /**
+         * Override the default strings used by yargs with the key/value pairs provided in obj
+         *
+         * If you explicitly specify a locale(), you should do so before calling `updateStrings()`.
+         */
+        updateStrings(obj: { [key: string]: string }): Argv<T>;
+
+        /**
+         * Set a usage message to show which commands to use.
+         * Inside `message`, the string `$0` will get interpolated to the current script name or node command for the present script similar to how `$0` works in bash or perl.
+         *
+         * If the optional `description`/`builder`/`handler` are provided, `.usage()` acts an an alias for `.command()`.
+         * This allows you to use `.usage()` to configure the default command that will be run as an entry-point to your application
+         * and allows you to provide configuration for the positional arguments accepted by your program:
+         */
+        usage(message: string): Argv<T>;
+        usage<U>(command: string | ReadonlyArray<string>, description: string, builder?: (args: Argv<T>) => Argv<U>, handler?: (args: Arguments<U>) => void): Argv<T>;
+        usage<U>(command: string | ReadonlyArray<string>, showInHelp: boolean, builder?: (args: Argv<T>) => Argv<U>, handler?: (args: Arguments<U>) => void): Argv<T>;
+        usage<O extends { [key: string]: Options }>(command: string | ReadonlyArray<string>, description: string, builder?: O, handler?: (args: Arguments<InferredOptionTypes<O>>) => void): Argv<T>;
+        usage<O extends { [key: string]: Options }>(command: string | ReadonlyArray<string>, showInHelp: boolean, builder?: O, handler?: (args: Arguments<InferredOptionTypes<O>>) => void): Argv<T>;
+
+        /**
+         * Add an option (e.g. `--version`) that displays the version number (given by the version parameter) and exits the process.
+         * By default yargs enables version for the `--version` option.
+         *
+         * If no arguments are passed to version (`.version()`), yargs will parse the package.json of your module and use its version value.
+         *
+         * If the boolean argument `false` is provided, it will disable `--version`.
+         */
+        version(): Argv<T>;
+        version(version: string): Argv<T>;
+        version(enable: boolean): Argv<T>;
+        version(optionKey: string, version: string): Argv<T>;
+        version(optionKey: string, description: string, version: string): Argv<T>;
+
+        /**
+         * Format usage output to wrap at columns many columns.
+         *
+         * By default wrap will be set to `Math.min(80, windowWidth)`. Use `.wrap(null)` to specify no column limit (no right-align).
+         * Use `.wrap(yargs.terminalWidth())` to maximize the width of yargs' usage instructions.
+         */
+        wrap(columns: number | null): Argv<T>;
+    }
+
+    type Arguments<T = {}> = T & {
+        /** Non-option arguments */
+        _: Array<string | number>;
+        /** The script name or node command */
+        $0: string;
+        /** All remaining options */
+        [argName: string]: unknown;
+    };
+
+    interface RequireDirectoryOptions {
+        /** Look for command modules in all subdirectories and apply them as a flattened (non-hierarchical) list. */
+        recurse?: boolean | undefined;
+        /** The types of files to look for when requiring command modules. */
+        extensions?: ReadonlyArray<string> | undefined;
+        /**
+         * A synchronous function called for each command module encountered.
+         * Accepts `commandObject`, `pathToFile`, and `filename` as arguments.
+         * Returns `commandObject` to include the command; any falsy value to exclude/skip it.
+         */
+        visit?: ((commandObject: any, pathToFile?: string, filename?: string) => any) | undefined;
+        /** Whitelist certain modules */
+        include?: RegExp | ((pathToFile: string) => boolean) | undefined;
+        /** Blacklist certain modules. */
+        exclude?: RegExp | ((pathToFile: string) => boolean) | undefined;
+    }
+
+    interface Options {
+        /** string or array of strings, alias(es) for the canonical option key, see `alias()` */
+        alias?: string | ReadonlyArray<string> | undefined;
+        /** boolean, interpret option as an array, see `array()` */
+        array?: boolean | undefined;
+        /**  boolean, interpret option as a boolean flag, see `boolean()` */
+        boolean?: boolean | undefined;
+        /** value or array of values, limit valid option arguments to a predefined set, see `choices()` */
+        choices?: Choices | undefined;
+        /** function, coerce or transform parsed command line values into another value, see `coerce()` */
+        coerce?: ((arg: any) => any) | undefined;
+        /** boolean, interpret option as a path to a JSON config file, see `config()` */
+        config?: boolean | undefined;
+        /** function, provide a custom config parsing function, see `config()` */
+        configParser?: ((configPath: string) => object) | undefined;
+        /** string or object, require certain keys not to be set, see `conflicts()` */
+        conflicts?: string | ReadonlyArray<string> | { [key: string]: string | ReadonlyArray<string> } | undefined;
+        /** boolean, interpret option as a count of boolean flags, see `count()` */
+        count?: boolean | undefined;
+        /** value, set a default value for the option, see `default()` */
+        default?: any;
+        /** string, use this description for the default value in help content, see `default()` */
+        defaultDescription?: string | undefined;
+        /**
+         *  @deprecated since version 6.6.0
+         *  Use 'demandOption' instead
+         */
+        demand?: boolean | string | undefined;
+        /** boolean or string, mark the argument as deprecated, see `deprecateOption()` */
+        deprecate?: boolean | string | undefined;
+        /** boolean or string, mark the argument as deprecated, see `deprecateOption()` */
+        deprecated?: boolean | string | undefined;
+        /** boolean or string, demand the option be given, with optional error message, see `demandOption()` */
+        demandOption?: boolean | string | undefined;
+        /** string, the option description for help content, see `describe()` */
+        desc?: string | undefined;
+        /** string, the option description for help content, see `describe()` */
+        describe?: string | undefined;
+        /** string, the option description for help content, see `describe()` */
+        description?: string | undefined;
+        /** boolean, indicate that this key should not be reset when a command is invoked, see `global()` */
+        global?: boolean | undefined;
+        /** string, when displaying usage instructions place the option under an alternative group heading, see `group()` */
+        group?: string | undefined;
+        /** don't display option in help output. */
+        hidden?: boolean | undefined;
+        /**  string or object, require certain keys to be set, see `implies()` */
+        implies?: string | ReadonlyArray<string> | { [key: string]: string | ReadonlyArray<string> } | undefined;
+        /** number, specify how many arguments should be consumed for the option, see `nargs()` */
+        nargs?: number | undefined;
+        /** boolean, apply path.normalize() to the option, see `normalize()` */
+        normalize?: boolean | undefined;
+        /** boolean, interpret option as a number, `number()` */
+        number?: boolean | undefined;
+        /**
+         *  @deprecated since version 6.6.0
+         *  Use 'demandOption' instead
+         */
+        require?: boolean | string | undefined;
+        /**
+         *  @deprecated since version 6.6.0
+         *  Use 'demandOption' instead
+         */
+        required?: boolean | string | undefined;
+        /** boolean, require the option be specified with a value, see `requiresArg()` */
+        requiresArg?: boolean | undefined;
+        /** boolean, skips validation if the option is present, see `skipValidation()` */
+        skipValidation?: boolean | undefined;
+        /** boolean, interpret option as a string, see `string()` */
+        string?: boolean | undefined;
+        type?: "array" | "count" | PositionalOptionsType | undefined;
+    }
+
+    interface PositionalOptions {
+        /** string or array of strings, see `alias()` */
+        alias?: string | ReadonlyArray<string> | undefined;
+        /** boolean, interpret option as an array, see `array()` */
+        array?: boolean | undefined;
+        /** value or array of values, limit valid option arguments to a predefined set, see `choices()` */
+        choices?: Choices | undefined;
+        /** function, coerce or transform parsed command line values into another value, see `coerce()` */
+        coerce?: ((arg: any) => any) | undefined;
+        /** string or object, require certain keys not to be set, see `conflicts()` */
+        conflicts?: string | ReadonlyArray<string> | { [key: string]: string | ReadonlyArray<string> } | undefined;
+        /** value, set a default value for the option, see `default()` */
+        default?: any;
+        /** boolean or string, demand the option be given, with optional error message, see `demandOption()` */
+        demandOption?: boolean | string | undefined;
+        /** string, the option description for help content, see `describe()` */
+        desc?: string | undefined;
+        /** string, the option description for help content, see `describe()` */
+        describe?: string | undefined;
+        /** string, the option description for help content, see `describe()` */
+        description?: string | undefined;
+        /** string or object, require certain keys to be set, see `implies()` */
+        implies?: string | ReadonlyArray<string> | { [key: string]: string | ReadonlyArray<string> } | undefined;
+        /** boolean, apply path.normalize() to the option, see normalize() */
+        normalize?: boolean | undefined;
+        type?: PositionalOptionsType | undefined;
+    }
+
+    /** Remove keys K in T */
+    type Omit<T, K> = { [key in Exclude<keyof T, K>]: T[key] };
+
+    /** Remove undefined as a possible value for keys K in T */
+    type Defined<T, K extends keyof T> = Omit<T, K> & { [key in K]: Exclude<T[key], undefined> };
+
+    /** Convert T to T[] and T | undefined to T[] | undefined */
+    type ToArray<T> = Array<Exclude<T, undefined>> | Extract<T, undefined>;
+
+    /** Gives string[] if T is an array type, otherwise string. Preserves | undefined. */
+    type ToString<T> = (Exclude<T, undefined> extends any[] ? string[] : string) | Extract<T, undefined>;
+
+    /** Gives number[] if T is an array type, otherwise number. Preserves | undefined. */
+    type ToNumber<T> = (Exclude<T, undefined> extends any[] ? number[] : number) | Extract<T, undefined>;
+
+    type InferredOptionType<O extends Options | PositionalOptions> =
+        O extends { default: any, coerce: (arg: any) => infer T } ? T :
+        O extends { default: infer D } ? D :
+        O extends { type: "count" } ? number :
+        O extends { count: true } ? number :
+        O extends { required: string | true } ? RequiredOptionType<O> :
+        O extends { require: string | true } ? RequiredOptionType<O> :
+        O extends { demand: string | true } ? RequiredOptionType<O> :
+        O extends { demandOption: string | true } ? RequiredOptionType<O> :
+        RequiredOptionType<O> | undefined;
+
+    type RequiredOptionType<O extends Options | PositionalOptions> =
+        O extends { type: "array", string: true } ? string[] :
+        O extends { type: "array", number: true } ? number[] :
+        O extends { type: "array", normalize: true } ? string[] :
+        O extends { type: "string", array: true } ? string[] :
+        O extends { type: "number", array: true } ? number[] :
+        O extends { string: true, array: true } ? string[] :
+        O extends { number: true, array: true } ? number[] :
+        O extends { normalize: true, array: true } ? string[] :
+        O extends { type: "array" } ? Array<string | number> :
+        O extends { type: "boolean" } ? boolean :
+        O extends { type: "number" } ? number :
+        O extends { type: "string" } ? string :
+        O extends { array: true } ? Array<string | number> :
+        O extends { boolean: true } ? boolean :
+        O extends { number: true } ? number :
+        O extends { string: true } ? string :
+        O extends { normalize: true } ? string :
+        O extends { choices: ReadonlyArray<infer C> } ? C :
+        O extends { coerce: (arg: any) => infer T } ? T :
+        unknown;
+
+    type InferredOptionTypes<O extends { [key: string]: Options }> = { [key in keyof O]: InferredOptionType<O[key]> };
+
+    interface CommandModule<T = {}, U = {}> {
+        /** array of strings (or a single string) representing aliases of `exports.command`, positional args defined in an alias are ignored */
+        aliases?: ReadonlyArray<string> | string | undefined;
+        /** object declaring the options the command accepts, or a function accepting and returning a yargs instance */
+        builder?: CommandBuilder<T, U> | undefined;
+        /** string (or array of strings) that executes this command when given on the command line, first string may contain positional args */
+        command?: ReadonlyArray<string> | string | undefined;
+        /** boolean (or string) to show deprecation notice */
+        deprecated?: boolean | string | undefined;
+        /** string used as the description for the command in help text, use `false` for a hidden command */
+        describe?: string | false | undefined;
+        /** a function which will be passed the parsed argv. */
+        handler: (args: Arguments<U>) => void;
+    }
+
+    type ParseCallback<T = {}> = (err: Error | undefined, argv: Arguments<T>, output: string) => void;
+    type CommandBuilder<T = {}, U = {}> = { [key: string]: Options } | ((args: Argv<T>) => Argv<U>) | ((args: Argv<T>) => PromiseLike<Argv<U>>);
+    type SyncCompletionFunction = (current: string, argv: any) => string[];
+    type AsyncCompletionFunction = (current: string, argv: any, done: (completion: ReadonlyArray<string>) => void) => void;
+    type PromiseCompletionFunction = (current: string, argv: any) => Promise<string[]>;
+    type MiddlewareFunction<T = {}> = (args: Arguments<T>) => void;
+    type Choices = ReadonlyArray<string | number | true | undefined>;
+    type PositionalOptionsType = "boolean" | "number" | "string";
+}
+
+declare var yargs: yargs.Argv;
+export = yargs;

web/node_modules/jest-config/node_modules/@types/yargs/package.json

@@ -0,0 +1,62 @@
+{
+    "name": "@types/yargs",
+    "version": "15.0.14",
+    "description": "TypeScript definitions for yargs",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/yargs",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Martin Poelstra",
+            "url": "https://github.com/poelstra",
+            "githubUsername": "poelstra"
+        },
+        {
+            "name": "Mizunashi Mana",
+            "url": "https://github.com/mizunashi-mana",
+            "githubUsername": "mizunashi-mana"
+        },
+        {
+            "name": "Jeffery Grajkowski",
+            "url": "https://github.com/pushplay",
+            "githubUsername": "pushplay"
+        },
+        {
+            "name": "Jimi (Dimitris) Charalampidis",
+            "url": "https://github.com/JimiC",
+            "githubUsername": "JimiC"
+        },
+        {
+            "name": "Steffen Viken Valvåg",
+            "url": "https://github.com/steffenvv",
+            "githubUsername": "steffenvv"
+        },
+        {
+            "name": "Emily Marigold Klassen",
+            "url": "https://github.com/forivall",
+            "githubUsername": "forivall"
+        },
+        {
+            "name": "ExE Boss",
+            "url": "https://github.com/ExE-Boss",
+            "githubUsername": "ExE-Boss"
+        },
+        {
+            "name": "Aankhen",
+            "url": "https://github.com/Aankhen",
+            "githubUsername": "Aankhen"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/yargs"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@types/yargs-parser": "*"
+    },
+    "typesPublisherContentHash": "08f18db584d12815700691202627482987b3f369093c020e1539deee222b2a09",
+    "typeScriptVersion": "3.6"
+}

web/node_modules/jest-config/node_modules/@types/yargs/yargs.d.ts

@@ -0,0 +1,9 @@
+import { Argv } from '.';
+
+export = Yargs;
+
+declare function Yargs(
+    processArgs?: ReadonlyArray<string>,
+    cwd?: string,
+    parentRequire?: NodeRequire,
+): Argv;

web/node_modules/jest-config/node_modules/deepmerge/changelog.md

@@ -0,0 +1,159 @@
+# [4.2.2](https://github.com/TehShrike/deepmerge/releases/tag/v4.2.2)
+
+- `isMergeableObject` is now only called if there are two values that could be merged.  [a34dd4d2](https://github.com/TehShrike/deepmerge/commit/a34dd4d25bf5e250653540a2022bc832c7b00a19)
+
+# [4.2.1](https://github.com/TehShrike/deepmerge/releases/tag/v4.2.1)
+
+- Fix: falsey values can now be merged.  [#170](https://github.com/TehShrike/deepmerge/issues/170)
+
+# [4.2.0](https://github.com/TehShrike/deepmerge/releases/tag/v4.2.0)
+
+- Properties are now only overwritten if they exist on the target object and are enumerable.  [#164](https://github.com/TehShrike/deepmerge/pull/164)
+
+Technically this could probably be a patch release since "which properties get overwritten" wasn't documented and accidentally overwriting a built-in function or some function up the property chain would almost certainly be undesirable, but it feels like a gray area, so here we are with a feature version bump.
+
+# [4.1.2](https://github.com/TehShrike/deepmerge/releases/tag/v4.1.2)
+
+- Rolled back #167 since `Object.assign` breaks ES5 support.  [55067352](https://github.com/TehShrike/deepmerge/commit/55067352a92c65a6c44a5165f3387720aae1e192)
+
+# [4.1.1](https://github.com/TehShrike/deepmerge/releases/tag/v4.1.1)
+
+- The `options` argument is no longer mutated [#167](https://github.com/TehShrike/deepmerge/pull/167)
+
+# [4.1.0](https://github.com/TehShrike/deepmerge/releases/tag/v4.1.0)
+
+- `cloneUnlessOtherwiseSpecified` is now exposed to the `arrayMerge` function [#165](https://github.com/TehShrike/deepmerge/pull/165)
+
+# [4.0.0](https://github.com/TehShrike/deepmerge/releases/tag/v4.0.0)
+
+- The `main` entry point in `package.json` is now a CommonJS module instead of a UMD module [#155](https://github.com/TehShrike/deepmerge/pull/155)
+
+# [3.3.0](https://github.com/TehShrike/deepmerge/releases/tag/v3.3.0)
+
+- Enumerable Symbol properties are now copied [#151](https://github.com/TehShrike/deepmerge/pull/151)
+
+# [3.2.1](https://github.com/TehShrike/deepmerge/releases/tag/v3.2.1)
+
+- bumping dev dependency versions to try to shut up bogus security warnings from Github/npm [#149](https://github.com/TehShrike/deepmerge/pull/149)
+
+# [3.2.0](https://github.com/TehShrike/deepmerge/releases/tag/v3.2.0)
+
+- feature: added the [`customMerge`](https://github.com/TehShrike/deepmerge#custommerge) option [#133](https://github.com/TehShrike/deepmerge/pull/133)
+
+# [3.1.0](https://github.com/TehShrike/deepmerge/releases/tag/v3.1.0)
+
+- typescript typing: make the `all` function generic [#129](https://github.com/TehShrike/deepmerge/pull/129)
+
+# [3.0.0](https://github.com/TehShrike/deepmerge/releases/tag/v3.0.0)
+
+- drop ES module build [#123](https://github.com/TehShrike/deepmerge/issues/123)
+
+# [2.2.1](https://github.com/TehShrike/deepmerge/releases/tag/v2.2.1)
+
+- bug: typescript export type was wrong [#121](https://github.com/TehShrike/deepmerge/pull/121)
+
+# [2.2.0](https://github.com/TehShrike/deepmerge/releases/tag/v2.2.0)
+
+- feature: added TypeScript typings [#119](https://github.com/TehShrike/deepmerge/pull/119)
+
+# [2.1.1](https://github.com/TehShrike/deepmerge/releases/tag/v2.1.1)
+
+- documentation: Rename "methods" to "api", note ESM syntax [#103](https://github.com/TehShrike/deepmerge/pull/103)
+- documentation: Fix grammar [#107](https://github.com/TehShrike/deepmerge/pull/107)
+- documentation: Restructure headers for clarity + some wording tweaks [108](https://github.com/TehShrike/deepmerge/pull/108) + [109](https://github.com/TehShrike/deepmerge/pull/109)
+
+
+# [2.1.0](https://github.com/TehShrike/deepmerge/releases/tag/v2.1.0)
+
+- feature: Support a custom `isMergeableObject` function [#96](https://github.com/TehShrike/deepmerge/pull/96)
+- documentation: note a Webpack bug that some users might need to work around [#100](https://github.com/TehShrike/deepmerge/pull/100)
+
+# [2.0.1](https://github.com/TehShrike/deepmerge/releases/tag/v2.0.1)
+
+- documentation: fix the old array merge algorithm in the readme.  [#84](https://github.com/TehShrike/deepmerge/pull/84)
+
+# [2.0.0](https://github.com/TehShrike/deepmerge/releases/tag/v2.0.0)
+
+- breaking: the array merge algorithm has changed from a complicated thing to `target.concat(source).map(element => cloneUnlessOtherwiseSpecified(element, optionsArgument))`
+- breaking: The `clone` option now defaults to `true`
+- feature: `merge.all` now accepts an array of any size, even 0 or 1 elements
+
+See [pull request 77](https://github.com/TehShrike/deepmerge/pull/77).
+
+# [1.5.2](https://github.com/TehShrike/deepmerge/releases/tag/v1.5.2)
+
+- fix: no longer attempts to merge React elements [#76](https://github.com/TehShrike/deepmerge/issues/76)
+
+# [1.5.1](https://github.com/TehShrike/deepmerge/releases/tag/v1.5.1)
+
+- bower support: officially dropping bower support.  If you use bower, please depend on the [unpkg distribution](https://unpkg.com/deepmerge/dist/umd.js).  See [#63](https://github.com/TehShrike/deepmerge/issues/63)
+
+# [1.5.0](https://github.com/TehShrike/deepmerge/releases/tag/v1.5.0)
+
+- bug fix: merging objects into arrays was allowed, and doesn't make any sense. [#65](https://github.com/TehShrike/deepmerge/issues/65) published as a feature release instead of a patch because it is a decent behavior change.
+
+# [1.4.4](https://github.com/TehShrike/deepmerge/releases/tag/v1.4.4)
+
+- bower support: updated `main` in bower.json
+
+# [1.4.3](https://github.com/TehShrike/deepmerge/releases/tag/v1.4.3)
+
+- bower support: inline is-mergeable-object in a new CommonJS build, so that people using both bower and CommonJS can bundle the library [0b34e6](https://github.com/TehShrike/deepmerge/commit/0b34e6e95f989f2fc8091d25f0d291c08f3d2d24)
+
+# [1.4.2](https://github.com/TehShrike/deepmerge/releases/tag/v1.4.2)
+
+- performance: bump is-mergeable-object dependency version for a slight performance improvement [5906c7](https://github.com/TehShrike/deepmerge/commit/5906c765d691d48e83d76efbb0d4b9ca150dc12c)
+
+# [1.4.1](https://github.com/TehShrike/deepmerge/releases/tag/v1.4.1)
+
+- documentation: fix unpkg link [acc45b](https://github.com/TehShrike/deepmerge/commit/acc45be85519c1df906a72ecb24764b622d18d47)
+
+# [1.4.0](https://github.com/TehShrike/deepmerge/releases/tag/v1.4.0)
+
+- api: instead of only exporting a UMD module, expose a UMD module with `pkg.main`, a CJS module with `pkg.browser`, and an ES module with `pkg.module` [#62](https://github.com/TehShrike/deepmerge/pull/62)
+
+# [1.3.2](https://github.com/TehShrike/deepmerge/releases/tag/v1.3.2)
+
+- documentation: note the minified/gzipped file sizes [56](https://github.com/TehShrike/deepmerge/pull/56)
+- documentation: make data structures more readable in merge example: pull request [57](https://github.com/TehShrike/deepmerge/pull/57)
+
+# [1.3.1](https://github.com/TehShrike/deepmerge/releases/tag/v1.3.1)
+
+- documentation: clarify and test some array merging documentation: pull request [51](https://github.com/TehShrike/deepmerge/pull/51)
+
+# [1.3.0](https://github.com/TehShrike/deepmerge/releases/tag/v1.3.0)
+
+- feature: `merge.all`, a merge function that merges any number of objects: pull request [50](https://github.com/TehShrike/deepmerge/pull/50)
+
+# [1.2.0](https://github.com/TehShrike/deepmerge/releases/tag/v1.2.0)
+
+- fix: an error that would be thrown when an array would be merged onto a truthy non-array value: pull request [46](https://github.com/TehShrike/deepmerge/pull/46)
+- feature: the ability to clone: Issue [28](https://github.com/TehShrike/deepmerge/issues/28), pull requests [44](https://github.com/TehShrike/deepmerge/pull/44) and [48](https://github.com/TehShrike/deepmerge/pull/48)
+- maintenance: added tests + travis to `.npmignore`: pull request [47](https://github.com/TehShrike/deepmerge/pull/47)
+
+# [1.1.1](https://github.com/TehShrike/deepmerge/releases/tag/v1.1.1)
+
+- fix an issue where an error was thrown when merging an array onto a non-array: [Pull request 46](https://github.com/TehShrike/deepmerge/pull/46)
+
+# [1.1.0](https://github.com/TehShrike/deepmerge/releases/tag/v1.1.0)
+
+- allow consumers to specify their own array merging algorithm: [Pull request 37](https://github.com/TehShrike/deepmerge/pull/37)
+
+# [1.0.3](https://github.com/TehShrike/deepmerge/releases/tag/v1.0.3)
+
+- adding bower.json back: [Issue 38](https://github.com/TehShrike/deepmerge/pull/38)
+- updating keywords and Github links in package.json [bc3898e](https://github.com/TehShrike/deepmerge/commit/bc3898e587a56f74591328f40f656b0152c1d5eb)
+
+# [1.0.2](https://github.com/TehShrike/deepmerge/releases/tag/v1.0.2)
+
+- Updating the readme: dropping bower, testing that the example works: [7102fc](https://github.com/TehShrike/deepmerge/commit/7102fcc4ddec11e2d33205866f9f18df14e5aeb5)
+
+# [1.0.1](https://github.com/TehShrike/deepmerge/releases/tag/v1.0.1)
+
+- `null`, dates, and regular expressions are now properly merged in arrays: [Issue 18](https://github.com/TehShrike/deepmerge/pull/18), plus commit: [ef1c6b](https://github.com/TehShrike/deepmerge/commit/ef1c6bac8350ba12a24966f0bc7da02560827586)
+
+# 1.0.0
+
+- Should only be a patch change, because this module is READY. [Issue 15](https://github.com/TehShrike/deepmerge/issues/15)
+- Regular expressions are now treated like primitive values when merging: [Issue 30](https://github.com/TehShrike/deepmerge/pull/30)
+- Dates are now treated like primitives when merging: [Issue 31](https://github.com/TehShrike/deepmerge/issues/31)

web/node_modules/jest-config/node_modules/deepmerge/dist/cjs.js

@@ -0,0 +1,133 @@
+'use strict';
+
+var isMergeableObject = function isMergeableObject(value) {
+	return isNonNullObject(value)
+		&& !isSpecial(value)
+};
+
+function isNonNullObject(value) {
+	return !!value && typeof value === 'object'
+}
+
+function isSpecial(value) {
+	var stringValue = Object.prototype.toString.call(value);
+
+	return stringValue === '[object RegExp]'
+		|| stringValue === '[object Date]'
+		|| isReactElement(value)
+}
+
+// see https://github.com/facebook/react/blob/b5ac963fb791d1298e7f396236383bc955f916c1/src/isomorphic/classic/element/ReactElement.js#L21-L25
+var canUseSymbol = typeof Symbol === 'function' && Symbol.for;
+var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for('react.element') : 0xeac7;
+
+function isReactElement(value) {
+	return value.$$typeof === REACT_ELEMENT_TYPE
+}
+
+function emptyTarget(val) {
+	return Array.isArray(val) ? [] : {}
+}
+
+function cloneUnlessOtherwiseSpecified(value, options) {
+	return (options.clone !== false && options.isMergeableObject(value))
+		? deepmerge(emptyTarget(value), value, options)
+		: value
+}
+
+function defaultArrayMerge(target, source, options) {
+	return target.concat(source).map(function(element) {
+		return cloneUnlessOtherwiseSpecified(element, options)
+	})
+}
+
+function getMergeFunction(key, options) {
+	if (!options.customMerge) {
+		return deepmerge
+	}
+	var customMerge = options.customMerge(key);
+	return typeof customMerge === 'function' ? customMerge : deepmerge
+}
+
+function getEnumerableOwnPropertySymbols(target) {
+	return Object.getOwnPropertySymbols
+		? Object.getOwnPropertySymbols(target).filter(function(symbol) {
+			return target.propertyIsEnumerable(symbol)
+		})
+		: []
+}
+
+function getKeys(target) {
+	return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target))
+}
+
+function propertyIsOnObject(object, property) {
+	try {
+		return property in object
+	} catch(_) {
+		return false
+	}
+}
+
+// Protects from prototype poisoning and unexpected merging up the prototype chain.
+function propertyIsUnsafe(target, key) {
+	return propertyIsOnObject(target, key) // Properties are safe to merge if they don't exist in the target yet,
+		&& !(Object.hasOwnProperty.call(target, key) // unsafe if they exist up the prototype chain,
+			&& Object.propertyIsEnumerable.call(target, key)) // and also unsafe if they're nonenumerable.
+}
+
+function mergeObject(target, source, options) {
+	var destination = {};
+	if (options.isMergeableObject(target)) {
+		getKeys(target).forEach(function(key) {
+			destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
+		});
+	}
+	getKeys(source).forEach(function(key) {
+		if (propertyIsUnsafe(target, key)) {
+			return
+		}
+
+		if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
+			destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
+		} else {
+			destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
+		}
+	});
+	return destination
+}
+
+function deepmerge(target, source, options) {
+	options = options || {};
+	options.arrayMerge = options.arrayMerge || defaultArrayMerge;
+	options.isMergeableObject = options.isMergeableObject || isMergeableObject;
+	// cloneUnlessOtherwiseSpecified is added to `options` so that custom arrayMerge()
+	// implementations can use it. The caller may not replace it.
+	options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
+
+	var sourceIsArray = Array.isArray(source);
+	var targetIsArray = Array.isArray(target);
+	var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
+
+	if (!sourceAndTargetTypesMatch) {
+		return cloneUnlessOtherwiseSpecified(source, options)
+	} else if (sourceIsArray) {
+		return options.arrayMerge(target, source, options)
+	} else {
+		return mergeObject(target, source, options)
+	}
+}
+
+deepmerge.all = function deepmergeAll(array, options) {
+	if (!Array.isArray(array)) {
+		throw new Error('first argument should be an array')
+	}
+
+	return array.reduce(function(prev, next) {
+		return deepmerge(prev, next, options)
+	}, {})
+};
+
+var deepmerge_1 = deepmerge;
+
+module.exports = deepmerge_1;

web/node_modules/jest-config/node_modules/deepmerge/dist/umd.js

@@ -0,0 +1,139 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+	typeof define === 'function' && define.amd ? define(factory) :
+	(global = global || self, global.deepmerge = factory());
+}(this, function () { 'use strict';
+
+	var isMergeableObject = function isMergeableObject(value) {
+		return isNonNullObject(value)
+			&& !isSpecial(value)
+	};
+
+	function isNonNullObject(value) {
+		return !!value && typeof value === 'object'
+	}
+
+	function isSpecial(value) {
+		var stringValue = Object.prototype.toString.call(value);
+
+		return stringValue === '[object RegExp]'
+			|| stringValue === '[object Date]'
+			|| isReactElement(value)
+	}
+
+	// see https://github.com/facebook/react/blob/b5ac963fb791d1298e7f396236383bc955f916c1/src/isomorphic/classic/element/ReactElement.js#L21-L25
+	var canUseSymbol = typeof Symbol === 'function' && Symbol.for;
+	var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for('react.element') : 0xeac7;
+
+	function isReactElement(value) {
+		return value.$$typeof === REACT_ELEMENT_TYPE
+	}
+
+	function emptyTarget(val) {
+		return Array.isArray(val) ? [] : {}
+	}
+
+	function cloneUnlessOtherwiseSpecified(value, options) {
+		return (options.clone !== false && options.isMergeableObject(value))
+			? deepmerge(emptyTarget(value), value, options)
+			: value
+	}
+
+	function defaultArrayMerge(target, source, options) {
+		return target.concat(source).map(function(element) {
+			return cloneUnlessOtherwiseSpecified(element, options)
+		})
+	}
+
+	function getMergeFunction(key, options) {
+		if (!options.customMerge) {
+			return deepmerge
+		}
+		var customMerge = options.customMerge(key);
+		return typeof customMerge === 'function' ? customMerge : deepmerge
+	}
+
+	function getEnumerableOwnPropertySymbols(target) {
+		return Object.getOwnPropertySymbols
+			? Object.getOwnPropertySymbols(target).filter(function(symbol) {
+				return target.propertyIsEnumerable(symbol)
+			})
+			: []
+	}
+
+	function getKeys(target) {
+		return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target))
+	}
+
+	function propertyIsOnObject(object, property) {
+		try {
+			return property in object
+		} catch(_) {
+			return false
+		}
+	}
+
+	// Protects from prototype poisoning and unexpected merging up the prototype chain.
+	function propertyIsUnsafe(target, key) {
+		return propertyIsOnObject(target, key) // Properties are safe to merge if they don't exist in the target yet,
+			&& !(Object.hasOwnProperty.call(target, key) // unsafe if they exist up the prototype chain,
+				&& Object.propertyIsEnumerable.call(target, key)) // and also unsafe if they're nonenumerable.
+	}
+
+	function mergeObject(target, source, options) {
+		var destination = {};
+		if (options.isMergeableObject(target)) {
+			getKeys(target).forEach(function(key) {
+				destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
+			});
+		}
+		getKeys(source).forEach(function(key) {
+			if (propertyIsUnsafe(target, key)) {
+				return
+			}
+
+			if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
+				destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
+			} else {
+				destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
+			}
+		});
+		return destination
+	}
+
+	function deepmerge(target, source, options) {
+		options = options || {};
+		options.arrayMerge = options.arrayMerge || defaultArrayMerge;
+		options.isMergeableObject = options.isMergeableObject || isMergeableObject;
+		// cloneUnlessOtherwiseSpecified is added to `options` so that custom arrayMerge()
+		// implementations can use it. The caller may not replace it.
+		options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
+
+		var sourceIsArray = Array.isArray(source);
+		var targetIsArray = Array.isArray(target);
+		var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
+
+		if (!sourceAndTargetTypesMatch) {
+			return cloneUnlessOtherwiseSpecified(source, options)
+		} else if (sourceIsArray) {
+			return options.arrayMerge(target, source, options)
+		} else {
+			return mergeObject(target, source, options)
+		}
+	}
+
+	deepmerge.all = function deepmergeAll(array, options) {
+		if (!Array.isArray(array)) {
+			throw new Error('first argument should be an array')
+		}
+
+		return array.reduce(function(prev, next) {
+			return deepmerge(prev, next, options)
+		}, {})
+	};
+
+	var deepmerge_1 = deepmerge;
+
+	return deepmerge_1;
+
+}));

web/node_modules/jest-config/node_modules/deepmerge/index.d.ts

@@ -0,0 +1,16 @@
+declare function deepmerge<T>(x: Partial<T>, y: Partial<T>, options?: deepmerge.Options): T;
+declare function deepmerge<T1, T2>(x: Partial<T1>, y: Partial<T2>, options?: deepmerge.Options): T1 & T2;
+
+declare namespace deepmerge {
+	export interface Options {
+		arrayMerge?(target: any[], source: any[], options?: Options): any[];
+		clone?: boolean;
+		customMerge?: (key: string, options?: Options) => ((x: any, y: any) => any) | undefined;
+		isMergeableObject?(value: object): boolean;
+	}
+
+	export function all (objects: object[], options?: Options): object;
+	export function all<T> (objects: Partial<T>[], options?: Options): T;
+}
+
+export = deepmerge;

web/node_modules/jest-config/node_modules/deepmerge/index.js

@@ -0,0 +1,106 @@
+var defaultIsMergeableObject = require('is-mergeable-object')
+
+function emptyTarget(val) {
+	return Array.isArray(val) ? [] : {}
+}
+
+function cloneUnlessOtherwiseSpecified(value, options) {
+	return (options.clone !== false && options.isMergeableObject(value))
+		? deepmerge(emptyTarget(value), value, options)
+		: value
+}
+
+function defaultArrayMerge(target, source, options) {
+	return target.concat(source).map(function(element) {
+		return cloneUnlessOtherwiseSpecified(element, options)
+	})
+}
+
+function getMergeFunction(key, options) {
+	if (!options.customMerge) {
+		return deepmerge
+	}
+	var customMerge = options.customMerge(key)
+	return typeof customMerge === 'function' ? customMerge : deepmerge
+}
+
+function getEnumerableOwnPropertySymbols(target) {
+	return Object.getOwnPropertySymbols
+		? Object.getOwnPropertySymbols(target).filter(function(symbol) {
+			return target.propertyIsEnumerable(symbol)
+		})
+		: []
+}
+
+function getKeys(target) {
+	return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target))
+}
+
+function propertyIsOnObject(object, property) {
+	try {
+		return property in object
+	} catch(_) {
+		return false
+	}
+}
+
+// Protects from prototype poisoning and unexpected merging up the prototype chain.
+function propertyIsUnsafe(target, key) {
+	return propertyIsOnObject(target, key) // Properties are safe to merge if they don't exist in the target yet,
+		&& !(Object.hasOwnProperty.call(target, key) // unsafe if they exist up the prototype chain,
+			&& Object.propertyIsEnumerable.call(target, key)) // and also unsafe if they're nonenumerable.
+}
+
+function mergeObject(target, source, options) {
+	var destination = {}
+	if (options.isMergeableObject(target)) {
+		getKeys(target).forEach(function(key) {
+			destination[key] = cloneUnlessOtherwiseSpecified(target[key], options)
+		})
+	}
+	getKeys(source).forEach(function(key) {
+		if (propertyIsUnsafe(target, key)) {
+			return
+		}
+
+		if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
+			destination[key] = getMergeFunction(key, options)(target[key], source[key], options)
+		} else {
+			destination[key] = cloneUnlessOtherwiseSpecified(source[key], options)
+		}
+	})
+	return destination
+}
+
+function deepmerge(target, source, options) {
+	options = options || {}
+	options.arrayMerge = options.arrayMerge || defaultArrayMerge
+	options.isMergeableObject = options.isMergeableObject || defaultIsMergeableObject
+	// cloneUnlessOtherwiseSpecified is added to `options` so that custom arrayMerge()
+	// implementations can use it. The caller may not replace it.
+	options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified
+
+	var sourceIsArray = Array.isArray(source)
+	var targetIsArray = Array.isArray(target)
+	var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray
+
+	if (!sourceAndTargetTypesMatch) {
+		return cloneUnlessOtherwiseSpecified(source, options)
+	} else if (sourceIsArray) {
+		return options.arrayMerge(target, source, options)
+	} else {
+		return mergeObject(target, source, options)
+	}
+}
+
+deepmerge.all = function deepmergeAll(array, options) {
+	if (!Array.isArray(array)) {
+		throw new Error('first argument should be an array')
+	}
+
+	return array.reduce(function(prev, next) {
+		return deepmerge(prev, next, options)
+	}, {})
+}
+
+module.exports = deepmerge

web/node_modules/jest-config/node_modules/deepmerge/license.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2012 James Halliday, Josh Duff, and other contributors
+
+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.

web/node_modules/jest-config/node_modules/deepmerge/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "deepmerge",
+  "description": "A library for deep (recursive) merging of Javascript objects",
+  "keywords": [
+    "merge",
+    "deep",
+    "extend",
+    "copy",
+    "clone",
+    "recursive"
+  ],
+  "version": "4.2.2",
+  "homepage": "https://github.com/TehShrike/deepmerge",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/TehShrike/deepmerge.git"
+  },
+  "main": "dist/cjs.js",
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "scripts": {
+    "build": "rollup -c",
+    "test": "npm run build && tape test/*.js && jsmd readme.md && npm run test:typescript",
+    "test:typescript": "tsc --noEmit test/typescript.ts && ts-node test/typescript.ts",
+    "size": "npm run build && uglifyjs --compress --mangle -- ./dist/umd.js | gzip -c | wc -c"
+  },
+  "devDependencies": {
+    "@types/node": "^8.10.54",
+    "is-mergeable-object": "1.1.0",
+    "is-plain-object": "^2.0.4",
+    "jsmd": "^1.0.2",
+    "rollup": "^1.23.1",
+    "rollup-plugin-commonjs": "^10.1.0",
+    "rollup-plugin-node-resolve": "^5.2.0",
+    "tape": "^4.11.0",
+    "ts-node": "7.0.1",
+    "typescript": "=2.2.2",
+    "uglify-js": "^3.6.1"
+  },
+  "license": "MIT",
+  "dependencies": {}
+}

web/node_modules/jest-config/node_modules/deepmerge/readme.md

@@ -0,0 +1,264 @@
+# deepmerge
+
+Merges the enumerable properties of two or more objects deeply.
+
+> UMD bundle is 723B minified+gzipped
+
+## Getting Started
+
+### Example Usage
+<!--js
+const merge = require('./')
+-->
+
+```js
+const x = {
+	foo: { bar: 3 },
+	array: [{
+		does: 'work',
+		too: [ 1, 2, 3 ]
+	}]
+}
+
+const y = {
+	foo: { baz: 4 },
+	quux: 5,
+	array: [{
+		does: 'work',
+		too: [ 4, 5, 6 ]
+	}, {
+		really: 'yes'
+	}]
+}
+
+const output = {
+	foo: {
+		bar: 3,
+		baz: 4
+	},
+	array: [{
+		does: 'work',
+		too: [ 1, 2, 3 ]
+	}, {
+		does: 'work',
+		too: [ 4, 5, 6 ]
+	}, {
+		really: 'yes'
+	}],
+	quux: 5
+}
+
+merge(x, y) // => output
+```
+
+
+### Installation
+
+With [npm](http://npmjs.org) do:
+
+```sh
+npm install deepmerge
+```
+
+deepmerge can be used directly in the browser without the use of package managers/bundlers as well:  [UMD version from unpkg.com](https://unpkg.com/deepmerge/dist/umd.js).
+
+
+### Include
+
+deepmerge exposes a CommonJS entry point:
+
+```
+const merge = require('deepmerge')
+```
+
+The ESM entry point was dropped due to a [Webpack bug](https://github.com/webpack/webpack/issues/6584).
+
+# API
+
+
+## `merge(x, y, [options])`
+
+Merge two objects `x` and `y` deeply, returning a new merged object with the
+elements from both `x` and `y`.
+
+If an element at the same key is present for both `x` and `y`, the value from
+`y` will appear in the result.
+
+Merging creates a new object, so that neither `x` or `y` is modified.
+
+**Note:** By default, arrays are merged by concatenating them.
+
+## `merge.all(arrayOfObjects, [options])`
+
+Merges any number of objects into a single result object.
+
+```js
+const foobar = { foo: { bar: 3 } }
+const foobaz = { foo: { baz: 4 } }
+const bar = { bar: 'yay!' }
+
+merge.all([ foobar, foobaz, bar ]) // => { foo: { bar: 3, baz: 4 }, bar: 'yay!' }
+```
+
+
+## Options
+
+### `arrayMerge`
+
+There are multiple ways to merge two arrays, below are a few examples but you can also create your own custom function.
+
+Your `arrayMerge` function will be called with three arguments: a `target` array, the `source` array, and an `options` object with these properties:
+
+- `isMergeableObject(value)`
+- `cloneUnlessOtherwiseSpecified(value, options)`
+
+#### `arrayMerge` example: overwrite target array
+
+Overwrites the existing array values completely rather than concatenating them:
+
+```js
+const overwriteMerge = (destinationArray, sourceArray, options) => sourceArray
+
+merge(
+	[1, 2, 3],
+	[3, 2, 1],
+	{ arrayMerge: overwriteMerge }
+) // => [3, 2, 1]
+```
+
+#### `arrayMerge` example: combine arrays
+
+Combines objects at the same index in the two arrays.
+
+This was the default array merging algorithm pre-version-2.0.0.
+
+```js
+const combineMerge = (target, source, options) => {
+	const destination = target.slice()
+
+	source.forEach((item, index) => {
+		if (typeof destination[index] === 'undefined') {
+			destination[index] = options.cloneUnlessOtherwiseSpecified(item, options)
+		} else if (options.isMergeableObject(item)) {
+			destination[index] = merge(target[index], item, options)
+		} else if (target.indexOf(item) === -1) {
+			destination.push(item)
+		}
+	})
+	return destination
+}
+
+merge(
+	[{ a: true }],
+	[{ b: true }, 'ah yup'],
+	{ arrayMerge: combineMerge }
+) // => [{ a: true, b: true }, 'ah yup']
+```
+
+### `isMergeableObject`
+
+By default, deepmerge clones every property from almost every kind of object.
+
+You may not want this, if your objects are of special types, and you want to copy the whole object instead of just copying its properties.
+
+You can accomplish this by passing in a function for the `isMergeableObject` option.
+
+If you only want to clone properties of plain objects, and ignore all "special" kinds of instantiated objects, you probably want to drop in [`is-plain-object`](https://github.com/jonschlinkert/is-plain-object).
+
+```js
+const isPlainObject = require('is-plain-object')
+
+function SuperSpecial() {
+	this.special = 'oh yeah man totally'
+}
+
+const instantiatedSpecialObject = new SuperSpecial()
+
+const target = {
+	someProperty: {
+		cool: 'oh for sure'
+	}
+}
+
+const source = {
+	someProperty: instantiatedSpecialObject
+}
+
+const defaultOutput = merge(target, source)
+
+defaultOutput.someProperty.cool // => 'oh for sure'
+defaultOutput.someProperty.special // => 'oh yeah man totally'
+defaultOutput.someProperty instanceof SuperSpecial // => false
+
+const customMergeOutput = merge(target, source, {
+	isMergeableObject: isPlainObject
+})
+
+customMergeOutput.someProperty.cool // => undefined
+customMergeOutput.someProperty.special // => 'oh yeah man totally'
+customMergeOutput.someProperty instanceof SuperSpecial // => true
+```
+
+### `customMerge`
+
+Specifies a function which can be used to override the default merge behavior for a property, based on the property name.
+
+The `customMerge` function will be passed the key for each property, and should return the function which should be used to merge the values for that property.
+
+It may also return undefined, in which case the default merge behaviour will be used.
+
+```js
+const alex = {
+	name: {
+		first: 'Alex',
+		last: 'Alexson'
+	},
+	pets: ['Cat', 'Parrot']
+}
+
+const tony = {
+	name: {
+		first: 'Tony',
+		last: 'Tonison'
+	},
+	pets: ['Dog']
+}
+
+const mergeNames = (nameA, nameB) => `${nameA.first} and ${nameB.first}`
+
+const options = {
+	customMerge: (key) => {
+		if (key === 'name') {
+			return mergeNames
+		}
+	}
+}
+
+const result = merge(alex, tony, options)
+
+result.name // => 'Alex and Tony'
+result.pets // => ['Cat', 'Parrot', 'Dog']
+```
+
+
+### `clone`
+
+*Deprecated.*
+
+Defaults to `true`.
+
+If `clone` is `false` then child objects will be copied directly instead of being cloned.  This was the default behavior before version 2.x.
+
+
+# Testing
+
+With [npm](http://npmjs.org) do:
+
+```sh
+npm test
+```
+
+
+# License
+
+MIT

web/node_modules/jest-config/node_modules/deepmerge/rollup.config.js

@@ -0,0 +1,22 @@
+import resolve from 'rollup-plugin-node-resolve'
+import commonjs from 'rollup-plugin-commonjs'
+import pkg from './package.json'
+
+export default {
+	input: `index.js`,
+	plugins: [
+		commonjs(),
+		resolve(),
+	],
+	output: [
+		{
+			file: pkg.main,
+			format: `cjs`
+		},
+		{
+			name: 'deepmerge',
+			file: 'dist/umd.js',
+			format: `umd`
+		},
+	],
+}

web/node_modules/jest-config/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.

web/node_modules/jest-config/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;
+}

web/node_modules/jest-config/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;

web/node_modules/jest-config/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 {};

web/node_modules/jest-config/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);
+}

web/node_modules/jest-config/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;

web/node_modules/jest-config/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;

web/node_modules/jest-config/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;

web/node_modules/jest-config/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);
+}

web/node_modules/jest-config/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 {};

web/node_modules/jest-config/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;
+}

web/node_modules/jest-config/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;

web/node_modules/jest-config/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';
+}

web/node_modules/jest-config/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 {};

web/node_modules/jest-config/node_modules/jest-resolve/build/types.js

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

web/node_modules/jest-config/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"
+}

web/node_modules/jest-config/node_modules/pretty-format/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.

web/node_modules/jest-config/node_modules/pretty-format/README.md

@@ -0,0 +1,454 @@
+# pretty-format
+
+Stringify any JavaScript value.
+
+- Serialize built-in JavaScript types.
+- Serialize application-specific data types with built-in or user-defined plugins.
+
+## Installation
+
+```sh
+$ yarn add pretty-format
+```
+
+## Usage
+
+```js
+const prettyFormat = require('pretty-format'); // CommonJS
+```
+
+```js
+import prettyFormat from 'pretty-format'; // ES2015 modules
+```
+
+```js
+const val = {object: {}};
+val.circularReference = val;
+val[Symbol('foo')] = 'foo';
+val.map = new Map([['prop', 'value']]);
+val.array = [-0, Infinity, NaN];
+
+console.log(prettyFormat(val));
+/*
+Object {
+  "array": Array [
+    -0,
+    Infinity,
+    NaN,
+  ],
+  "circularReference": [Circular],
+  "map": Map {
+    "prop" => "value",
+  },
+  "object": Object {},
+  Symbol(foo): "foo",
+}
+*/
+```
+
+## Usage with options
+
+```js
+function onClick() {}
+
+console.log(prettyFormat(onClick));
+/*
+[Function onClick]
+*/
+
+const options = {
+  printFunctionName: false,
+};
+console.log(prettyFormat(onClick, options));
+/*
+[Function]
+*/
+```
+
+<!-- prettier-ignore -->
+| key                 | type      | default    | description                                             |
+| :------------------ | :-------- | :--------- | :------------------------------------------------------ |
+| `callToJSON`        | `boolean` | `true`     | call `toJSON` method (if it exists) on objects          |
+| `escapeRegex`       | `boolean` | `false`    | escape special characters in regular expressions        |
+| `escapeString`      | `boolean` | `true`     | escape special characters in strings                    |
+| `highlight`         | `boolean` | `false`    | highlight syntax with colors in terminal (some plugins) |
+| `indent`            | `number`  | `2`        | spaces in each level of indentation                     |
+| `maxDepth`          | `number`  | `Infinity` | levels to print in arrays, objects, elements, and so on |
+| `min`               | `boolean` | `false`    | minimize added space: no indentation nor line breaks    |
+| `plugins`           | `array`   | `[]`       | plugins to serialize application-specific data types    |
+| `printFunctionName` | `boolean` | `true`     | include or omit the name of a function                  |
+| `theme`             | `object`  |            | colors to highlight syntax in terminal                  |
+
+Property values of `theme` are from [ansi-styles colors](https://github.com/chalk/ansi-styles#colors)
+
+```js
+const DEFAULT_THEME = {
+  comment: 'gray',
+  content: 'reset',
+  prop: 'yellow',
+  tag: 'cyan',
+  value: 'green',
+};
+```
+
+## Usage with plugins
+
+The `pretty-format` package provides some built-in plugins, including:
+
+- `ReactElement` for elements from `react`
+- `ReactTestComponent` for test objects from `react-test-renderer`
+
+```js
+// CommonJS
+const React = require('react');
+const renderer = require('react-test-renderer');
+const prettyFormat = require('pretty-format');
+const ReactElement = prettyFormat.plugins.ReactElement;
+const ReactTestComponent = prettyFormat.plugins.ReactTestComponent;
+```
+
+```js
+import React from 'react';
+import renderer from 'react-test-renderer';
+// ES2015 modules and destructuring assignment
+import prettyFormat from 'pretty-format';
+const {ReactElement, ReactTestComponent} = prettyFormat.plugins;
+```
+
+```js
+const onClick = () => {};
+const element = React.createElement('button', {onClick}, 'Hello World');
+
+const formatted1 = prettyFormat(element, {
+  plugins: [ReactElement],
+  printFunctionName: false,
+});
+const formatted2 = prettyFormat(renderer.create(element).toJSON(), {
+  plugins: [ReactTestComponent],
+  printFunctionName: false,
+});
+/*
+<button
+  onClick=[Function]
+>
+  Hello World
+</button>
+*/
+```
+
+## Usage in Jest
+
+For snapshot tests, Jest uses `pretty-format` with options that include some of its built-in plugins. For this purpose, plugins are also known as **snapshot serializers**.
+
+To serialize application-specific data types, you can add modules to `devDependencies` of a project, and then:
+
+In an **individual** test file, you can add a module as follows. It precedes any modules from Jest configuration.
+
+```js
+import serializer from 'my-serializer-module';
+expect.addSnapshotSerializer(serializer);
+
+// tests which have `expect(value).toMatchSnapshot()` assertions
+```
+
+For **all** test files, you can specify modules in Jest configuration. They precede built-in plugins for React, HTML, and Immutable.js data types. For example, in a `package.json` file:
+
+```json
+{
+  "jest": {
+    "snapshotSerializers": ["my-serializer-module"]
+  }
+}
+```
+
+## Writing plugins
+
+A plugin is a JavaScript object.
+
+If `options` has a `plugins` array: for the first plugin whose `test(val)` method returns a truthy value, then `prettyFormat(val, options)` returns the result from either:
+
+- `serialize(val, …)` method of the **improved** interface (available in **version 21** or later)
+- `print(val, …)` method of the **original** interface (if plugin does not have `serialize` method)
+
+### test
+
+Write `test` so it can receive `val` argument of any type. To serialize **objects** which have certain properties, then a guarded expression like `val != null && …` or more concise `val && …` prevents the following errors:
+
+- `TypeError: Cannot read property 'whatever' of null`
+- `TypeError: Cannot read property 'whatever' of undefined`
+
+For example, `test` method of built-in `ReactElement` plugin:
+
+```js
+const elementSymbol = Symbol.for('react.element');
+const test = val => val && val.$$typeof === elementSymbol;
+```
+
+Pay attention to efficiency in `test` because `pretty-format` calls it often.
+
+### serialize
+
+The **improved** interface is available in **version 21** or later.
+
+Write `serialize` to return a string, given the arguments:
+
+- `val` which “passed the test”
+- unchanging `config` object: derived from `options`
+- current `indentation` string: concatenate to `indent` from `config`
+- current `depth` number: compare to `maxDepth` from `config`
+- current `refs` array: find circular references in objects
+- `printer` callback function: serialize children
+
+### config
+
+<!-- prettier-ignore -->
+| key                 | type      | description                                             |
+| :------------------ | :-------- | :------------------------------------------------------ |
+| `callToJSON`        | `boolean` | call `toJSON` method (if it exists) on objects          |
+| `colors`            | `Object`  | escape codes for colors to highlight syntax             |
+| `escapeRegex`       | `boolean` | escape special characters in regular expressions        |
+| `escapeString`      | `boolean` | escape special characters in strings                    |
+| `indent`            | `string`  | spaces in each level of indentation                     |
+| `maxDepth`          | `number`  | levels to print in arrays, objects, elements, and so on |
+| `min`               | `boolean` | minimize added space: no indentation nor line breaks    |
+| `plugins`           | `array`   | plugins to serialize application-specific data types    |
+| `printFunctionName` | `boolean` | include or omit the name of a function                  |
+| `spacingInner`      | `strong`  | spacing to separate items in a list                     |
+| `spacingOuter`      | `strong`  | spacing to enclose a list of items                      |
+
+Each property of `colors` in `config` corresponds to a property of `theme` in `options`:
+
+- the key is the same (for example, `tag`)
+- the value in `colors` is a object with `open` and `close` properties whose values are escape codes from [ansi-styles](https://github.com/chalk/ansi-styles) for the color value in `theme` (for example, `'cyan'`)
+
+Some properties in `config` are derived from `min` in `options`:
+
+- `spacingInner` and `spacingOuter` are **newline** if `min` is `false`
+- `spacingInner` is **space** and `spacingOuter` is **empty string** if `min` is `true`
+
+### Example of serialize and test
+
+This plugin is a pattern you can apply to serialize composite data types. Side note: `pretty-format` does not need a plugin to serialize arrays.
+
+```js
+// We reused more code when we factored out a function for child items
+// that is independent of depth, name, and enclosing punctuation (see below).
+const SEPARATOR = ',';
+function serializeItems(items, config, indentation, depth, refs, printer) {
+  if (items.length === 0) {
+    return '';
+  }
+  const indentationItems = indentation + config.indent;
+  return (
+    config.spacingOuter +
+    items
+      .map(
+        item =>
+          indentationItems +
+          printer(item, config, indentationItems, depth, refs), // callback
+      )
+      .join(SEPARATOR + config.spacingInner) +
+    (config.min ? '' : SEPARATOR) + // following the last item
+    config.spacingOuter +
+    indentation
+  );
+}
+
+const plugin = {
+  test(val) {
+    return Array.isArray(val);
+  },
+  serialize(array, config, indentation, depth, refs, printer) {
+    const name = array.constructor.name;
+    return ++depth > config.maxDepth
+      ? '[' + name + ']'
+      : (config.min ? '' : name + ' ') +
+          '[' +
+          serializeItems(array, config, indentation, depth, refs, printer) +
+          ']';
+  },
+};
+```
+
+```js
+const val = {
+  filter: 'completed',
+  items: [
+    {
+      text: 'Write test',
+      completed: true,
+    },
+    {
+      text: 'Write serialize',
+      completed: true,
+    },
+  ],
+};
+```
+
+```js
+console.log(
+  prettyFormat(val, {
+    plugins: [plugin],
+  }),
+);
+/*
+Object {
+  "filter": "completed",
+  "items": Array [
+    Object {
+      "completed": true,
+      "text": "Write test",
+    },
+    Object {
+      "completed": true,
+      "text": "Write serialize",
+    },
+  ],
+}
+*/
+```
+
+```js
+console.log(
+  prettyFormat(val, {
+    indent: 4,
+    plugins: [plugin],
+  }),
+);
+/*
+Object {
+    "filter": "completed",
+    "items": Array [
+        Object {
+            "completed": true,
+            "text": "Write test",
+        },
+        Object {
+            "completed": true,
+            "text": "Write serialize",
+        },
+    ],
+}
+*/
+```
+
+```js
+console.log(
+  prettyFormat(val, {
+    maxDepth: 1,
+    plugins: [plugin],
+  }),
+);
+/*
+Object {
+  "filter": "completed",
+  "items": [Array],
+}
+*/
+```
+
+```js
+console.log(
+  prettyFormat(val, {
+    min: true,
+    plugins: [plugin],
+  }),
+);
+/*
+{"filter": "completed", "items": [{"completed": true, "text": "Write test"}, {"completed": true, "text": "Write serialize"}]}
+*/
+```
+
+### print
+
+The **original** interface is adequate for plugins:
+
+- that **do not** depend on options other than `highlight` or `min`
+- that **do not** depend on `depth` or `refs` in recursive traversal, and
+- if values either
+  - do **not** require indentation, or
+  - do **not** occur as children of JavaScript data structures (for example, array)
+
+Write `print` to return a string, given the arguments:
+
+- `val` which “passed the test”
+- current `printer(valChild)` callback function: serialize children
+- current `indenter(lines)` callback function: indent lines at the next level
+- unchanging `config` object: derived from `options`
+- unchanging `colors` object: derived from `options`
+
+The 3 properties of `config` are `min` in `options` and:
+
+- `spacing` and `edgeSpacing` are **newline** if `min` is `false`
+- `spacing` is **space** and `edgeSpacing` is **empty string** if `min` is `true`
+
+Each property of `colors` corresponds to a property of `theme` in `options`:
+
+- the key is the same (for example, `tag`)
+- the value in `colors` is a object with `open` and `close` properties whose values are escape codes from [ansi-styles](https://github.com/chalk/ansi-styles) for the color value in `theme` (for example, `'cyan'`)
+
+### Example of print and test
+
+This plugin prints functions with the **number of named arguments** excluding rest argument.
+
+```js
+const plugin = {
+  print(val) {
+    return `[Function ${val.name || 'anonymous'} ${val.length}]`;
+  },
+  test(val) {
+    return typeof val === 'function';
+  },
+};
+```
+
+```js
+const val = {
+  onClick(event) {},
+  render() {},
+};
+
+prettyFormat(val, {
+  plugins: [plugin],
+});
+/*
+Object {
+  "onClick": [Function onClick 1],
+  "render": [Function render 0],
+}
+*/
+
+prettyFormat(val);
+/*
+Object {
+  "onClick": [Function onClick],
+  "render": [Function render],
+}
+*/
+```
+
+This plugin **ignores** the `printFunctionName` option. That limitation of the original `print` interface is a reason to use the improved `serialize` interface, described above.
+
+```js
+prettyFormat(val, {
+  plugins: [pluginOld],
+  printFunctionName: false,
+});
+/*
+Object {
+  "onClick": [Function onClick 1],
+  "render": [Function render 0],
+}
+*/
+
+prettyFormat(val, {
+  printFunctionName: false,
+});
+/*
+Object {
+  "onClick": [Function],
+  "render": [Function],
+}
+*/
+```

web/node_modules/jest-config/node_modules/pretty-format/build/collections.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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, Printer, Refs } from './types';
+/**
+ * Return entries (for example, of a map)
+ * with spacing, indentation, and comma
+ * without surrounding punctuation (for example, braces)
+ */
+export declare function printIteratorEntries(iterator: Iterator<[unknown, unknown]>, config: Config, indentation: string, depth: number, refs: Refs, printer: Printer, separator?: string): string;
+/**
+ * Return values (for example, of a set)
+ * with spacing, indentation, and comma
+ * without surrounding punctuation (braces or brackets)
+ */
+export declare function printIteratorValues(iterator: Iterator<unknown>, config: Config, indentation: string, depth: number, refs: Refs, printer: Printer): string;
+/**
+ * Return items (for example, of an array)
+ * with spacing, indentation, and comma
+ * without surrounding punctuation (for example, brackets)
+ **/
+export declare function printListItems(list: ArrayLike<unknown>, config: Config, indentation: string, depth: number, refs: Refs, printer: Printer): string;
+/**
+ * Return properties of an object
+ * with spacing, indentation, and comma
+ * without surrounding punctuation (for example, braces)
+ */
+export declare function printObjectProperties(val: Record<string, unknown>, config: Config, indentation: string, depth: number, refs: Refs, printer: Printer): string;

web/node_modules/jest-config/node_modules/pretty-format/build/collections.js

@@ -0,0 +1,185 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.printIteratorEntries = printIteratorEntries;
+exports.printIteratorValues = printIteratorValues;
+exports.printListItems = printListItems;
+exports.printObjectProperties = printObjectProperties;
+
+/**
+ * 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 getKeysOfEnumerableProperties = object => {
+  const keys = Object.keys(object).sort();
+
+  if (Object.getOwnPropertySymbols) {
+    Object.getOwnPropertySymbols(object).forEach(symbol => {
+      if (Object.getOwnPropertyDescriptor(object, symbol).enumerable) {
+        keys.push(symbol);
+      }
+    });
+  }
+
+  return keys;
+};
+/**
+ * Return entries (for example, of a map)
+ * with spacing, indentation, and comma
+ * without surrounding punctuation (for example, braces)
+ */
+
+function printIteratorEntries(
+  iterator,
+  config,
+  indentation,
+  depth,
+  refs,
+  printer, // Too bad, so sad that separator for ECMAScript Map has been ' => '
+  // What a distracting diff if you change a data structure to/from
+  // ECMAScript Object or Immutable.Map/OrderedMap which use the default.
+  separator = ': '
+) {
+  let result = '';
+  let current = iterator.next();
+
+  if (!current.done) {
+    result += config.spacingOuter;
+    const indentationNext = indentation + config.indent;
+
+    while (!current.done) {
+      const name = printer(
+        current.value[0],
+        config,
+        indentationNext,
+        depth,
+        refs
+      );
+      const value = printer(
+        current.value[1],
+        config,
+        indentationNext,
+        depth,
+        refs
+      );
+      result += indentationNext + name + separator + value;
+      current = iterator.next();
+
+      if (!current.done) {
+        result += ',' + config.spacingInner;
+      } else if (!config.min) {
+        result += ',';
+      }
+    }
+
+    result += config.spacingOuter + indentation;
+  }
+
+  return result;
+}
+/**
+ * Return values (for example, of a set)
+ * with spacing, indentation, and comma
+ * without surrounding punctuation (braces or brackets)
+ */
+
+function printIteratorValues(
+  iterator,
+  config,
+  indentation,
+  depth,
+  refs,
+  printer
+) {
+  let result = '';
+  let current = iterator.next();
+
+  if (!current.done) {
+    result += config.spacingOuter;
+    const indentationNext = indentation + config.indent;
+
+    while (!current.done) {
+      result +=
+        indentationNext +
+        printer(current.value, config, indentationNext, depth, refs);
+      current = iterator.next();
+
+      if (!current.done) {
+        result += ',' + config.spacingInner;
+      } else if (!config.min) {
+        result += ',';
+      }
+    }
+
+    result += config.spacingOuter + indentation;
+  }
+
+  return result;
+}
+/**
+ * Return items (for example, of an array)
+ * with spacing, indentation, and comma
+ * without surrounding punctuation (for example, brackets)
+ **/
+
+function printListItems(list, config, indentation, depth, refs, printer) {
+  let result = '';
+
+  if (list.length) {
+    result += config.spacingOuter;
+    const indentationNext = indentation + config.indent;
+
+    for (let i = 0; i < list.length; i++) {
+      result +=
+        indentationNext +
+        printer(list[i], config, indentationNext, depth, refs);
+
+      if (i < list.length - 1) {
+        result += ',' + config.spacingInner;
+      } else if (!config.min) {
+        result += ',';
+      }
+    }
+
+    result += config.spacingOuter + indentation;
+  }
+
+  return result;
+}
+/**
+ * Return properties of an object
+ * with spacing, indentation, and comma
+ * without surrounding punctuation (for example, braces)
+ */
+
+function printObjectProperties(val, config, indentation, depth, refs, printer) {
+  let result = '';
+  const keys = getKeysOfEnumerableProperties(val);
+
+  if (keys.length) {
+    result += config.spacingOuter;
+    const indentationNext = indentation + config.indent;
+
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const name = printer(key, config, indentationNext, depth, refs);
+      const value = printer(val[key], config, indentationNext, depth, refs);
+      result += indentationNext + name + ': ' + value;
+
+      if (i < keys.length - 1) {
+        result += ',' + config.spacingInner;
+      } else if (!config.min) {
+        result += ',';
+      }
+    }
+
+    result += config.spacingOuter + indentation;
+  }
+
+  return result;
+}

web/node_modules/jest-config/node_modules/pretty-format/build/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 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 * as PrettyFormat from './types';
+/**
+ * Returns a presentation string of your `val` object
+ * @param val any potential JavaScript object
+ * @param options Custom settings
+ */
+declare function prettyFormat(val: unknown, options?: PrettyFormat.OptionsReceived): string;
+declare namespace prettyFormat {
+    var plugins: {
+        AsymmetricMatcher: PrettyFormat.NewPlugin;
+        ConvertAnsi: PrettyFormat.NewPlugin;
+        DOMCollection: PrettyFormat.NewPlugin;
+        DOMElement: PrettyFormat.NewPlugin;
+        Immutable: PrettyFormat.NewPlugin;
+        ReactElement: PrettyFormat.NewPlugin;
+        ReactTestComponent: PrettyFormat.NewPlugin;
+    };
+}
+declare namespace prettyFormat {
+    type Colors = PrettyFormat.Colors;
+    type Config = PrettyFormat.Config;
+    type Options = PrettyFormat.Options;
+    type OptionsReceived = PrettyFormat.OptionsReceived;
+    type OldPlugin = PrettyFormat.OldPlugin;
+    type NewPlugin = PrettyFormat.NewPlugin;
+    type Plugin = PrettyFormat.Plugin;
+    type Plugins = PrettyFormat.Plugins;
+    type Refs = PrettyFormat.Refs;
+    type Theme = PrettyFormat.Theme;
+}
+export = prettyFormat;

web/node_modules/jest-config/node_modules/pretty-format/build/index.js

@@ -0,0 +1,560 @@
+'use strict';
+
+var _ansiStyles = _interopRequireDefault(require('ansi-styles'));
+
+var _collections = require('./collections');
+
+var _AsymmetricMatcher = _interopRequireDefault(
+  require('./plugins/AsymmetricMatcher')
+);
+
+var _ConvertAnsi = _interopRequireDefault(require('./plugins/ConvertAnsi'));
+
+var _DOMCollection = _interopRequireDefault(require('./plugins/DOMCollection'));
+
+var _DOMElement = _interopRequireDefault(require('./plugins/DOMElement'));
+
+var _Immutable = _interopRequireDefault(require('./plugins/Immutable'));
+
+var _ReactElement = _interopRequireDefault(require('./plugins/ReactElement'));
+
+var _ReactTestComponent = _interopRequireDefault(
+  require('./plugins/ReactTestComponent')
+);
+
+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.
+ */
+
+/* eslint-disable local/ban-types-eventually */
+const toString = Object.prototype.toString;
+const toISOString = Date.prototype.toISOString;
+const errorToString = Error.prototype.toString;
+const regExpToString = RegExp.prototype.toString;
+/**
+ * Explicitly comparing typeof constructor to function avoids undefined as name
+ * when mock identity-obj-proxy returns the key as the value for any key.
+ */
+
+const getConstructorName = val =>
+  (typeof val.constructor === 'function' && val.constructor.name) || 'Object';
+/* global window */
+
+/** Is val is equal to global window object? Works even if it does not exist :) */
+
+const isWindow = val => typeof window !== 'undefined' && val === window;
+
+const SYMBOL_REGEXP = /^Symbol\((.*)\)(.*)$/;
+const NEWLINE_REGEXP = /\n/gi;
+
+class PrettyFormatPluginError extends Error {
+  constructor(message, stack) {
+    super(message);
+    this.stack = stack;
+    this.name = this.constructor.name;
+  }
+}
+
+function isToStringedArrayType(toStringed) {
+  return (
+    toStringed === '[object Array]' ||
+    toStringed === '[object ArrayBuffer]' ||
+    toStringed === '[object DataView]' ||
+    toStringed === '[object Float32Array]' ||
+    toStringed === '[object Float64Array]' ||
+    toStringed === '[object Int8Array]' ||
+    toStringed === '[object Int16Array]' ||
+    toStringed === '[object Int32Array]' ||
+    toStringed === '[object Uint8Array]' ||
+    toStringed === '[object Uint8ClampedArray]' ||
+    toStringed === '[object Uint16Array]' ||
+    toStringed === '[object Uint32Array]'
+  );
+}
+
+function printNumber(val) {
+  return Object.is(val, -0) ? '-0' : String(val);
+}
+
+function printBigInt(val) {
+  return String(`${val}n`);
+}
+
+function printFunction(val, printFunctionName) {
+  if (!printFunctionName) {
+    return '[Function]';
+  }
+
+  return '[Function ' + (val.name || 'anonymous') + ']';
+}
+
+function printSymbol(val) {
+  return String(val).replace(SYMBOL_REGEXP, 'Symbol($1)');
+}
+
+function printError(val) {
+  return '[' + errorToString.call(val) + ']';
+}
+/**
+ * The first port of call for printing an object, handles most of the
+ * data-types in JS.
+ */
+
+function printBasicValue(val, printFunctionName, escapeRegex, escapeString) {
+  if (val === true || val === false) {
+    return '' + val;
+  }
+
+  if (val === undefined) {
+    return 'undefined';
+  }
+
+  if (val === null) {
+    return 'null';
+  }
+
+  const typeOf = typeof val;
+
+  if (typeOf === 'number') {
+    return printNumber(val);
+  }
+
+  if (typeOf === 'bigint') {
+    return printBigInt(val);
+  }
+
+  if (typeOf === 'string') {
+    if (escapeString) {
+      return '"' + val.replace(/"|\\/g, '\\$&') + '"';
+    }
+
+    return '"' + val + '"';
+  }
+
+  if (typeOf === 'function') {
+    return printFunction(val, printFunctionName);
+  }
+
+  if (typeOf === 'symbol') {
+    return printSymbol(val);
+  }
+
+  const toStringed = toString.call(val);
+
+  if (toStringed === '[object WeakMap]') {
+    return 'WeakMap {}';
+  }
+
+  if (toStringed === '[object WeakSet]') {
+    return 'WeakSet {}';
+  }
+
+  if (
+    toStringed === '[object Function]' ||
+    toStringed === '[object GeneratorFunction]'
+  ) {
+    return printFunction(val, printFunctionName);
+  }
+
+  if (toStringed === '[object Symbol]') {
+    return printSymbol(val);
+  }
+
+  if (toStringed === '[object Date]') {
+    return isNaN(+val) ? 'Date { NaN }' : toISOString.call(val);
+  }
+
+  if (toStringed === '[object Error]') {
+    return printError(val);
+  }
+
+  if (toStringed === '[object RegExp]') {
+    if (escapeRegex) {
+      // https://github.com/benjamingr/RegExp.escape/blob/master/polyfill.js
+      return regExpToString.call(val).replace(/[\\^$*+?.()|[\]{}]/g, '\\$&');
+    }
+
+    return regExpToString.call(val);
+  }
+
+  if (val instanceof Error) {
+    return printError(val);
+  }
+
+  return null;
+}
+/**
+ * Handles more complex objects ( such as objects with circular references.
+ * maps and sets etc )
+ */
+
+function printComplexValue(
+  val,
+  config,
+  indentation,
+  depth,
+  refs,
+  hasCalledToJSON
+) {
+  if (refs.indexOf(val) !== -1) {
+    return '[Circular]';
+  }
+
+  refs = refs.slice();
+  refs.push(val);
+  const hitMaxDepth = ++depth > config.maxDepth;
+  const min = config.min;
+
+  if (
+    config.callToJSON &&
+    !hitMaxDepth &&
+    val.toJSON &&
+    typeof val.toJSON === 'function' &&
+    !hasCalledToJSON
+  ) {
+    return printer(val.toJSON(), config, indentation, depth, refs, true);
+  }
+
+  const toStringed = toString.call(val);
+
+  if (toStringed === '[object Arguments]') {
+    return hitMaxDepth
+      ? '[Arguments]'
+      : (min ? '' : 'Arguments ') +
+          '[' +
+          (0, _collections.printListItems)(
+            val,
+            config,
+            indentation,
+            depth,
+            refs,
+            printer
+          ) +
+          ']';
+  }
+
+  if (isToStringedArrayType(toStringed)) {
+    return hitMaxDepth
+      ? '[' + val.constructor.name + ']'
+      : (min ? '' : val.constructor.name + ' ') +
+          '[' +
+          (0, _collections.printListItems)(
+            val,
+            config,
+            indentation,
+            depth,
+            refs,
+            printer
+          ) +
+          ']';
+  }
+
+  if (toStringed === '[object Map]') {
+    return hitMaxDepth
+      ? '[Map]'
+      : 'Map {' +
+          (0, _collections.printIteratorEntries)(
+            val.entries(),
+            config,
+            indentation,
+            depth,
+            refs,
+            printer,
+            ' => '
+          ) +
+          '}';
+  }
+
+  if (toStringed === '[object Set]') {
+    return hitMaxDepth
+      ? '[Set]'
+      : 'Set {' +
+          (0, _collections.printIteratorValues)(
+            val.values(),
+            config,
+            indentation,
+            depth,
+            refs,
+            printer
+          ) +
+          '}';
+  } // Avoid failure to serialize global window object in jsdom test environment.
+  // For example, not even relevant if window is prop of React element.
+
+  return hitMaxDepth || isWindow(val)
+    ? '[' + getConstructorName(val) + ']'
+    : (min ? '' : getConstructorName(val) + ' ') +
+        '{' +
+        (0, _collections.printObjectProperties)(
+          val,
+          config,
+          indentation,
+          depth,
+          refs,
+          printer
+        ) +
+        '}';
+}
+
+function isNewPlugin(plugin) {
+  return plugin.serialize != null;
+}
+
+function printPlugin(plugin, val, config, indentation, depth, refs) {
+  let printed;
+
+  try {
+    printed = isNewPlugin(plugin)
+      ? plugin.serialize(val, config, indentation, depth, refs, printer)
+      : plugin.print(
+          val,
+          valChild => printer(valChild, config, indentation, depth, refs),
+          str => {
+            const indentationNext = indentation + config.indent;
+            return (
+              indentationNext +
+              str.replace(NEWLINE_REGEXP, '\n' + indentationNext)
+            );
+          },
+          {
+            edgeSpacing: config.spacingOuter,
+            min: config.min,
+            spacing: config.spacingInner
+          },
+          config.colors
+        );
+  } catch (error) {
+    throw new PrettyFormatPluginError(error.message, error.stack);
+  }
+
+  if (typeof printed !== 'string') {
+    throw new Error(
+      `pretty-format: Plugin must return type "string" but instead returned "${typeof printed}".`
+    );
+  }
+
+  return printed;
+}
+
+function findPlugin(plugins, val) {
+  for (let p = 0; p < plugins.length; p++) {
+    try {
+      if (plugins[p].test(val)) {
+        return plugins[p];
+      }
+    } catch (error) {
+      throw new PrettyFormatPluginError(error.message, error.stack);
+    }
+  }
+
+  return null;
+}
+
+function printer(val, config, indentation, depth, refs, hasCalledToJSON) {
+  const plugin = findPlugin(config.plugins, val);
+
+  if (plugin !== null) {
+    return printPlugin(plugin, val, config, indentation, depth, refs);
+  }
+
+  const basicResult = printBasicValue(
+    val,
+    config.printFunctionName,
+    config.escapeRegex,
+    config.escapeString
+  );
+
+  if (basicResult !== null) {
+    return basicResult;
+  }
+
+  return printComplexValue(
+    val,
+    config,
+    indentation,
+    depth,
+    refs,
+    hasCalledToJSON
+  );
+}
+
+const DEFAULT_THEME = {
+  comment: 'gray',
+  content: 'reset',
+  prop: 'yellow',
+  tag: 'cyan',
+  value: 'green'
+};
+const DEFAULT_THEME_KEYS = Object.keys(DEFAULT_THEME);
+const DEFAULT_OPTIONS = {
+  callToJSON: true,
+  escapeRegex: false,
+  escapeString: true,
+  highlight: false,
+  indent: 2,
+  maxDepth: Infinity,
+  min: false,
+  plugins: [],
+  printFunctionName: true,
+  theme: DEFAULT_THEME
+};
+
+function validateOptions(options) {
+  Object.keys(options).forEach(key => {
+    if (!DEFAULT_OPTIONS.hasOwnProperty(key)) {
+      throw new Error(`pretty-format: Unknown option "${key}".`);
+    }
+  });
+
+  if (options.min && options.indent !== undefined && options.indent !== 0) {
+    throw new Error(
+      'pretty-format: Options "min" and "indent" cannot be used together.'
+    );
+  }
+
+  if (options.theme !== undefined) {
+    if (options.theme === null) {
+      throw new Error(`pretty-format: Option "theme" must not be null.`);
+    }
+
+    if (typeof options.theme !== 'object') {
+      throw new Error(
+        `pretty-format: Option "theme" must be of type "object" but instead received "${typeof options.theme}".`
+      );
+    }
+  }
+}
+
+const getColorsHighlight = options =>
+  DEFAULT_THEME_KEYS.reduce((colors, key) => {
+    const value =
+      options.theme && options.theme[key] !== undefined
+        ? options.theme[key]
+        : DEFAULT_THEME[key];
+    const color = value && _ansiStyles.default[value];
+
+    if (
+      color &&
+      typeof color.close === 'string' &&
+      typeof color.open === 'string'
+    ) {
+      colors[key] = color;
+    } else {
+      throw new Error(
+        `pretty-format: Option "theme" has a key "${key}" whose value "${value}" is undefined in ansi-styles.`
+      );
+    }
+
+    return colors;
+  }, Object.create(null));
+
+const getColorsEmpty = () =>
+  DEFAULT_THEME_KEYS.reduce((colors, key) => {
+    colors[key] = {
+      close: '',
+      open: ''
+    };
+    return colors;
+  }, Object.create(null));
+
+const getPrintFunctionName = options =>
+  options && options.printFunctionName !== undefined
+    ? options.printFunctionName
+    : DEFAULT_OPTIONS.printFunctionName;
+
+const getEscapeRegex = options =>
+  options && options.escapeRegex !== undefined
+    ? options.escapeRegex
+    : DEFAULT_OPTIONS.escapeRegex;
+
+const getEscapeString = options =>
+  options && options.escapeString !== undefined
+    ? options.escapeString
+    : DEFAULT_OPTIONS.escapeString;
+
+const getConfig = options => ({
+  callToJSON:
+    options && options.callToJSON !== undefined
+      ? options.callToJSON
+      : DEFAULT_OPTIONS.callToJSON,
+  colors:
+    options && options.highlight
+      ? getColorsHighlight(options)
+      : getColorsEmpty(),
+  escapeRegex: getEscapeRegex(options),
+  escapeString: getEscapeString(options),
+  indent:
+    options && options.min
+      ? ''
+      : createIndent(
+          options && options.indent !== undefined
+            ? options.indent
+            : DEFAULT_OPTIONS.indent
+        ),
+  maxDepth:
+    options && options.maxDepth !== undefined
+      ? options.maxDepth
+      : DEFAULT_OPTIONS.maxDepth,
+  min: options && options.min !== undefined ? options.min : DEFAULT_OPTIONS.min,
+  plugins:
+    options && options.plugins !== undefined
+      ? options.plugins
+      : DEFAULT_OPTIONS.plugins,
+  printFunctionName: getPrintFunctionName(options),
+  spacingInner: options && options.min ? ' ' : '\n',
+  spacingOuter: options && options.min ? '' : '\n'
+});
+
+function createIndent(indent) {
+  return new Array(indent + 1).join(' ');
+}
+/**
+ * Returns a presentation string of your `val` object
+ * @param val any potential JavaScript object
+ * @param options Custom settings
+ */
+
+function prettyFormat(val, options) {
+  if (options) {
+    validateOptions(options);
+
+    if (options.plugins) {
+      const plugin = findPlugin(options.plugins, val);
+
+      if (plugin !== null) {
+        return printPlugin(plugin, val, getConfig(options), '', 0, []);
+      }
+    }
+  }
+
+  const basicResult = printBasicValue(
+    val,
+    getPrintFunctionName(options),
+    getEscapeRegex(options),
+    getEscapeString(options)
+  );
+
+  if (basicResult !== null) {
+    return basicResult;
+  }
+
+  return printComplexValue(val, getConfig(options), '', 0, []);
+}
+
+prettyFormat.plugins = {
+  AsymmetricMatcher: _AsymmetricMatcher.default,
+  ConvertAnsi: _ConvertAnsi.default,
+  DOMCollection: _DOMCollection.default,
+  DOMElement: _DOMElement.default,
+  Immutable: _Immutable.default,
+  ReactElement: _ReactElement.default,
+  ReactTestComponent: _ReactTestComponent.default
+};
+module.exports = prettyFormat;

web/node_modules/jest-config/node_modules/pretty-format/build/plugins/AsymmetricMatcher.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { NewPlugin } from '../types';
+export declare const serialize: NewPlugin['serialize'];
+export declare const test: NewPlugin['test'];
+declare const plugin: NewPlugin;
+export default plugin;

web/node_modules/jest-config/node_modules/pretty-format/build/plugins/AsymmetricMatcher.js

@@ -0,0 +1,103 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = exports.test = exports.serialize = void 0;
+
+var _collections = require('../collections');
+
+var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
+const asymmetricMatcher =
+  typeof Symbol === 'function' && Symbol.for
+    ? Symbol.for('jest.asymmetricMatcher')
+    : 0x1357a5;
+const SPACE = ' ';
+
+const serialize = (val, config, indentation, depth, refs, printer) => {
+  const stringedValue = val.toString();
+
+  if (
+    stringedValue === 'ArrayContaining' ||
+    stringedValue === 'ArrayNotContaining'
+  ) {
+    if (++depth > config.maxDepth) {
+      return '[' + stringedValue + ']';
+    }
+
+    return (
+      stringedValue +
+      SPACE +
+      '[' +
+      (0, _collections.printListItems)(
+        val.sample,
+        config,
+        indentation,
+        depth,
+        refs,
+        printer
+      ) +
+      ']'
+    );
+  }
+
+  if (
+    stringedValue === 'ObjectContaining' ||
+    stringedValue === 'ObjectNotContaining'
+  ) {
+    if (++depth > config.maxDepth) {
+      return '[' + stringedValue + ']';
+    }
+
+    return (
+      stringedValue +
+      SPACE +
+      '{' +
+      (0, _collections.printObjectProperties)(
+        val.sample,
+        config,
+        indentation,
+        depth,
+        refs,
+        printer
+      ) +
+      '}'
+    );
+  }
+
+  if (
+    stringedValue === 'StringMatching' ||
+    stringedValue === 'StringNotMatching'
+  ) {
+    return (
+      stringedValue +
+      SPACE +
+      printer(val.sample, config, indentation, depth, refs)
+    );
+  }
+
+  if (
+    stringedValue === 'StringContaining' ||
+    stringedValue === 'StringNotContaining'
+  ) {
+    return (
+      stringedValue +
+      SPACE +
+      printer(val.sample, config, indentation, depth, refs)
+    );
+  }
+
+  return val.toAsymmetricMatcher();
+};
+
+exports.serialize = serialize;
+
+const test = val => val && val.$$typeof === asymmetricMatcher;
+
+exports.test = test;
+const plugin = {
+  serialize,
+  test
+};
+var _default = plugin;
+exports.default = _default;

web/node_modules/jest-config/node_modules/pretty-format/build/plugins/ConvertAnsi.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { NewPlugin } from '../types';
+export declare const test: NewPlugin['test'];
+export declare const serialize: NewPlugin['serialize'];
+declare const plugin: NewPlugin;
+export default plugin;

web/node_modules/jest-config/node_modules/pretty-format/build/plugins/ConvertAnsi.js

@@ -0,0 +1,96 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = exports.serialize = exports.test = void 0;
+
+var _ansiRegex = _interopRequireDefault(require('ansi-regex'));
+
+var _ansiStyles = _interopRequireDefault(require('ansi-styles'));
+
+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 toHumanReadableAnsi = text =>
+  text.replace((0, _ansiRegex.default)(), match => {
+    switch (match) {
+      case _ansiStyles.default.red.close:
+      case _ansiStyles.default.green.close:
+      case _ansiStyles.default.cyan.close:
+      case _ansiStyles.default.gray.close:
+      case _ansiStyles.default.white.close:
+      case _ansiStyles.default.yellow.close:
+      case _ansiStyles.default.bgRed.close:
+      case _ansiStyles.default.bgGreen.close:
+      case _ansiStyles.default.bgYellow.close:
+      case _ansiStyles.default.inverse.close:
+      case _ansiStyles.default.dim.close:
+      case _ansiStyles.default.bold.close:
+      case _ansiStyles.default.reset.open:
+      case _ansiStyles.default.reset.close:
+        return '</>';
+
+      case _ansiStyles.default.red.open:
+        return '<red>';
+
+      case _ansiStyles.default.green.open:
+        return '<green>';
+
+      case _ansiStyles.default.cyan.open:
+        return '<cyan>';
+
+      case _ansiStyles.default.gray.open:
+        return '<gray>';
+
+      case _ansiStyles.default.white.open:
+        return '<white>';
+
+      case _ansiStyles.default.yellow.open:
+        return '<yellow>';
+
+      case _ansiStyles.default.bgRed.open:
+        return '<bgRed>';
+
+      case _ansiStyles.default.bgGreen.open:
+        return '<bgGreen>';
+
+      case _ansiStyles.default.bgYellow.open:
+        return '<bgYellow>';
+
+      case _ansiStyles.default.inverse.open:
+        return '<inverse>';
+
+      case _ansiStyles.default.dim.open:
+        return '<dim>';
+
+      case _ansiStyles.default.bold.open:
+        return '<bold>';
+
+      default:
+        return '';
+    }
+  });
+
+const test = val =>
+  typeof val === 'string' && !!val.match((0, _ansiRegex.default)());
+
+exports.test = test;
+
+const serialize = (val, config, indentation, depth, refs, printer) =>
+  printer(toHumanReadableAnsi(val), config, indentation, depth, refs);
+
+exports.serialize = serialize;
+const plugin = {
+  serialize,
+  test
+};
+var _default = plugin;
+exports.default = _default;

web/node_modules/jest-config/node_modules/pretty-format/build/plugins/DOMCollection.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { NewPlugin } from '../types';
+export declare const test: NewPlugin['test'];
+export declare const serialize: NewPlugin['serialize'];
+declare const plugin: NewPlugin;
+export default plugin;

web/node_modules/jest-config/node_modules/pretty-format/build/plugins/DOMCollection.js

@@ -0,0 +1,80 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = exports.serialize = exports.test = void 0;
+
+var _collections = require('../collections');
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/* eslint-disable local/ban-types-eventually */
+const SPACE = ' ';
+const OBJECT_NAMES = ['DOMStringMap', 'NamedNodeMap'];
+const ARRAY_REGEXP = /^(HTML\w*Collection|NodeList)$/;
+
+const testName = name =>
+  OBJECT_NAMES.indexOf(name) !== -1 || ARRAY_REGEXP.test(name);
+
+const test = val =>
+  val &&
+  val.constructor &&
+  !!val.constructor.name &&
+  testName(val.constructor.name);
+
+exports.test = test;
+
+const isNamedNodeMap = collection =>
+  collection.constructor.name === 'NamedNodeMap';
+
+const serialize = (collection, config, indentation, depth, refs, printer) => {
+  const name = collection.constructor.name;
+
+  if (++depth > config.maxDepth) {
+    return '[' + name + ']';
+  }
+
+  return (
+    (config.min ? '' : name + SPACE) +
+    (OBJECT_NAMES.indexOf(name) !== -1
+      ? '{' +
+        (0, _collections.printObjectProperties)(
+          isNamedNodeMap(collection)
+            ? Array.from(collection).reduce((props, attribute) => {
+                props[attribute.name] = attribute.value;
+                return props;
+              }, {})
+            : {...collection},
+          config,
+          indentation,
+          depth,
+          refs,
+          printer
+        ) +
+        '}'
+      : '[' +
+        (0, _collections.printListItems)(
+          Array.from(collection),
+          config,
+          indentation,
+          depth,
+          refs,
+          printer
+        ) +
+        ']')
+  );
+};
+
+exports.serialize = serialize;
+const plugin = {
+  serialize,
+  test
+};
+var _default = plugin;
+exports.default = _default;

web/node_modules/jest-config/node_modules/pretty-format/build/plugins/DOMElement.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { NewPlugin } from '../types';
+export declare const test: NewPlugin['test'];
+export declare const serialize: NewPlugin['serialize'];
+declare const plugin: NewPlugin;
+export default plugin;

web/node_modules/jest-config/node_modules/pretty-format/build/plugins/DOMElement.js

@@ -0,0 +1,125 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = exports.serialize = exports.test = void 0;
+
+var _markup = require('./lib/markup');
+
+/**
+ * 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 ELEMENT_NODE = 1;
+const TEXT_NODE = 3;
+const COMMENT_NODE = 8;
+const FRAGMENT_NODE = 11;
+const ELEMENT_REGEXP = /^((HTML|SVG)\w*)?Element$/;
+
+const testNode = val => {
+  var _val$hasAttribute;
+
+  const constructorName = val.constructor.name;
+  const {nodeType, tagName} = val;
+  const isCustomElement =
+    (typeof tagName === 'string' && tagName.includes('-')) ||
+    ((_val$hasAttribute = val.hasAttribute) === null ||
+    _val$hasAttribute === void 0
+      ? void 0
+      : _val$hasAttribute.call(val, 'is'));
+  return (
+    (nodeType === ELEMENT_NODE &&
+      (ELEMENT_REGEXP.test(constructorName) || isCustomElement)) ||
+    (nodeType === TEXT_NODE && constructorName === 'Text') ||
+    (nodeType === COMMENT_NODE && constructorName === 'Comment') ||
+    (nodeType === FRAGMENT_NODE && constructorName === 'DocumentFragment')
+  );
+};
+
+const test = val => {
+  var _val$constructor;
+
+  return (
+    (val === null || val === void 0
+      ? void 0
+      : (_val$constructor = val.constructor) === null ||
+        _val$constructor === void 0
+      ? void 0
+      : _val$constructor.name) && testNode(val)
+  );
+};
+
+exports.test = test;
+
+function nodeIsText(node) {
+  return node.nodeType === TEXT_NODE;
+}
+
+function nodeIsComment(node) {
+  return node.nodeType === COMMENT_NODE;
+}
+
+function nodeIsFragment(node) {
+  return node.nodeType === FRAGMENT_NODE;
+}
+
+const serialize = (node, config, indentation, depth, refs, printer) => {
+  if (nodeIsText(node)) {
+    return (0, _markup.printText)(node.data, config);
+  }
+
+  if (nodeIsComment(node)) {
+    return (0, _markup.printComment)(node.data, config);
+  }
+
+  const type = nodeIsFragment(node)
+    ? `DocumentFragment`
+    : node.tagName.toLowerCase();
+
+  if (++depth > config.maxDepth) {
+    return (0, _markup.printElementAsLeaf)(type, config);
+  }
+
+  return (0, _markup.printElement)(
+    type,
+    (0, _markup.printProps)(
+      nodeIsFragment(node)
+        ? []
+        : Array.from(node.attributes)
+            .map(attr => attr.name)
+            .sort(),
+      nodeIsFragment(node)
+        ? {}
+        : Array.from(node.attributes).reduce((props, attribute) => {
+            props[attribute.name] = attribute.value;
+            return props;
+          }, {}),
+      config,
+      indentation + config.indent,
+      depth,
+      refs,
+      printer
+    ),
+    (0, _markup.printChildren)(
+      Array.prototype.slice.call(node.childNodes || node.children),
+      config,
+      indentation + config.indent,
+      depth,
+      refs,
+      printer
+    ),
+    config,
+    indentation
+  );
+};
+
+exports.serialize = serialize;
+const plugin = {
+  serialize,
+  test
+};
+var _default = plugin;
+exports.default = _default;

web/node_modules/jest-config/node_modules/pretty-format/build/plugins/Immutable.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { NewPlugin } from '../types';
+export declare const serialize: NewPlugin['serialize'];
+export declare const test: NewPlugin['test'];
+declare const plugin: NewPlugin;
+export default plugin;

web/node_modules/jest-config/node_modules/pretty-format/build/plugins/Immutable.js

@@ -0,0 +1,247 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = exports.test = exports.serialize = void 0;
+
+var _collections = require('../collections');
+
+/**
+ * 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.
+ */
+// SENTINEL constants are from https://github.com/facebook/immutable-js
+const IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';
+const IS_LIST_SENTINEL = '@@__IMMUTABLE_LIST__@@';
+const IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';
+const IS_MAP_SENTINEL = '@@__IMMUTABLE_MAP__@@';
+const IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';
+const IS_RECORD_SENTINEL = '@@__IMMUTABLE_RECORD__@@'; // immutable v4
+
+const IS_SEQ_SENTINEL = '@@__IMMUTABLE_SEQ__@@';
+const IS_SET_SENTINEL = '@@__IMMUTABLE_SET__@@';
+const IS_STACK_SENTINEL = '@@__IMMUTABLE_STACK__@@';
+
+const getImmutableName = name => 'Immutable.' + name;
+
+const printAsLeaf = name => '[' + name + ']';
+
+const SPACE = ' ';
+const LAZY = '…'; // Seq is lazy if it calls a method like filter
+
+const printImmutableEntries = (
+  val,
+  config,
+  indentation,
+  depth,
+  refs,
+  printer,
+  type
+) =>
+  ++depth > config.maxDepth
+    ? printAsLeaf(getImmutableName(type))
+    : getImmutableName(type) +
+      SPACE +
+      '{' +
+      (0, _collections.printIteratorEntries)(
+        val.entries(),
+        config,
+        indentation,
+        depth,
+        refs,
+        printer
+      ) +
+      '}'; // Record has an entries method because it is a collection in immutable v3.
+// Return an iterator for Immutable Record from version v3 or v4.
+
+function getRecordEntries(val) {
+  let i = 0;
+  return {
+    next() {
+      if (i < val._keys.length) {
+        const key = val._keys[i++];
+        return {
+          done: false,
+          value: [key, val.get(key)]
+        };
+      }
+
+      return {
+        done: true,
+        value: undefined
+      };
+    }
+  };
+}
+
+const printImmutableRecord = (
+  val,
+  config,
+  indentation,
+  depth,
+  refs,
+  printer
+) => {
+  // _name property is defined only for an Immutable Record instance
+  // which was constructed with a second optional descriptive name arg
+  const name = getImmutableName(val._name || 'Record');
+  return ++depth > config.maxDepth
+    ? printAsLeaf(name)
+    : name +
+        SPACE +
+        '{' +
+        (0, _collections.printIteratorEntries)(
+          getRecordEntries(val),
+          config,
+          indentation,
+          depth,
+          refs,
+          printer
+        ) +
+        '}';
+};
+
+const printImmutableSeq = (val, config, indentation, depth, refs, printer) => {
+  const name = getImmutableName('Seq');
+
+  if (++depth > config.maxDepth) {
+    return printAsLeaf(name);
+  }
+
+  if (val[IS_KEYED_SENTINEL]) {
+    return (
+      name +
+      SPACE +
+      '{' + // from Immutable collection of entries or from ECMAScript object
+      (val._iter || val._object
+        ? (0, _collections.printIteratorEntries)(
+            val.entries(),
+            config,
+            indentation,
+            depth,
+            refs,
+            printer
+          )
+        : LAZY) +
+      '}'
+    );
+  }
+
+  return (
+    name +
+    SPACE +
+    '[' +
+    (val._iter || // from Immutable collection of values
+    val._array || // from ECMAScript array
+    val._collection || // from ECMAScript collection in immutable v4
+    val._iterable // from ECMAScript collection in immutable v3
+      ? (0, _collections.printIteratorValues)(
+          val.values(),
+          config,
+          indentation,
+          depth,
+          refs,
+          printer
+        )
+      : LAZY) +
+    ']'
+  );
+};
+
+const printImmutableValues = (
+  val,
+  config,
+  indentation,
+  depth,
+  refs,
+  printer,
+  type
+) =>
+  ++depth > config.maxDepth
+    ? printAsLeaf(getImmutableName(type))
+    : getImmutableName(type) +
+      SPACE +
+      '[' +
+      (0, _collections.printIteratorValues)(
+        val.values(),
+        config,
+        indentation,
+        depth,
+        refs,
+        printer
+      ) +
+      ']';
+
+const serialize = (val, config, indentation, depth, refs, printer) => {
+  if (val[IS_MAP_SENTINEL]) {
+    return printImmutableEntries(
+      val,
+      config,
+      indentation,
+      depth,
+      refs,
+      printer,
+      val[IS_ORDERED_SENTINEL] ? 'OrderedMap' : 'Map'
+    );
+  }
+
+  if (val[IS_LIST_SENTINEL]) {
+    return printImmutableValues(
+      val,
+      config,
+      indentation,
+      depth,
+      refs,
+      printer,
+      'List'
+    );
+  }
+
+  if (val[IS_SET_SENTINEL]) {
+    return printImmutableValues(
+      val,
+      config,
+      indentation,
+      depth,
+      refs,
+      printer,
+      val[IS_ORDERED_SENTINEL] ? 'OrderedSet' : 'Set'
+    );
+  }
+
+  if (val[IS_STACK_SENTINEL]) {
+    return printImmutableValues(
+      val,
+      config,
+      indentation,
+      depth,
+      refs,
+      printer,
+      'Stack'
+    );
+  }
+
+  if (val[IS_SEQ_SENTINEL]) {
+    return printImmutableSeq(val, config, indentation, depth, refs, printer);
+  } // For compatibility with immutable v3 and v4, let record be the default.
+
+  return printImmutableRecord(val, config, indentation, depth, refs, printer);
+}; // Explicitly comparing sentinel properties to true avoids false positive
+// when mock identity-obj-proxy returns the key as the value for any key.
+
+exports.serialize = serialize;
+
+const test = val =>
+  val &&
+  (val[IS_ITERABLE_SENTINEL] === true || val[IS_RECORD_SENTINEL] === true);
+
+exports.test = test;
+const plugin = {
+  serialize,
+  test
+};
+var _default = plugin;
+exports.default = _default;

web/node_modules/jest-config/node_modules/pretty-format/build/plugins/ReactElement.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { NewPlugin } from '../types';
+export declare const serialize: NewPlugin['serialize'];
+export declare const test: NewPlugin['test'];
+declare const plugin: NewPlugin;
+export default plugin;

web/node_modules/jest-config/node_modules/pretty-format/build/plugins/ReactElement.js

@@ -0,0 +1,166 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = exports.test = exports.serialize = void 0;
+
+var ReactIs = _interopRequireWildcard(require('react-is'));
+
+var _markup = require('./lib/markup');
+
+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.
+ */
+// Given element.props.children, or subtree during recursive traversal,
+// return flattened array of children.
+const getChildren = (arg, children = []) => {
+  if (Array.isArray(arg)) {
+    arg.forEach(item => {
+      getChildren(item, children);
+    });
+  } else if (arg != null && arg !== false) {
+    children.push(arg);
+  }
+
+  return children;
+};
+
+const getType = element => {
+  const type = element.type;
+
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  if (typeof type === 'function') {
+    return type.displayName || type.name || 'Unknown';
+  }
+
+  if (ReactIs.isFragment(element)) {
+    return 'React.Fragment';
+  }
+
+  if (ReactIs.isSuspense(element)) {
+    return 'React.Suspense';
+  }
+
+  if (typeof type === 'object' && type !== null) {
+    if (ReactIs.isContextProvider(element)) {
+      return 'Context.Provider';
+    }
+
+    if (ReactIs.isContextConsumer(element)) {
+      return 'Context.Consumer';
+    }
+
+    if (ReactIs.isForwardRef(element)) {
+      if (type.displayName) {
+        return type.displayName;
+      }
+
+      const functionName = type.render.displayName || type.render.name || '';
+      return functionName !== ''
+        ? 'ForwardRef(' + functionName + ')'
+        : 'ForwardRef';
+    }
+
+    if (ReactIs.isMemo(element)) {
+      const functionName =
+        type.displayName || type.type.displayName || type.type.name || '';
+      return functionName !== '' ? 'Memo(' + functionName + ')' : 'Memo';
+    }
+  }
+
+  return 'UNDEFINED';
+};
+
+const getPropKeys = element => {
+  const {props} = element;
+  return Object.keys(props)
+    .filter(key => key !== 'children' && props[key] !== undefined)
+    .sort();
+};
+
+const serialize = (element, config, indentation, depth, refs, printer) =>
+  ++depth > config.maxDepth
+    ? (0, _markup.printElementAsLeaf)(getType(element), config)
+    : (0, _markup.printElement)(
+        getType(element),
+        (0, _markup.printProps)(
+          getPropKeys(element),
+          element.props,
+          config,
+          indentation + config.indent,
+          depth,
+          refs,
+          printer
+        ),
+        (0, _markup.printChildren)(
+          getChildren(element.props.children),
+          config,
+          indentation + config.indent,
+          depth,
+          refs,
+          printer
+        ),
+        config,
+        indentation
+      );
+
+exports.serialize = serialize;
+
+const test = val => val && ReactIs.isElement(val);
+
+exports.test = test;
+const plugin = {
+  serialize,
+  test
+};
+var _default = plugin;
+exports.default = _default;

web/node_modules/jest-config/node_modules/pretty-format/build/plugins/ReactTestComponent.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 { NewPlugin } from '../types';
+export declare type ReactTestObject = {
+    $$typeof: symbol;
+    type: string;
+    props?: Record<string, unknown>;
+    children?: null | Array<ReactTestChild>;
+};
+declare type ReactTestChild = ReactTestObject | string | number;
+export declare const serialize: NewPlugin['serialize'];
+export declare const test: NewPlugin['test'];
+declare const plugin: NewPlugin;
+export default plugin;

web/node_modules/jest-config/node_modules/pretty-format/build/plugins/ReactTestComponent.js

@@ -0,0 +1,65 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = exports.test = exports.serialize = void 0;
+
+var _markup = require('./lib/markup');
+
+var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
+const testSymbol =
+  typeof Symbol === 'function' && Symbol.for
+    ? Symbol.for('react.test.json')
+    : 0xea71357;
+
+const getPropKeys = object => {
+  const {props} = object;
+  return props
+    ? Object.keys(props)
+        .filter(key => props[key] !== undefined)
+        .sort()
+    : [];
+};
+
+const serialize = (object, config, indentation, depth, refs, printer) =>
+  ++depth > config.maxDepth
+    ? (0, _markup.printElementAsLeaf)(object.type, config)
+    : (0, _markup.printElement)(
+        object.type,
+        object.props
+          ? (0, _markup.printProps)(
+              getPropKeys(object),
+              object.props,
+              config,
+              indentation + config.indent,
+              depth,
+              refs,
+              printer
+            )
+          : '',
+        object.children
+          ? (0, _markup.printChildren)(
+              object.children,
+              config,
+              indentation + config.indent,
+              depth,
+              refs,
+              printer
+            )
+          : '',
+        config,
+        indentation
+      );
+
+exports.serialize = serialize;
+
+const test = val => val && val.$$typeof === testSymbol;
+
+exports.test = test;
+const plugin = {
+  serialize,
+  test
+};
+var _default = plugin;
+exports.default = _default;

web/node_modules/jest-config/node_modules/pretty-format/build/plugins/lib/escapeHTML.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 escapeHTML(str: string): string;

web/node_modules/jest-config/node_modules/pretty-format/build/plugins/lib/escapeHTML.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = escapeHTML;
+
+/**
+ * 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 escapeHTML(str) {
+  return str.replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}