single-file-core 1.5.123 → 1.5.125

package/core/helper.js

@@ -293,6 +293,9 @@ function preProcessDoc(doc, win, options) {
 }
 
 function markInvalidNesting(doc) {
+	if (!doc.body) {
+		return;
+	}
 	addTrackIds(doc.body);
 	const verificationDoc = parseDocContent(serialize(doc));
 	const markedMap = buildTrackIdMap(doc.body);

package/core/lib/doctype.js

@@ -38,9 +38,6 @@ function getDoctypeString(doc) {
 		} else if (docType.systemId) {
 			docTypeString += " SYSTEM \"" + docType.systemId + "\"";
 		}
-		if (docType.internalSubset) {
-			docTypeString += " [" + docType.internalSubset + "]";
-		}
 		docTypeString += ">";
 	}
 	return docTypeString;

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

@@ -405,7 +405,7 @@ class ProcessorHelperCommon {
 			}
 			sheetIndex++;
 		});
-		processFontDetails(fontsDetails);
+		processFontDetails(fontsDetails, fonts);
 		await Promise.all([...stylesheets].map(async ([, stylesheetInfo], sheetIndex) => {
 			if (stylesheetInfo.stylesheet) {
 				const cssRules = stylesheetInfo.stylesheet.children;
@@ -449,7 +449,10 @@ class ProcessorHelperCommon {
 						removedRules.push(cssRule);
 					} else {
 						fontsDetails.emittedFonts.add(ruleKey);
-						await this.processFontFaceRule(ruleData, fontInfo, fonts, fontTests, stats);
+						const keptRule = await this.processFontFaceRule(ruleData, fontInfo, fonts, fontTests, stats);
+						if (!keptRule) {
+							removedRules.push(cssRule);
+						}
 					}
 				} else {
 					removedRules.push(cssRule);

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

@@ -648,6 +648,9 @@ function getProcessorHelperClass(utilInstance) {
 					}
 				}
 				stats.fonts.discarded -= fontInfo.length;
+				if (!fontInfo.length) {
+					return false;
+				}
 				fontInfo.reverse();
 				try {
 					srcDeclaration.data.value = cssTree.parse(fontInfo.map(fontSource => fontSource.src).join(","), { context: "value", parseCustomProperty: true });
@@ -656,6 +659,7 @@ function getProcessorHelperClass(utilInstance) {
 					// ignored
 				}
 			}
+			return true;
 		}
 	};
 }

package/core/lib/processor-helper.js

@@ -574,6 +574,9 @@ function getProcessorHelperClass(utilInstance) {
 			removedNodes.forEach(node => ruleData.block.children.remove(node));
 			const srcDeclaration = ruleData.block.children.filter(node => node.property == "src").tail;
 			if (srcDeclaration) {
+				if (!fontInfo.length) {
+					return false;
+				}
 				fontInfo.reverse();
 				try {
 					srcDeclaration.data.value = cssTree.parse(fontInfo.map(fontSource => fontSource.src).join(","), { context: "value", parseCustomProperty: true });
@@ -582,6 +585,7 @@ function getProcessorHelperClass(utilInstance) {
 					// ignored
 				}
 			}
+			return true;
 		}
 	};
 }

package/core/util.js

@@ -240,7 +240,7 @@ function getInstance(utilOptions) {
 			startTime = Date.now();
 			log("  // STARTED download url =", resourceURL, "asBinary =", options.asBinary);
 		}
-		if (options.blockMixedContent && /^https:/i.test(options.baseURI) && !/^https:/i.test(resourceURL)) {
+		if (options.blockMixedContent && /^https:/i.test(options.baseURI) && !/^https:/i.test(resourceURL) && !/^blob:https:/i.test(resourceURL)) {
 			return getFetchResponse(resourceURL, options);
 		}
 		if (options.networkTimeout) {
@@ -390,13 +390,13 @@ function guessMIMEType(expectedType, buffer) {
 		if (compareBytes([255, 255, 255, 255], [0, 0, 2, 0])) {
 			return "image/x-icon";
 		}
-		if (compareBytes([255, 255], [78, 77])) {
+		if (compareBytes([255, 255], [66, 77])) {
 			return "image/bmp";
 		}
 		if (compareBytes([255, 255, 255, 255, 255, 255], [71, 73, 70, 56, 57, 97])) {
 			return "image/gif";
 		}
-		if (compareBytes([255, 255, 255, 255, 255, 255], [71, 73, 70, 56, 59, 97])) {
+		if (compareBytes([255, 255, 255, 255, 255, 255], [71, 73, 70, 56, 55, 97])) {
 			return "image/gif";
 		}
 		if (compareBytes([255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255], [82, 73, 70, 70, 0, 0, 0, 0, 87, 69, 66, 80, 86, 80])) {
@@ -434,7 +434,7 @@ function guessMIMEType(expectedType, buffer) {
 		if (compareBytes([0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255], [0, 0, 0, 0, 102, 116, 121, 112, 105, 115, 111, 109])) {
 			return "video/mp4";
 		}
-		if (compareBytes([255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255], [82, 73, 70, 70, 0, 0, 0, 0, 87, 65, 86, 69])) {
+		if (compareBytes([255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255], [82, 73, 70, 70, 0, 0, 0, 0, 65, 86, 73, 32])) {
 			return "video/x-msvideo";
 		}
 		if (compareBytes([255, 255, 255, 255], [0, 0, 1, 179]) || compareBytes([255, 255, 255, 255], [0, 0, 1, 186])) {
@@ -443,18 +443,18 @@ function guessMIMEType(expectedType, buffer) {
 		if (compareBytes([255, 255, 255, 255], [79, 103, 103, 83])) {
 			return "video/ogg";
 		}
-		if (compareBytes([255], [71])) {
-			return "video/mp2t";
-		}
 		if (compareBytes([255, 255, 255, 255], [26, 69, 223, 163])) {
 			return "video/webm";
 		}
 		if (compareBytes([0, 0, 0, 0, 255, 255, 255, 255, 255, 255], [0, 0, 0, 0, 102, 116, 121, 112, 51, 103])) {
 			return "video/3gpp";
 		}
+		if (compareBytes([255], [71])) {
+			return "video/mp2t";
+		}
 	}
 	if (expectedType == "audio") {
-		if (compareBytes([255, 255], [255, 249]) || compareBytes([255, 255], [255, 254])) {
+		if (compareBytes([255, 255], [255, 241]) || compareBytes([255, 255], [255, 249]) || compareBytes([255, 255], [255, 254])) {
 			return "audio/aac";
 		}
 		if (compareBytes([255, 255, 255, 255], [77, 84, 104, 100])) {

package/doc/singlefile-archive.md

@@ -735,6 +735,23 @@ zip64 locator states an absolute offset in the original file, so it needs the sh
 this formula produces and cannot be used to find it. A reader that instead uses the
 sentinels arithmetically gets a shift in the billions, with no diagnostic.
 
+Which leaves the record itself to be located without the offset that normally points at
+it. Scan backward from the locator for the `PK\x06\x06` signature and confirm each
+candidate against the record's own size field, the 8 bytes at `p + 4`, which by
+definition excludes the leading 12:
+
+```
+p + 12 + size == locatorPosition
+```
+
+A well-formed archive puts the record immediately before the locator, where it is 56
+bytes long if it carries no extensible data sector, so `locatorPosition - 56` is worth
+testing before scanning at all. The confirmation matters on the archives that miss:
+past the record the scan walks back through the central directory, whose file names and
+extra fields are arbitrary bytes, and past that through entry data, and a four-byte
+signature turns up in bytes nothing constrains. The test settles each candidate against
+the record's own field, so it needs no offset it does not already have.
+
 ### 4.6 Text tools
 
 The optional text body (`insertTextBody`) addresses one more consumer: software that
@@ -972,22 +989,24 @@ limit of what the CDATA rung buys here — its value is that real payloads rarel
 above states a MUST rather than a quality-of-implementation preference — exhaustion is
 reachable by construction, not only by a payload built to provoke it.
 
-The check MUST be made against the payload's final bytes, for every payload the
-writer hides and in every variant that hides one. Every rejection restarts the build
-(§6): the wrapper choice changes the bytes preceding the archive, so the archive must
-be rewritten at its new position.
-
-Two fields are patched after that check. The EOCD comment-length field sits at the
-end of the ZIP region and is patched under the declared form (§6.1, step 11); the
-writer tests the bytes around it again with the final value in place and keeps the raw
-form when that value would complete a pattern, since the raw form is always valid. The
-`tEXt "ZIP"` length field sits inside the pixel-data wrapper, with the fixed `tEXt`
-type and `ZIP` keyword after it, and is written last (step 12). The header is tested
-with the rest of the payload, the length as zeros, which cannot join a pattern; the
-real length is big-endian, so a pattern byte in it would have to be the most
-significant byte of the chunk's size, and the smallest byte any pattern contains, `-`
-at 0x2D, puts that size at 0x2D000000 bytes, about 755 MB. The writer refuses to
-build a self-extracting PNG variant whose chunk reaches that size rather than
+The selection test above — both patterns, on every rung the writer considers — MUST
+be applied to the payload's bytes in their final form, for every payload the writer
+hides and in every variant that hides one. *Final* is the whole of the requirement:
+bytes the writer has yet to settle have not been tested. Every rejection restarts the build (§6):
+the wrapper choice changes the bytes preceding the archive, so the archive must be
+rewritten at its new position.
+
+Two fields are patched after that test, and each needs one of its own. The EOCD
+comment-length field sits at the end of the ZIP region and is patched under the
+declared form (§6.1, step 11); the writer tests the bytes around it again with the
+final value in place and keeps the raw form when that value would complete a pattern,
+since the raw form is always valid. The `tEXt "ZIP"` length field sits inside the pixel-data wrapper,
+with the fixed `tEXt` type and `ZIP` keyword after it, and is written last (step 12).
+The header is tested with the rest of the payload, the length as zeros, which cannot
+join a pattern; the real length is big-endian, so a pattern byte in it would have to be
+the most significant byte of the chunk's size, and the smallest byte any pattern
+contains, `-` at 0x2D, puts that size at 0x2D000000 bytes, about 755 MB. The writer
+refuses to build a self-extracting PNG variant whose chunk reaches that size rather than
 re-check the field.
 
 ### 5.2 The appended-data budget
@@ -1043,6 +1062,15 @@ self-consistent:
   file positions (§4.2), so a reader of the *whole file* never needs prepended-data
   compensation — the repair by which a reader recomputes offsets that disagree with
   the file size. A reader of the recovered ZIP region alone does need it (§4.5).
+
+  The alternative, offsets relative to the start of the region, is not a compatibility
+  problem in itself: a reader that compensates arrives at the same entries, and 7-Zip
+  opens such a file when told the type. What absolute offsets buy is the step before
+  that. The file is a valid archive read as it stands, so it survives format
+  auto-detection — 7-Zip reports a base of 0 and a physical size covering the whole
+  file — and the compensation is confined to the one path that cannot avoid it,
+  universal-mode recovery. Nothing in the format depends on the choice; a writer using
+  the other form produces files this document's readers still open.
 - **PDF offsets are header-relative.** The document's own cross-reference offsets are
   interpreted from the `%PDF-` header, so embedding it needs no rewriting; the writer
   only MUST keep the header inside the scan window (§4.3).
@@ -1766,7 +1794,10 @@ of §5.7.
 
 ### 8.4 The charset round trip, measured
 
-Two claims of §2.1 were verified.
+Two claims of §2.1 were verified. The first is re-derived on every run by
+`test/sfz-harness/charset-round-trip.js`, which reads the tables below out of the
+runtime's own decoders rather than trusting this section, and checks the reverse table
+the extractor ships against the one the rule of §5.5 produces.
 
 **Which encodings qualify.** Decoding all 256 byte values through each encoding
 defined by the WHATWG standard shows 20 that are injective and never produce U+FFFD:

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "single-file-core",
-  "version": "1.5.123",
+  "version": "1.5.125",
   "description": "SingleFile Core",
   "author": "Gildas Lormeau",
   "license": "AGPL-3.0-or-later",
   "scripts": {
-    "test": "deno run --allow-read test/sfz-harness/format-rules.js && deno run --allow-read test/sfz-harness/stored-trigger.js && deno run --allow-read test/sfz-harness/check-determinism.js && deno run --allow-read test/sfz-harness/option-wiring.js && deno run --allow-read test/sfz-harness/css-property-filter.js && deno run --allow-read test/sfz-harness/adopted-stylesheets-hook.js && deno run --allow-read test/sfz-harness/css-fonts-minifier.js && deno run --allow-read test/sfz-harness/inlined-functions.js && deno run --allow-read test/sfz-harness/pages-archive.js && deno run --allow-read test/sfz-harness/filename-max-length.js && deno run --allow-read test/sfz-harness/entry-compression.js && deno run --allow-read test/sfz-harness/filename-characters.js && deno run --allow-read test/sfz-harness/byte-map.js && deno run --allow-read test/sfz-harness/zip64.js",
+    "test": "deno run --allow-read test/sfz-harness/format-rules.js && deno run --allow-read test/sfz-harness/stored-trigger.js && deno run --allow-read test/sfz-harness/check-determinism.js && deno run --allow-read test/sfz-harness/option-wiring.js && deno run --allow-read test/sfz-harness/css-property-filter.js && deno run --allow-read test/sfz-harness/adopted-stylesheets-hook.js && deno run --allow-read test/sfz-harness/css-fonts-minifier.js && deno run --allow-read test/sfz-harness/inlined-functions.js && deno run --allow-read test/sfz-harness/pages-archive.js && deno run --allow-read test/sfz-harness/filename-max-length.js && deno run --allow-read test/sfz-harness/entry-compression.js && deno run --allow-read test/sfz-harness/filename-characters.js && deno run --allow-read test/sfz-harness/byte-map.js && deno run --allow-read test/sfz-harness/zip64.js && deno run --allow-read test/sfz-harness/charset-round-trip.js",
     "bump-patch": "npm version patch --no-git-tag-version && npm run bump-commit",
     "bump-minor": "npm version minor --no-git-tag-version && npm run bump-commit",
     "bump-major": "npm version major --no-git-tag-version && npm run bump-commit",

package/processors/compression/compression-display.js

@@ -54,7 +54,9 @@ async function display(document, docContent, { disableFramePointerEvents, inPlac
 	if (disableFramePointerEvents) {
 		doc.querySelectorAll("iframe").forEach(element => {
 			const pointerEvents = "pointer-events";
-			element.style.setProperty("-sf-" + pointerEvents, element.style.getPropertyValue(pointerEvents), element.style.getPropertyPriority(pointerEvents));
+			if (element.style.getPropertyValue(pointerEvents) != "none" || element.style.getPropertyPriority(pointerEvents) != "important") {
+				element.style.setProperty("--sf-" + pointerEvents, element.style.getPropertyValue(pointerEvents), element.style.getPropertyPriority(pointerEvents));
+			}
 			element.style.setProperty(pointerEvents, "none", "important");
 		});
 	}

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

@@ -177,7 +177,7 @@ function initRequestSync(message) {
 	if (!TOP_WINDOW) {
 		windowId = globalThis.frameId = message.windowId;
 	}
-	processFrames(document, message.options, windowId, sessionId);
+	processFrames(document, message.options, windowId, sessionId, false);
 	if (!TOP_WINDOW) {
 		sendInitResponse({ frames: [getFrameData(document, globalThis, windowId, message.options, message.scrolling)], sessionId, requestedFrameId: document.documentElement.dataset.requestedFrameId && windowId });
 		delete document.documentElement.dataset.requestedFrameId;
@@ -190,7 +190,7 @@ async function initRequestAsync(message) {
 	if (!TOP_WINDOW) {
 		windowId = globalThis.frameId = message.windowId;
 	}
-	processFrames(document, message.options, windowId, sessionId);
+	processFrames(document, message.options, windowId, sessionId, message.waitForFrames !== false);
 	if (!TOP_WINDOW) {
 		sendInitResponse({ frames: [getFrameData(document, globalThis, windowId, message.options, message.scrolling)], sessionId, requestedFrameId: document.documentElement.dataset.requestedFrameId && windowId });
 		delete document.documentElement.dataset.requestedFrameId;
@@ -254,15 +254,15 @@ function initResponse(message) {
 		}
 	}
 }
-function processFrames(doc, options, parentWindowId, sessionId) {
+function processFrames(doc, options, parentWindowId, sessionId, waitForFrames) {
 	const frameElements = getFrames(doc);
-	processFramesAsync(doc, frameElements, options, parentWindowId, sessionId);
+	processFramesAsync(doc, frameElements, options, parentWindowId, sessionId, waitForFrames);
 	if (frameElements.length) {
-		processFramesSync(doc, frameElements, options, parentWindowId, sessionId);
+		processFramesSync(doc, frameElements, options, parentWindowId, sessionId, waitForFrames);
 	}
 }
 
-function processFramesAsync(doc, frameElements, options, parentWindowId, sessionId) {
+function processFramesAsync(doc, frameElements, options, parentWindowId, sessionId, waitForFrames) {
 	const frames = [];
 	let requestTimeouts;
 	if (sessions.get(sessionId)) {
@@ -280,17 +280,18 @@ function processFramesAsync(doc, frameElements, options, parentWindowId, session
 	frameElements.forEach((frameElement, frameIndex) => {
 		const windowId = parentWindowId + WINDOW_ID_SEPARATOR + frameIndex;
 		try {
-			sendMessage(frameElement.contentWindow, { method: INIT_REQUEST_MESSAGE, windowId, sessionId, options, scrolling: frameElement.scrolling });
+			sendMessage(frameElement.contentWindow, { method: INIT_REQUEST_MESSAGE, windowId, sessionId, options, scrolling: frameElement.scrolling, waitForFrames });
 			// eslint-disable-next-line no-unused-vars
 		} catch (error) {
 			// ignored
 		}
-		requestTimeouts[windowId] = globalThis.setTimeout(() => sendInitResponse({ frames: [{ windowId, processed: true }], sessionId }), TIMEOUT_INIT_REQUEST_MESSAGE);
+		setFrameFallback(sessionId, windowId, () => getSrcdocFrameData(frameElement, windowId, options, sessionId));
+		requestTimeouts[windowId] = globalThis.setTimeout(() => sendInitResponse({ frames: [getFrameFallback(sessionId, windowId) || { windowId, processed: true }], sessionId }), TIMEOUT_INIT_REQUEST_MESSAGE);
 	});
 	delete doc.documentElement.dataset.requestedFrameId;
 }
 
-function processFramesSync(doc, frameElements, options, parentWindowId, sessionId) {
+function processFramesSync(doc, frameElements, options, parentWindowId, sessionId, waitForFrames) {
 	const frames = [];
 	frameElements.forEach((frameElement, frameIndex) => {
 		const windowId = parentWindowId + WINDOW_ID_SEPARATOR + frameIndex;
@@ -303,21 +304,25 @@ function processFramesSync(doc, frameElements, options, parentWindowId, sessionI
 		} catch (error) {
 			// ignored
 		}
-		const srcdoc = frameElement.getAttribute("srcdoc");
-		if (!frameDoc && srcdoc) {
-			const doc = new DOMParser().parseFromString(srcdoc, "text/html");
-			frameDoc = doc;
-			frameWindow = globalThis;
-		}
 		if (frameDoc) {
 			try {
 				clearFrameTimeout("requestTimeouts", sessionId, windowId);
-				processFrames(frameDoc, options, windowId, sessionId);
+				processFrames(frameDoc, options, windowId, sessionId, waitForFrames);
 				frames.push(getFrameData(frameDoc, frameWindow, windowId, options, frameElement.scrolling));
 				// eslint-disable-next-line no-unused-vars
 			} catch (error) {
 				frames.push({ windowId, processed: true });
 			}
+		} else if (!waitForFrames) {
+			// the frame is cross-origin or sandboxed, so its document is out of reach. Re-parsing
+			// srcdoc is the only source left here, and it is markup only: no script has run and
+			// nothing is rendered. When there is time to wait, the fallback is kept for the frames
+			// that never answer instead, so a frame that does answer wins with its rendered data
+			const fallbackFrameData = getFrameFallback(sessionId, windowId);
+			if (fallbackFrameData) {
+				clearFrameTimeout("requestTimeouts", sessionId, windowId);
+				frames.push(fallbackFrameData);
+			}
 		}
 	});
 	sendInitResponse({ frames, sessionId, requestedFrameId: doc.documentElement.dataset.requestedFrameId && parentWindowId });
@@ -338,7 +343,39 @@ function clearFrameTimeout(type, sessionId, windowId) {
 function createFrameResponseTimeout(sessionId, windowId) {
 	const session = sessions.get(sessionId);
 	if (session && session.responseTimeouts) {
-		session.responseTimeouts[windowId] = globalThis.setTimeout(() => sendInitResponse({ frames: [{ windowId: windowId, processed: true }], sessionId: sessionId }), TIMEOUT_INIT_RESPONSE_MESSAGE);
+		session.responseTimeouts[windowId] = globalThis.setTimeout(() => sendInitResponse({ frames: [getFrameFallback(sessionId, windowId) || { windowId, processed: true }], sessionId: sessionId }), TIMEOUT_INIT_RESPONSE_MESSAGE);
+	}
+}
+
+function setFrameFallback(sessionId, windowId, getFallbackFrameData) {
+	const session = sessions.get(sessionId);
+	if (session) {
+		if (!session.frameFallbacks) {
+			session.frameFallbacks = {};
+		}
+		session.frameFallbacks[windowId] = getFallbackFrameData;
+	}
+}
+
+function getFrameFallback(sessionId, windowId) {
+	const session = sessions.get(sessionId);
+	const getFallbackFrameData = session && session.frameFallbacks && session.frameFallbacks[windowId];
+	if (getFallbackFrameData) {
+		return getFallbackFrameData();
+	}
+}
+
+function getSrcdocFrameData(frameElement, windowId, options, sessionId) {
+	const srcdoc = frameElement.getAttribute("srcdoc");
+	if (srcdoc) {
+		try {
+			const frameDoc = new DOMParser().parseFromString(srcdoc, "text/html");
+			processFrames(frameDoc, options, windowId, sessionId, false);
+			return getFrameData(frameDoc, globalThis, windowId, options, frameElement.scrolling);
+			// eslint-disable-next-line no-unused-vars
+		} catch (error) {
+			// ignored
+		}
 	}
 }
 

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

@@ -412,6 +412,7 @@
 			}
 		};
 		document.fonts.delete.toString = function () { return "function delete() { [native code] }"; };
+		setFunctionName(document.fonts.delete, "delete");
 		const clearFonts = document.fonts.clear;
 		document.fonts.clear = function () {
 			try {
@@ -423,16 +424,16 @@
 			}
 		};
 		document.fonts.clear.toString = function () { return "function clear() { [native code] }"; };
+		setFunctionName(document.fonts.clear, "clear");
 	}
 
 	if (globalThis.IntersectionObserver) {
 		const origIntersectionObserver = globalThis.IntersectionObserver;
-		globalThis.IntersectionObserver = function IntersectionObserver() {
+		globalThis.IntersectionObserver = function IntersectionObserver(callback) {
 			try {
 				const intersectionObserver = new origIntersectionObserver(...arguments);
 				const observeIntersection = origIntersectionObserver.prototype.observe || intersectionObserver.observe;
 				const unobserveIntersection = origIntersectionObserver.prototype.unobserve || intersectionObserver.unobserve;
-				const callback = arguments[0];
 				const options = arguments[1];
 				if (observeIntersection) {
 					intersectionObserver.observe = function (targetElement) {
@@ -450,6 +451,7 @@
 						}
 					};
 					intersectionObserver.observe.toString = function () { return "function observe() { [native code] }"; };
+					setFunctionName(intersectionObserver.observe, "observe");
 				}
 				if (unobserveIntersection) {
 					intersectionObserver.unobserve = function (targetElement) {
@@ -471,6 +473,7 @@
 						}
 					};
 					intersectionObserver.unobserve.toString = function () { return "function unobserve() { [native code] }"; };
+					setFunctionName(intersectionObserver.unobserve, "unobserve");
 				}
 				observers.set(intersectionObserver, { callback, options });
 				return intersectionObserver;
@@ -496,6 +499,7 @@
 		}
 	};
 	CSSStyleSheet.prototype.replaceSync.toString = function () { return "function replaceSync() { [native code] }"; };
+	setFunctionName(CSSStyleSheet.prototype.replaceSync, "replaceSync");
 	const orginalReplace = CSSStyleSheet.prototype.replace;
 	CSSStyleSheet.prototype.replace = async function (text) {
 		try {
@@ -508,10 +512,11 @@
 		}
 	};
 	CSSStyleSheet.prototype.replace.toString = function () { return "function replace() { [native code] }"; };
+	setFunctionName(CSSStyleSheet.prototype.replace, "replace");
 	const originalInsertRule = CSSStyleSheet.prototype.insertRule;
-	CSSStyleSheet.prototype.insertRule = function (rule, index) {
+	CSSStyleSheet.prototype.insertRule = function (rule) {
 		try {
-			const result = originalInsertRule.apply(this, [rule, index]);
+			const result = originalInsertRule.apply(this, [rule, arguments[1]]);
 			adoptedStylesheetsData.delete(this);
 			return result;
 		} catch (error) {
@@ -520,6 +525,7 @@
 		}
 	};
 	CSSStyleSheet.prototype.insertRule.toString = function () { return "function insertRule() { [native code] }"; };
+	setFunctionName(CSSStyleSheet.prototype.insertRule, "insertRule");
 	const originalDeleteRule = CSSStyleSheet.prototype.deleteRule;
 	CSSStyleSheet.prototype.deleteRule = function (index) {
 		try {
@@ -532,6 +538,7 @@
 		}
 	};
 	CSSStyleSheet.prototype.deleteRule.toString = function () { return "function deleteRule() { [native code] }"; };
+	setFunctionName(CSSStyleSheet.prototype.deleteRule, "deleteRule");
 
 	// the listener below is reached through the host element, and a closed shadow root is
 	// not reachable from it, so the roots are recorded as they are created

package/test/sfz-harness/README.md

@@ -27,7 +27,7 @@ any check failed.
 
 | Script | What it covers |
 |---|---|
-| `format-rules.js` | The rules of the format: charset round trip, the wrapper-tag ladder and its selection tests, the identifier, appended-data placement and declaration, password scope, the PDF and PNG faces. |
+| `format-rules.js` | The rules of the format: the charset declaration and the doctype cap that keeps it inside the scan window, the wrapper-tag ladder and its selection tests, the identifier, appended-data placement and declaration, password scope, the PDF and PNG faces. |
 | `stored-trigger.js` | That a stored (uncompressed) entry whose bytes contain a rung's pattern moves the writer to the right rung. |
 | `check-determinism.js` | That the same inputs produce the same bytes, and that the levers which should change the output do. |
 | `option-wiring.js` | That every option `compression.js` reads is either declared as a caller option or classified as internal, and that `single-file.js` still builds its argument from that declaration. Guards the layer the other suites sit below. |
@@ -40,6 +40,7 @@ any check failed.
 | `filename-characters.js` | That `getValidFilename` maps a full-width lookalike one character at a time — `C++` used to be saved as `C＋` — while a run of characters with no lookalike still collapses to a single replacement. |
 | `zip64.js` | That the `page.pdf` record injection accounts for the zip64 end of central directory record (§5.7): all four EOCD fields left at their sentinels, the entry counts and directory size carried in the zip64 record, the directory offset pointing at the injected record, and the archive still readable. The branch runs only past 4 GiB or 65535 entries, so nothing reached it before; the suite forces zip64 through `zipWriter.options` from inside the `writeEntries` callback, with no production lever. |
 | `byte-map.js` | That the byte offsets §8.2 of the specification prints still describe what the writer emits: the prologue order, the doctype and root tag with nothing between them, the identifier's length ahead of the region, absolute EOCD offsets, and the entry order. The specimen §8.2 documents is saved from a live URL and has never been in this repository, so none of its numbers could be checked; three of them were wrong. This builds an equivalent with no network. |
+| `charset-round-trip.js` | That the encoding tables §8.4 prints still describe the WHATWG index: which 20 of the 38 encodings carry all 256 byte values through a decode injectively, the sizes of the reverse tables they need, and the five windows-1252 positions a platform codec of the same name leaves undefined. It also re-derives the reverse table the extractor ships as a literal, which no build step checks and which corrupts one byte per occurrence when wrong. |
 | `css-fonts-minifier.js` | That `removeUnusedFonts` reads the font families it prunes on correctly: a `var()` family resolved from the values the document declares and not only from the ones the body inherits, every font kept when the value is genuinely undetermined, and a multi-word family name that does not also claim a font named after its own tail. |
 
 ## The tools

package/test/sfz-harness/charset-round-trip.js

@@ -0,0 +1,161 @@
+/*
+ * Copyright 2010-2026 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.
+ */
+
+// Universal mode recovers the ZIP region from the characters the HTML parser produced, so the
+// declared charset has to carry all 256 byte values through a decode injectively (§2.1). Which
+// encodings do is a property of the WHATWG index, not of this repository, and §8.4 prints the
+// answer as a table: 20 qualify, 18 do not, and each qualifying one needs a reverse table of a
+// stated size. Nothing re-derived that table -- it was measured once, by hand, outside the repo,
+// and would go stale silently if an index changed or the prose were edited.
+//
+// The last check is the one with teeth. §5.5 requires the reverse table to be derived from the
+// WHATWG index and NOT from a platform codec of the same name, because most platform codecs
+// leave five windows-1252 positions undefined and those bytes occur in ordinary compressed data.
+// The extractor ships that table as a literal, so it is derived once at authoring time and never
+// again; here it is re-derived from the runtime's own decoder and compared entry by entry.
+
+const BYTES = new Uint8Array(256).map((_, index) => index);
+
+// the 20 of §8.4, in the order the section lists them
+const QUALIFYING = [
+	"windows-1252", "iso-8859-2", "iso-8859-4", "iso-8859-5", "iso-8859-10", "iso-8859-13",
+	"iso-8859-14", "iso-8859-15", "iso-8859-16", "koi8-r", "koi8-u", "macintosh", "windows-1250",
+	"windows-1251", "windows-1254", "windows-1256", "windows-1258", "x-mac-cyrillic", "ibm866",
+	"x-user-defined"
+];
+// the 18 that do not: eight single-byte encodings with undefined positions in their index, then
+// the multi-byte ones, which decode a lone byte sequence to U+FFFD or to fewer than 256 characters
+const DISQUALIFIED = [
+	"iso-8859-3", "iso-8859-6", "iso-8859-7", "iso-8859-8", "windows-874", "windows-1253",
+	"windows-1255", "windows-1257",
+	"utf-8", "utf-16le", "utf-16be", "gbk", "gb18030", "big5", "euc-jp", "shift_jis", "euc-kr",
+	"iso-2022-jp"
+];
+
+let failures = 0;
+
+function describe(label) {
+	const points = Array.from(new TextDecoder(label).decode(BYTES));
+	if (points.length != 256) {
+		return { qualifies: false, reason: points.length + " characters" };
+	}
+	const table = new Map();
+	const seen = new Set();
+	let identity = 0;
+	for (let byte = 0; byte < 256; byte++) {
+		const codePoint = points[byte].codePointAt(0);
+		if (codePoint == 0xFFFD) {
+			return { qualifies: false, reason: "U+FFFD at 0x" + byte.toString(16) };
+		}
+		if (seen.has(codePoint)) {
+			return { qualifies: false, reason: "collision at 0x" + byte.toString(16) };
+		}
+		seen.add(codePoint);
+		if (codePoint == byte) {
+			identity++;
+		} else {
+			table.set(codePoint, byte);
+		}
+	}
+	return { qualifies: true, identity, table, points };
+}
+
+const described = new Map([...QUALIFYING, ...DISQUALIFIED].map(label => [label, describe(label)]));
+
+check("§8.4 covers the whole standard: 20 qualifying + 18 disqualified",
+	QUALIFYING.length + DISQUALIFIED.length == 38 && new Set([...QUALIFYING, ...DISQUALIFIED]).size == 38);
+
+const wrongVerdict = [...described].filter(([label, result]) =>
+	result.qualifies != QUALIFYING.includes(label));
+check("every encoding falls on the side of the table §8.4 puts it on", wrongVerdict.length == 0,
+	wrongVerdict.map(([label, result]) => label + " " + (result.reason || "qualifies")).join(", "));
+
+// §8.4 quotes the extremes of the reverse-table sizes; they bound what an implementation has to
+// carry to support any qualifying charset rather than only the one the reference writer declares
+const qualifying = QUALIFYING.filter(label => described.get(label).qualifies);
+const sizes = qualifying.map(label => [label, described.get(label).table.size]);
+const smallest = Math.min(...sizes.map(([, size]) => size));
+const largest = Math.max(...sizes.map(([, size]) => size));
+check("the smallest reverse table is 8 entries, iso-8859-15", smallest == 8 &&
+	sizes.filter(([, size]) => size == smallest).map(([label]) => label).join() == "iso-8859-15");
+check("the largest is 128, for koi8-r, koi8-u, ibm866 and x-user-defined", largest == 128 &&
+	sizes.filter(([, size]) => size == largest).map(([label]) => label).sort().join() ==
+	"ibm866,koi8-r,koi8-u,x-user-defined");
+
+const windows1252 = described.get("windows-1252");
+check("windows-1252 decodes 229 of the 256 values to themselves (§5.5 rule 1)",
+	windows1252.identity == 229, String(windows1252.identity));
+check("its reverse table is the remaining 27 (§5.5 rule 2)", windows1252.table.size == 27,
+	String(windows1252.table.size));
+
+// the trap of §5.5: iso-8859-1 is a LABEL of windows-1252, not the identity mapping its name
+// suggests, so a reader that treats it as latin-1 builds a table with no entries at all
+check("iso-8859-1 is a label of windows-1252, not a separate identity encoding",
+	new TextDecoder("iso-8859-1").encoding == "windows-1252" &&
+	new TextDecoder("latin1").encoding == "windows-1252");
+
+// the five positions of the §5.5 table: the WHATWG index assigns them, most platform codecs do not
+check("the WHATWG index assigns 0x81, 0x8D, 0x8F, 0x90 and 0x9D (§5.5)",
+	[0x81, 0x8D, 0x8F, 0x90, 0x9D].every(byte =>
+		windows1252.points[byte].codePointAt(0) == byte && !windows1252.table.has(byte)));
+
+// §8.4's caveat on x-user-defined: it qualifies on the criterion and is still a poor choice
+check("x-user-defined maps 0x80-0xFF into the Private Use Area, U+F780-U+F7FF",
+	[...Array(128).keys()].every(index =>
+		described.get("x-user-defined").points[128 + index].codePointAt(0) == 0xF780 + index));
+
+// the round trip of §5.5 rules 1 and 2, on every byte value and every qualifying charset. NUL and
+// the newlines need rules 3 and 4 in a browser, where the parser has replaced and normalized them;
+// through a decoder alone they arrive intact, so the mapping is exact for all 256 values here
+const broken = qualifying.filter(label => {
+	const { table, points } = described.get(label);
+	return points.some((character, byte) => {
+		const codePoint = character.codePointAt(0);
+		return (table.has(codePoint) ? table.get(codePoint) : codePoint) != byte;
+	});
+});
+check("all 256 byte values survive decode and reverse mapping, under every qualifying charset",
+	broken.length == 0, broken.join(", "));
+
+// the extractor's own table, re-derived. It is inlined into every archive, so an error here is
+// not caught by any build step and corrupts one byte per occurrence in the recovered region
+const compression = await Deno.readTextFile(new URL("../../processors/compression/compression.js", import.meta.url));
+const literal = compression.slice(compression.indexOf("const characterMap = new Map(["));
+const shipped = new Map([...literal.slice(0, literal.indexOf("]);")).matchAll(/\[(\d+),\s*(\d+)\]/g)]
+	.map(([, codePoint, byte]) => [Number(codePoint), Number(byte)]));
+const expected = new Map([[0xFFFD, 0], ...windows1252.table]);
+const wrongEntries = [...expected].filter(([codePoint, byte]) => shipped.get(codePoint) !== byte);
+const extraEntries = [...shipped].filter(([codePoint]) => !expected.has(codePoint));
+check("the extractor's characterMap is the derived windows-1252 table plus U+FFFD (28 entries)",
+	shipped.size == 28 && wrongEntries.length == 0 && extraEntries.length == 0,
+	"missing/wrong " + JSON.stringify(wrongEntries) + " extra " + JSON.stringify(extraEntries));
+
+console.log(failures ? `\n${failures} check(s) FAILED` : "\nall checks passed");
+Deno.exit(failures ? 1 : 0);
+
+function check(label, condition, detail) {
+	if (!condition) {
+		failures++;
+	}
+	console.log((condition ? "PASS" : "FAIL") + " " + label + (condition || !detail ? "" : ": " + detail));
+}