single-file-core 1.5.129 → 1.6.0

package/core/helper.js

@@ -82,6 +82,15 @@ const DEFAULT_REPLACEMENT_CHARACTER = "_";
 const DEFAULT_REPLACEMENT_CHARACTERS = ["～", "＋", "？", "％", "＊", "：", "｜", "＂", "＜", "＞", "＼"];
 const CHARACTER_CLASS_SPECIAL_CHARACTERS = ["[", "]", "^", "-", "\\"];
 const NESTING_TRACK_ID_ATTRIBUTE_NAME = "data-sf-nesting-track-id";
+const DEPRECATED_OPTION_NAMES = {
+	loadDeferredImages: "loadDeferredContent",
+	loadDeferredImagesMaxIdleTime: "loadDeferredContentMaxIdleTime",
+	loadDeferredImagesBlockCookies: "loadDeferredContentBlockCookies",
+	loadDeferredImagesBlockStorage: "loadDeferredContentBlockStorage",
+	loadDeferredImagesKeepZoomLevel: "loadDeferredContentKeepZoomLevel",
+	loadDeferredImagesDispatchScrollEvent: "loadDeferredContentDispatchScrollEvent",
+	loadDeferredImagesBeforeFrames: "loadDeferredContentBeforeFrames"
+};
 const addEventListener = (type, listener, options) => globalThis.addEventListener(type, listener, options);
 const removeEventListener = (type, listener, options) => globalThis.removeEventListener(type, listener, options);
 // eslint-disable-next-line no-unused-vars
@@ -117,6 +126,7 @@ export {
 	parseDocContent,
 	markInvalidNesting,
 	fixInvalidNesting,
+	normalizeOptions,
 	ON_BEFORE_CAPTURE_EVENT_NAME,
 	ON_AFTER_CAPTURE_EVENT_NAME,
 	WIN_ID_ATTRIBUTE_NAME,
@@ -153,6 +163,22 @@ export {
 // lossy format: the same frame costs an order of magnitude less than as a PNG.
 // toDataURL falls back to PNG without reporting it when it does not support the
 // format, so the type it returned is tested instead of assumed
+function normalizeOptions(options) {
+	let normalizedOptions = options;
+	if (options) {
+		Object.keys(DEPRECATED_OPTION_NAMES).forEach(deprecatedName => {
+			const optionName = DEPRECATED_OPTION_NAMES[deprecatedName];
+			if (options[deprecatedName] !== undefined && options[optionName] === undefined) {
+				if (normalizedOptions == options) {
+					normalizedOptions = Object.assign({}, options);
+				}
+				normalizedOptions[optionName] = options[deprecatedName];
+			}
+		});
+	}
+	return normalizedOptions;
+}
+
 function getPosterDataURI(canvasElement) {
 	for (const contentType of POSTER_CONTENT_TYPES) {
 		const dataURI = canvasElement.toDataURL(contentType, POSTER_QUALITY);
@@ -535,7 +561,7 @@ function getResourcesInfo(win, doc, element, options, data, elementHidden, compu
 		const imageData = {
 			currentSrc: elementHidden ?
 				EMPTY_RESOURCE :
-				(options.loadDeferredImages && element.getAttribute(LAZY_SRC_ATTRIBUTE_NAME)) || element.currentSrc
+				(options.loadDeferredContent && element.getAttribute(LAZY_SRC_ATTRIBUTE_NAME)) || element.currentSrc
 		};
 		data.images.push(imageData);
 		element.setAttribute(IMAGE_ATTRIBUTE_NAME, data.images.length - 1);

package/core/index.js

@@ -31,6 +31,7 @@ const DEBUG = false;
 const Set = globalThis.Set;
 const Map = globalThis.Map;
 const JSON = globalThis.JSON;
+const URL = globalThis.URL;
 
 let util;
 
@@ -102,7 +103,7 @@ const FINALIZE_STAGE = 4;
 const STAGES = [{
 	sequential: [
 		{ action: "preProcessPage" },
-		{ option: "loadDeferredImagesKeepZoomLevel", action: "resetZoomLevel" },
+		{ option: "loadDeferredContentKeepZoomLevel", action: "resetZoomLevel" },
 		{ action: "replaceStyleContents" },
 		{ action: "replaceInvalidElements" },
 		{ action: "resetCharsetMeta" },
@@ -160,7 +161,7 @@ const STAGES = [{
 		{ action: "cleanupPage" }
 	],
 	parallel: [
-		{ option: "enableMaff", action: "insertMAFFMetaData" },
+		{ option: "readMaffMetadata", action: "readMAFFMetaData" },
 		{ action: "setDocInfo" }
 	]
 }, {
@@ -421,6 +422,9 @@ const SHADOWROOT_DELEGATES_FOCUS = "shadowrootdelegatesfocus";
 const SHADOWROOT_CLONABLE = "shadowrootclonable";
 const SHADOWROOT_SERIALIZABLE = "shadowrootserializable";
 const SCRIPT_OPTIONS = "data-single-file-options";
+const JAVASCRIPT_URI_PROTOCOL = "javascript:";
+const DISABLED_SCRIPT_URI = "javascript:void(0)";
+const SCRIPT_URI_ATTRIBUTE_NAMES = ["href", "src", "action", "formaction", "data"];
 const UTF8_CHARSET = "utf-8";
 const TAINTED_CANVAS_WARNING_MESSAGE = "SingleFile: canvas elements tainted by a cross-origin resource, dropped from the page:";
 
@@ -448,7 +452,7 @@ class Processor {
 	initialize() {
 		this.options.saveDate = new Date();
 		this.options.saveUrl = this.options.url;
-		if (this.options.enableMaff) {
+		if (this.options.readMaffMetadata) {
 			this.maffMetaDataPromise = this.batchRequest.addURL(util.resolveURL("index.rdf", this.options.baseURI || this.options.url), { expectedType: "document" });
 		}
 		this.maxResources = this.batchRequest.getMaxResources();
@@ -497,7 +501,7 @@ class Processor {
 		}
 		this.workStyleElement = this.doc.createElement("style");
 		this.doc.body.appendChild(this.workStyleElement);
-		this.onEventAttributeNames = getOnEventAttributeNames(this.doc);
+		this.onEventAttributeNames = new Set(getOnEventAttributeNames(this.doc));
 	}
 
 	finalize() {
@@ -637,7 +641,7 @@ class Processor {
 								imgElement.dataset.singleFileOriginURL = imgElement.getAttribute("src");
 								imgElement.setAttribute("src", imageData.currentSrc);
 							}
-							if (this.options.loadDeferredImages) {
+							if (this.options.loadDeferredContent) {
 								if ((!imgElement.getAttribute("src") || imgElement.getAttribute("src") == util.EMPTY_RESOURCE) && imgElement.getAttribute("data-src")) {
 									imageData.src = imgElement.dataset.src;
 									imgElement.setAttribute("src", imgElement.dataset.src);
@@ -648,7 +652,7 @@ class Processor {
 					}
 				}
 			});
-			if (this.options.loadDeferredImages) {
+			if (this.options.loadDeferredContent) {
 				this.doc.querySelectorAll("img[data-srcset]").forEach(imgElement => {
 					if (!imgElement.getAttribute("srcset") && imgElement.getAttribute("data-srcset")) {
 						imgElement.setAttribute("srcset", imgElement.dataset.srcset);
@@ -676,7 +680,7 @@ class Processor {
 			optionsElement.type = "application/json";
 			optionsElement.setAttribute(SCRIPT_OPTIONS, "");
 			optionsElement.textContent = JSON.stringify({
-				saveUrl: this.options.url,
+				saveUrl: this.options.saveUrl,
 				saveDate: this.options.saveDate.getTime(),
 				visitDate: (this.options.visitDate || this.options.saveDate).getTime(),
 				filenameTemplate: this.options.filenameTemplate,
@@ -852,18 +856,16 @@ class Processor {
 	}
 
 	removeEmbedScripts() {
-		const JAVASCRIPT_URI_PREFIX = "javascript:";
-		const DISABLED_SCRIPT = "javascript:void(0)";
-		this.onEventAttributeNames.forEach(attributeName => this.doc.querySelectorAll("[" + attributeName + "]").forEach(element => element.removeAttribute(attributeName)));
-		this.doc.querySelectorAll("[href]").forEach(element => {
-			if (element.href && element.href.match && element.href.trim().startsWith(JAVASCRIPT_URI_PREFIX)) {
-				element.setAttribute("href", DISABLED_SCRIPT);
-			}
-		});
-		this.doc.querySelectorAll("[src]").forEach(element => {
-			if (element.src && element.src.trim().startsWith(JAVASCRIPT_URI_PREFIX)) {
-				element.setAttribute("src", DISABLED_SCRIPT);
-			}
+		this.doc.querySelectorAll("*").forEach(element => {
+			Array.from(element.attributes).forEach(attribute => {
+				const localName = attribute.localName || attribute.name;
+				const attributeName = localName.toLowerCase();
+				if (this.onEventAttributeNames.has(attributeName)) {
+					element.removeAttributeNS(attribute.namespaceURI, localName);
+				} else if (SCRIPT_URI_ATTRIBUTE_NAMES.includes(attributeName) && isScriptURI(attribute.value)) {
+					element.setAttributeNS(attribute.namespaceURI, attribute.name, DISABLED_SCRIPT_URI);
+				}
+			});
 		});
 		const scriptElements = this.doc.querySelectorAll("script:not([type=\"application/ld+json\"]):not([" + SCRIPT_OPTIONS + "])");
 		this.stats.set("discarded", "scripts", scriptElements.length);
@@ -1647,7 +1649,7 @@ class Processor {
 		this.doc.documentElement.style.removeProperty("-sf-min-height");
 	}
 
-	async insertMAFFMetaData() {
+	async readMAFFMetaData() {
 		const maffMetaData = await this.maffMetaDataPromise;
 		if (maffMetaData && maffMetaData.content) {
 			const NAMESPACE_RDF = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
@@ -1655,7 +1657,10 @@ class Processor {
 			const originalURLElement = maffDoc.querySelector("RDF > Description > originalurl");
 			const archiveTimeElement = maffDoc.querySelector("RDF > Description > archivetime");
 			if (originalURLElement) {
-				this.options.saveUrl = originalURLElement.getAttributeNS(NAMESPACE_RDF, "resource");
+				const value = originalURLElement.getAttributeNS(NAMESPACE_RDF, "resource");
+				if (value) {
+					this.options.saveUrl = value;
+				}
 			}
 			if (archiveTimeElement) {
 				const value = archiveTimeElement.getAttributeNS(NAMESPACE_RDF, "resource");
@@ -1709,6 +1714,14 @@ function normalizeURL(url) {
 	}
 }
 
+function isScriptURI(value) {
+	try {
+		return new URL(value).protocol == JAVASCRIPT_URI_PROTOCOL;
+	} catch {
+		return false;
+	}
+}
+
 function getOnEventAttributeNames(doc) {
 	const element = doc.body || doc.createElement("div");
 	const attributeNames = [];

package/core/infobar.js

@@ -141,28 +141,28 @@ const INFOBAR_STYLES = `
 
 @keyframes flash {
   0%, 100% {
-	background-color: #737373;
+    background-color: #737373;
   }
   50% {
-	background-color: #dd6a00;
+    background-color: #dd6a00;
   }
 }
 
 @keyframes ripple {
   0% {
-	transform: scale(1);
-	opacity: 1;
+    transform: scale(1);
+    opacity: 1;
   }
   45%, 100% {
-	transform: scale(2);
-	opacity: 0;
+    transform: scale(2);
+    opacity: 0;
   }
 }
 
 @media (prefers-reduced-motion: reduce) {
   .infobar,
   .infobar:not(:focus-within):not(.infobar-focus)::after {
-	animation-name: none;
+    animation-name: none;
   }
 }
 

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

@@ -562,7 +562,7 @@ function getProcessorHelperClass(utilInstance) {
 		}
 
 		setMetaCSP(metaElement) {
-			metaElement.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:;";
+			metaElement.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:; form-action 'none'; base-uri 'none';";
 		}
 
 		removeUnusedStylesheets(doc) {

package/core/lib/processor-helper.js

@@ -488,7 +488,7 @@ function getProcessorHelperClass(utilInstance) {
 		}
 
 		setMetaCSP(metaElement) {
-			metaElement.content = "default-src 'none'; connect-src 'self' data: blob:; font-src 'self' data: blob:; img-src 'self' data: blob:; style-src 'self' 'unsafe-inline' data: blob:; frame-src 'self' data: blob:; media-src 'self' data: blob:; script-src 'self' 'unsafe-inline' data: blob:; object-src 'self' data: blob:;";
+			metaElement.content = "default-src 'none'; connect-src 'self' data: blob:; font-src 'self' data: blob:; img-src 'self' data: blob:; style-src 'self' 'unsafe-inline' data: blob:; frame-src 'self' data: blob:; media-src 'self' data: blob:; script-src 'self' 'unsafe-inline' data: blob:; object-src 'self' data: blob:; form-action 'none'; base-uri 'none';";
 		}
 
 		removeUnusedStylesheets() {

package/package.json

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

package/processors/compression/compression.js

@@ -132,7 +132,8 @@ export {
 	process,
 	createArchive,
 	escapeHTML,
-	PROCESS_OPTION_NAMES
+	PROCESS_OPTION_NAMES,
+	DEFAULT_MAX_APPENDED_DATA_LENGTH
 };
 
 async function process(pageData, options, lastModDate = new Date()) {

package/processors/frame-tree/content/content-frame-tree.js

@@ -114,7 +114,7 @@ async function onMessage(event) {
 			}
 			if (!TOP_WINDOW) {
 				globalThis.stop();
-				if (message.options.loadDeferredImages) {
+				if (message.options.loadDeferredContent) {
 					lazy.process(message.options);
 				}
 				await initRequestAsync(message);

package/processors/hooks/content/content-hooks-frames-web.js

@@ -23,12 +23,12 @@
 
 (() => {
 
-	const LOAD_DEFERRED_IMAGES_START_EVENT = "single-file-load-deferred-images-start";
-	const LOAD_DEFERRED_IMAGES_END_EVENT = "single-file-load-deferred-images-end";
-	const LOAD_DEFERRED_IMAGES_KEEP_ZOOM_LEVEL_START_EVENT = "single-file-load-deferred-images-keep-zoom-level-start";
-	const LOAD_DEFERRED_IMAGES_KEEP_ZOOM_LEVEL_END_EVENT = "single-file-load-deferred-images-keep-zoom-level-end";
-	const LOAD_DEFERRED_IMAGES_RESET_ZOOM_LEVEL_EVENT = "single-file-load-deferred-images-keep-zoom-level-reset";
-	const LOAD_DEFERRED_IMAGES_RESET_EVENT = "single-file-load-deferred-images-reset";
+	const LOAD_DEFERRED_CONTENT_START_EVENT = "single-file-load-deferred-content-start";
+	const LOAD_DEFERRED_CONTENT_END_EVENT = "single-file-load-deferred-content-end";
+	const LOAD_DEFERRED_CONTENT_KEEP_ZOOM_LEVEL_START_EVENT = "single-file-load-deferred-content-keep-zoom-level-start";
+	const LOAD_DEFERRED_CONTENT_KEEP_ZOOM_LEVEL_END_EVENT = "single-file-load-deferred-content-keep-zoom-level-end";
+	const LOAD_DEFERRED_CONTENT_RESET_ZOOM_LEVEL_EVENT = "single-file-load-deferred-content-keep-zoom-level-reset";
+	const LOAD_DEFERRED_CONTENT_RESET_EVENT = "single-file-load-deferred-content-reset";
 	const BLOCK_COOKIES_START_EVENT = "single-file-block-cookies-start";
 	const BLOCK_COOKIES_END_EVENT = "single-file-block-cookies-end";
 	const BLOCK_STORAGE_START_EVENT = "single-file-block-storage-start";
@@ -89,12 +89,12 @@
 	new MutationObserver(init).observe(document, { childList: true });
 
 	function init() {
-		document.addEventListener(LOAD_DEFERRED_IMAGES_START_EVENT, onLoadDeferredImagesStart);
-		document.addEventListener(LOAD_DEFERRED_IMAGES_KEEP_ZOOM_LEVEL_START_EVENT, onLoadDeferredImagesKeepZoomLevelStart);
-		document.addEventListener(LOAD_DEFERRED_IMAGES_END_EVENT, onLoadDeferredImagesEnd);
-		document.addEventListener(LOAD_DEFERRED_IMAGES_KEEP_ZOOM_LEVEL_END_EVENT, onLoadDeferredImagesKeepZoomLevelEnd);
-		document.addEventListener(LOAD_DEFERRED_IMAGES_RESET_EVENT, resetScreenSize);
-		document.addEventListener(LOAD_DEFERRED_IMAGES_RESET_ZOOM_LEVEL_EVENT, onLoadDeferredImagesResetZoomLevel);
+		document.addEventListener(LOAD_DEFERRED_CONTENT_START_EVENT, onLoadDeferredContentStart);
+		document.addEventListener(LOAD_DEFERRED_CONTENT_KEEP_ZOOM_LEVEL_START_EVENT, onLoadDeferredContentKeepZoomLevelStart);
+		document.addEventListener(LOAD_DEFERRED_CONTENT_END_EVENT, onLoadDeferredContentEnd);
+		document.addEventListener(LOAD_DEFERRED_CONTENT_KEEP_ZOOM_LEVEL_END_EVENT, onLoadDeferredContentKeepZoomLevelEnd);
+		document.addEventListener(LOAD_DEFERRED_CONTENT_RESET_EVENT, resetScreenSize);
+		document.addEventListener(LOAD_DEFERRED_CONTENT_RESET_ZOOM_LEVEL_EVENT, onLoadDeferredContentResetZoomLevel);
 		document.addEventListener(DISPATCH_SCROLL_START_EVENT, onDispatchScrollStart);
 		document.addEventListener(DISPATCH_SCROLL_END_EVENT, onDispatchScrollEnd);
 		document.addEventListener(BLOCK_COOKIES_START_EVENT, onBlockCookiesStart);
@@ -107,23 +107,33 @@
 		document.addEventListener(BOOTSTRAP_EVENT, onBootstrap);
 	}
 
-	function onLoadDeferredImagesStart() {
-		loadDeferredImagesStart();
+	function onLoadDeferredContentStart(event) {
+		loadDeferredContentStart(false, getMinZoomFactor(event));
 	}
 
-	function onLoadDeferredImagesKeepZoomLevelStart() {
-		loadDeferredImagesStart(true);
+	function onLoadDeferredContentKeepZoomLevelStart(event) {
+		loadDeferredContentStart(true, getMinZoomFactor(event));
 	}
 
-	function onLoadDeferredImagesEnd() {
-		loadDeferredImagesEnd();
+	function getMinZoomFactor(event) {
+		try {
+			const { minZoomFactor } = JSON.parse(event.detail);
+			return minZoomFactor > 0 && minZoomFactor <= 1 ? minZoomFactor : 0;
+			// eslint-disable-next-line no-unused-vars
+		} catch (error) {
+			return 0;
+		}
+	}
+
+	function onLoadDeferredContentEnd() {
+		loadDeferredContentEnd();
 	}
 
-	function onLoadDeferredImagesKeepZoomLevelEnd() {
-		loadDeferredImagesEnd(true);
+	function onLoadDeferredContentKeepZoomLevelEnd() {
+		loadDeferredContentEnd(true);
 	}
 
-	function onLoadDeferredImagesResetZoomLevel() {
+	function onLoadDeferredContentResetZoomLevel() {
 		const transform = document.documentElement.style.getPropertyValue("-sf-transform");
 		const transformPriority = document.documentElement.style.getPropertyPriority("-sf-transform");
 		const transformOrigin = document.documentElement.style.getPropertyValue("-sf-transform-origin");
@@ -211,34 +221,34 @@
 		}
 	}
 
-	function loadDeferredImagesStart(keepZoomLevel) {
+	function loadDeferredContentStart(keepZoomLevel, minZoomFactor) {
 		const scrollingElement = document.scrollingElement || document.documentElement;
 		const clientHeight = scrollingElement.clientHeight;
 		const clientWidth = scrollingElement.clientWidth;
-		const scrollHeight = Math.max(scrollingElement.scrollHeight - clientHeight, clientHeight);
-		const scrollWidth = Math.max(scrollingElement.scrollWidth - clientWidth, clientWidth);
+		const maxScrollY = Math.max(scrollingElement.scrollHeight - clientHeight, clientHeight);
+		const maxScrollX = Math.max(scrollingElement.scrollWidth - clientWidth, clientWidth);
 		document.querySelectorAll("[loading=lazy]").forEach(element => {
 			element.loading = "eager";
 			element.setAttribute(LAZY_LOAD_ATTRIBUTE, "");
 		});
-		scrollingElement.__defineGetter__("clientHeight", () => scrollHeight);
-		scrollingElement.__defineGetter__("clientWidth", () => scrollWidth);
-		screen.__defineGetter__("height", () => scrollHeight);
-		screen.__defineGetter__("width", () => scrollWidth);
+		scrollingElement.__defineGetter__("clientHeight", () => maxScrollY);
+		scrollingElement.__defineGetter__("clientWidth", () => maxScrollX);
+		screen.__defineGetter__("height", () => maxScrollY);
+		screen.__defineGetter__("width", () => maxScrollX);
 		globalThis._singleFile_innerHeight = globalThis.innerHeight;
 		globalThis._singleFile_innerWidth = globalThis.innerWidth;
-		globalThis.__defineGetter__("innerHeight", () => scrollHeight);
-		globalThis.__defineGetter__("innerWidth", () => scrollWidth);
+		globalThis.__defineGetter__("innerHeight", () => maxScrollY);
+		globalThis.__defineGetter__("innerWidth", () => maxScrollX);
 		if (!keepZoomLevel) {
 			if (!globalThis._singleFile_getBoundingClientRect) {
 				globalThis._singleFile_getBoundingClientRect = Element.prototype.getBoundingClientRect;
 				Element.prototype.getBoundingClientRect = function () {
 					const boundingRect = globalThis._singleFile_getBoundingClientRect.call(this);
 					if (this == scrollingElement) {
-						boundingRect.__defineGetter__("height", () => scrollHeight);
-						boundingRect.__defineGetter__("bottom", () => scrollHeight + boundingRect.top);
-						boundingRect.__defineGetter__("width", () => scrollWidth);
-						boundingRect.__defineGetter__("right", () => scrollWidth + boundingRect.left);
+						boundingRect.__defineGetter__("height", () => maxScrollY);
+						boundingRect.__defineGetter__("bottom", () => maxScrollY + boundingRect.top);
+						boundingRect.__defineGetter__("width", () => maxScrollX);
+						boundingRect.__defineGetter__("right", () => maxScrollX + boundingRect.left);
 					}
 					return boundingRect;
 				};
@@ -283,9 +293,9 @@
 			setFunctionName(ImageWrapper, "Image");
 			globalThis.__defineGetter__("Image", () => ImageWrapper);
 		}
-		const verticalZoomFactor = clientHeight / scrollHeight;
-		const horizontalZoomFactor = clientWidth / scrollWidth;
-		const zoomFactor = Math.min(verticalZoomFactor, horizontalZoomFactor);
+		const verticalZoomFactor = clientHeight / maxScrollY;
+		const horizontalZoomFactor = clientWidth / maxScrollX;
+		const zoomFactor = Math.max(Math.min(verticalZoomFactor, horizontalZoomFactor), minZoomFactor || 0);
 		const scrollPosition = { x: globalThis.scrollX, y: globalThis.scrollY };
 		if (zoomFactor < 1) {
 			const transform = document.documentElement.style.getPropertyValue("transform");
@@ -336,7 +346,7 @@
 		}
 	}
 
-	function loadDeferredImagesEnd(keepZoomLevel) {
+	function loadDeferredContentEnd(keepZoomLevel) {
 		document.querySelectorAll("[" + LAZY_LOAD_ATTRIBUTE + "]").forEach(element => {
 			element.loading = "lazy";
 			element.removeAttribute(LAZY_LOAD_ATTRIBUTE);

package/processors/hooks/content/content-hooks-frames.js

@@ -21,12 +21,12 @@
  *   Source.
  */
 
-const LOAD_DEFERRED_IMAGES_START_EVENT = "single-file-load-deferred-images-start";
-const LOAD_DEFERRED_IMAGES_END_EVENT = "single-file-load-deferred-images-end";
-const LOAD_DEFERRED_IMAGES_KEEP_ZOOM_LEVEL_START_EVENT = "single-file-load-deferred-images-keep-zoom-level-start";
-const LOAD_DEFERRED_IMAGES_KEEP_ZOOM_LEVEL_END_EVENT = "single-file-load-deferred-images-keep-zoom-level-end";
-const LOAD_DEFERRED_IMAGES_RESET_ZOOM_LEVEL_EVENT = "single-file-load-deferred-images-keep-zoom-level-reset";
-const LOAD_DEFERRED_IMAGES_RESET_EVENT = "single-file-load-deferred-images-reset";
+const LOAD_DEFERRED_CONTENT_START_EVENT = "single-file-load-deferred-content-start";
+const LOAD_DEFERRED_CONTENT_END_EVENT = "single-file-load-deferred-content-end";
+const LOAD_DEFERRED_CONTENT_KEEP_ZOOM_LEVEL_START_EVENT = "single-file-load-deferred-content-keep-zoom-level-start";
+const LOAD_DEFERRED_CONTENT_KEEP_ZOOM_LEVEL_END_EVENT = "single-file-load-deferred-content-keep-zoom-level-end";
+const LOAD_DEFERRED_CONTENT_RESET_ZOOM_LEVEL_EVENT = "single-file-load-deferred-content-keep-zoom-level-reset";
+const LOAD_DEFERRED_CONTENT_RESET_EVENT = "single-file-load-deferred-content-reset";
 const BLOCK_COOKIES_START_EVENT = "single-file-block-cookies-start";
 const BLOCK_COOKIES_END_EVENT = "single-file-block-cookies-end";
 const DISPATCH_SCROLL_START_EVENT = "single-file-dispatch-scroll-event-start";
@@ -98,9 +98,9 @@ function onNewWorklet(event) {
 export {
 	getFontsData,
 	getWorkletsData,
-	loadDeferredImagesStart,
-	loadDeferredImagesEnd,
-	loadDeferredImagesResetZoomLevel,
+	loadDeferredContentStart,
+	loadDeferredContentEnd,
+	loadDeferredContentResetZoomLevel,
 	LOAD_IMAGE_EVENT,
 	IMAGE_LOADED_EVENT
 };
@@ -113,44 +113,45 @@ function getWorkletsData() {
 	return Array.from(worklets.values());
 }
 
-function loadDeferredImagesStart(options) {
-	if (options.loadDeferredImagesBlockCookies) {
+function loadDeferredContentStart(options) {
+	if (options.loadDeferredContentBlockCookies) {
 		document.dispatchEvent(new CustomEvent(BLOCK_COOKIES_START_EVENT));
 	}
-	if (options.loadDeferredImagesBlockStorage) {
+	if (options.loadDeferredContentBlockStorage) {
 		document.dispatchEvent(new CustomEvent(BLOCK_STORAGE_START_EVENT));
 	}
-	if (options.loadDeferredImagesDispatchScrollEvent) {
+	if (options.loadDeferredContentDispatchScrollEvent) {
 		document.dispatchEvent(new CustomEvent(DISPATCH_SCROLL_START_EVENT));
 	}
-	if (options.loadDeferredImagesKeepZoomLevel) {
-		document.dispatchEvent(new CustomEvent(LOAD_DEFERRED_IMAGES_KEEP_ZOOM_LEVEL_START_EVENT));
+	const detail = JSON.stringify({ minZoomFactor: options.loadDeferredContentMinZoomFactor });
+	if (options.loadDeferredContentKeepZoomLevel) {
+		document.dispatchEvent(new CustomEvent(LOAD_DEFERRED_CONTENT_KEEP_ZOOM_LEVEL_START_EVENT, { detail }));
 	} else {
-		document.dispatchEvent(new CustomEvent(LOAD_DEFERRED_IMAGES_START_EVENT));
+		document.dispatchEvent(new CustomEvent(LOAD_DEFERRED_CONTENT_START_EVENT, { detail }));
 	}
 }
 
-function loadDeferredImagesEnd(options) {
-	if (options.loadDeferredImagesBlockCookies) {
+function loadDeferredContentEnd(options) {
+	if (options.loadDeferredContentBlockCookies) {
 		document.dispatchEvent(new CustomEvent(BLOCK_COOKIES_END_EVENT));
 	}
-	if (options.loadDeferredImagesBlockStorage) {
+	if (options.loadDeferredContentBlockStorage) {
 		document.dispatchEvent(new CustomEvent(BLOCK_STORAGE_END_EVENT));
 	}
-	if (options.loadDeferredImagesDispatchScrollEvent) {
+	if (options.loadDeferredContentDispatchScrollEvent) {
 		document.dispatchEvent(new CustomEvent(DISPATCH_SCROLL_END_EVENT));
 	}
-	if (options.loadDeferredImagesKeepZoomLevel) {
-		document.dispatchEvent(new CustomEvent(LOAD_DEFERRED_IMAGES_KEEP_ZOOM_LEVEL_END_EVENT));
+	if (options.loadDeferredContentKeepZoomLevel) {
+		document.dispatchEvent(new CustomEvent(LOAD_DEFERRED_CONTENT_KEEP_ZOOM_LEVEL_END_EVENT));
 	} else {
-		document.dispatchEvent(new CustomEvent(LOAD_DEFERRED_IMAGES_END_EVENT));
+		document.dispatchEvent(new CustomEvent(LOAD_DEFERRED_CONTENT_END_EVENT));
 	}
 }
 
-function loadDeferredImagesResetZoomLevel(options) {
-	if (options.loadDeferredImagesKeepZoomLevel) {
-		document.dispatchEvent(new CustomEvent(LOAD_DEFERRED_IMAGES_RESET_ZOOM_LEVEL_EVENT));
+function loadDeferredContentResetZoomLevel(options) {
+	if (options.loadDeferredContentKeepZoomLevel) {
+		document.dispatchEvent(new CustomEvent(LOAD_DEFERRED_CONTENT_RESET_ZOOM_LEVEL_EVENT));
 	} else {
-		document.dispatchEvent(new CustomEvent(LOAD_DEFERRED_IMAGES_RESET_EVENT));
+		document.dispatchEvent(new CustomEvent(LOAD_DEFERRED_CONTENT_RESET_EVENT));
 	}
 }

package/processors/lazy/content/content-lazy-loader.js

@@ -81,7 +81,7 @@ async function process(options) {
 }
 
 function resetZoomLevel(options) {
-	hooksFrames.loadDeferredImagesResetZoomLevel(options);
+	hooksFrames.loadDeferredContentResetZoomLevel(options);
 }
 
 function triggerLazyLoading(options) {
@@ -112,12 +112,12 @@ function triggerLazyLoading(options) {
 				}
 			}
 		});
-		await setIdleTimeout(options.loadDeferredImagesMaxIdleTime * 2);
+		await setIdleTimeout(options.loadDeferredContentMaxIdleTime * 2);
 		await deferForceLazyLoadEnd(observer, options, cleanupAndResolve);
 		observer.observe(document, { subtree: true, childList: true, attributes: true });
 		document.addEventListener(hooksFrames.LOAD_IMAGE_EVENT, onImageLoadEvent);
 		document.addEventListener(hooksFrames.IMAGE_LOADED_EVENT, onImageLoadedEvent);
-		hooksFrames.loadDeferredImagesStart(options);
+		hooksFrames.loadDeferredContentStart(options);
 
 		async function setIdleTimeout(delay) {
 			await setAsyncTimeout("idleTimeout", async () => {
@@ -130,7 +130,7 @@ function triggerLazyLoading(options) {
 					clearAsyncTimeout("idleTimeout");
 					await setIdleTimeout(Math.max(500, delay / 2));
 				}
-			}, delay, options.loadDeferredImagesNativeTimeout);
+			}, delay);
 		}
 
 		function onResourceLoad(event) {
@@ -167,28 +167,28 @@ function triggerLazyLoading(options) {
 }
 
 async function deferLazyLoadEnd(observer, options, resolve) {
-	await setAsyncTimeout("loadTimeout", () => lazyLoadEnd(observer, options, resolve), options.loadDeferredImagesMaxIdleTime, options.loadDeferredImagesNativeTimeout);
+	await setAsyncTimeout("loadTimeout", () => lazyLoadEnd(observer, options, resolve), options.loadDeferredContentMaxIdleTime);
 }
 
 async function deferForceLazyLoadEnd(observer, options, resolve) {
 	await setAsyncTimeout("maxTimeout", async () => {
 		await clearAsyncTimeout("loadTimeout");
 		await lazyLoadEnd(observer, options, resolve);
-	}, options.loadDeferredImagesMaxIdleTime * 10, options.loadDeferredImagesNativeTimeout);
+	}, options.loadDeferredContentMaxIdleTime * 10);
 }
 
 async function lazyLoadEnd(observer, options, resolve) {
 	await clearAsyncTimeout("idleTimeout");
-	hooksFrames.loadDeferredImagesEnd(options);
+	hooksFrames.loadDeferredContentEnd(options);
 	await setAsyncTimeout("endTimeout", async () => {
 		await clearAsyncTimeout("maxTimeout");
 		resolve();
-	}, options.loadDeferredImagesMaxIdleTime / 2, options.loadDeferredImagesNativeTimeout);
+	}, options.loadDeferredContentMaxIdleTime / 2);
 	observer.disconnect();
 }
 
-async function setAsyncTimeout(type, callback, delay, forceNativeTimeout) {
-	if (browser && browser.runtime && browser.runtime.sendMessage && !forceNativeTimeout) {
+async function setAsyncTimeout(type, callback, delay) {
+	if (browser && browser.runtime && browser.runtime.sendMessage) {
 		if (!timeouts.get(type) || !timeouts.get(type).pending) {
 			const timeoutData = { callback, pending: true };
 			timeouts.set(type, timeoutData);