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 FLOAT_RANGE = /^\d+(\.\d+)?(-\d+(\.\d+)?)*$/
|
11 |
|
12 | function normalize (versions) {
|
13 | return versions.filter(function (version) {
|
14 | return typeof version === 'string'
|
15 | })
|
16 | }
|
17 |
|
18 | function nameMapper (name) {
|
19 | return function mapName (version) {
|
20 | return name + ' ' + version
|
21 | }
|
22 | }
|
23 |
|
24 | function getMajor (version) {
|
25 | return parseInt(version.split('.')[0])
|
26 | }
|
27 |
|
28 | function getMajorVersions (released, number) {
|
29 | if (released.length === 0) return []
|
30 | var minimum = getMajor(released[released.length - 1]) - parseInt(number) + 1
|
31 | var selected = []
|
32 | for (var i = released.length - 1; i >= 0; i--) {
|
33 | if (minimum > getMajor(released[i])) break
|
34 | selected.unshift(released[i])
|
35 | }
|
36 | return selected
|
37 | }
|
38 |
|
39 | function uniq (array) {
|
40 | var filtered = []
|
41 | for (var i = 0; i < array.length; i++) {
|
42 | if (filtered.indexOf(array[i]) === -1) filtered.push(array[i])
|
43 | }
|
44 | return filtered
|
45 | }
|
46 |
|
47 |
|
48 |
|
49 | function fillUsage (result, name, data) {
|
50 | for (var i in data) {
|
51 | result[name + ' ' + i] = data[i]
|
52 | }
|
53 | }
|
54 |
|
55 | function generateFilter (sign, version) {
|
56 | version = parseFloat(version)
|
57 | if (sign === '>') {
|
58 | return function (v) {
|
59 | return parseFloat(v) > version
|
60 | }
|
61 | } else if (sign === '>=') {
|
62 | return function (v) {
|
63 | return parseFloat(v) >= version
|
64 | }
|
65 | } else if (sign === '<') {
|
66 | return function (v) {
|
67 | return parseFloat(v) < version
|
68 | }
|
69 | } else {
|
70 | return function (v) {
|
71 | return parseFloat(v) <= version
|
72 | }
|
73 | }
|
74 | }
|
75 |
|
76 | function compareStrings (a, b) {
|
77 | if (a < b) return -1
|
78 | if (a > b) return +1
|
79 | return 0
|
80 | }
|
81 |
|
82 | function normalizeVersion (data, version) {
|
83 | if (data.versions.indexOf(version) !== -1) {
|
84 | return version
|
85 | } else if (browserslist.versionAliases[data.name][version]) {
|
86 | return browserslist.versionAliases[data.name][version]
|
87 | } else if (data.versions.length === 1) {
|
88 | return data.versions[0]
|
89 | } else {
|
90 | return false
|
91 | }
|
92 | }
|
93 |
|
94 | function filterByYear (since) {
|
95 | return Object.keys(agents).reduce(function (selected, name) {
|
96 | var data = byName(name)
|
97 | if (!data) return selected
|
98 | var versions = Object.keys(data.releaseDate).filter(function (v) {
|
99 | return data.releaseDate[v] >= since
|
100 | })
|
101 | return selected.concat(versions.map(nameMapper(data.name)))
|
102 | }, [])
|
103 | }
|
104 |
|
105 | function byName (name) {
|
106 | name = name.toLowerCase()
|
107 | name = browserslist.aliases[name] || name
|
108 | return browserslist.data[name]
|
109 | }
|
110 |
|
111 | function checkName (name) {
|
112 | var data = byName(name)
|
113 | if (!data) throw new BrowserslistError('Unknown browser ' + name)
|
114 | return data
|
115 | }
|
116 |
|
117 | function unknownQuery (query) {
|
118 | return new BrowserslistError('Unknown browser query `' + query + '`')
|
119 | }
|
120 |
|
121 | function resolve (queries, context) {
|
122 | return queries.reduce(function (result, selection, index) {
|
123 | selection = selection.trim()
|
124 | if (selection === '') return result
|
125 |
|
126 | var isExclude = selection.indexOf('not ') === 0
|
127 | if (isExclude) {
|
128 | if (index === 0) {
|
129 | throw new BrowserslistError(
|
130 | 'Write any browsers query (for instance, `defaults`) ' +
|
131 | 'before `' + selection + '`')
|
132 | }
|
133 | selection = selection.slice(4)
|
134 | }
|
135 |
|
136 | for (var i = 0; i < QUERIES.length; i++) {
|
137 | var type = QUERIES[i]
|
138 | var match = selection.match(type.regexp)
|
139 | if (match) {
|
140 | var args = [context].concat(match.slice(1))
|
141 | var array = type.select.apply(browserslist, args)
|
142 | if (isExclude) {
|
143 | array = array.concat(array.map(function (j) {
|
144 | return j.replace(/\s\S+/, ' 0')
|
145 | }))
|
146 | return result.filter(function (j) {
|
147 | return array.indexOf(j) === -1
|
148 | })
|
149 | }
|
150 | return result.concat(array)
|
151 | }
|
152 | }
|
153 |
|
154 | throw unknownQuery(selection)
|
155 | }, [])
|
156 | }
|
157 |
|
158 |
|
159 |
|
160 |
|
161 |
|
162 |
|
163 |
|
164 |
|
165 |
|
166 |
|
167 |
|
168 |
|
169 |
|
170 |
|
171 |
|
172 |
|
173 |
|
174 |
|
175 |
|
176 |
|
177 |
|
178 |
|
179 |
|
180 | function browserslist (queries, opts) {
|
181 | if (typeof opts === 'undefined') opts = { }
|
182 |
|
183 | if (typeof opts.path === 'undefined') {
|
184 | opts.path = path.resolve ? path.resolve('.') : '.'
|
185 | }
|
186 |
|
187 | if (typeof queries === 'undefined' || queries === null) {
|
188 | var config = browserslist.loadConfig(opts)
|
189 | if (config) {
|
190 | queries = config
|
191 | } else {
|
192 | queries = browserslist.defaults
|
193 | }
|
194 | }
|
195 |
|
196 | if (typeof queries === 'string') {
|
197 | queries = queries.split(/,\s*/)
|
198 | }
|
199 |
|
200 | if (!Array.isArray(queries)) {
|
201 | throw new BrowserslistError(
|
202 | 'Browser queries must be an array. Got ' + typeof queries + '.')
|
203 | }
|
204 |
|
205 | var context = {
|
206 | ignoreUnknownVersions: opts.ignoreUnknownVersions,
|
207 | dangerousExtend: opts.dangerousExtend
|
208 | }
|
209 |
|
210 | env.oldDataWarning(browserslist.data)
|
211 | var stats = env.getStat(opts)
|
212 | if (stats) {
|
213 | context.customUsage = { }
|
214 | for (var browser in stats) {
|
215 | fillUsage(context.customUsage, browser, stats[browser])
|
216 | }
|
217 | }
|
218 |
|
219 | var result = resolve(queries, context).map(function (i) {
|
220 | var parts = i.split(' ')
|
221 | var name = parts[0]
|
222 | var version = parts[1]
|
223 | if (version === '0') {
|
224 | return name + ' ' + byName(name).versions[0]
|
225 | } else {
|
226 | return i
|
227 | }
|
228 | }).sort(function (name1, name2) {
|
229 | name1 = name1.split(' ')
|
230 | name2 = name2.split(' ')
|
231 | if (name1[0] === name2[0]) {
|
232 | if (FLOAT_RANGE.test(name1[1]) && FLOAT_RANGE.test(name2[1])) {
|
233 | return parseFloat(name2[1]) - parseFloat(name1[1])
|
234 | } else {
|
235 | return compareStrings(name2[1], name1[1])
|
236 | }
|
237 | } else {
|
238 | return compareStrings(name1[0], name2[0])
|
239 | }
|
240 | })
|
241 |
|
242 | return uniq(result)
|
243 | }
|
244 |
|
245 |
|
246 | browserslist.data = { }
|
247 | browserslist.usage = {
|
248 | global: { },
|
249 | custom: null
|
250 | }
|
251 |
|
252 |
|
253 | browserslist.defaults = [
|
254 | '> 0.5%',
|
255 | 'last 2 versions',
|
256 | 'Firefox ESR',
|
257 | 'not dead'
|
258 | ]
|
259 |
|
260 |
|
261 | browserslist.aliases = {
|
262 | fx: 'firefox',
|
263 | ff: 'firefox',
|
264 | ios: 'ios_saf',
|
265 | explorer: 'ie',
|
266 | blackberry: 'bb',
|
267 | explorermobile: 'ie_mob',
|
268 | operamini: 'op_mini',
|
269 | operamobile: 'op_mob',
|
270 | chromeandroid: 'and_chr',
|
271 | firefoxandroid: 'and_ff',
|
272 | ucandroid: 'and_uc',
|
273 | qqandroid: 'and_qq'
|
274 | }
|
275 |
|
276 |
|
277 | browserslist.versionAliases = { }
|
278 |
|
279 | browserslist.clearCaches = env.clearCaches
|
280 | browserslist.parseConfig = env.parseConfig
|
281 | browserslist.readConfig = env.readConfig
|
282 | browserslist.findConfig = env.findConfig
|
283 | browserslist.loadConfig = env.loadConfig
|
284 |
|
285 |
|
286 |
|
287 |
|
288 |
|
289 |
|
290 |
|
291 |
|
292 |
|
293 |
|
294 |
|
295 |
|
296 |
|
297 |
|
298 |
|
299 | browserslist.coverage = function (browsers, stats) {
|
300 | var data
|
301 | if (typeof stats === 'undefined') {
|
302 | data = browserslist.usage.global
|
303 | } else if (stats === 'my stats') {
|
304 | var opts = {}
|
305 | opts.path = path.resolve ? path.resolve('.') : '.'
|
306 | var customStats = env.getStat(opts)
|
307 | if (!customStats) {
|
308 | throw new BrowserslistError('Custom usage statistics was not provided')
|
309 | }
|
310 | data = {}
|
311 | for (var browser in customStats) {
|
312 | fillUsage(data, browser, customStats[browser])
|
313 | }
|
314 | } else if (typeof stats === 'string') {
|
315 | if (stats.length > 2) {
|
316 | stats = stats.toLowerCase()
|
317 | } else {
|
318 | stats = stats.toUpperCase()
|
319 | }
|
320 | env.loadCountry(browserslist.usage, stats)
|
321 | data = browserslist.usage[stats]
|
322 | } else {
|
323 | if ('dataByBrowser' in stats) {
|
324 | stats = stats.dataByBrowser
|
325 | }
|
326 | data = { }
|
327 | for (var name in stats) {
|
328 | for (var version in stats[name]) {
|
329 | data[name + ' ' + version] = stats[name][version]
|
330 | }
|
331 | }
|
332 | }
|
333 |
|
334 | return browsers.reduce(function (all, i) {
|
335 | var usage = data[i]
|
336 | if (usage === undefined) {
|
337 | usage = data[i.replace(/ \S+$/, ' 0')]
|
338 | }
|
339 | return all + (usage || 0)
|
340 | }, 0)
|
341 | }
|
342 |
|
343 | var QUERIES = [
|
344 | {
|
345 | regexp: /^last\s+(\d+)\s+major versions?$/i,
|
346 | select: function (context, versions) {
|
347 | return Object.keys(agents).reduce(function (selected, name) {
|
348 | var data = byName(name)
|
349 | if (!data) return selected
|
350 | var array = getMajorVersions(data.released, versions)
|
351 |
|
352 | array = array.map(nameMapper(data.name))
|
353 | return selected.concat(array)
|
354 | }, [])
|
355 | }
|
356 | },
|
357 | {
|
358 | regexp: /^last\s+(\d+)\s+versions?$/i,
|
359 | select: function (context, versions) {
|
360 | return Object.keys(agents).reduce(function (selected, name) {
|
361 | var data = byName(name)
|
362 | if (!data) return selected
|
363 | var array = data.released.slice(-versions)
|
364 |
|
365 | array = array.map(nameMapper(data.name))
|
366 | return selected.concat(array)
|
367 | }, [])
|
368 | }
|
369 | },
|
370 | {
|
371 | regexp: /^last\s+(\d+)\s+electron\s+major versions?$/i,
|
372 | select: function (context, versions) {
|
373 | var validVersions = getMajorVersions(Object.keys(e2c).reverse(), versions)
|
374 | return validVersions.map(function (i) {
|
375 | return 'chrome ' + e2c[i]
|
376 | })
|
377 | }
|
378 | },
|
379 | {
|
380 | regexp: /^last\s+(\d+)\s+(\w+)\s+major versions?$/i,
|
381 | select: function (context, versions, name) {
|
382 | var data = checkName(name)
|
383 | var validVersions = getMajorVersions(data.released, versions)
|
384 | return validVersions.map(nameMapper(data.name))
|
385 | }
|
386 | },
|
387 | {
|
388 | regexp: /^last\s+(\d+)\s+electron\s+versions?$/i,
|
389 | select: function (context, versions) {
|
390 | return Object.keys(e2c).reverse().slice(-versions).map(function (i) {
|
391 | return 'chrome ' + e2c[i]
|
392 | })
|
393 | }
|
394 | },
|
395 | {
|
396 | regexp: /^last\s+(\d+)\s+(\w+)\s+versions?$/i,
|
397 | select: function (context, versions, name) {
|
398 | var data = checkName(name)
|
399 | return data.released.slice(-versions).map(nameMapper(data.name))
|
400 | }
|
401 | },
|
402 | {
|
403 | regexp: /^unreleased\s+versions$/i,
|
404 | select: function () {
|
405 | return Object.keys(agents).reduce(function (selected, name) {
|
406 | var data = byName(name)
|
407 | if (!data) return selected
|
408 | var array = data.versions.filter(function (v) {
|
409 | return data.released.indexOf(v) === -1
|
410 | })
|
411 |
|
412 | array = array.map(nameMapper(data.name))
|
413 | return selected.concat(array)
|
414 | }, [])
|
415 | }
|
416 | },
|
417 | {
|
418 | regexp: /^unreleased\s+electron\s+versions?$/i,
|
419 | select: function () {
|
420 | return []
|
421 | }
|
422 | },
|
423 | {
|
424 | regexp: /^unreleased\s+(\w+)\s+versions?$/i,
|
425 | select: function (context, name) {
|
426 | var data = checkName(name)
|
427 | return data.versions.filter(function (v) {
|
428 | return data.released.indexOf(v) === -1
|
429 | }).map(nameMapper(data.name))
|
430 | }
|
431 | },
|
432 | {
|
433 | regexp: /^last\s+(\d+)\s+years?$/i,
|
434 | select: function (context, years) {
|
435 | var date = new Date()
|
436 | var since = date.setFullYear(date.getFullYear() - years) / 1000
|
437 |
|
438 | return filterByYear(since)
|
439 | }
|
440 | },
|
441 | {
|
442 | regexp: /^since (\d+)(?:-(\d+))?(?:-(\d+))?$/i,
|
443 | select: function (context, year, month, date) {
|
444 | year = parseInt(year)
|
445 | month = parseInt(month || '01') - 1
|
446 | date = parseInt(date || '01')
|
447 | var since = Date.UTC(year, month, date, 0, 0, 0) / 1000
|
448 |
|
449 | return filterByYear(since)
|
450 | }
|
451 | },
|
452 | {
|
453 | regexp: /^(>=?|<=?)\s*(\d*\.?\d+)%$/,
|
454 | select: function (context, sign, popularity) {
|
455 | popularity = parseFloat(popularity)
|
456 | var usage = browserslist.usage.global
|
457 |
|
458 | return Object.keys(usage).reduce(function (result, version) {
|
459 | if (sign === '>') {
|
460 | if (usage[version] > popularity) {
|
461 | result.push(version)
|
462 | }
|
463 | } else if (sign === '<') {
|
464 | if (usage[version] < popularity) {
|
465 | result.push(version)
|
466 | }
|
467 | } else if (sign === '<=') {
|
468 | if (usage[version] <= popularity) {
|
469 | result.push(version)
|
470 | }
|
471 | } else if (usage[version] >= popularity) {
|
472 | result.push(version)
|
473 | }
|
474 | return result
|
475 | }, [])
|
476 | }
|
477 | },
|
478 | {
|
479 | regexp: /^(>=?|<=?)\s*(\d*\.?\d+)%\s+in\s+my\s+stats$/,
|
480 | select: function (context, sign, popularity) {
|
481 | popularity = parseFloat(popularity)
|
482 |
|
483 | if (!context.customUsage) {
|
484 | throw new BrowserslistError('Custom usage statistics was not provided')
|
485 | }
|
486 |
|
487 | var usage = context.customUsage
|
488 |
|
489 | return Object.keys(usage).reduce(function (result, version) {
|
490 | if (sign === '>') {
|
491 | if (usage[version] > popularity) {
|
492 | result.push(version)
|
493 | }
|
494 | } else if (sign === '<') {
|
495 | if (usage[version] < popularity) {
|
496 | result.push(version)
|
497 | }
|
498 | } else if (sign === '<=') {
|
499 | if (usage[version] <= popularity) {
|
500 | result.push(version)
|
501 | }
|
502 | } else if (usage[version] >= popularity) {
|
503 | result.push(version)
|
504 | }
|
505 | return result
|
506 | }, [])
|
507 | }
|
508 | },
|
509 | {
|
510 | regexp: /^(>=?|<=?)\s*(\d*\.?\d+)%\s+in\s+((alt-)?\w\w)$/,
|
511 | select: function (context, sign, popularity, place) {
|
512 | popularity = parseFloat(popularity)
|
513 |
|
514 | if (place.length === 2) {
|
515 | place = place.toUpperCase()
|
516 | } else {
|
517 | place = place.toLowerCase()
|
518 | }
|
519 |
|
520 | env.loadCountry(browserslist.usage, place)
|
521 | var usage = browserslist.usage[place]
|
522 |
|
523 | return Object.keys(usage).reduce(function (result, version) {
|
524 | if (sign === '>') {
|
525 | if (usage[version] > popularity) {
|
526 | result.push(version)
|
527 | }
|
528 | } else if (sign === '<') {
|
529 | if (usage[version] < popularity) {
|
530 | result.push(version)
|
531 | }
|
532 | } else if (sign === '<=') {
|
533 | if (usage[version] <= popularity) {
|
534 | result.push(version)
|
535 | }
|
536 | } else if (usage[version] >= popularity) {
|
537 | result.push(version)
|
538 | }
|
539 | return result
|
540 | }, [])
|
541 | }
|
542 | },
|
543 | {
|
544 | regexp: /^cover\s+(\d*\.?\d+)%(\s+in\s+(my\s+stats|(alt-)?\w\w))?$/,
|
545 | select: function (context, coverage, statMode) {
|
546 | coverage = parseFloat(coverage)
|
547 |
|
548 | var usage = browserslist.usage.global
|
549 | if (statMode) {
|
550 | if (statMode.match(/^\s+in\s+my\s+stats$/)) {
|
551 | if (!context.customUsage) {
|
552 | throw new BrowserslistError(
|
553 | 'Custom usage statistics was not provided'
|
554 | )
|
555 | }
|
556 | usage = context.customUsage
|
557 | } else {
|
558 | var match = statMode.match(/\s+in\s+((alt-)?\w\w)/)
|
559 | var place = match[1]
|
560 | if (place.length === 2) {
|
561 | place = place.toUpperCase()
|
562 | } else {
|
563 | place = place.toLowerCase()
|
564 | }
|
565 | env.loadCountry(browserslist.usage, place)
|
566 | usage = browserslist.usage[place]
|
567 | }
|
568 | }
|
569 |
|
570 | var versions = Object.keys(usage).sort(function (a, b) {
|
571 | return usage[b] - usage[a]
|
572 | })
|
573 |
|
574 | var coveraged = 0
|
575 | var result = []
|
576 | var version
|
577 | for (var i = 0; i <= versions.length; i++) {
|
578 | version = versions[i]
|
579 | if (usage[version] === 0) break
|
580 |
|
581 | coveraged += usage[version]
|
582 | result.push(version)
|
583 | if (coveraged >= coverage) break
|
584 | }
|
585 |
|
586 | return result
|
587 | }
|
588 | },
|
589 | {
|
590 | regexp: /^electron\s+([\d.]+)\s*-\s*([\d.]+)$/i,
|
591 | select: function (context, from, to) {
|
592 | if (!e2c[from]) {
|
593 | throw new BrowserslistError('Unknown version ' + from + ' of electron')
|
594 | }
|
595 | if (!e2c[to]) {
|
596 | throw new BrowserslistError('Unknown version ' + to + ' of electron')
|
597 | }
|
598 |
|
599 | from = parseFloat(from)
|
600 | to = parseFloat(to)
|
601 |
|
602 | return Object.keys(e2c).filter(function (i) {
|
603 | var parsed = parseFloat(i)
|
604 | return parsed >= from && parsed <= to
|
605 | }).map(function (i) {
|
606 | return 'chrome ' + e2c[i]
|
607 | })
|
608 | }
|
609 | },
|
610 | {
|
611 | regexp: /^(\w+)\s+([\d.]+)\s*-\s*([\d.]+)$/i,
|
612 | select: function (context, name, from, to) {
|
613 | var data = checkName(name)
|
614 | from = parseFloat(normalizeVersion(data, from) || from)
|
615 | to = parseFloat(normalizeVersion(data, to) || to)
|
616 |
|
617 | function filter (v) {
|
618 | var parsed = parseFloat(v)
|
619 | return parsed >= from && parsed <= to
|
620 | }
|
621 |
|
622 | return data.released.filter(filter).map(nameMapper(data.name))
|
623 | }
|
624 | },
|
625 | {
|
626 | regexp: /^electron\s*(>=?|<=?)\s*([\d.]+)$/i,
|
627 | select: function (context, sign, version) {
|
628 | return Object.keys(e2c)
|
629 | .filter(generateFilter(sign, version))
|
630 | .map(function (i) {
|
631 | return 'chrome ' + e2c[i]
|
632 | })
|
633 | }
|
634 | },
|
635 | {
|
636 | regexp: /^(\w+)\s*(>=?|<=?)\s*([\d.]+)$/,
|
637 | select: function (context, name, sign, version) {
|
638 | var data = checkName(name)
|
639 | var alias = browserslist.versionAliases[data.name][version]
|
640 | if (alias) {
|
641 | version = alias
|
642 | }
|
643 | return data.released
|
644 | .filter(generateFilter(sign, version))
|
645 | .map(function (v) {
|
646 | return data.name + ' ' + v
|
647 | })
|
648 | }
|
649 | },
|
650 | {
|
651 | regexp: /^(firefox|ff|fx)\s+esr$/i,
|
652 | select: function () {
|
653 | return ['firefox 52', 'firefox 60']
|
654 | }
|
655 | },
|
656 | {
|
657 | regexp: /(operamini|op_mini)\s+all/i,
|
658 | select: function () {
|
659 | return ['op_mini all']
|
660 | }
|
661 | },
|
662 | {
|
663 | regexp: /^electron\s+([\d.]+)$/i,
|
664 | select: function (context, version) {
|
665 | var chrome = e2c[version]
|
666 | if (!chrome) {
|
667 | throw new BrowserslistError(
|
668 | 'Unknown version ' + version + ' of electron')
|
669 | }
|
670 | return ['chrome ' + chrome]
|
671 | }
|
672 | },
|
673 | {
|
674 | regexp: /^node\s+(\d+(\.\d+)?(\.\d+)?)$/i,
|
675 | select: function (context, version) {
|
676 | var nodeReleases = jsReleases.filter(function (i) {
|
677 | return i.name === 'nodejs'
|
678 | })
|
679 | var matched = nodeReleases.filter(function (i) {
|
680 | return (i.version + '.').indexOf(version + '.') === 0
|
681 | })
|
682 | if (matched.length === 0) {
|
683 | if (context.ignoreUnknownVersions) {
|
684 | return []
|
685 | } else {
|
686 | throw new BrowserslistError(
|
687 | 'Unknown version ' + version + ' of Node.js')
|
688 | }
|
689 | }
|
690 | return ['node ' + matched[matched.length - 1].version]
|
691 | }
|
692 | },
|
693 | {
|
694 | regexp: /^maintained\s+node\s+versions$/i,
|
695 | select: function (context) {
|
696 | var now = Date.now()
|
697 | var queries = Object.keys(jsEOL).filter(function (key) {
|
698 | return now < Date.parse(jsEOL[key].end)
|
699 | }).map(function (key) {
|
700 | return 'node ' + key.slice(1)
|
701 | })
|
702 | return resolve(queries, context)
|
703 | }
|
704 | },
|
705 | {
|
706 | regexp: /^(\w+)\s+(tp|[\d.]+)$/i,
|
707 | select: function (context, name, version) {
|
708 | if (/^tp$/i.test(version)) version = 'TP'
|
709 | var data = checkName(name)
|
710 | var alias = normalizeVersion(data, version)
|
711 | if (alias) {
|
712 | version = alias
|
713 | } else {
|
714 | if (version.indexOf('.') === -1) {
|
715 | alias = version + '.0'
|
716 | } else {
|
717 | alias = version.replace(/\.0$/, '')
|
718 | }
|
719 | alias = normalizeVersion(data, alias)
|
720 | if (alias) {
|
721 | version = alias
|
722 | } else if (context.ignoreUnknownVersions) {
|
723 | return []
|
724 | } else {
|
725 | throw new BrowserslistError(
|
726 | 'Unknown version ' + version + ' of ' + name)
|
727 | }
|
728 | }
|
729 | return [data.name + ' ' + version]
|
730 | }
|
731 | },
|
732 | {
|
733 | regexp: /^extends (.+)$/i,
|
734 | select: function (context, name) {
|
735 | return resolve(env.loadQueries(context, name), context)
|
736 | }
|
737 | },
|
738 | {
|
739 | regexp: /^defaults$/i,
|
740 | select: function () {
|
741 | return browserslist(browserslist.defaults)
|
742 | }
|
743 | },
|
744 | {
|
745 | regexp: /^dead$/i,
|
746 | select: function (context) {
|
747 | var dead = ['ie <= 10', 'ie_mob <= 10', 'bb <= 10', 'op_mob <= 12.1']
|
748 | return resolve(dead, context)
|
749 | }
|
750 | },
|
751 | {
|
752 | regexp: /^(\w+)$/i,
|
753 | select: function (context, name) {
|
754 | if (byName(name)) {
|
755 | throw new BrowserslistError(
|
756 | 'Specify versions in Browserslist query for browser ' + name)
|
757 | } else {
|
758 | throw unknownQuery(name)
|
759 | }
|
760 | }
|
761 | }
|
762 | ];
|
763 |
|
764 |
|
765 |
|
766 | (function () {
|
767 | for (var name in agents) {
|
768 | var browser = agents[name]
|
769 | browserslist.data[name] = {
|
770 | name: name,
|
771 | versions: normalize(agents[name].versions),
|
772 | released: normalize(agents[name].versions.slice(0, -3)),
|
773 | releaseDate: agents[name].release_date
|
774 | }
|
775 | fillUsage(browserslist.usage.global, name, browser.usage_global)
|
776 |
|
777 | browserslist.versionAliases[name] = { }
|
778 | for (var i = 0; i < browser.versions.length; i++) {
|
779 | var full = browser.versions[i]
|
780 | if (!full) continue
|
781 |
|
782 | if (full.indexOf('-') !== -1) {
|
783 | var interval = full.split('-')
|
784 | for (var j = 0; j < interval.length; j++) {
|
785 | browserslist.versionAliases[name][interval[j]] = full
|
786 | }
|
787 | }
|
788 | }
|
789 | }
|
790 | }())
|
791 |
|
792 | module.exports = browserslist
|