Minor things

Author: cdoublev

lib/cssom/CSS-impl.js

@@ -49,8 +49,8 @@ function supportsValue(property, value) {
  * @see {@link https://drafts.csswg.org/css-conditional-3/#dom-css-supports-conditiontext}
  */
 function supportsCondition(conditionText) {
-    const parsed = parseCSSGrammar(`(${conditionText})`, '<supports-condition>')
-    return parsed ? matchSupport(parsed) : false
+    const condition = parseCSSGrammar(`(${conditionText})`, '<supports-condition>')
+    return condition ? matchSupport(condition) : false
 }
 
 /**

lib/parse/grammar.js

@@ -270,8 +270,10 @@ function matchFunction(value, node, parser) {
         value = { ...value, name: match.value }
     }
     if (definition.value) {
-        const list = new Stream(value.value, input.source)
-        const match = parser.parseCSSValue(list, definition.value, ctx)
+        const match = parser.parseCSSValue(
+            new Stream(value.value, input.source),
+            definition.value,
+            ctx)
         if (match === null || match instanceof SyntaxError) {
             return match
         }

lib/parse/parser.js

@@ -152,8 +152,8 @@ function isInvalidPropertyRule(rule) {
         return substitutions.keywords.includes(initialValue)
     }
     if (initialValue) {
-        const parsed = parseCSSGrammar(initialValue, syntax.slice(1, -1), '@style')
-        return !(parsed && isComputationallyIndependent(parsed))
+        const match = parseCSSGrammar(initialValue, syntax.slice(1, -1), '@style')
+        return !(match && isComputationallyIndependent(match))
     }
     return true
 }
@@ -943,14 +943,14 @@ function parseCSSGrammar(input, grammar, context) {
 function parseCSSGrammarList(input, grammar, context) {
     input = parseCommaSeparatedComponentValueList(input)
     if (input.length === 1) {
-        const list = input[0]
-        if (list.length === 1 && isWhitespace(list[0])) {
+        const value = input[0]
+        if (value.length === 1 && isWhitespace(value[0])) {
             input.pop()
             return input
         }
     }
     context = createContext(context)
-    return list(input.map(list => parseCSSGrammar(list, grammar, context)), ',')
+    return list(input.map(value => parseCSSGrammar(value, grammar, context)), ',')
 }
 
 /**

lib/parse/shorthand.js

@@ -66,8 +66,6 @@ function parseLonghandsByIndex(values, longhands) {
  * @param {object[][]} lists
  * @param {string[]} longhands
  * @returns {Map}
- * @see {@link https://drafts.csswg.org/css-transitions-2/#propdef-transition}
- * @see {@link https://drafts.csswg.org/scroll-animations-1/#propdef-scroll-timeline}
  */
 function parseCoordinatedValueList(lists, longhands) {
     const declarations = new Map(longhands.map(longhand => [longhand, list([], ',')]))
@@ -863,7 +861,7 @@ function parseSides(values, { length: sides }) {
  * @see {@link https://drafts.csswg.org/scroll-animations-1/#propdef-view-timeline}
  */
 function parseViewTimeline(values, longhands) {
-    values = values.map(list => isOmitted(list[1]) ? [list[0], omitted, omitted] : list.flat())
+    values = values.map(value => isOmitted(value[1]) ? [value[0], omitted, omitted] : value.flat())
     return parseCoordinatedValueList(values, longhands)
 }
 

lib/parse/types.js

@@ -120,9 +120,9 @@ function createType(unit, entries = [], percentHint = entries.percentHint ?? nul
  * @see {@link https://drafts.css-houdini.org/css-typed-om-1/#cssnumericvalue-invert-a-type}
  */
 function invertType(type) {
-    const result = createType(null, [], type.percentHint)
-    type.forEach((exponent, unit) => result.set(unit, -1 * exponent))
-    return result
+    const inverted = createType(null, [], type.percentHint)
+    type.forEach((exponent, unit) => inverted.set(unit, -1 * exponent))
+    return inverted
 }
 
 /**

lib/serialize.js

@@ -1548,11 +1548,11 @@ function serializeURL({ value }) {
  * @see {@link https://drafts.csswg.org/css-syntax-3/#typedef-unicode-range-token}
  */
 function serializeUnicodeRange({ from, to }) {
-    const result = `U+${from.toString(16).toUpperCase()}`
+    const string = `U+${from.toString(16).toUpperCase()}`
     if (to === 0) {
-        return result
+        return string
     }
-    return `${result}-${to.toString(16).toUpperCase()}`
+    return `${string}-${to.toString(16).toUpperCase()}`
 }
 
 /**
@@ -2064,10 +2064,10 @@ function representBackgroundSize(size) {
 function representBorder(declarations, sides) {
     const values = []
     for (const [index, declaration] of declarations.entries()) {
-        const match = values[Math.floor(index / sides % 3)]
+        const fallback = values[Math.floor(index / sides % 3)]
         const value = serializeCSSValue(declaration)
-        if (match) {
-            if (match === value) {
+        if (fallback) {
+            if (fallback === value) {
                 continue
             }
             return ['']
@@ -3130,21 +3130,21 @@ function representWhiteSpace(declarations, longhands) {
 }
 
 /**
- * @param {string[]} list
+ * @param {string[]} sides
  * @returns {string[]}
  */
-function representSides(list) {
-    list = [...list]
-    let index = list.length
+function representSides(sides) {
+    sides = [...sides]
+    let index = sides.length
     while (1 < index--) {
-        const side = list[index]
-        const opposite = list[index - 2] ?? list[0]
+        const side = sides[index]
+        const opposite = sides[index - 2] ?? sides[0]
         if (side !== opposite) {
             break
         }
-        list.pop()
+        sides.pop()
     }
-    return list
+    return sides
 }
 
 /**