single-file-core 1.2.32 → 1.2.34

package/core/index.js

@@ -837,7 +837,13 @@ class Processor {
 				const originalElement = templateElement.content.firstChild;
 				if (originalElement) {
 					if (originalElement.hasAttributes()) {
-						Array.from(originalElement.attributes).forEach(attribute => placeHolderElement.setAttribute(attribute.name, attribute.value));
+						Array.from(originalElement.attributes).forEach(attribute => {
+							try {
+								placeHolderElement.setAttribute(attribute.name, attribute.value);
+							} catch (error) {
+								// ignored
+							}
+						});
 					}
 					originalElement.childNodes.forEach(childNode => placeHolderElement.appendChild(childNode.cloneNode(true)));
 				}

package/modules/css-fonts-minifier.js

@@ -60,12 +60,12 @@ function process(doc, stylesheets, styles, options) {
 		if (cssRules) {
 			stats.processed += cssRules.size;
 			stats.discarded += cssRules.size;
-			getFontsInfo(cssRules, fontsInfo);
+			getFontsInfo(cssRules, fontsInfo, options);
 			docContent = getRulesTextContent(doc, cssRules, workStyleElement, docContent);
 		}
 	});
 	styles.forEach(declarations => {
-		const fontFamilyNames = getFontFamilyNames(declarations);
+		const fontFamilyNames = getFontFamilyNames(declarations, options);
 		if (fontFamilyNames.length) {
 			fontsInfo.used.push(fontFamilyNames);
 		}
@@ -110,12 +110,12 @@ function process(doc, stylesheets, styles, options) {
 	return stats;
 }
 
-function getFontsInfo(cssRules, fontsInfo) {
+function getFontsInfo(cssRules, fontsInfo, options) {
 	cssRules.forEach(ruleData => {
-		if (ruleData.type == "Atrule" && (ruleData.name == "media" || ruleData.name == "supports") && ruleData.block && ruleData.block.children) {
-			getFontsInfo(ruleData.block.children, fontsInfo);
+		if (ruleData.type == "Atrule" && (ruleData.name == "media" || ruleData.name == "supports" || ruleData.name == "layer") && ruleData.block && ruleData.block.children) {
+			getFontsInfo(ruleData.block.children, fontsInfo, options);
 		} else if (ruleData.type == "Rule") {
-			const fontFamilyNames = getFontFamilyNames(ruleData.block);
+			const fontFamilyNames = getFontFamilyNames(ruleData.block, options);
 			if (fontFamilyNames.length) {
 				fontsInfo.used.push(fontFamilyNames);
 			}
@@ -138,7 +138,7 @@ function filterUnusedFonts(cssRules, declaredFonts, unusedFonts, filteredUsedFon
 	const removedRules = [];
 	for (let cssRule = cssRules.head; cssRule; cssRule = cssRule.next) {
 		const ruleData = cssRule.data;
-		if (ruleData.type == "Atrule" && (ruleData.name == "media" || ruleData.name == "supports") && ruleData.block && ruleData.block.children) {
+		if (ruleData.type == "Atrule" && (ruleData.name == "media" || ruleData.name == "supports" || ruleData.name == "layer") && ruleData.block && ruleData.block.children) {
 			filterUnusedFonts(ruleData.block.children, declaredFonts, unusedFonts, filteredUsedFonts, docContent);
 		} else if (ruleData.type == "Atrule" && ruleData.name == "font-face") {
 			const fontFamily = helper.normalizeFontFamily(getDeclarationValue(ruleData.block.children, "font-family"));
@@ -171,8 +171,8 @@ function testUsedFont(ruleData, familyName, declaredFonts, filteredUsedFonts) {
 			const fontWeight = helper.getFontWeight(getDeclarationValue(ruleData.block.children, "font-weight") || "400");
 			const declaredFontsWeights = declaredFonts
 				.filter(fontInfo => fontInfo.fontFamily == familyName && fontInfo.fontStyle == fontStyle)
-				.map(fontInfo => fontInfo.fontWeight)
-				.sort((weight1, weight2) => Number.parseInt(weight1, 10) - Number.parseInt(weight2, 10));
+				.map(fontInfo => fontInfo.fontWeight.split(" "))
+				.sort((weight1, weight2) => Number.parseInt(weight1[0], 10) - Number.parseInt(weight2[0], 10));
 			let usedFontWeights = optionalUsedFonts.map(fontInfo => getUsedFontWeight(fontInfo, fontStyle, declaredFontsWeights));
 			test = testFontweight(fontWeight, usedFontWeights);
 			if (!test) {
@@ -202,8 +202,8 @@ function testUsedFont(ruleData, familyName, declaredFonts, filteredUsedFonts) {
 
 function testFontweight(fontWeight, usedFontWeights) {
 	let test;
-	for (const value of fontWeight.split(/[ ,]/)) {
-		test = test || usedFontWeights.includes(helper.getFontWeight(helper.removeQuotes(value)));
+	for (const value of fontWeight.split(",")) {
+		test = test || usedFontWeights.includes(helper.getFontWeight(helper.removeQuotes(value.trim())));
 	}
 	return test;
 }
@@ -222,7 +222,7 @@ function getDeclarationValue(declarations, propertyName) {
 	}
 }
 
-function getFontFamilyNames(declarations) {
+function getFontFamilyNames(declarations, options) {
 	let fontFamilyName = declarations.children.filter(node => node.property == "font-family").tail;
 	let fontFamilyNames = [];
 	if (fontFamilyName) {
@@ -238,7 +238,13 @@ function getFontFamilyNames(declarations) {
 	const font = declarations.children.filter(node => node.property == "font").tail;
 	if (font && font.data && font.data.value) {
 		try {
-			const parsedFont = fontPropertyParser.parse(font.data.value);
+			let value = font.data.value;
+			let fontFamilyName = cssTree.generate(value);
+			const matchedVar = fontFamilyName.match(/^var\((--.*)\)$/);
+			if (matchedVar && matchedVar[1]) {
+				value = cssTree.parse(globalThis.getComputedStyle(options.doc.body).getPropertyValue(matchedVar[1]), { context: "value" });
+			}
+			const parsedFont = fontPropertyParser.parse(value);
 			parsedFont.family.forEach(familyName => fontFamilyNames.push(helper.normalizeFontFamily(familyName)));
 		} catch (error) {
 			// ignored				
@@ -289,12 +295,12 @@ function parseFamilyNames(fontFamilyNameTokenData, fontFamilyNames) {
 
 function getUsedFontWeight(fontInfo, fontStyle, fontWeights) {
 	let foundWeight;
-	fontWeights = fontWeights.map(weight => String(Number.parseInt(weight, 10)));
+	fontWeights = fontWeights.map(weights => weights.map(value => String(Number.parseInt(value, 10))));
 	if (fontInfo[2] == fontStyle) {
 		let fontWeight = Number(fontInfo[1]);
 		if (fontWeights.length > 1) {
 			if (fontWeight >= 400 && fontWeight <= 500) {
-				foundWeight = fontWeights.find(weight => weight >= fontWeight && weight <= 500);
+				foundWeight = fontWeights.find(weights => weights[0] >= fontWeight && weights[weights.length - 1] <= 500);
 				if (!foundWeight) {
 					foundWeight = findDescendingFontWeight(fontWeight, fontWeights);
 				}
@@ -303,13 +309,13 @@ function getUsedFontWeight(fontInfo, fontStyle, fontWeights) {
 				}
 			}
 			if (fontWeight < 400) {
-				foundWeight = fontWeights.slice().reverse().find(weight => weight <= fontWeight);
+				foundWeight = fontWeights.slice().reverse().find(weights => weights[weights.length - 1] <= fontWeight);
 				if (!foundWeight) {
 					foundWeight = findAscendingFontWeight(fontWeight, fontWeights);
 				}
 			}
 			if (fontWeight > 500) {
-				foundWeight = fontWeights.find(weight => weight >= fontWeight);
+				foundWeight = fontWeights.find(weights => weights[0] >= fontWeight);
 				if (!foundWeight) {
 					foundWeight = findDescendingFontWeight(fontWeight, fontWeights);
 				}
@@ -318,21 +324,21 @@ function getUsedFontWeight(fontInfo, fontStyle, fontWeights) {
 			foundWeight = fontWeights[0];
 		}
 	}
-	return foundWeight;
+	return foundWeight ? foundWeight.join(" ") : undefined;
 }
 
 function findDescendingFontWeight(fontWeight, fontWeights) {
-	return fontWeights.slice().reverse().find(weight => weight < fontWeight);
+	return fontWeights.slice().reverse().find(weights => weights[weights.length - 1] < fontWeight);
 }
 
 function findAscendingFontWeight(fontWeight, fontWeights) {
-	return fontWeights.find(weight => weight > fontWeight);
+	return fontWeights.find(weights => weights[0] > fontWeight);
 }
 
 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")) {
+			if (ruleData.type == "Atrule" && (ruleData.name == "media" || ruleData.name == "supports" || ruleData.name == "layer")) {
 				content = getRulesTextContent(doc, ruleData.block.children, workStylesheet, content);
 			} else if (ruleData.type == "Rule") {
 				content = getDeclarationsTextContent(ruleData.block.children, workStylesheet, content);

package/package.json

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

package/processors/compression/compression-extract.js

@@ -164,11 +164,6 @@ async function extract(content, { password, prompt = () => { }, shadowRootScript
 						}
 					}
 				}));
-				if (filename.match(REGEXP_MATCH_INDEX) || filename.match(REGEXP_MATCH_FRAMES) || noBlobURL) {
-					resource.content = await getDataURI(textContent, mimeType);
-				} else {
-					resource.content = URL.createObjectURL(new Blob([textContent], { type: mimeType }));
-				}
 				resource.textContent = textContent;
 			}
 			if (filename.match(REGEXP_MATCH_INDEX)) {
@@ -176,6 +171,11 @@ async function extract(content, { password, prompt = () => { }, shadowRootScript
 					resource.textContent = textContent.replace(/<script data-template-shadow-root.*<\/script>/g, "<script data-template-shadow-root src=" + shadowRootScriptURL + "></" + "script>");
 				}
 			}
+			if (filename.match(REGEXP_MATCH_INDEX) || filename.match(REGEXP_MATCH_FRAMES) || noBlobURL) {
+				resource.content = await getDataURI(textContent, mimeType);
+			} else {
+				resource.content = URL.createObjectURL(new Blob([textContent], { type: mimeType }));
+			}
 			if (filename.match(REGEXP_MATCH_ROOT_INDEX)) {
 				docContent = textContent;
 				url = resource.url;