@thejaredwilcurt/csslop 0.0.24 → 0.0.26

package/src/declarations/process.js

@@ -7,8 +7,16 @@ import { hasInvalidQuotesCount } from '../value/quotes.js';
 
 import { absorbBackgroundLonghandsIntoShorthand } from './background.js';
 import { collapseBorderTrioWithPerEdgeColor } from './border.js';
-import { shorthandMap } from './config.js';
+import {
+  getLonghandsOf,
+  shorthandMap
+} from './config.js';
 import { hoistCssWideKeywordsIntoShorthands } from './css-wide-keywords.js';
+import { foldLonghandOverridesIntoShorthands } from './fold.js';
+import {
+  collectDeclaredProperties,
+  indexFirstDeclarationByProperty
+} from './lookup.js';
 import {
   getMergeProps,
   tryMergeToShorthand
@@ -49,17 +57,95 @@ function usesModernSyntax (value) {
 }
 
 /**
- * Finds the index of the last declaration matching a predicate, which is the
- * declaration that wins the cascade within a rule.
+ * Creates the bookkeeping for the declarations that survive deduplication.
+ *
+ * A dropped declaration leaves an empty slot behind instead of being spliced
+ * out, so that every position already recorded stays valid. Two indexes then
+ * answer the questions the deduplication loop asks about the survivors: which
+ * declaration last set a given property, and which vendor-prefixed
+ * declarations are still standing.
+ *
+ * @return {object} The surviving-declaration bookkeeping.
+ */
+function createSurvivingDeclarations () {
+  return {
+    slots: [],
+    positionsByProperty: new Map(),
+    vendorPrefixedPositions: []
+  };
+}
+
+/**
+ * Records a declaration as surviving, at the end of the output so far.
  *
- * @param  {Array}                     declarations  The declarations to search.
- * @param  {function(object): boolean} predicate     Called with each declaration, returning whether it matches.
- * @return {number}                                  The index of the matching declaration, or -1 when absent.
+ * @param {object} survivors    The surviving-declaration bookkeeping.
+ * @param {object} declaration  The declaration to keep.
  */
-function findLastIndex (declarations, predicate) {
-  for (let index = declarations.length - 1; index >= 0; index--) {
-    if (predicate(declarations[index])) {
-      return index;
+function keepDeclaration (survivors, declaration) {
+  const position = survivors.slots.length;
+  survivors.slots.push(declaration);
+  if (!declaration.property) {
+    return;
+  }
+  const positions = survivors.positionsByProperty.get(declaration.property);
+  if (positions) {
+    positions.push(position);
+  } else {
+    survivors.positionsByProperty.set(declaration.property, [position]);
+  }
+  if (declaration.property.startsWith('-')) {
+    survivors.vendorPrefixedPositions.push(position);
+  }
+}
+
+/**
+ * Drops a declaration that a later one made redundant. Only the last surviving
+ * declaration of a property is ever dropped, which is the one at the end of
+ * that property's position list.
+ *
+ * @param {object} survivors  The surviving-declaration bookkeeping.
+ * @param {number} position   The position of the declaration to drop.
+ */
+function dropDeclaration (survivors, position) {
+  const { property } = survivors.slots[position];
+  survivors.slots[position] = null;
+  survivors.positionsByProperty.get(property).pop();
+  const vendorPrefixedEntry = survivors.vendorPrefixedPositions.lastIndexOf(position);
+  if (vendorPrefixedEntry !== -1) {
+    survivors.vendorPrefixedPositions.splice(vendorPrefixedEntry, 1);
+  }
+}
+
+/**
+ * Finds the surviving declaration that last set a property, which is the one
+ * that currently wins the cascade within the rule.
+ *
+ * @param  {object} survivors  The surviving-declaration bookkeeping.
+ * @param  {string} property   The property name to look for.
+ * @return {number}            The position of the matching declaration, or -1 when absent.
+ */
+function findLastPositionOfProperty (survivors, property) {
+  const positions = survivors.positionsByProperty.get(property);
+  if (!positions?.length) {
+    return -1;
+  }
+  return positions[positions.length - 1];
+}
+
+/**
+ * Finds the surviving vendor-prefixed declaration that last set the prefixed
+ * form of a property, such as `-webkit-transform` for `transform`. Only the
+ * prefixed declarations are visited, rather than every survivor.
+ *
+ * @param  {object} survivors  The surviving-declaration bookkeeping.
+ * @param  {string} property   The unprefixed property name.
+ * @return {number}            The position of the matching declaration, or -1 when absent.
+ */
+function findLastVendorPrefixedPosition (survivors, property) {
+  for (let entry = survivors.vendorPrefixedPositions.length - 1; entry >= 0; entry--) {
+    const position = survivors.vendorPrefixedPositions[entry];
+    if (survivors.slots[position].property.endsWith(property)) {
+      return position;
     }
   }
   return -1;
@@ -74,11 +160,11 @@ function findLastIndex (declarations, predicate) {
  * @return {Array}               The surviving declarations, in source order.
  */
 function deduplicateDeclarations (declarations) {
-  const result = [];
+  const survivors = createSurvivingDeclarations();
 
   for (const declaration of declarations) {
     if (declaration.type === 'rule' || declaration.type === 'media') {
-      result.push(declaration);
+      keepDeclaration(survivors, declaration);
       continue;
     }
 
@@ -93,35 +179,23 @@ function deduplicateDeclarations (declarations) {
 
     const minifiedValue = minifyValue(declaration);
 
-    let previousIndex = findLastIndex(result, (candidate) => {
-      return candidate.property === propertyName;
-    });
+    const previousPosition = findLastPositionOfProperty(survivors, propertyName);
 
     // An unprefixed property with the same value also replaces its prefixed form
-    let prefixedIndex = -1;
+    let prefixedPosition = -1;
     if (!propertyName.startsWith('-')) {
-      prefixedIndex = findLastIndex(result, (candidate) => {
-        return (
-          candidate.property &&
-          candidate.property.endsWith(propertyName) &&
-          candidate.property.startsWith('-')
-        );
-      });
+      prefixedPosition = findLastVendorPrefixedPosition(survivors, propertyName);
     }
 
-    if (prefixedIndex !== -1) {
-      const prefixedValue = minifyValue(result[prefixedIndex]);
+    if (prefixedPosition !== -1) {
+      const prefixedValue = minifyValue(survivors.slots[prefixedPosition]);
       if (minifiedValue === prefixedValue) {
-        result.splice(prefixedIndex, 1);
-        // Re-adjust previousIndex if we removed an item before it
-        if (previousIndex > prefixedIndex) {
-          previousIndex--;
-        }
+        dropDeclaration(survivors, prefixedPosition);
       }
     }
 
-    if (previousIndex !== -1) {
-      const previousValue = minifyValue(result[previousIndex]);
+    if (previousPosition !== -1) {
+      const previousValue = minifyValue(survivors.slots[previousPosition]);
 
       if (previousValue.includes('!important') && !minifiedValue.includes('!important')) {
         continue;
@@ -129,18 +203,37 @@ function deduplicateDeclarations (declarations) {
 
       // Fallbacks for custom variables or older browser functions should be kept
       if (usesModernSyntax(minifiedValue) && !usesModernSyntax(previousValue)) {
-        result.push(declaration);
+        keepDeclaration(survivors, declaration);
         continue;
       }
 
       // Otherwise override previous identical property
-      result.splice(previousIndex, 1);
+      dropDeclaration(survivors, previousPosition);
     }
 
-    result.push(declaration);
+    keepDeclaration(survivors, declaration);
   }
 
-  return result;
+  return survivors.slots.filter((slot) => {
+    return slot !== null;
+  });
+}
+
+/**
+ * Indexes the position of the first declaration of each property, which is the
+ * earliest position a property can occupy within the rule.
+ *
+ * @param  {Array} declarations  The declarations of a single rule, in source order.
+ * @return {Map}                 Map of property name to its first index.
+ */
+function indexFirstDeclarationOfEachProperty (declarations) {
+  const firstIndexByProperty = new Map();
+  declarations.forEach((declaration, index) => {
+    if (declaration.property && !firstIndexByProperty.has(declaration.property)) {
+      firstIndexByProperty.set(declaration.property, index);
+    }
+  });
+  return firstIndexByProperty;
 }
 
 /**
@@ -152,6 +245,9 @@ function deduplicateDeclarations (declarations) {
  */
 function removeLonghandsOverriddenByShorthands (declarations) {
   const propertiesToRemove = new Set();
+  // A longhand precedes the shorthand exactly when its first occurrence does,
+  // so one index of first positions answers every shorthand's question.
+  const firstIndexByProperty = indexFirstDeclarationOfEachProperty(declarations);
 
   declarations.forEach((declaration, shorthandIndex) => {
     if (!declaration.property || !shorthandMap[declaration.property]) {
@@ -159,10 +255,8 @@ function removeLonghandsOverriddenByShorthands (declarations) {
     }
     const overridden = getOverriddenLonghands(declaration.property);
     for (const longhandProperty of overridden) {
-      const longhandIndex = declarations.findIndex((candidate, index) => {
-        return candidate.property === longhandProperty && index < shorthandIndex;
-      });
-      if (longhandIndex !== -1) {
+      const longhandIndex = firstIndexByProperty.get(longhandProperty);
+      if (longhandIndex !== undefined && longhandIndex < shorthandIndex) {
         propertiesToRemove.add(longhandProperty);
       }
     }
@@ -194,10 +288,9 @@ function getReplacedLonghands (shorthandName, mergeableProperties, relevantDecla
   if (!hasMixedImportant || !MIXED_IMPORTANT_SHORTHANDS.has(shorthandName)) {
     return mergeableProperties;
   }
+  const declarationByProperty = indexFirstDeclarationByProperty(relevantDeclarations);
   return mergeableProperties.filter((property) => {
-    const declaration = relevantDeclarations.find((candidate) => {
-      return candidate.property === property;
-    });
+    const declaration = declarationByProperty.get(property);
     return declaration && !minifyValue(declaration).includes('!important');
   });
 }
@@ -217,15 +310,12 @@ function removeSubsumedShorthands (builtDeclarations) {
       return true;
     }
     const isSubsumedByOtherShorthand = builtDeclarations.some((other) => {
-      if (other === declaration) {
-        return false;
-      }
-      const otherLonghands = shorthandMap[other.property];
-      if (!otherLonghands) {
+      if (other === declaration || !shorthandMap[other.property]) {
         return false;
       }
+      const otherLonghands = getLonghandsOf(other.property);
       return longhands.every((longhand) => {
-        return otherLonghands.includes(longhand);
+        return otherLonghands.has(longhand);
       });
     });
     return !isSubsumedByOtherShorthand;
@@ -249,21 +339,23 @@ function mergeLonghandsIntoShorthands (declarations, context) {
     builtShorthand = false;
     const replacedProperties = new Set();
     const builtDeclarations = [];
+    // Every shorthand asks the same questions of the same declarations, so the
+    // set of declared properties is gathered once per pass rather than rescanned
+    // for each of the dozens of shorthand families.
+    const declaredProperties = collectDeclaredProperties(result);
 
     for (const [shorthand, longhands] of Object.entries(shorthandMap)) {
-      const shorthandAlreadyExists = result.some((declaration) => {
-        return declaration.property === shorthand;
-      });
-      if (shorthandAlreadyExists) {
+      if (declaredProperties.has(shorthand)) {
         continue;
       }
 
-      const mergeableProperties = getMergeProps(shorthand, longhands, result);
+      const mergeableProperties = getMergeProps(shorthand, longhands, declaredProperties);
       if (!mergeableProperties) {
         continue;
       }
+      const mergeablePropertySet = new Set(mergeableProperties);
       const relevantDeclarations = result.filter((declaration) => {
-        return mergeableProperties.includes(declaration.property);
+        return mergeablePropertySet.has(declaration.property);
       });
       const mergedValue = tryMergeToShorthand(mergeableProperties, relevantDeclarations, shorthand, context);
       if (!mergedValue) {
@@ -305,6 +397,7 @@ function processDeclarations (declarations, context) {
   result = removeLonghandsOverriddenByShorthands(result);
   result = absorbBackgroundLonghandsIntoShorthand(result);
   result = mergeLonghandsIntoShorthands(result, context);
+  result = foldLonghandOverridesIntoShorthands(result, context);
   result = hoistCssWideKeywordsIntoShorthands(result);
   result = collapseBorderTrioWithPerEdgeColor(result);
 

package/src/declarations/shorthand-values.js

@@ -6,6 +6,7 @@ import { collapseShorthandParts } from '../value/shared.js';
 import { splitTopLevelComponents } from '../value/syntax.js';
 
 import { buildBackgroundShorthandValue } from './background.js';
+import { UNIFORM_VALUE_SHORTHANDS } from './config.js';
 
 /**
  * @typedef  {object} ShorthandComponents
@@ -275,6 +276,25 @@ function buildFlexValue ({ valueMap, importantSuffix }) {
   return [grow, shrink, basis].join(' ') + importantSuffix;
 }
 
+/**
+ * Builds the value of a shorthand that applies one value to every longhand it
+ * sets, such as `marker` or the bidirectional gap decoration rules. Such a
+ * shorthand cannot express longhands that differ, so the group only collapses
+ * when every longhand already holds the same value.
+ *
+ * @param  {ShorthandComponents} components  The collected longhand values.
+ * @return {string|null}                     The shorthand value, or null when it cannot be built.
+ */
+function buildUniformValue ({ cleanValues, importantSuffix }) {
+  const isSharedByAll = cleanValues.every((value) => {
+    return value === cleanValues[0];
+  });
+  if (!isSharedByAll) {
+    return null;
+  }
+  return cleanValues[0] + importantSuffix;
+}
+
 /**
  * Determines whether a shorthand takes a single width, style, and color, as
  * `border` and `outline` do.
@@ -364,6 +384,9 @@ const NAMED_SHORTHAND_BUILDERS = {
  * @return {string|null}                        The shorthand value, or null when it cannot be built.
  */
 function buildShorthandValue (shorthandName, components) {
+  if (UNIFORM_VALUE_SHORTHANDS.has(shorthandName)) {
+    return buildUniformValue(components);
+  }
   const namedBuilder = NAMED_SHORTHAND_BUILDERS[shorthandName];
   if (namedBuilder) {
     return namedBuilder(components);

package/src/index.js

@@ -41,7 +41,10 @@ import {
   removeRedundantLayerStatementSemicolon,
   stringifyRule
 } from './rules/stringify.js';
-import { minifyValue } from './value/minify.js';
+import {
+  clearMinifiedValueCache,
+  minifyValue
+} from './value/minify.js';
 
 /**
  * Splits a minified CSS selector list at top-level commas, respecting
@@ -175,6 +178,27 @@ function mergeAdjacentRulesWithIdenticalBodies (ruleStrings) {
   return result;
 }
 
+/**
+ * Prepares the module-level state a single minification pass relies on: the
+ * active charset, and an empty value cache, since a value memoized under a
+ * different charset may no longer minify the same way.
+ *
+ * @param {string} charset  The `@charset` value detected in the source.
+ */
+function beginMinificationPass (charset) {
+  setActiveCharset(charset);
+  clearMinifiedValueCache();
+}
+
+/**
+ * Releases the module-level state a minification pass built up, so a cache
+ * filled by a large stylesheet is not retained until the next pass runs.
+ */
+function endMinificationPass () {
+  clearActiveCharset();
+  clearMinifiedValueCache();
+}
+
 /**
  * Parses, optimizes, and minifies a CSS string by applying rule merging, declaration deduplication, value compression, and dead-code elimination.
  *
@@ -192,7 +216,7 @@ export const minifyCSS = function (input) {
   const output = [];
 
   const detectedCharset = detectCharset(source);
-  setActiveCharset(detectedCharset);
+  beginMinificationPass(detectedCharset);
 
   try {
     ast = parse(
@@ -200,7 +224,7 @@ export const minifyCSS = function (input) {
       { preserveFormatting: true, silent: true }
     );
   } catch {
-    clearActiveCharset();
+    endMinificationPass();
     return source;
   }
 
@@ -248,10 +272,10 @@ export const minifyCSS = function (input) {
 
     const mergedOutput = removeRedundantLayerStatementSemicolon(mergeAdjacentRulesWithIdenticalBodies(output));
 
-    clearActiveCharset();
+    endMinificationPass();
     return restoreEscapeSequences(mergedOutput.join(''));
   }
 
-  clearActiveCharset();
+  endMinificationPass();
   return source;
 };

package/src/position-try.js

@@ -2,6 +2,8 @@
  * @file Handles `@position-try` rule analysis, usage tracking, and dead-rule elimination during CSS minification.
  */
 
+import { registersCustomProperty } from './rules/property.js';
+
 /**
  * Scans top-level rules to register `@property` custom properties in the context and collect `@position-try` rule declarations and initial usage counts.
  *
@@ -14,7 +16,7 @@ function collectRuleMetadata (rules, context) {
   const positionTryUsage = new Map();
 
   for (const rule of rules) {
-    if (rule.type === 'property' && rule.name) {
+    if (rule.type === 'property' && rule.name && registersCustomProperty(rule)) {
       context.registeredCustomProperties.add(rule.name);
       const syntaxDeclaration = (rule.declarations || []).find((declaration) => {
         return declaration.type !== 'whitespace' && declaration.property === 'syntax';