@thejaredwilcurt/csslop 0.0.14 → 0.0.16

package/package.json

@@ -2,7 +2,7 @@
   "name": "@thejaredwilcurt/csslop",
   "main": "index.js",
   "type": "module",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "description": "Experimental CSS minification",
   "scripts": {
     "prestart": "node ./scripts/prestart.js",

package/src/value/gradients.js

@@ -269,6 +269,9 @@ function normalizeBoundaryPositionTokens (mergedStops) {
     if (isLastStop && positionTokens[positionTokens.length - 1] === '100%') {
       positionTokens.pop();
     }
+    if (isLastStop && positionTokens.length === 1 && positionTokens[0] === '100%') {
+      positionTokens.pop();
+    }
     if (positionTokens.length > 0 && positionTokens[0] === previousEndPosition) {
       positionTokens[0] = '0';
     }

package/src/value/minify.js

@@ -172,6 +172,238 @@ function replaceOutsideStringsAndUrls (value, replacer) {
   return result;
 }
 
+/**
+ * Determines whether a character can appear inside a CSS identifier.
+ *
+ * @param  {string}  character  A single character.
+ * @return {boolean}            True when the character is identifier-like.
+ */
+function isIdentifierCharacter (character) {
+  if (!character) {
+    return false;
+  }
+  const codePoint = character.charCodeAt(0);
+  const isUppercaseLetter = codePoint >= 65 && codePoint <= 90;
+  const isLowercaseLetter = codePoint >= 97 && codePoint <= 122;
+  const isDigit = codePoint >= 48 && codePoint <= 57;
+  return isUppercaseLetter || isLowercaseLetter || isDigit || character === '_' || character === '-';
+}
+
+/**
+ * Detects a `light-dark(` function call at the provided position.
+ *
+ * @param  {string}  value  The CSS value being scanned.
+ * @param  {number}  index  The candidate start index.
+ * @return {boolean}        True when a light-dark function starts at index.
+ */
+function startsLightDarkFunction (value, index) {
+  if (value.slice(index, index + 11).toLowerCase() !== 'light-dark(') {
+    return false;
+  }
+  return !isIdentifierCharacter(value[index - 1]);
+}
+
+/**
+ * Finds the closing parenthesis for an opening parenthesis while respecting
+ * nested parentheses and quoted strings.
+ *
+ * @param  {string} value           The CSS text being scanned.
+ * @param  {number} openParenIndex  The index of the opening `(` character.
+ * @return {number}                 The closing `)` index, or -1 if unmatched.
+ */
+function findMatchingParenthesis (value, openParenIndex) {
+  let depth = 1;
+  let index = openParenIndex + 1;
+  let activeQuote = '';
+
+  while (index < value.length) {
+    const character = value[index];
+    if (activeQuote) {
+      if (character === '\\') {
+        index += 2;
+        continue;
+      }
+      if (character === activeQuote) {
+        activeQuote = '';
+      }
+      index++;
+      continue;
+    }
+
+    if (character === '"' || character === '\'') {
+      activeQuote = character;
+      index++;
+      continue;
+    }
+
+    if (character === '(') {
+      depth++;
+      index++;
+      continue;
+    }
+
+    if (character === ')') {
+      depth--;
+      if (depth === 0) {
+        return index;
+      }
+    }
+    index++;
+  }
+
+  return -1;
+}
+
+/**
+ * Splits a CSS function argument list at top-level commas while respecting
+ * nested parentheses and quoted strings.
+ *
+ * @param  {string} argumentString  The raw content between function parentheses.
+ * @return {Array}                  The top-level argument strings.
+ */
+function splitTopLevelFunctionArguments (argumentString) {
+  const argumentsList = [];
+  let currentArgument = '';
+  let depth = 0;
+  let index = 0;
+  let activeQuote = '';
+
+  while (index < argumentString.length) {
+    const character = argumentString[index];
+    if (activeQuote) {
+      currentArgument += character;
+      if (character === '\\') {
+        if (index + 1 < argumentString.length) {
+          currentArgument += argumentString[index + 1];
+          index += 2;
+          continue;
+        }
+      } else if (character === activeQuote) {
+        activeQuote = '';
+      }
+      index++;
+      continue;
+    }
+
+    if (character === '"' || character === '\'') {
+      activeQuote = character;
+      currentArgument += character;
+      index++;
+      continue;
+    }
+
+    if (character === '(') {
+      depth++;
+      currentArgument += character;
+      index++;
+      continue;
+    }
+
+    if (character === ')') {
+      if (depth > 0) {
+        depth--;
+      }
+      currentArgument += character;
+      index++;
+      continue;
+    }
+
+    if (character === ',' && depth === 0) {
+      argumentsList.push(currentArgument.trim());
+      currentArgument = '';
+      index++;
+      continue;
+    }
+
+    currentArgument += character;
+    index++;
+  }
+
+  argumentsList.push(currentArgument.trim());
+  return argumentsList;
+}
+
+/**
+ * Simplifies `light-dark(a,b)` to `a` when both top-level arguments are identical
+ * after prior minification has normalized them.
+ *
+ * @param  {string} value  The CSS value to simplify.
+ * @return {string}        The value with redundant light-dark functions removed.
+ */
+function simplifyEquivalentLightDarkFunctions (value) {
+  let result = '';
+  let index = 0;
+
+  const consumeQuoted = (start) => {
+    const quote = value[start];
+    let end = start + 1;
+    while (end < value.length) {
+      if (value[end] === '\\') {
+        end += 2;
+        continue;
+      }
+      if (value[end] === quote) {
+        end++;
+        break;
+      }
+      end++;
+    }
+    return end;
+  };
+
+  const startsUrl = (start) => {
+    return value.slice(start, start + 4).toLowerCase() === 'url(';
+  };
+
+  while (index < value.length) {
+    if (value[index] === '"' || value[index] === '\'') {
+      const end = consumeQuoted(index);
+      result += value.slice(index, end);
+      index = end;
+      continue;
+    }
+
+    if (startsUrl(index)) {
+      const end = findMatchingParenthesis(value, index + 3);
+      if (end === -1) {
+        result += value.slice(index);
+        break;
+      }
+      result += value.slice(index, end + 1);
+      index = end + 1;
+      continue;
+    }
+
+    if (startsLightDarkFunction(value, index)) {
+      const openParenIndex = index + 10;
+      const closingParenIndex = findMatchingParenthesis(value, openParenIndex);
+      if (closingParenIndex === -1) {
+        result += value.slice(index);
+        break;
+      }
+
+      const argumentString = value.slice(openParenIndex + 1, closingParenIndex);
+      const argumentsList = splitTopLevelFunctionArguments(argumentString);
+      if (argumentsList.length === 2) {
+        const firstArgument = simplifyEquivalentLightDarkFunctions(argumentsList[0]);
+        const secondArgument = simplifyEquivalentLightDarkFunctions(argumentsList[1]);
+        if (firstArgument === secondArgument) {
+          result += firstArgument;
+        } else {
+          result += value.slice(index, openParenIndex + 1) + firstArgument + ',' + secondArgument + ')';
+        }
+        index = closingParenIndex + 1;
+        continue;
+      }
+    }
+
+    result += value[index];
+    index++;
+  }
+
+  return result;
+}
+
 /**
  * Normalizes whitespace, quotes, and unicode escapes in a CSS value string.
  *
@@ -802,6 +1034,9 @@ function minifyValue (declaration) {
     // Shorten all color tokens (hex and named) to their shortest representation
     val = replaceOutsideStringsAndUrls(val, shortenColorValues);
 
+    // Collapse light-dark() when both normalized branches are identical
+    val = simplifyEquivalentLightDarkFunctions(val);
+
     // Property-specific optimizations
     val = applyPropertyOptimizations(val, declaration.property);
   }