single-file-core 1.0.0

package/modules/css-matched-rules.js

@@ -0,0 +1,350 @@
+/*
+ * Copyright 2010-2020 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 * as cssTree from "./../vendor/css-tree.js";
+
+const MEDIA_ALL = "all";
+const IGNORED_PSEUDO_ELEMENTS = ["after", "before", "first-letter", "first-line", "placeholder", "selection", "part", "marker"];
+const SINGLE_FILE_HIDDEN_CLASS_NAME = "sf-hidden";
+const DISPLAY_STYLE = "display";
+const REGEXP_VENDOR_IDENTIFIER = /-(ms|webkit|moz|o)-/;
+const DEBUG = false;
+
+class MatchedRules {
+	constructor(doc, stylesheets, styles) {
+		this.doc = doc;
+		this.mediaAllInfo = createMediaInfo(MEDIA_ALL);
+		const matchedElementsCache = new Map();
+		let sheetIndex = 0;
+		const workStyleElement = doc.createElement("style");
+		doc.body.appendChild(workStyleElement);
+		stylesheets.forEach(stylesheetInfo => {
+			if (!stylesheetInfo.scoped) {
+				const cssRules = stylesheetInfo.stylesheet.children;
+				if (cssRules) {
+					if (stylesheetInfo.mediaText && stylesheetInfo.mediaText != MEDIA_ALL) {
+						const mediaInfo = createMediaInfo(stylesheetInfo.mediaText);
+						this.mediaAllInfo.medias.set("style-" + sheetIndex + "-" + stylesheetInfo.mediaText, mediaInfo);
+						getMatchedElementsRules(doc, cssRules, mediaInfo, sheetIndex, styles, matchedElementsCache, workStyleElement);
+					} else {
+						getMatchedElementsRules(doc, cssRules, this.mediaAllInfo, sheetIndex, styles, matchedElementsCache, workStyleElement);
+					}
+				}
+			}
+			sheetIndex++;
+		});
+		let startTime;
+		if (DEBUG) {
+			startTime = Date.now();
+			log("  -- STARTED sortRules");
+		}
+		sortRules(this.mediaAllInfo);
+		if (DEBUG) {
+			log("  -- ENDED sortRules", Date.now() - startTime);
+			startTime = Date.now();
+			log("  -- STARTED computeCascade");
+		}
+		computeCascade(this.mediaAllInfo, [], this.mediaAllInfo, workStyleElement);
+		workStyleElement.remove();
+		if (DEBUG) {
+			log("  -- ENDED computeCascade", Date.now() - startTime);
+		}
+	}
+
+	getMediaAllInfo() {
+		return this.mediaAllInfo;
+	}
+}
+
+export {
+	getMediaAllInfo
+};
+
+function getMediaAllInfo(doc, stylesheets, styles) {
+	return new MatchedRules(doc, stylesheets, styles).getMediaAllInfo();
+}
+
+function createMediaInfo(media) {
+	const mediaInfo = { media: media, elements: new Map(), medias: new Map(), rules: new Map(), pseudoRules: new Map() };
+	if (media == MEDIA_ALL) {
+		mediaInfo.matchedStyles = new Map();
+	}
+	return mediaInfo;
+}
+
+function getMatchedElementsRules(doc, cssRules, mediaInfo, sheetIndex, styles, matchedElementsCache, workStylesheet) {
+	let mediaIndex = 0;
+	let ruleIndex = 0;
+	let startTime;
+	if (DEBUG && cssRules.length > 1) {
+		startTime = Date.now();
+		log("  -- STARTED getMatchedElementsRules", " index =", sheetIndex, "rules.length =", cssRules.length);
+	}
+	cssRules.forEach(ruleData => {
+		if (ruleData.block && ruleData.block.children && ruleData.prelude && ruleData.prelude.children) {
+			if (ruleData.type == "Atrule" && ruleData.name == "media") {
+				const mediaText = cssTree.generate(ruleData.prelude);
+				const ruleMediaInfo = createMediaInfo(mediaText);
+				mediaInfo.medias.set("rule-" + sheetIndex + "-" + mediaIndex + "-" + mediaText, ruleMediaInfo);
+				mediaIndex++;
+				getMatchedElementsRules(doc, ruleData.block.children, ruleMediaInfo, sheetIndex, styles, matchedElementsCache, workStylesheet);
+			} else if (ruleData.type == "Rule") {
+				const selectors = ruleData.prelude.children.toArray();
+				const selectorsText = ruleData.prelude.children.toArray().map(selector => cssTree.generate(selector));
+				const ruleInfo = { ruleData, mediaInfo, ruleIndex, sheetIndex, matchedSelectors: new Set(), declarations: new Set(), selectors, selectorsText };
+				if (!invalidSelector(selectorsText.join(","), workStylesheet)) {
+					for (let selector = ruleData.prelude.children.head, selectorIndex = 0; selector; selector = selector.next, selectorIndex++) {
+						const selectorText = selectorsText[selectorIndex];
+						const selectorInfo = { selector, selectorText, ruleInfo };
+						getMatchedElementsSelector(doc, selectorInfo, styles, matchedElementsCache);
+					}
+				}
+				ruleIndex++;
+			}
+		}
+	});
+	if (DEBUG && cssRules.length > 1) {
+		log("  -- ENDED   getMatchedElementsRules", "delay =", Date.now() - startTime);
+	}
+}
+
+function invalidSelector(selectorText, workStylesheet) {
+	workStylesheet.textContent = selectorText + "{}";
+	return workStylesheet.sheet ? !workStylesheet.sheet.cssRules.length : workStylesheet.sheet;
+}
+
+function getMatchedElementsSelector(doc, selectorInfo, styles, matchedElementsCache) {
+	const filteredSelectorText = getFilteredSelector(selectorInfo.selector, selectorInfo.selectorText);
+	const selectorText = filteredSelectorText != selectorInfo.selectorText ? filteredSelectorText : selectorInfo.selectorText;
+	const cachedMatchedElements = matchedElementsCache.get(selectorText);
+	let matchedElements = cachedMatchedElements;
+	if (!matchedElements) {
+		try {
+			matchedElements = doc.querySelectorAll(selectorText);
+			if (selectorText != "." + SINGLE_FILE_HIDDEN_CLASS_NAME) {
+				matchedElements = Array.from(doc.querySelectorAll(selectorText)).filter(matchedElement =>
+					!matchedElement.classList.contains(SINGLE_FILE_HIDDEN_CLASS_NAME) &&
+					(matchedElement.style.getPropertyValue(DISPLAY_STYLE) != "none" || matchedElement.style.getPropertyPriority("display") != "important")
+				);
+			}
+		} catch (error) {
+			// ignored				
+		}
+	}
+	if (matchedElements) {
+		if (!cachedMatchedElements) {
+			matchedElementsCache.set(selectorText, matchedElements);
+		}
+		if (matchedElements.length) {
+			if (filteredSelectorText == selectorInfo.selectorText) {
+				matchedElements.forEach(element => addRule(element, selectorInfo, styles));
+			} else {
+				let pseudoSelectors = selectorInfo.ruleInfo.mediaInfo.pseudoRules.get(selectorInfo.ruleInfo.ruleData);
+				if (!pseudoSelectors) {
+					pseudoSelectors = new Set();
+					selectorInfo.ruleInfo.mediaInfo.pseudoRules.set(selectorInfo.ruleInfo.ruleData, pseudoSelectors);
+				}
+				pseudoSelectors.add(selectorInfo.selectorText);
+			}
+		}
+	}
+}
+
+function getFilteredSelector(selector, selectorText) {
+	const removedSelectors = [];
+	selector = { data: cssTree.parse(cssTree.generate(selector.data), { context: "selector" }) };
+	filterPseudoClasses(selector);
+	if (removedSelectors.length) {
+		removedSelectors.forEach(({ parentSelector, selector }) => {
+			if (parentSelector.data.children.size == 0 || !selector.prev || selector.prev.data.type == "Combinator" || selector.prev.data.type == "WhiteSpace") {
+				parentSelector.data.children.replace(selector, cssTree.parse("*", { context: "selector" }).children.head);
+			} else {
+				parentSelector.data.children.remove(selector);
+			}
+		});
+		selectorText = cssTree.generate(selector.data).trim();
+	}
+	return selectorText;
+
+	function filterPseudoClasses(selector, parentSelector) {
+		if (selector.data.children) {
+			for (let childSelector = selector.data.children.head; childSelector; childSelector = childSelector.next) {
+				filterPseudoClasses(childSelector, selector);
+			}
+		}
+		if ((selector.data.type == "PseudoClassSelector") ||
+			(selector.data.type == "PseudoElementSelector" && (testVendorPseudo(selector) || IGNORED_PSEUDO_ELEMENTS.includes(selector.data.name)))) {
+			removedSelectors.push({ parentSelector, selector });
+		}
+	}
+
+	function testVendorPseudo(selector) {
+		const name = selector.data.name;
+		return name.startsWith("-") || name.startsWith("\\-");
+	}
+}
+
+function addRule(element, selectorInfo, styles) {
+	const mediaInfo = selectorInfo.ruleInfo.mediaInfo;
+	const elementStyle = styles.get(element);
+	let elementInfo = mediaInfo.elements.get(element);
+	if (!elementInfo) {
+		elementInfo = [];
+		if (elementStyle) {
+			elementInfo.push({ styleInfo: { styleData: elementStyle, declarations: new Set() } });
+		}
+		mediaInfo.elements.set(element, elementInfo);
+	}
+	const specificity = computeSpecificity(selectorInfo.selector.data);
+	specificity.ruleIndex = selectorInfo.ruleInfo.ruleIndex;
+	specificity.sheetIndex = selectorInfo.ruleInfo.sheetIndex;
+	selectorInfo.specificity = specificity;
+	elementInfo.push(selectorInfo);
+}
+
+function computeCascade(mediaInfo, parentMediaInfo, mediaAllInfo, workStylesheet) {
+	mediaInfo.elements.forEach((elementInfo/*, element*/) =>
+		getDeclarationsInfo(elementInfo, workStylesheet/*, element*/).forEach((declarationsInfo, property) => {
+			if (declarationsInfo.selectorInfo.ruleInfo || mediaInfo == mediaAllInfo) {
+				let info;
+				if (declarationsInfo.selectorInfo.ruleInfo) {
+					info = declarationsInfo.selectorInfo.ruleInfo;
+					const ruleData = info.ruleData;
+					const ascendantMedia = [mediaInfo, ...parentMediaInfo].find(media => media.rules.get(ruleData)) || mediaInfo;
+					ascendantMedia.rules.set(ruleData, info);
+					if (ruleData) {
+						info.matchedSelectors.add(declarationsInfo.selectorInfo.selectorText);
+					}
+				} else {
+					info = declarationsInfo.selectorInfo.styleInfo;
+					const styleData = info.styleData;
+					const matchedStyleInfo = mediaAllInfo.matchedStyles.get(styleData);
+					if (!matchedStyleInfo) {
+						mediaAllInfo.matchedStyles.set(styleData, info);
+					}
+				}
+				if (!info.declarations.has(property)) {
+					info.declarations.add(property);
+				}
+			}
+		}));
+	delete mediaInfo.elements;
+	mediaInfo.medias.forEach(childMediaInfo => computeCascade(childMediaInfo, [mediaInfo, ...parentMediaInfo], mediaAllInfo, workStylesheet));
+}
+
+function getDeclarationsInfo(elementInfo, workStylesheet/*, element*/) {
+	const declarationsInfo = new Map();
+	const processedProperties = new Set();
+	elementInfo.forEach(selectorInfo => {
+		let declarations;
+		if (selectorInfo.styleInfo) {
+			declarations = selectorInfo.styleInfo.styleData.children;
+		} else {
+			declarations = selectorInfo.ruleInfo.ruleData.block.children;
+		}
+		processDeclarations(declarationsInfo, declarations, selectorInfo, processedProperties, workStylesheet);
+	});
+	return declarationsInfo;
+}
+
+function processDeclarations(declarationsInfo, declarations, selectorInfo, processedProperties, workStylesheet) {
+	for (let declaration = declarations.tail; declaration; declaration = declaration.prev) {
+		const declarationData = declaration.data;
+		const declarationText = cssTree.generate(declarationData);
+		if (declarationData.type == "Declaration" &&
+			(declarationText.match(REGEXP_VENDOR_IDENTIFIER) || !processedProperties.has(declarationData.property) || declarationData.important) && !invalidDeclaration(declarationText, workStylesheet)) {
+			const declarationInfo = declarationsInfo.get(declarationData);
+			if (!declarationInfo || (declarationData.important && !declarationInfo.important)) {
+				declarationsInfo.set(declarationData, { selectorInfo, important: declarationData.important });
+				if (!declarationText.match(REGEXP_VENDOR_IDENTIFIER)) {
+					processedProperties.add(declarationData.property);
+				}
+			}
+		}
+	}
+}
+
+function invalidDeclaration(declarationText, workStylesheet) {
+	let invalidDeclaration;
+	workStylesheet.textContent = "single-file-declaration { " + declarationText + "}";
+	if (workStylesheet.sheet && !workStylesheet.sheet.cssRules[0].style.length) {
+		if (!declarationText.match(REGEXP_VENDOR_IDENTIFIER)) {
+			invalidDeclaration = true;
+		}
+	}
+	return invalidDeclaration;
+}
+
+function sortRules(media) {
+	media.elements.forEach(elementRules => elementRules.sort((ruleInfo1, ruleInfo2) =>
+		ruleInfo1.styleInfo && !ruleInfo2.styleInfo ? -1 :
+			!ruleInfo1.styleInfo && ruleInfo2.styleInfo ? 1 :
+				compareSpecificity(ruleInfo1.specificity, ruleInfo2.specificity)));
+	media.medias.forEach(sortRules);
+}
+
+function computeSpecificity(selector, specificity = { a: 0, b: 0, c: 0 }) {
+	if (selector.type == "IdSelector") {
+		specificity.a++;
+	}
+	if (selector.type == "ClassSelector" || selector.type == "AttributeSelector" || (selector.type == "PseudoClassSelector" && selector.name != "not")) {
+		specificity.b++;
+	}
+	if ((selector.type == "TypeSelector" && selector.name != "*") || selector.type == "PseudoElementSelector") {
+		specificity.c++;
+	}
+	if (selector.children) {
+		selector.children.forEach(selector => computeSpecificity(selector, specificity));
+	}
+	return specificity;
+}
+
+function compareSpecificity(specificity1, specificity2) {
+	if (specificity1.a > specificity2.a) {
+		return -1;
+	} else if (specificity1.a < specificity2.a) {
+		return 1;
+	} else if (specificity1.b > specificity2.b) {
+		return -1;
+	} else if (specificity1.b < specificity2.b) {
+		return 1;
+	} else if (specificity1.c > specificity2.c) {
+		return -1;
+	} else if (specificity1.c < specificity2.c) {
+		return 1;
+	} else if (specificity1.sheetIndex > specificity2.sheetIndex) {
+		return -1;
+	} else if (specificity1.sheetIndex < specificity2.sheetIndex) {
+		return 1;
+	} else if (specificity1.ruleIndex > specificity2.ruleIndex) {
+		return -1;
+	} else if (specificity1.ruleIndex < specificity2.ruleIndex) {
+		return 1;
+	} else {
+		return -1;
+	}
+}
+
+function log(...args) {
+	console.log("S-File <css-mat>", ...args); // eslint-disable-line no-console
+}

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

@@ -0,0 +1,91 @@
+/*
+ * Copyright 2010-2020 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 * as cssTree from "./../vendor/css-tree.js";
+import * as mediaQueryParser from "./../vendor/css-media-query-parser.js";
+import { flatten } from "./../single-file-helper.js";
+
+const helper = {
+	flatten
+};
+
+const MEDIA_ALL = "all";
+const MEDIA_SCREEN = "screen";
+
+export {
+	process
+};
+
+function process(stylesheets) {
+	const stats = { processed: 0, discarded: 0 };
+	stylesheets.forEach((stylesheetInfo, element) => {
+		if (matchesMediaType(stylesheetInfo.mediaText || MEDIA_ALL, MEDIA_SCREEN) && stylesheetInfo.stylesheet.children) {
+			const removedRules = processRules(stylesheetInfo.stylesheet.children, stats);
+			removedRules.forEach(({ cssRules, cssRule }) => cssRules.remove(cssRule));
+		} else {
+			stylesheets.delete(element);
+		}
+	});
+	return stats;
+}
+
+function processRules(cssRules, stats, removedRules = []) {
+	for (let cssRule = cssRules.head; cssRule; cssRule = cssRule.next) {
+		const ruleData = cssRule.data;
+		if (ruleData.type == "Atrule" && ruleData.name == "media" && ruleData.block && ruleData.block.children && ruleData.prelude && ruleData.prelude.children) {
+			stats.processed++;
+			if (matchesMediaType(cssTree.generate(ruleData.prelude), MEDIA_SCREEN)) {
+				processRules(ruleData.block.children, stats, removedRules);
+			} else {
+				removedRules.push({ cssRules, cssRule });
+				stats.discarded++;
+			}
+		}
+	}
+	return removedRules;
+}
+
+function matchesMediaType(mediaText, mediaType) {
+	const foundMediaTypes = helper.flatten(mediaQueryParser.parseMediaList(mediaText).map(node => getMediaTypes(node, mediaType)));
+	return foundMediaTypes.find(mediaTypeInfo => (!mediaTypeInfo.not && (mediaTypeInfo.value == mediaType || mediaTypeInfo.value == MEDIA_ALL))
+		|| (mediaTypeInfo.not && (mediaTypeInfo.value == MEDIA_ALL || mediaTypeInfo.value != mediaType)));
+}
+
+function getMediaTypes(parentNode, mediaType, mediaTypes = []) {
+	parentNode.nodes.map((node, indexNode) => {
+		if (node.type == "media-query") {
+			return getMediaTypes(node, mediaType, mediaTypes);
+		} else {
+			if (node.type == "media-type") {
+				const nodeMediaType = { not: Boolean(indexNode && parentNode.nodes[0].type == "keyword" && parentNode.nodes[0].value == "not"), value: node.value };
+				if (!mediaTypes.find(mediaType => nodeMediaType.not == mediaType.not && nodeMediaType.value == mediaType.value)) {
+					mediaTypes.push(nodeMediaType);
+				}
+			}
+		}
+	});
+	if (!mediaTypes.length) {
+		mediaTypes.push({ not: false, value: MEDIA_ALL });
+	}
+	return mediaTypes;
+}

package/modules/css-rules-minifier.js

@@ -0,0 +1,146 @@
+/*
+ * Copyright 2010-2020 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 * as cssTree from "./../vendor/css-tree.js";
+
+const DEBUG = false;
+
+export {
+	process
+};
+
+function process(stylesheets, styles, mediaAllInfo) {
+	const stats = { processed: 0, discarded: 0 };
+	let sheetIndex = 0;
+	stylesheets.forEach(stylesheetInfo => {
+		if (!stylesheetInfo.scoped) {
+			const cssRules = stylesheetInfo.stylesheet.children;
+			if (cssRules) {
+				stats.processed += cssRules.size;
+				stats.discarded += cssRules.size;
+				let mediaInfo;
+				if (stylesheetInfo.mediaText && stylesheetInfo.mediaText != "all") {
+					mediaInfo = mediaAllInfo.medias.get("style-" + sheetIndex + "-" + stylesheetInfo.mediaText);
+				} else {
+					mediaInfo = mediaAllInfo;
+				}
+				processRules(cssRules, sheetIndex, mediaInfo);
+				stats.discarded -= cssRules.size;
+			}
+		}
+		sheetIndex++;
+	});
+	let startTime;
+	if (DEBUG) {
+		startTime = Date.now();
+		log("  -- STARTED processStyleAttribute");
+	}
+	styles.forEach(style => processStyleAttribute(style, mediaAllInfo));
+	if (DEBUG) {
+		log("  -- ENDED   processStyleAttribute delay =", Date.now() - startTime);
+	}
+	return stats;
+}
+
+function processRules(cssRules, sheetIndex, mediaInfo) {
+	let mediaRuleIndex = 0, startTime;
+	if (DEBUG && cssRules.size > 1) {
+		startTime = Date.now();
+		log("  -- STARTED processRules", "rules.length =", cssRules.size);
+	}
+	const removedCssRules = [];
+	for (let cssRule = cssRules.head; cssRule; cssRule = cssRule.next) {
+		const ruleData = cssRule.data;
+		if (ruleData.block && ruleData.block.children && ruleData.prelude && ruleData.prelude.children) {
+			if (ruleData.type == "Atrule" && ruleData.name == "media") {
+				const mediaText = cssTree.generate(ruleData.prelude);
+				processRules(ruleData.block.children, sheetIndex, mediaInfo.medias.get("rule-" + sheetIndex + "-" + mediaRuleIndex + "-" + mediaText));
+				if (!ruleData.prelude.children.size || !ruleData.block.children.size) {
+					removedCssRules.push(cssRule);
+				}
+				mediaRuleIndex++;
+			} else if (ruleData.type == "Rule") {
+				const ruleInfo = mediaInfo.rules.get(ruleData);
+				const pseudoSelectors = mediaInfo.pseudoRules.get(ruleData);
+				if (!ruleInfo && !pseudoSelectors) {
+					removedCssRules.push(cssRule);
+				} else if (ruleInfo) {
+					processRuleInfo(ruleData, ruleInfo, pseudoSelectors);
+					if (!ruleData.prelude.children.size || !ruleData.block.children.size) {
+						removedCssRules.push(cssRule);
+					}
+				}
+			}
+		} else {
+			if (!ruleData || ruleData.type == "Raw" || (ruleData.type == "Rule" && (!ruleData.prelude || ruleData.prelude.type == "Raw"))) {
+				removedCssRules.push(cssRule);
+			}
+		}
+	}
+	removedCssRules.forEach(cssRule => cssRules.remove(cssRule));
+	if (DEBUG && cssRules.size > 1) {
+		log("  -- ENDED   processRules delay =", Date.now() - startTime);
+	}
+}
+
+function processRuleInfo(ruleData, ruleInfo, pseudoSelectors) {
+	const removedDeclarations = [];
+	const removedSelectors = [];
+	let pseudoSelectorFound;
+	for (let selector = ruleData.prelude.children.head; selector; selector = selector.next) {
+		const selectorText = cssTree.generate(selector.data);
+		if (pseudoSelectors && pseudoSelectors.has(selectorText)) {
+			pseudoSelectorFound = true;
+		}
+		if (!ruleInfo.matchedSelectors.has(selectorText) && (!pseudoSelectors || !pseudoSelectors.has(selectorText))) {
+			removedSelectors.push(selector);
+		}
+	}
+	if (!pseudoSelectorFound) {
+		for (let declaration = ruleData.block.children.tail; declaration; declaration = declaration.prev) {
+			if (!ruleInfo.declarations.has(declaration.data)) {
+				removedDeclarations.push(declaration);
+			}
+		}
+	}
+	removedDeclarations.forEach(declaration => ruleData.block.children.remove(declaration));
+	removedSelectors.forEach(selector => ruleData.prelude.children.remove(selector));
+}
+
+function processStyleAttribute(styleData, mediaAllInfo) {
+	const removedDeclarations = [];
+	const styleInfo = mediaAllInfo.matchedStyles.get(styleData);
+	if (styleInfo) {
+		let propertyFound;
+		for (let declaration = styleData.children.head; declaration && !propertyFound; declaration = declaration.next) {
+			if (!styleInfo.declarations.has(declaration.data)) {
+				removedDeclarations.push(declaration);
+			}
+		}
+		removedDeclarations.forEach(declaration => styleData.children.remove(declaration));
+	}
+}
+
+function log(...args) {
+	console.log("S-File <css-min>", ...args); // eslint-disable-line no-console
+}

package/modules/html-images-alt-minifier.js

@@ -0,0 +1,109 @@
+/*
+ * Copyright 2010-2020 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 * as srcsetParser from "./../vendor/html-srcset-parser.js";
+
+const EMPTY_RESOURCE = "data:,";
+
+export {
+	process
+};
+
+function process(doc) {
+	doc.querySelectorAll("picture").forEach(pictureElement => {
+		const imgElement = pictureElement.querySelector("img");
+		if (imgElement) {
+			let { src, srcset } = getImgSrcData(imgElement);
+			if (!src) {
+				const data = getSourceSrcData(Array.from(pictureElement.querySelectorAll("source")).reverse());
+				src = data.src;
+				if (!srcset) {
+					srcset = data.srcset;
+				}
+			}
+			setSrc({ src, srcset }, imgElement, pictureElement);
+		}
+	});
+	doc.querySelectorAll(":not(picture) > img[srcset]").forEach(imgElement => setSrc(getImgSrcData(imgElement), imgElement));
+}
+
+function getImgSrcData(imgElement) {
+	let src = imgElement.getAttribute("src");
+	if (src == EMPTY_RESOURCE) {
+		src = null;
+	}
+	let srcset = getSourceSrc(imgElement.getAttribute("srcset"));
+	if (srcset == EMPTY_RESOURCE) {
+		srcset = null;
+	}
+	return { src, srcset };
+}
+
+function getSourceSrcData(sources) {
+	let source = sources.find(source => source.src);
+	let src = source && source.src;
+	let srcset = source && source.srcset;
+	if (!src) {
+		source = sources.find(source => getSourceSrc(source.src));
+		src = source && source.src;
+		if (src == EMPTY_RESOURCE) {
+			src = null;
+		}
+	}
+	if (!srcset) {
+		source = sources.find(source => getSourceSrc(source.srcset));
+		srcset = source && source.srcset;
+		if (srcset == EMPTY_RESOURCE) {
+			srcset = null;
+		}
+	}
+	return { src, srcset };
+}
+
+function setSrc(srcData, imgElement, pictureElement) {
+	if (srcData.src) {
+		imgElement.setAttribute("src", srcData.src);
+		imgElement.setAttribute("srcset", "");
+		imgElement.setAttribute("sizes", "");
+	} else {
+		imgElement.setAttribute("src", EMPTY_RESOURCE);
+		if (srcData.srcset) {
+			imgElement.setAttribute("srcset", srcData.srcset);
+		} else {
+			imgElement.setAttribute("srcset", "");
+			imgElement.setAttribute("sizes", "");
+		}
+	}
+	if (pictureElement) {
+		pictureElement.querySelectorAll("source").forEach(sourceElement => sourceElement.remove());
+	}
+}
+
+function getSourceSrc(sourceSrcSet) {
+	if (sourceSrcSet) {
+		const srcset = srcsetParser.process(sourceSrcSet);
+		if (srcset.length) {
+			return (srcset.find(srcset => srcset.url)).url;
+		}
+	}
+}