text: 'use strict';Object.defineProperty(exports, "__esModule", { value: true });exports.normalize = exports.isJSONString = exports.getTestEnvironment = undefined;var _utils;
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  function _load_utils() {return _utils = require('./utils');}Object.defineProperty(exports, 'getTestEnvironment', { enumerable: true, get: function () {return (_utils || _load_utils()).
  
  
  
  
      getTestEnvironment;} });Object.defineProperty(exports, 'isJSONString', { enumerable: true, get: function () {return (_utils || _load_utils()).isJSONString;} });var _normalize2;function _load_normalize() {return _normalize2 = require('./normalize');}Object.defineProperty(exports, 'normalize', { enumerable: true, get: function () {return _interopRequireDefault(_normalize2 || _load_normalize()).
      default;} });exports.
  
  readConfig = readConfig;var _path;function _load_path() {return _path = _interopRequireDefault(require('path'));}var _normalize3;function _load_normalize2() {return _normalize3 = _interopRequireDefault(require('./normalize'));}var _resolve_config_path;function _load_resolve_config_path() {return _resolve_config_path = _interopRequireDefault(require('./resolve_config_path'));}var _read_config_file_and_set_root_dir;function _load_read_config_file_and_set_root_dir() {return _read_config_file_and_set_root_dir = _interopRequireDefault(require('./read_config_file_and_set_root_dir'));}function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { default: obj };}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
  
  skipArgvConfigOption,
  parentConfigPath)
  
  
  
  
  
  {
    let rawOptions;
    let configPath = null;
  
    if (typeof packageRootOrConfig !== 'string') {
      if (parentConfigPath) {
        rawOptions = packageRootOrConfig;
        rawOptions.rootDir = (_path || _load_path()).default.dirname(parentConfigPath);
      } else {
        throw new Error(
        'Jest: Cannot use configuration as an object without a file path.');
  
      }
    } else if ((0, (_utils || _load_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 (e) {
        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` or `jest.conf.js`
    } else if (!skipArgvConfigOption && typeof argv.config == 'string') {
      configPath = (0, (_resolve_config_path || _load_resolve_config_path()).default)(argv.config, process.cwd());
      rawOptions = (0, (_read_config_file_and_set_root_dir || _load_read_config_file_and_set_root_dir()).default)(configPath);
    } else {
      // Otherwise just try to find config in the current rootDir.
      configPath = (0, (_resolve_config_path || _load_resolve_config_path()).default)(packageRootOrConfig, process.cwd());
      rawOptions = (0, (_read_config_file_and_set_root_dir || _load_read_config_file_and_set_root_dir()).default)(configPath);
    }var _normalize =
  
    (0, (_normalize3 || _load_normalize2()).default)(rawOptions, argv);const options = _normalize.options,hasDeprecationWarnings = _normalize.hasDeprecationWarnings;var _getConfigs =
    getConfigs(options);const globalConfig = _getConfigs.globalConfig,projectConfig = _getConfigs.projectConfig;
    return {
      configPath,
      globalConfig,
      hasDeprecationWarnings,
      projectConfig };
  
  }
  
  const getConfigs =
  options =>
  {
    return {
      globalConfig: Object.freeze({
        bail: options.bail,
        changedFilesWithAncestor: options.changedFilesWithAncestor,
        changedSince: options.changedSince,
        collectCoverage: options.collectCoverage,
        collectCoverageFrom: options.collectCoverageFrom,
        collectCoverageOnlyFrom: options.collectCoverageOnlyFrom,
        coverageDirectory: options.coverageDirectory,
        coverageReporters: options.coverageReporters,
        coverageThreshold: options.coverageThreshold,
        detectLeaks: options.detectLeaks,
        enabledTestsMap: options.enabledTestsMap,
        expand: options.expand,
        findRelatedTests: options.findRelatedTests,
        forceExit: options.forceExit,
        globalSetup: options.globalSetup,
        globalTeardown: options.globalTeardown,
        json: options.json,
        lastCommit: options.lastCommit,
        listTests: options.listTests,
        logHeapUsage: options.logHeapUsage,
        mapCoverage: options.mapCoverage,
        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,
        testFailureExitCode: options.testFailureExitCode,
        testNamePattern: options.testNamePattern,
        testPathPattern: options.testPathPattern,
        testResultsProcessor: options.testResultsProcessor,
        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,
        browser: options.browser,
        cache: options.cache,
        cacheDirectory: options.cacheDirectory,
        clearMocks: options.clearMocks,
        coveragePathIgnorePatterns: options.coveragePathIgnorePatterns,
        cwd: options.cwd,
        detectLeaks: options.detectLeaks,
        displayName: options.displayName,
        forceCoverageMatch: options.forceCoverageMatch,
        globals: options.globals,
        haste: options.haste,
        moduleDirectories: options.moduleDirectories,
        moduleFileExtensions: options.moduleFileExtensions,
        moduleLoader: options.moduleLoader,
        moduleNameMapper: options.moduleNameMapper,
        modulePathIgnorePatterns: options.modulePathIgnorePatterns,
        modulePaths: options.modulePaths,
        name: options.name,
        resetMocks: options.resetMocks,
        resetModules: options.resetModules,
        resolver: options.resolver,
        restoreMocks: options.restoreMocks,
        rootDir: options.rootDir,
        roots: options.roots,
        runner: options.runner,
        setupFiles: options.setupFiles,
        setupTestFrameworkScriptFile: options.setupTestFrameworkScriptFile,
        skipNodeResolution: options.skipNodeResolution,
        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 }) };
  
  
  };