single-file-core 1.2.24 → 1.2.26

package/core/lib/processor-helper.js

@@ -24,42 +24,14 @@
 /* global globalThis */
 
 import * as cssTree from "./../../vendor/css-tree.js";
-import {
-	normalizeFontFamily,
-	getFontWeight
-} from "./../helper.js";
 
 const JSON = globalThis.JSON;
 const FontFace = globalThis.FontFace;
 
 const ABOUT_BLANK_URI = "about:blank";
 const UTF8_CHARSET = "utf-8";
-
-const REGEXP_URL_SIMPLE_QUOTES_FN = /url\s*\(\s*'(.*?)'\s*\)/i;
-const REGEXP_URL_DOUBLE_QUOTES_FN = /url\s*\(\s*"(.*?)"\s*\)/i;
-const REGEXP_URL_NO_QUOTES_FN = /url\s*\(\s*(.*?)\s*\)/i;
-const REGEXP_URL_FUNCTION = /(url|local|-sf-url-original)\(.*?\)\s*(,|$)/g;
-const REGEXP_SIMPLE_QUOTES_STRING = /^'(.*?)'$/;
-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_SRC = /(.*?)\s*,?$/;
 const EMPTY_URL_SOURCE = /^url\(["']?data:[^,]*,?["']?\)/;
 const LOCAL_SOURCE = "local(";
-const MEDIA_ALL = "all";
-const FONT_STRETCHES = {
-	"ultra-condensed": "50%",
-	"extra-condensed": "62.5%",
-	"condensed": "75%",
-	"semi-condensed": "87.5%",
-	"normal": "100%",
-	"semi-expanded": "112.5%",
-	"expanded": "125%",
-	"extra-expanded": "150%",
-	"ultra-expanded": "200%"
-};
 const FONT_MAX_LOAD_DELAY = 5000;
 
 let util;
@@ -89,39 +61,6 @@ function getProcessorHelperClass(utilInstance) {
 	const ProcessorHelperCommon = getProcessorHelperCommonClass(util, cssTree);
 
 	return class ProcessorHelper extends ProcessorHelperCommon {
-		async processPageResources(doc, baseURI, options, resources, styles, batchRequest) {
-			const processAttributeArgs = [
-				["link[href][rel*=\"icon\"]", "href", true],
-				["object[type=\"image/svg+xml\"], object[type=\"image/svg-xml\"], object[data*=\".svg\"]", "data"],
-				["img[src], input[src][type=image]", "src"],
-				["embed[src*=\".svg\"]", "src"],
-				["video[poster]", "poster"],
-				["*[background]", "background"],
-				["image", "xlink:href"],
-				["image", "href"]
-			];
-			if (options.blockImages) {
-				doc.querySelectorAll("svg").forEach(element => element.remove());
-			}
-			let resourcePromises = processAttributeArgs.map(([selector, attributeName, removeElementIfMissing]) =>
-				this.processAttribute(doc.querySelectorAll(selector), attributeName, baseURI, options, "image", resources, batchRequest, removeElementIfMissing)
-			);
-			resourcePromises = resourcePromises.concat([
-				this.processXLinks(doc.querySelectorAll("use"), doc, baseURI, options, batchRequest),
-				this.processSrcset(doc.querySelectorAll("img[srcset], source[srcset]"), baseURI, options, resources, batchRequest)
-			]);
-			resourcePromises.push(this.processAttribute(doc.querySelectorAll("object[data*=\".pdf\"]"), "data", baseURI, options, null, resources, batchRequest));
-			resourcePromises.push(this.processAttribute(doc.querySelectorAll("embed[src*=\".pdf\"]"), "src", baseURI, options, null, resources, batchRequest));
-			resourcePromises.push(this.processAttribute(doc.querySelectorAll("audio[src], audio > source[src]"), "src", baseURI, options, "audio", resources, batchRequest));
-			resourcePromises.push(this.processAttribute(doc.querySelectorAll("video[src], video > source[src]"), "src", baseURI, options, "video", resources, batchRequest));
-			resourcePromises.push(this.processAttribute(doc.querySelectorAll("audio track[src], video track[src]"), "src", baseURI, options, null, resources, batchRequest));
-			resourcePromises.push(this.processAttribute(doc.querySelectorAll("model[src]"), "src", baseURI, options, null, resources, batchRequest));
-			await Promise.all(resourcePromises);
-			if (options.saveFavicon) {
-				this.processShortcutIcons(doc);
-			}
-		}
-
 		async processLinkElement(element, stylesheetInfo, stylesheets, baseURI, options, workStyleElement, resources) {
 			if (element.tagName.toUpperCase() == "LINK") {
 				element.removeAttribute("integrity");
@@ -134,13 +73,7 @@ function getProcessorHelperClass(utilInstance) {
 		}
 
 		async processStylesheetElement(element, stylesheetInfo, stylesheets, baseURI, options, workStyleElement, resources) {
-			if (options.blockStylesheets) {
-				if (element.tagName.toUpperCase() == "LINK") {
-					element.href = util.EMPTY_RESOURCE;
-				} else {
-					element.textContent = "";
-				}
-			} else {
+			if (!options.blockStylesheets) {
 				if (element.tagName.toUpperCase() == "LINK") {
 					await this.resolveLinkStylesheetURLs(stylesheetInfo, element, element.href, baseURI, options, workStyleElement, resources, stylesheets);
 				} else {
@@ -148,10 +81,16 @@ function getProcessorHelperClass(utilInstance) {
 					stylesheetInfo.stylesheet = cssTree.parse(element.textContent, { context: "stylesheet", parseCustomProperty: true });
 					await this.resolveImportURLs(stylesheetInfo, baseURI, options, workStyleElement, resources, stylesheets);
 				}
+			} else {
+				if (element.tagName.toUpperCase() == "LINK") {
+					element.href = util.EMPTY_RESOURCE;
+				} else {
+					element.textContent = "";
+				}
 			}
 		}
 
-		replaceStylesheets(doc, stylesheets, resources, options) {
+		replaceStylesheets(doc, stylesheets, options, resources) {
 			for (const [key, stylesheetInfo] of stylesheets) {
 				if (key.urlNode) {
 					const name = "stylesheet_" + resources.stylesheets.size + ".css";
@@ -284,48 +223,20 @@ function getProcessorHelperClass(utilInstance) {
 			resources.frames.set(frameWindowId, { name, content: pageData.content, resources: pageData.resources, url: frameData.url });
 		}
 
-		async processStylesheet(cssRules, baseURI, options, resources, batchRequest) {
-			const promises = [];
-			const removedRules = [];
-			for (let cssRule = cssRules.head; cssRule; cssRule = cssRule.next) {
-				const ruleData = cssRule.data;
-				if (ruleData.type == "Atrule" && ruleData.name == "charset") {
-					removedRules.push(cssRule);
-				} else if (ruleData.block && ruleData.block.children) {
-					if (ruleData.type == "Rule") {
-						promises.push(this.processStyle(ruleData, options, resources, batchRequest));
-					} else if (ruleData.type == "Atrule" && (ruleData.name == "media" || ruleData.name == "supports")) {
-						promises.push(this.processStylesheet(ruleData.block.children, baseURI, options, resources, batchRequest));
-					} else if (ruleData.type == "Atrule" && ruleData.name == "font-face") {
-						promises.push(processFontFaceRule(ruleData));
-					}
-				}
-			}
-			removedRules.forEach(cssRule => cssRules.remove(cssRule));
-			await Promise.all(promises);
-
-			async function processFontFaceRule(ruleData) {
-				const urls = getUrlFunctions(ruleData);
-				await Promise.all(urls.map(async urlNode => {
-					const originalResourceURL = urlNode.value;
-					if (!options.blockFonts) {
-						const resourceURL = normalizeURL(originalResourceURL);
-						if (!testIgnoredPath(resourceURL) && testValidURL(resourceURL)) {
-							let { content, extension, indexResource, contentType } = await batchRequest.addURL(resourceURL,
-								{ asBinary: true, expectedType: "font", baseURI, blockMixedContent: options.blockMixedContent });
-							const name = "fonts/" + indexResource + extension;
-							if (!isDataURL(resourceURL) && options.saveOriginalURLs) {
-								urlNode.value = "-sf-url-original(" + JSON.stringify(originalResourceURL) + ") " + name;
-							} else {
-								urlNode.value = name;
-							}
-							resources.fonts.set(indexResource, { name, content, extension, contentType, url: resourceURL });
-						}
-					} else {
-						urlNode.value = util.EMPTY_RESOURCE;
-					}
-				}));
+		async processFont(resourceURL, urlNode, originalResourceURL, baseURI, options, resources, batchRequest) {
+			let { content, extension, indexResource, contentType } = await batchRequest.addURL(resourceURL, {
+				asBinary: true,
+				expectedType: "font",
+				baseURI,
+				blockMixedContent: options.blockMixedContent
+			});
+			const name = "fonts/" + indexResource + extension;
+			if (!isDataURL(resourceURL) && options.saveOriginalURLs) {
+				urlNode.value = "-sf-url-original(" + JSON.stringify(originalResourceURL) + ") " + name;
+			} else {
+				urlNode.value = name;
 			}
+			resources.fonts.set(indexResource, { name, content, extension, contentType, url: resourceURL });
 		}
 
 		async processStyle(ruleData, options, resources, batchRequest) {
@@ -351,7 +262,7 @@ function getProcessorHelperClass(utilInstance) {
 			}));
 		}
 
-		async processAttribute(resourceElements, attributeName, baseURI, options, expectedType, resources, batchRequest, removeElementIfMissing) {
+		async processAttribute(resourceElements, attributeName, baseURI, options, expectedType, resources, removeElementIfMissing, batchRequest) {
 			await Promise.all(Array.from(resourceElements).map(async resourceElement => {
 				let resourceURL = resourceElement.getAttribute(attributeName);
 				if (resourceURL != null) {
@@ -422,43 +333,11 @@ function getProcessorHelperClass(utilInstance) {
 			}
 		}
 
-		async processSrcset(resourceElements, baseURI, options, resources, batchRequest) {
-			await Promise.all(Array.from(resourceElements).map(async resourceElement => {
-				const originSrcset = resourceElement.getAttribute("srcset");
-				const srcset = util.parseSrcset(originSrcset);
-				if (options.saveOriginalURLs && !isDataURL(originSrcset)) {
-					resourceElement.setAttribute("data-sf-original-srcset", originSrcset);
-				}
-				if (!options.blockImages) {
-					const srcsetValues = await Promise.all(srcset.map(async srcsetValue => {
-						let resourceURL = normalizeURL(srcsetValue.url);
-						if (!testIgnoredPath(resourceURL)) {
-							if (testValidPath(resourceURL)) {
-								try {
-									resourceURL = util.resolveURL(resourceURL, baseURI);
-								} catch (error) {
-									// ignored
-								}
-								if (testValidURL(resourceURL)) {
-									const { content, indexResource, extension, contentType } = await batchRequest.addURL(resourceURL, { asBinary: true, expectedType: "image" });
-									const name = "images/" + indexResource + extension;
-									resources.images.set(indexResource, { name, content, extension, contentType, url: resourceURL });
-									return name + (srcsetValue.w ? " " + srcsetValue.w + "w" : srcsetValue.d ? " " + srcsetValue.d + "x" : "");
-								} else {
-									return "";
-								}
-							} else {
-								return "";
-							}
-						} else {
-							return resourceURL + (srcsetValue.w ? " " + srcsetValue.w + "w" : srcsetValue.d ? " " + srcsetValue.d + "x" : "");
-						}
-					}));
-					resourceElement.setAttribute("srcset", srcsetValues.join(", "));
-				} else {
-					resourceElement.setAttribute("srcset", "");
-				}
-			}));
+		async processImageSrcset(resourceURL, srcsetValue, resources, batchRequest) {
+			const { content, indexResource, extension, contentType } = await batchRequest.addURL(resourceURL, { asBinary: true, expectedType: "image" });
+			const name = "images/" + indexResource + extension;
+			resources.images.set(indexResource, { name, content, extension, contentType, url: resourceURL });
+			return name + (srcsetValue.w ? " " + srcsetValue.w + "w" : srcsetValue.d ? " " + srcsetValue.d + "x" : "");
 		}
 
 		testEmptyResource(resource) {
@@ -499,10 +378,6 @@ function getProcessorHelperClass(utilInstance) {
 			};
 		}
 
-		removeAlternativeFonts(doc, stylesheets, fontResources, fontTests) {
-			return removeAlternativeFonts(doc, stylesheets, fontResources, fontTests);
-		}
-
 		async processScript(element, resourceURL, options, charset) {
 			const content = await util.getContent(resourceURL, {
 				asBinary: true,
@@ -527,276 +402,91 @@ function getProcessorHelperClass(utilInstance) {
 
 		removeUnusedStylesheets() {
 		}
-	};
-}
-
-async function removeAlternativeFonts(doc, stylesheets, fontResources, fontTests) {
-	const fontsDetails = {
-		fonts: new Map(),
-		medias: new Map(),
-		supports: new Map()
-	};
-	const stats = { rules: { processed: 0, discarded: 0 }, fonts: { processed: 0, discarded: 0 } };
-	let sheetIndex = 0;
-	stylesheets.forEach(stylesheetInfo => {
-		const cssRules = stylesheetInfo.stylesheet.children;
-		if (cssRules) {
-			stats.rules.processed += cssRules.size;
-			stats.rules.discarded += cssRules.size;
-			if (stylesheetInfo.mediaText && stylesheetInfo.mediaText != MEDIA_ALL) {
-				const mediaFontsDetails = createFontsDetailsInfo();
-				fontsDetails.medias.set("media-" + sheetIndex + "-" + stylesheetInfo.mediaText, mediaFontsDetails);
-				getFontsDetails(doc, cssRules, sheetIndex, mediaFontsDetails);
-			} else {
-				getFontsDetails(doc, cssRules, sheetIndex, fontsDetails);
-			}
-		}
-		sheetIndex++;
-	});
-	processFontDetails(fontsDetails, fontResources);
-	await Promise.all([...stylesheets].map(async ([, stylesheetInfo], sheetIndex) => {
-		const cssRules = stylesheetInfo.stylesheet.children;
-		const media = stylesheetInfo.mediaText;
-		if (cssRules) {
-			if (media && media != MEDIA_ALL) {
-				await processFontFaceRules(cssRules, sheetIndex, fontsDetails.medias.get("media-" + sheetIndex + "-" + media), fontResources, fontTests, stats);
-			} else {
-				await processFontFaceRules(cssRules, sheetIndex, fontsDetails, fontResources, fontTests, stats);
-			}
-			stats.rules.discarded -= cssRules.size;
-		}
-	}));
-	return stats;
-}
-
-function getFontsDetails(doc, cssRules, sheetIndex, mediaFontsDetails) {
-	let mediaIndex = 0, supportsIndex = 0;
-	cssRules.forEach(ruleData => {
-		if (ruleData.type == "Atrule" && ruleData.name == "media" && ruleData.block && ruleData.block.children && ruleData.prelude) {
-			const mediaText = cssTree.generate(ruleData.prelude);
-			const fontsDetails = createFontsDetailsInfo();
-			mediaFontsDetails.medias.set("media-" + sheetIndex + "-" + mediaIndex + "-" + mediaText, fontsDetails);
-			mediaIndex++;
-			getFontsDetails(doc, ruleData.block.children, sheetIndex, fontsDetails);
-		} else if (ruleData.type == "Atrule" && ruleData.name == "supports" && ruleData.block && ruleData.block.children && ruleData.prelude) {
-			const supportsText = cssTree.generate(ruleData.prelude);
-			const fontsDetails = createFontsDetailsInfo();
-			mediaFontsDetails.supports.set("supports-" + sheetIndex + "-" + supportsIndex + "-" + supportsText, fontsDetails);
-			supportsIndex++;
-			getFontsDetails(doc, ruleData.block.children, sheetIndex, fontsDetails);
-		} else if (ruleData.type == "Atrule" && ruleData.name == "font-face" && ruleData.block && ruleData.block.children) {
-			const fontKey = getFontKey(ruleData);
-			let fontInfo = mediaFontsDetails.fonts.get(fontKey);
-			if (!fontInfo) {
-				fontInfo = [];
-				mediaFontsDetails.fonts.set(fontKey, fontInfo);
-			}
-			const src = getPropertyValue(ruleData, "src");
-			if (src) {
-				const fontSources = src.match(REGEXP_URL_FUNCTION);
-				if (fontSources) {
-					fontSources.forEach(source => fontInfo.unshift(source));
-				}
-			}
-		}
-	});
-}
 
-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 fontUrl = getURL(fontSource);
-			if (fontFormatMatch && fontFormatMatch[1]) {
-				fontFormat = fontFormatMatch[1].replace(REGEXP_SIMPLE_QUOTES_STRING, "$1").replace(REGEXP_DOUBLE_QUOTES_STRING, "$1").toLowerCase();
-			}
-			if (!fontFormat) {
-				const fontFormatMatch = fontSource.match(REGEXP_URL_FUNCTION_WOFF);
-				if (fontFormatMatch && fontFormatMatch[1]) {
-					fontFormat = fontFormatMatch[1];
+		async processFontFaceRule(ruleData, fontInfo, fontResources, fontTests, stats) {
+			await Promise.all(fontInfo.map(async source => {
+				if (fontTests.has(source.src)) {
+					source.valid = fontTests.get(source.src);
 				} else {
-					const fontFormatMatch = fontSource.match(REGEXP_URL_FUNCTION_WOFF_ALT);
-					if (fontFormatMatch && fontFormatMatch[1]) {
-						fontFormat = fontFormatMatch[1];
+					if (FontFace && source.fontUrl) {
+						const resourceEntry = [...fontResources].find(([, resource]) => source.fontUrl && resource.name == source.fontUrl);
+						if (resourceEntry) {
+							const resource = resourceEntry[1];
+							const fontFace = new FontFace("test-font", new Uint8Array(resource.content).buffer);
+							try {
+								let timeout;
+								await Promise.race([
+									fontFace.load().then(() => fontFace.loaded).then(() => { source.valid = true; globalThis.clearTimeout(timeout); }),
+									new Promise(resolve => timeout = globalThis.setTimeout(() => { source.valid = true; resolve(); }, FONT_MAX_LOAD_DELAY))
+								]);
+							} catch (error) {
+								const fontFace = new FontFace("test-font", "url(" + resource.url + ")");
+								try {
+									let timeout;
+									await Promise.race([
+										fontFace.load().then(() => fontFace.loaded).then(() => { source.valid = true; globalThis.clearTimeout(timeout); }),
+										new Promise(resolve => timeout = globalThis.setTimeout(() => { source.valid = true; resolve(); }, FONT_MAX_LOAD_DELAY))
+									]);
+								} catch (error) {
+									// ignored
+								}
+							}
+						} else {
+							source.valid = true;
+						}
+					} else {
+						source.valid = true;
 					}
+					fontTests.set(source.src, source.valid);
 				}
-			}
-			if (!fontFormat && fontUrl) {
-				const fontFormatMatch = fontUrl.match(REGEXP_FONT_FORMAT);
-				if (fontFormatMatch && fontFormatMatch[1]) {
-					fontFormat = fontFormatMatch[1];
-				}
-			}
-			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 };
-		}));
-	});
-	fontsDetails.medias.forEach(mediaFontsDetails => processFontDetails(mediaFontsDetails, fontResources));
-	fontsDetails.supports.forEach(supportsFontsDetails => processFontDetails(supportsFontsDetails, fontResources));
-}
-
-async function processFontFaceRules(cssRules, sheetIndex, fontsDetails, fontResources, fontTests, stats) {
-	const removedRules = [];
-	let mediaIndex = 0, supportsIndex = 0;
-	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) {
-			const mediaText = cssTree.generate(ruleData.prelude);
-			await processFontFaceRules(ruleData.block.children, sheetIndex, fontsDetails.medias.get("media-" + sheetIndex + "-" + mediaIndex + "-" + mediaText), fontResources, fontTests, stats);
-			mediaIndex++;
-		} else if (ruleData.type == "Atrule" && ruleData.name == "supports" && ruleData.block && ruleData.block.children && ruleData.prelude) {
-			const supportsText = cssTree.generate(ruleData.prelude);
-			await processFontFaceRules(ruleData.block.children, sheetIndex, fontsDetails.supports.get("supports-" + sheetIndex + "-" + supportsIndex + "-" + supportsText), fontResources, fontTests, stats);
-			supportsIndex++;
-		} else if (ruleData.type == "Atrule" && ruleData.name == "font-face") {
-			const key = getFontKey(ruleData);
-			const fontInfo = fontsDetails.fonts.get(key);
-			if (fontInfo) {
-				fontsDetails.fonts.delete(key);
-				await processFontFaceRule(ruleData, fontInfo, fontResources, fontTests, stats);
+			}));
+			const findSourceByFormat = (fontFormat, testValidity) => fontInfo.find(source => !source.src.match(EMPTY_URL_SOURCE) && source.format == fontFormat && (!testValidity || source.valid));
+			const findSourceByContentType = (contentType, testValidity) => fontInfo.find(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));
+			stats.fonts.processed += fontInfo.length;
+			stats.fonts.discarded += fontInfo.length;
+			const woffFontFound =
+				findSourceByFormat("woff2-variations", true) || findSourceByFormat("woff2", true) || findSourceByFormat("woff", true) ||
+				findSourceByContentType("font/woff2", true) || findSourceByContentType("font/woff", true) || findSourceByContentType("application/font-woff", true) || findSourceByContentType("application/x-font-woff", true);
+			if (woffFontFound) {
+				fontInfo = filterSources(woffFontFound);
 			} else {
-				removedRules.push(cssRule);
-			}
-		}
-	}
-	removedRules.forEach(cssRule => cssRules.remove(cssRule));
-}
-
-async function processFontFaceRule(ruleData, fontInfo, fontResources, fontTests, stats) {
-	await Promise.all(fontInfo.map(async source => {
-		if (fontTests.has(source.src)) {
-			source.valid = fontTests.get(source.src);
-		} else {
-			if (FontFace && source.fontUrl) {
-				const resourceEntry = [...fontResources].find(([, resource]) => source.fontUrl && resource.name == source.fontUrl);
-				if (resourceEntry) {
-					const resource = resourceEntry[1];
-					const fontFace = new FontFace("test-font", new Uint8Array(resource.content).buffer);
-					try {
-						let timeout;
-						await Promise.race([
-							fontFace.load().then(() => fontFace.loaded).then(() => { source.valid = true; globalThis.clearTimeout(timeout); }),
-							new Promise(resolve => timeout = globalThis.setTimeout(() => { source.valid = true; resolve(); }, FONT_MAX_LOAD_DELAY))
-						]);
-					} catch (error) {
-						const fontFace = new FontFace("test-font", "url(" + resource.url + ")");
-						try {
-							let timeout;
-							await Promise.race([
-								fontFace.load().then(() => fontFace.loaded).then(() => { source.valid = true; globalThis.clearTimeout(timeout); }),
-								new Promise(resolve => timeout = globalThis.setTimeout(() => { source.valid = true; resolve(); }, FONT_MAX_LOAD_DELAY))
-							]);
-						} catch (error) {
-							// ignored
-						}
-					}
+				const ttfFontFound =
+					findSourceByFormat("truetype-variations", true) || findSourceByFormat("truetype", true) ||
+					findSourceByContentType("font/ttf", true) || findSourceByContentType("application/x-font-ttf", true) || findSourceByContentType("application/x-font-ttf", true) || findSourceByContentType("application/x-font-truetype", true);
+				if (ttfFontFound) {
+					fontInfo = filterSources(ttfFontFound);
 				} else {
-					source.valid = true;
+					const otfFontFound =
+						findSourceByFormat("opentype") || findSourceByFormat("embedded-opentype") ||
+						findSourceByContentType("font/otf") || findSourceByContentType("application/x-font-opentype") || findSourceByContentType("application/font-sfnt");
+					if (otfFontFound) {
+						fontInfo = filterSources(otfFontFound);
+					} else {
+						fontInfo = fontInfo.filter(source => !source.src.match(EMPTY_URL_SOURCE) && (source.valid) || source.src.startsWith(LOCAL_SOURCE));
+					}
 				}
-			} else {
-				source.valid = true;
 			}
-			fontTests.set(source.src, source.valid);
-		}
-	}));
-	const findSourceByFormat = (fontFormat, testValidity) => fontInfo.find(source => !source.src.match(EMPTY_URL_SOURCE) && source.format == fontFormat && (!testValidity || source.valid));
-	const findSourceByContentType = (contentType, testValidity) => fontInfo.find(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));
-	stats.fonts.processed += fontInfo.length;
-	stats.fonts.discarded += fontInfo.length;
-	const woffFontFound =
-		findSourceByFormat("woff2-variations", true) || findSourceByFormat("woff2", true) || findSourceByFormat("woff", true) ||
-		findSourceByContentType("font/woff2", true) || findSourceByContentType("font/woff", true) || findSourceByContentType("application/font-woff", true) || findSourceByContentType("application/x-font-woff", true);
-	if (woffFontFound) {
-		fontInfo = filterSources(woffFontFound);
-	} else {
-		const ttfFontFound =
-			findSourceByFormat("truetype-variations", true) || findSourceByFormat("truetype", true) ||
-			findSourceByContentType("font/ttf", true) || findSourceByContentType("application/x-font-ttf", true) || findSourceByContentType("application/x-font-ttf", true) || findSourceByContentType("application/x-font-truetype", true);
-		if (ttfFontFound) {
-			fontInfo = filterSources(ttfFontFound);
-		} else {
-			const otfFontFound =
-				findSourceByFormat("opentype") || findSourceByFormat("embedded-opentype") ||
-				findSourceByContentType("font/otf") || findSourceByContentType("application/x-font-opentype") || findSourceByContentType("application/font-sfnt");
-			if (otfFontFound) {
-				fontInfo = filterSources(otfFontFound);
-			} else {
-				fontInfo = fontInfo.filter(source => !source.src.match(EMPTY_URL_SOURCE) && (source.valid) || source.src.startsWith(LOCAL_SOURCE));
+			stats.fonts.discarded -= fontInfo.length;
+			const removedNodes = [];
+			for (let node = ruleData.block.children.head; node; node = node.next) {
+				if (node.data.property == "src") {
+					removedNodes.push(node);
+				}
 			}
-		}
-	}
-	stats.fonts.discarded -= fontInfo.length;
-	const removedNodes = [];
-	for (let node = ruleData.block.children.head; node; node = node.next) {
-		if (node.data.property == "src") {
-			removedNodes.push(node);
-		}
-	}
-	removedNodes.pop();
-	removedNodes.forEach(node => ruleData.block.children.remove(node));
-	const srcDeclaration = ruleData.block.children.filter(node => node.property == "src").tail;
-	if (srcDeclaration) {
-		fontInfo.reverse();
-		try {
-			srcDeclaration.data.value = cssTree.parse(fontInfo.map(fontSource => fontSource.src).join(","), { context: "value", parseCustomProperty: true });
-		}
-		catch (error) {
-			// ignored
-		}
-	}
-}
-
-function getPropertyValue(ruleData, propertyName) {
-	let property;
-	if (ruleData.block.children) {
-		property = ruleData.block.children.filter(node => {
-			try {
-				return node.property == propertyName && !cssTree.generate(node.value).match(/\\9$/);
-			} catch (error) {
-				return node.property == propertyName;
+			removedNodes.pop();
+			removedNodes.forEach(node => ruleData.block.children.remove(node));
+			const srcDeclaration = ruleData.block.children.filter(node => node.property == "src").tail;
+			if (srcDeclaration) {
+				fontInfo.reverse();
+				try {
+					srcDeclaration.data.value = cssTree.parse(fontInfo.map(fontSource => fontSource.src).join(","), { context: "value", parseCustomProperty: true });
+				}
+				catch (error) {
+					// ignored
+				}
+				return true;
 			}
-		}).tail;
-	}
-	if (property) {
-		try {
-			return cssTree.generate(property.data.value);
-		} catch (error) {
-			// ignored
 		}
-	}
-}
-
-function getFontKey(ruleData) {
-	return JSON.stringify([
-		normalizeFontFamily(getPropertyValue(ruleData, "font-family")),
-		getFontWeight(getPropertyValue(ruleData, "font-weight") || "400"),
-		getPropertyValue(ruleData, "font-style") || "normal",
-		getPropertyValue(ruleData, "unicode-range"),
-		getFontStretch(getPropertyValue(ruleData, "font-stretch")),
-		getPropertyValue(ruleData, "font-variant") || "normal",
-		getPropertyValue(ruleData, "font-feature-settings"),
-		getPropertyValue(ruleData, "font-variation-settings")
-	]);
-}
-
-function getFontStretch(stretch) {
-	return FONT_STRETCHES[stretch] || stretch;
-}
-
-function createFontsDetailsInfo() {
-	return {
-		fonts: new Map(),
-		medias: new Map(),
-		supports: new Map()
 	};
-}
-
-function getURL(urlFunction) {
-	urlFunction = urlFunction.replace(/url\(-sf-url-original\\\(\\"(.*?)\\"\\\)\\ /g, "");
-	const urlMatch = urlFunction.match(REGEXP_URL_SIMPLE_QUOTES_FN) ||
-		urlFunction.match(REGEXP_URL_DOUBLE_QUOTES_FN) ||
-		urlFunction.match(REGEXP_URL_NO_QUOTES_FN);
-	return urlMatch && urlMatch[1];
 }