single-file-core 1.6.22 → 1.6.24

package/core/index.js

@@ -911,7 +911,7 @@ class Processor {
 		const scriptElements = this.doc.querySelectorAll("script:not([type=\"application/ld+json\"]):not([" + SCRIPT_OPTIONS + "])");
 		this.stats.set("discarded", "scripts", scriptElements.length);
 		this.stats.set("processed", "scripts", scriptElements.length);
-		scriptElements.forEach(element => element.remove());
+		scriptElements.forEach(element => removeElement(element));
 	}
 
 	removeDiscardedResources() {
@@ -929,7 +929,7 @@ class Processor {
 				placeholderElement.replaceWith(noscriptElement);
 			});
 		} else {
-			this.doc.querySelectorAll("noscript").forEach(element => element.remove());
+			this.doc.querySelectorAll("noscript").forEach(element => removeElement(element));
 		}
 		this.doc.querySelectorAll("meta[http-equiv=refresh], meta[disabled-http-equiv]").forEach(element => element.remove());
 		this.doc.querySelectorAll("meta[http-equiv=\"content-security-policy\"]").forEach(element => element.remove());
@@ -946,13 +946,13 @@ class Processor {
 			if (relValue.length) {
 				element.setAttribute("rel", relValue);
 			} else {
-				element.remove();
+				removeElement(element);
 			}
 		});
 		this.processorHelper.removeUnusedStylesheets(this.doc);
 		this.doc.querySelectorAll("link[rel*=stylesheet]:not([href]),link[rel*=stylesheet][href=\"\"]").forEach(element => element.remove());
 		if (this.options.removeHiddenElements) {
-			this.doc.querySelectorAll("input[type=hidden]").forEach(element => element.remove());
+			this.doc.querySelectorAll("input[type=hidden]").forEach(element => removeElement(element));
 		}
 		if (this.options.removedElementsSelector) {
 			try {
@@ -1075,6 +1075,9 @@ class Processor {
 	moveStylesInHead() {
 		this.doc.querySelectorAll("style").forEach(stylesheet => {
 			if (stylesheet.getAttribute(util.STYLE_ATTRIBUTE_NAME) == "") {
+				if (testSiblingPositionKept(stylesheet)) {
+					stylesheet.before(createPlaceholderElement(stylesheet));
+				}
 				this.doc.head.appendChild(stylesheet);
 			}
 		});
@@ -1816,6 +1819,26 @@ function normalizeURL(url) {
 	}
 }
 
+function removeElement(element) {
+	if (testSiblingPositionKept(element)) {
+		element.replaceWith(createPlaceholderElement(element));
+	} else {
+		element.remove();
+	}
+}
+
+function testSiblingPositionKept(element) {
+	return Boolean(element.parentElement) && element.parentElement != element.ownerDocument.head;
+}
+
+function createPlaceholderElement(element) {
+	const placeholderElement = element.ownerDocument.createElementNS(element.namespaceURI, element.localName);
+	if (element.localName == "input") {
+		placeholderElement.setAttribute("type", "hidden");
+	}
+	return placeholderElement;
+}
+
 function isScriptURI(value) {
 	try {
 		return new URL(value).protocol == JAVASCRIPT_URI_PROTOCOL;

package/core/lib/processor-helper-common.js

@@ -29,6 +29,8 @@ import {
 	getDataURI
 } from "./../helper.js";
 import { serialize as serializeSrcset } from "./../../vendor/html-srcset-parser.js";
+import { getNestedChildren } from "./../../modules/css-nested-rules.js";
+import { decodeName } from "./../../modules/css-identifier.js";
 
 const DATA_URI_PREFIX = "data:";
 const ABOUT_BLANK_URI = "about:blank";
@@ -50,7 +52,9 @@ const REGEXP_DOUBLE_QUOTES_STRING = /^"(.*?)"$/;
 const REGEXP_URL_FUNCTION_WOFF = /^url\(\s*["']?data:font\/(woff2?)/;
 const REGEXP_URL_FUNCTION_WOFF_ALT = /^url\(\s*["']?data:application\/x-font-(woff)/;
 const REGEXP_FONT_FORMAT = /\.([^.?#]+)((\?|#).*?)?$/;
-const REGEXP_FONT_FORMAT_VALUE = /format\((.*?)\)\s*,?$/;
+const REGEXP_FONT_FORMAT_VALUE = /format\(\s*([^)]*?)\s*\)/;
+const REGEXP_FONT_TECH_VALUE = /tech\(\s*([^)]*?)\s*\)/;
+const REGEXP_FONT_FORMAT_SUPPORTS = /^(\S+)\s+supports\s+(.+)$/;
 const REGEXP_FONT_SRC = /(.*?)\s*,?$/;
 const MEDIA_ALL = "all";
 const Blob = globalThis.Blob;
@@ -173,7 +177,7 @@ class ProcessorHelperCommon {
 		}));
 	}
 
-	async processStylesheet(cssRules, baseURI, options, resources, batchRequest) {
+	async processStylesheet(cssRules, baseURI, options, resources, batchRequest, fontFaceInvalid = false) {
 		const promises = [];
 		const removedRules = [];
 		const processorHelper = this;
@@ -182,13 +186,22 @@ class ProcessorHelperCommon {
 			if (ruleData.type == "Atrule" && ruleData.name == "charset") {
 				removedRules.push(cssRule);
 			} else if (ruleData.block && ruleData.block.children) {
-				if (ruleData.type == "Rule") {
+				if (ruleData.type == "Atrule" && decodeName(ruleData.name) == "font-face") {
+					if (fontFaceInvalid) {
+						removedRules.push(cssRule);
+					} else {
+						promises.push(processFontFaceRule(ruleData));
+					}
+				} else if (ruleData.type == "Rule") {
+					removeFontFaceRules(ruleData.block.children);
+					promises.push(processorHelper.processStyle(ruleData, options, resources, batchRequest));
+				} else if (ruleData.type == "Atrule" && getNestedChildren(ruleData)) {
+					promises.push(processorHelper.processStylesheet(ruleData.block.children, baseURI, options, resources, batchRequest, fontFaceInvalid || decodeName(ruleData.name) == "scope"));
+				} else {
 					promises.push(processorHelper.processStyle(ruleData, options, resources, batchRequest));
-				} else if (ruleData.type == "Atrule" && (ruleData.name == "media" || ruleData.name == "supports" || ruleData.name == "layer" || ruleData.name == "container")) {
-					promises.push(processorHelper.processStylesheet(ruleData.block.children, baseURI, options, resources, batchRequest));
-				} else if (ruleData.type == "Atrule" && ruleData.name == "font-face") {
-					promises.push(processFontFaceRule(ruleData));
 				}
+			} else if (ruleData.type == "Declaration") {
+				promises.push(processorHelper.processStyle(ruleData, options, resources, batchRequest));
 			}
 		}
 		removedRules.forEach(cssRule => cssRules.remove(cssRule));
@@ -572,6 +585,7 @@ class ProcessorHelperCommon {
 			this.getPropertyValue(ruleData, "font-style") || "normal",
 			this.getPropertyValue(ruleData, "unicode-range"),
 			getFontStretch(this.getPropertyValue(ruleData, "font-stretch")),
+			this.getPropertyValue(ruleData, "font-width"),
 			this.getPropertyValue(ruleData, "font-variant") || "normal",
 			this.getPropertyValue(ruleData, "font-feature-settings"),
 			this.getPropertyValue(ruleData, "font-variation-settings"),
@@ -609,10 +623,19 @@ function processFontDetails(fontsDetails, fontResources) {
 	fontsDetails.fonts.forEach((fontInfo, fontKey) => {
 		fontsDetails.fonts.set(fontKey, fontInfo.map(fontSource => {
 			const fontFormatMatch = fontSource.match(REGEXP_FONT_FORMAT_VALUE);
-			let fontFormat;
+			const fontTechMatch = fontSource.match(REGEXP_FONT_TECH_VALUE);
+			let fontFormat, fontTech;
 			const fontUrl = getURL(fontSource);
 			if (fontFormatMatch && fontFormatMatch[1]) {
 				fontFormat = fontFormatMatch[1].replace(REGEXP_SIMPLE_QUOTES_STRING, "$1").replace(REGEXP_DOUBLE_QUOTES_STRING, "$1").toLowerCase();
+				const fontFormatSupportsMatch = fontFormat.match(REGEXP_FONT_FORMAT_SUPPORTS);
+				if (fontFormatSupportsMatch) {
+					fontFormat = fontFormatSupportsMatch[1];
+					fontTech = fontFormatSupportsMatch[2];
+				}
+			}
+			if (fontTechMatch && fontTechMatch[1]) {
+				fontTech = fontTechMatch[1].toLowerCase();
 			}
 			if (!fontFormat) {
 				const fontFormatMatch = fontSource.match(REGEXP_URL_FUNCTION_WOFF);
@@ -633,9 +656,9 @@ function processFontDetails(fontsDetails, fontResources) {
 			}
 			if (fontResources) {
 				const fontResource = Array.from(fontResources.values()).find(info => info.name == fontUrl);
-				return { src: fontSource.match(REGEXP_FONT_SRC)[1], fontUrl, format: fontFormat, contentType: fontResource && fontResource.contentType };
+				return { src: fontSource.match(REGEXP_FONT_SRC)[1], fontUrl, format: fontFormat, tech: fontTech, contentType: fontResource && fontResource.contentType };
 			} else {
-				return { src: fontSource.match(REGEXP_FONT_SRC)[1], fontUrl, format: fontFormat };
+				return { src: fontSource.match(REGEXP_FONT_SRC)[1], fontUrl, format: fontFormat, tech: fontTech };
 			}
 		}));
 	});
@@ -681,6 +704,22 @@ function getCharset(stylesheetContent = "") {
 	}
 }
 
+function removeFontFaceRules(cssRules) {
+	const removedRules = [];
+	for (let cssRule = cssRules.head; cssRule; cssRule = cssRule.next) {
+		const ruleData = cssRule.data;
+		if (ruleData.type == "Atrule" && decodeName(ruleData.name) == "font-face") {
+			removedRules.push(cssRule);
+		} else {
+			const children = getNestedChildren(ruleData);
+			if (children) {
+				removeFontFaceRules(children);
+			}
+		}
+	}
+	removedRules.forEach(cssRule => cssRules.remove(cssRule));
+}
+
 function getUrlFunctions(declarationList) {
 	return cssTree.findAll(declarationList, node => node.type == "Url");
 }

package/core/lib/processor-helper-inline.js

@@ -731,8 +731,8 @@ function getProcessorHelperClass(utilInstance) {
 						fontTests.set(source.src, source.valid);
 					}
 				}));
-				const findSourceByFormat = (fontFormat, testValidity) => util.findLast(fontInfo, source => !source.src.match(EMPTY_URL_SOURCE) && source.format == fontFormat && (!testValidity || source.valid));
-				const filterSources = fontSource => fontInfo.filter(source => source == fontSource || source.src.startsWith(LOCAL_SOURCE));
+				const findSourceByFormat = (fontFormat, testValidity) => util.findLast(fontInfo, source => !source.src.match(EMPTY_URL_SOURCE) && !source.tech && source.format == fontFormat && (!testValidity || source.valid));
+				const filterSources = fontSource => fontInfo.filter(source => source == fontSource || source.src.startsWith(LOCAL_SOURCE) || (source.tech && source.valid));
 				stats.fonts.processed += fontInfo.length;
 				stats.fonts.discarded += fontInfo.length;
 				const woffFontFound =

package/core/lib/processor-helper.js

@@ -645,9 +645,9 @@ function getProcessorHelperClass(utilInstance) {
 					fontTests.set(source.src, source.valid);
 				}
 			}));
-			const findSourceByFormat = (fontFormat, testValidity) => util.findLast(fontInfo, source => !source.src.match(EMPTY_URL_SOURCE) && source.format == fontFormat && (!testValidity || source.valid));
-			const findSourceByContentType = (contentType, testValidity) => util.findLast(fontInfo, source => !source.src.match(EMPTY_URL_SOURCE) && source.contentType == contentType && (!testValidity || source.valid));
-			const filterSources = fontSource => fontInfo.filter(source => source == fontSource || source.src.startsWith(LOCAL_SOURCE));
+			const findSourceByFormat = (fontFormat, testValidity) => util.findLast(fontInfo, source => !source.src.match(EMPTY_URL_SOURCE) && !source.tech && source.format == fontFormat && (!testValidity || source.valid));
+			const findSourceByContentType = (contentType, testValidity) => util.findLast(fontInfo, source => !source.src.match(EMPTY_URL_SOURCE) && !source.tech && source.contentType == contentType && (!testValidity || source.valid));
+			const filterSources = fontSource => fontInfo.filter(source => source == fontSource || source.src.startsWith(LOCAL_SOURCE) || (source.tech && source.valid));
 			stats.fonts.processed += fontInfo.length;
 			stats.fonts.discarded += fontInfo.length;
 			const woffFontFound =

package/modules/css-fonts-minifier.js

@@ -23,6 +23,8 @@
 
 import * as cssTree from "./../vendor/css-tree.js";
 import * as fontPropertyParser from "./../vendor/css-font-property-parser.js";
+import { getNestedChildren } from "./css-nested-rules.js";
+import { decodeName } from "./css-identifier.js";
 import {
 	normalizeFontFamily,
 	flatten,
@@ -41,6 +43,9 @@ const helper = {
 	removeQuotes
 };
 
+const FONT_FACE_PARENT_AT_RULE_NAMES = ["media", "supports", "layer", "container"];
+const FONT_WIDTH_DESCRIPTOR_NAMES = ["font-stretch", "font-width"];
+const FONT_STRETCH_READINGS = ["fontStretch", "legacyFontStretch"];
 const REGEXP_COMMA = /\s*,\s*/;
 const REGEXP_SPACES = /\s+/g;
 const REGEXP_ANGLE = /^([-+]?(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?)(deg|grad|rad|turn)?$/;
@@ -173,40 +178,49 @@ function keepDeclaredFontIfRendered(familyName, fontsInfo, filteredUsedFonts, op
 	}
 }
 
-function getFontsInfo(cssRules, fontsInfo, options) {
+function getFontsInfo(cssRules, fontsInfo, options, fontFaceAllowed = true) {
 	cssRules.forEach(ruleData => {
-		if (ruleData.type == "Atrule" && (ruleData.name == "media" || ruleData.name == "supports" || ruleData.name == "layer" || ruleData.name == "container") && ruleData.block && ruleData.block.children) {
-			getFontsInfo(ruleData.block.children, fontsInfo, options);
-		} else if (ruleData.type == "Rule") {
-			const fontFamilyNames = getFontFamilyNames(ruleData.block, options);
-			if (fontFamilyNames.length) {
-				fontsInfo.used.push(fontFamilyNames);
-			}
-		} else {
-			if (ruleData.type == "Atrule" && ruleData.name == "font-face") {
+		if (ruleData.type == "Atrule" && ruleData.name == "font-face") {
+			if (fontFaceAllowed) {
 				const fontFamily = helper.normalizeFontFamily(getDeclarationValue(ruleData.block.children, "font-family"));
 				if (fontFamily) {
 					const fontWeight = getDeclarationValue(ruleData.block.children, "font-weight") || "400";
 					const fontStyle = getDeclarationValue(ruleData.block.children, "font-style") || "normal";
 					const fontVariant = getDeclarationValue(ruleData.block.children, "font-variant") || "normal";
-					const fontStretch = getDeclarationValue(ruleData.block.children, "font-stretch") || "normal";
+					const fontStretch = getDeclarationValue(ruleData.block.children, FONT_WIDTH_DESCRIPTOR_NAMES) || "normal";
+					const legacyFontStretch = getDeclarationValue(ruleData.block.children, "font-stretch") || "normal";
 					const unicodeRange = getDeclarationValue(ruleData.block.children, "unicode-range");
 					fontWeight.split(",").forEach(weightValue =>
-						fontsInfo.declared.push({ fontFamily, fontWeight: helper.getFontWeight(helper.removeQuotes(weightValue)), fontStyle, fontVariant, fontStretch, unicodeRange, ruleData }));
+						fontsInfo.declared.push({ fontFamily, fontWeight: helper.getFontWeight(helper.removeQuotes(weightValue)), fontStyle, fontVariant, fontStretch, legacyFontStretch, unicodeRange, ruleData }));
+				}
+			}
+		} else {
+			const children = getNestedChildren(ruleData);
+			if (children) {
+				const fontFamilyNames = getFontFamilyNames(ruleData.block, options);
+				if (fontFamilyNames.length) {
+					fontsInfo.used.push(fontFamilyNames);
 				}
+				getFontsInfo(children, fontsInfo, options, fontFaceAllowed && testFontFaceParent(ruleData));
 			}
 		}
 	});
 }
 
+function testFontFaceParent(ruleData) {
+	return ruleData.type == "Atrule" && typeof ruleData.name == "string" && FONT_FACE_PARENT_AT_RULE_NAMES.includes(decodeName(ruleData.name));
+}
+
 function getCustomPropertiesInfo(cssRules, customProperties) {
 	cssRules.forEach(ruleData => {
 		if (ruleData.type == "Atrule" && ruleData.name == "import" && ruleData.prelude && ruleData.prelude.children && ruleData.prelude.children.head.data.importedChildren) {
 			getCustomPropertiesInfo(ruleData.prelude.children.head.data.importedChildren, customProperties);
-		} else if (ruleData.type == "Atrule" && (ruleData.name == "media" || ruleData.name == "supports" || ruleData.name == "layer" || ruleData.name == "container") && ruleData.block && ruleData.block.children) {
-			getCustomPropertiesInfo(ruleData.block.children, customProperties);
-		} else if (ruleData.type == "Rule" && ruleData.block && ruleData.block.children) {
-			getCustomProperties(ruleData.block.children, customProperties);
+		} else {
+			const children = getNestedChildren(ruleData);
+			if (children) {
+				getCustomProperties(children, customProperties);
+				getCustomPropertiesInfo(children, customProperties);
+			}
 		}
 	});
 }
@@ -235,24 +249,20 @@ function getCustomProperties(declarations, customProperties) {
 }
 
 function getCustomPropertyValues(name, options) {
-	let values;
+	const values = new Set();
 	if (globalThis.getComputedStyle && options.doc) {
 		const computedValue = globalThis.getComputedStyle(options.doc.body).getPropertyValue(name);
 		if (computedValue && computedValue.trim()) {
-			values = [computedValue];
+			values.add(computedValue.trim());
 		}
 	}
-	if (!values) {
-		// the property is not inherited by the body: it is declared on a descendant, or in a
-		// media query that does not apply, so the value seen by the element using it cannot be
-		// determined here. Every value declared for it in the document is taken as a candidate,
-		// which still discards the fonts named by none of them
-		const declaredValues = options.customProperties && options.customProperties.get(name);
-		if (declaredValues && declaredValues.size) {
-			values = Array.from(declaredValues);
-		}
+	const declaredValues = options.customProperties && options.customProperties.get(name);
+	if (declaredValues) {
+		declaredValues.forEach(value => values.add(value));
+	}
+	if (values.size) {
+		return Array.from(values);
 	}
-	return values;
 }
 
 function resolveFamilyName(familyName, options, resolvedProperties = new Set()) {
@@ -325,7 +335,7 @@ function filterUnusedFonts(cssRules, declaredFonts, unusedFonts, selectedFonts,
 		const ruleData = cssRule.data;
 		if (ruleData.type == "Atrule" && ruleData.name == "import" && ruleData.prelude && ruleData.prelude.children && ruleData.prelude.children.head.data.importedChildren) {
 			filterUnusedFonts(ruleData.prelude.children.head.data.importedChildren, declaredFonts, unusedFonts, selectedFonts, docChars, usedFontsCharacters);
-		} else if (ruleData.type == "Atrule" && (ruleData.name == "media" || ruleData.name == "supports" || ruleData.name == "layer" || ruleData.name == "container") && ruleData.block && ruleData.block.children) {
+		} else if (testFontFaceParent(ruleData) && ruleData.block && ruleData.block.children) {
 			filterUnusedFonts(ruleData.block.children, declaredFonts, unusedFonts, selectedFonts, docChars, usedFontsCharacters);
 		} else if (ruleData.type == "Atrule" && ruleData.name == "font-face") {
 			const fontFamily = helper.normalizeFontFamily(getDeclarationValue(ruleData.block.children, "font-family"));
@@ -427,26 +437,27 @@ function testUsedFont(ruleData, familyName, selectedFonts) {
 function getSelectedFonts(declaredFonts, filteredUsedFonts) {
 	const selectedFonts = new Map();
 	filteredUsedFonts.forEach((usedFonts, familyName) => {
-		const fonts = declaredFonts
-			.filter(fontInfo => fontInfo.fontFamily == familyName)
+		const familyFonts = declaredFonts.filter(fontInfo => fontInfo.fontFamily == familyName);
+		const readings = familyFonts.some(fontInfo => fontInfo.legacyFontStretch != fontInfo.fontStretch) ? FONT_STRETCH_READINGS : FONT_STRETCH_READINGS.slice(0, 1);
+		const fontLists = readings.map(reading => familyFonts
 			.map(fontInfo => ({
 				ruleData: fontInfo.ruleData,
 				weight: parseFontWeight(fontInfo.fontWeight),
 				style: parseFontStyle(fontInfo.fontStyle),
-				stretch: parseFontStretch(fontInfo.fontStretch)
+				stretch: parseFontStretch(fontInfo[reading])
 			}))
-			.filter(fontInfo => fontInfo.weight && fontInfo.style && fontInfo.stretch);
-		const selection = { candidates: new Set(fonts.map(fontInfo => fontInfo.ruleData)), rules: new Set(), rulesByStyle: new Map() };
+			.filter(fontInfo => fontInfo.weight && fontInfo.style && fontInfo.stretch));
+		const selection = { candidates: new Set(helper.flatten(fontLists).map(fontInfo => fontInfo.ruleData)), rules: new Set(), rulesByStyle: new Map() };
 		usedFonts.forEach(([, fontWeight, fontStyle, , fontStretch]) => {
 			let styleRules = selection.rulesByStyle.get(fontStyle);
 			if (!styleRules) {
 				styleRules = new Set();
 				selection.rulesByStyle.set(fontStyle, styleRules);
 			}
-			FONT_MATCHING_ALGORITHMS.forEach(algorithm => selectFonts(fonts, fontWeight, fontStyle, fontStretch, algorithm).forEach(fontInfo => {
+			fontLists.forEach(fonts => FONT_MATCHING_ALGORITHMS.forEach(algorithm => selectFonts(fonts, fontWeight, fontStyle, fontStretch, algorithm).forEach(fontInfo => {
 				styleRules.add(fontInfo.ruleData);
 				selection.rules.add(fontInfo.ruleData);
-			}));
+			})));
 		});
 		selectedFonts.set(familyName, selection);
 	});
@@ -658,13 +669,21 @@ function parseRange(value, parseValue) {
 }
 
 function getDeclarationValue(declarations, propertyName) {
+	const value = getDeclarationText(declarations, propertyName);
+	if (value !== undefined) {
+		return value.toLowerCase();
+	}
+}
+
+function getDeclarationText(declarations, propertyName) {
+	const propertyNames = Array.isArray(propertyName) ? propertyName : [propertyName];
 	let property;
 	if (declarations) {
-		property = declarations.filter(declaration => declaration.property == propertyName).tail;
+		property = declarations.filter(declaration => propertyNames.includes(declaration.property)).tail;
 	}
 	if (property) {
 		try {
-			return helper.removeQuotes(cssTree.generate(property.data.value)).toLowerCase();
+			return helper.removeQuotes(cssTree.generate(property.data.value));
 			// eslint-disable-next-line no-unused-vars
 		} catch (error) {
 			// ignored
@@ -769,12 +788,10 @@ function parseFamilyNames(fontFamilyNameTokenData, fontFamilyNames) {
 
 function getRulesTextContent(doc, cssRules, workStylesheet, content) {
 	cssRules.forEach(ruleData => {
-		if (ruleData.block && ruleData.block.children && ruleData.prelude && ruleData.prelude.children) {
-			if (ruleData.type == "Atrule" && (ruleData.name == "media" || ruleData.name == "supports" || ruleData.name == "layer" || ruleData.name == "container")) {
-				content = getRulesTextContent(doc, ruleData.block.children, workStylesheet, content);
-			} else if (ruleData.type == "Rule") {
-				content = getDeclarationsTextContent(ruleData.block.children, workStylesheet, content);
-			}
+		const children = getNestedChildren(ruleData);
+		if (children) {
+			content = getDeclarationsTextContent(children, workStylesheet, content);
+			content = getRulesTextContent(doc, children, workStylesheet, content);
 		}
 	});
 	return content;
@@ -793,7 +810,7 @@ function getDeclarationsTextContent(declarations, workStylesheet, content) {
 }
 
 function getDeclarationUnescapedValue(declarations, property, workStylesheet) {
-	const rawValue = getDeclarationValue(declarations, property) || "";
+	const rawValue = getDeclarationText(declarations, property) || "";
 	if (rawValue) {
 		workStylesheet.textContent = "tmp { content:\"" + rawValue + "\"}";
 		if (workStylesheet.sheet && workStylesheet.sheet.cssRules) {
@@ -837,14 +854,15 @@ function getLaterUnicodeRanges(declaredFonts, ruleData) {
 	if (index == -1) {
 		return [];
 	}
-	const { fontFamily, fontWeight, fontStyle, fontStretch } = declaredFonts[index];
+	const { fontFamily, fontWeight, fontStyle, fontStretch, legacyFontStretch } = declaredFonts[index];
 	return declaredFonts
 		.slice(index + 1)
 		.filter(fontInfo => fontInfo.ruleData != ruleData &&
 			fontInfo.fontFamily == fontFamily &&
 			fontInfo.fontWeight == fontWeight &&
 			fontInfo.fontStyle == fontStyle &&
-			fontInfo.fontStretch == fontStretch)
+			fontInfo.fontStretch == fontStretch &&
+			fontInfo.legacyFontStretch == legacyFontStretch)
 		.map(fontInfo => fontInfo.unicodeRange);
 }
 

package/modules/css-media-query-utils.js

@@ -1,63 +1,63 @@
 import * as mediaQueryParser from "../vendor/css-media-query-parser.js";
 
 function parseMediaListSafe(mediaText) {
-    return mediaQueryParser.parseMediaList(mediaText);
+	return mediaQueryParser.parseMediaList(mediaText);
 }
 
 function containsNotKeyword(node) {
-    if (!node || !node.nodes) return false;
-    for (const token of node.nodes) {
-        if (token && token.type === "keyword" && token.value && token.value.toLowerCase() === "not") {
-            return true;
-        }
-    }
-    return false;
+	if (!node || !node.nodes) return false;
+	for (const token of node.nodes) {
+		if (token && token.type === "keyword" && token.value && token.value.toLowerCase() === "not") {
+			return true;
+		}
+	}
+	return false;
 }
 
 function isMediaTypeNegated(parentNode, index) {
-    for (let j = index - 1; j >= 0; j--) {
-        const prev = parentNode.nodes[j];
-        if (!prev) continue;
-        if (prev.type === "operator" && prev.value === ",") {
-            break;
-        }
-        if (prev.type === "keyword" && prev.value && prev.value.toLowerCase() === "not") {
-            return true;
-        }
-    }
-    return false;
+	for (let j = index - 1; j >= 0; j--) {
+		const prev = parentNode.nodes[j];
+		if (!prev) continue;
+		if (prev.type === "operator" && prev.value === ",") {
+			break;
+		}
+		if (prev.type === "keyword" && prev.value && prev.value.toLowerCase() === "not") {
+			return true;
+		}
+	}
+	return false;
 }
 
 function extractMediaTypes(parentNode, mediaTypes = []) {
-    for (let index = 0; index < parentNode.nodes.length; index++) {
-        const node = parentNode.nodes[index];
-        if (node.type == "media-query") {
-            extractMediaTypes(node, mediaTypes);
-            continue;
-        }
-        if (node.type == "media-type") {
-            const negated = isMediaTypeNegated(parentNode, index);
-            mediaTypes.push({ not: negated, value: node.value });
-        }
-    }
-    return mediaTypes;
+	for (let index = 0; index < parentNode.nodes.length; index++) {
+		const node = parentNode.nodes[index];
+		if (node.type == "media-query") {
+			extractMediaTypes(node, mediaTypes);
+			continue;
+		}
+		if (node.type == "media-type") {
+			const negated = isMediaTypeNegated(parentNode, index);
+			mediaTypes.push({ not: negated, value: node.value });
+		}
+	}
+	return mediaTypes;
 }
 
 function isFeaturefulOrCompound(node) {
-    if (!node || !node.nodes) return false;
-    for (const token of node.nodes) {
-        if (!token) continue;
-        if (token.type === "media-feature-expression") return true;
-        if (token.type === "keyword" && token.value && token.value.toLowerCase() === "and") return true;
-    }
-    if (containsNotKeyword(node)) return true;
-    return false;
+	if (!node || !node.nodes) return false;
+	for (const token of node.nodes) {
+		if (!token) continue;
+		if (token.type === "media-feature-expression") return true;
+		if (token.type === "keyword" && token.value && token.value.toLowerCase() === "and") return true;
+	}
+	if (containsNotKeyword(node)) return true;
+	return false;
 }
 
 export {
-    parseMediaListSafe,
-    containsNotKeyword,
-    isMediaTypeNegated,
-    extractMediaTypes,
-    isFeaturefulOrCompound
+	parseMediaListSafe,
+	containsNotKeyword,
+	isMediaTypeNegated,
+	extractMediaTypes,
+	isFeaturefulOrCompound
 };

package/modules/css-medias-alt-minifier.js

@@ -23,6 +23,7 @@
 
 import * as cssTree from "./../vendor/css-tree.js";
 import { flatten } from "./../core/helper.js";
+import { getNestedChildren } from "./css-nested-rules.js";
 import {
 	parseMediaListSafe,
 	containsNotKeyword as utilContainsNotKeyword,
@@ -71,6 +72,8 @@ function processRules(cssRules, stats, keepPrintStyleSheets, removedRules = [])
 				removedRules.push({ cssRules, cssRule });
 				stats.discarded++;
 			}
+		} else if (getNestedChildren(ruleData)) {
+			processRules(ruleData.block.children, stats, keepPrintStyleSheets, removedRules);
 		}
 	}
 	return removedRules;

package/modules/css-nested-rules.js

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2010-2022 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 { decodeName } from "./css-identifier.js";
+
+const RULE_TYPE = "Rule";
+const AT_RULE_TYPE = "Atrule";
+const LEAF_AT_RULE_NAMES = ["font-face", "keyframes"];
+const REGEXP_VENDOR_PREFIX = /^-[^-]+-/;
+
+export {
+	getNestedChildren
+};
+
+function getNestedChildren(ruleData) {
+	if (ruleData.block && ruleData.block.children) {
+		if (ruleData.type == RULE_TYPE) {
+			return ruleData.block.children;
+		} else if (ruleData.type == AT_RULE_TYPE && typeof ruleData.name == "string" && !LEAF_AT_RULE_NAMES.includes(decodeName(ruleData.name).replace(REGEXP_VENDOR_PREFIX, ""))) {
+			return ruleData.block.children;
+		}
+	}
+}

package/modules/css-rules-minifier.js

@@ -22,14 +22,13 @@
  */
 
 import * as cssTree from "./../vendor/css-tree.js";
-import { computeMaxSpecificity } from "./css-specificity.js";
+import { computeMaxSpecificity, PSEUDO_ELEMENT_SYNONYMS } from "./css-specificity.js";
 import { parsePrelude } from "./css-scope-prelude-parser.js";
 import { sanitizeSelector, matchUnqueryableAttributeSelector, matchUnqueryablePseudoClass } from "./css-selector-sanitizer.js";
 import { ESCAPE_CHARACTER, decodeIdentifier, decodeName } from "./css-identifier.js";
 
 const DEBUG = false;
 
-const PSEUDO_ELEMENT_SYNONYMS = new Set(["after", "before", "first-letter", "first-line"]);
 const FUNCTIONAL_PSEUDO_CLASS_NAMES = new Set(["not", "is", "where", "has", "nth-child", "nth-last-child"]);
 const MEDIA_AT_RULE_NAME = "media";
 const SUPPORTS_AT_RULE_NAME = "supports";