“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.default = exports.semverMin = exports.isBrowsersQueryValid = void 0;

var _browserslist = _interopRequireDefault(require(“browserslist”));

var _invariant = _interopRequireDefault(require(“invariant”));

var _semver = _interopRequireDefault(require(“semver”));

var _utils = require(“./utils”);

var _builtInModules = _interopRequireDefault(require(“../data/built-in-modules.json”));

var _options = require(“./options”);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const browserslistDefaults = _browserslist.default.defaults; const validBrowserslistTargets = […Object.keys(_browserslist.default.data), …Object.keys(_browserslist.default.aliases)];

const objectToBrowserslist = object => {

return Object.keys(object).reduce((list, targetName) => {
  if (validBrowserslistTargets.indexOf(targetName) >= 0) {
    const targetVersion = object[targetName];
    return list.concat(`${targetName} ${targetVersion}`);
  }

  return list;
}, []);

};

const validateTargetNames = targets => {

const validTargets = Object.keys(_options.TargetNames);

for (const target in targets) {
  if (!_options.TargetNames[target]) {
    throw new Error(`Invalid Option: '${target}' is not a valid target
      Maybe you meant to use '${(0, _utils.findSuggestion)(validTargets, target)}'?`);
  }
}

};

const browserNameMap = {

and_chr: "chrome",
and_ff: "firefox",
android: "android",
chrome: "chrome",
edge: "edge",
firefox: "firefox",
ie: "ie",
ie_mob: "ie",
ios_saf: "ios",
node: "node",
op_mob: "opera",
opera: "opera",
safari: "safari",
samsung: "samsung"

};

const isBrowsersQueryValid = browsers => typeof browsers === “string” || Array.isArray(browsers);

exports.isBrowsersQueryValid = isBrowsersQueryValid;

const validateBrowsers = browsers => {

(0, _invariant.default)(typeof browsers === "undefined" || isBrowsersQueryValid(browsers), `Invalid Option: '${browsers}' is not a valid browserslist query`);
return browsers;

};

const semverMin = (first, second) => {

return first && _semver.default.lt(first, second) ? first : second;

};

exports.semverMin = semverMin;

const mergeBrowsers = (fromQuery, fromTarget) => {

return Object.keys(fromTarget).reduce((queryObj, targKey) => {
  if (targKey !== _options.TargetNames.browsers) {
    queryObj[targKey] = fromTarget[targKey];
  }

  return queryObj;
}, fromQuery);

};

const getLowestVersions = browsers => {

return browsers.reduce((all, browser) => {
  const [browserName, browserVersion] = browser.split(" ");
  const normalizedBrowserName = browserNameMap[browserName];

  if (!normalizedBrowserName) {
    return all;
  }

  try {
    const splitVersion = browserVersion.split("-")[0].toLowerCase();
    const isSplitUnreleased = (0, _utils.isUnreleasedVersion)(splitVersion, browserName);

    if (!all[normalizedBrowserName]) {
      all[normalizedBrowserName] = isSplitUnreleased ? splitVersion : (0, _utils.semverify)(splitVersion);
      return all;
    }

    const version = all[normalizedBrowserName];
    const isUnreleased = (0, _utils.isUnreleasedVersion)(version, browserName);

    if (isUnreleased && isSplitUnreleased) {
      all[normalizedBrowserName] = (0, _utils.getLowestUnreleased)(version, splitVersion, browserName);
    } else if (isUnreleased) {
      all[normalizedBrowserName] = (0, _utils.semverify)(splitVersion);
    } else if (!isUnreleased && !isSplitUnreleased) {
      const parsedBrowserVersion = (0, _utils.semverify)(splitVersion);
      all[normalizedBrowserName] = semverMin(version, parsedBrowserVersion);
    }
  } catch (e) {}

  return all;
}, {});

};

const outputDecimalWarning = decimalTargets => {

if (!decimalTargets || !decimalTargets.length) {
  return;
}

console.log("Warning, the following targets are using a decimal version:");
console.log("");
decimalTargets.forEach(({
  target,
  value
}) => console.log(`  ${target}: ${value}`));
console.log("");
console.log("We recommend using a string for minor/patch versions to avoid numbers like 6.10");
console.log("getting parsed as 6.1, which can lead to unexpected behavior.");
console.log("");

};

const semverifyTarget = (target, value) => {

try {
  return (0, _utils.semverify)(value);
} catch (error) {
  throw new Error(`Invalid Option: '${value}' is not a valid value for 'targets.${target}'.`);
}

};

const targetParserMap = {

__default: (target, value) => {
  const version = (0, _utils.isUnreleasedVersion)(value, target) ? value.toLowerCase() : semverifyTarget(target, value);
  return [target, version];
},
node: (target, value) => {
  const parsed = value === true || value === "current" ? process.versions.node : semverifyTarget(target, value);
  return [target, parsed];
}

};

const getTargets = (targets = {}, options = {}) => {

const targetOpts = {};
validateTargetNames(targets);

if (targets.esmodules) {
  const supportsESModules = _builtInModules.default["es6.module"];
  targets.browsers = Object.keys(supportsESModules).map(browser => `${browser} ${supportsESModules[browser]}`).join(", ");
}

const browsersquery = validateBrowsers(targets.browsers);
const hasTargets = Object.keys(targets).length > 0;
const shouldParseBrowsers = !!targets.browsers;
const shouldSearchForConfig = !options.ignoreBrowserslistConfig && !hasTargets;

if (shouldParseBrowsers || shouldSearchForConfig) {
  if (!hasTargets) {
    _browserslist.default.defaults = objectToBrowserslist(targets);
  }

  const browsers = (0, _browserslist.default)(browsersquery, {
    path: options.configPath,
    mobileToDesktop: true
  });
  const queryBrowsers = getLowestVersions(browsers);
  targets = mergeBrowsers(queryBrowsers, targets);
  _browserslist.default.defaults = browserslistDefaults;
}

const parsed = Object.keys(targets).filter(value => value !== _options.TargetNames.esmodules).sort().reduce((results, target) => {
  if (target !== _options.TargetNames.browsers) {
    const value = targets[target];

    if (typeof value === "number" && value % 1 !== 0) {
      results.decimalWarnings.push({
        target,
        value
      });
    }

    const parser = targetParserMap[target] || targetParserMap.__default;
    const [parsedTarget, parsedValue] = parser(target, value);

    if (parsedValue) {
      results.targets[parsedTarget] = parsedValue;
    }
  }

  return results;
}, {
  targets: targetOpts,
  decimalWarnings: []
});
outputDecimalWarning(parsed.decimalWarnings);
return parsed.targets;

};

var _default = getTargets; exports.default = _default;