Server : Apache/2.4.41 (Ubuntu) System : Linux absol.cf 5.4.0-198-generic #218-Ubuntu SMP Fri Sep 27 20:18:53 UTC 2024 x86_64 User : www-data ( 33) PHP Version : 7.4.33 Disable Function : pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,pcntl_unshare, Directory :  /var/www/html/libs/absol-full/dist/js/

Upload File : current_dir [ Writeable ] document_root [ Writeable ]

/*** module: node_modules/browserslist/index.js ***/
"use strict";

var jsReleases = require('node-releases/data/processed/envs.json');

var agents = require('caniuse-lite/dist/unpacker/agents').agents;

var jsEOL = require('node-releases/data/release-schedule/release-schedule.json');

var path = require('path');

var e2c = require('electron-to-chromium/versions');

var BrowserslistError = require('./error');

var env = require('./node'); // Will load browser.js in webpack


var YEAR = 365.259641 * 24 * 60 * 60 * 1000;
var ANDROID_EVERGREEN_FIRST = 37;
var QUERY_OR = 1;
var QUERY_AND = 2;

function isVersionsMatch(versionA, versionB) {
  return (versionA + '.').indexOf(versionB + '.') === 0;
}

function isEolReleased(name) {
  var version = name.slice(1);
  return jsReleases.some(function (i) {
    return isVersionsMatch(i.version, 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;
} // Helpers


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 parseFloat(v) > version;
    };
  } else if (sign === '>=') {
    return function (v) {
      return parseFloat(v) >= version;
    };
  } else if (sign === '<') {
    return function (v) {
      return parseFloat(v) < version;
    };
  } else {
    return function (v) {
      return parseFloat(v) <= version;
    };
  }
}

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'));
} // this follows the npm-like semver behavior


function semverFilterLoose(operator, range) {
  range = range.split('.').map(parseSimpleInt);

  if (typeof range[1] === 'undefined') {
    range[1] = 'x';
  } // ignore any patch version because we only return minor versions
  // range[2] = 'x'


  switch (operator) {
    case '<=':
      return function (version) {
        version = version.split('.').map(parseSimpleInt);
        return compareSemverLoose(version, range) <= 0;
      };

    default:
    case '>=':
      return function (version) {
        version = version.split('.').map(parseSimpleInt);
        return compareSemverLoose(version, range) >= 0;
      };
  }
} // this follows the npm-like semver behavior


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 / 1000;
  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) {
      return data.releaseDate[v] >= 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 mapVersions(data, map) {
  data.versions = data.versions.map(function (i) {
    return map[i] || i;
  });
  data.released = data.versions.map(function (i) {
    return map[i] || i;
  });
  var fixedDate = {};

  for (var i in data.releaseDate) {
    fixedDate[map[i] || i] = data.releaseDate[i];
  }

  data.releaseDate = fixedDate;
  return data;
}

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;

      if (name === 'op_mob') {
        cloned = mapVersions(cloned, {
          '10.0-10.1': '10'
        });
      }

      return cloned;
    }
  }

  return browserslist.data[name];
}

function normalizeAndroidVersions(androidVersions, chromeVersions) {
  var firstEvergreen = ANDROID_EVERGREEN_FIRST;
  var last = chromeVersions[chromeVersions.length - 1];
  return androidVersions.filter(function (version) {
    return /^(?:[2-4]\.|[34]$)/.test(version);
  }).concat(chromeVersions.slice(firstEvergreen - last - 1));
}

function normalizeAndroidData(android, chrome) {
  android.released = normalizeAndroidVersions(android.released, chrome.released);
  android.versions = normalizeAndroidVersions(android.versions, chrome.versions);
  return android;
}

function checkName(name, context) {
  var data = byName(name, context);
  if (!data) throw new BrowserslistError('Unknown browser ' + name);
  return data;
}

function unknownQuery(query) {
  return new BrowserslistError('Unknown browser query `' + query + '`. ' + 'Maybe you are using old Browserslist or made typo in query.');
}

function filterAndroid(list, versions, context) {
  if (context.mobileToDesktop) return list;
  var released = browserslist.data.android.released;
  var last = released[released.length - 1];
  var diff = last - ANDROID_EVERGREEN_FIRST - versions;

  if (diff > 0) {
    return list.slice(-1);
  } else {
    return list.slice(diff - 1);
  }
}
/**
 * Resolves queries into a browser list.
 * @param {string|string[]} queries Queries to combine.
 * Either an array of queries or a long string of queries.
 * @param {object} [context] Optional arguments to
 * the select function in `queries`.
 * @returns {string[]} A list of browsers
 */


function resolve(queries, context) {
  if (Array.isArray(queries)) {
    queries = flatten(queries.map(parse));
  } else {
    queries = parse(queries);
  }

  return queries.reduce(function (result, query, index) {
    var selection = query.queryString;
    var isExclude = selection.indexOf('not ') === 0;

    if (isExclude) {
      if (index === 0) {
        throw new BrowserslistError('Write any browsers query (for instance, `defaults`) ' + 'before `' + selection + '`');
      }

      selection = selection.slice(4);
    }

    for (var i = 0; i < QUERIES.length; i++) {
      var type = QUERIES[i];
      var match = selection.match(type.regexp);

      if (match) {
        var args = [context].concat(match.slice(1));
        var array = type.select.apply(browserslist, args).map(function (j) {
          var parts = j.split(' ');

          if (parts[1] === '0') {
            return parts[0] + ' ' + byName(parts[0], context).versions[0];
          } else {
            return j;
          }
        });

        switch (query.type) {
          case QUERY_AND:
            if (isExclude) {
              return result.filter(function (j) {
                return array.indexOf(j) === -1;
              });
            } else {
              return result.filter(function (j) {
                return array.indexOf(j) !== -1;
              });
            }

          case QUERY_OR:
          default:
            if (isExclude) {
              var filter = {};
              array.forEach(function (j) {
                filter[j] = true;
              });
              return result.filter(function (j) {
                return !filter[j];
              });
            }

            return result.concat(array);
        }
      }
    }

    throw unknownQuery(selection);
  }, []);
}

var cache = {};
/**
 * Return array of browsers by selection queries.
 *
 * @param {(string|string[])} [queries=browserslist.defaults] Browser queries.
 * @param {object} [opts] Options.
 * @param {string} [opts.path="."] Path to processed file.
 *                                 It will be used to find config files.
 * @param {string} [opts.env="production"] Processing environment.
 *                                         It will be used to take right
 *                                         queries from config file.
 * @param {string} [opts.config] Path to config file with queries.
 * @param {object} [opts.stats] Custom browser usage statistics
 *                              for "> 1% in my stats" query.
 * @param {boolean} [opts.ignoreUnknownVersions=false] Do not throw on unknown
 *                                                     version in direct query.
 * @param {boolean} [opts.dangerousExtend] Disable security checks
 *                                         for extend query.
 * @param {boolean} [opts.mobileToDesktop] Alias mobile browsers to the desktop
 *                                         version when Can I Use doesn't have
 *                                         data about the specified version.
 * @returns {string[]} Array with browser names in Can I Use.
 *
 * @example
 * browserslist('IE >= 10, IE 8') //=> ['ie 11', 'ie 10', 'ie 8']
 */

function browserslist(queries, opts) {
  if (typeof opts === 'undefined') opts = {};

  if (typeof opts.path === 'undefined') {
    opts.path = path.resolve ? path.resolve('.') : '.';
  }

  if (typeof queries === 'undefined' || queries === null) {
    var config = browserslist.loadConfig(opts);

    if (config) {
      queries = config;
    } else {
      queries = browserslist.defaults;
    }
  }

  if (!(typeof queries === 'string' || Array.isArray(queries))) {
    throw new BrowserslistError('Browser queries must be an array or string. Got ' + typeof queries + '.');
  }

  var context = {
    ignoreUnknownVersions: opts.ignoreUnknownVersions,
    dangerousExtend: opts.dangerousExtend,
    mobileToDesktop: opts.mobileToDesktop,
    path: opts.path,
    env: opts.env
  };
  env.oldDataWarning(browserslist.data);
  var stats = env.getStat(opts, browserslist.data);

  if (stats) {
    context.customUsage = {};

    for (var browser in stats) {
      fillUsage(context.customUsage, browser, stats[browser]);
    }
  }

  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]) {
      // assumptions on caniuse data
      // 1) version ranges never overlaps
      // 2) if version is not a range, it never contains `-`
      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 (!process.env.BROWSERSLIST_DISABLE_CACHE) {
    cache[cacheKey] = result;
  }

  return result;
}

function parse(queries) {
  var qs = [];

  do {
    queries = doMatch(queries, qs);
  } while (queries);

  return qs;
}

function doMatch(string, qs) {
  var or = /^(?:,\s*|\s+or\s+)(.*)/i;
  var and = /^\s+and\s+(.*)/i;
  return find(string, function (parsed, n, max) {
    if (and.test(parsed)) {
      qs.unshift({
        type: QUERY_AND,
        queryString: parsed.match(and)[1]
      });
      return true;
    } else if (or.test(parsed)) {
      qs.unshift({
        type: QUERY_OR,
        queryString: parsed.match(or)[1]
      });
      return true;
    } else if (n === max) {
      qs.unshift({
        type: QUERY_OR,
        queryString: parsed.trim()
      });
      return true;
    }

    return false;
  });
}

function find(string, predicate) {
  for (var n = 1, max = string.length; n <= max; n++) {
    var parsed = string.substr(-n, n);

    if (predicate(parsed, n, max)) {
      return string.slice(0, -n);
    }
  }

  return '';
}

function flatten(array) {
  if (!Array.isArray(array)) return [array];
  return array.reduce(function (a, b) {
    return a.concat(flatten(b));
  }, []);
} // Will be filled by Can I Use data below


browserslist.cache = {};
browserslist.data = {};
browserslist.usage = {
  global: {},
  custom: null
}; // Default browsers query

browserslist.defaults = ['> 0.5%', 'last 2 versions', 'Firefox ESR', 'not dead']; // Browser names aliases

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'
}; // Can I Use only provides a few versions for some browsers (e.g. and_chr).
// Fallback to a similar browser for unknown versions

browserslist.desktopNames = {
  and_chr: 'chrome',
  and_ff: 'firefox',
  ie_mob: 'ie',
  op_mob: 'opera',
  android: 'chrome' // has extra processing logic

}; // Aliases to work with joined versions like `ios_saf 7.0-7.1`

browserslist.versionAliases = {};
browserslist.clearCaches = env.clearCaches;
browserslist.parseConfig = env.parseConfig;
browserslist.readConfig = env.readConfig;
browserslist.findConfig = env.findConfig;
browserslist.loadConfig = env.loadConfig;
/**
 * Return browsers market coverage.
 *
 * @param {string[]} browsers Browsers names in Can I Use.
 * @param {string|object} [stats="global"] Which statistics should be used.
 *                                         Country code or custom statistics.
 *                                         Pass `"my stats"` to load statistics
 *                                         from Browserslist files.
 *
 * @return {number} Total market coverage for all selected browsers.
 *
 * @example
 * browserslist.coverage(browserslist('> 1% in US'), 'US') //=> 83.1
 */

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 = env.getStat(opts);

    if (!customStats) {
      throw new BrowserslistError('Custom usage statistics was not provided');
    }

    data = {};

    for (var browser in customStats) {
      fillUsage(data, browser, customStats[browser]);
    }
  } else if (typeof stats === 'string') {
    if (stats.length > 2) {
      stats = stats.toLowerCase();
    } else {
      stats = stats.toUpperCase();
    }

    env.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 === undefined) {
      usage = data[i.replace(/ \S+$/, ' 0')];
    }

    return all + (usage || 0);
  }, 0);
};

function nodeQuery(context, version) {
  var nodeReleases = jsReleases.filter(function (i) {
    return i.name === 'nodejs';
  });
  var matched = nodeReleases.filter(function (i) {
    return isVersionsMatch(i.version, version);
  });

  if (matched.length === 0) {
    if (context.ignoreUnknownVersions) {
      return [];
    } else {
      throw new BrowserslistError('Unknown version ' + version + ' of Node.js');
    }
  }

  return ['node ' + matched[matched.length - 1].version];
}

function sinceQuery(context, year, month, date) {
  year = parseInt(year);
  month = parseInt(month || '01') - 1;
  date = parseInt(date || '01');
  return filterByYear(Date.UTC(year, month, date, 0, 0, 0), context);
}

function coverQuery(context, coverage, statMode) {
  coverage = parseFloat(coverage);
  var usage = browserslist.usage.global;

  if (statMode) {
    if (statMode.match(/^my\s+stats$/)) {
      if (!context.customUsage) {
        throw new BrowserslistError('Custom usage statistics was not provided');
      }

      usage = context.customUsage;
    } else {
      var place;

      if (statMode.length === 2) {
        place = statMode.toUpperCase();
      } else {
        place = statMode.toLowerCase();
      }

      env.loadCountry(browserslist.usage, place, browserslist.data);
      usage = browserslist.usage[place];
    }
  }

  var versions = Object.keys(usage).sort(function (a, b) {
    return usage[b] - usage[a];
  });
  var coveraged = 0;
  var result = [];
  var version;

  for (var i = 0; i <= versions.length; i++) {
    version = versions[i];
    if (usage[version] === 0) break;
    coveraged += usage[version];
    result.push(version);
    if (coveraged >= coverage) break;
  }

  return result;
}

var QUERIES = [{
  regexp: /^last\s+(\d+)\s+major\s+versions?$/i,
  select: function (context, versions) {
    return Object.keys(agents).reduce(function (selected, name) {
      var data = byName(name, context);
      if (!data) return selected;
      var list = getMajorVersions(data.released, versions);
      list = list.map(nameMapper(data.name));

      if (data.name === 'android') {
        list = filterAndroid(list, versions, context);
      }

      return selected.concat(list);
    }, []);
  }
}, {
  regexp: /^last\s+(\d+)\s+versions?$/i,
  select: function (context, versions) {
    return Object.keys(agents).reduce(function (selected, name) {
      var data = byName(name, context);
      if (!data) return selected;
      var list = data.released.slice(-versions);
      list = list.map(nameMapper(data.name));

      if (data.name === 'android') {
        list = filterAndroid(list, versions, context);
      }

      return selected.concat(list);
    }, []);
  }
}, {
  regexp: /^last\s+(\d+)\s+electron\s+major\s+versions?$/i,
  select: function (context, versions) {
    var validVersions = getMajorVersions(Object.keys(e2c), versions);
    return validVersions.map(function (i) {
      return 'chrome ' + e2c[i];
    });
  }
}, {
  regexp: /^last\s+(\d+)\s+(\w+)\s+major\s+versions?$/i,
  select: function (context, versions, name) {
    var data = checkName(name, context);
    var validVersions = getMajorVersions(data.released, versions);
    var list = validVersions.map(nameMapper(data.name));

    if (data.name === 'android') {
      list = filterAndroid(list, versions, context);
    }

    return list;
  }
}, {
  regexp: /^last\s+(\d+)\s+electron\s+versions?$/i,
  select: function (context, versions) {
    return Object.keys(e2c).slice(-versions).map(function (i) {
      return 'chrome ' + e2c[i];
    });
  }
}, {
  regexp: /^last\s+(\d+)\s+(\w+)\s+versions?$/i,
  select: function (context, versions, name) {
    var data = checkName(name, context);
    var list = data.released.slice(-versions).map(nameMapper(data.name));

    if (data.name === 'android') {
      list = filterAndroid(list, versions, context);
    }

    return list;
  }
}, {
  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);
    }, []);
  }
}, {
  regexp: /^unreleased\s+electron\s+versions?$/i,
  select: function () {
    return [];
  }
}, {
  regexp: /^unreleased\s+(\w+)\s+versions?$/i,
  select: function (context, name) {
    var data = checkName(name, context);
    return data.versions.filter(function (v) {
      return data.released.indexOf(v) === -1;
    }).map(nameMapper(data.name));
  }
}, {
  regexp: /^last\s+(\d*.?\d+)\s+years?$/i,
  select: function (context, years) {
    return filterByYear(Date.now() - YEAR * years, context);
  }
}, {
  regexp: /^since (\d+)$/i,
  select: sinceQuery
}, {
  regexp: /^since (\d+)-(\d+)$/i,
  select: sinceQuery
}, {
  regexp: /^since (\d+)-(\d+)-(\d+)$/i,
  select: sinceQuery
}, {
  regexp: /^(>=?|<=?)\s*(\d+|\d+\.\d+|\.\d+)%$/,
  select: function (context, sign, popularity) {
    popularity = parseFloat(popularity);
    var usage = browserslist.usage.global;
    return Object.keys(usage).reduce(function (result, version) {
      if (sign === '>') {
        if (usage[version] > popularity) {
          result.push(version);
        }
      } else if (sign === '<') {
        if (usage[version] < popularity) {
          result.push(version);
        }
      } else if (sign === '<=') {
        if (usage[version] <= popularity) {
          result.push(version);
        }
      } else if (usage[version] >= popularity) {
        result.push(version);
      }

      return result;
    }, []);
  }
}, {
  regexp: /^(>=?|<=?)\s*(\d+|\d+\.\d+|\.\d+)%\s+in\s+my\s+stats$/,
  select: function (context, sign, popularity) {
    popularity = parseFloat(popularity);

    if (!context.customUsage) {
      throw new BrowserslistError('Custom usage statistics was not provided');
    }

    var usage = context.customUsage;
    return Object.keys(usage).reduce(function (result, version) {
      if (sign === '>') {
        if (usage[version] > popularity) {
          result.push(version);
        }
      } else if (sign === '<') {
        if (usage[version] < popularity) {
          result.push(version);
        }
      } else if (sign === '<=') {
        if (usage[version] <= popularity) {
          result.push(version);
        }
      } else if (usage[version] >= popularity) {
        result.push(version);
      }

      return result;
    }, []);
  }
}, {
  regexp: /^(>=?|<=?)\s*(\d+|\d+\.\d+|\.\d+)%\s+in\s+(\S+)\s+stats$/,
  select: function (context, sign, popularity, name) {
    popularity = parseFloat(popularity);
    var stats = env.loadStat(context, name, browserslist.data);

    if (stats) {
      context.customUsage = {};

      for (var browser in stats) {
        fillUsage(context.customUsage, browser, stats[browser]);
      }
    }

    if (!context.customUsage) {
      throw new BrowserslistError('Custom usage statistics was not provided');
    }

    var usage = context.customUsage;
    return Object.keys(usage).reduce(function (result, version) {
      if (sign === '>') {
        if (usage[version] > popularity) {
          result.push(version);
        }
      } else if (sign === '<') {
        if (usage[version] < popularity) {
          result.push(version);
        }
      } else if (sign === '<=') {
        if (usage[version] <= popularity) {
          result.push(version);
        }
      } else if (usage[version] >= popularity) {
        result.push(version);
      }

      return result;
    }, []);
  }
}, {
  regexp: /^(>=?|<=?)\s*(\d+|\d+\.\d+|\.\d+)%\s+in\s+((alt-)?\w\w)$/,
  select: function (context, sign, popularity, place) {
    popularity = parseFloat(popularity);

    if (place.length === 2) {
      place = place.toUpperCase();
    } else {
      place = place.toLowerCase();
    }

    env.loadCountry(browserslist.usage, place, browserslist.data);
    var usage = browserslist.usage[place];
    return Object.keys(usage).reduce(function (result, version) {
      if (sign === '>') {
        if (usage[version] > popularity) {
          result.push(version);
        }
      } else if (sign === '<') {
        if (usage[version] < popularity) {
          result.push(version);
        }
      } else if (sign === '<=') {
        if (usage[version] <= popularity) {
          result.push(version);
        }
      } else if (usage[version] >= popularity) {
        result.push(version);
      }

      return result;
    }, []);
  }
}, {
  regexp: /^cover\s+(\d+|\d+\.\d+|\.\d+)%$/,
  select: coverQuery
}, {
  regexp: /^cover\s+(\d+|\d+\.\d+|\.\d+)%\s+in\s+(my\s+stats|(alt-)?\w\w)$/,
  select: coverQuery
}, {
  regexp: /^supports\s+([\w-]+)$/,
  select: function (context, feature) {
    env.loadFeature(browserslist.cache, feature);
    var features = browserslist.cache[feature];
    return Object.keys(features).reduce(function (result, version) {
      var flags = features[version];

      if (flags.indexOf('y') >= 0 || flags.indexOf('a') >= 0) {
        result.push(version);
      }

      return result;
    }, []);
  }
}, {
  regexp: /^electron\s+([\d.]+)\s*-\s*([\d.]+)$/i,
  select: function (context, from, to) {
    var fromToUse = normalizeElectron(from);
    var toToUse = normalizeElectron(to);

    if (!e2c[fromToUse]) {
      throw new BrowserslistError('Unknown version ' + from + ' of electron');
    }

    if (!e2c[toToUse]) {
      throw new BrowserslistError('Unknown version ' + to + ' of electron');
    }

    from = parseFloat(from);
    to = parseFloat(to);
    return Object.keys(e2c).filter(function (i) {
      var parsed = parseFloat(i);
      return parsed >= from && parsed <= to;
    }).map(function (i) {
      return 'chrome ' + e2c[i];
    });
  }
}, {
  regexp: /^node\s+([\d.]+)\s*-\s*([\d.]+)$/i,
  select: function (context, from, to) {
    var nodeVersions = jsReleases.filter(function (i) {
      return i.name === 'nodejs';
    }).map(function (i) {
      return i.version;
    });
    return nodeVersions.filter(semverFilterLoose('>=', from)).filter(semverFilterLoose('<=', to)).map(function (v) {
      return 'node ' + v;
    });
  }
}, {
  regexp: /^(\w+)\s+([\d.]+)\s*-\s*([\d.]+)$/i,
  select: function (context, name, from, to) {
    var data = checkName(name, context);
    from = parseFloat(normalizeVersion(data, from) || from);
    to = parseFloat(normalizeVersion(data, to) || to);

    function filter(v) {
      var parsed = parseFloat(v);
      return parsed >= from && parsed <= to;
    }

    return data.released.filter(filter).map(nameMapper(data.name));
  }
}, {
  regexp: /^electron\s*(>=?|<=?)\s*([\d.]+)$/i,
  select: function (context, sign, version) {
    var versionToUse = normalizeElectron(version);
    return Object.keys(e2c).filter(generateFilter(sign, versionToUse)).map(function (i) {
      return 'chrome ' + e2c[i];
    });
  }
}, {
  regexp: /^node\s*(>=?|<=?)\s*([\d.]+)$/i,
  select: function (context, sign, version) {
    var nodeVersions = jsReleases.filter(function (i) {
      return i.name === 'nodejs';
    }).map(function (i) {
      return i.version;
    });
    return nodeVersions.filter(generateSemverFilter(sign, version)).map(function (v) {
      return 'node ' + v;
    });
  }
}, {
  regexp: /^(\w+)\s*(>=?|<=?)\s*([\d.]+)$/,
  select: function (context, name, sign, version) {
    var data = checkName(name, context);
    var alias = browserslist.versionAliases[data.name][version];

    if (alias) {
      version = alias;
    }

    return data.released.filter(generateFilter(sign, version)).map(function (v) {
      return data.name + ' ' + v;
    });
  }
}, {
  regexp: /^(firefox|ff|fx)\s+esr$/i,
  select: function () {
    return ['firefox 78'];
  }
}, {
  regexp: /(operamini|op_mini)\s+all/i,
  select: function () {
    return ['op_mini all'];
  }
}, {
  regexp: /^electron\s+([\d.]+)$/i,
  select: function (context, version) {
    var versionToUse = normalizeElectron(version);
    var chrome = e2c[versionToUse];

    if (!chrome) {
      throw new BrowserslistError('Unknown version ' + version + ' of electron');
    }

    return ['chrome ' + chrome];
  }
}, {
  regexp: /^node\s+(\d+)$/i,
  select: nodeQuery
}, {
  regexp: /^node\s+(\d+\.\d+)$/i,
  select: nodeQuery
}, {
  regexp: /^node\s+(\d+\.\d+\.\d+)$/i,
  select: nodeQuery
}, {
  regexp: /^current\s+node$/i,
  select: function (context) {
    return [env.currentNode(resolve, context)];
  }
}, {
  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);
  }
}, {
  regexp: /^phantomjs\s+1.9$/i,
  select: function () {
    return ['safari 5'];
  }
}, {
  regexp: /^phantomjs\s+2.1$/i,
  select: function () {
    return ['safari 6'];
  }
}, {
  regexp: /^(\w+)\s+(tp|[\d.]+)$/i,
  select: function (context, name, version) {
    if (/^tp$/i.test(version)) version = 'TP';
    var data = checkName(name, 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 BrowserslistError('Unknown version ' + version + ' of ' + name);
      }
    }

    return [data.name + ' ' + version];
  }
}, {
  regexp: /^browserslist config$/i,
  select: function (context) {
    return browserslist(undefined, context);
  }
}, {
  regexp: /^extends (.+)$/i,
  select: function (context, name) {
    return resolve(env.loadQueries(context, name), context);
  }
}, {
  regexp: /^defaults$/i,
  select: function (context) {
    return resolve(browserslist.defaults, context);
  }
}, {
  regexp: /^dead$/i,
  select: function (context) {
    var dead = ['ie <= 10', 'ie_mob <= 11', 'bb <= 10', 'op_mob <= 12.1', 'samsung 4'];
    return resolve(dead, context);
  }
}, {
  regexp: /^(\w+)$/i,
  select: function (context, name) {
    if (byName(name, context)) {
      throw new BrowserslistError('Specify versions in Browserslist query for browser ' + name);
    } else {
      throw unknownQuery(name);
    }
  }
}]; // Get and convert Can I Use data

(function () {
  for (var name in agents) {
    var browser = agents[name];
    browserslist.data[name] = {
      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, browser.usage_global);
    browserslist.versionAliases[name] = {};

    for (var i = 0; i < browser.versions.length; i++) {
      var full = browser.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.versionAliases.op_mob['59'] = '58';
})();

module.exports = browserslist;