single-file-core 1.5.48 → 1.5.49

package/modules/css-scope-prelude-parser.js

@@ -0,0 +1,119 @@
+/*
+ * Copyright 2010-2025 Gildas Lormeau
+ * contact : gildas.lormeau <at> gmail.com
+ * 
+ * This file is part of SingleFile.
+ *
+ *   The code in this file is free software: you can redistribute it and/or 
+ *   modify it under the terms of the GNU Affero General Public License 
+ *   (GNU AGPL) as published by the Free Software Foundation, either version 3
+ *   of the License, or (at your option) any later version.
+ * 
+ *   The code in this file is distributed in the hope that it will be useful, 
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of 
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero 
+ *   General Public License for more details.
+ *
+ *   As additional permission under GNU AGPL version 3 section 7, you may 
+ *   distribute UNMODIFIED VERSIONS OF THIS file without the copy of the GNU 
+ *   AGPL normally required by section 4, provided you include this license 
+ *   notice and a URL through which recipients can access the Corresponding 
+ *   Source.
+ */
+
+import * as cssTree from "./../vendor/css-tree.js";
+
+const CANONICAL_PSEUDO_ELEMENT_NAMES = new Set(["after", "before", "first-letter", "first-line", "placeholder", "selection", "part", "marker"]);
+
+export {
+  parsePrelude
+};
+
+function parsePrelude(prelude) {
+  if (!prelude) {
+    return { include: [], exclude: [] };
+  }
+
+  // Normalize prelude to a string then split on a top-level `to` keyword.
+  // Using generated string is pragmatic: `to` as an at-rule keyword is expected
+  // to appear at top-level with surrounding whitespace. We split on whitespace+to+whitespace.
+  const preludeText = cssTree.generate(prelude).trim();
+  if (!preludeText) return { include: [], exclude: [] };
+
+  // Split on top-level ' to ' (case-insensitive) — join remaining parts if multiple 'to' appear
+  const parts = preludeText.split(/\s+to\s+/i);
+  const includeText = parts[0].trim();
+  const excludeText = parts.length > 1 ? parts.slice(1).join(" to ").trim() : "";
+
+  function parseSelectorList(text) {
+    if (!text) return [];
+    // Strip balanced outer parentheses that css-tree may produce in generated preludes
+    function stripOuterParens(s) {
+      let str = s.trim();
+      while (str.length >= 2 && str[0] === "(" && str[str.length - 1] === ")") {
+        // ensure they are balanced pairs for the whole string
+        let depth = 0;
+        let balanced = true;
+        for (let i = 0; i < str.length; i++) {
+          if (str[i] === "(") depth++;
+          else if (str[i] === ")") depth--;
+          if (depth === 0 && i < str.length - 1) { balanced = false; break; }
+        }
+        if (!balanced) break;
+        str = str.substring(1, str.length - 1).trim();
+      }
+      return str;
+    }
+
+    const cleaned = stripOuterParens(text);
+    // css-tree expects a selectorList context
+    const ast = cssTree.parse(cleaned, { context: "selectorList" });
+    const selectors = [];
+    if (ast && ast.children) {
+      for (let node = ast.children.head; node; node = node.next) {
+        const sel = node.data;
+        selectors.push({ ast: sel, text: cssTree.generate(sel) });
+      }
+    }
+    return selectors;
+  }
+
+  const include = parseSelectorList(includeText);
+  const exclude = parseSelectorList(excludeText);
+
+  // Validate: pseudo-elements are not allowed in scope start/end selectors
+  function containsPseudoElement(selectorAst) {
+    let found = false;
+    cssTree.walk(selectorAst, {
+      visit: "PseudoElementSelector",
+      enter() { found = true; }
+    });
+    if (!found) {
+      // also check for pseudo-class names that are treated as pseudo-elements by some authors
+      cssTree.walk(selectorAst, {
+        visit: "PseudoClassSelector",
+        enter(node) {
+          const name = (node.name || "").toLowerCase();
+          // keep this conservative: disallow known pseudo-element names if used as pseudo-class
+          if (CANONICAL_PSEUDO_ELEMENT_NAMES.has(name)) {
+            found = true;
+          }
+        }
+      });
+    }
+    return found;
+  }
+
+  for (const s of include) {
+    if (containsPseudoElement(s.ast)) {
+      throw new Error("Pseudo-elements are not allowed in @scope prelude (scope-start)");
+    }
+  }
+  for (const s of exclude) {
+    if (containsPseudoElement(s.ast)) {
+      throw new Error("Pseudo-elements are not allowed in @scope prelude (scope-end)");
+    }
+  }
+
+  return { include, exclude };
+}

package/modules/css-selector-sanitizer.js

@@ -0,0 +1,106 @@
+/*
+/*
+ * Copyright 2010-2025 Gildas Lormeau
+ * contact : gildas.lormeau <at> gmail.com
+ * 
+ * This file is part of SingleFile.
+ *
+ *   The code in this file is free software: you can redistribute it and/or 
+ *   modify it under the terms of the GNU Affero General Public License 
+ *   (GNU AGPL) as published by the Free Software Foundation, either version 3
+ *   of the License, or (at your option) any later version.
+ * 
+ *   The code in this file is distributed in the hope that it will be useful, 
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of 
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero 
+ *   General Public License for more details.
+ *
+ *   As additional permission under GNU AGPL version 3 section 7, you may 
+ *   distribute UNMODIFIED VERSIONS OF THIS file without the copy of the GNU 
+ *   AGPL normally required by section 4, provided you include this license 
+ *   notice and a URL through which recipients can access the Corresponding 
+ *   Source.
+ */
+
+import * as cssTree from "./../vendor/css-tree.js";
+
+const UNMATCHABLE_PSEUDO_CLASSES = [
+    "active-view-transition",
+    "active-view-transition-type",
+    "blank",
+    "buffering",
+    "current",
+    "first",
+    "future",
+    "has-slotted",
+    "host-context",
+    "heading",
+    "left",
+    "muted",
+    "open",
+    "past",
+    "paused",
+    "picture-in-picture",
+    "playing",
+    "right",
+    "seeking",
+    "stalled",
+    "volume-locked",
+];
+
+export {
+    sanitizeSelector,
+};
+
+/**
+ * Sanitize a selector AST into a QSA-safe selector string.
+ * Optional `ancestors` array may be provided to expand nesting selectors (`&`).
+ */
+function sanitizeSelector(selector, ancestors, docContext) {
+    if (!docContext.normalizedSelectorText) docContext.normalizedSelectorText = new WeakMap();
+    if (docContext.normalizedSelectorText.has(selector)) {
+        return docContext.normalizedSelectorText.get(selector);
+    }
+    const ast = cssTree.clone(selector.data);
+    normalizeSelectorNode(ast, ancestors);
+    let normalized = cssTree.generate(ast);
+    if (!normalized || !normalized.trim()) {
+        normalized = "*";
+    }
+    docContext.normalizedSelectorText.set(selector, normalized);
+    return normalized;
+}
+
+function normalizeSelectorNode(selector, ancestors) {
+    let current = selector.children.head;
+    while (current) {
+        const next = current.next;
+        const childNode = current.data;
+        if (childNode.type === "NestingSelector") {
+            if (ancestors && ancestors.length) {
+                const lastAncestor = ancestors[ancestors.length - 1];
+                let ancestorAst = lastAncestor && lastAncestor.data ? lastAncestor.data : lastAncestor;
+                if (ancestorAst && ancestorAst.type === "SelectorList" && ancestorAst.children && ancestorAst.children.tail) {
+                    ancestorAst = ancestorAst.children.tail.data;
+                }
+                if (ancestorAst && ancestorAst.children) {
+                    for (let a = ancestorAst.children.head; a; a = a.next) {
+                        const cloned = cssTree.clone(a.data);
+                        selector.children.insertData(cloned, current);
+                    }
+                    selector.children.remove(current);
+                }
+            }
+        } else if (childNode.type === "TypeSelector" && typeof childNode.name === "string" && childNode.name.includes("|")) {
+            childNode.name = childNode.name.substring(childNode.name.lastIndexOf("|") + 1);
+        } else if (childNode.type === "PseudoElementSelector") {
+            selector.children.remove(current);
+        } else if (childNode.type === "PseudoClassSelector") {
+            const pseudoName = (childNode.name || "").toLowerCase();
+            if (UNMATCHABLE_PSEUDO_CLASSES.includes(pseudoName)) {
+                selector.children.remove(current);
+            }
+        }
+        current = next;
+    }
+}

package/modules/css-specificity.js

@@ -0,0 +1,211 @@
+/*
+ * Copyright 2010-2025 Gildas Lormeau
+ * contact : gildas.lormeau <at> gmail.com
+ * 
+ * This file is part of SingleFile.
+ *
+ *   The code in this file is free software: you can redistribute it and/or 
+ *   modify it under the terms of the GNU Affero General Public License 
+ *   (GNU AGPL) as published by the Free Software Foundation, either version 3
+ *   of the License, or (at your option) any later version.
+ * 
+ *   The code in this file is distributed in the hope that it will be useful, 
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of 
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero 
+ *   General Public License for more details.
+ *
+ *   As additional permission under GNU AGPL version 3 section 7, you may 
+ *   distribute UNMODIFIED VERSIONS OF THIS file without the copy of the GNU 
+ *   AGPL normally required by section 4, provided you include this license 
+ *   notice and a URL through which recipients can access the Corresponding 
+ *   Source.
+ */
+
+import * as cssTree from "./../vendor/css-tree.js";
+
+export {
+    computeSpecificity,
+    computeMaxSpecificity
+};
+
+function computeSpecificity(selector, specificity = { a: 0, b: 0, c: 0 }) {
+    if (!selector || !selector.type) {
+        return specificity;
+    }
+    switch (selector.type) {
+        case "Selector":
+            traverseChildren(selector.children, (child) => computeSpecificity(child, specificity));
+            break;
+
+        case "IdSelector":
+            specificity.a++;
+            break;
+
+        case "ClassSelector":
+            specificity.b++;
+            break;
+
+        case "AttributeSelector":
+            specificity.b++;
+            break;
+
+        case "TypeSelector":
+            if (selector.name !== "*") {
+                specificity.c++;
+            }
+            break;
+
+        case "PseudoElementSelector":
+            specificity.c++;
+            break;
+
+        case "PseudoClassSelector": {
+            const pseudoName = selector.name.toLowerCase();
+
+            if (pseudoName === "where") {
+                // :where() has zero specificity - do nothing
+                break;
+            }
+
+            if (pseudoName === "is" || pseudoName === "not" || pseudoName === "has") {
+                // :is(), :not(), :has() - use the max specificity from their selector list
+                traverseChildren(selector.children, (child) => {
+                    if (child.type === "SelectorList") {
+                        addMaxSpecificity(specificity, getMaxSpecificityFromList(child));
+                    }
+                });
+                break;
+            }
+
+            if (pseudoName === "nth-child" || pseudoName === "nth-last-child") {
+                // :nth-child() and :nth-last-child() count as one pseudo-class
+                specificity.b++;
+
+                // Plus the max specificity from their selector list (if any)
+                traverseChildren(selector.children, (child) => {
+                    if (child.type === "Nth" && child.selector) {
+                        addMaxSpecificity(specificity, getMaxSpecificityFromList(child.selector));
+                    }
+                });
+                break;
+            }
+
+            // Regular pseudo-classes contribute to 'b'
+            // Exception: :scope is treated as a type selector (contributes to 'c')
+            if (pseudoName === "scope") {
+                specificity.c++;
+            } else {
+                specificity.b++;
+            }
+            break;
+        }
+
+        case "Combinator":
+        case "Raw":
+            break;
+    }
+
+    return specificity;
+}
+
+function addMaxSpecificity(specificity, maxSpec) {
+    specificity.a += maxSpec.a;
+    specificity.b += maxSpec.b;
+    specificity.c += maxSpec.c;
+}
+
+function traverseChildren(children, callback) {
+    if (!children) return;
+
+    let current = children.head;
+    while (current) {
+        callback(current.data);
+        current = current.next;
+    }
+}
+
+function getMaxSpecificityFromList(selectorList) {
+    let maxSpec = { a: 0, b: 0, c: 0 };
+
+    traverseChildren(selectorList.children, (selector) => {
+        const spec = computeSpecificity(selector, { a: 0, b: 0, c: 0 });
+        if (spec.a > maxSpec.a ||
+            (spec.a === maxSpec.a && spec.b > maxSpec.b) ||
+            (spec.a === maxSpec.a && spec.b === maxSpec.b && spec.c > maxSpec.c)) {
+            maxSpec = spec;
+        }
+    });
+
+    return maxSpec;
+}
+
+function computeMaxSpecificity(selector, ancestorsSelectors) {
+    // If no ancestors provided, keep existing behavior
+    if (!ancestorsSelectors || !ancestorsSelectors.length) {
+        let maxSpecificity = { a: 0, b: 0, c: 0 };
+        const stack = [];
+        cssTree.walk(selector, {
+            enter(node) {
+                stack.push(node);
+                if (node.type === "Selector") {
+                    const insideWhere = stack.some(n => n.type === "PseudoClassSelector" && n.name === "where");
+                    if (insideWhere) return;
+                    const specificity = computeSpecificity(node);
+                    if (specificity.a > maxSpecificity.a ||
+                        (specificity.a === maxSpecificity.a && specificity.b > maxSpecificity.b) ||
+                        (specificity.a === maxSpecificity.a && specificity.b === maxSpecificity.b && specificity.c > maxSpecificity.c)) {
+                        maxSpecificity = specificity;
+                    }
+                }
+            },
+            leave() {
+                stack.pop();
+            }
+        });
+        return maxSpecificity;
+    }
+
+    // When ancestors are provided, compute specificity for every expanded selector
+    // Build context strings for ancestors (similar to combineWithAncestors behavior)
+    const childText = cssTree.generate(selector);
+    let contexts = [""];
+    ancestorsSelectors.forEach(selectorList => {
+        if (!selectorList || !selectorList.children || !selectorList.children.size) return;
+        const parentSelectors = selectorList.children.toArray();
+        const nextContexts = [];
+        contexts.forEach(context => parentSelectors.forEach(parentSelector => {
+            const parentText = cssTree.generate(parentSelector);
+            const combined = context ? context + " " + parentText : parentText;
+            if (!nextContexts.includes(combined)) nextContexts.push(combined);
+        }));
+        if (nextContexts.length) contexts = nextContexts;
+    });
+
+    function combineStrings(context, child) {
+        if (!context) return child;
+        if (!child) return context;
+        if (child.indexOf("&") !== -1) return child.split("&").join(context);
+        return context + " " + child;
+    }
+
+    let maxSpecificity = { a: 0, b: 0, c: 0 };
+    const seen = new Set();
+    contexts.forEach(context => {
+        const full = combineStrings(context, childText);
+        if (seen.has(full)) return;
+        seen.add(full);
+        try {
+            const parsed = cssTree.parse(full, { context: "selectorList" });
+            // reuse original logic to compute max specificity over parsed AST
+            const spec = computeMaxSpecificity(parsed);
+            if (spec.a > maxSpecificity.a ||
+                (spec.a === maxSpecificity.a && spec.b > maxSpecificity.b) ||
+                (spec.a === maxSpecificity.a && spec.b === maxSpecificity.b && spec.c > maxSpecificity.c)) {
+                maxSpecificity = spec;
+            }
+        } catch {
+            // ignore parse errors and continue
+        }
+    });
+    return maxSpecificity;
+}

package/modules/html-serializer.js

@@ -147,17 +147,22 @@ function serializeAttribute(attribute, element, compressHTML) {
 		}
 		const invalidUnquotedValue = !compressHTML || value.match(/[ \t\n\f\r'"`=<>]/);
 		content += " ";
-		if (!attribute.namespace) {
+		const namespaceURI = attribute.namespaceURI;
+		const localName = attribute.localName || name;
+		if (!namespaceURI) {
 			content += name;
-		} else if (attribute.namespaceURI == "http://www.w3.org/XML/1998/namespace") {
-			content += "xml:" + name;
-		} else if (attribute.namespaceURI == "http://www.w3.org/2000/xmlns/") {
-			if (name !== "xmlns") {
-				content += "xmlns:";
+		} else if (namespaceURI == "http://www.w3.org/XML/1998/namespace") {
+			content += "xml:" + localName;
+		} else if (namespaceURI == "http://www.w3.org/2000/xmlns/") {
+			if (localName === "xmlns") {
+				content += "xmlns";
+			} else {
+				content += "xmlns:" + localName;
 			}
-			content += name;
-		} else if (attribute.namespaceURI == "http://www.w3.org/1999/xlink") {
-			content += "xlink:" + name;
+		} else if (namespaceURI == "http://www.w3.org/1999/xlink") {
+			content += "xlink:" + localName;
+		} else if (attribute.prefix) {
+			content += attribute.prefix + ":" + localName;
 		} else {
 			content += name;
 		}

package/modules/index.js

@@ -22,7 +22,6 @@
  */
 
 import * as fontsMinifier from "./css-fonts-minifier.js";
-import * as matchedRules from "./css-matched-rules.js";
 import * as mediasAltMinifier from "./css-medias-alt-minifier.js";
 import * as cssRulesMinifier from "./css-rules-minifier.js";
 import * as imagesAltMinifier from "./html-images-alt-minifier.js";
@@ -32,7 +31,6 @@ import * as templateFormatter from "./template-formatter.js";
 
 export {
 	fontsMinifier,
-	matchedRules,
 	mediasAltMinifier,
 	cssRulesMinifier,
 	imagesAltMinifier,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "single-file-core",
-  "version": "1.5.48",
+  "version": "1.5.49",
   "description": "SingleFile Core",
   "author": "Gildas Lormeau",
   "license": "AGPL-3.0-or-later",
@@ -16,6 +16,6 @@
   },
   "homepage": "https://github.com/gildas-lormeau/single-file-core#readme",
   "devDependencies": {
-    "eslint": "^9.20.1"
+    "eslint": "^9.38.0"
   }
 }