single-file-core 1.1.78 → 1.2.0

package/core/index.js

@@ -23,36 +23,40 @@
 
 /* global globalThis */
 
+import {
+	getProcessorHelperClass,
+	cssTree
+} from "./processor-helper.js";
+
 const DEBUG = false;
 
 const Set = globalThis.Set;
 const Map = globalThis.Map;
 const JSON = globalThis.JSON;
-const setTimeout = globalThis.setTimeout;
-const clearTimeout = globalThis.clearTimeout;
-const Image = globalThis.Image;
 
-let util, cssTree;
+let util;
 
 export {
 	getClass
 };
 
 function getClass(...args) {
-	[util, cssTree] = args;
+	[util] = args;
 	return SingleFileClass;
 }
 
 class SingleFileClass {
 	constructor(options) {
 		this.options = options;
+		const ProcessorHelper = getProcessorHelperClass(options, util);
+		this.processorHelper = new ProcessorHelper();
 	}
 	async run() {
 		const waitForUserScript = globalThis[util.WAIT_FOR_USERSCRIPT_PROPERTY_NAME];
 		if (this.options.userScriptEnabled && waitForUserScript) {
 			await waitForUserScript(util.ON_BEFORE_CAPTURE_EVENT_NAME);
 		}
-		this.runner = new Runner(this.options, true);
+		this.runner = new Runner(this.options, this.processorHelper, true);
 		await this.runner.loadPage();
 		await this.runner.initialize();
 		if (this.options.userScriptEnabled && waitForUserScript) {
@@ -124,7 +128,7 @@ const STAGES = [{
 	],
 	parallel: [
 		{ option: "blockVideos", action: "insertMissingVideoPosters" },
-		{ action: "resolveStylesheetURLs" },
+		{ action: "resolveStylesheetsURLs" },
 		{ option: "!removeFrames", action: "resolveFrameURLs" }
 	]
 }, {
@@ -162,7 +166,7 @@ const STAGES = [{
 }];
 
 class Runner {
-	constructor(options, root) {
+	constructor(options, processorHelper, root) {
 		const rootDocDefined = root && options.doc;
 		this.root = root;
 		this.options = options;
@@ -174,7 +178,7 @@ class Runner {
 		this.options.updatedResources = this.options.updatedResources || {};
 		this.options.fontTests = new Map();
 		this.batchRequest = new BatchRequest();
-		this.processor = new Processor(options, this.batchRequest);
+		this.processor = new Processor(options, processorHelper, this.batchRequest);
 		if (rootDocDefined) {
 			const docData = util.preProcessDoc(this.options.doc, this.options.win, this.options);
 			this.options.canvases = docData.canvases;
@@ -360,6 +364,7 @@ class BatchRequest {
 				indexResource = indexResource + 1;
 				const content = await util.getContent(resourceURL, {
 					asBinary,
+					inline: !options.compressContent,
 					expectedType,
 					maxResourceSize: options.maxResourceSize,
 					maxResourceSizeEnabled: options.maxResourceSizeEnabled,
@@ -372,10 +377,11 @@ class BatchRequest {
 				});
 				onloadListener({ url: resourceURL });
 				if (!this.cancelled) {
+					const extension = util.getContentTypeExtension(content.contentType) || util.getFilenameExtension(resourceURL, options.filenameReplacedCharacters, options.filenameReplacementCharacter);
 					resourceRequests.forEach(callbacks => {
 						const duplicateCallbacks = this.duplicates.get(requestKey);
 						const duplicate = duplicateCallbacks && duplicateCallbacks.length > 1 && duplicateCallbacks.includes(callbacks);
-						callbacks.resolve({ content: content.data, indexResource: currentIndexResource, duplicate });
+						callbacks.resolve({ content: content.data, indexResource: currentIndexResource, duplicate, contentType: content.contentType, extension });
 					});
 				}
 			} catch (error) {
@@ -401,24 +407,27 @@ class BatchRequest {
 // ---------
 // Processor
 // ---------
-const PREFIXES_FORBIDDEN_DATA_URI = ["data:text/"];
-const PREFIX_DATA_URI_IMAGE_SVG = "data:image/svg+xml";
-const SCRIPT_TAG_FOUND = /<script/gi;
-const NOSCRIPT_TAG_FOUND = /<noscript/gi;
-const CANVAS_TAG_FOUND = /<canvas/gi;
-const SHADOWROOT_ATTRIBUTE_NAME = "shadowroot";
+const SHADOWROOT_ATTRIBUTE_NAME = "shadowrootmode";
 const SCRIPT_TEMPLATE_SHADOW_ROOT = "data-template-shadow-root";
 const UTF8_CHARSET = "utf-8";
 
 class Processor {
-	constructor(options, batchRequest) {
+	constructor(options, processorHelper, batchRequest) {
 		this.options = options;
+		this.processorHelper = processorHelper;
 		this.stats = new Stats(options);
 		this.baseURI = normalizeURL(options.baseURI || options.url);
 		this.batchRequest = batchRequest;
 		this.stylesheets = new Map();
 		this.styles = new Map();
-		this.cssVariables = new Map();
+		this.resources = {
+			cssVariables: new Map(),
+			fonts: new Map(),
+			stylesheets: new Map(),
+			scripts: new Map(),
+			images: new Map(),
+			frames: new Map()
+		};
 		this.fontTests = options.fontTests;
 	}
 
@@ -439,6 +448,7 @@ class Processor {
 		let content;
 		if (!pageContent || this.options.saveRawPage) {
 			content = await util.getContent(this.baseURI, {
+				inline: !this.options.compressContent,
 				maxResourceSize: this.options.maxResourceSize,
 				maxResourceSizeEnabled: this.options.maxResourceSizeEnabled,
 				charset,
@@ -532,10 +542,10 @@ class Processor {
 			}
 		}
 		if (this.options.insertMetaCSP) {
-			const metaTag = this.doc.createElement("meta");
-			metaTag.httpEquiv = "content-security-policy";
-			metaTag.content = "default-src 'none'; font-src 'self' data:; img-src 'self' data:; style-src 'unsafe-inline'; media-src 'self' data:; script-src 'unsafe-inline' data:; object-src 'self' data:; frame-src 'self' data:;";
-			this.doc.head.appendChild(metaTag);
+			const metaElement = this.doc.createElement("meta");
+			metaElement.httpEquiv = "content-security-policy";
+			this.processorHelper.setMetaCSP(metaElement);
+			this.doc.head.appendChild(metaElement);
 		}
 		if (this.options.insertMetaNoIndex) {
 			let metaElement = this.doc.querySelector("meta[name=robots][content*=noindex]");
@@ -561,12 +571,13 @@ class Processor {
 		}
 		const filename = await util.formatFilename(content, this.options);
 		const matchTitle = this.baseURI.match(/([^/]*)\/?(\.html?.*)$/) || this.baseURI.match(/\/\/([^/]*)\/?$/);
-		const pageData = {
+		const additionalData = this.processorHelper.getAdditionalPageData(this.doc, content, this.resources);
+		const pageData = Object.assign({
 			stats: this.stats.data,
 			title: this.options.title || (this.baseURI && matchTitle ? matchTitle[1] : url.hostname ? url.hostname : ""),
 			filename,
 			content
-		};
+		}, additionalData);
 		if (this.options.addProof) {
 			pageData.hash = await util.digest("SHA-256", content);
 		}
@@ -778,13 +789,13 @@ class Processor {
 		const noscriptPlaceholders = new Map();
 		this.doc.querySelectorAll("noscript").forEach(noscriptElement => {
 			const placeholderElement = this.doc.createElement("div");
-			placeholderElement.innerHTML = noscriptElement.dataset.singleFileDisabledNoscript;
+			placeholderElement.innerHTML = noscriptElement.dataset[util.NO_SCRIPT_PROPERTY_NAME];
 			noscriptElement.replaceWith(placeholderElement);
 			noscriptPlaceholders.set(placeholderElement, noscriptElement);
 		});
 		this.doc.querySelectorAll("meta[http-equiv=refresh], meta[disabled-http-equiv]").forEach(element => element.remove());
 		noscriptPlaceholders.forEach((noscriptElement, placeholderElement) => {
-			noscriptElement.dataset.singleFileDisabledNoscript = placeholderElement.innerHTML;
+			noscriptElement.dataset[util.NO_SCRIPT_PROPERTY_NAME] = placeholderElement.innerHTML;
 			placeholderElement.replaceWith(noscriptElement);
 		});
 		this.doc.querySelectorAll("meta[http-equiv=\"content-security-policy\"]").forEach(element => element.remove());
@@ -804,7 +815,8 @@ class Processor {
 				element.remove();
 			}
 		});
-		this.doc.querySelectorAll("link[rel*=stylesheet][rel*=alternate][title],link[rel*=stylesheet]:not([href]),link[rel*=stylesheet][href=\"\"]").forEach(element => element.remove());
+		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());
 		}
@@ -918,7 +930,7 @@ class Processor {
 						if (canvasData.backgroundColor) {
 							backgroundStyle["background-color"] = canvasData.backgroundColor;
 						}
-						ProcessorHelper.setBackgroundImage(canvasElement, "url(" + canvasData.dataURI + ")", backgroundStyle);
+						this.processorHelper.setBackgroundImage(canvasElement, "url(" + canvasData.dataURI + ")", backgroundStyle);
 						this.stats.add("processed", "canvas", 1);
 					}
 				}
@@ -1062,13 +1074,13 @@ class Processor {
 			} else {
 				const styleContent = element.getAttribute("style");
 				const declarationList = cssTree.parse(styleContent, { context: "declarationList", parseCustomProperty: true });
-				ProcessorHelper.resolveStylesheetURLs(declarationList, this.baseURI, this.workStyleElement);
+				this.processorHelper.resolveStylesheetURLs(declarationList, this.baseURI, this.workStyleElement);
 				this.styles.set(element, declarationList);
 			}
 		});
 	}
 
-	async resolveStylesheetURLs() {
+	async resolveStylesheetsURLs() {
 		await Promise.all(Array.from(this.doc.querySelectorAll("style, link[rel*=stylesheet]")).map(async element => {
 			const options = Object.assign({}, this.options, { charset: this.charset });
 			let mediaText;
@@ -1080,10 +1092,7 @@ class Processor {
 				mediaText,
 				scoped
 			};
-			if (element.tagName.toUpperCase() == "LINK" && element.charset) {
-				options.charset = element.charset;
-			}
-			await processElement(element, stylesheetInfo, this.stylesheets, this.baseURI, options, this.workStyleElement);
+			await this.processorHelper.processLinkElement(element, stylesheetInfo, this.stylesheets, this.baseURI, options, this.workStyleElement, this.resources);
 		}));
 		if (this.options.rootDocument) {
 			const newResources = Object.keys(this.options.updatedResources)
@@ -1096,38 +1105,14 @@ class Processor {
 					const element = this.doc.createElement("style");
 					this.doc.body.appendChild(element);
 					element.textContent = resource.content;
-					await processElement(element, stylesheetInfo, this.stylesheets, this.baseURI, this.options, this.workStyleElement);
+					await this.processorHelper.processStylesheetElement(element, stylesheetInfo, this.stylesheets, this.baseURI, this.options, this.workStyleElement, this.resources);
 				}
 			}));
 		}
-
-		async function processElement(element, stylesheetInfo, stylesheets, baseURI, options, workStyleElement) {
-			let stylesheet;
-			stylesheets.set(element, stylesheetInfo);
-			if (!options.blockStylesheets) {
-				if (element.tagName.toUpperCase() == "LINK") {
-					stylesheet = await ProcessorHelper.resolveLinkStylesheetURLs(element.href, baseURI, options, workStyleElement);
-				} else {
-					stylesheet = cssTree.parse(element.textContent, { context: "stylesheet", parseCustomProperty: true });
-					const importFound = await ProcessorHelper.resolveImportURLs(stylesheet, baseURI, options, workStyleElement);
-					if (importFound) {
-						stylesheet = cssTree.parse(cssTree.generate(stylesheet), { context: "stylesheet", parseCustomProperty: true });
-					}
-				}
-			}
-			if (stylesheet && stylesheet.children) {
-				if (options.compressCSS) {
-					ProcessorHelper.removeSingleLineCssComments(stylesheet);
-				}
-				ProcessorHelper.replacePseudoClassDefined(stylesheet);
-				stylesheetInfo.stylesheet = stylesheet;
-			} else {
-				stylesheets.delete(element);
-			}
-		}
 	}
 
 	async resolveFrameURLs() {
+		const processorHelper = this.processorHelper;
 		if (!this.options.saveRawPage) {
 			const frameElements = Array.from(this.doc.querySelectorAll("iframe, frame, object[type=\"text/html\"][data]"));
 			await Promise.all(frameElements.map(async frameElement => {
@@ -1173,7 +1158,7 @@ class Processor {
 				options.scrollPosition = frameData.scrollPosition;
 				options.scrolling = frameData.scrolling;
 				options.adoptedStyleSheets = frameData.adoptedStyleSheets;
-				frameData.runner = new Runner(options);
+				frameData.runner = new Runner(options, processorHelper);
 				frameData.frameElement = frameElement;
 				await frameData.runner.loadPage();
 				await frameData.runner.initialize();
@@ -1248,47 +1233,19 @@ class Processor {
 	}
 
 	async processStylesheets() {
-		this.options.fontDeclarations = new Map();
 		await Promise.all([...this.stylesheets].map(([, stylesheetInfo]) =>
-			ProcessorHelper.processStylesheet(stylesheetInfo.stylesheet.children, this.baseURI, this.options, this.cssVariables, this.batchRequest)
+			this.processorHelper.processStylesheet(stylesheetInfo.stylesheet.children, this.baseURI, this.options, this.resources, this.batchRequest)
 		));
 	}
 
 	async processStyleAttributes() {
 		return Promise.all([...this.styles].map(([, stylesheet]) =>
-			ProcessorHelper.processStyle(stylesheet, this.baseURI, this.options, this.cssVariables, this.batchRequest)
+			this.processorHelper.processStyle(stylesheet, this.options, this.resources, this.batchRequest)
 		));
 	}
 
 	async processPageResources() {
-		const processAttributeArgs = [
-			["link[href][rel*=\"icon\"]", "href", false, true],
-			["object[type=\"image/svg+xml\"], object[type=\"image/svg-xml\"], object[data*=\".svg\"]", "data"],
-			["img[src], input[src][type=image]", "src", true],
-			["embed[src*=\".svg\"]", "src"],
-			["video[poster]", "poster"],
-			["*[background]", "background"],
-			["image", "xlink:href"],
-			["image", "href"]
-		];
-		if (this.options.blockImages) {
-			this.doc.querySelectorAll("svg").forEach(element => element.remove());
-		}
-		let resourcePromises = processAttributeArgs.map(([selector, attributeName, processDuplicates, removeElementIfMissing]) =>
-			ProcessorHelper.processAttribute(this.doc.querySelectorAll(selector), attributeName, this.baseURI, this.options, "image", this.cssVariables, this.styles, this.batchRequest, processDuplicates, removeElementIfMissing)
-		);
-		resourcePromises = resourcePromises.concat([
-			ProcessorHelper.processXLinks(this.doc.querySelectorAll("use"), this.doc, this.baseURI, this.options, this.batchRequest),
-			ProcessorHelper.processSrcset(this.doc.querySelectorAll("img[srcset], source[srcset]"), this.baseURI, this.options, this.batchRequest)
-		]);
-		resourcePromises.push(ProcessorHelper.processAttribute(this.doc.querySelectorAll("object[data*=\".pdf\"]"), "data", this.baseURI, this.options, null, this.cssVariables, this.styles, this.batchRequest));
-		resourcePromises.push(ProcessorHelper.processAttribute(this.doc.querySelectorAll("embed[src*=\".pdf\"]"), "src", this.baseURI, this.options, null, this.cssVariables, this.styles, this.batchRequest));
-		resourcePromises.push(ProcessorHelper.processAttribute(this.doc.querySelectorAll("audio[src], audio > source[src]"), "src", this.baseURI, this.options, "audio", this.cssVariables, this.styles, this.batchRequest));
-		resourcePromises.push(ProcessorHelper.processAttribute(this.doc.querySelectorAll("video[src], video > source[src]"), "src", this.baseURI, this.options, "video", this.cssVariables, this.styles, this.batchRequest));
-		await Promise.all(resourcePromises);
-		if (this.options.saveFavicon) {
-			ProcessorHelper.processShortcutIcons(this.doc);
-		}
+		await this.processorHelper.processPageResources(this.doc, this.baseURI, this.options, this.resources, this.styles, this.batchRequest);
 	}
 
 	async processScripts() {
@@ -1309,21 +1266,7 @@ class Processor {
 				}
 				if (testValidURL(resourceURL)) {
 					element.removeAttribute("src");
-					const content = await util.getContent(resourceURL, {
-						asBinary: true,
-						charset: this.charset != UTF8_CHARSET && this.charset,
-						maxResourceSize: this.options.maxResourceSize,
-						maxResourceSizeEnabled: this.options.maxResourceSizeEnabled,
-						frameId: this.options.windowId,
-						resourceReferrer: this.options.resourceReferrer,
-						baseURI: this.options.baseURI,
-						blockMixedContent: this.options.blockMixedContent,
-						expectedType: "script",
-						acceptHeaders: this.options.acceptHeaders,
-						networkTimeout: this.options.networkTimeout
-					});
-					content.data = getUpdatedResourceContent(resourceURL, content, this.options);
-					element.setAttribute("src", content.data);
+					await this.processorHelper.processScript(element, resourceURL);
 					if (element.getAttribute("async") == "async" || element.getAttribute(util.ASYNC_SCRIPT_ATTRIBUTE_NAME) == "") {
 						element.setAttribute("async", "");
 					}
@@ -1340,7 +1283,7 @@ class Processor {
 	}
 
 	async removeAlternativeFonts() {
-		await util.removeAlternativeFonts(this.doc, this.stylesheets, this.options.fontDeclarations, this.options.fontTests);
+		await this.processorHelper.removeAlternativeFonts(this.doc, this.stylesheets, this.resources.fonts, this.options.fontTests);
 	}
 
 	async processFrames() {
@@ -1357,21 +1300,7 @@ class Processor {
 							await frameData.runner.run();
 							const pageData = await frameData.runner.getPageData();
 							frameElement.removeAttribute(util.WIN_ID_ATTRIBUTE_NAME);
-							let sandbox = "allow-popups allow-top-navigation allow-top-navigation-by-user-activation";
-							if (pageData.content.match(NOSCRIPT_TAG_FOUND) || pageData.content.match(CANVAS_TAG_FOUND) || pageData.content.match(SCRIPT_TAG_FOUND)) {
-								sandbox += " allow-scripts allow-same-origin";
-							}
-							frameElement.setAttribute("sandbox", sandbox);
-							if (frameElement.tagName.toUpperCase() == "OBJECT") {
-								frameElement.setAttribute("data", "data:text/html," + pageData.content);
-							} else {
-								if (frameElement.tagName.toUpperCase() == "FRAME") {
-									frameElement.setAttribute("src", "data:text/html," + pageData.content.replace(/%/g, "%25").replace(/#/g, "%23"));
-								} else {
-									frameElement.setAttribute("srcdoc", pageData.content);
-									frameElement.removeAttribute("src");
-								}
-							}
+							this.processorHelper.processFrame(frameElement, pageData, this.resources, frameWindowId, frameData);
 							this.stats.addAll(pageData);
 						} else {
 							frameElement.removeAttribute(util.WIN_ID_ATTRIBUTE_NAME);
@@ -1384,32 +1313,7 @@ class Processor {
 	}
 
 	replaceStylesheets() {
-		this.doc.querySelectorAll("style").forEach(styleElement => {
-			const stylesheetInfo = this.stylesheets.get(styleElement);
-			if (stylesheetInfo) {
-				this.stylesheets.delete(styleElement);
-				styleElement.textContent = generateStylesheetContent(stylesheetInfo.stylesheet, this.options);
-				if (stylesheetInfo.mediaText) {
-					styleElement.media = stylesheetInfo.mediaText;
-				}
-			} else {
-				styleElement.remove();
-			}
-		});
-		this.doc.querySelectorAll("link[rel*=stylesheet]").forEach(linkElement => {
-			const stylesheetInfo = this.stylesheets.get(linkElement);
-			if (stylesheetInfo) {
-				this.stylesheets.delete(linkElement);
-				const styleElement = this.doc.createElement("style");
-				if (stylesheetInfo.mediaText) {
-					styleElement.media = stylesheetInfo.mediaText;
-				}
-				styleElement.textContent = generateStylesheetContent(stylesheetInfo.stylesheet, this.options);
-				linkElement.parentElement.replaceChild(styleElement, linkElement);
-			} else {
-				linkElement.remove();
-			}
-		});
+		this.processorHelper.replaceStylesheets(this.doc, this.stylesheets, this.resources, this.options);
 	}
 
 	replaceStyleAttributes() {
@@ -1417,7 +1321,7 @@ class Processor {
 			const declarationList = this.styles.get(element);
 			if (declarationList) {
 				this.styles.delete(element);
-				element.setAttribute("style", generateStylesheetContent(declarationList, this.options));
+				element.setAttribute("style", this.processorHelper.generateStylesheetContent(declarationList, this.options));
 			} else {
 				element.setAttribute("style", "");
 			}
@@ -1425,7 +1329,8 @@ class Processor {
 	}
 
 	insertVariables() {
-		if (this.cssVariables.size) {
+		const { cssVariables } = this.resources;
+		if (cssVariables.size) {
 			const styleElement = this.doc.createElement("style");
 			const firstStyleElement = this.doc.head.querySelector("style");
 			if (firstStyleElement) {
@@ -1434,8 +1339,8 @@ class Processor {
 				this.doc.head.appendChild(styleElement);
 			}
 			let stylesheetContent = "";
-			this.cssVariables.forEach(({ content, url }, indexResource) => {
-				this.cssVariables.delete(indexResource);
+			cssVariables.forEach(({ content, url }, indexResource) => {
+				cssVariables.delete(indexResource);
 				if (stylesheetContent) {
 					stylesheetContent += ";";
 				}
@@ -1528,559 +1433,17 @@ class Processor {
 	}
 }
 
-// ---------------
-// ProcessorHelper
-// ---------------
-const DATA_URI_PREFIX = "data:";
-const ABOUT_BLANK_URI = "about:blank";
-const REGEXP_URL_HASH = /(#.+?)$/;
-const SINGLE_FILE_VARIABLE_NAME_PREFIX = "--sf-img-";
-const SINGLE_FILE_VARIABLE_MAX_SIZE = 512 * 1024;
-
-class ProcessorHelper {
-	static setBackgroundImage(element, url, style) {
-		element.style.setProperty("background-blend-mode", "normal", "important");
-		element.style.setProperty("background-clip", "content-box", "important");
-		element.style.setProperty("background-position", style && style["background-position"] ? style["background-position"] : "center", "important");
-		element.style.setProperty("background-color", style && style["background-color"] ? style["background-color"] : "transparent", "important");
-		element.style.setProperty("background-image", url, "important");
-		element.style.setProperty("background-size", style && style["background-size"] ? style["background-size"] : "100% 100%", "important");
-		element.style.setProperty("background-origin", "content-box", "important");
-		element.style.setProperty("background-repeat", "no-repeat", "important");
-	}
-
-	static processShortcutIcons(doc) {
-		let shortcutIcon = findShortcutIcon(Array.from(doc.querySelectorAll("link[href][rel=\"shortcut icon\"]")));
-		if (!shortcutIcon) {
-			shortcutIcon = findShortcutIcon(Array.from(doc.querySelectorAll("link[href][rel=\"icon\"]")));
-		}
-		if (!shortcutIcon) {
-			shortcutIcon = findShortcutIcon(Array.from(doc.querySelectorAll("link[href][rel*=\"icon\"]")));
-			if (shortcutIcon) {
-				shortcutIcon.rel = "shortcut icon";
-			}
-		}
-		if (shortcutIcon) {
-			doc.querySelectorAll("link[href][rel*=\"icon\"]").forEach(linkElement => {
-				if (linkElement != shortcutIcon) {
-					linkElement.remove();
-				}
-			});
-		}
-	}
-
-	static removeSingleLineCssComments(stylesheet) {
-		if (stylesheet.children) {
-			const removedRules = [];
-			for (let cssRule = stylesheet.children.head; cssRule; cssRule = cssRule.next) {
-				const ruleData = cssRule.data;
-				if (ruleData.type == "Raw" && ruleData.value && ruleData.value.trim().startsWith("//")) {
-					removedRules.push(cssRule);
-				}
-			}
-			removedRules.forEach(cssRule => stylesheet.children.remove(cssRule));
-		}
-	}
-
-	static replacePseudoClassDefined(stylesheet) {
-		const removedSelectors = [];
-		if (stylesheet.children) {
-			for (let cssRule = stylesheet.children.head; cssRule; cssRule = cssRule.next) {
-				const ruleData = cssRule.data;
-				if (ruleData.type == "Rule" && ruleData.prelude && ruleData.prelude.children) {
-					for (let selector = ruleData.prelude.children.head; selector; selector = selector.next) {
-						replacePseudoDefinedSelector(selector, ruleData.prelude);
-					}
-				}
-			}
-		}
-		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);
-				}
-			});
-		}
-
-		function replacePseudoDefinedSelector(selector, parentSelector) {
-			if (selector.data.children) {
-				for (let childSelector = selector.data.children.head; childSelector; childSelector = childSelector.next) {
-					replacePseudoDefinedSelector(childSelector, selector);
-				}
-			}
-			if (selector.data.type == "PseudoClassSelector" && selector.data.name == "defined") {
-				removedSelectors.push({ parentSelector, selector });
-			}
-		}
-	}
-
-	static async resolveImportURLs(stylesheet, baseURI, options, workStylesheet, importedStyleSheets = new Set()) {
-		let importFound;
-		ProcessorHelper.resolveStylesheetURLs(stylesheet, baseURI, workStylesheet);
-		const imports = getImportFunctions(stylesheet);
-		await Promise.all(imports.map(async node => {
-			const urlNode = cssTree.find(node, node => node.type == "Url") || cssTree.find(node, node => node.type == "String");
-			if (urlNode) {
-				let resourceURL = normalizeURL(urlNode.value);
-				if (!testIgnoredPath(resourceURL) && testValidPath(resourceURL)) {
-					urlNode.value = util.EMPTY_RESOURCE;
-					try {
-						resourceURL = util.resolveURL(resourceURL, baseURI);
-					} catch (error) {
-						// ignored
-					}
-					if (testValidURL(resourceURL) && !importedStyleSheets.has(resourceURL)) {
-						const content = await getStylesheetContent(resourceURL);
-						resourceURL = content.resourceURL;
-						content.data = getUpdatedResourceContent(resourceURL, content, options);
-						if (content.data && content.data.match(/^<!doctype /i)) {
-							content.data = "";
-						}
-						const mediaQueryListNode = cssTree.find(node, node => node.type == "MediaQueryList");
-						if (mediaQueryListNode) {
-							content.data = wrapMediaQuery(content.data, cssTree.generate(mediaQueryListNode));
-						}
-
-						content.data = content.data.replace(/:defined/gi, "*");
-
-						const importedStylesheet = cssTree.parse(content.data, { context: "stylesheet", parseCustomProperty: true });
-						const ancestorStyleSheets = new Set(importedStyleSheets);
-						ancestorStyleSheets.add(resourceURL);
-						await ProcessorHelper.resolveImportURLs(importedStylesheet, resourceURL, options, workStylesheet, ancestorStyleSheets);
-						for (let keyName of Object.keys(importedStylesheet)) {
-							node[keyName] = importedStylesheet[keyName];
-						}
-						importFound = true;
-					}
-				}
-			}
-		}));
-		return importFound;
-
-		async function getStylesheetContent(resourceURL) {
-			const content = await util.getContent(resourceURL, {
-				maxResourceSize: options.maxResourceSize,
-				maxResourceSizeEnabled: options.maxResourceSizeEnabled,
-				validateTextContentType: true,
-				frameId: options.frameId,
-				charset: options.charset,
-				resourceReferrer: options.resourceReferrer,
-				baseURI: options.baseURI,
-				blockMixedContent: options.blockMixedContent,
-				expectedType: "stylesheet",
-				acceptHeaders: options.acceptHeaders,
-				networkTimeout: options.networkTimeout
-			});
-			if (!(matchCharsetEquals(content.data, content.charset) || matchCharsetEquals(content.data, options.charset))) {
-				options = Object.assign({}, options, { charset: getCharset(content.data) });
-				return util.getContent(resourceURL, {
-					maxResourceSize: options.maxResourceSize,
-					maxResourceSizeEnabled: options.maxResourceSizeEnabled,
-					validateTextContentType: true,
-					frameId: options.frameId,
-					charset: options.charset,
-					resourceReferrer: options.resourceReferrer,
-					baseURI: options.baseURI,
-					blockMixedContent: options.blockMixedContent,
-					expectedType: "stylesheet",
-					acceptHeaders: options.acceptHeaders,
-					networkTimeout: options.networkTimeout
-				});
-			} else {
-				return content;
-			}
-		}
-	}
-
-	static resolveStylesheetURLs(stylesheet, baseURI, workStylesheet) {
-		const urls = getUrlFunctions(stylesheet);
-		urls.map(urlNode => {
-			const originalResourceURL = urlNode.value;
-			let resourceURL = normalizeURL(originalResourceURL);
-			if (!testIgnoredPath(resourceURL)) {
-				workStylesheet.textContent = "tmp { content:\"" + resourceURL + "\"}";
-				if (workStylesheet.sheet && workStylesheet.sheet.cssRules) {
-					resourceURL = util.removeQuotes(workStylesheet.sheet.cssRules[0].style.getPropertyValue("content"));
-				}
-				if (!testIgnoredPath(resourceURL)) {
-					if (!resourceURL || testValidPath(resourceURL)) {
-						let resolvedURL;
-						if (!originalResourceURL.startsWith("#")) {
-							try {
-								resolvedURL = util.resolveURL(resourceURL, baseURI);
-							} catch (error) {
-								// ignored
-							}
-						}
-						if (testValidURL(resolvedURL)) {
-							urlNode.value = resolvedURL;
-						}
-					} else {
-						urlNode.value = util.EMPTY_RESOURCE;
-					}
-				}
-			}
-		});
-	}
-
-	static async resolveLinkStylesheetURLs(resourceURL, baseURI, options, workStylesheet) {
-		resourceURL = normalizeURL(resourceURL);
-		if (resourceURL && resourceURL != baseURI && resourceURL != ABOUT_BLANK_URI) {
-			const content = await util.getContent(resourceURL, {
-				maxResourceSize: options.maxResourceSize,
-				maxResourceSizeEnabled: options.maxResourceSizeEnabled,
-				charset: options.charset,
-				frameId: options.frameId,
-				resourceReferrer: options.resourceReferrer,
-				validateTextContentType: true,
-				baseURI: baseURI,
-				blockMixedContent: options.blockMixedContent,
-				expectedType: "stylesheet",
-				acceptHeaders: options.acceptHeaders,
-				networkTimeout: options.networkTimeout
-			});
-			if (!(matchCharsetEquals(content.data, content.charset) || matchCharsetEquals(content.data, options.charset))) {
-				options = Object.assign({}, options, { charset: getCharset(content.data) });
-				return ProcessorHelper.resolveLinkStylesheetURLs(resourceURL, baseURI, options, workStylesheet);
-			}
-			resourceURL = content.resourceURL;
-			content.data = getUpdatedResourceContent(content.resourceURL, content, options);
-			if (content.data && content.data.match(/^<!doctype /i)) {
-				content.data = "";
-			}
-
-			content.data = content.data.replace(/:defined/gi, "*");
-
-			let stylesheet = cssTree.parse(content.data, { context: "stylesheet", parseCustomProperty: true });
-			const importFound = await ProcessorHelper.resolveImportURLs(stylesheet, resourceURL, options, workStylesheet);
-			if (importFound) {
-				stylesheet = cssTree.parse(cssTree.generate(stylesheet), { context: "stylesheet", parseCustomProperty: true });
-			}
-			return stylesheet;
-		}
-	}
-
-	static async processStylesheet(cssRules, baseURI, options, cssVariables, 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, baseURI, options, cssVariables, batchRequest));
-				} else if (ruleData.type == "Atrule" && (ruleData.name == "media" || ruleData.name == "supports")) {
-					promises.push(this.processStylesheet(ruleData.block.children, baseURI, options, cssVariables, 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 } = await batchRequest.addURL(resourceURL, { asBinary: true, expectedType: "font", baseURI, blockMixedContent: options.blockMixedContent });
-						let resourceURLs = options.fontDeclarations.get(urlNode);
-						if (!resourceURLs) {
-							resourceURLs = [];
-							options.fontDeclarations.set(urlNode, resourceURLs);
-						}
-						resourceURLs.push(resourceURL);
-						if (!isDataURL(resourceURL) && options.saveOriginalURLs) {
-							urlNode.value = "-sf-url-original(" + JSON.stringify(originalResourceURL) + ") " + content;
-						} else {
-							urlNode.value = content;
-						}
-					}
-				} else {
-					urlNode.value = util.EMPTY_RESOURCE;
-				}
-			}));
-		}
-	}
-
-	static async processStyle(ruleData, baseURI, options, cssVariables, batchRequest) {
-		const urls = getUrlFunctions(ruleData);
-		await Promise.all(urls.map(async urlNode => {
-			const originalResourceURL = urlNode.value;
-			if (!options.blockImages) {
-				const resourceURL = normalizeURL(originalResourceURL);
-				if (!testIgnoredPath(resourceURL) && testValidURL(resourceURL)) {
-					let { content, indexResource, duplicate } = await batchRequest.addURL(resourceURL, { asBinary: true, expectedType: "image", groupDuplicates: options.groupDuplicateImages });
-					if (!originalResourceURL.startsWith("#")) {
-						const maxSizeDuplicateImages = options.maxSizeDuplicateImages || SINGLE_FILE_VARIABLE_MAX_SIZE;
-						if (duplicate && options.groupDuplicateImages && util.getContentSize(content) < maxSizeDuplicateImages) {
-							const varNode = cssTree.parse("var(" + SINGLE_FILE_VARIABLE_NAME_PREFIX + indexResource + ")", { context: "value" });
-							for (let keyName of Object.keys(varNode.children.head.data)) {
-								urlNode[keyName] = varNode.children.head.data[keyName];
-							}
-							cssVariables.set(indexResource, { content, url: originalResourceURL });
-						} else {
-							if (!isDataURL(resourceURL) && options.saveOriginalURLs) {
-								urlNode.value = "-sf-url-original(" + JSON.stringify(originalResourceURL) + ") " + content;
-							} else {
-								urlNode.value = content;
-							}
-						}
-					}
-				}
-			} else {
-				urlNode.value = util.EMPTY_RESOURCE;
-			}
-		}));
-	}
-
-	static async processAttribute(resourceElements, attributeName, baseURI, options, expectedType, cssVariables, styles, batchRequest, processDuplicates, removeElementIfMissing) {
-		await Promise.all(Array.from(resourceElements).map(async resourceElement => {
-			let resourceURL = resourceElement.getAttribute(attributeName);
-			if (resourceURL != null) {
-				resourceURL = normalizeURL(resourceURL);
-				let originURL = resourceElement.dataset.singleFileOriginURL;
-				if (options.saveOriginalURLs && !isDataURL(resourceURL)) {
-					resourceElement.setAttribute("data-sf-original-" + attributeName, resourceURL);
-				}
-				delete resourceElement.dataset.singleFileOriginURL;
-				if (!options["block" + expectedType.charAt(0).toUpperCase() + expectedType.substring(1) + "s"]) {
-					if (!testIgnoredPath(resourceURL)) {
-						setAttributeEmpty(resourceElement, attributeName, expectedType);
-						if (testValidPath(resourceURL)) {
-							try {
-								resourceURL = util.resolveURL(resourceURL, baseURI);
-							} catch (error) {
-								// ignored
-							}
-							if (testValidURL(resourceURL)) {
-								let { content, indexResource, duplicate } = await batchRequest.addURL(
-									resourceURL,
-									{ asBinary: true, expectedType, groupDuplicates: options.groupDuplicateImages && resourceElement.tagName.toUpperCase() == "IMG" && attributeName == "src" });
-								if (originURL) {
-									if (content == util.EMPTY_RESOURCE) {
-										try {
-											originURL = util.resolveURL(originURL, baseURI);
-										} catch (error) {
-											// ignored
-										}
-										try {
-											resourceURL = originURL;
-											content = (
-												await util.getContent(resourceURL, {
-													asBinary: true,
-													expectedType,
-													maxResourceSize: options.maxResourceSize,
-													maxResourceSizeEnabled: options.maxResourceSizeEnabled,
-													frameId: options.windowId,
-													resourceReferrer: options.resourceReferrer,
-													acceptHeaders: options.acceptHeaders,
-													networkTimeout: options.networkTimeout
-												})
-											).data;
-										} catch (error) {
-											// ignored
-										}
-									}
-								}
-								if (removeElementIfMissing && content == util.EMPTY_RESOURCE) {
-									resourceElement.remove();
-								} else if (content !== util.EMPTY_RESOURCE) {
-									let forbiddenPrefixFound = PREFIXES_FORBIDDEN_DATA_URI.filter(prefixDataURI => content.startsWith(prefixDataURI)).length;
-									if (expectedType == "image") {
-										if (forbiddenPrefixFound && Image) {
-											forbiddenPrefixFound = await new Promise((resolve) => {
-												const image = new Image();
-												const timeoutId = setTimeout(() => resolve(true), 100);
-												image.src = content;
-												image.onload = () => cleanupAndResolve();
-												image.onerror = () => cleanupAndResolve(true);
-
-												function cleanupAndResolve(value) {
-													clearTimeout(timeoutId);
-													resolve(value);
-												}
-											});
-										}
-										if (!forbiddenPrefixFound) {
-											const isSVG = content.startsWith(PREFIX_DATA_URI_IMAGE_SVG);
-											const maxSizeDuplicateImages = options.maxSizeDuplicateImages || SINGLE_FILE_VARIABLE_MAX_SIZE;
-											if (processDuplicates && duplicate && !isSVG && util.getContentSize(content) < maxSizeDuplicateImages) {
-												if (ProcessorHelper.replaceImageSource(resourceElement, SINGLE_FILE_VARIABLE_NAME_PREFIX + indexResource, options)) {
-													cssVariables.set(indexResource, { content, url: originURL });
-													const declarationList = cssTree.parse(resourceElement.getAttribute("style"), { context: "declarationList", parseCustomProperty: true });
-													styles.set(resourceElement, declarationList);
-												} else {
-													resourceElement.setAttribute(attributeName, content);
-												}
-											} else {
-												resourceElement.setAttribute(attributeName, content);
-											}
-										}
-									} else {
-										resourceElement.setAttribute(attributeName, content);
-									}
-								}
-							}
-						}
-					}
-				} else {
-					setAttributeEmpty(resourceElement, attributeName, expectedType);
-				}
-			}
-		}));
-
-		function setAttributeEmpty(resourceElement, attributeName, expectedType) {
-			if (expectedType == "video" || expectedType == "audio") {
-				resourceElement.removeAttribute(attributeName);
-			} else {
-				resourceElement.setAttribute(attributeName, util.EMPTY_RESOURCE);
-			}
-		}
-	}
-
-	static async processXLinks(resourceElements, doc, baseURI, options, batchRequest) {
-		let attributeName = "xlink:href";
-		await Promise.all(Array.from(resourceElements).map(async resourceElement => {
-			let originalResourceURL = resourceElement.getAttribute(attributeName);
-			if (originalResourceURL == null) {
-				attributeName = "href";
-				originalResourceURL = resourceElement.getAttribute(attributeName);
-			}
-			if (options.saveOriginalURLs && !isDataURL(originalResourceURL)) {
-				resourceElement.setAttribute("data-sf-original-href", originalResourceURL);
-			}
-			let resourceURL = normalizeURL(originalResourceURL);
-			if (!options.blockImages) {
-				if (testValidPath(resourceURL) && !testIgnoredPath(resourceURL)) {
-					resourceElement.setAttribute(attributeName, util.EMPTY_RESOURCE);
-					try {
-						resourceURL = util.resolveURL(resourceURL, baseURI);
-					} catch (error) {
-						// ignored
-					}
-					if (testValidURL(resourceURL)) {
-						const hashMatch = originalResourceURL.match(REGEXP_URL_HASH);
-						if (originalResourceURL.startsWith(baseURI + "#")) {
-							resourceElement.setAttribute(attributeName, hashMatch[0]);
-						} else {
-							const response = await batchRequest.addURL(resourceURL, { expectedType: "image" });
-							const svgDoc = util.parseSVGContent(response.content);
-							if (hashMatch && hashMatch[0]) {
-								let symbolElement;
-								try {
-									symbolElement = svgDoc.querySelector(hashMatch[0]);
-								} catch (error) {
-									// ignored
-								}
-								if (symbolElement) {
-									resourceElement.setAttribute(attributeName, hashMatch[0]);
-									resourceElement.parentElement.insertBefore(symbolElement, resourceElement.parentElement.firstChild);
-								}
-							} else {
-								const content = await batchRequest.addURL(resourceURL, { expectedType: "image" });
-								resourceElement.setAttribute(attributeName, PREFIX_DATA_URI_IMAGE_SVG + "," + content);
-							}
-						}
-					}
-				} else if (resourceURL == options.url) {
-					resourceElement.setAttribute(attributeName, originalResourceURL.substring(resourceURL.length));
-				}
-			} else {
-				resourceElement.setAttribute(attributeName, util.EMPTY_RESOURCE);
-			}
-		}));
-	}
-
-	static async processSrcset(resourceElements, baseURI, options, 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 } = await batchRequest.addURL(resourceURL, { asBinary: true, expectedType: "image" });
-								const forbiddenPrefixFound = PREFIXES_FORBIDDEN_DATA_URI.filter(prefixDataURI => content.startsWith(prefixDataURI)).length;
-								if (forbiddenPrefixFound) {
-									return "";
-								}
-								return content + (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", "");
-			}
-		}));
-	}
-
-	static replaceImageSource(imgElement, variableName, options) {
-		const attributeValue = imgElement.getAttribute(util.IMAGE_ATTRIBUTE_NAME);
-		if (attributeValue) {
-			const imageData = options.images[Number(imgElement.getAttribute(util.IMAGE_ATTRIBUTE_NAME))];
-			if (imageData && imageData.replaceable) {
-				imgElement.setAttribute("src", `${PREFIX_DATA_URI_IMAGE_SVG},<svg xmlns="http://www.w3.org/2000/svg" width="${imageData.size.pxWidth}" height="${imageData.size.pxHeight}"><rect fill-opacity="0"/></svg>`);
-				const backgroundStyle = {};
-				const backgroundSize = (imageData.objectFit == "content" || imageData.objectFit == "cover") && imageData.objectFit;
-				if (backgroundSize) {
-					backgroundStyle["background-size"] = imageData.objectFit;
-				}
-				if (imageData.objectPosition) {
-					backgroundStyle["background-position"] = imageData.objectPosition;
-				}
-				if (imageData.backgroundColor) {
-					backgroundStyle["background-color"] = imageData.backgroundColor;
-				}
-				ProcessorHelper.setBackgroundImage(imgElement, "var(" + variableName + ")", backgroundStyle);
-				imgElement.removeAttribute(util.IMAGE_ATTRIBUTE_NAME);
-				return true;
-			}
-		}
-	}
-}
-
 // ----
 // Util
 // ----
+const DATA_URI_PREFIX = "data:";
+const ABOUT_BLANK_URI = "about:blank";
 const BLOB_URI_PREFIX = "blob:";
 const HTTP_URI_PREFIX = /^https?:\/\//;
 const FILE_URI_PREFIX = /^file:\/\//;
 const EMPTY_URL = /^https?:\/\/+\s*$/;
 const NOT_EMPTY_URL = /^(https?:\/\/|file:\/\/|blob:).+/;
-
-function getUpdatedResourceContent(resourceURL, content, options) {
-	if (options.rootDocument && options.updatedResources[resourceURL]) {
-		options.updatedResources[resourceURL].retrieved = true;
-		return options.updatedResources[resourceURL].content;
-	} else {
-		return content.data || "";
-	}
-}
+const SINGLE_FILE_VARIABLE_NAME_PREFIX = "--sf-img-";
 
 function normalizeURL(url) {
 	if (!url || url.startsWith(DATA_URI_PREFIX)) {
@@ -2090,22 +1453,6 @@ function normalizeURL(url) {
 	}
 }
 
-function matchCharsetEquals(stylesheetContent = "", charset = UTF8_CHARSET) {
-	const stylesheetCharset = getCharset(stylesheetContent);
-	if (stylesheetCharset) {
-		return stylesheetCharset == charset.toLowerCase();
-	} else {
-		return true;
-	}
-}
-
-function getCharset(stylesheetContent = "") {
-	const match = stylesheetContent.match(/^@charset\s+"([^"]*)";/i);
-	if (match && match[1]) {
-		return match[1].toLowerCase().trim();
-	}
-}
-
 function getOnEventAttributeNames(doc) {
 	const element = doc.createElement("div");
 	const attributeNames = [];
@@ -2118,39 +1465,10 @@ function getOnEventAttributeNames(doc) {
 	return attributeNames;
 }
 
-function getUrlFunctions(declarationList) {
-	return cssTree.findAll(declarationList, node => node.type == "Url");
-}
-
-function getImportFunctions(declarationList) {
-	return cssTree.findAll(declarationList, node => node.type == "Atrule" && node.name == "import");
-}
-
-function generateStylesheetContent(stylesheet, options) {
-	let stylesheetContent = cssTree.generate(stylesheet);
-	if (options.compressCSS) {
-		stylesheetContent = util.compressCSS(stylesheetContent);
-	}
-	if (options.saveOriginalURLs) {
-		stylesheetContent = replaceOriginalURLs(stylesheetContent);
-	}
-	return stylesheetContent;
-}
-
-function findShortcutIcon(shortcutIcons) {
-	shortcutIcons = shortcutIcons.filter(linkElement => linkElement.href != util.EMPTY_RESOURCE);
-	shortcutIcons.sort((linkElement1, linkElement2) => (parseInt(linkElement2.sizes, 10) || 16) - (parseInt(linkElement1.sizes, 10) || 16));
-	return shortcutIcons[0];
-}
-
 function isDataURL(url) {
 	return url && (url.startsWith(DATA_URI_PREFIX) || url.startsWith(BLOB_URI_PREFIX));
 }
 
-function replaceOriginalURLs(stylesheetContent) {
-	return stylesheetContent.replace(/url\(-sf-url-original\\\(\\"(.*?)\\"\\\)\\ /g, "/* original URL: $1 */url(");
-}
-
 function testIgnoredPath(resourceURL) {
 	return resourceURL && (resourceURL.startsWith(DATA_URI_PREFIX) || resourceURL == ABOUT_BLANK_URI);
 }
@@ -2163,14 +1481,6 @@ function testValidURL(resourceURL) {
 	return testValidPath(resourceURL) && (resourceURL.match(HTTP_URI_PREFIX) || resourceURL.match(FILE_URI_PREFIX) || resourceURL.startsWith(BLOB_URI_PREFIX)) && resourceURL.match(NOT_EMPTY_URL);
 }
 
-function wrapMediaQuery(stylesheetContent, mediaQuery) {
-	if (mediaQuery) {
-		return "@media " + mediaQuery + "{ " + stylesheetContent + " }";
-	} else {
-		return stylesheetContent;
-	}
-}
-
 function log(...args) {
 	console.log("S-File <core>   ", ...args); // eslint-disable-line no-console
 }