single-file-core 1.6.9 → 1.6.11

package/modules/css-selector-sanitizer.js

@@ -23,9 +23,11 @@
  */
 
 import * as cssTree from "./../vendor/css-tree.js";
+import { decodeName } from "./css-identifier.js";
 
 const TREE_STRUCTURAL_PSEUDO_CLASSES = [
     "root",
+    "scope",
     "empty",
     "first-child",
     "last-child",
@@ -47,6 +49,10 @@ const FUNCTIONAL_PSEUDO_CLASSES = [
     "where",
     "has"
 ];
+const MATCHING_FUNCTIONAL_PSEUDO_CLASSES = [
+    "is",
+    "where"
+];
 const STATE_ATTRIBUTE_NAMES = [
     "open"
 ];
@@ -56,15 +62,15 @@ export {
     sanitizeSelector,
 };
 
-function sanitizeSelector(selector, ancestors, docContext) {
+function sanitizeSelector(selector, docContext) {
     if (!docContext.normalizedSelectorText) {
         docContext.normalizedSelectorText = new WeakMap();
     }
     if (docContext.normalizedSelectorText.has(selector)) {
         return docContext.normalizedSelectorText.get(selector);
     }
-    const ast = cssTree.parse(cssTree.generate(selector.data), { context: "selectorList" });
-    normalizeSelectorNode(ast, ancestors);
+    const ast = copySelectorNode(selector.data);
+    normalizeSelectorNode(ast);
     let normalized = cssTree.generate(ast);
     if (!normalized || !normalized.trim()) {
         normalized = "*";
@@ -73,26 +79,19 @@ function sanitizeSelector(selector, ancestors, docContext) {
     return normalized;
 }
 
-function normalizeSelectorNode(selector, ancestors) {
+function copySelectorNode(node) {
+    // A node with no children is a Raw one, which clone would hand back raw where the round-trip
+    // parses it into the selector list the rest of this module walks.
+    return node.children ? cssTree.clone(node) : cssTree.parse(cssTree.generate(node), { context: "selectorList" });
+}
+
+function normalizeSelectorNode(selector) {
     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);
-                }
-            }
+            selector.children.replace(current, cssTree.parse(":scope", { context: "selector" }).children.head);
         } 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") {
@@ -100,13 +99,15 @@ function normalizeSelectorNode(selector, ancestors) {
         } else if (childNode.type === "PseudoClassSelector") {
             if (matchUnqueryablePseudoClass(childNode)) {
                 removeNode(selector.children, current);
+            } else if (childNode.children && MATCHING_FUNCTIONAL_PSEUDO_CLASSES.includes(childNode.name.toLowerCase())) {
+                normalizeSelectorNode(childNode.children.head.data);
             }
         } else if (childNode.type === "AttributeSelector") {
             if (matchUnqueryableAttributeSelector(childNode)) {
                 removeNode(selector.children, current);
             }
         } else if (childNode.type === "Selector") {
-            normalizeSelectorNode(childNode, ancestors);
+            normalizeSelectorNode(childNode);
         }
         current = next;
     }
@@ -121,13 +122,16 @@ function removeNode(list, item) {
 }
 
 function matchUnqueryableAttributeSelector(attributeSelector) {
-    return Boolean(attributeSelector.name) && STATE_ATTRIBUTE_NAMES.includes(attributeSelector.name.name.toLowerCase());
+    return Boolean(attributeSelector.name) && STATE_ATTRIBUTE_NAMES.includes(decodeName(attributeSelector.name.name));
 }
 
 function matchUnqueryablePseudoClass(pseudoClass) {
-    const name = pseudoClass.name.toLowerCase();
+    // A functional pseudo-class is compared by spelling on purpose: css-tree recognises the known
+    // names by spelling too, so it parses the argument of an escaped one as Raw rather than as a
+    // selector list, and reading `:i\73 (…)` as `:is(…)` would hand the rest of the pass an argument
+    // it cannot walk. Leaving it unrecognised keeps it unqueryable, which is the safe answer.
     return pseudoClass.children ? (
-        !TREE_STRUCTURAL_FUNCTIONAL_PSEUDO_CLASSES.includes(name) &&
-        !FUNCTIONAL_PSEUDO_CLASSES.includes(name)
-    ) : !TREE_STRUCTURAL_PSEUDO_CLASSES.includes(name);
+        !TREE_STRUCTURAL_FUNCTIONAL_PSEUDO_CLASSES.includes(pseudoClass.name.toLowerCase()) &&
+        !FUNCTIONAL_PSEUDO_CLASSES.includes(pseudoClass.name.toLowerCase())
+    ) : !TREE_STRUCTURAL_PSEUDO_CLASSES.includes(decodeName(pseudoClass.name));
 }

package/modules/css-specificity.js

@@ -91,12 +91,7 @@ function computeSpecificity(selector, specificity = { a: 0, b: 0, c: 0 }) {
             }
 
             // 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++;
-            }
+            specificity.b++;
             break;
         }
 
@@ -139,75 +134,25 @@ function getMaxSpecificityFromList(selectorList) {
     return maxSpec;
 }
 
-function computeMaxSpecificity(selector, ancestorsSelectors, scopeStack) {
-    // 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();
-            }
-        });
-        if (scopeStack && scopeStack.length) {
-            maxSpecificity.b++;
-        }
-        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;
-    }
-
+function computeMaxSpecificity(selector) {
     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;
+    const stack = [];
+    cssTree.walk(selector, {
+        enter(node) {
+            stack.push(node);
+            if (node.type === "Selector") {
+                const insideWhere = stack.some(n => n.type === "PseudoClassSelector" && n.name.toLowerCase() === "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;
+                }
             }
-        } catch {
-            // ignore parse errors and continue
+        },
+        leave() {
+            stack.pop();
         }
     });
     return maxSpecificity;

package/modules/template-formatter.js

@@ -17336,6 +17336,7 @@ function getFilteredOptions(options) {
 	delete filteredOptions.stylesheets;
 	delete filteredOptions.images;
 	delete filteredOptions.posters;
+	delete filteredOptions.generatedDataURIs;
 	delete filteredOptions.videos;
 	delete filteredOptions.shadowRoots;
 	delete filteredOptions.referrer;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "single-file-core",
-	"version": "1.6.9",
+	"version": "1.6.11",
 	"description": "SingleFile Core",
 	"author": "Gildas Lormeau",
 	"license": "AGPL-3.0-or-later",