single-file-core 1.6.22 → 1.6.23

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

@@ -25,79 +25,79 @@ 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
+	parsePrelude
 };
 
 function parsePrelude(prelude) {
-  if (!prelude) {
-    return { include: [], exclude: [] };
-  }
+	if (!prelude) {
+		return { include: [], exclude: [] };
+	}
 
-  const scopeNode = findScopeNode(prelude);
-  if (!scopeNode) {
-    return { include: [], exclude: [] };
-  }
+	const scopeNode = findScopeNode(prelude);
+	if (!scopeNode) {
+		return { include: [], exclude: [] };
+	}
 
-  const include = extractSelectorList(scopeNode.root);
-  const exclude = extractSelectorList(scopeNode.limit);
+	const include = extractSelectorList(scopeNode.root);
+	const exclude = extractSelectorList(scopeNode.limit);
 
-  // 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;
-  }
+	// 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.data)) {
-      throw new Error("Pseudo-elements are not allowed in @scope prelude (scope-start)");
-    }
-  }
-  for (const s of exclude) {
-    if (containsPseudoElement(s.data)) {
-      throw new Error("Pseudo-elements are not allowed in @scope prelude (scope-end)");
-    }
-  }
+	for (const s of include) {
+		if (containsPseudoElement(s.data)) {
+			throw new Error("Pseudo-elements are not allowed in @scope prelude (scope-start)");
+		}
+	}
+	for (const s of exclude) {
+		if (containsPseudoElement(s.data)) {
+			throw new Error("Pseudo-elements are not allowed in @scope prelude (scope-end)");
+		}
+	}
 
-  return { include, exclude };
+	return { include, exclude };
 }
 
 function findScopeNode(prelude) {
-  if (!prelude || !prelude.children) {
-    return null;
-  }
-  for (let node = prelude.children.head; node; node = node.next) {
-    if (node.data && node.data.type === "Scope") {
-      return node.data;
-    }
-  }
-  return null;
+	if (!prelude || !prelude.children) {
+		return null;
+	}
+	for (let node = prelude.children.head; node; node = node.next) {
+		if (node.data && node.data.type === "Scope") {
+			return node.data;
+		}
+	}
+	return null;
 }
 
 function extractSelectorList(selectorList) {
-  if (!selectorList || !selectorList.children) {
-    return [];
-  }
-  const selectors = [];
-  for (let node = selectorList.children.head; node; node = node.next) {
-    const selector = node.data;
-    selectors.push({ data: selector, text: cssTree.generate(selector) });
-  }
-  return selectors;
+	if (!selectorList || !selectorList.children) {
+		return [];
+	}
+	const selectors = [];
+	for (let node = selectorList.children.head; node; node = node.next) {
+		const selector = node.data;
+		selectors.push({ data: selector, text: cssTree.generate(selector) });
+	}
+	return selectors;
 }

package/modules/css-selector-sanitizer.js

@@ -26,112 +26,112 @@ 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",
-    "only-child",
-    "first-of-type",
-    "last-of-type",
-    "only-of-type"
+	"root",
+	"scope",
+	"empty",
+	"first-child",
+	"last-child",
+	"only-child",
+	"first-of-type",
+	"last-of-type",
+	"only-of-type"
 ];
 const TREE_STRUCTURAL_FUNCTIONAL_PSEUDO_CLASSES = [
-    "nth-child",
-    "nth-last-child",
-    "heading",
-    "nth-of-type",
-    "nth-last-of-type"
+	"nth-child",
+	"nth-last-child",
+	"heading",
+	"nth-of-type",
+	"nth-last-of-type"
 ];
 const FUNCTIONAL_PSEUDO_CLASSES = [
-    "not",
-    "is",
-    "where",
-    "has"
+	"not",
+	"is",
+	"where",
+	"has"
 ];
 const MATCHING_FUNCTIONAL_PSEUDO_CLASSES = [
-    "is",
-    "where"
+	"is",
+	"where"
 ];
 const STATE_ATTRIBUTE_NAMES = [
-    "open"
+	"open"
 ];
 export {
-    matchUnqueryableAttributeSelector,
-    matchUnqueryablePseudoClass,
-    sanitizeSelector,
+	matchUnqueryableAttributeSelector,
+	matchUnqueryablePseudoClass,
+	sanitizeSelector,
 };
 
 function sanitizeSelector(selector, docContext) {
-    if (!docContext.normalizedSelectorText) {
-        docContext.normalizedSelectorText = new WeakMap();
-    }
-    if (docContext.normalizedSelectorText.has(selector)) {
-        return docContext.normalizedSelectorText.get(selector);
-    }
-    const ast = copySelectorNode(selector.data);
-    normalizeSelectorNode(ast);
-    let normalized = cssTree.generate(ast);
-    if (!normalized || !normalized.trim()) {
-        normalized = "*";
-    }
-    docContext.normalizedSelectorText.set(selector, normalized);
-    return normalized;
+	if (!docContext.normalizedSelectorText) {
+		docContext.normalizedSelectorText = new WeakMap();
+	}
+	if (docContext.normalizedSelectorText.has(selector)) {
+		return docContext.normalizedSelectorText.get(selector);
+	}
+	const ast = copySelectorNode(selector.data);
+	normalizeSelectorNode(ast);
+	let normalized = cssTree.generate(ast);
+	if (!normalized || !normalized.trim()) {
+		normalized = "*";
+	}
+	docContext.normalizedSelectorText.set(selector, normalized);
+	return normalized;
 }
 
 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" });
+	// 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") {
-            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") {
-            selector.children.remove(current);
-        } 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);
-        }
-        current = next;
-    }
+	let current = selector.children.head;
+	while (current) {
+		const next = current.next;
+		const childNode = current.data;
+		if (childNode.type === "NestingSelector") {
+			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") {
+			selector.children.remove(current);
+		} 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);
+		}
+		current = next;
+	}
 }
 
 function removeNode(list, item) {
-    if (item.prev == null || item.prev.data.type == "Combinator" || item.prev.data.type == "WhiteSpace") {
-        list.replace(item, cssTree.parse("*", { context: "selector" }).children.head);
-    } else {
-        list.remove(item);
-    }
+	if (item.prev == null || item.prev.data.type == "Combinator" || item.prev.data.type == "WhiteSpace") {
+		list.replace(item, cssTree.parse("*", { context: "selector" }).children.head);
+	} else {
+		list.remove(item);
+	}
 }
 
 function matchUnqueryableAttributeSelector(attributeSelector) {
-    return Boolean(attributeSelector.name) && STATE_ATTRIBUTE_NAMES.includes(decodeName(attributeSelector.name.name));
+	return Boolean(attributeSelector.name) && STATE_ATTRIBUTE_NAMES.includes(decodeName(attributeSelector.name.name));
 }
 
 function matchUnqueryablePseudoClass(pseudoClass) {
-    // 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(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(pseudoClass.name.toLowerCase()) &&
         !FUNCTIONAL_PSEUDO_CLASSES.includes(pseudoClass.name.toLowerCase())
-    ) : !TREE_STRUCTURAL_PSEUDO_CLASSES.includes(decodeName(pseudoClass.name));
+	) : !TREE_STRUCTURAL_PSEUDO_CLASSES.includes(decodeName(pseudoClass.name));
 }

package/modules/css-specificity.js

@@ -22,138 +22,166 @@
  */
 
 import * as cssTree from "./../vendor/css-tree.js";
+import { decodeName } from "./css-identifier.js";
+
+const PSEUDO_ELEMENT_SYNONYMS = new Set(["after", "before", "first-letter", "first-line"]);
+const SELECTOR_ARGUMENT_PSEUDO_CLASSES = new Set(["host", "host-context"]);
+const SELECTOR_ARGUMENT_PSEUDO_ELEMENTS = new Set(["slotted"]);
 
 export {
-    computeSpecificity,
-    computeMaxSpecificity
+	computeSpecificity,
+	computeMaxSpecificity,
+	PSEUDO_ELEMENT_SYNONYMS
 };
 
 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'
-            specificity.b++;
-            break;
-        }
-
-        case "Combinator":
-        case "Raw":
-            break;
-    }
-
-    return specificity;
+	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++;
+			if (SELECTOR_ARGUMENT_PSEUDO_ELEMENTS.has(decodeName(selector.name))) {
+				addArgumentSpecificity(specificity, selector);
+			}
+			break;
+
+		case "PseudoClassSelector": {
+			const pseudoName = decodeName(selector.name);
+
+			if (pseudoName === "where") {
+				// :where() has zero specificity - do nothing
+				break;
+			}
+
+			if (PSEUDO_ELEMENT_SYNONYMS.has(pseudoName)) {
+				specificity.c++;
+				break;
+			}
+
+			if (SELECTOR_ARGUMENT_PSEUDO_CLASSES.has(pseudoName)) {
+				specificity.b++;
+				addArgumentSpecificity(specificity, selector);
+				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'
+			specificity.b++;
+			break;
+		}
+
+		case "Combinator":
+		case "Raw":
+			break;
+	}
+
+	return specificity;
+}
+
+function addArgumentSpecificity(specificity, selector) {
+	traverseChildren(selector.children, (child) => {
+		if (child.type === "Selector") {
+			addMaxSpecificity(specificity, computeSpecificity(child, { a: 0, b: 0, c: 0 }));
+		}
+	});
 }
 
 function addMaxSpecificity(specificity, maxSpec) {
-    specificity.a += maxSpec.a;
-    specificity.b += maxSpec.b;
-    specificity.c += maxSpec.c;
+	specificity.a += maxSpec.a;
+	specificity.b += maxSpec.b;
+	specificity.c += maxSpec.c;
 }
 
 function traverseChildren(children, callback) {
-    if (!children) return;
+	if (!children) return;
 
-    let current = children.head;
-    while (current) {
-        callback(current.data);
-        current = current.next;
-    }
+	let current = children.head;
+	while (current) {
+		callback(current.data);
+		current = current.next;
+	}
 }
 
 function getMaxSpecificityFromList(selectorList) {
-    let maxSpec = { a: 0, b: 0, c: 0 };
+	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 ||
+	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;
-        }
-    });
+			maxSpec = spec;
+		}
+	});
 
-    return maxSpec;
+	return maxSpec;
 }
 
 function computeMaxSpecificity(selector) {
-    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.toLowerCase() === "where");
-                if (insideWhere) return;
-                const specificity = computeSpecificity(node);
-                if (specificity.a > maxSpecificity.a ||
+	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.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;
-                }
-            }
-        },
-        leave() {
-            stack.pop();
-        }
-    });
-    return maxSpecificity;
+					maxSpecificity = specificity;
+				}
+			}
+		},
+		leave() {
+			stack.pop();
+		}
+	});
+	return maxSpecificity;
 }

package/modules/html-minifier.js

@@ -250,7 +250,7 @@ function compressJSONLD(node) {
 
 function removeEmptyInlineElements(doc) {
 	doc.querySelectorAll("style, script:not([src])").forEach(element => {
-		if (!element.textContent.trim()) {
+		if (!element.textContent.trim() && element.parentElement == doc.head) {
 			element.remove();
 		}
 	});

package/package.json

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

package/processors/compression/compression.js

@@ -988,9 +988,14 @@ async function getContent() {
 		}
 		let storedDirectoryOffset = view.getUint32(endOfDirectoryOffset + 16, true);
 		let directoryOffset = endOfDirectoryOffset - view.getUint32(endOfDirectoryOffset + 12, true);
+		let signature = 0x02014b50;
 		if (locatorOffset >= 0 && view.getUint32(locatorOffset, true) == 0x07064b50) {
 			storedDirectoryOffset = view.getUint32(locatorOffset + 8, true) + view.getUint32(locatorOffset + 12, true) * 0x100000000;
 			directoryOffset = locatorOffset - 56;
+			signature = 0x06064b50;
+		}
+		if (directoryOffset < 0 || view.getUint32(directoryOffset, true) != signature) {
+			return 0;
 		}
 		return Math.max(0, storedDirectoryOffset - directoryOffset);
 	}