single-file-core 1.1.78 → 1.2.0

package/core/processor-helper.js

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2010-2022 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 { getProcessorHelperClass as getHelperInlineClass, cssTree } from "./lib/processor-helper-inline.js";
+import { getProcessorHelperClass as getHelperClass } from "./lib/processor-helper.js";
+
+export {
+	getProcessorHelperClass,
+	cssTree
+};
+
+function getProcessorHelperClass(options, utilInstance) {
+	return options.compressContent ? getHelperClass(utilInstance) : getHelperInlineClass(utilInstance);
+}

package/core/util.js

@@ -32,6 +32,13 @@ const ONE_MB = 1024 * 1024;
 const PREFIX_CONTENT_TYPE_TEXT = "text/";
 const DEFAULT_REPLACED_CHARACTERS = ["~", "+", "\\\\", "?", "%", "*", ":", "|", "\"", "<", ">", "\x00-\x1f", "\x7F"];
 const DEFAULT_REPLACEMENT_CHARACTER = "_";
+const CONTENT_TYPE_EXTENSIONS = {
+	"image/svg+xml": ".svg",
+	"image/png": ".png",
+	"image/jpeg": ".jpg",
+	"image/gif": ".gif",
+	"image/webp": ".webp"
+};
 
 const URL = globalThis.URL;
 const DOMParser = globalThis.DOMParser;
@@ -51,6 +58,14 @@ function getInstance(utilOptions) {
 	utilOptions.fetch = utilOptions.fetch || fetch;
 	utilOptions.frameFetch = utilOptions.frameFetch || utilOptions.fetch || fetch;
 	return {
+		getDoctypeString,
+		getFilenameExtension(resourceURL, replacedCharacters, replacementCharacter) {
+			const matchExtension = new URL(resourceURL).pathname.match(/(\.[^\\/.]*)$/);
+			return ((matchExtension && matchExtension[1] && this.getValidFilename(matchExtension[1], replacedCharacters, replacementCharacter)) || "").toLowerCase();
+		},
+		getContentTypeExtension(contentType) {
+			return CONTENT_TYPE_EXTENSIONS[contentType] || "";
+		},
 		getContent,
 		parseURL(resourceURL, baseURI) {
 			if (baseURI === undefined) {
@@ -130,9 +145,6 @@ function getInstance(utilOptions) {
 		removeUnusedFonts(doc, stylesheets, styles, options) {
 			return modules.fontsMinifier.process(doc, stylesheets, styles, options);
 		},
-		removeAlternativeFonts(doc, stylesheets, fontDeclarations, fontTests) {
-			return modules.fontsAltMinifier.process(doc, stylesheets, fontDeclarations, fontTests);
-		},
 		getMediaAllInfo(doc, stylesheets, styles) {
 			return modules.matchedRules.getMediaAllInfo(doc, stylesheets, styles);
 		},
@@ -185,7 +197,8 @@ function getInstance(utilOptions) {
 		SINGLE_FILE_UI_ELEMENT_CLASS: helper.SINGLE_FILE_UI_ELEMENT_CLASS,
 		EMPTY_RESOURCE: helper.EMPTY_RESOURCE,
 		INFOBAR_TAGNAME: helper.INFOBAR_TAGNAME,
-		WAIT_FOR_USERSCRIPT_PROPERTY_NAME: helper.WAIT_FOR_USERSCRIPT_PROPERTY_NAME
+		WAIT_FOR_USERSCRIPT_PROPERTY_NAME: helper.WAIT_FOR_USERSCRIPT_PROPERTY_NAME,
+		NO_SCRIPT_PROPERTY_NAME: helper.NO_SCRIPT_PROPERTY_NAME
 	};
 
 	async function getContent(resourceURL, options) {
@@ -241,7 +254,7 @@ function getInstance(utilOptions) {
 		try {
 			buffer = await response.arrayBuffer();
 		} catch (error) {
-			return { data: options.asBinary ? helper.EMPTY_RESOURCE : "", resourceURL };
+			return options.inline ? { data: options.asBinary ? helper.EMPTY_RESOURCE : "", resourceURL } : { resourceURL };
 		}
 		resourceURL = response.url || resourceURL;
 		let contentType = "", charset;
@@ -300,12 +313,16 @@ function getInstance(utilOptions) {
 async function getFetchResponse(resourceURL, options, data, charset, contentType) {
 	if (data) {
 		if (options.asBinary) {
-			const reader = new FileReader();
-			reader.readAsDataURL(new Blob([data], { type: contentType + (options.charset ? ";charset=" + options.charset : "") }));
-			data = await new Promise((resolve, reject) => {
-				reader.addEventListener("load", () => resolve(reader.result), false);
-				reader.addEventListener("error", reject, false);
-			});
+			if (options.inline)	{
+				const reader = new FileReader();
+				reader.readAsDataURL(new Blob([data], { type: contentType + (options.charset ? ";charset=" + options.charset : "") }));
+				data = await new Promise((resolve, reject) => {
+					reader.addEventListener("load", () => resolve(reader.result), false);
+					reader.addEventListener("error", reject, false);
+				});
+			} else {
+				data = new Uint8Array(data);
+			}
 		} else {
 			const firstBytes = new Uint8Array(data.slice(0, 4));
 			if (firstBytes[0] == 132 && firstBytes[1] == 49 && firstBytes[2] == 149 && firstBytes[3] == 51) {
@@ -323,10 +340,10 @@ async function getFetchResponse(resourceURL, options, data, charset, contentType
 			}
 			data = data.replace(/\ufeff/gi, "");
 		}
-	} else {
+	} else if (options.inline) {
 		data = options.asBinary ? helper.EMPTY_RESOURCE : "";
 	}
-	return { data, resourceURL, charset };
+	return { data, resourceURL, charset, contentType };
 }
 
 function guessMIMEType(expectedType, buffer) {
@@ -404,6 +421,24 @@ function hex(buffer) {
 	return hexCodes.join("");
 }
 
+function getDoctypeString(doc) {
+	const docType = doc.doctype;
+	let docTypeString = "";
+	if (docType) {
+		docTypeString = "<!DOCTYPE " + docType.nodeName;
+		if (docType.publicId) {
+			docTypeString += " PUBLIC \"" + docType.publicId + "\"";
+			if (docType.systemId)
+				docTypeString += " \"" + docType.systemId + "\"";
+		} else if (docType.systemId)
+			docTypeString += " SYSTEM \"" + docType.systemId + "\"";
+		if (docType.internalSubset)
+			docTypeString += " [" + docType.internalSubset + "]";
+		docTypeString += "> ";
+	}
+	return docTypeString;
+}
+
 function log(...args) {
 	console.log("S-File <browser>", ...args); // eslint-disable-line no-console
 }

package/modules/css-fonts-minifier.js

@@ -218,27 +218,13 @@ function getFontFamilyNames(declarations) {
 	let fontFamilyName = declarations.children.filter(node => node.property == "font-family").tail;
 	let fontFamilyNames = [];
 	if (fontFamilyName) {
-		let familyName = "";
 		if (fontFamilyName.data.value.children) {
-			let previousType;
-			fontFamilyName.data.value.children.forEach(node => {
-				if (node.type == "Operator" && node.value == "," && familyName) {
-					fontFamilyNames.push(helper.normalizeFontFamily(familyName));
-					familyName = "";
-					previousType = null;
-				} else {
-					if (previousType == "Identifier" && node.type == "Identifier") {
-						familyName += " ";
-					}
-					familyName += cssTree.generate(node);
-				}
-				previousType = node.type;
-			});
+			parseFamilyNames(fontFamilyName.data.value, fontFamilyNames);
 		} else {
 			fontFamilyName = cssTree.generate(fontFamilyName.data.value);
-		}
-		if (familyName) {
-			fontFamilyNames.push(helper.normalizeFontFamily(familyName));
+			if (fontFamilyName) {
+				fontFamilyNames.push(helper.normalizeFontFamily(fontFamilyName));
+			}
 		}
 	}
 	const font = declarations.children.filter(node => node.property == "font").tail;
@@ -253,6 +239,43 @@ function getFontFamilyNames(declarations) {
 	return fontFamilyNames;
 }
 
+function parseFamilyNames(fontFamilyNameTokenData, fontFamilyNames) {
+	let nextToken = fontFamilyNameTokenData.children.head;
+	while (nextToken) {
+		if (nextToken.data.type == "Identifier") {
+			let familyName = nextToken.data.name;
+			let nextIdentifierToken = nextToken.next;
+			while (nextIdentifierToken && nextIdentifierToken.data.type != "Operator" && nextIdentifierToken.data.value != ",") {
+				familyName += " " + nextIdentifierToken.data.name;
+				nextIdentifierToken = nextIdentifierToken.next;
+			}
+			fontFamilyNames.push(helper.normalizeFontFamily(familyName));
+			nextToken = nextToken.next;
+		} else if (nextToken.data.type == "Function" && nextToken.data.name == "var" && nextToken.data.children) {
+			const varName = nextToken.data.children.head.data.name;
+			fontFamilyNames.push(helper.normalizeFontFamily("var(" + varName + ")"));
+			let nextValueToken = nextToken.data.children.head.next;
+			while (nextValueToken && nextValueToken.data.type == "Operator" && nextValueToken.data.value == ",") {
+				nextValueToken = nextValueToken.next;
+			}
+			const fallbackToken = nextValueToken;
+			if (fallbackToken) {
+				if (fallbackToken.data.children) {
+					parseFamilyNames(fallbackToken.data, fontFamilyNames);
+				} else {
+					fontFamilyNames.push(helper.normalizeFontFamily(fallbackToken.data.value));
+				}
+			}
+			nextToken = nextToken.next;
+		} else if (nextToken.data.type == "String") {
+			fontFamilyNames.push(helper.normalizeFontFamily(nextToken.data.value));
+			nextToken = nextToken.next;
+		} else if (nextToken.data.type == "Operator" && nextToken.data.value == ",") {
+			nextToken = nextToken.next;
+		}
+	}
+}
+
 function getUsedFontWeight(fontInfo, fontStyle, fontWeights) {
 	let foundWeight;
 	fontWeights = fontWeights.map(weight => String(Number.parseInt(weight, 10)));

package/modules/index.js

@@ -21,7 +21,6 @@
  *   Source.
  */
 
-import * as fontsAltMinifier from "./css-fonts-alt-minifier.js";
 import * as fontsMinifier from "./css-fonts-minifier.js";
 import * as matchedRules from "./css-matched-rules.js";
 import * as mediasAltMinifier from "./css-medias-alt-minifier.js";
@@ -32,7 +31,6 @@ import * as serializer from "./html-serializer.js";
 import * as templateFormatter from "./template-formatter.js";
 
 export {
-	fontsAltMinifier,
 	fontsMinifier,
 	matchedRules,
 	mediasAltMinifier,

package/package.json

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

package/processors/compression/compression-display.js

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2010-2022 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.
+ */
+
+/* global DOMParser */
+
+export {
+	display
+};
+
+async function display(document, docContent, { disableFramePointerEvents } = {}) {
+	const DISABLED_NOSCRIPT_ATTRIBUTE_NAME = "data-single-filez-disabled-noscript";
+	const doc = (new DOMParser()).parseFromString(docContent, "text/html");
+	doc.querySelectorAll("noscript:not([" + DISABLED_NOSCRIPT_ATTRIBUTE_NAME + "])").forEach(element => {
+		element.setAttribute(DISABLED_NOSCRIPT_ATTRIBUTE_NAME, element.innerHTML);
+		element.textContent = "";
+	});
+	if (doc.doctype) {
+		if (document.doctype) {
+			document.replaceChild(doc.doctype, document.doctype);
+		} else {
+			document.insertBefore(doc.doctype, document.documentElement);
+		}
+	} else if (document.doctype) {
+		document.doctype.remove();
+	}
+	if (disableFramePointerEvents) {
+		doc.querySelectorAll("iframe").forEach(element => {
+			const pointerEvents = "pointer-events";
+			element.style.setProperty("-sf-" + pointerEvents, element.style.getPropertyValue(pointerEvents), element.style.getPropertyPriority(pointerEvents));
+			element.style.setProperty(pointerEvents, "none", "important");
+		});
+	}
+	document.replaceChild(document.importNode(doc.documentElement, true), document.documentElement);
+	document.documentElement.setAttribute("data-sfz", "");
+	document.querySelectorAll("link[rel*=icon]").forEach(element => element.parentElement.replaceChild(element, element));
+	document.open = document.write = document.close = () => { };
+	for (let element of Array.from(document.querySelectorAll("script"))) {
+		await new Promise((resolve, reject) => {
+			const scriptElement = document.createElement("script");
+			Array.from(element.attributes).forEach(attribute => scriptElement.setAttribute(attribute.name, attribute.value));
+			const async = element.getAttribute("async") == "" || element.getAttribute("async") == "async";
+			if (element.textContent) {
+				scriptElement.textContent = element.textContent;
+			} else if (!async) {
+				scriptElement.addEventListener("load", resolve);
+				scriptElement.addEventListener("error", reject);
+			}
+			element.parentElement.replaceChild(scriptElement, element);
+			if (element.textContent || async) {
+				resolve();
+			}
+		});
+	}
+}

package/processors/compression/compression-extract.js

@@ -0,0 +1,151 @@
+/*
+ * Copyright 2010-2022 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.
+ */
+
+/* global zip, Blob, FileReader, URL */
+
+export {
+	extract
+};
+
+async function extract(content, { password, prompt = () => { }, shadowRootScriptURL, zipOptions = { useWebWorkers: false }, noBlobURL } = {}) {
+	const KNOWN_MIMETYPES = {
+		"gif": "image/gif",
+		"jpg": "image/jpeg",
+		"png": "image/png",
+		"tif": "image/tiff",
+		"tiff": "image/tiff",
+		"bmp": "image/bmp",
+		"ico": "image/vnd.microsoft.icon",
+		"webp": "image/webp",
+		"svg": "image/svg+xml",
+		"avi": "video/x-msvideo",
+		"ogv": "video/ogg",
+		"mp4": "video/mp4",
+		"mpeg": "video/mpeg",
+		"ts": "video/mp2t",
+		"webm": "video/webm",
+		"3gp": "video/3gpp",
+		"3g2": "video/3gpp",
+		"mp3": "audio/mpeg",
+		"oga": "audio/ogg",
+		"mid": "audio/midi",
+		"midi": "audio/midi",
+		"opus": "audio/opus",
+		"wav": "audio/wav",
+		"weba": "audio/webm"
+	};
+	if (Array.isArray(content)) {
+		content = new Blob([new Uint8Array(content)]);
+	}
+	zip.configure(zipOptions);
+	const blobReader = new zip.BlobReader(content);
+	let resources = [];
+	const zipReader = new zip.ZipReader(blobReader);
+	const entries = await zipReader.getEntries();
+	const options = { password };
+	await Promise.all(entries.map(async entry => {
+		let dataWriter, content, textContent, name, blob;
+		if (!options.password && entry.encrypted) {
+			options.password = prompt("Please enter the password to view the page");
+		}
+		name = entry.filename.match(/^([0-9_]+\/)?(.*)$/)[2];
+		if (entry.filename.match(/index\.html$/) || entry.filename.match(/stylesheet_[0-9]+\.css/) || entry.filename.match(/scripts\/[0-9]+\.js/)) {
+			dataWriter = new zip.TextWriter();
+			textContent = await entry.getData(dataWriter, options);
+		} else {
+			const extension = entry.filename.match(/\.([^.]+)/);
+			let mimeType;
+			if (extension && extension[1] && KNOWN_MIMETYPES[extension[1]]) {
+				mimeType = KNOWN_MIMETYPES[extension[1]];
+			} else {
+				mimeType = "application/octet-stream";
+			}
+			if (entry.filename.match(/frames\//) || noBlobURL) {
+				content = await entry.getData(new zip.Data64URIWriter(mimeType), options);
+			} else {
+				blob = await entry.getData(new zip.BlobWriter(mimeType), options);
+				content = URL.createObjectURL(blob);
+			}
+		}
+		resources.push({ filename: entry.filename, name, url: entry.comment, content, blob, textContent, parentResources: [] });
+	}));
+	await zipReader.close();
+	let docContent, origDocContent, url;
+	resources = resources.sort((resourceLeft, resourceRight) => resourceRight.filename.length - resourceLeft.filename.length);
+	const REGEXP_ESCAPE = /([{}()^$&.*?/+|[\\\\]|\]|-)/g;
+	for (const resource of resources) {
+		if (resource.textContent !== undefined) {
+			let prefixPath = "";
+			const prefixPathMatch = resource.filename.match(/(.*\/)[^/]+$/);
+			if (prefixPathMatch && prefixPathMatch[1]) {
+				prefixPath = prefixPathMatch[1];
+			}
+			if (resource.filename.match(/^([0-9_]+\/)?index\.html$/)) {
+				origDocContent = resource.textContent;
+			}
+			const isScript = resource.filename.match(/scripts\/[0-9]+\.js/);
+			if (!isScript) {
+				resources.forEach(innerResource => {
+					if (innerResource.filename.startsWith(prefixPath) && innerResource.filename != resource.filename) {
+						const filename = innerResource.filename.substring(prefixPath.length);
+						if (!filename.match(/manifest\.json$/)) {
+							const searchRegExp = new RegExp(filename.replace(REGEXP_ESCAPE, "\\$1"), "g");
+							const position = resource.textContent.search(searchRegExp);
+							if (position != -1) {
+								innerResource.parentResources.push(resource.filename);
+								resource.textContent = resource.textContent.replace(searchRegExp, innerResource.content);
+							}
+						}
+					}
+				});
+			}
+			let mimeType;
+			if (resource.filename.match(/stylesheet_[0-9]+\.css/)) {
+				mimeType = "text/css";
+			} else if (isScript) {
+				mimeType = "text/javascript";
+			} else if (resource.filename.match(/index\.html$/)) {
+				mimeType = "text/html";
+				if (shadowRootScriptURL) {
+					resource.textContent = resource.textContent.replace(/<script data-template-shadow-root.*<\/script>/g, "<script data-template-shadow-root src=" + shadowRootScriptURL + "></" + "script>");
+				}
+			}
+			if (resource.filename.match(/^([0-9_]+\/)?index\.html$/)) {
+				docContent = resource.textContent;
+				url = resource.url;
+			} else {
+				const reader = new FileReader();
+				if (resource.textContent) {
+					reader.readAsDataURL(new Blob([resource.textContent], { type: mimeType + ";charset=utf-8" }));
+					resource.content = await new Promise((resolve, reject) => {
+						reader.addEventListener("load", () => resolve(reader.result), false);
+						reader.addEventListener("error", reject, false);
+					});
+				} else {
+					resource.content = "data:text/plain,";
+				}
+			}
+		}
+	}
+	return { docContent, origDocContent, resources, url };
+}