postcss-merge-idents 9.0.3 → 9.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postcss-merge-idents",
-  "version": "9.0.3",
+  "version": "9.0.4",
   "description": "Merge keyframe and counter style identifiers.",
   "exports": {
     ".": {
@@ -34,8 +34,8 @@
     "url": "git+https://github.com/cssnano/cssnano.git"
   },
   "dependencies": {
-    "cssnano-utils": "^7.0.3",
-    "postcss-value-parser": "^4.2.0"
+    "@csstools/css-tokenizer": "^4.0.2",
+    "cssnano-utils": "^8.0.0"
   },
   "bugs": {
     "url": "https://github.com/cssnano/cssnano/issues"
@@ -44,6 +44,7 @@
     "node": "^22.22.3 || ^24.15.0 || >=26.0"
   },
   "devDependencies": {
+    "@webref/css": "8.7.5",
     "postcss": "^8.5.28"
   },
   "peerDependencies": {
@@ -51,6 +52,7 @@
   },
   "type": "module",
   "scripts": {
+    "acquire": "node ./script/acquire.mjs",
     "test": "node --test"
   }
 }

package/src/data/mergeIdents.json

@@ -0,0 +1,58 @@
+{
+  "cssWideKeywords": [
+    "inherit",
+    "initial",
+    "revert",
+    "revert-layer",
+    "revert-rule",
+    "unset"
+  ],
+  "keyframes": {
+    "shorthandKeywords": [
+      "alternate",
+      "alternate-reverse",
+      "auto",
+      "backwards",
+      "both",
+      "ease",
+      "ease-in",
+      "ease-in-out",
+      "ease-out",
+      "forwards",
+      "infinite",
+      "linear",
+      "none",
+      "normal",
+      "paused",
+      "reverse",
+      "running",
+      "step-end",
+      "step-start"
+    ]
+  },
+  "counterStyle": {
+    "keywords": [
+      "additive",
+      "alphabetic",
+      "auto",
+      "bullets",
+      "cyclic",
+      "extends",
+      "fixed",
+      "inside",
+      "none",
+      "numbers",
+      "numeric",
+      "outside",
+      "spell-out",
+      "symbolic",
+      "words"
+    ],
+    "functions": {
+      "counter()": [1],
+      "counters()": [2],
+      "target-counter()": [2],
+      "target-counters()": [3]
+    }
+  }
+}

package/src/index.js

@@ -1,130 +1,263 @@
-import valueParser from 'postcss-value-parser';
 import cssnanoUtils from 'cssnano-utils';
+import { LayerRegistry, compareAtRulePriority } from './lib/layerRegistry.js';
+import {
+  classifyDeclaration,
+  getBody,
+  getContainer,
+  parseAtRuleName,
+} from './lib/grammar.js';
+import { rewriteDeclaration } from './lib/valueRewriter.js';
+
+const { asciiLowerCase } = cssnanoUtils;
+
+/**
+ * @typedef {{
+ *   rule: import('postcss').AtRule,
+ *   body?: string,
+ *   layerPriority: number[],
+ *   documentIndex: number,
+ *   parsed: { isString: boolean, isReservedName: boolean, key: string, tokenText: string }
+ * }} AtRuleEntry
+ *
+ * @typedef {{
+ *   entries: AtRuleEntry[],
+ *   resolver?: (key: string) => { text: string, key: string } | undefined,
+ *   definedNames?: Set<string>
+ * }} FamilyRecord
+ */
+
+/**
+ * Collects the entries that may join a cross-name merge group: repeat
+ * definitions of one name collapse to their highest priority copy first, and
+ * only when all copies share a body. Reserved names never merge because a
+ * stylesheet that spells one is not free to take another spelling.
+ *
+ * @param {Map<string, AtRuleEntry[]>} byName
+ * @param {Set<import('postcss').AtRule>} removals
+ * @return {AtRuleEntry[]}
+ */
+function collectEligibleEntries(byName, removals) {
+  /** @type {AtRuleEntry[]} */
+  const eligible = [];
+
+  for (const list of byName.values()) {
+    if (list.length === 1) {
+      if (!list[0].parsed.isReservedName) {
+        eligible.push(list[0]);
+      }
+      continue;
+    }
+    const firstBody = getBody(list[0]);
+    if (!list.every((item) => getBody(item) === firstBody)) {
+      continue;
+    }
+    let survivor = list[0];
+    for (let i = 1; i < list.length; i++) {
+      if (compareAtRulePriority(survivor, list[i]) < 0) {
+        survivor = list[i];
+      }
+    }
+    for (const item of list) {
+      if (item !== survivor) {
+        removals.add(item.rule);
+      }
+    }
+    if (!survivor.parsed.isReservedName) {
+      eligible.push(survivor);
+    }
+  }
+
+  return eligible;
+}
 
-const { sameParent } = cssnanoUtils;
-const keyframesRegex = /keyframes/i;
-const animationRegex = /animation/i;
-const counterStyleRegex = /counter-style/i;
-const listStyleSystemRegex = /(list-style|system)/i;
 /**
- * @param {Record<string, string>} obj
- * @return {(key: string) => string}
+ * @param {AtRuleEntry[]} entries
+ * @param {Set<import('postcss').AtRule>} removals
+ * @return {{ resolver: (key: string) => { text: string, key: string } | undefined, definedNames: Set<string>, hasReplacements: boolean }}
  */
-function canonical(obj) {
-  // Prevent potential infinite loops
-  let stack = 50;
-
-  /**
-   * @param {string} key
-   * @return {string}
-   */
-  return function recurse(key) {
-    if (Object.hasOwn(obj, key) && obj[key] !== key && stack) {
-      stack--;
-
-      return recurse(obj[key]);
+function processAtRuleEntries(entries, removals) {
+  const definedNames = new Set();
+  if (entries.length === 0) {
+    return {
+      resolver: () => undefined,
+      definedNames,
+      hasReplacements: false,
+    };
+  }
+
+  for (const entry of entries) {
+    definedNames.add(entry.parsed.key);
+  }
+
+  if (entries.length === 1) {
+    return {
+      resolver: () => undefined,
+      definedNames,
+      hasReplacements: false,
+    };
+  }
+
+  /** @type {Map<string, AtRuleEntry[]>} */
+  const byName = new Map();
+  for (const entry of entries) {
+    let nameList = byName.get(entry.parsed.key);
+    if (!nameList) {
+      nameList = [];
+      byName.set(entry.parsed.key, nameList);
     }
+    nameList.push(entry);
+  }
 
-    stack = 50;
+  const eligible = collectEligibleEntries(byName, removals);
 
-    return key;
+  /** @type {Map<string, AtRuleEntry[]>} */
+  const groupsByBody = new Map();
+
+  for (const item of eligible) {
+    const groupKey = (item.parsed.isString ? 's:' : 'i:') + getBody(item);
+    let group = groupsByBody.get(groupKey);
+    if (!group) {
+      group = [];
+      groupsByBody.set(groupKey, group);
+    }
+    group.push(item);
+  }
+
+  /** @type {Map<string, { text: string, key: string }>} */
+  const resolved = new Map();
+
+  for (const group of groupsByBody.values()) {
+    if (group.length > 1) {
+      let survivor = group[0];
+      for (let i = 1; i < group.length; i++) {
+        if (compareAtRulePriority(survivor, group[i]) < 0) {
+          survivor = group[i];
+        }
+      }
+      for (const item of group) {
+        if (item !== survivor) {
+          removals.add(item.rule);
+          resolved.set(item.parsed.key, {
+            text: survivor.parsed.tokenText,
+            key: survivor.parsed.key,
+          });
+        }
+      }
+    }
+  }
+
+  return {
+    resolver: (key) => resolved.get(key),
+    definedNames,
+    hasReplacements: resolved.size > 0,
   };
 }
 
+/**
+ * Finds or creates the family record of one at-rule name in one container.
+ *
+ * @param {Map<import('postcss').Container, Map<string, FamilyRecord>>} scopes
+ * @param {import('postcss').Container} container
+ * @param {string} name
+ * @return {FamilyRecord}
+ */
+function familyRecordFor(scopes, container, name) {
+  let containerScope = scopes.get(container);
+  if (!containerScope) {
+    containerScope = new Map();
+    scopes.set(container, containerScope);
+  }
+  let familyData = containerScope.get(name);
+  if (!familyData) {
+    familyData = { entries: [] };
+    containerScope.set(name, familyData);
+  }
+  return familyData;
+}
+
 /**
  * @param {import('postcss').Root} css
  * @return {void}
  */
 function mergeAtRules(css) {
-  const pairs = [
-    {
-      atrule: keyframesRegex,
-      decl: animationRegex,
-      /** @type {import('postcss').AtRule[]} */
-      cache: [],
-      replacements: {},
-      /** @type {import('postcss').Declaration[]} */
-      decls: [],
-      /** @type {import('postcss').AtRule[]} */
-      removals: [],
-    },
-    {
-      atrule: counterStyleRegex,
-      decl: listStyleSystemRegex,
-      cache: [],
-      replacements: {},
-      decls: [],
-      removals: [],
-    },
-  ];
+  const layerRegistry = new LayerRegistry();
+  let keyframesCount = 0;
+  let counterStyleCount = 0;
+  let documentIndex = 0;
 
-  /**
-   * @type {{atrule: RegExp, decl: RegExp, replacements: Record<string, string>, removals: import('postcss').AtRule[], cache: import('postcss').AtRule[], decls: import('postcss').Declaration[]} | undefined}
-   */
-  let relevant;
+  /** @type {Map<import('postcss').Container, Map<string, FamilyRecord>>} */
+  const scopes = new Map();
 
-  css.walk((node) => {
-    if (node.type === 'atrule') {
-      relevant = pairs.find((pair) =>
-        pair.atrule.test(node.name.toLowerCase())
-      );
+  css.walkAtRules((atRule) => {
+    const name = asciiLowerCase(atRule.name);
+    if (name === 'layer') {
+      layerRegistry.declareLayerAtRule(atRule);
+      return;
+    }
 
-      if (!relevant) {
-        return;
-      }
+    const isKeyframes = name.endsWith('keyframes');
+    const isCounterStyle = name.endsWith('counter-style');
+    if (!isKeyframes && !isCounterStyle) {
+      return;
+    }
 
-      if (relevant.cache.length < 1) {
-        relevant.cache.push(node);
-        return;
-      } else {
-        const toString = node.nodes ? node.nodes.toString() : '';
-
-        for (const cached of relevant.cache) {
-          const cachedStringContent = cached.nodes
-            ? cached.nodes.toString()
-            : '';
-          if (
-            cached.name.toLowerCase() === node.name.toLowerCase() &&
-            sameParent(cached, node) &&
-            cachedStringContent === toString
-          ) {
-            relevant.removals.push(cached);
-            relevant.replacements[cached.params] = node.params;
-          }
-        }
+    if (isKeyframes) {
+      keyframesCount++;
+    } else {
+      counterStyleCount++;
+    }
 
-        relevant.cache.push(node);
+    const container = getContainer(atRule);
+    const familyData = familyRecordFor(scopes, container, name);
 
-        return;
-      }
+    const parsed = parseAtRuleName(atRule.params, name);
+    if (parsed) {
+      familyData.entries.push({
+        rule: atRule,
+        parsed,
+        layerPriority: layerRegistry.getPriority(atRule),
+        documentIndex: documentIndex++,
+      });
     }
+  });
+
+  if (keyframesCount < 2 && counterStyleCount < 2) {
+    return;
+  }
 
-    if (node.type === 'decl') {
-      relevant = pairs.find((pair) => pair.decl.test(node.prop.toLowerCase()));
+  /** @type {Set<import('postcss').AtRule>} */
+  const removals = new Set();
+  let hasReplacements = false;
 
-      if (!relevant) {
-        return;
+  for (const containerScope of scopes.values()) {
+    for (const familyData of containerScope.values()) {
+      const result = processAtRuleEntries(familyData.entries, removals);
+      familyData.resolver = result.resolver;
+      familyData.definedNames = result.definedNames;
+      if (result.hasReplacements) {
+        hasReplacements = true;
       }
-
-      relevant.decls.push(node);
     }
-  });
+  }
 
-  for (const pair of pairs) {
-    const canon = canonical(pair.replacements);
-
-    for (const decl of pair.decls) {
-      decl.value = valueParser(decl.value)
-        .walk((node) => {
-          if (node.type === 'word') {
-            node.value = canon(node.value);
-          }
-        })
-        .toString();
-    }
-    for (const cached of pair.removals) {
-      cached.remove();
-    }
+  if (removals.size === 0) {
+    return;
+  }
+
+  if (hasReplacements) {
+    const singleScope =
+      scopes.size === 1 ? (scopes.values().next().value ?? null) : null;
+
+    css.walkDecls((decl) => {
+      const classification = classifyDeclaration(decl);
+      if (classification) {
+        rewriteDeclaration(decl, classification, scopes, singleScope);
+      }
+    });
+  }
+
+  for (const node of removals) {
+    node.remove();
   }
 }