tiny perf bits (#386)

```
# before

19097  analyzer.cjs
90945  analyzer.cjs.map
17440  analyzer.modern.js
90485  analyzer.modern.js.map
18871  analyzer.module.js
90985  analyzer.module.js.map
19071  analyzer.umd.js
91146  analyzer.umd.js.map
27391  index.d.ts

# after 

19021  analyzer.cjs
90418  analyzer.cjs.map
17338  analyzer.modern.js
89870  analyzer.modern.js.map
18795  analyzer.module.js
90458  analyzer.module.js.map
18975  analyzer.umd.js
90628  analyzer.umd.js.map
27391  index.d.ts

```

---------

Co-authored-by: Bart Veneman <bart.veneman@drukwerkdeal.nl>

Author: bartveneman

src/atrules/atrules.js

@@ -68,27 +68,26 @@ export function isMediaBrowserhack(prelude) {
         returnValue = true
         return this.break
       }
-    }
-    if (node.type === MediaFeature) {
+    } else if (node.type === MediaFeature) {
       if (value !== null && value.unit === '\\0') {
         returnValue = true
         return this.break
       }
-      if (strEquals('-moz-images-in-menus', name)
+      else if (strEquals('-moz-images-in-menus', name)
         || strEquals('min--moz-device-pixel-ratio', name)
         || strEquals('-ms-high-contrast', name)
       ) {
         returnValue = true
         return this.break
       }
-      if (strEquals('min-resolution', name)
+      else if (strEquals('min-resolution', name)
         && strEquals('.001', value.value)
         && strEquals('dpcm', value.unit)
       ) {
         returnValue = true
         return this.break
       }
-      if (strEquals('-webkit-min-device-pixel-ratio', name)) {
+      else if (strEquals('-webkit-min-device-pixel-ratio', name)) {
         let val = value.value
         if ((strEquals('0', val) || strEquals('10000', val))) {
           returnValue = true

src/collection.js

@@ -78,7 +78,7 @@ export class Collection {
 
 		items.forEach((list, key) => {
 			if (useLocations) {
-				let nodes = list.map(index => {
+				let nodes = list.map(function (index) {
 					let position = index * 4
 					/** @type {CssLocation} */
 					return {
@@ -89,8 +89,9 @@ export class Collection {
 					}
 				})
 				uniqueWithLocations.set(key, nodes)
+			} else {
+				unique[key] = list.length
 			}
-			unique[key] = list.length
 		})
 
 		let total = this._total

src/index.js

@@ -73,7 +73,7 @@ export function analyze(css, options = {}) {
   // Stylesheet
   let totalComments = 0
   let commentsSize = 0
-  let embeds = new Collection(useLocations)
+  let embeds = new Collection(false)
   let embedSize = 0
   let embedTypes = {
     total: 0,

src/properties/property-utils.js

@@ -11,9 +11,9 @@ export function isHack(property) {
   let code = property.charCodeAt(0)
 
   return code === 47 // /
+    || code === 42 // *
     || code === 95 // _
     || code === 43 // +
-    || code === 42 // *
     || code === 38 // &
     || code === 36 // $
     || code === 35 // #

src/selectors/utils.js

@@ -2,6 +2,7 @@
 import walk from 'css-tree/walker'
 import { startsWith, strEquals } from '../string-utils.js'
 import { hasVendorPrefix } from '../vendor-prefix.js'
+import { KeywordSet } from '../keyword-set.js'
 import {
   PseudoClassSelector,
   PseudoElementSelector,
@@ -29,20 +30,17 @@ function analyzeList(selectorListAst, cb) {
   return childSelectors
 }
 
-/** @param {string} name */
-function isPseudoFunction(name) {
-  return (
-    strEquals(name, 'not')
-    || strEquals(name, 'nth-child')
-    || strEquals(name, 'nth-last-child')
-    || strEquals(name, 'where')
-    || strEquals(name, 'is')
-    || strEquals(name, 'has')
-    || strEquals(name, 'matches')
-    || strEquals(name, '-webkit-any')
-    || strEquals(name, '-moz-any')
-  )
-}
+const PSEUDO_FUNCTIONS = new KeywordSet([
+  'nth-child',
+  'where',
+  'not',
+  'is',
+  'has',
+  'nth-last-child',
+  'matches',
+  '-webkit-any',
+  '-moz-any',
+])
 
 /** @param {import('css-tree').Selector} selector */
 export function isAccessibility(selector) {
@@ -57,17 +55,17 @@ export function isAccessibility(selector) {
       }
     }
     // Test for [aria-] or [role] inside :is()/:where() and friends
-    else if (node.type === PseudoClassSelector) {
-      if (isPseudoFunction(node.name)) {
-        let list = analyzeList(node, isAccessibility)
+    else if (node.type === PseudoClassSelector && PSEUDO_FUNCTIONS.has(node.name)) {
+      let list = analyzeList(node, isAccessibility)
 
-        if (list.some(b => b === true)) {
+      for (let c of list) {
+        if (c === true) {
           isA11y = true
-          return this.skip
+          break
         }
-
-        return this.skip
       }
+
+      return this.skip
     }
   })
 
@@ -82,15 +80,17 @@ export function isPrefixed(selector) {
   let isPrefixed = false
 
   walk(selector, function (node) {
-    if (node.type === PseudoElementSelector
-      || node.type === TypeSelector
-      || node.type === PseudoClassSelector
+    let type = node.type
+
+    if (type === PseudoElementSelector
+      || type === TypeSelector
+      || type === PseudoClassSelector
     ) {
       if (hasVendorPrefix(node.name)) {
         isPrefixed = true
         return this.break
       }
-    } else if (node.type === AttributeSelector) {
+    } else if (type === AttributeSelector) {
       if (hasVendorPrefix(node.name.name)) {
         isPrefixed = true
         return this.break
@@ -110,20 +110,21 @@ export function getComplexity(selector) {
   let complexity = 0
 
   walk(selector, function (node) {
-    if (node.type === Selector || node.type === Nth) return
+    let type = node.type
+    if (type === Selector || type === Nth) return
 
     complexity++
 
-    if (node.type === PseudoElementSelector
-      || node.type === TypeSelector
-      || node.type === PseudoClassSelector
+    if (type === PseudoElementSelector
+      || type === TypeSelector
+      || type === PseudoClassSelector
     ) {
       if (hasVendorPrefix(node.name)) {
         complexity++
       }
     }
 
-    if (node.type === AttributeSelector) {
+    if (type === AttributeSelector) {
       if (node.value) {
         complexity++
       }
@@ -133,16 +134,16 @@ export function getComplexity(selector) {
       return this.skip
     }
 
-    if (node.type === PseudoClassSelector) {
-      if (isPseudoFunction(node.name)) {
+    if (type === PseudoClassSelector) {
+      if (PSEUDO_FUNCTIONS.has(node.name)) {
         let list = analyzeList(node, getComplexity)
 
         // Bail out for empty/non-existent :nth-child() params
         if (list.length === 0) return
 
-        list.forEach((c) => {
+        for (let c of list) {
           complexity += c
-        })
+        }
         return this.skip
       }
     }

src/string-utils.js

@@ -1,11 +1,3 @@
-/**
- * @param {string} str
- * @param {number} at
- */
-function charCodeAt(str, at) {
-  return str.charCodeAt(at)
-}
-
 /**
  * Case-insensitive compare two character codes
  * @param {string} referenceCode
@@ -38,7 +30,7 @@ export function strEquals(base, maybe) {
   if (len !== maybe.length) return false
 
   for (let i = 0; i < len; i++) {
-    if (compareChar(charCodeAt(base, i), charCodeAt(maybe, i)) === false) {
+    if (compareChar(base.charCodeAt(i), maybe.charCodeAt(i)) === false) {
       return false
     }
   }
@@ -66,7 +58,7 @@ export function endsWith(base, maybe) {
   }
 
   for (let i = len - 1; i >= offset; i--) {
-    if (compareChar(charCodeAt(base, i - offset), charCodeAt(maybe, i)) === false) {
+    if (compareChar(base.charCodeAt(i - offset), maybe.charCodeAt(i)) === false) {
       return false
     }
   }
@@ -76,16 +68,22 @@ export function endsWith(base, maybe) {
 
 /**
  * Case-insensitive testing whether a string starts with a given substring
+ *
+ * @example
+ * startsWith('test', 'my-test') // false
+ * startsWith('test', 'tes') // true
+ * startsWith('test', 'test-me') // true
+ *
  * @param {string} base
  * @param {string} maybe
- * @returns {boolean} true if `test` starts with `base`, false otherwise
+ * @returns {boolean} true if `base` starts with `maybe`, false otherwise
  */
 export function startsWith(base, maybe) {
   let len = base.length
   if (maybe.length < len) return false
 
   for (let i = 0; i < len; i++) {
-    if (compareChar(charCodeAt(base, i), charCodeAt(maybe, i)) === false) {
+    if (compareChar(base.charCodeAt(i), maybe.charCodeAt(i)) === false) {
       return false
     }
   }

src/stylesheet/stylesheet.js

@@ -1,12 +1,3 @@
-/**
- * @param {string} str
- * @param {number} start
- * @param {number} end
- */
-function substring(str, start, end) {
-	return str.substring(start, end)
-}
-
 /** @param {string} embed */
 export function getEmbedType(embed) {
 	// data:image/gif;base64,R0lG
@@ -15,12 +6,12 @@ export function getEmbedType(embed) {
 	let comma = embed.indexOf(',')
 
 	if (semicolon === -1) {
-		return substring(embed, start, comma)
+		return embed.substring(start, comma)
 	}
 
 	if (comma !== -1 && comma < semicolon) {
-		return substring(embed, start, comma);
+		return embed.substring(start, comma);
 	}
 
-	return substring(embed, start, semicolon)
+	return embed.substring(start, semicolon)
 }

src/values/animations.js

@@ -24,32 +24,30 @@ const TIMING_FUNCTION_VALUES = new KeywordSet([
 export function analyzeAnimation(children, cb) {
   let durationFound = false
 
-  children.forEach(child => {
+  for (let child of children) {
     let type = child.type
     let name = child.name
 
     // Right after a ',' we start over again
     if (type === Operator) {
-      return durationFound = false
-    }
-    if (type === Dimension && durationFound === false) {
+      durationFound = false
+    } else if (type === Dimension && durationFound === false) {
+      // The first Dimension is the duration, the second is the delay
       durationFound = true
-      return cb({
+      cb({
         type: 'duration',
         value: child,
       })
-    }
-    if (type === Identifier && TIMING_KEYWORDS.has(name)) {
-      return cb({
+    } else if (type === Identifier && TIMING_KEYWORDS.has(name)) {
+      cb({
         type: 'fn',
         value: child,
       })
-    }
-    if (type === Func && TIMING_FUNCTION_VALUES.has(name)) {
-      return cb({
+    } else if (type === Func && TIMING_FUNCTION_VALUES.has(name)) {
+      cb({
         type: 'fn',
         value: child,
       })
     }
-  })
+  }
 }