index.js 34 KB

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