import bbm from "/new/baseline-browser-mapping@v2.10.14/dist=es2019,mode=imports?from=baseline-browser-mapping";
import jsReleases from "/new/node-releases@v2.0.37/dist=es2019,mode=imports/data/processed/envs.json?from=node-releases";
import require$$0 from "/new/caniuse-lite@v1.0.30001784/dist=es2019,mode=imports/dist/unpacker/agents?from=caniuse-lite";
import e2c from "/new/electron-to-chromium@v1.5.331/dist=es2019,mode=imports/versions?from=electron-to-chromium";
import jsEOL from "/new/node-releases@v2.0.37/dist=es2019,mode=imports/data/release-schedule/release-schedule.json?from=node-releases";
var _nodeResolve_empty = {};
var _nodeResolve_empty$1 = /* @__PURE__ */ Object.freeze({
  __proto__: null,
  default: _nodeResolve_empty
});
function BrowserslistError(message) {
  this.name = "BrowserslistError";
  this.message = message;
  this.browserslist = true;
  if (Error.captureStackTrace) {
    Error.captureStackTrace(this, BrowserslistError);
  }
}
BrowserslistError.prototype = Error.prototype;
var error = BrowserslistError;
function noop() {
}
var browser = {
  loadQueries: function loadQueries() {
    throw new error("Sharable configs are not supported in client-side build of Browserslist");
  },
  getStat: function getStat(opts) {
    return opts.stats;
  },
  loadConfig: function loadConfig(opts) {
    if (opts.config) {
      throw new error("Browserslist config are not supported in client-side build");
    }
  },
  loadCountry: function loadCountry() {
    throw new error("Country statistics are not supported in client-side build of Browserslist");
  },
  loadFeature: function loadFeature() {
    throw new error("Supports queries are not available in client-side build of Browserslist");
  },
  currentNode: function currentNode(resolve2, context) {
    return resolve2(["maintained node versions"], context)[0];
  },
  parseConfig: noop,
  readConfig: noop,
  findConfig: noop,
  findConfigFile: noop,
  clearCaches: noop,
  oldDataWarning: noop,
  env: {}
};
var AND_REGEXP = /^\s+and\s+(.*)/i;
var OR_REGEXP = /^(?:,\s*|\s+or\s+)(.*)/i;
function flatten(array) {
  if (!Array.isArray(array))
    return [array];
  return array.reduce(function(a, b) {
    return a.concat(flatten(b));
  }, []);
}
function find(string, predicate) {
  for (var max = string.length, n = 1; n <= max; n++) {
    var parsed = string.substr(-n, n);
    if (predicate(parsed, n, max)) {
      return string.slice(0, -n);
    }
  }
  return "";
}
function matchQuery(all, query) {
  var node = {query};
  if (query.indexOf("not ") === 0) {
    node.not = true;
    query = query.slice(4);
  }
  for (var name in all) {
    var type = all[name];
    var match = query.match(type.regexp);
    if (match) {
      node.type = name;
      for (var i = 0; i < type.matches.length; i++) {
        node[type.matches[i]] = match[i + 1];
      }
      return node;
    }
  }
  node.type = "unknown";
  return node;
}
function matchBlock(all, string, qs) {
  var node;
  return find(string, function(parsed, n, max) {
    if (AND_REGEXP.test(parsed)) {
      node = matchQuery(all, parsed.match(AND_REGEXP)[1]);
      node.compose = "and";
      qs.unshift(node);
      return true;
    } else if (OR_REGEXP.test(parsed)) {
      node = matchQuery(all, parsed.match(OR_REGEXP)[1]);
      node.compose = "or";
      qs.unshift(node);
      return true;
    } else if (n === max) {
      node = matchQuery(all, parsed.trim());
      node.compose = "or";
      qs.unshift(node);
      return true;
    }
    return false;
  });
}
var parse = function parse2(all, queries) {
  if (!Array.isArray(queries))
    queries = [queries];
  return flatten(queries.map(function(block) {
    var qs = [];
    do {
      block = matchBlock(all, block, qs);
    } while (block);
    return qs;
  }));
};
function getDefaultExportFromNamespaceIfNotNamed(n) {
  return n && Object.prototype.hasOwnProperty.call(n, "default") && Object.keys(n).length === 1 ? n["default"] : n;
}
var path = /* @__PURE__ */ getDefaultExportFromNamespaceIfNotNamed(_nodeResolve_empty$1);
var agents = require$$0.agents;
var YEAR = 365.259641 * 24 * 60 * 60 * 1e3;
var ANDROID_EVERGREEN_FIRST = "37";
var OP_MOB_BLINK_FIRST = 14;
var FIREFOX_ESR_VERSION = "140";
function isVersionsMatch(versionA, versionB) {
  return (versionA + ".").indexOf(versionB + ".") === 0;
}
function isEolReleased(name) {
  var version = name.slice(1);
  return browserslist.nodeVersions.some(function(i) {
    return isVersionsMatch(i, version);
  });
}
function normalize(versions) {
  return versions.filter(function(version) {
    return typeof version === "string";
  });
}
function normalizeElectron(version) {
  var versionToUse = version;
  if (version.split(".").length === 3) {
    versionToUse = version.split(".").slice(0, -1).join(".");
  }
  return versionToUse;
}
function nameMapper(name) {
  return function mapName(version) {
    return name + " " + version;
  };
}
function getMajor(version) {
  return parseInt(version.split(".")[0]);
}
function getMajorVersions(released, number) {
  if (released.length === 0)
    return [];
  var majorVersions = uniq(released.map(getMajor));
  var minimum = majorVersions[majorVersions.length - number];
  if (!minimum) {
    return released;
  }
  var selected = [];
  for (var i = released.length - 1; i >= 0; i--) {
    if (minimum > getMajor(released[i]))
      break;
    selected.unshift(released[i]);
  }
  return selected;
}
function uniq(array) {
  var filtered = [];
  for (var i = 0; i < array.length; i++) {
    if (filtered.indexOf(array[i]) === -1)
      filtered.push(array[i]);
  }
  return filtered;
}
function fillUsage(result, name, data) {
  for (var i in data) {
    result[name + " " + i] = data[i];
  }
}
function generateFilter(sign, version) {
  version = parseFloat(version);
  if (sign === ">") {
    return function(v) {
      return parseLatestFloat(v) > version;
    };
  } else if (sign === ">=") {
    return function(v) {
      return parseLatestFloat(v) >= version;
    };
  } else if (sign === "<") {
    return function(v) {
      return parseFloat(v) < version;
    };
  } else {
    return function(v) {
      return parseFloat(v) <= version;
    };
  }
  function parseLatestFloat(v) {
    return parseFloat(v.split("-")[1] || v);
  }
}
function generateSemverFilter(sign, version) {
  version = version.split(".").map(parseSimpleInt);
  version[1] = version[1] || 0;
  version[2] = version[2] || 0;
  if (sign === ">") {
    return function(v) {
      v = v.split(".").map(parseSimpleInt);
      return compareSemver(v, version) > 0;
    };
  } else if (sign === ">=") {
    return function(v) {
      v = v.split(".").map(parseSimpleInt);
      return compareSemver(v, version) >= 0;
    };
  } else if (sign === "<") {
    return function(v) {
      v = v.split(".").map(parseSimpleInt);
      return compareSemver(version, v) > 0;
    };
  } else {
    return function(v) {
      v = v.split(".").map(parseSimpleInt);
      return compareSemver(version, v) >= 0;
    };
  }
}
function parseSimpleInt(x) {
  return parseInt(x);
}
function compare(a, b) {
  if (a < b)
    return -1;
  if (a > b)
    return 1;
  return 0;
}
function compareSemver(a, b) {
  return compare(parseInt(a[0]), parseInt(b[0])) || compare(parseInt(a[1] || "0"), parseInt(b[1] || "0")) || compare(parseInt(a[2] || "0"), parseInt(b[2] || "0"));
}
function semverFilterLoose(operator, range) {
  range = range.split(".").map(parseSimpleInt);
  if (typeof range[1] === "undefined") {
    range[1] = "x";
  }
  switch (operator) {
    case "<=":
      return function(version) {
        version = version.split(".").map(parseSimpleInt);
        return compareSemverLoose(version, range) <= 0;
      };
    case ">=":
    default:
      return function(version) {
        version = version.split(".").map(parseSimpleInt);
        return compareSemverLoose(version, range) >= 0;
      };
  }
}
function compareSemverLoose(version, range) {
  if (version[0] !== range[0]) {
    return version[0] < range[0] ? -1 : 1;
  }
  if (range[1] === "x") {
    return 0;
  }
  if (version[1] !== range[1]) {
    return version[1] < range[1] ? -1 : 1;
  }
  return 0;
}
function resolveVersion(data, version) {
  if (data.versions.indexOf(version) !== -1) {
    return version;
  } else if (browserslist.versionAliases[data.name][version]) {
    return browserslist.versionAliases[data.name][version];
  } else {
    return false;
  }
}
function normalizeVersion(data, version) {
  var resolved = resolveVersion(data, version);
  if (resolved) {
    return resolved;
  } else if (data.versions.length === 1) {
    return data.versions[0];
  } else {
    return false;
  }
}
function filterByYear(since, context) {
  since = since / 1e3;
  return Object.keys(agents).reduce(function(selected, name) {
    var data = byName(name, context);
    if (!data)
      return selected;
    var versions = Object.keys(data.releaseDate).filter(function(v) {
      var date = data.releaseDate[v];
      return date !== null && date >= since;
    });
    return selected.concat(versions.map(nameMapper(data.name)));
  }, []);
}
function cloneData(data) {
  return {
    name: data.name,
    versions: data.versions,
    released: data.released,
    releaseDate: data.releaseDate
  };
}
function byName(name, context) {
  name = name.toLowerCase();
  name = browserslist.aliases[name] || name;
  if (context.mobileToDesktop && browserslist.desktopNames[name]) {
    var desktop = browserslist.data[browserslist.desktopNames[name]];
    if (name === "android") {
      return normalizeAndroidData(cloneData(browserslist.data[name]), desktop);
    } else {
      var cloned = cloneData(desktop);
      cloned.name = name;
      return cloned;
    }
  }
  return browserslist.data[name];
}
function normalizeAndroidVersions(androidVersions, chromeVersions) {
  var iFirstEvergreen = chromeVersions.indexOf(ANDROID_EVERGREEN_FIRST);
  return androidVersions.filter(function(version) {
    return /^(?:[2-4]\.|[34]$)/.test(version);
  }).concat(chromeVersions.slice(iFirstEvergreen));
}
var DANGEROUS_KEYS = ["__proto__", "constructor", "prototype"];
function copyObject(obj) {
  var copy = {};
  for (var key in obj) {
    if (DANGEROUS_KEYS.indexOf(key) === -1) {
      copy[key] = obj[key];
    }
  }
  return copy;
}
function normalizeAndroidData(android, chrome) {
  android.released = normalizeAndroidVersions(android.released, chrome.released);
  android.versions = normalizeAndroidVersions(android.versions, chrome.versions);
  android.releaseDate = copyObject(android.releaseDate);
  android.released.forEach(function(v) {
    if (android.releaseDate[v] === void 0) {
      android.releaseDate[v] = chrome.releaseDate[v];
    }
  });
  return android;
}
function checkName(name, context) {
  var data = byName(name, context);
  if (!data)
    throw new error("Unknown browser " + name);
  return data;
}
function unknownQuery(query) {
  return new error("Unknown browser query `" + query + "`. Maybe you are using old Browserslist or made typo in query.");
}
function filterJumps(list, name, nVersions, context) {
  var jump = 1;
  switch (name) {
    case "android":
      if (context.mobileToDesktop)
        return list;
      var released = browserslist.data.chrome.released;
      jump = released.length - released.indexOf(ANDROID_EVERGREEN_FIRST);
      break;
    case "op_mob":
      var latest = browserslist.data.op_mob.released.slice(-1)[0];
      jump = getMajor(latest) - OP_MOB_BLINK_FIRST + 1;
      break;
    default:
      return list;
  }
  if (nVersions <= jump) {
    return list.slice(-1);
  }
  return list.slice(jump - 1 - nVersions);
}
function isSupported(flags, withPartial) {
  return typeof flags === "string" && (flags.indexOf("y") >= 0 || withPartial && flags.indexOf("a") >= 0);
}
function resolve(queries, context) {
  return parseQueries(queries).reduce(function(result, node, index) {
    if (node.not && index === 0) {
      throw new error("Write any browsers query (for instance, `defaults`) before `" + node.query + "`");
    }
    var type = QUERIES[node.type];
    var array = type.select.call(browserslist, context, node).map(function(j) {
      var parts = j.split(" ");
      if (parts[1] === "0") {
        return parts[0] + " " + byName(parts[0], context).versions[0];
      } else {
        return j;
      }
    });
    if (node.compose === "and") {
      if (node.not) {
        return result.filter(function(j) {
          return array.indexOf(j) === -1;
        });
      } else {
        return result.filter(function(j) {
          return array.indexOf(j) !== -1;
        });
      }
    } else {
      if (node.not) {
        var filter = {};
        array.forEach(function(j) {
          filter[j] = true;
        });
        return result.filter(function(j) {
          return !filter[j];
        });
      }
      return result.concat(array);
    }
  }, []);
}
function prepareOpts(opts) {
  if (typeof opts === "undefined")
    opts = {};
  if (typeof opts.path === "undefined") {
    opts.path = path.resolve ? path.resolve(".") : ".";
  }
  return opts;
}
function prepareQueries(queries, opts) {
  if (typeof queries === "undefined" || queries === null) {
    var config = browserslist.loadConfig(opts);
    if (config) {
      queries = config;
    } else {
      queries = browserslist.defaults;
    }
  }
  return queries;
}
function checkQueries(queries) {
  if (!(typeof queries === "string" || Array.isArray(queries))) {
    throw new error("Browser queries must be an array or string. Got " + typeof queries + ".");
  }
}
var cache = {};
var parseCache = {};
function browserslist(queries, opts) {
  opts = prepareOpts(opts);
  queries = prepareQueries(queries, opts);
  checkQueries(queries);
  var needsPath = parseQueries(queries).some(function(node) {
    return QUERIES[node.type].needsPath;
  });
  var context = {
    ignoreUnknownVersions: opts.ignoreUnknownVersions,
    dangerousExtend: opts.dangerousExtend,
    throwOnMissing: opts.throwOnMissing,
    mobileToDesktop: opts.mobileToDesktop,
    env: opts.env
  };
  if (needsPath) {
    context.path = opts.path;
  }
  browser.oldDataWarning(browserslist.data);
  var stats = browser.getStat(opts, browserslist.data);
  if (stats) {
    context.customUsage = {};
    for (var browser$1 in stats) {
      fillUsage(context.customUsage, browser$1, stats[browser$1]);
    }
  }
  var cacheKey = JSON.stringify([queries, context]);
  if (cache[cacheKey])
    return cache[cacheKey];
  var result = uniq(resolve(queries, context)).sort(function(name1, name2) {
    name1 = name1.split(" ");
    name2 = name2.split(" ");
    if (name1[0] === name2[0]) {
      var version1 = name1[1].split("-")[0];
      var version2 = name2[1].split("-")[0];
      return compareSemver(version2.split("."), version1.split("."));
    } else {
      return compare(name1[0], name2[0]);
    }
  });
  if (!browser.env.BROWSERSLIST_DISABLE_CACHE) {
    cache[cacheKey] = result;
  }
  return result;
}
function parseQueries(queries) {
  var cacheKey = JSON.stringify(queries);
  if (cacheKey in parseCache)
    return parseCache[cacheKey];
  var result = parse(QUERIES, queries);
  if (!browser.env.BROWSERSLIST_DISABLE_CACHE) {
    parseCache[cacheKey] = result;
  }
  return result;
}
function loadCustomUsage(context, config) {
  var stats = browser.loadStat(context, config, browserslist.data);
  if (stats) {
    context.customUsage = {};
    for (var browser$1 in stats) {
      fillUsage(context.customUsage, browser$1, stats[browser$1]);
    }
  }
  if (!context.customUsage) {
    throw new error("Custom usage statistics was not provided");
  }
  return context.customUsage;
}
browserslist.parse = function(queries, opts) {
  opts = prepareOpts(opts);
  queries = prepareQueries(queries, opts);
  checkQueries(queries);
  return parseQueries(queries);
};
browserslist.cache = {};
browserslist.data = {};
browserslist.usage = {
  global: {},
  custom: null
};
browserslist.defaults = ["> 0.5%", "last 2 versions", "Firefox ESR", "not dead"];
browserslist.aliases = {
  fx: "firefox",
  ff: "firefox",
  ios: "ios_saf",
  explorer: "ie",
  blackberry: "bb",
  explorermobile: "ie_mob",
  operamini: "op_mini",
  operamobile: "op_mob",
  chromeandroid: "and_chr",
  firefoxandroid: "and_ff",
  ucandroid: "and_uc",
  qqandroid: "and_qq"
};
browserslist.desktopNames = {
  and_chr: "chrome",
  and_ff: "firefox",
  ie_mob: "ie",
  android: "chrome"
};
browserslist.versionAliases = {};
browserslist.clearCaches = browser.clearCaches;
browserslist.parseConfig = browser.parseConfig;
browserslist.readConfig = browser.readConfig;
browserslist.findConfigFile = browser.findConfigFile;
browserslist.findConfig = browser.findConfig;
browserslist.loadConfig = browser.loadConfig;
browserslist.coverage = function(browsers, stats) {
  var data;
  if (typeof stats === "undefined") {
    data = browserslist.usage.global;
  } else if (stats === "my stats") {
    var opts = {};
    opts.path = path.resolve ? path.resolve(".") : ".";
    var customStats = browser.getStat(opts);
    if (!customStats) {
      throw new error("Custom usage statistics was not provided");
    }
    data = {};
    for (var browser$1 in customStats) {
      fillUsage(data, browser$1, customStats[browser$1]);
    }
  } else if (typeof stats === "string") {
    if (stats.length > 2) {
      stats = stats.toLowerCase();
    } else {
      stats = stats.toUpperCase();
    }
    browser.loadCountry(browserslist.usage, stats, browserslist.data);
    data = browserslist.usage[stats];
  } else {
    if ("dataByBrowser" in stats) {
      stats = stats.dataByBrowser;
    }
    data = {};
    for (var name in stats) {
      for (var version in stats[name]) {
        data[name + " " + version] = stats[name][version];
      }
    }
  }
  return browsers.reduce(function(all, i) {
    var usage = data[i];
    if (usage === void 0) {
      usage = data[i.replace(/ \S+$/, " 0")];
    }
    return all + (usage || 0);
  }, 0);
};
function nodeQuery(context, node) {
  var matched = browserslist.nodeVersions.filter(function(i) {
    return isVersionsMatch(i, node.version);
  });
  if (matched.length === 0) {
    if (context.ignoreUnknownVersions) {
      return [];
    } else {
      throw new error("Unknown version " + node.version + " of Node.js");
    }
  }
  return ["node " + matched[matched.length - 1]];
}
function sinceQuery(context, node) {
  var year = parseInt(node.year);
  var month = parseInt(node.month || "01") - 1;
  var day = parseInt(node.day || "01");
  return filterByYear(Date.UTC(year, month, day, 0, 0, 0), context);
}
function bbmTransform(bbmVersions) {
  var browsers = {
    chrome: "chrome",
    chrome_android: "and_chr",
    edge: "edge",
    firefox: "firefox",
    firefox_android: "and_ff",
    safari: "safari",
    safari_ios: "ios_saf",
    webview_android: "android",
    samsunginternet_android: "samsung",
    opera_android: "op_mob",
    opera: "opera",
    qq_android: "and_qq",
    uc_android: "and_uc",
    kai_os: "kaios"
  };
  return bbmVersions.filter(function(version) {
    return Object.keys(browsers).indexOf(version.browser) !== -1;
  }).map(function(version) {
    return browsers[version.browser] + " >= " + version.version;
  });
}
function coverQuery(context, node) {
  var coverage = parseFloat(node.coverage);
  var usage = browserslist.usage.global;
  if (node.place) {
    if (node.place.match(/^my\s+stats$/i)) {
      if (!context.customUsage) {
        throw new error("Custom usage statistics was not provided");
      }
      usage = context.customUsage;
    } else {
      var place;
      if (node.place.length === 2) {
        place = node.place.toUpperCase();
      } else {
        place = node.place.toLowerCase();
      }
      browser.loadCountry(browserslist.usage, place, browserslist.data);
      usage = browserslist.usage[place];
    }
  } else if (node.config) {
    usage = loadCustomUsage(context, node.config);
  }
  var versions = Object.keys(usage).sort(function(a, b) {
    return usage[b] - usage[a];
  });
  var covered = 0;
  var result = [];
  var version;
  for (var i = 0; i < versions.length; i++) {
    version = versions[i];
    if (usage[version] === 0)
      break;
    covered += usage[version];
    result.push(version);
    if (covered >= coverage)
      break;
  }
  return result;
}
var QUERIES = {
  last_major_versions: {
    matches: ["versions"],
    regexp: /^last\s+(\d+)\s+major\s+versions?$/i,
    select: function(context, node) {
      return Object.keys(agents).reduce(function(selected, name) {
        var data = byName(name, context);
        if (!data)
          return selected;
        var list = getMajorVersions(data.released, node.versions);
        list = list.map(nameMapper(data.name));
        list = filterJumps(list, data.name, node.versions, context);
        return selected.concat(list);
      }, []);
    }
  },
  last_versions: {
    matches: ["versions"],
    regexp: /^last\s+(\d+)\s+versions?$/i,
    select: function(context, node) {
      return Object.keys(agents).reduce(function(selected, name) {
        var data = byName(name, context);
        if (!data)
          return selected;
        var list = data.released.slice(-node.versions);
        list = list.map(nameMapper(data.name));
        list = filterJumps(list, data.name, node.versions, context);
        return selected.concat(list);
      }, []);
    }
  },
  last_electron_major_versions: {
    matches: ["versions"],
    regexp: /^last\s+(\d+)\s+electron\s+major\s+versions?$/i,
    select: function(context, node) {
      var validVersions = getMajorVersions(Object.keys(e2c), node.versions);
      return validVersions.map(function(i) {
        return "chrome " + e2c[i];
      });
    }
  },
  last_node_major_versions: {
    matches: ["versions"],
    regexp: /^last\s+(\d+)\s+node\s+major\s+versions?$/i,
    select: function(context, node) {
      return getMajorVersions(browserslist.nodeVersions, node.versions).map(function(version) {
        return "node " + version;
      });
    }
  },
  last_browser_major_versions: {
    matches: ["versions", "browser"],
    regexp: /^last\s+(\d+)\s+(\w+)\s+major\s+versions?$/i,
    select: function(context, node) {
      var data = checkName(node.browser, context);
      var validVersions = getMajorVersions(data.released, node.versions);
      var list = validVersions.map(nameMapper(data.name));
      list = filterJumps(list, data.name, node.versions, context);
      return list;
    }
  },
  last_electron_versions: {
    matches: ["versions"],
    regexp: /^last\s+(\d+)\s+electron\s+versions?$/i,
    select: function(context, node) {
      return Object.keys(e2c).slice(-node.versions).map(function(i) {
        return "chrome " + e2c[i];
      });
    }
  },
  last_node_versions: {
    matches: ["versions"],
    regexp: /^last\s+(\d+)\s+node\s+versions?$/i,
    select: function(context, node) {
      return browserslist.nodeVersions.slice(-node.versions).map(function(version) {
        return "node " + version;
      });
    }
  },
  last_browser_versions: {
    matches: ["versions", "browser"],
    regexp: /^last\s+(\d+)\s+(\w+)\s+versions?$/i,
    select: function(context, node) {
      var data = checkName(node.browser, context);
      var list = data.released.slice(-node.versions).map(nameMapper(data.name));
      list = filterJumps(list, data.name, node.versions, context);
      return list;
    }
  },
  unreleased_versions: {
    matches: [],
    regexp: /^unreleased\s+versions$/i,
    select: function(context) {
      return Object.keys(agents).reduce(function(selected, name) {
        var data = byName(name, context);
        if (!data)
          return selected;
        var list = data.versions.filter(function(v) {
          return data.released.indexOf(v) === -1;
        });
        list = list.map(nameMapper(data.name));
        return selected.concat(list);
      }, []);
    }
  },
  unreleased_electron_versions: {
    matches: [],
    regexp: /^unreleased\s+electron\s+versions?$/i,
    select: function() {
      return [];
    }
  },
  unreleased_browser_versions: {
    matches: ["browser"],
    regexp: /^unreleased\s+(\w+)\s+versions?$/i,
    select: function(context, node) {
      var data = checkName(node.browser, context);
      return data.versions.filter(function(v) {
        return data.released.indexOf(v) === -1;
      }).map(nameMapper(data.name));
    }
  },
  last_years: {
    matches: ["years"],
    regexp: /^last\s+((\d+\.)?\d+)\s+years?$/i,
    select: function(context, node) {
      return filterByYear(Date.now() - YEAR * node.years, context);
    }
  },
  since_y: {
    matches: ["year"],
    regexp: /^since (\d+)$/i,
    select: sinceQuery
  },
  since_y_m: {
    matches: ["year", "month"],
    regexp: /^since (\d+)-(\d+)$/i,
    select: sinceQuery
  },
  since_y_m_d: {
    matches: ["year", "month", "day"],
    regexp: /^since (\d+)-(\d+)-(\d+)$/i,
    select: sinceQuery
  },
  baseline: {
    matches: ["year", "availability", "date", "downstream", "kaios"],
    regexp: /^baseline\s+(?:(\d+)|(newly|widely)\s+available(?:\s+on\s+(\d{4}-\d{2}-\d{2}))?)?(\s+with\s+downstream)?(\s+including\s+kaios)?$/i,
    select: function(context, node) {
      var baselineVersions;
      var includeDownstream = !!node.downstream;
      var includeKaiOS = !!node.kaios;
      if (node.availability === "newly" && node.date) {
        throw new error('Using newly available with a date is not supported, please use "widely available on YYYY-MM-DD" and add 30 months to the date you specified.');
      }
      if (node.year) {
        baselineVersions = bbm.getCompatibleVersions({
          targetYear: node.year,
          includeDownstreamBrowsers: includeDownstream,
          includeKaiOS,
          suppressWarnings: true
        });
      } else if (node.date) {
        baselineVersions = bbm.getCompatibleVersions({
          widelyAvailableOnDate: node.date,
          includeDownstreamBrowsers: includeDownstream,
          includeKaiOS,
          suppressWarnings: true
        });
      } else if (node.availability === "newly") {
        var future30months = new Date().setMonth(new Date().getMonth() + 30);
        baselineVersions = bbm.getCompatibleVersions({
          widelyAvailableOnDate: future30months,
          includeDownstreamBrowsers: includeDownstream,
          includeKaiOS,
          suppressWarnings: true
        });
      } else {
        baselineVersions = bbm.getCompatibleVersions({
          includeDownstreamBrowsers: includeDownstream,
          includeKaiOS,
          suppressWarnings: true
        });
      }
      return resolve(bbmTransform(baselineVersions), context);
    }
  },
  popularity: {
    matches: ["sign", "popularity"],
    regexp: /^(>=?|<=?)\s*(\d+|\d+\.\d+|\.\d+)%$/,
    select: function(context, node) {
      var popularity = parseFloat(node.popularity);
      var usage = browserslist.usage.global;
      return Object.keys(usage).reduce(function(result, version) {
        if (node.sign === ">") {
          if (usage[version] > popularity) {
            result.push(version);
          }
        } else if (node.sign === "<") {
          if (usage[version] < popularity) {
            result.push(version);
          }
        } else if (node.sign === "<=") {
          if (usage[version] <= popularity) {
            result.push(version);
          }
        } else if (usage[version] >= popularity) {
          result.push(version);
        }
        return result;
      }, []);
    }
  },
  popularity_in_my_stats: {
    matches: ["sign", "popularity"],
    regexp: /^(>=?|<=?)\s*(\d+|\d+\.\d+|\.\d+)%\s+in\s+my\s+stats$/,
    select: function(context, node) {
      var popularity = parseFloat(node.popularity);
      if (!context.customUsage) {
        throw new error("Custom usage statistics was not provided");
      }
      var usage = context.customUsage;
      return Object.keys(usage).reduce(function(result, version) {
        var percentage = usage[version];
        if (percentage == null) {
          return result;
        }
        if (node.sign === ">") {
          if (percentage > popularity) {
            result.push(version);
          }
        } else if (node.sign === "<") {
          if (percentage < popularity) {
            result.push(version);
          }
        } else if (node.sign === "<=") {
          if (percentage <= popularity) {
            result.push(version);
          }
        } else if (percentage >= popularity) {
          result.push(version);
        }
        return result;
      }, []);
    }
  },
  popularity_in_config_stats: {
    matches: ["sign", "popularity", "config"],
    regexp: /^(>=?|<=?)\s*(\d+|\d+\.\d+|\.\d+)%\s+in\s+(\S+)\s+stats$/,
    select: function(context, node) {
      var popularity = parseFloat(node.popularity);
      var usage = loadCustomUsage(context, node.config);
      return Object.keys(usage).reduce(function(result, version) {
        var percentage = usage[version];
        if (percentage == null) {
          return result;
        }
        if (node.sign === ">") {
          if (percentage > popularity) {
            result.push(version);
          }
        } else if (node.sign === "<") {
          if (percentage < popularity) {
            result.push(version);
          }
        } else if (node.sign === "<=") {
          if (percentage <= popularity) {
            result.push(version);
          }
        } else if (percentage >= popularity) {
          result.push(version);
        }
        return result;
      }, []);
    }
  },
  popularity_in_place: {
    matches: ["sign", "popularity", "place"],
    regexp: /^(>=?|<=?)\s*(\d+|\d+\.\d+|\.\d+)%\s+in\s+((alt-)?\w\w)$/,
    select: function(context, node) {
      var popularity = parseFloat(node.popularity);
      var place = node.place;
      if (place.length === 2) {
        place = place.toUpperCase();
      } else {
        place = place.toLowerCase();
      }
      browser.loadCountry(browserslist.usage, place, browserslist.data);
      var usage = browserslist.usage[place];
      return Object.keys(usage).reduce(function(result, version) {
        var percentage = usage[version];
        if (percentage == null) {
          return result;
        }
        if (node.sign === ">") {
          if (percentage > popularity) {
            result.push(version);
          }
        } else if (node.sign === "<") {
          if (percentage < popularity) {
            result.push(version);
          }
        } else if (node.sign === "<=") {
          if (percentage <= popularity) {
            result.push(version);
          }
        } else if (percentage >= popularity) {
          result.push(version);
        }
        return result;
      }, []);
    }
  },
  cover: {
    matches: ["coverage"],
    regexp: /^cover\s+(\d+|\d+\.\d+|\.\d+)%$/i,
    select: coverQuery
  },
  cover_in: {
    matches: ["coverage", "place"],
    regexp: /^cover\s+(\d+|\d+\.\d+|\.\d+)%\s+in\s+(my\s+stats|(alt-)?\w\w)$/i,
    select: coverQuery
  },
  cover_config: {
    matches: ["coverage", "config"],
    regexp: /^cover\s+(\d+|\d+\.\d+|\.\d+)%\s+in\s+(\S+)\s+stats$/i,
    select: coverQuery
  },
  supports: {
    matches: ["supportType", "feature"],
    regexp: /^(?:(fully|partially)\s+)?supports\s+([\w-]+)$/,
    select: function(context, node) {
      browser.loadFeature(browserslist.cache, node.feature);
      var withPartial = node.supportType !== "fully";
      var features = browserslist.cache[node.feature];
      var result = [];
      for (var name in features) {
        var data = byName(name, context);
        var iMax = data.released.length - 1;
        while (iMax >= 0) {
          if (data.released[iMax] in features[name])
            break;
          iMax--;
        }
        var checkDesktop = context.mobileToDesktop && name in browserslist.desktopNames && isSupported(features[name][data.released[iMax]], withPartial);
        data.versions.forEach(function(version) {
          var flags = features[name][version];
          if (flags === void 0 && checkDesktop) {
            flags = features[browserslist.desktopNames[name]][version];
          }
          if (isSupported(flags, withPartial)) {
            result.push(name + " " + version);
          }
        });
      }
      return result;
    }
  },
  electron_range: {
    matches: ["from", "to"],
    regexp: /^electron\s+([\d.]+)\s*-\s*([\d.]+)$/i,
    select: function(context, node) {
      var fromToUse = normalizeElectron(node.from);
      var toToUse = normalizeElectron(node.to);
      var from = parseFloat(node.from);
      var to = parseFloat(node.to);
      if (!e2c[fromToUse]) {
        throw new error("Unknown version " + from + " of electron");
      }
      if (!e2c[toToUse]) {
        throw new error("Unknown version " + to + " of electron");
      }
      return Object.keys(e2c).filter(function(i) {
        var parsed = parseFloat(i);
        return parsed >= from && parsed <= to;
      }).map(function(i) {
        return "chrome " + e2c[i];
      });
    }
  },
  node_range: {
    matches: ["from", "to"],
    regexp: /^node\s+([\d.]+)\s*-\s*([\d.]+)$/i,
    select: function(context, node) {
      return browserslist.nodeVersions.filter(semverFilterLoose(">=", node.from)).filter(semverFilterLoose("<=", node.to)).map(function(v) {
        return "node " + v;
      });
    }
  },
  browser_range: {
    matches: ["browser", "from", "to"],
    regexp: /^(\w+)\s+([\d.]+)\s*-\s*([\d.]+)$/i,
    select: function(context, node) {
      var data = checkName(node.browser, context);
      var from = parseFloat(normalizeVersion(data, node.from) || node.from);
      var to = parseFloat(normalizeVersion(data, node.to) || node.to);
      function filter(v) {
        var parsed = parseFloat(v);
        return parsed >= from && parsed <= to;
      }
      return data.released.filter(filter).map(nameMapper(data.name));
    }
  },
  electron_ray: {
    matches: ["sign", "version"],
    regexp: /^electron\s*(>=?|<=?)\s*([\d.]+)$/i,
    select: function(context, node) {
      var versionToUse = normalizeElectron(node.version);
      return Object.keys(e2c).filter(generateFilter(node.sign, versionToUse)).map(function(i) {
        return "chrome " + e2c[i];
      });
    }
  },
  node_ray: {
    matches: ["sign", "version"],
    regexp: /^node\s*(>=?|<=?)\s*([\d.]+)$/i,
    select: function(context, node) {
      return browserslist.nodeVersions.filter(generateSemverFilter(node.sign, node.version)).map(function(v) {
        return "node " + v;
      });
    }
  },
  browser_ray: {
    matches: ["browser", "sign", "version"],
    regexp: /^(\w+)\s*(>=?|<=?)\s*([\d.]+|esr)$/i,
    select: function(context, node) {
      var version = node.version;
      var data = checkName(node.browser, context);
      var alias = browserslist.versionAliases[data.name][version.toLowerCase()];
      if (alias)
        version = alias;
      if (!/[\d.]+/.test(version)) {
        throw new error("Unknown version " + version + " of " + node.browser);
      }
      return data.released.filter(generateFilter(node.sign, version)).map(function(v) {
        return data.name + " " + v;
      });
    }
  },
  firefox_esr: {
    matches: [],
    regexp: /^(firefox|ff|fx)\s+esr$/i,
    select: function() {
      return ["firefox " + FIREFOX_ESR_VERSION];
    }
  },
  opera_mini_all: {
    matches: [],
    regexp: /(operamini|op_mini)\s+all/i,
    select: function() {
      return ["op_mini all"];
    }
  },
  electron_version: {
    matches: ["version"],
    regexp: /^electron\s+([\d.]+)$/i,
    select: function(context, node) {
      var versionToUse = normalizeElectron(node.version);
      var chrome = e2c[versionToUse];
      if (!chrome) {
        throw new error("Unknown version " + node.version + " of electron");
      }
      return ["chrome " + chrome];
    }
  },
  node_major_version: {
    matches: ["version"],
    regexp: /^node\s+(\d+)$/i,
    select: nodeQuery
  },
  node_minor_version: {
    matches: ["version"],
    regexp: /^node\s+(\d+\.\d+)$/i,
    select: nodeQuery
  },
  node_patch_version: {
    matches: ["version"],
    regexp: /^node\s+(\d+\.\d+\.\d+)$/i,
    select: nodeQuery
  },
  current_node: {
    matches: [],
    regexp: /^current\s+node$/i,
    select: function(context) {
      return [browser.currentNode(resolve, context)];
    }
  },
  maintained_node: {
    matches: [],
    regexp: /^maintained\s+node\s+versions$/i,
    select: function(context) {
      var now = Date.now();
      var queries = Object.keys(jsEOL).filter(function(key) {
        return now < Date.parse(jsEOL[key].end) && now > Date.parse(jsEOL[key].start) && isEolReleased(key);
      }).map(function(key) {
        return "node " + key.slice(1);
      });
      return resolve(queries, context);
    }
  },
  phantomjs_1_9: {
    matches: [],
    regexp: /^phantomjs\s+1.9$/i,
    select: function() {
      return ["safari 5"];
    }
  },
  phantomjs_2_1: {
    matches: [],
    regexp: /^phantomjs\s+2.1$/i,
    select: function() {
      return ["safari 6"];
    }
  },
  browser_version: {
    matches: ["browser", "version"],
    regexp: /^(\w+)\s+(tp|[\d.]+)$/i,
    select: function(context, node) {
      var version = node.version;
      if (/^tp$/i.test(version))
        version = "TP";
      var data = checkName(node.browser, context);
      var alias = normalizeVersion(data, version);
      if (alias) {
        version = alias;
      } else {
        if (version.indexOf(".") === -1) {
          alias = version + ".0";
        } else {
          alias = version.replace(/\.0$/, "");
        }
        alias = normalizeVersion(data, alias);
        if (alias) {
          version = alias;
        } else if (context.ignoreUnknownVersions) {
          return [];
        } else {
          throw new error("Unknown version " + version + " of " + node.browser);
        }
      }
      return [data.name + " " + version];
    }
  },
  browserslist_config: {
    matches: [],
    regexp: /^browserslist config$/i,
    needsPath: true,
    select: function(context) {
      return browserslist(void 0, context);
    }
  },
  extends: {
    matches: ["config"],
    regexp: /^extends (.+)$/i,
    needsPath: true,
    select: function(context, node) {
      return resolve(browser.loadQueries(context, node.config), context);
    }
  },
  defaults: {
    matches: [],
    regexp: /^defaults$/i,
    select: function(context) {
      return resolve(browserslist.defaults, context);
    }
  },
  dead: {
    matches: [],
    regexp: /^dead$/i,
    select: function(context) {
      var dead = [
        "Baidu >= 0",
        "ie <= 11",
        "ie_mob <= 11",
        "bb <= 10",
        "op_mob <= 12.1",
        "samsung 4"
      ];
      return resolve(dead, context);
    }
  },
  unknown: {
    matches: [],
    regexp: /^(\w+)$/i,
    select: function(context, node) {
      if (byName(node.query, context)) {
        throw new error("Specify versions in Browserslist query for browser " + node.query);
      } else {
        throw unknownQuery(node.query);
      }
    }
  }
};
(function() {
  for (var name in agents) {
    var browser2 = agents[name];
    browserslist.data[name] = {
      name,
      versions: normalize(agents[name].versions),
      released: normalize(agents[name].versions.slice(0, -3)),
      releaseDate: agents[name].release_date
    };
    fillUsage(browserslist.usage.global, name, browser2.usage_global);
    browserslist.versionAliases[name] = {};
    for (var i = 0; i < browser2.versions.length; i++) {
      var full = browser2.versions[i];
      if (!full)
        continue;
      if (full.indexOf("-") !== -1) {
        var interval = full.split("-");
        for (var j = 0; j < interval.length; j++) {
          browserslist.versionAliases[name][interval[j]] = full;
        }
      }
    }
  }
  browserslist.nodeVersions = jsReleases.map(function(release) {
    return release.version;
  });
})();
browserslist.versionAliases.firefox.esr = FIREFOX_ESR_VERSION;
var browserslist_1 = browserslist;
export default browserslist_1;