claude-autopm 2.12.3 → 3.0.0

package/packages/plugin-devops/node_modules/jest-config/build/normalize.js

@@ -0,0 +1,1180 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = normalize;
+function _crypto() {
+  const data = require('crypto');
+  _crypto = function () {
+    return data;
+  };
+  return data;
+}
+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 _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function _deepmerge() {
+  const data = _interopRequireDefault(require('deepmerge'));
+  _deepmerge = function () {
+    return data;
+  };
+  return data;
+}
+function _glob() {
+  const data = require('glob');
+  _glob = function () {
+    return data;
+  };
+  return data;
+}
+function _gracefulFs() {
+  const data = require('graceful-fs');
+  _gracefulFs = function () {
+    return data;
+  };
+  return data;
+}
+function _micromatch() {
+  const data = _interopRequireDefault(require('micromatch'));
+  _micromatch = function () {
+    return data;
+  };
+  return data;
+}
+function _jestRegexUtil() {
+  const data = require('jest-regex-util');
+  _jestRegexUtil = function () {
+    return data;
+  };
+  return data;
+}
+function _jestResolve() {
+  const data = _interopRequireWildcard(require('jest-resolve'));
+  _jestResolve = function () {
+    return data;
+  };
+  return data;
+}
+function _jestUtil() {
+  const data = require('jest-util');
+  _jestUtil = function () {
+    return data;
+  };
+  return data;
+}
+function _jestValidate() {
+  const data = require('jest-validate');
+  _jestValidate = function () {
+    return data;
+  };
+  return data;
+}
+var _Defaults = _interopRequireDefault(require('./Defaults'));
+var _Deprecated = _interopRequireDefault(require('./Deprecated'));
+var _ReporterValidationErrors = require('./ReporterValidationErrors');
+var _ValidConfig = require('./ValidConfig');
+var _color = require('./color');
+var _constants = require('./constants');
+var _getMaxWorkers = _interopRequireDefault(require('./getMaxWorkers'));
+var _parseShardPair = require('./parseShardPair');
+var _setFromArgv = _interopRequireDefault(require('./setFromArgv'));
+var _stringToBytes = _interopRequireDefault(require('./stringToBytes'));
+var _utils = require('./utils');
+var _validatePattern = _interopRequireDefault(require('./validatePattern'));
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== 'function') return null;
+  var cacheBabelInterop = new WeakMap();
+  var cacheNodeInterop = new WeakMap();
+  return (_getRequireWildcardCache = function (nodeInterop) {
+    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
+    return {default: obj};
+  }
+  var cache = _getRequireWildcardCache(nodeInterop);
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor
+        ? Object.getOwnPropertyDescriptor(obj, key)
+        : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+const ERROR = `${_utils.BULLET}Validation Error`;
+const PRESET_EXTENSIONS = ['.json', '.js', '.cjs', '.mjs'];
+const PRESET_NAME = 'jest-preset';
+const createConfigError = message =>
+  new (_jestValidate().ValidationError)(
+    ERROR,
+    message,
+    _utils.DOCUMENTATION_NOTE
+  );
+function verifyDirectoryExists(path, key) {
+  try {
+    const rootStat = (0, _gracefulFs().statSync)(path);
+    if (!rootStat.isDirectory()) {
+      throw createConfigError(
+        `  ${_chalk().default.bold(path)} in the ${_chalk().default.bold(
+          key
+        )} option is not a directory.`
+      );
+    }
+  } catch (err) {
+    if (err instanceof _jestValidate().ValidationError) {
+      throw err;
+    }
+    if (err.code === 'ENOENT') {
+      throw createConfigError(
+        `  Directory ${_chalk().default.bold(
+          path
+        )} in the ${_chalk().default.bold(key)} option was not found.`
+      );
+    }
+
+    // Not sure in which cases `statSync` can throw, so let's just show the underlying error to the user
+    throw createConfigError(
+      `  Got an error trying to find ${_chalk().default.bold(
+        path
+      )} in the ${_chalk().default.bold(key)} option.\n\n  Error was: ${
+        err.message
+      }`
+    );
+  }
+}
+const mergeOptionWithPreset = (options, preset, optionName) => {
+  if (options[optionName] && preset[optionName]) {
+    options[optionName] = {
+      ...options[optionName],
+      ...preset[optionName],
+      ...options[optionName]
+    };
+  }
+};
+const mergeGlobalsWithPreset = (options, preset) => {
+  if (options.globals && preset.globals) {
+    options.globals = (0, _deepmerge().default)(
+      preset.globals,
+      options.globals
+    );
+  }
+};
+const setupPreset = async (options, optionsPreset) => {
+  let preset;
+  const presetPath = (0, _utils.replaceRootDirInPath)(
+    options.rootDir,
+    optionsPreset
+  );
+  const presetModule = _jestResolve().default.findNodeModule(
+    presetPath.startsWith('.')
+      ? presetPath
+      : path().join(presetPath, PRESET_NAME),
+    {
+      basedir: options.rootDir,
+      extensions: PRESET_EXTENSIONS
+    }
+  );
+  try {
+    if (!presetModule) {
+      throw new Error(`Cannot find module '${presetPath}'`);
+    }
+
+    // Force re-evaluation to support multiple projects
+    try {
+      delete require.cache[require.resolve(presetModule)];
+    } catch {}
+    preset = await (0, _jestUtil().requireOrImportModule)(presetModule);
+  } catch (error) {
+    if (error instanceof SyntaxError || error instanceof TypeError) {
+      throw createConfigError(
+        `  Preset ${_chalk().default.bold(presetPath)} is invalid:\n\n  ${
+          error.message
+        }\n  ${error.stack}`
+      );
+    }
+    if (error.message.includes('Cannot find module')) {
+      if (error.message.includes(presetPath)) {
+        const preset = _jestResolve().default.findNodeModule(presetPath, {
+          basedir: options.rootDir
+        });
+        if (preset) {
+          throw createConfigError(
+            `  Module ${_chalk().default.bold(
+              presetPath
+            )} should have "jest-preset.js" or "jest-preset.json" file at the root.`
+          );
+        }
+        throw createConfigError(
+          `  Preset ${_chalk().default.bold(presetPath)} not found.`
+        );
+      }
+      throw createConfigError(
+        `  Missing dependency in ${_chalk().default.bold(presetPath)}:\n\n  ${
+          error.message
+        }\n  ${error.stack}`
+      );
+    }
+    throw createConfigError(
+      `  An unknown error occurred in ${_chalk().default.bold(
+        presetPath
+      )}:\n\n  ${error.message}\n  ${error.stack}`
+    );
+  }
+  if (options.setupFiles) {
+    options.setupFiles = (preset.setupFiles || []).concat(options.setupFiles);
+  }
+  if (options.setupFilesAfterEnv) {
+    options.setupFilesAfterEnv = (preset.setupFilesAfterEnv || []).concat(
+      options.setupFilesAfterEnv
+    );
+  }
+  if (options.modulePathIgnorePatterns && preset.modulePathIgnorePatterns) {
+    options.modulePathIgnorePatterns = preset.modulePathIgnorePatterns.concat(
+      options.modulePathIgnorePatterns
+    );
+  }
+  mergeOptionWithPreset(options, preset, 'moduleNameMapper');
+  mergeOptionWithPreset(options, preset, 'transform');
+  mergeGlobalsWithPreset(options, preset);
+  return {
+    ...preset,
+    ...options
+  };
+};
+const setupBabelJest = options => {
+  const transform = options.transform;
+  let babelJest;
+  if (transform) {
+    const customJSPattern = Object.keys(transform).find(pattern => {
+      const regex = new RegExp(pattern);
+      return regex.test('a.js') || regex.test('a.jsx');
+    });
+    const customTSPattern = Object.keys(transform).find(pattern => {
+      const regex = new RegExp(pattern);
+      return regex.test('a.ts') || regex.test('a.tsx');
+    });
+    [customJSPattern, customTSPattern].forEach(pattern => {
+      if (pattern) {
+        const customTransformer = transform[pattern];
+        if (Array.isArray(customTransformer)) {
+          if (customTransformer[0] === 'babel-jest') {
+            babelJest = require.resolve('babel-jest');
+            customTransformer[0] = babelJest;
+          } else if (customTransformer[0].includes('babel-jest')) {
+            babelJest = customTransformer[0];
+          }
+        } else {
+          if (customTransformer === 'babel-jest') {
+            babelJest = require.resolve('babel-jest');
+            transform[pattern] = babelJest;
+          } else if (customTransformer.includes('babel-jest')) {
+            babelJest = customTransformer;
+          }
+        }
+      }
+    });
+  } else {
+    babelJest = require.resolve('babel-jest');
+    options.transform = {
+      [_constants.DEFAULT_JS_PATTERN]: babelJest
+    };
+  }
+};
+const normalizeCollectCoverageFrom = (options, key) => {
+  const initialCollectCoverageFrom = options[key];
+  let value;
+  if (!initialCollectCoverageFrom) {
+    value = [];
+  }
+  if (!Array.isArray(initialCollectCoverageFrom)) {
+    try {
+      value = JSON.parse(initialCollectCoverageFrom);
+    } catch {}
+    if (options[key] && !Array.isArray(value)) {
+      value = [initialCollectCoverageFrom];
+    }
+  } else {
+    value = initialCollectCoverageFrom;
+  }
+  if (value) {
+    value = value.map(filePath =>
+      filePath.replace(/^(!?)(<rootDir>\/)(.*)/, '$1$3')
+    );
+  }
+  return value;
+};
+const normalizeUnmockedModulePathPatterns = (options, key) =>
+  // _replaceRootDirTags is specifically well-suited for substituting
+  // <rootDir> in paths (it deals with properly interpreting relative path
+  // separators, etc).
+  //
+  // For patterns, direct global substitution is far more ideal, so we
+  // special case substitutions for patterns here.
+  options[key].map(pattern =>
+    (0, _jestRegexUtil().replacePathSepForRegex)(
+      pattern.replace(/<rootDir>/g, options.rootDir)
+    )
+  );
+const normalizeMissingOptions = (options, configPath, projectIndex) => {
+  if (!options.id) {
+    options.id = (0, _crypto().createHash)('sha1')
+      .update(options.rootDir)
+      // In case we load config from some path that has the same root dir
+      .update(configPath || '')
+      .update(String(projectIndex))
+      .digest('hex')
+      .substring(0, 32);
+  }
+  if (!options.setupFiles) {
+    options.setupFiles = [];
+  }
+  return options;
+};
+const normalizeRootDir = options => {
+  // Assert that there *is* a rootDir
+  if (!options.rootDir) {
+    throw createConfigError(
+      `  Configuration option ${_chalk().default.bold(
+        'rootDir'
+      )} must be specified.`
+    );
+  }
+  options.rootDir = path().normalize(options.rootDir);
+  try {
+    // try to resolve windows short paths, ignoring errors (permission errors, mostly)
+    options.rootDir = (0, _jestUtil().tryRealpath)(options.rootDir);
+  } catch {
+    // ignored
+  }
+  verifyDirectoryExists(options.rootDir, 'rootDir');
+  return {
+    ...options,
+    rootDir: options.rootDir
+  };
+};
+const normalizeReporters = ({reporters, rootDir}) => {
+  if (!reporters || !Array.isArray(reporters)) {
+    return undefined;
+  }
+  (0, _ReporterValidationErrors.validateReporters)(reporters);
+  return reporters.map(reporterConfig => {
+    const normalizedReporterConfig =
+      typeof reporterConfig === 'string'
+        ? // if reporter config is a string, we wrap it in an array
+          // and pass an empty object for options argument, to normalize
+          // the shape.
+          [reporterConfig, {}]
+        : reporterConfig;
+    const reporterPath = (0, _utils.replaceRootDirInPath)(
+      rootDir,
+      normalizedReporterConfig[0]
+    );
+    if (!['default', 'github-actions', 'summary'].includes(reporterPath)) {
+      const reporter = _jestResolve().default.findNodeModule(reporterPath, {
+        basedir: rootDir
+      });
+      if (!reporter) {
+        throw new (_jestResolve().default.ModuleNotFoundError)(
+          'Could not resolve a module for a custom reporter.\n' +
+            `  Module name: ${reporterPath}`
+        );
+      }
+      normalizedReporterConfig[0] = reporter;
+    }
+    return normalizedReporterConfig;
+  });
+};
+const buildTestPathPattern = argv => {
+  const patterns = [];
+  if (argv._) {
+    patterns.push(...argv._);
+  }
+  if (argv.testPathPattern) {
+    patterns.push(...argv.testPathPattern);
+  }
+  const replacePosixSep = pattern => {
+    // yargs coerces positional args into numbers
+    const patternAsString = pattern.toString();
+    if (path().sep === '/') {
+      return patternAsString;
+    }
+    return patternAsString.replace(/\//g, '\\\\');
+  };
+  const testPathPattern = patterns.map(replacePosixSep).join('|');
+  if ((0, _validatePattern.default)(testPathPattern)) {
+    return testPathPattern;
+  } else {
+    showTestPathPatternError(testPathPattern);
+    return '';
+  }
+};
+const showTestPathPatternError = testPathPattern => {
+  (0, _jestUtil().clearLine)(process.stdout);
+
+  // eslint-disable-next-line no-console
+  console.log(
+    _chalk().default.red(
+      `  Invalid testPattern ${testPathPattern} supplied. ` +
+        'Running all tests instead.'
+    )
+  );
+};
+function validateExtensionsToTreatAsEsm(extensionsToTreatAsEsm) {
+  if (!extensionsToTreatAsEsm || extensionsToTreatAsEsm.length === 0) {
+    return;
+  }
+  function printConfig(opts) {
+    const string = opts.map(ext => `'${ext}'`).join(', ');
+    return _chalk().default.bold(`extensionsToTreatAsEsm: [${string}]`);
+  }
+  const extensionWithoutDot = extensionsToTreatAsEsm.some(
+    ext => !ext.startsWith('.')
+  );
+  if (extensionWithoutDot) {
+    throw createConfigError(`  Option: ${printConfig(
+      extensionsToTreatAsEsm
+    )} includes a string that does not start with a period (${_chalk().default.bold(
+      '.'
+    )}).
+  Please change your configuration to ${printConfig(
+    extensionsToTreatAsEsm.map(ext => (ext.startsWith('.') ? ext : `.${ext}`))
+  )}.`);
+  }
+  if (extensionsToTreatAsEsm.includes('.js')) {
+    throw createConfigError(
+      `  Option: ${printConfig(
+        extensionsToTreatAsEsm
+      )} includes ${_chalk().default.bold(
+        "'.js'"
+      )} which is always inferred based on ${_chalk().default.bold(
+        'type'
+      )} in its nearest ${_chalk().default.bold('package.json')}.`
+    );
+  }
+  if (extensionsToTreatAsEsm.includes('.cjs')) {
+    throw createConfigError(
+      `  Option: ${printConfig(
+        extensionsToTreatAsEsm
+      )} includes ${_chalk().default.bold(
+        "'.cjs'"
+      )} which is always treated as CommonJS.`
+    );
+  }
+  if (extensionsToTreatAsEsm.includes('.mjs')) {
+    throw createConfigError(
+      `  Option: ${printConfig(
+        extensionsToTreatAsEsm
+      )} includes ${_chalk().default.bold(
+        "'.mjs'"
+      )} which is always treated as an ECMAScript Module.`
+    );
+  }
+}
+async function normalize(
+  initialOptions,
+  argv,
+  configPath,
+  projectIndex = Infinity,
+  isProjectOptions
+) {
+  const {hasDeprecationWarnings} = (0, _jestValidate().validate)(
+    initialOptions,
+    {
+      comment: _utils.DOCUMENTATION_NOTE,
+      deprecatedConfig: _Deprecated.default,
+      exampleConfig: isProjectOptions
+        ? _ValidConfig.initialProjectOptions
+        : _ValidConfig.initialOptions,
+      recursiveDenylist: [
+        // 'coverageThreshold' allows to use 'global' and glob strings on the same
+        // level, there's currently no way we can deal with such config
+        'coverageThreshold',
+        'globals',
+        'moduleNameMapper',
+        'testEnvironmentOptions',
+        'transform'
+      ]
+    }
+  );
+  let options = normalizeMissingOptions(
+    normalizeRootDir((0, _setFromArgv.default)(initialOptions, argv)),
+    configPath,
+    projectIndex
+  );
+  if (options.preset) {
+    options = await setupPreset(options, options.preset);
+  }
+  if (!options.setupFilesAfterEnv) {
+    options.setupFilesAfterEnv = [];
+  }
+  options.testEnvironment = (0, _jestResolve().resolveTestEnvironment)({
+    requireResolveFunction: require.resolve,
+    rootDir: options.rootDir,
+    testEnvironment:
+      options.testEnvironment ||
+      require.resolve(_Defaults.default.testEnvironment)
+  });
+  if (!options.roots) {
+    options.roots = [options.rootDir];
+  }
+  if (
+    !options.testRunner ||
+    options.testRunner === 'circus' ||
+    options.testRunner === 'jest-circus' ||
+    options.testRunner === 'jest-circus/runner'
+  ) {
+    options.testRunner = require.resolve('jest-circus/runner');
+  } else if (options.testRunner === 'jasmine2') {
+    try {
+      options.testRunner = require.resolve('jest-jasmine2');
+    } catch (error) {
+      if (error.code === 'MODULE_NOT_FOUND') {
+        throw createConfigError(
+          'jest-jasmine is no longer shipped by default with Jest, you need to install it explicitly or provide an absolute path to Jest'
+        );
+      }
+      throw error;
+    }
+  }
+  if (!options.coverageDirectory) {
+    options.coverageDirectory = path().resolve(options.rootDir, 'coverage');
+  }
+  setupBabelJest(options);
+  // TODO: Type this properly
+  const newOptions = {
+    ..._Defaults.default
+  };
+  if (options.resolver) {
+    newOptions.resolver = (0, _utils.resolve)(null, {
+      filePath: options.resolver,
+      key: 'resolver',
+      rootDir: options.rootDir
+    });
+  }
+  validateExtensionsToTreatAsEsm(options.extensionsToTreatAsEsm);
+  if (options.watchman == null) {
+    options.watchman = _Defaults.default.watchman;
+  }
+  const optionKeys = Object.keys(options);
+  optionKeys.reduce((newOptions, key) => {
+    // The resolver has been resolved separately; skip it
+    if (key === 'resolver') {
+      return newOptions;
+    }
+
+    // This is cheating, because it claims that all keys of InitialOptions are Required.
+    // We only really know it's Required for oldOptions[key], not for oldOptions.someOtherKey,
+    // so oldOptions[key] is the only way it should be used.
+    const oldOptions = options;
+    let value;
+    switch (key) {
+      case 'setupFiles':
+      case 'setupFilesAfterEnv':
+      case 'snapshotSerializers':
+        {
+          const option = oldOptions[key];
+          value =
+            option &&
+            option.map(filePath =>
+              (0, _utils.resolve)(newOptions.resolver, {
+                filePath,
+                key,
+                rootDir: options.rootDir
+              })
+            );
+        }
+        break;
+      case 'modulePaths':
+      case 'roots':
+        {
+          const option = oldOptions[key];
+          value =
+            option &&
+            option.map(filePath =>
+              path().resolve(
+                options.rootDir,
+                (0, _utils.replaceRootDirInPath)(options.rootDir, filePath)
+              )
+            );
+        }
+        break;
+      case 'collectCoverageFrom':
+        value = normalizeCollectCoverageFrom(oldOptions, key);
+        break;
+      case 'cacheDirectory':
+      case 'coverageDirectory':
+        {
+          const option = oldOptions[key];
+          value =
+            option &&
+            path().resolve(
+              options.rootDir,
+              (0, _utils.replaceRootDirInPath)(options.rootDir, option)
+            );
+        }
+        break;
+      case 'dependencyExtractor':
+      case 'globalSetup':
+      case 'globalTeardown':
+      case 'runtime':
+      case 'snapshotResolver':
+      case 'testResultsProcessor':
+      case 'testRunner':
+      case 'filter':
+        {
+          const option = oldOptions[key];
+          value =
+            option &&
+            (0, _utils.resolve)(newOptions.resolver, {
+              filePath: option,
+              key,
+              rootDir: options.rootDir
+            });
+        }
+        break;
+      case 'runner':
+        {
+          const option = oldOptions[key];
+          value =
+            option &&
+            (0, _jestResolve().resolveRunner)(newOptions.resolver, {
+              filePath: option,
+              requireResolveFunction: require.resolve,
+              rootDir: options.rootDir
+            });
+        }
+        break;
+      case 'prettierPath':
+        {
+          // We only want this to throw if "prettierPath" is explicitly passed
+          // from config or CLI, and the requested path isn't found. Otherwise we
+          // set it to null and throw an error lazily when it is used.
+
+          const option = oldOptions[key];
+          value =
+            option &&
+            (0, _utils.resolve)(newOptions.resolver, {
+              filePath: option,
+              key,
+              optional: option === _Defaults.default[key],
+              rootDir: options.rootDir
+            });
+        }
+        break;
+      case 'moduleNameMapper':
+        const moduleNameMapper = oldOptions[key];
+        value =
+          moduleNameMapper &&
+          Object.keys(moduleNameMapper).map(regex => {
+            const item = moduleNameMapper && moduleNameMapper[regex];
+            return (
+              item && [
+                regex,
+                (0, _utils._replaceRootDirTags)(options.rootDir, item)
+              ]
+            );
+          });
+        break;
+      case 'transform':
+        const transform = oldOptions[key];
+        value =
+          transform &&
+          Object.keys(transform).map(regex => {
+            const transformElement = transform[regex];
+            return [
+              regex,
+              (0, _utils.resolve)(newOptions.resolver, {
+                filePath: Array.isArray(transformElement)
+                  ? transformElement[0]
+                  : transformElement,
+                key,
+                rootDir: options.rootDir
+              }),
+              Array.isArray(transformElement) ? transformElement[1] : {}
+            ];
+          });
+        break;
+      case 'reporters':
+        value = normalizeReporters(oldOptions);
+        break;
+      case 'coveragePathIgnorePatterns':
+      case 'modulePathIgnorePatterns':
+      case 'testPathIgnorePatterns':
+      case 'transformIgnorePatterns':
+      case 'watchPathIgnorePatterns':
+      case 'unmockedModulePathPatterns':
+        value = normalizeUnmockedModulePathPatterns(oldOptions, key);
+        break;
+      case 'haste':
+        value = {
+          ...oldOptions[key]
+        };
+        if (value.hasteImplModulePath != null) {
+          const resolvedHasteImpl = (0, _utils.resolve)(newOptions.resolver, {
+            filePath: (0, _utils.replaceRootDirInPath)(
+              options.rootDir,
+              value.hasteImplModulePath
+            ),
+            key: 'haste.hasteImplModulePath',
+            rootDir: options.rootDir
+          });
+          value.hasteImplModulePath = resolvedHasteImpl || undefined;
+        }
+        break;
+      case 'projects':
+        value = (oldOptions[key] || [])
+          .map(project =>
+            typeof project === 'string'
+              ? (0, _utils._replaceRootDirTags)(options.rootDir, project)
+              : project
+          )
+          .reduce((projects, project) => {
+            // Project can be specified as globs. If a glob matches any files,
+            // We expand it to these paths. If not, we keep the original path
+            // for the future resolution.
+            const globMatches =
+              typeof project === 'string' ? (0, _glob().sync)(project) : [];
+            return projects.concat(globMatches.length ? globMatches : project);
+          }, []);
+        break;
+      case 'moduleDirectories':
+      case 'testMatch':
+        {
+          const replacedRootDirTags = (0, _utils._replaceRootDirTags)(
+            (0, _utils.escapeGlobCharacters)(options.rootDir),
+            oldOptions[key]
+          );
+          if (replacedRootDirTags) {
+            value = Array.isArray(replacedRootDirTags)
+              ? replacedRootDirTags.map(_jestUtil().replacePathSepForGlob)
+              : (0, _jestUtil().replacePathSepForGlob)(replacedRootDirTags);
+          } else {
+            value = replacedRootDirTags;
+          }
+        }
+        break;
+      case 'testRegex':
+        {
+          const option = oldOptions[key];
+          value = option
+            ? (Array.isArray(option) ? option : [option]).map(
+                _jestRegexUtil().replacePathSepForRegex
+              )
+            : [];
+        }
+        break;
+      case 'moduleFileExtensions': {
+        value = oldOptions[key];
+        if (
+          Array.isArray(value) &&
+          // If it's the wrong type, it can throw at a later time
+          (options.runner === undefined ||
+            options.runner === _Defaults.default.runner) &&
+          // Only require 'js' for the default jest-runner
+          !value.includes('js')
+        ) {
+          const errorMessage =
+            "  moduleFileExtensions must include 'js':\n" +
+            '  but instead received:\n' +
+            `    ${_chalk().default.bold.red(JSON.stringify(value))}`;
+
+          // If `js` is not included, any dependency Jest itself injects into
+          // the environment, like jasmine or sourcemap-support, will need to
+          // `require` its modules with a file extension. This is not plausible
+          // in the long run, so it's way easier to just fail hard early.
+          // We might consider throwing if `json` is missing as well, as it's a
+          // fair assumption from modules that they can do
+          // `require('some-package/package') without the trailing `.json` as it
+          // works in Node normally.
+          throw createConfigError(
+            `${errorMessage}\n  Please change your configuration to include 'js'.`
+          );
+        }
+        break;
+      }
+      case 'bail': {
+        const bail = oldOptions[key];
+        if (typeof bail === 'boolean') {
+          value = bail ? 1 : 0;
+        } else if (typeof bail === 'string') {
+          value = 1;
+          // If Jest is invoked as `jest --bail someTestPattern` then need to
+          // move the pattern from the `bail` configuration and into `argv._`
+          // to be processed as an extra parameter
+          argv._.push(bail);
+        } else {
+          value = oldOptions[key];
+        }
+        break;
+      }
+      case 'displayName': {
+        const displayName = oldOptions[key];
+        /**
+         * Ensuring that displayName shape is correct here so that the
+         * reporters can trust the shape of the data
+         */
+        if (typeof displayName === 'object') {
+          const {name, color} = displayName;
+          if (
+            !name ||
+            !color ||
+            typeof name !== 'string' ||
+            typeof color !== 'string'
+          ) {
+            const errorMessage =
+              `  Option "${_chalk().default.bold(
+                'displayName'
+              )}" must be of type:\n\n` +
+              '  {\n' +
+              '    name: string;\n' +
+              '    color: string;\n' +
+              '  }\n';
+            throw createConfigError(errorMessage);
+          }
+          value = oldOptions[key];
+        } else {
+          value = {
+            color: (0, _color.getDisplayNameColor)(options.runner),
+            name: displayName
+          };
+        }
+        break;
+      }
+      case 'testTimeout': {
+        if (oldOptions[key] < 0) {
+          throw createConfigError(
+            `  Option "${_chalk().default.bold(
+              'testTimeout'
+            )}" must be a natural number.`
+          );
+        }
+        value = oldOptions[key];
+        break;
+      }
+      case 'snapshotFormat': {
+        value = {
+          ..._Defaults.default.snapshotFormat,
+          ...oldOptions[key]
+        };
+        break;
+      }
+      case 'automock':
+      case 'cache':
+      case 'changedSince':
+      case 'changedFilesWithAncestor':
+      case 'clearMocks':
+      case 'collectCoverage':
+      case 'coverageProvider':
+      case 'coverageReporters':
+      case 'coverageThreshold':
+      case 'detectLeaks':
+      case 'detectOpenHandles':
+      case 'errorOnDeprecated':
+      case 'expand':
+      case 'extensionsToTreatAsEsm':
+      case 'globals':
+      case 'fakeTimers':
+      case 'findRelatedTests':
+      case 'forceCoverageMatch':
+      case 'forceExit':
+      case 'injectGlobals':
+      case 'lastCommit':
+      case 'listTests':
+      case 'logHeapUsage':
+      case 'maxConcurrency':
+      case 'id':
+      case 'noStackTrace':
+      case 'notify':
+      case 'notifyMode':
+      case 'onlyChanged':
+      case 'onlyFailures':
+      case 'openHandlesTimeout':
+      case 'outputFile':
+      case 'passWithNoTests':
+      case 'randomize':
+      case 'replname':
+      case 'resetMocks':
+      case 'resetModules':
+      case 'restoreMocks':
+      case 'rootDir':
+      case 'runTestsByPath':
+      case 'sandboxInjectedGlobals':
+      case 'silent':
+      case 'showSeed':
+      case 'skipFilter':
+      case 'skipNodeResolution':
+      case 'slowTestThreshold':
+      case 'testEnvironment':
+      case 'testEnvironmentOptions':
+      case 'testFailureExitCode':
+      case 'testLocationInResults':
+      case 'testNamePattern':
+      case 'useStderr':
+      case 'verbose':
+      case 'watch':
+      case 'watchAll':
+      case 'watchman':
+      case 'workerThreads':
+        value = oldOptions[key];
+        break;
+      case 'workerIdleMemoryLimit':
+        value = (0, _stringToBytes.default)(
+          oldOptions[key],
+          (0, _os().totalmem)()
+        );
+        break;
+      case 'watchPlugins':
+        value = (oldOptions[key] || []).map(watchPlugin => {
+          if (typeof watchPlugin === 'string') {
+            return {
+              config: {},
+              path: (0, _jestResolve().resolveWatchPlugin)(
+                newOptions.resolver,
+                {
+                  filePath: watchPlugin,
+                  requireResolveFunction: require.resolve,
+                  rootDir: options.rootDir
+                }
+              )
+            };
+          } else {
+            return {
+              config: watchPlugin[1] || {},
+              path: (0, _jestResolve().resolveWatchPlugin)(
+                newOptions.resolver,
+                {
+                  filePath: watchPlugin[0],
+                  requireResolveFunction: require.resolve,
+                  rootDir: options.rootDir
+                }
+              )
+            };
+          }
+        });
+        break;
+    }
+    // @ts-expect-error: automock is missing in GlobalConfig, so what
+    newOptions[key] = value;
+    return newOptions;
+  }, newOptions);
+  if (options.watchman && options.haste?.enableSymlinks) {
+    throw new (_jestValidate().ValidationError)(
+      'Validation Error',
+      'haste.enableSymlinks is incompatible with watchman',
+      'Either set haste.enableSymlinks to false or do not use watchman'
+    );
+  }
+  newOptions.roots.forEach((root, i) => {
+    verifyDirectoryExists(root, `roots[${i}]`);
+  });
+  try {
+    // try to resolve windows short paths, ignoring errors (permission errors, mostly)
+    newOptions.cwd = (0, _jestUtil().tryRealpath)(process.cwd());
+  } catch {
+    // ignored
+  }
+  newOptions.testSequencer = (0, _jestResolve().resolveSequencer)(
+    newOptions.resolver,
+    {
+      filePath:
+        options.testSequencer ||
+        require.resolve(_Defaults.default.testSequencer),
+      requireResolveFunction: require.resolve,
+      rootDir: options.rootDir
+    }
+  );
+  if (newOptions.runner === _Defaults.default.runner) {
+    newOptions.runner = require.resolve(newOptions.runner);
+  }
+  newOptions.nonFlagArgs = argv._?.map(arg => `${arg}`);
+  newOptions.testPathPattern = buildTestPathPattern(argv);
+  newOptions.json = !!argv.json;
+  newOptions.testFailureExitCode = parseInt(newOptions.testFailureExitCode, 10);
+  if (
+    newOptions.lastCommit ||
+    newOptions.changedFilesWithAncestor ||
+    newOptions.changedSince
+  ) {
+    newOptions.onlyChanged = true;
+  }
+  if (argv.all) {
+    newOptions.onlyChanged = false;
+    newOptions.onlyFailures = false;
+  } else if (newOptions.testPathPattern) {
+    // When passing a test path pattern we don't want to only monitor changed
+    // files unless `--watch` is also passed.
+    newOptions.onlyChanged = newOptions.watch;
+  }
+  newOptions.randomize = newOptions.randomize || argv.randomize;
+  newOptions.showSeed =
+    newOptions.randomize || newOptions.showSeed || argv.showSeed;
+  const upperBoundSeedValue = 2 ** 31;
+
+  // bounds are determined by xoroshiro128plus which is used in v8 and is used here (at time of writing)
+  newOptions.seed =
+    argv.seed ??
+    Math.floor((2 ** 32 - 1) * Math.random() - upperBoundSeedValue);
+  if (
+    newOptions.seed < -upperBoundSeedValue ||
+    newOptions.seed > upperBoundSeedValue - 1
+  ) {
+    throw new (_jestValidate().ValidationError)(
+      'Validation Error',
+      `seed value must be between \`-0x80000000\` and \`0x7fffffff\` inclusive - instead it is ${newOptions.seed}`
+    );
+  }
+  if (!newOptions.onlyChanged) {
+    newOptions.onlyChanged = false;
+  }
+  if (!newOptions.lastCommit) {
+    newOptions.lastCommit = false;
+  }
+  if (!newOptions.onlyFailures) {
+    newOptions.onlyFailures = false;
+  }
+  if (!newOptions.watchAll) {
+    newOptions.watchAll = false;
+  }
+
+  // as unknown since it can happen. We really need to fix the types here
+  if (newOptions.moduleNameMapper === _Defaults.default.moduleNameMapper) {
+    newOptions.moduleNameMapper = [];
+  }
+  if (argv.ci != null) {
+    newOptions.ci = argv.ci;
+  }
+  newOptions.updateSnapshot =
+    newOptions.ci && !argv.updateSnapshot
+      ? 'none'
+      : argv.updateSnapshot
+      ? 'all'
+      : 'new';
+  newOptions.maxConcurrency = parseInt(newOptions.maxConcurrency, 10);
+  newOptions.maxWorkers = (0, _getMaxWorkers.default)(argv, options);
+  if (newOptions.testRegex.length > 0 && options.testMatch) {
+    throw createConfigError(
+      `  Configuration options ${_chalk().default.bold('testMatch')} and` +
+        ` ${_chalk().default.bold('testRegex')} cannot be used together.`
+    );
+  }
+  if (newOptions.testRegex.length > 0 && !options.testMatch) {
+    // Prevent the default testMatch conflicting with any explicitly
+    // configured `testRegex` value
+    newOptions.testMatch = [];
+  }
+
+  // If argv.json is set, coverageReporters shouldn't print a text report.
+  if (argv.json) {
+    newOptions.coverageReporters = (newOptions.coverageReporters || []).filter(
+      reporter => reporter !== 'text'
+    );
+  }
+
+  // If collectCoverage is enabled while using --findRelatedTests we need to
+  // avoid having false negatives in the generated coverage report.
+  // The following: `--findRelatedTests '/rootDir/file1.js' --coverage`
+  // Is transformed to: `--findRelatedTests '/rootDir/file1.js' --coverage --collectCoverageFrom 'file1.js'`
+  // where arguments to `--collectCoverageFrom` should be globs (or relative
+  // paths to the rootDir)
+  if (newOptions.collectCoverage && argv.findRelatedTests) {
+    let collectCoverageFrom = newOptions.nonFlagArgs.map(filename => {
+      filename = (0, _utils.replaceRootDirInPath)(options.rootDir, filename);
+      return path().isAbsolute(filename)
+        ? path().relative(options.rootDir, filename)
+        : filename;
+    });
+
+    // Don't override existing collectCoverageFrom options
+    if (newOptions.collectCoverageFrom) {
+      collectCoverageFrom = collectCoverageFrom.reduce((patterns, filename) => {
+        if (
+          (0, _micromatch().default)(
+            [
+              (0, _jestUtil().replacePathSepForGlob)(
+                path().relative(options.rootDir, filename)
+              )
+            ],
+            newOptions.collectCoverageFrom
+          ).length === 0
+        ) {
+          return patterns;
+        }
+        return [...patterns, filename];
+      }, newOptions.collectCoverageFrom);
+    }
+    newOptions.collectCoverageFrom = collectCoverageFrom;
+  } else if (!newOptions.collectCoverageFrom) {
+    newOptions.collectCoverageFrom = [];
+  }
+  if (!newOptions.findRelatedTests) {
+    newOptions.findRelatedTests = false;
+  }
+  if (!newOptions.projects) {
+    newOptions.projects = [];
+  }
+  if (!newOptions.sandboxInjectedGlobals) {
+    newOptions.sandboxInjectedGlobals = [];
+  }
+  if (!newOptions.forceExit) {
+    newOptions.forceExit = false;
+  }
+  if (!newOptions.logHeapUsage) {
+    newOptions.logHeapUsage = false;
+  }
+  if (argv.shard) {
+    newOptions.shard = (0, _parseShardPair.parseShardPair)(argv.shard);
+  }
+  return {
+    hasDeprecationWarnings,
+    options: newOptions
+  };
+}