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