single-file-core 1.6.0 → 1.6.2

package/test/sfz-harness/README.md

@@ -1,87 +0,0 @@
-# SFZ format harness
-
-Tests for the SingleFile archive writer in `processors/compression/`, which drive
-`process()` directly with synthetic page data, so they need no browser and no network.
-The format itself is specified in [`doc/singlefile-archive.md`](../../doc/singlefile-archive.md).
-
-The directory has since taken in suites for code the archive writer does not own — the
-CSS processors, the download filename helpers — because they need the same Deno-with-a-
-DOM-stub setup and there was nowhere else to put them. The table says which is which.
-
-Run them with Deno, from the repository root:
-
-```
-npm test
-```
-
-which is [`test/run.js`](../run.js), the runner for every suite under `test/`. It takes
-name filters, so this directory alone is:
-
-```
-deno run --allow-read --allow-run test/run.js sfz-harness
-```
-
-or one at a time, which needs no runner:
-
-```
-deno run --allow-read test/sfz-harness/format-rules.js
-```
-
-## The suites
-
-CI runs these. Each prints one `PASS`/`FAIL` line per check and exits non-zero if
-any check failed.
-
-| Script | What it covers |
-|---|---|
-| `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. |
-| `css-property-filter.js` | That the declaration filter keeps a property css-tree's dictionary does not know (`stop-color`, `flood-opacity`, anything newer than the pinned build) and still drops a genuinely invalid value. |
-| `adopted-stylesheets-hook.js` | That the page-world hook answers the adopted-stylesheets request for a CLOSED shadow root, which its host does not expose. |
-| `inlined-functions.js` | That a function serialized into a self-extracting archive names nothing outside itself. An import survives bundling and still reads correctly, and the archive then throws a bare `ReferenceError` and renders nothing. |
-| `pages-archive.js` | That `createPagesArchive` packs several pages into one archive correctly: the first page at the root and the others in folders, the manifest, the symlink a deduplicated entry leaves behind, and the escaping of crawled titles in both tables of contents. Also that the options reaching the archive writer are derived from `PROCESS_OPTION_NAMES` rather than hand-listed — a hand copy dropped `maxAppendedDataLength` for months — and that `password` stays out of that derivation, since forwarding it would make the writer withhold the prologue's title as if the archive were encrypted while the table of contents and every entry comment still rode in that same cleartext prologue. |
-| `pages-router.js` | That the router opens a multi-page archive on the page a reader expects: the table of contents when the archive stores one, the first page when it does not, and the page a route in the hash names whatever else is stored. The router is inlined into the archive as source text and only ever ran inside a saved page, so nothing drove it before; the table of contents shipped stored, routable and unreachable. |
-| `content-type-sniffing.js` | That a magic-byte match beats the `Content-Type` header, and that the header survives when nothing matches. science.org serves its woff2 files as `text/plain`, which used to be trusted, so the fonts were embedded as `data:text/plain` and the SFZ writer deflated a file that is already Brotli-compressed. Two cases guard the rules themselves rather than the outcome: a video whose first byte is `G` must not be relabelled `video/mp2t`, and the generic `mif1` HEIF brand must identify nothing, because an AVIF can carry it and calling it HEIC would name a format no browser decodes. |
-| `entry-compression.js` | That an entry is deflated or stored on the content type the server sent, not on the extension alone — a module served as `text/javascript` from a `.ts` URL used to go in uncompressed — and that an unrecognized `application/octet-stream` still stays stored. |
-| `filename-max-length.js` | That `formatFilename` counts the ellipsis as well as the extension in the budget it truncates to, so a filename at `filenameMaxLength` stays at it, and that a limit shorter than the extension does not reach `Blob.slice` with a negative start. |
-| `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. |
-| `relocation-cost.js` | That the figures §5.2 prints for relocating the extra-data element reconstruct. Two of the three came from live captures and did not: the paragraph subtracted the terminator and the end tags from the reservation without subtracting the element, which the appended placement carries too, so it over-counted by the whole element. This pins the corrected arithmetic — the cost is the reservation margin alone, it is positive on every rung whenever an element exists, and the only way relocation saves bytes is to have no element to relocate. |
-| `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. |
-| `font-face-composite.js` | That several `@font-face` rules declaring the same family with the same style descriptors are one composite face and not a stack where the last rule wins, which is what CSS Fonts 4 §5.2 and §4.5.1 say: both members are kept with their own sources, faces split by `unicode-range` are all kept, an outright duplicate rule is emitted once, and a source repeated inside one rule is listed once, at the position of its later declaration. |
-
-## The tools
-
-Not tests — they print, they do not assert, and CI does not run them. The runner skips
-them by name, in the `NOT_SUITES` list of [`test/run.js`](../run.js). Everything else in
-this directory IS run, so a new file is either a suite or a line in that list.
-
-| Script | Use |
-|---|---|
-| `smoke.js` | Build one archive and print its size, chosen rung and first 200 bytes. |
-| `search-triggers.js` | Search seeds for page data that triggers a given condition. Its results are `trigger-seeds.json`. |
-| `gen-e2e-page.js` | Write a page fixture to disk for end-to-end use. |
-
-`common.js` builds the synthetic page data and options; `dom-stub.js` supplies the
-minimum DOM the compression code touches, because Deno has no `DOMParser`. Import it
-first — `compression.js` reads `globalThis.DOMParser` when it loads.
-
-## Adding a test
-
-Add checks to the suite that already covers the area, rather than creating a file per
-rule. A check is one line:
-
-```js
-check("the label that appears in the output", actual, expected);
-```
-
-Two things are worth doing every time. Write the comment that says *why* the rule
-exists, not what the code does — several rules here look arbitrary until you know which
-tokenizer state or which reader made them necessary. And confirm the test can fail:
-break the rule in `compression.js`, watch the check go red, then put it back. A check
-that passes against a deliberately broken writer is protecting nothing, which is how
-the case-insensitivity of the rung patterns went untested for as long as it did.

package/test/sfz-harness/adopted-stylesheets-hook.js

@@ -1,240 +0,0 @@
-/*
- * 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.
- */
-
-// A shadow root's constructed stylesheets cannot be read from the extension's own
-// world, so the page-world hook reads them and answers a request event. It used to
-// resolve the root with `event.target.shadowRoot`, which is null for a CLOSED root,
-// and then answered nothing at all. The extension still captured the root's content,
-// because it reaches closed roots through openOrClosedShadowRoot, so a closed root
-// came back in the saved page with its markup intact and its styles gone, with no
-// error anywhere. Measured on 2026-08-30 in Firefox and in Chrome, and again after
-// the fix, with tmp/closed-shadow-root-probe.html.
-//
-// The hook now records every root as it is attached and falls back to that record.
-// This test drives the hook's own listener over a stub of the one browser rule the
-// bug turns on: attachShadow returns the root to its caller either way, and leaves
-// host.shadowRoot null when the mode is closed.
-
-const REQUEST_EVENT = "single-file-request-get-adopted-stylesheets";
-const RESPONSE_EVENT = "single-file-response-get-adopted-stylesheets";
-const UNREGISTER_EVENT = "single-file-unregister-request-get-adopted-stylesheets";
-const HOOK_PATH = new URL("../../processors/hooks/content/content-hooks-frames-web.js", import.meta.url);
-
-let failures = 0;
-
-const documentListeners = new Map();
-installStubs();
-const originalAttachShadow = globalThis.Element.prototype.attachShadow;
-new Function(await Deno.readTextFile(HOOK_PATH))();
-const listener = documentListeners.get(REQUEST_EVENT);
-
-check("the hook registers a listener for the request event", Boolean(listener));
-check("the hook patches attachShadow", globalThis.Element.prototype.attachShadow !== originalAttachShadow);
-check("the patched attachShadow still looks native",
-	globalThis.Element.prototype.attachShadow.toString() === "function attachShadow() { [native code] }" &&
-	globalThis.Element.prototype.attachShadow.name === "attachShadow");
-
-// an open root: the host exposes it, which is the path that always worked
-const openHost = new StubElement();
-const openRoot = openHost.attachShadow({ mode: "open" });
-adopt(openRoot, ".open { color: red }");
-check("attachShadow returns the root for an open mode", openRoot instanceof StubShadowRoot);
-check("an open root answers with its stylesheets",
-	sameStrings(request(openHost, openRoot), [".open { color: red }"]));
-
-// a closed root: the host exposes nothing, so only the record can resolve it
-const closedHost = new StubElement();
-const closedRoot = closedHost.attachShadow({ mode: "closed" });
-adopt(closedRoot, ".closed { color: blue }");
-check("a closed root is hidden from its host", closedHost.shadowRoot === null);
-check("attachShadow returns the root for a closed mode", closedRoot instanceof StubShadowRoot);
-check("a closed root answers with its stylesheets",
-	sameStrings(request(closedHost, closedRoot), [".closed { color: blue }"]));
-
-// the same, for a sheet the page never passed through replaceSync, so that the
-// answer comes from cssRules rather than from the recorded text
-const rulesHost = new StubElement();
-const rulesRoot = rulesHost.attachShadow({ mode: "closed" });
-rulesRoot.adoptedStyleSheets = [{ cssRules: [{ cssText: ".rules { color: green }" }] }];
-check("a closed root answers from cssRules when the text was not recorded",
-	sameStrings(request(rulesHost, rulesRoot), [".rules { color: green }"]));
-
-// an empty root still registers the hook's listener on itself, which is what lets a
-// NESTED host inside it be reached later; only the answer is withheld
-const emptyHost = new StubElement();
-const emptyRoot = emptyHost.attachShadow({ mode: "closed" });
-check("an empty root answers nothing", request(emptyHost, emptyRoot) === undefined);
-check("an empty root is still listened to for nested hosts", emptyRoot.listenerCount(REQUEST_EVENT) > 0);
-
-// a target that is neither a host nor a recorded root must not throw
-check("an unrelated target is ignored", request(new StubElement(), new StubShadowRoot()) === undefined);
-
-// the cleanup the hook installs on each root it answers for. Both halves of it were dead:
-// the unregister handler was a fresh closure per handshake, so it was never the no-op that
-// re-adding a registered listener is and one was left behind per root per save, and it
-// removed the request listener without the capture flag it had been added with, which
-// matches nothing at all
-const repeatHost = new StubElement();
-const repeatRoot = repeatHost.attachShadow({ mode: "open" });
-adopt(repeatRoot, ".repeat { color: teal }");
-request(repeatHost, repeatRoot);
-const unregisterAfterFirst = repeatRoot.listenerCount(UNREGISTER_EVENT);
-request(repeatHost, repeatRoot);
-request(repeatHost, repeatRoot);
-check("one handshake installs one unregister listener", unregisterAfterFirst === 1);
-check("repeated handshakes do not accumulate unregister listeners",
-	repeatRoot.listenerCount(UNREGISTER_EVENT) === 1);
-check("the root is listened to for requests until it is unregistered",
-	repeatRoot.listenerCount(REQUEST_EVENT) === 1);
-repeatRoot.dispatchEvent(new globalThis.CustomEvent(UNREGISTER_EVENT, { bubbles: true }));
-check("unregistering removes the request listener the hook added with capture",
-	repeatRoot.listenerCount(REQUEST_EVENT) === 0);
-check("the unregister listener removes itself once it has fired",
-	repeatRoot.listenerCount(UNREGISTER_EVENT) === 0);
-
-console.log(failures ? `\n${failures} check(s) FAILED` : "\nall checks passed");
-Deno.exit(failures ? 1 : 0);
-
-function request(target, listeningRoot) {
-	let answer;
-	const responseListener = event => answer = event.detail.adoptedStyleSheets;
-	listeningRoot.addEventListener(RESPONSE_EVENT, responseListener);
-	listener({ target, stopPropagation() { } });
-	listeningRoot.removeEventListener(RESPONSE_EVENT, responseListener);
-	return answer;
-}
-
-function adopt(root, text) {
-	const sheet = new globalThis.CSSStyleSheet();
-	sheet.replaceSync(text);
-	root.adoptedStyleSheets = [sheet];
-}
-
-function sameStrings(value, expected) {
-	return Array.isArray(value) && value.length === expected.length && value.every((item, index) => item === expected[index]);
-}
-
-function check(label, condition) {
-	if (!condition) {
-		failures++;
-	}
-	console.log((condition ? "PASS" : "FAIL") + " " + label);
-}
-
-// the stub below models only what the hook touches while it installs itself and
-// while it answers one request; it is deliberately not a DOM
-function StubShadowRoot() {
-	this.adoptedStyleSheets = [];
-	this.listeners = new Map();
-}
-
-function StubElement() {
-	this.shadowRoot = null;
-	this.listeners = new Map();
-}
-
-function installStubs() {
-	// a listener is identified by type, callback AND capture: adding one that is already
-	// registered is a no-op, and removing one with a different capture flag matches nothing.
-	// The stub has to model both, because those are the two rules the cleanup code got wrong
-	const listenerMethods = {
-		addEventListener(type, listener, options) {
-			const capture = Boolean(options && options.capture);
-			if (!this.listeners.has(type)) {
-				this.listeners.set(type, []);
-			}
-			const listeners = this.listeners.get(type);
-			if (!listeners.some(entry => entry.listener === listener && entry.capture === capture)) {
-				listeners.push({ listener, capture, once: Boolean(options && options.once) });
-			}
-		},
-		removeEventListener(type, listener, options) {
-			const capture = Boolean(options && options.capture);
-			const listeners = this.listeners.get(type) || [];
-			const index = listeners.findIndex(entry => entry.listener === listener && entry.capture === capture);
-			if (index !== -1) {
-				listeners.splice(index, 1);
-			}
-		},
-		dispatchEvent(event) {
-			event.currentTarget = this;
-			(this.listeners.get(event.type) || []).slice().forEach(entry => {
-				if (entry.once) {
-					this.removeEventListener(event.type, entry.listener, { capture: entry.capture });
-				}
-				entry.listener(event);
-			});
-			event.currentTarget = null;
-			return true;
-		},
-		listenerCount(type) {
-			return (this.listeners.get(type) || []).length;
-		}
-	};
-	Object.assign(StubShadowRoot.prototype, listenerMethods);
-	Object.assign(StubElement.prototype, listenerMethods);
-
-	// the rule the bug turns on: the caller gets the root whatever the mode, while the
-	// host exposes it only when the mode is open
-	StubElement.prototype.attachShadow = function (init) {
-		const shadowRoot = new StubShadowRoot();
-		shadowRoot.host = this;
-		this.shadowRoot = init && init.mode === "closed" ? null : shadowRoot;
-		return shadowRoot;
-	};
-
-	const recordedText = new WeakMap();
-	class StubCSSStyleSheet {
-		replaceSync(text) {
-			recordedText.set(this, text);
-		}
-		get cssRules() {
-			return [{ cssText: recordedText.get(this) }];
-		}
-	}
-
-	globalThis.Element = StubElement;
-	globalThis.CSSStyleSheet = StubCSSStyleSheet;
-	globalThis.CustomEvent = class CustomEvent {
-		constructor(type, init = {}) {
-			this.type = type;
-			this.detail = init.detail;
-			this.bubbles = Boolean(init.bubbles);
-		}
-	};
-	globalThis.Event = class Event { constructor(type) { this.type = type; } };
-	globalThis.UIEvent = globalThis.Event;
-	globalThis.screen = { width: 0, height: 0 };
-	globalThis.MutationObserver = class MutationObserver { observe() { } };
-	globalThis.fetch = () => Promise.reject(new Error("the hook test makes no request"));
-	globalThis.document = {
-		addEventListener(type, listener) {
-			documentListeners.set(type, listener);
-		},
-		removeEventListener() { },
-		dispatchEvent() { return true; },
-		querySelectorAll: () => [],
-		documentElement: {},
-		fonts: { add() { }, delete() { }, clear() { }, forEach() { } }
-	};
-}

package/test/sfz-harness/byte-map.js

@@ -1,137 +0,0 @@
-// §8.2 of doc/singlefile-archive.md is a table of byte offsets. Nothing could check it: the
-// specimen it describes is saved from a live URL through the CLI, so it needs a network and a
-// browser and has never existed in this repository. Three of its rows were wrong for an unknown
-// length of time — the doctype is 15 bytes and nothing separates it from the root element start
-// tag, so the first three offsets were each one too high — and §4.2's derived figure is stale by
-// about 20 KB. This builds an equivalent specimen from the harness, deterministically and with no
-// network, and asserts both the offsets the document prints and the structural relations they
-// stand for. A writer change that moves the layout fails here instead of rotting in the prose.
-import "./dom-stub.js";
-import { makeOptions, runProcess, freezeDate } from "./common.js";
-
-const zipScript = await Deno.readTextFile(new URL("../../vendor/zip/zip.min.js", import.meta.url));
-
-let failed = false;
-
-function check(label, actual, expected) {
-	const ok = actual === expected;
-	console.log(`${ok ? "PASS" : "FAIL"} ${label}: ${actual}${ok ? "" : " (expected " + expected + ")"}`);
-	failed ||= !ok;
-}
-
-// a two-entry archive, matching the shape §8.2 documents: index.html and manifest.json only
-function makeSpecimenPageData() {
-	return {
-		title: "Example Domain",
-		doctype: "<!DOCTYPE html>",
-		content: "<html><body><h1>Example Domain</h1><p>" + "specimen ".repeat(64) + "</p></body></html>",
-		comment: "\n url: https://example.com/ \n saved date: Wed Aug 13 2025 \n",
-		resources: { stylesheets: [], images: [] }
-	};
-}
-
-const restoreDate = freezeDate();
-const { bytes } = await runProcess(makeSpecimenPageData(), makeOptions({
-	zipScript,
-	url: "https://example.com/",
-	insertCanonicalLink: false
-}));
-restoreDate();
-
-const text = new TextDecoder("windows-1252").decode(bytes);
-const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-const at = needle => text.indexOf(needle);
-
-const doctype = at("<!DOCTYPE html>");
-const root = at("<html data-sfz>");
-const charset = at("<meta charset=");
-const charsetEnd = charset + text.substring(charset).indexOf(">") + 1;
-const comment = at("<!--\n url:");
-const title = at("<title>");
-const style = at("<style>");
-const body = at("<body hidden>");
-const script = at("<script>");
-const wrapperStart = at("<!--sfz-data");
-const region = at("PK\x03\x04");
-const central = text.indexOf("PK\x01\x02", region);
-const eocd = text.indexOf("PK\x05\x06", central);
-const payload = at("<sfz-extra-data>");
-const endTags = at("</body></html>");
-
-console.log(`specimen: ${bytes.length} bytes`);
-console.log([
-	["html-prologue begins", doctype], ["root element start tag", root],
-	["charset declaration", charset], ["implementation comment", comment],
-	["title", title], ["stylesheet", style], ["body hidden", body],
-	["bootstrap script", script], ["wrapper start tag", wrapperStart],
-	["ZIP region begins", region], ["central directory", central],
-	["EOCD", eocd], ["recovery payload", payload], ["end tags", endTags]
-].map(([label, offset]) => `  ${String(offset).padStart(7)}  ${label}`).join("\n"));
-
-// the prologue order, which §3.1 and §6.1 both got backwards until 2026-09-01: the charset
-// declaration precedes the comment, because the comment carries an unbounded URL
-check("doctype opens the file", doctype, 0);
-check("root element start tag follows the doctype with nothing between", root, doctype + "<!DOCTYPE html>".length);
-check("charset declaration follows the root element start tag", charset, root + "<html data-sfz>".length);
-check("the comment begins where the charset declaration ends", comment, charsetEnd);
-check("the charset declaration is inside the prescan window", charsetEnd <= 1024, true);
-
-// the ordering the byte map asserts, region by region
-check("prologue order holds end to end",
-	[doctype, root, charset, comment, title, style, body, script, wrapperStart, region, central, eocd, payload, endTags]
-		.every((offset, index, all) => offset >= 0 && (index === 0 || offset > all[index - 1])), true);
-
-// the identifier sits inside the wrapper, so the region starts 12 bytes after the tag (§1.3)
-check("the identifier precedes the region by the length of the start tag", region - wrapperStart, "<!--sfz-data".length);
-
-// offsets are absolute file positions, not region-relative (§5.3)
-check("the EOCD directory offset is an absolute file position", view.getUint32(eocd + 16, true), central);
-check("the EOCD counts both entries", view.getUint16(eocd + 10, true), 2);
-check("the EOCD declares no archive comment", view.getUint16(eocd + 20, true), 0);
-
-// the region ends at the wrapper close tag, and the payload describes it minus the two
-// comment-length bytes (§4.5)
-const wrapperEnd = text.indexOf("-->", eocd);
-check("the wrapper closes after the EOCD", wrapperEnd > eocd, true);
-check("the appended run fits the budget", bytes.length - wrapperEnd <= 65535, true);
-
-// the entries the document names, in the order it names them (§4.2)
-let records = 0;
-for (let index = text.indexOf("PK\x01\x02"); index != -1; index = text.indexOf("PK\x01\x02", index + 1)) {
-	records++;
-}
-check("the central directory holds two records", records, 2);
-check("index.html is listed first", text.indexOf("index.html", central) < text.indexOf("manifest.json", central), true);
-
-// §4.2: page.pdf's local header lies before the ZIP region, so the prepended-data compensation
-// a reader of the recovered region applies takes its offset negative. The magnitude is the
-// region's start and moves with the size of the inlined library, so only the relation is checked
-{
-	const pdf = new TextEncoder().encode("%PDF-1.4\n1 0 obj\n<< /X (specimen) >>\nendobj\ntrailer\n<<>>\n%%EOF\n");
-	const restore = freezeDate();
-	const { bytes: pdfBytes } = await runProcess(makeSpecimenPageData(), makeOptions({
-		zipScript,
-		url: "https://example.com/",
-		insertCanonicalLink: false,
-		embeddedPdf: pdf
-	}));
-	restore();
-	const pdfText = new TextDecoder("windows-1252").decode(pdfBytes);
-	const pdfView = new DataView(pdfBytes.buffer, pdfBytes.byteOffset, pdfBytes.byteLength);
-	const pdfRegion = pdfText.indexOf("PK\x03\x04", pdfText.indexOf("<!--sfz-data"));
-	let record = pdfText.indexOf("PK\x01\x02", pdfRegion);
-	let stored;
-	while (record != -1 && stored === undefined) {
-		if (pdfText.substr(record + 46, pdfView.getUint16(record + 28, true)) == "page.pdf") {
-			stored = pdfView.getUint32(record + 42, true);
-		}
-		record = pdfText.indexOf("PK\x01\x02", record + 1);
-	}
-	check("page.pdf is listed in the central directory", stored !== undefined, true);
-	check("its local header sits where the central record says", pdfText.indexOf("PK\x03\x04"), stored);
-	check("its header is inside the PDF scan window", stored < 1024, true);
-	check("its header lies before the ZIP region", stored < pdfRegion, true);
-	check("so the compensated offset is negative", stored - pdfRegion < 0, true);
-}
-
-Deno.exit(failed ? 1 : 0);

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

@@ -1,161 +0,0 @@
-/*
- * 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));
-}