single-file-core 1.5.48 → 1.5.49

package/core/index.js

@@ -1404,10 +1404,7 @@ class Processor {
 	}
 
 	removeUnusedStyles() {
-		if (!this.mediaAllInfo) {
-			this.mediaAllInfo = util.getMediaAllInfo(this.doc, this.stylesheets, this.styles);
-		}
-		const stats = util.minifyCSSRules(this.stylesheets, this.styles, this.mediaAllInfo);
+		const stats = util.minifyCSSRules(this.doc, this.stylesheets);
 		this.stats.set("processed", "CSS rules", stats.processed);
 		this.stats.set("discarded", "CSS rules", stats.discarded);
 	}

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

@@ -183,6 +183,22 @@ function getProcessorHelperClass(utilInstance) {
 							if (mediaQueryListNode) {
 								content.data = this.wrapMediaQuery(content.data, cssTree.generate(mediaQueryListNode));
 							}
+							const layerListNode = cssTree.find(node, node => node.type == "LayerList");
+							if (layerListNode) {
+								const layerNames = [];
+								layerListNode.children.forEach(child => {
+									if (child.type == "Identifier") {
+										layerNames.push(child.name);
+									}
+								});
+								if (layerNames.length == 1) {
+									content.data = this.wrapLayer(content.data, layerNames[0]);
+								}
+							}
+							const supportsNode = cssTree.find(node, node => node.type == "Supports");
+							if (supportsNode) {
+								content.data = "@supports " + cssTree.generate(supportsNode) + " { " + content.data + " }";
+							}
 							const importedStylesheet = cssTree.parse(content.data, { context: "stylesheet", parseCustomProperty: true });
 							const ancestorStyleSheets = new Set(importedStyleSheets);
 							ancestorStyleSheets.add(resourceURL);
@@ -470,6 +486,14 @@ function getProcessorHelperClass(utilInstance) {
 			}
 		}
 
+		wrapLayer(stylesheetContent, layerName) {
+			if (layerName) {
+				return "@layer " + layerName + " { " + stylesheetContent + " }";
+			} else {
+				return stylesheetContent;
+			}
+		}
+
 		getAdditionalPageData() {
 			return {};
 		}

package/core/lib/processor-helper.js

@@ -162,10 +162,18 @@ function getProcessorHelperClass(utilInstance) {
 						}
 						if (testValidURL(resourceURL)) {
 							const mediaQueryListNode = cssTree.find(node, node => node.type == "MediaQueryList");
-							let mediaText;
+							let mediaText, layerName, supportsCondition;
 							if (mediaQueryListNode) {
 								mediaText = cssTree.generate(mediaQueryListNode);
 							}
+							const layerNode = cssTree.find(node, node => node.type == "Layer");
+							if (layerNode) {
+								layerName = layerNode.name;
+							}
+							const supportsNode = cssTree.find(node, node => node.type == "Supports");
+							if (supportsNode) {
+								supportsCondition = cssTree.generate(supportsNode);
+							}
 							const existingStylesheet = Array.from(stylesheets).find(([, stylesheetInfo]) => stylesheetInfo.resourceURL == resourceURL);
 							let stylesheet;
 							if (existingStylesheet) {
@@ -178,7 +186,9 @@ function getProcessorHelperClass(utilInstance) {
 							} else {
 								const stylesheetInfo = {
 									scoped,
-									mediaText
+									mediaText,
+									layerName,
+									supportsCondition
 								};
 								const content = await this.getStylesheetContent(resourceURL, options);
 								stylesheetInfo.url = resourceURL = content.resourceURL;
@@ -189,6 +199,9 @@ function getProcessorHelperClass(utilInstance) {
 								stylesheets.set({ urlNode }, stylesheetInfo);
 							}
 							urlNode.importedChildren = stylesheet.children;
+							urlNode.importedMediaText = mediaText;
+							urlNode.importedLayerName = layerName;
+							urlNode.importedSupportsCondition = supportsCondition;
 						}
 					}
 				}

package/core/util.js

@@ -160,15 +160,12 @@ function getInstance(utilOptions) {
 		minifyHTML(doc, options) {
 			return modules.htmlMinifier.process(doc, options);
 		},
-		minifyCSSRules(stylesheets, styles, mediaAllInfo) {
-			return modules.cssRulesMinifier.process(stylesheets, styles, mediaAllInfo);
+		minifyCSSRules(doc, stylesheets) {
+			return modules.cssRulesMinifier.process(doc, stylesheets);
 		},
 		removeUnusedFonts(doc, stylesheets, styles, options) {
 			return modules.fontsMinifier.process(doc, stylesheets, styles, options);
 		},
-		getMediaAllInfo(doc, stylesheets, styles) {
-			return modules.matchedRules.getMediaAllInfo(doc, stylesheets, styles);
-		},
 		compressCSS(content, options) {
 			return vendor.cssMinifier.processString(content, options);
 		},

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

@@ -0,0 +1,63 @@
+import * as mediaQueryParser from "../vendor/css-media-query-parser.js";
+
+function parseMediaListSafe(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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+export {
+    parseMediaListSafe,
+    containsNotKeyword,
+    isMediaTypeNegated,
+    extractMediaTypes,
+    isFeaturefulOrCompound
+};

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

@@ -22,8 +22,13 @@
  */
 
 import * as cssTree from "./../vendor/css-tree.js";
-import * as mediaQueryParser from "./../vendor/css-media-query-parser.js";
 import { flatten } from "./../core/helper.js";
+import {
+	parseMediaListSafe,
+	containsNotKeyword as utilContainsNotKeyword,
+	extractMediaTypes,
+	isFeaturefulOrCompound
+} from "./css-media-query-utils.js";
 
 const helper = {
 	flatten
@@ -72,28 +77,26 @@ function processRules(cssRules, stats, keepPrintStyleSheets, removedRules = [])
 }
 
 function matchesMediaType(mediaText, keepPrintStyleSheets) {
-	const foundMediaTypes = helper.flatten(mediaQueryParser.parseMediaList(mediaText).map(node => getMediaTypes(node)));
-	return foundMediaTypes.find(mediaTypeInfo =>
-		(!mediaTypeInfo.not && (mediaTypeInfo.value == MEDIA_SCREEN || mediaTypeInfo.value == MEDIA_ALL || (keepPrintStyleSheets && mediaTypeInfo.value == MEDIA_PRINT))) ||
-		(mediaTypeInfo.not && (mediaTypeInfo.value != MEDIA_SCREEN || mediaText.includes(" and "))));
-}
-
-function getMediaTypes(parentNode, mediaTypes = []) {
-	parentNode.nodes.map((node, indexNode) => {
-		if (node.type == "media-query") {
-			return getMediaTypes(node);
-		} else {
-			if (node.type == "media-type") {
-				const nodeMediaType = {
-					not: Boolean(indexNode && parentNode.nodes[0].type == "keyword" && parentNode.nodes[0].value == "not"),
-					value: node.value
-				};
-				mediaTypes.push(nodeMediaType);
-			}
+	let parsed;
+	try {
+		parsed = parseMediaListSafe(mediaText);
+		for (const node of parsed) {
+			if (!node || !node.nodes) continue;
+			if (isFeaturefulOrCompound(node)) return true;
+			if (utilContainsNotKeyword(node)) return true;
 		}
-	});
-	if (!mediaTypes.length) {
-		mediaTypes.push({ not: false, value: MEDIA_ALL });
+	} catch {
+		return true;
+	}
+	let foundMediaTypes = helper.flatten(parsed.filter(n => n && n.nodes).map(node => extractMediaTypes(node)));
+	if (!foundMediaTypes || !foundMediaTypes.length) {
+		foundMediaTypes = [{ not: false, value: MEDIA_ALL }];
 	}
-	return mediaTypes;
+	return foundMediaTypes.some(mediaTypeInfo =>
+		!mediaTypeInfo.not && (
+			mediaTypeInfo.value == MEDIA_SCREEN ||
+			mediaTypeInfo.value == MEDIA_ALL ||
+			(keepPrintStyleSheets && mediaTypeInfo.value == MEDIA_PRINT)
+		)
+	);
 }