CasperSecurity
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
}
case '>=':
default:
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) {
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 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.throwOnMissing] Throw error on missing env.
* @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$/i)) {
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) {
var percentage = usage[version]
if (percentage == null) {
return result
}
if (sign === '>') {
if (percentage > popularity) {
result.push(version)
}
} else if (sign === '<') {
if (percentage < popularity) {
result.push(version)
}
} else if (sign === '<=') {
if (percentage <= popularity) {
result.push(version)
}
} else if (percentage >= 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) {
var percentage = usage[version]
if (percentage == null) {
return result
}
if (sign === '>') {
if (percentage > popularity) {
result.push(version)
}
} else if (sign === '<') {
if (percentage < popularity) {
result.push(version)
}
} else if (sign === '<=') {
if (percentage <= popularity) {
result.push(version)
}
} else if (percentage >= 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) {
var percentage = usage[version]
if (percentage == null) {
return result
}
if (sign === '>') {
if (percentage > popularity) {
result.push(version)
}
} else if (sign === '<') {
if (percentage < popularity) {
result.push(version)
}
} else if (sign === '<=') {
if (percentage <= popularity) {
result.push(version)
}
} else if (percentage >= popularity) {
result.push(version)
}
return result
}, [])
}
},
{
regexp: /^cover\s+(\d+|\d+\.\d+|\.\d+)%$/i,
select: coverQuery
},
{
regexp: /^cover\s+(\d+|\d+\.\d+|\.\d+)%\s+in\s+(my\s+stats|(alt-)?\w\w)$/i,
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', 'firefox 91']
}
},
{
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