browserslist 4.28.5 → 4.28.7

package/index.js

@@ -399,8 +399,17 @@ function checkQueries(queries) {
   }
 }
 
-var cache = {}
-var parseCache = {}
+var CACHE_MAX_ENTRIES = 500
+
+function boundedCacheSet(map, key, value) {
+  if (map.size >= CACHE_MAX_ENTRIES) {
+    map.delete(map.keys().next().value)
+  }
+  map.set(key, value)
+}
+
+var cache = new Map()
+var parseCache = new Map()
 
 function browserslist(queries, opts) {
   opts = prepareOpts(opts)
@@ -432,7 +441,7 @@ function browserslist(queries, opts) {
   }
 
   var cacheKey = JSON.stringify([queries, context])
-  if (cache[cacheKey]) return cache[cacheKey]
+  if (cache.has(cacheKey)) return cache.get(cacheKey)
 
   var result = uniq(resolve(queries, context)).sort(function (name1, name2) {
     name1 = name1.split(' ')
@@ -449,17 +458,17 @@ function browserslist(queries, opts) {
     }
   })
   if (!env.env.BROWSERSLIST_DISABLE_CACHE) {
-    cache[cacheKey] = result
+    boundedCacheSet(cache, cacheKey, result)
   }
   return result
 }
 
 function parseQueries(queries) {
   var cacheKey = JSON.stringify(queries)
-  if (cacheKey in parseCache) return parseCache[cacheKey]
+  if (parseCache.has(cacheKey)) return parseCache.get(cacheKey)
   var result = parseWithoutCache(QUERIES, queries)
   if (!env.env.BROWSERSLIST_DISABLE_CACHE) {
-    parseCache[cacheKey] = result
+    boundedCacheSet(parseCache, cacheKey, result)
   }
   return result
 }
@@ -823,7 +832,7 @@ var QUERIES = {
     //   ...with downstream
     //   ...including kaios
     regexp:
-      /^baseline\s+(?:(\d+)|(newly|widely)\s+available(?:\s+on\s+(\d{4}-\d{2}-\d{2}))?)?(\s+with\s+downstream)?(\s+including\s+kaios)?$/i,
+      /^baseline\s+(?!\s)(?:(\d+)|(newly|widely)\s+(?!\s)available(?:\s+(?!\s)on\s+(?!\s)(\d{4}-\d{2}-\d{2}))?)?(\s+(?!\s)with\s+(?!\s)downstream)?(\s+(?!\s)including\s+(?!\s)kaios)?$/i,
     select: function (context, node) {
       var baselineVersions
       var includeDownstream = !!node.downstream
@@ -1058,10 +1067,8 @@ var QUERIES = {
         throw new BrowserslistError('Unknown version ' + to + ' of electron')
       }
       return Object.keys(e2c)
-        .filter(function (i) {
-          var parsed = parseFloat(i)
-          return parsed >= from && parsed <= to
-        })
+        .filter(semverFilterLoose('>=', node.from))
+        .filter(semverFilterLoose('<=', node.to))
         .map(function (i) {
           return 'chrome ' + e2c[i]
         })

package/node.js

@@ -7,7 +7,8 @@ var BrowserslistError = require('./error')
 
 var IS_SECTION = /^\s*\[(.+)]\s*$/
 var CONFIG_PATTERN = /^browserslist-config-/
-var SCOPED_CONFIG__PATTERN = /@[^/]+(?:\/[^/]+)?\/browserslist-config(?:-|$|\/)/
+var SCOPED_CONFIG__PATTERN =
+  /^@[^/]+(?:\/[^/]+)?\/browserslist-config(?:-|$|\/)/
 var FORMAT =
   'Browserslist config should be a string or an array ' +
   'of strings with browser queries'
@@ -221,12 +222,13 @@ function normalizeStats(data, stats) {
 
   if (typeof stats !== 'object') return undefined
 
-  var normalized = {}
+  var normalized = Object.create(null)
   for (var i in stats) {
     var versions = Object.keys(stats[i])
-    if (versions.length === 1 && data[i] && data[i].versions.length === 1) {
-      var normal = data[i].versions[0]
-      normalized[i] = {}
+    var known = Object.prototype.hasOwnProperty.call(data, i) && data[i]
+    if (versions.length === 1 && known && known.versions.length === 1) {
+      var normal = known.versions[0]
+      normalized[i] = Object.create(null)
       normalized[i][normal] = stats[i][versions[0]]
     } else {
       normalized[i] = stats[i]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "browserslist",
-  "version": "4.28.5",
+  "version": "4.28.7",
   "description": "Share target browsers between different front-end tools, like Autoprefixer, Stylelint and babel-env-preset",
   "keywords": [
     "browsers",
@@ -33,10 +33,10 @@
   },
   "types": "./index.d.ts",
   "dependencies": {
-    "baseline-browser-mapping": "^2.10.42",
-    "caniuse-lite": "^1.0.30001800",
-    "electron-to-chromium": "^1.5.387",
-    "node-releases": "^2.0.50",
+    "baseline-browser-mapping": "^2.10.44",
+    "caniuse-lite": "^1.0.30001806",
+    "electron-to-chromium": "^1.5.393",
+    "node-releases": "^2.0.51",
     "update-browserslist-db": "^1.2.3"
   },
   "engines": {

package/parse.js

@@ -1,21 +1,22 @@
-var AND_REGEXP = /^\s+and\s+(.*)/i
-var OR_REGEXP = /^(?:,\s*|\s+or\s+)(.*)/i
+var SPACE = /\s/
 
 function flatten(array) {
   if (!Array.isArray(array)) return [array]
-  return array.reduce(function (a, b) {
-    return a.concat(flatten(b))
-  }, [])
-}
-
-function find(string, predicate) {
-  for (var max = string.length, n = 1; n <= max; n++) {
-    var parsed = string.substr(-n, n)
-    if (predicate(parsed, n, max)) {
-      return string.slice(0, -n)
+  // Iterative flatten: `reduce`+`concat` copies the accumulator on every step,
+  // which is O(n²) once a query resolves to many nodes.
+  var result = []
+  var stack = [array]
+  while (stack.length) {
+    var item = stack.pop()
+    if (Array.isArray(item)) {
+      for (var i = item.length - 1; i >= 0; i--) {
+        stack.push(item[i])
+      }
+    } else {
+      result.push(item)
     }
   }
-  return ''
+  return result
 }
 
 function matchQuery(all, query) {
@@ -41,27 +42,86 @@ function matchQuery(all, query) {
   return node
 }
 
-function matchBlock(all, string, qs) {
-  var node
-  return find(string, function (parsed, n, max) {
-    if (AND_REGEXP.test(parsed)) {
-      node = matchQuery(all, parsed.match(AND_REGEXP)[1])
-      node.compose = 'and'
-      qs.unshift(node)
-      return true
-    } else if (OR_REGEXP.test(parsed)) {
-      node = matchQuery(all, parsed.match(OR_REGEXP)[1])
-      node.compose = 'or'
-      qs.unshift(node)
-      return true
-    } else if (n === max) {
-      node = matchQuery(all, parsed.trim())
-      node.compose = 'or'
-      qs.unshift(node)
-      return true
+function pushClause(all, qs, text, compose) {
+  var node = matchQuery(all, text.trim())
+  node.compose = compose
+  qs.push(node)
+}
+
+// Splits a query block into clauses on the `\s+and\s+`, `\s+or\s+` and `,\s*`
+// delimiters in a single left-to-right pass. The previous implementation grew
+// a suffix one character at a time and re-tested anchored `\s+…` regexps at
+// every length, which backtracks across whitespace runs and is O(n²) — a
+// small padded query could freeze the event loop for tens of seconds.
+function parseBlock(all, block, qs) {
+  if (block.length === 0) return
+
+  var len = block.length
+  var clauseStart = 0
+  // Compose for the clause currently being read; the leftmost clause is `or`.
+  var compose = 'or'
+  var i = 0
+
+  while (i < len) {
+    var ch = block[i]
+
+    if (ch === ',') {
+      // `,\s*` delimiter. A delimiter at the very start (i === 0) has no left
+      // clause — the original never emits one there.
+      if (i !== 0) pushClause(all, qs, block.slice(clauseStart, i), compose)
+      i++
+      while (i < len && SPACE.test(block[i])) i++
+      compose = 'or'
+      clauseStart = i
+      continue
     }
-    return false
-  })
+
+    if (SPACE.test(ch)) {
+      // Possible `\s+and\s+` or `\s+or\s+`. Scan the whitespace run once
+      // (linear, no backtracking), then check the following keyword.
+      var q = i
+      while (q < len && SPACE.test(block[q])) q++
+
+      if (
+        q + 3 < len &&
+        (block[q] === 'a' || block[q] === 'A') &&
+        (block[q + 1] === 'n' || block[q + 1] === 'N') &&
+        (block[q + 2] === 'd' || block[q + 2] === 'D') &&
+        SPACE.test(block[q + 3])
+      ) {
+        // The leading `\s+` of `\s+and\s+` absorbs whitespace at the block
+        // start, so a delimiter at i === 0 has no left clause.
+        if (i !== 0) pushClause(all, qs, block.slice(clauseStart, i), compose)
+        var afterAnd = q + 3
+        while (afterAnd < len && SPACE.test(block[afterAnd])) afterAnd++
+        compose = 'and'
+        i = afterAnd
+        clauseStart = afterAnd
+        continue
+      } else if (
+        q + 2 < len &&
+        (block[q] === 'o' || block[q] === 'O') &&
+        (block[q + 1] === 'r' || block[q + 1] === 'R') &&
+        SPACE.test(block[q + 2])
+      ) {
+        if (i !== 0) pushClause(all, qs, block.slice(clauseStart, i), compose)
+        var afterOr = q + 2
+        while (afterOr < len && SPACE.test(block[afterOr])) afterOr++
+        compose = 'or'
+        i = afterOr
+        clauseStart = afterOr
+        continue
+      } else {
+        // Whitespace inside a clause; skip the run and keep reading.
+        i = q
+        continue
+      }
+    }
+
+    i++
+  }
+
+  pushClause(all, qs, block.slice(clauseStart), compose)
 }
 
 module.exports = function parse(all, queries) {
@@ -69,9 +129,7 @@ module.exports = function parse(all, queries) {
   return flatten(
     queries.map(function (block) {
       var qs = []
-      do {
-        block = matchBlock(all, block, qs)
-      } while (block)
+      parseBlock(all, block, qs)
       return qs
     })
   )