1 | var jsReleases = require('node-releases/data/processed/envs.json')
|
2 | var agents = require('caniuse-lite/dist/unpacker/agents').agents
|
3 | var jsEOL = require('node-releases/data/release-schedule/release-schedule.json')
|
4 | var path = require('path')
|
5 | var e2c = require('electron-to-chromium/versions')
|
6 |
|
7 | var BrowserslistError = require('./error')
|
8 | var env = require('./node')
|
9 |
|
10 | var YEAR = 365.259641 * 24 * 60 * 60 * 1000
|
11 | var ANDROID_EVERGREEN_FIRST = 37
|
12 |
|
13 | var QUERY_OR = 1
|
14 | var QUERY_AND = 2
|
15 |
|
16 | function isVersionsMatch (versionA, versionB) {
|
17 | return (versionA + '.').indexOf(versionB + '.') === 0
|
18 | }
|
19 |
|
20 | function isEolReleased (name) {
|
21 | var version = name.slice(1)
|
22 | return jsReleases.some(function (i) {
|
23 | return isVersionsMatch(i.version, version)
|
24 | })
|
25 | }
|
26 |
|
27 | function normalize (versions) {
|
28 | return versions.filter(function (version) {
|
29 | return typeof version === 'string'
|
30 | })
|
31 | }
|
32 |
|
33 | function normalizeElectron (version) {
|
34 | var versionToUse = version
|
35 | if (version.split('.').length === 3) {
|
36 | versionToUse = version
|
37 | .split('.')
|
38 | .slice(0, -1)
|
39 | .join('.')
|
40 | }
|
41 | return versionToUse
|
42 | }
|
43 |
|
44 | function nameMapper (name) {
|
45 | return function mapName (version) {
|
46 | return name + ' ' + version
|
47 | }
|
48 | }
|
49 |
|
50 | function getMajor (version) {
|
51 | return parseInt(version.split('.')[0])
|
52 | }
|
53 |
|
54 | function getMajorVersions (released, number) {
|
55 | if (released.length === 0) return []
|
56 | var majorVersions = uniq(released.map(getMajor))
|
57 | var minimum = majorVersions[majorVersions.length - number]
|
58 | if (!minimum) {
|
59 | return released
|
60 | }
|
61 | var selected = []
|
62 | for (var i = released.length - 1; i >= 0; i--) {
|
63 | if (minimum > getMajor(released[i])) break
|
64 | selected.unshift(released[i])
|
65 | }
|
66 | return selected
|
67 | }
|
68 |
|
69 | function uniq (array) {
|
70 | var filtered = []
|
71 | for (var i = 0; i < array.length; i++) {
|
72 | if (filtered.indexOf(array[i]) === -1) filtered.push(array[i])
|
73 | }
|
74 | return filtered
|
75 | }
|
76 |
|
77 |
|
78 |
|
79 | function fillUsage (result, name, data) {
|
80 | for (var i in data) {
|
81 | result[name + ' ' + i] = data[i]
|
82 | }
|
83 | }
|
84 |
|
85 | function generateFilter (sign, version) {
|
86 | version = parseFloat(version)
|
87 | if (sign === '>') {
|
88 | return function (v) {
|
89 | return parseFloat(v) > version
|
90 | }
|
91 | } else if (sign === '>=') {
|
92 | return function (v) {
|
93 | return parseFloat(v) >= version
|
94 | }
|
95 | } else if (sign === '<') {
|
96 | return function (v) {
|
97 | return parseFloat(v) < version
|
98 | }
|
99 | } else {
|
100 | return function (v) {
|
101 | return parseFloat(v) <= version
|
102 | }
|
103 | }
|
104 | }
|
105 |
|
106 | function generateSemverFilter (sign, version) {
|
107 | version = version.split('.').map(parseSimpleInt)
|
108 | version[1] = version[1] || 0
|
109 | version[2] = version[2] || 0
|
110 | if (sign === '>') {
|
111 | return function (v) {
|
112 | v = v.split('.').map(parseSimpleInt)
|
113 | return compareSemver(v, version) > 0
|
114 | }
|
115 | } else if (sign === '>=') {
|
116 | return function (v) {
|
117 | v = v.split('.').map(parseSimpleInt)
|
118 | return compareSemver(v, version) >= 0
|
119 | }
|
120 | } else if (sign === '<') {
|
121 | return function (v) {
|
122 | v = v.split('.').map(parseSimpleInt)
|
123 | return compareSemver(version, v) > 0
|
124 | }
|
125 | } else {
|
126 | return function (v) {
|
127 | v = v.split('.').map(parseSimpleInt)
|
128 | return compareSemver(version, v) >= 0
|
129 | }
|
130 | }
|
131 | }
|
132 |
|
133 | function parseSimpleInt (x) {
|
134 | return parseInt(x)
|
135 | }
|
136 |
|
137 | function compare (a, b) {
|
138 | if (a < b) return -1
|
139 | if (a > b) return +1
|
140 | return 0
|
141 | }
|
142 |
|
143 | function compareSemver (a, b) {
|
144 | return (
|
145 | compare(parseInt(a[0]), parseInt(b[0])) ||
|
146 | compare(parseInt(a[1] || '0'), parseInt(b[1] || '0')) ||
|
147 | compare(parseInt(a[2] || '0'), parseInt(b[2] || '0'))
|
148 | )
|
149 | }
|
150 |
|
151 |
|
152 | function semverFilterLoose (operator, range) {
|
153 | range = range.split('.').map(parseSimpleInt)
|
154 | if (typeof range[1] === 'undefined') {
|
155 | range[1] = 'x'
|
156 | }
|
157 |
|
158 |
|
159 | switch (operator) {
|
160 | case '<=':
|
161 | return function (version) {
|
162 | version = version.split('.').map(parseSimpleInt)
|
163 | return compareSemverLoose(version, range) <= 0
|
164 | }
|
165 | default:
|
166 | case '>=':
|
167 | return function (version) {
|
168 | version = version.split('.').map(parseSimpleInt)
|
169 | return compareSemverLoose(version, range) >= 0
|
170 | }
|
171 | }
|
172 | }
|
173 |
|
174 |
|
175 | function compareSemverLoose (version, range) {
|
176 | if (version[0] !== range[0]) {
|
177 | return version[0] < range[0] ? -1 : +1
|
178 | }
|
179 | if (range[1] === 'x') {
|
180 | return 0
|
181 | }
|
182 | if (version[1] !== range[1]) {
|
183 | return version[1] < range[1] ? -1 : +1
|
184 | }
|
185 | return 0
|
186 | }
|
187 |
|
188 | function resolveVersion (data, version) {
|
189 | if (data.versions.indexOf(version) !== -1) {
|
190 | return version
|
191 | } else if (browserslist.versionAliases[data.name][version]) {
|
192 | return browserslist.versionAliases[data.name][version]
|
193 | } else {
|
194 | return false
|
195 | }
|
196 | }
|
197 |
|
198 | function normalizeVersion (data, version) {
|
199 | var resolved = resolveVersion(data, version)
|
200 | if (resolved) {
|
201 | return resolved
|
202 | } else if (data.versions.length === 1) {
|
203 | return data.versions[0]
|
204 | } else {
|
205 | return false
|
206 | }
|
207 | }
|
208 |
|
209 | function filterByYear (since, context) {
|
210 | since = since / 1000
|
211 | return Object.keys(agents).reduce(function (selected, name) {
|
212 | var data = byName(name, context)
|
213 | if (!data) return selected
|
214 | var versions = Object.keys(data.releaseDate).filter(function (v) {
|
215 | return data.releaseDate[v] >= since
|
216 | })
|
217 | return selected.concat(versions.map(nameMapper(data.name)))
|
218 | }, [])
|
219 | }
|
220 |
|
221 | function cloneData (data) {
|
222 | return {
|
223 | name: data.name,
|
224 | versions: data.versions,
|
225 | released: data.released,
|
226 | releaseDate: data.releaseDate
|
227 | }
|
228 | }
|
229 |
|
230 | function mapVersions (data, map) {
|
231 | data.versions = data.versions.map(function (i) {
|
232 | return map[i] || i
|
233 | })
|
234 | data.released = data.versions.map(function (i) {
|
235 | return map[i] || i
|
236 | })
|
237 | var fixedDate = { }
|
238 | for (var i in data.releaseDate) {
|
239 | fixedDate[map[i] || i] = data.releaseDate[i]
|
240 | }
|
241 | data.releaseDate = fixedDate
|
242 | return data
|
243 | }
|
244 |
|
245 | function byName (name, context) {
|
246 | name = name.toLowerCase()
|
247 | name = browserslist.aliases[name] || name
|
248 | if (context.mobileToDesktop && browserslist.desktopNames[name]) {
|
249 | var desktop = browserslist.data[browserslist.desktopNames[name]]
|
250 | if (name === 'android') {
|
251 | return normalizeAndroidData(cloneData(browserslist.data[name]), desktop)
|
252 | } else {
|
253 | var cloned = cloneData(desktop)
|
254 | cloned.name = name
|
255 | if (name === 'op_mob') {
|
256 | cloned = mapVersions(cloned, { '10.0-10.1': '10' })
|
257 | }
|
258 | return cloned
|
259 | }
|
260 | }
|
261 | return browserslist.data[name]
|
262 | }
|
263 |
|
264 | function normalizeAndroidVersions (androidVersions, chromeVersions) {
|
265 | var firstEvergreen = ANDROID_EVERGREEN_FIRST
|
266 | var last = chromeVersions[chromeVersions.length - 1]
|
267 | return androidVersions
|
268 | .filter(function (version) { return /^(?:[2-4]\.|[34]$)/.test(version) })
|
269 | .concat(chromeVersions.slice(firstEvergreen - last - 1))
|
270 | }
|
271 |
|
272 | function normalizeAndroidData (android, chrome) {
|
273 | android.released = normalizeAndroidVersions(android.released, chrome.released)
|
274 | android.versions = normalizeAndroidVersions(android.versions, chrome.versions)
|
275 | return android
|
276 | }
|
277 |
|
278 | function checkName (name, context) {
|
279 | var data = byName(name, context)
|
280 | if (!data) throw new BrowserslistError('Unknown browser ' + name)
|
281 | return data
|
282 | }
|
283 |
|
284 | function unknownQuery (query) {
|
285 | return new BrowserslistError(
|
286 | 'Unknown browser query `' + query + '`. ' +
|
287 | 'Maybe you are using old Browserslist or made typo in query.'
|
288 | )
|
289 | }
|
290 |
|
291 | function filterAndroid (list, versions, context) {
|
292 | if (context.mobileToDesktop) return list
|
293 | var released = browserslist.data.android.released
|
294 | var last = released[released.length - 1]
|
295 | var diff = last - ANDROID_EVERGREEN_FIRST - versions
|
296 | if (diff > 0) {
|
297 | return list.slice(-1)
|
298 | } else {
|
299 | return list.slice(diff - 1)
|
300 | }
|
301 | }
|
302 |
|
303 |
|
304 |
|
305 |
|
306 |
|
307 |
|
308 |
|
309 |
|
310 |
|
311 | function resolve (queries, context) {
|
312 | if (Array.isArray(queries)) {
|
313 | queries = flatten(queries.map(parse))
|
314 | } else {
|
315 | queries = parse(queries)
|
316 | }
|
317 |
|
318 | return queries.reduce(function (result, query, index) {
|
319 | var selection = query.queryString
|
320 |
|
321 | var isExclude = selection.indexOf('not ') === 0
|
322 | if (isExclude) {
|
323 | if (index === 0) {
|
324 | throw new BrowserslistError(
|
325 | 'Write any browsers query (for instance, `defaults`) ' +
|
326 | 'before `' + selection + '`')
|
327 | }
|
328 | selection = selection.slice(4)
|
329 | }
|
330 |
|
331 | for (var i = 0; i < QUERIES.length; i++) {
|
332 | var type = QUERIES[i]
|
333 | var match = selection.match(type.regexp)
|
334 | if (match) {
|
335 | var args = [context].concat(match.slice(1))
|
336 | var array = type.select.apply(browserslist, args).map(function (j) {
|
337 | var parts = j.split(' ')
|
338 | if (parts[1] === '0') {
|
339 | return parts[0] + ' ' + byName(parts[0], context).versions[0]
|
340 | } else {
|
341 | return j
|
342 | }
|
343 | })
|
344 |
|
345 | switch (query.type) {
|
346 | case QUERY_AND:
|
347 | if (isExclude) {
|
348 | return result.filter(function (j) {
|
349 | return array.indexOf(j) === -1
|
350 | })
|
351 | } else {
|
352 | return result.filter(function (j) {
|
353 | return array.indexOf(j) !== -1
|
354 | })
|
355 | }
|
356 | case QUERY_OR:
|
357 | default:
|
358 | if (isExclude) {
|
359 | var filter = { }
|
360 | array.forEach(function (j) {
|
361 | filter[j] = true
|
362 | })
|
363 | return result.filter(function (j) {
|
364 | return !filter[j]
|
365 | })
|
366 | }
|
367 | return result.concat(array)
|
368 | }
|
369 | }
|
370 | }
|
371 |
|
372 | throw unknownQuery(selection)
|
373 | }, [])
|
374 | }
|
375 |
|
376 | var cache = { }
|
377 |
|
378 |
|
379 |
|
380 |
|
381 |
|
382 |
|
383 |
|
384 |
|
385 |
|
386 |
|
387 |
|
388 |
|
389 |
|
390 |
|
391 |
|
392 |
|
393 |
|
394 |
|
395 |
|
396 |
|
397 |
|
398 |
|
399 |
|
400 |
|
401 |
|
402 |
|
403 | function browserslist (queries, opts) {
|
404 | if (typeof opts === 'undefined') opts = { }
|
405 |
|
406 | if (typeof opts.path === 'undefined') {
|
407 | opts.path = path.resolve ? path.resolve('.') : '.'
|
408 | }
|
409 |
|
410 | if (typeof queries === 'undefined' || queries === null) {
|
411 | var config = browserslist.loadConfig(opts)
|
412 | if (config) {
|
413 | queries = config
|
414 | } else {
|
415 | queries = browserslist.defaults
|
416 | }
|
417 | }
|
418 |
|
419 | if (!(typeof queries === 'string' || Array.isArray(queries))) {
|
420 | throw new BrowserslistError(
|
421 | 'Browser queries must be an array or string. Got ' + typeof queries + '.')
|
422 | }
|
423 |
|
424 | var context = {
|
425 | ignoreUnknownVersions: opts.ignoreUnknownVersions,
|
426 | dangerousExtend: opts.dangerousExtend,
|
427 | mobileToDesktop: opts.mobileToDesktop,
|
428 | path: opts.path,
|
429 | env: opts.env
|
430 | }
|
431 |
|
432 | env.oldDataWarning(browserslist.data)
|
433 | var stats = env.getStat(opts, browserslist.data)
|
434 | if (stats) {
|
435 | context.customUsage = { }
|
436 | for (var browser in stats) {
|
437 | fillUsage(context.customUsage, browser, stats[browser])
|
438 | }
|
439 | }
|
440 |
|
441 | var cacheKey = JSON.stringify([queries, context])
|
442 | if (cache[cacheKey]) return cache[cacheKey]
|
443 |
|
444 | var result = uniq(resolve(queries, context)).sort(function (name1, name2) {
|
445 | name1 = name1.split(' ')
|
446 | name2 = name2.split(' ')
|
447 | if (name1[0] === name2[0]) {
|
448 |
|
449 |
|
450 |
|
451 | var version1 = name1[1].split('-')[0]
|
452 | var version2 = name2[1].split('-')[0]
|
453 | return compareSemver(version2.split('.'), version1.split('.'))
|
454 | } else {
|
455 | return compare(name1[0], name2[0])
|
456 | }
|
457 | })
|
458 | if (!process.env.BROWSERSLIST_DISABLE_CACHE) {
|
459 | cache[cacheKey] = result
|
460 | }
|
461 | return result
|
462 | }
|
463 |
|
464 | function parse (queries) {
|
465 | var qs = []
|
466 | do {
|
467 | queries = doMatch(queries, qs)
|
468 | } while (queries)
|
469 | return qs
|
470 | }
|
471 |
|
472 | function doMatch (string, qs) {
|
473 | var or = /^(?:,\s*|\s+or\s+)(.*)/i
|
474 | var and = /^\s+and\s+(.*)/i
|
475 |
|
476 | return find(string, function (parsed, n, max) {
|
477 | if (and.test(parsed)) {
|
478 | qs.unshift({ type: QUERY_AND, queryString: parsed.match(and)[1] })
|
479 | return true
|
480 | } else if (or.test(parsed)) {
|
481 | qs.unshift({ type: QUERY_OR, queryString: parsed.match(or)[1] })
|
482 | return true
|
483 | } else if (n === max) {
|
484 | qs.unshift({ type: QUERY_OR, queryString: parsed.trim() })
|
485 | return true
|
486 | }
|
487 | return false
|
488 | })
|
489 | }
|
490 |
|
491 | function find (string, predicate) {
|
492 | for (var n = 1, max = string.length; n <= max; n++) {
|
493 | var parsed = string.substr(-n, n)
|
494 | if (predicate(parsed, n, max)) {
|
495 | return string.slice(0, -n)
|
496 | }
|
497 | }
|
498 | return ''
|
499 | }
|
500 |
|
501 | function flatten (array) {
|
502 | if (!Array.isArray(array)) return [array]
|
503 | return array.reduce(function (a, b) {
|
504 | return a.concat(flatten(b))
|
505 | }, [])
|
506 | }
|
507 |
|
508 |
|
509 | browserslist.cache = { }
|
510 | browserslist.data = { }
|
511 | browserslist.usage = {
|
512 | global: { },
|
513 | custom: null
|
514 | }
|
515 |
|
516 |
|
517 | browserslist.defaults = [
|
518 | '> 0.5%',
|
519 | 'last 2 versions',
|
520 | 'Firefox ESR',
|
521 | 'not dead'
|
522 | ]
|
523 |
|
524 |
|
525 | browserslist.aliases = {
|
526 | fx: 'firefox',
|
527 | ff: 'firefox',
|
528 | ios: 'ios_saf',
|
529 | explorer: 'ie',
|
530 | blackberry: 'bb',
|
531 | explorermobile: 'ie_mob',
|
532 | operamini: 'op_mini',
|
533 | operamobile: 'op_mob',
|
534 | chromeandroid: 'and_chr',
|
535 | firefoxandroid: 'and_ff',
|
536 | ucandroid: 'and_uc',
|
537 | qqandroid: 'and_qq'
|
538 | }
|
539 |
|
540 |
|
541 |
|
542 | browserslist.desktopNames = {
|
543 | and_chr: 'chrome',
|
544 | and_ff: 'firefox',
|
545 | ie_mob: 'ie',
|
546 | op_mob: 'opera',
|
547 | android: 'chrome'
|
548 | }
|
549 |
|
550 |
|
551 | browserslist.versionAliases = { }
|
552 |
|
553 | browserslist.clearCaches = env.clearCaches
|
554 | browserslist.parseConfig = env.parseConfig
|
555 | browserslist.readConfig = env.readConfig
|
556 | browserslist.findConfig = env.findConfig
|
557 | browserslist.loadConfig = env.loadConfig
|
558 |
|
559 |
|
560 |
|
561 |
|
562 |
|
563 |
|
564 |
|
565 |
|
566 |
|
567 |
|
568 |
|
569 |
|
570 |
|
571 |
|
572 |
|
573 | browserslist.coverage = function (browsers, stats) {
|
574 | var data
|
575 | if (typeof stats === 'undefined') {
|
576 | data = browserslist.usage.global
|
577 | } else if (stats === 'my stats') {
|
578 | var opts = {}
|
579 | opts.path = path.resolve ? path.resolve('.') : '.'
|
580 | var customStats = env.getStat(opts)
|
581 | if (!customStats) {
|
582 | throw new BrowserslistError('Custom usage statistics was not provided')
|
583 | }
|
584 | data = {}
|
585 | for (var browser in customStats) {
|
586 | fillUsage(data, browser, customStats[browser])
|
587 | }
|
588 | } else if (typeof stats === 'string') {
|
589 | if (stats.length > 2) {
|
590 | stats = stats.toLowerCase()
|
591 | } else {
|
592 | stats = stats.toUpperCase()
|
593 | }
|
594 | env.loadCountry(browserslist.usage, stats, browserslist.data)
|
595 | data = browserslist.usage[stats]
|
596 | } else {
|
597 | if ('dataByBrowser' in stats) {
|
598 | stats = stats.dataByBrowser
|
599 | }
|
600 | data = { }
|
601 | for (var name in stats) {
|
602 | for (var version in stats[name]) {
|
603 | data[name + ' ' + version] = stats[name][version]
|
604 | }
|
605 | }
|
606 | }
|
607 |
|
608 | return browsers.reduce(function (all, i) {
|
609 | var usage = data[i]
|
610 | if (usage === undefined) {
|
611 | usage = data[i.replace(/ \S+$/, ' 0')]
|
612 | }
|
613 | return all + (usage || 0)
|
614 | }, 0)
|
615 | }
|
616 |
|
617 | function nodeQuery (context, version) {
|
618 | var nodeReleases = jsReleases.filter(function (i) {
|
619 | return i.name === 'nodejs'
|
620 | })
|
621 | var matched = nodeReleases.filter(function (i) {
|
622 | return isVersionsMatch(i.version, version)
|
623 | })
|
624 | if (matched.length === 0) {
|
625 | if (context.ignoreUnknownVersions) {
|
626 | return []
|
627 | } else {
|
628 | throw new BrowserslistError('Unknown version ' + version + ' of Node.js')
|
629 | }
|
630 | }
|
631 | return ['node ' + matched[matched.length - 1].version]
|
632 | }
|
633 |
|
634 | function sinceQuery (context, year, month, date) {
|
635 | year = parseInt(year)
|
636 | month = parseInt(month || '01') - 1
|
637 | date = parseInt(date || '01')
|
638 | return filterByYear(Date.UTC(year, month, date, 0, 0, 0), context)
|
639 | }
|
640 |
|
641 | function coverQuery (context, coverage, statMode) {
|
642 | coverage = parseFloat(coverage)
|
643 | var usage = browserslist.usage.global
|
644 | if (statMode) {
|
645 | if (statMode.match(/^my\s+stats$/)) {
|
646 | if (!context.customUsage) {
|
647 | throw new BrowserslistError(
|
648 | 'Custom usage statistics was not provided'
|
649 | )
|
650 | }
|
651 | usage = context.customUsage
|
652 | } else {
|
653 | var place
|
654 | if (statMode.length === 2) {
|
655 | place = statMode.toUpperCase()
|
656 | } else {
|
657 | place = statMode.toLowerCase()
|
658 | }
|
659 | env.loadCountry(browserslist.usage, place, browserslist.data)
|
660 | usage = browserslist.usage[place]
|
661 | }
|
662 | }
|
663 | var versions = Object.keys(usage).sort(function (a, b) {
|
664 | return usage[b] - usage[a]
|
665 | })
|
666 | var coveraged = 0
|
667 | var result = []
|
668 | var version
|
669 | for (var i = 0; i <= versions.length; i++) {
|
670 | version = versions[i]
|
671 | if (usage[version] === 0) break
|
672 | coveraged += usage[version]
|
673 | result.push(version)
|
674 | if (coveraged >= coverage) break
|
675 | }
|
676 | return result
|
677 | }
|
678 |
|
679 | var QUERIES = [
|
680 | {
|
681 | regexp: /^last\s+(\d+)\s+major\s+versions?$/i,
|
682 | select: function (context, versions) {
|
683 | return Object.keys(agents).reduce(function (selected, name) {
|
684 | var data = byName(name, context)
|
685 | if (!data) return selected
|
686 | var list = getMajorVersions(data.released, versions)
|
687 | list = list.map(nameMapper(data.name))
|
688 | if (data.name === 'android') {
|
689 | list = filterAndroid(list, versions, context)
|
690 | }
|
691 | return selected.concat(list)
|
692 | }, [])
|
693 | }
|
694 | },
|
695 | {
|
696 | regexp: /^last\s+(\d+)\s+versions?$/i,
|
697 | select: function (context, versions) {
|
698 | return Object.keys(agents).reduce(function (selected, name) {
|
699 | var data = byName(name, context)
|
700 | if (!data) return selected
|
701 | var list = data.released.slice(-versions)
|
702 | list = list.map(nameMapper(data.name))
|
703 | if (data.name === 'android') {
|
704 | list = filterAndroid(list, versions, context)
|
705 | }
|
706 | return selected.concat(list)
|
707 | }, [])
|
708 | }
|
709 | },
|
710 | {
|
711 | regexp: /^last\s+(\d+)\s+electron\s+major\s+versions?$/i,
|
712 | select: function (context, versions) {
|
713 | var validVersions = getMajorVersions(Object.keys(e2c), versions)
|
714 | return validVersions.map(function (i) {
|
715 | return 'chrome ' + e2c[i]
|
716 | })
|
717 | }
|
718 | },
|
719 | {
|
720 | regexp: /^last\s+(\d+)\s+(\w+)\s+major\s+versions?$/i,
|
721 | select: function (context, versions, name) {
|
722 | var data = checkName(name, context)
|
723 | var validVersions = getMajorVersions(data.released, versions)
|
724 | var list = validVersions.map(nameMapper(data.name))
|
725 | if (data.name === 'android') {
|
726 | list = filterAndroid(list, versions, context)
|
727 | }
|
728 | return list
|
729 | }
|
730 | },
|
731 | {
|
732 | regexp: /^last\s+(\d+)\s+electron\s+versions?$/i,
|
733 | select: function (context, versions) {
|
734 | return Object.keys(e2c)
|
735 | .slice(-versions)
|
736 | .map(function (i) {
|
737 | return 'chrome ' + e2c[i]
|
738 | })
|
739 | }
|
740 | },
|
741 | {
|
742 | regexp: /^last\s+(\d+)\s+(\w+)\s+versions?$/i,
|
743 | select: function (context, versions, name) {
|
744 | var data = checkName(name, context)
|
745 | var list = data.released.slice(-versions).map(nameMapper(data.name))
|
746 | if (data.name === 'android') {
|
747 | list = filterAndroid(list, versions, context)
|
748 | }
|
749 | return list
|
750 | }
|
751 | },
|
752 | {
|
753 | regexp: /^unreleased\s+versions$/i,
|
754 | select: function (context) {
|
755 | return Object.keys(agents).reduce(function (selected, name) {
|
756 | var data = byName(name, context)
|
757 | if (!data) return selected
|
758 | var list = data.versions.filter(function (v) {
|
759 | return data.released.indexOf(v) === -1
|
760 | })
|
761 | list = list.map(nameMapper(data.name))
|
762 | return selected.concat(list)
|
763 | }, [])
|
764 | }
|
765 | },
|
766 | {
|
767 | regexp: /^unreleased\s+electron\s+versions?$/i,
|
768 | select: function () {
|
769 | return []
|
770 | }
|
771 | },
|
772 | {
|
773 | regexp: /^unreleased\s+(\w+)\s+versions?$/i,
|
774 | select: function (context, name) {
|
775 | var data = checkName(name, context)
|
776 | return data.versions
|
777 | .filter(function (v) {
|
778 | return data.released.indexOf(v) === -1
|
779 | })
|
780 | .map(nameMapper(data.name))
|
781 | }
|
782 | },
|
783 | {
|
784 | regexp: /^last\s+(\d*.?\d+)\s+years?$/i,
|
785 | select: function (context, years) {
|
786 | return filterByYear(Date.now() - YEAR * years, context)
|
787 | }
|
788 | },
|
789 | {
|
790 | regexp: /^since (\d+)$/i,
|
791 | select: sinceQuery
|
792 | },
|
793 | {
|
794 | regexp: /^since (\d+)-(\d+)$/i,
|
795 | select: sinceQuery
|
796 | },
|
797 | {
|
798 | regexp: /^since (\d+)-(\d+)-(\d+)$/i,
|
799 | select: sinceQuery
|
800 | },
|
801 | {
|
802 | regexp: /^(>=?|<=?)\s*(\d+|\d+\.\d+|\.\d+)%$/,
|
803 | select: function (context, sign, popularity) {
|
804 | popularity = parseFloat(popularity)
|
805 | var usage = browserslist.usage.global
|
806 | return Object.keys(usage).reduce(function (result, version) {
|
807 | if (sign === '>') {
|
808 | if (usage[version] > popularity) {
|
809 | result.push(version)
|
810 | }
|
811 | } else if (sign === '<') {
|
812 | if (usage[version] < popularity) {
|
813 | result.push(version)
|
814 | }
|
815 | } else if (sign === '<=') {
|
816 | if (usage[version] <= popularity) {
|
817 | result.push(version)
|
818 | }
|
819 | } else if (usage[version] >= popularity) {
|
820 | result.push(version)
|
821 | }
|
822 | return result
|
823 | }, [])
|
824 | }
|
825 | },
|
826 | {
|
827 | regexp: /^(>=?|<=?)\s*(\d+|\d+\.\d+|\.\d+)%\s+in\s+my\s+stats$/,
|
828 | select: function (context, sign, popularity) {
|
829 | popularity = parseFloat(popularity)
|
830 | if (!context.customUsage) {
|
831 | throw new BrowserslistError('Custom usage statistics was not provided')
|
832 | }
|
833 | var usage = context.customUsage
|
834 | return Object.keys(usage).reduce(function (result, version) {
|
835 | if (sign === '>') {
|
836 | if (usage[version] > popularity) {
|
837 | result.push(version)
|
838 | }
|
839 | } else if (sign === '<') {
|
840 | if (usage[version] < popularity) {
|
841 | result.push(version)
|
842 | }
|
843 | } else if (sign === '<=') {
|
844 | if (usage[version] <= popularity) {
|
845 | result.push(version)
|
846 | }
|
847 | } else if (usage[version] >= popularity) {
|
848 | result.push(version)
|
849 | }
|
850 | return result
|
851 | }, [])
|
852 | }
|
853 | },
|
854 | {
|
855 | regexp: /^(>=?|<=?)\s*(\d+|\d+\.\d+|\.\d+)%\s+in\s+(\S+)\s+stats$/,
|
856 | select: function (context, sign, popularity, name) {
|
857 | popularity = parseFloat(popularity)
|
858 | var stats = env.loadStat(context, name, browserslist.data)
|
859 | if (stats) {
|
860 | context.customUsage = {}
|
861 | for (var browser in stats) {
|
862 | fillUsage(context.customUsage, browser, stats[browser])
|
863 | }
|
864 | }
|
865 | if (!context.customUsage) {
|
866 | throw new BrowserslistError('Custom usage statistics was not provided')
|
867 | }
|
868 | var usage = context.customUsage
|
869 | return Object.keys(usage).reduce(function (result, version) {
|
870 | if (sign === '>') {
|
871 | if (usage[version] > popularity) {
|
872 | result.push(version)
|
873 | }
|
874 | } else if (sign === '<') {
|
875 | if (usage[version] < popularity) {
|
876 | result.push(version)
|
877 | }
|
878 | } else if (sign === '<=') {
|
879 | if (usage[version] <= popularity) {
|
880 | result.push(version)
|
881 | }
|
882 | } else if (usage[version] >= popularity) {
|
883 | result.push(version)
|
884 | }
|
885 | return result
|
886 | }, [])
|
887 | }
|
888 | },
|
889 | {
|
890 | regexp: /^(>=?|<=?)\s*(\d+|\d+\.\d+|\.\d+)%\s+in\s+((alt-)?\w\w)$/,
|
891 | select: function (context, sign, popularity, place) {
|
892 | popularity = parseFloat(popularity)
|
893 | if (place.length === 2) {
|
894 | place = place.toUpperCase()
|
895 | } else {
|
896 | place = place.toLowerCase()
|
897 | }
|
898 | env.loadCountry(browserslist.usage, place, browserslist.data)
|
899 | var usage = browserslist.usage[place]
|
900 | return Object.keys(usage).reduce(function (result, version) {
|
901 | if (sign === '>') {
|
902 | if (usage[version] > popularity) {
|
903 | result.push(version)
|
904 | }
|
905 | } else if (sign === '<') {
|
906 | if (usage[version] < popularity) {
|
907 | result.push(version)
|
908 | }
|
909 | } else if (sign === '<=') {
|
910 | if (usage[version] <= popularity) {
|
911 | result.push(version)
|
912 | }
|
913 | } else if (usage[version] >= popularity) {
|
914 | result.push(version)
|
915 | }
|
916 | return result
|
917 | }, [])
|
918 | }
|
919 | },
|
920 | {
|
921 | regexp: /^cover\s+(\d+|\d+\.\d+|\.\d+)%$/,
|
922 | select: coverQuery
|
923 | },
|
924 | {
|
925 | regexp: /^cover\s+(\d+|\d+\.\d+|\.\d+)%\s+in\s+(my\s+stats|(alt-)?\w\w)$/,
|
926 | select: coverQuery
|
927 | },
|
928 | {
|
929 | regexp: /^supports\s+([\w-]+)$/,
|
930 | select: function (context, feature) {
|
931 | env.loadFeature(browserslist.cache, feature)
|
932 | var features = browserslist.cache[feature]
|
933 | return Object.keys(features).reduce(function (result, version) {
|
934 | var flags = features[version]
|
935 | if (flags.indexOf('y') >= 0 || flags.indexOf('a') >= 0) {
|
936 | result.push(version)
|
937 | }
|
938 | return result
|
939 | }, [])
|
940 | }
|
941 | },
|
942 | {
|
943 | regexp: /^electron\s+([\d.]+)\s*-\s*([\d.]+)$/i,
|
944 | select: function (context, from, to) {
|
945 | var fromToUse = normalizeElectron(from)
|
946 | var toToUse = normalizeElectron(to)
|
947 | if (!e2c[fromToUse]) {
|
948 | throw new BrowserslistError('Unknown version ' + from + ' of electron')
|
949 | }
|
950 | if (!e2c[toToUse]) {
|
951 | throw new BrowserslistError('Unknown version ' + to + ' of electron')
|
952 | }
|
953 | from = parseFloat(from)
|
954 | to = parseFloat(to)
|
955 | return Object.keys(e2c)
|
956 | .filter(function (i) {
|
957 | var parsed = parseFloat(i)
|
958 | return parsed >= from && parsed <= to
|
959 | })
|
960 | .map(function (i) {
|
961 | return 'chrome ' + e2c[i]
|
962 | })
|
963 | }
|
964 | },
|
965 | {
|
966 | regexp: /^node\s+([\d.]+)\s*-\s*([\d.]+)$/i,
|
967 | select: function (context, from, to) {
|
968 | var nodeVersions = jsReleases
|
969 | .filter(function (i) {
|
970 | return i.name === 'nodejs'
|
971 | })
|
972 | .map(function (i) {
|
973 | return i.version
|
974 | })
|
975 | return nodeVersions
|
976 | .filter(semverFilterLoose('>=', from))
|
977 | .filter(semverFilterLoose('<=', to))
|
978 | .map(function (v) {
|
979 | return 'node ' + v
|
980 | })
|
981 | }
|
982 | },
|
983 | {
|
984 | regexp: /^(\w+)\s+([\d.]+)\s*-\s*([\d.]+)$/i,
|
985 | select: function (context, name, from, to) {
|
986 | var data = checkName(name, context)
|
987 | from = parseFloat(normalizeVersion(data, from) || from)
|
988 | to = parseFloat(normalizeVersion(data, to) || to)
|
989 | function filter (v) {
|
990 | var parsed = parseFloat(v)
|
991 | return parsed >= from && parsed <= to
|
992 | }
|
993 | return data.released.filter(filter).map(nameMapper(data.name))
|
994 | }
|
995 | },
|
996 | {
|
997 | regexp: /^electron\s*(>=?|<=?)\s*([\d.]+)$/i,
|
998 | select: function (context, sign, version) {
|
999 | var versionToUse = normalizeElectron(version)
|
1000 | return Object.keys(e2c)
|
1001 | .filter(generateFilter(sign, versionToUse))
|
1002 | .map(function (i) {
|
1003 | return 'chrome ' + e2c[i]
|
1004 | })
|
1005 | }
|
1006 | },
|
1007 | {
|
1008 | regexp: /^node\s*(>=?|<=?)\s*([\d.]+)$/i,
|
1009 | select: function (context, sign, version) {
|
1010 | var nodeVersions = jsReleases
|
1011 | .filter(function (i) {
|
1012 | return i.name === 'nodejs'
|
1013 | })
|
1014 | .map(function (i) {
|
1015 | return i.version
|
1016 | })
|
1017 | return nodeVersions
|
1018 | .filter(generateSemverFilter(sign, version))
|
1019 | .map(function (v) {
|
1020 | return 'node ' + v
|
1021 | })
|
1022 | }
|
1023 | },
|
1024 | {
|
1025 | regexp: /^(\w+)\s*(>=?|<=?)\s*([\d.]+)$/,
|
1026 | select: function (context, name, sign, version) {
|
1027 | var data = checkName(name, context)
|
1028 | var alias = browserslist.versionAliases[data.name][version]
|
1029 | if (alias) {
|
1030 | version = alias
|
1031 | }
|
1032 | return data.released
|
1033 | .filter(generateFilter(sign, version))
|
1034 | .map(function (v) {
|
1035 | return data.name + ' ' + v
|
1036 | })
|
1037 | }
|
1038 | },
|
1039 | {
|
1040 | regexp: /^(firefox|ff|fx)\s+esr$/i,
|
1041 | select: function () {
|
1042 | return ['firefox 78']
|
1043 | }
|
1044 | },
|
1045 | {
|
1046 | regexp: /(operamini|op_mini)\s+all/i,
|
1047 | select: function () {
|
1048 | return ['op_mini all']
|
1049 | }
|
1050 | },
|
1051 | {
|
1052 | regexp: /^electron\s+([\d.]+)$/i,
|
1053 | select: function (context, version) {
|
1054 | var versionToUse = normalizeElectron(version)
|
1055 | var chrome = e2c[versionToUse]
|
1056 | if (!chrome) {
|
1057 | throw new BrowserslistError(
|
1058 | 'Unknown version ' + version + ' of electron'
|
1059 | )
|
1060 | }
|
1061 | return ['chrome ' + chrome]
|
1062 | }
|
1063 | },
|
1064 | {
|
1065 | regexp: /^node\s+(\d+)$/i,
|
1066 | select: nodeQuery
|
1067 | },
|
1068 | {
|
1069 | regexp: /^node\s+(\d+\.\d+)$/i,
|
1070 | select: nodeQuery
|
1071 | },
|
1072 | {
|
1073 | regexp: /^node\s+(\d+\.\d+\.\d+)$/i,
|
1074 | select: nodeQuery
|
1075 | },
|
1076 | {
|
1077 | regexp: /^current\s+node$/i,
|
1078 | select: function (context) {
|
1079 | return [env.currentNode(resolve, context)]
|
1080 | }
|
1081 | },
|
1082 | {
|
1083 | regexp: /^maintained\s+node\s+versions$/i,
|
1084 | select: function (context) {
|
1085 | var now = Date.now()
|
1086 | var queries = Object.keys(jsEOL)
|
1087 | .filter(function (key) {
|
1088 | return (
|
1089 | now < Date.parse(jsEOL[key].end) &&
|
1090 | now > Date.parse(jsEOL[key].start) &&
|
1091 | isEolReleased(key)
|
1092 | )
|
1093 | })
|
1094 | .map(function (key) {
|
1095 | return 'node ' + key.slice(1)
|
1096 | })
|
1097 | return resolve(queries, context)
|
1098 | }
|
1099 | },
|
1100 | {
|
1101 | regexp: /^phantomjs\s+1.9$/i,
|
1102 | select: function () {
|
1103 | return ['safari 5']
|
1104 | }
|
1105 | },
|
1106 | {
|
1107 | regexp: /^phantomjs\s+2.1$/i,
|
1108 | select: function () {
|
1109 | return ['safari 6']
|
1110 | }
|
1111 | },
|
1112 | {
|
1113 | regexp: /^(\w+)\s+(tp|[\d.]+)$/i,
|
1114 | select: function (context, name, version) {
|
1115 | if (/^tp$/i.test(version)) version = 'TP'
|
1116 | var data = checkName(name, context)
|
1117 | var alias = normalizeVersion(data, version)
|
1118 | if (alias) {
|
1119 | version = alias
|
1120 | } else {
|
1121 | if (version.indexOf('.') === -1) {
|
1122 | alias = version + '.0'
|
1123 | } else {
|
1124 | alias = version.replace(/\.0$/, '')
|
1125 | }
|
1126 | alias = normalizeVersion(data, alias)
|
1127 | if (alias) {
|
1128 | version = alias
|
1129 | } else if (context.ignoreUnknownVersions) {
|
1130 | return []
|
1131 | } else {
|
1132 | throw new BrowserslistError(
|
1133 | 'Unknown version ' + version + ' of ' + name
|
1134 | )
|
1135 | }
|
1136 | }
|
1137 | return [data.name + ' ' + version]
|
1138 | }
|
1139 | },
|
1140 | {
|
1141 | regexp: /^browserslist config$/i,
|
1142 | select: function (context) {
|
1143 | return browserslist(undefined, context)
|
1144 | }
|
1145 | },
|
1146 | {
|
1147 | regexp: /^extends (.+)$/i,
|
1148 | select: function (context, name) {
|
1149 | return resolve(env.loadQueries(context, name), context)
|
1150 | }
|
1151 | },
|
1152 | {
|
1153 | regexp: /^defaults$/i,
|
1154 | select: function (context) {
|
1155 | return resolve(browserslist.defaults, context)
|
1156 | }
|
1157 | },
|
1158 | {
|
1159 | regexp: /^dead$/i,
|
1160 | select: function (context) {
|
1161 | var dead = [
|
1162 | 'ie <= 10',
|
1163 | 'ie_mob <= 11',
|
1164 | 'bb <= 10',
|
1165 | 'op_mob <= 12.1',
|
1166 | 'samsung 4'
|
1167 | ]
|
1168 | return resolve(dead, context)
|
1169 | }
|
1170 | },
|
1171 | {
|
1172 | regexp: /^(\w+)$/i,
|
1173 | select: function (context, name) {
|
1174 | if (byName(name, context)) {
|
1175 | throw new BrowserslistError(
|
1176 | 'Specify versions in Browserslist query for browser ' + name
|
1177 | )
|
1178 | } else {
|
1179 | throw unknownQuery(name)
|
1180 | }
|
1181 | }
|
1182 | }
|
1183 | ];
|
1184 |
|
1185 |
|
1186 |
|
1187 | (function () {
|
1188 | for (var name in agents) {
|
1189 | var browser = agents[name]
|
1190 | browserslist.data[name] = {
|
1191 | name: name,
|
1192 | versions: normalize(agents[name].versions),
|
1193 | released: normalize(agents[name].versions.slice(0, -3)),
|
1194 | releaseDate: agents[name].release_date
|
1195 | }
|
1196 | fillUsage(browserslist.usage.global, name, browser.usage_global)
|
1197 |
|
1198 | browserslist.versionAliases[name] = { }
|
1199 | for (var i = 0; i < browser.versions.length; i++) {
|
1200 | var full = browser.versions[i]
|
1201 | if (!full) continue
|
1202 |
|
1203 | if (full.indexOf('-') !== -1) {
|
1204 | var interval = full.split('-')
|
1205 | for (var j = 0; j < interval.length; j++) {
|
1206 | browserslist.versionAliases[name][interval[j]] = full
|
1207 | }
|
1208 | }
|
1209 | }
|
1210 | }
|
1211 |
|
1212 | browserslist.versionAliases.op_mob['59'] = '58'
|
1213 | }())
|
1214 |
|
1215 | module.exports = browserslist
|