single-file-cli 2.1.3 → 2.2.1

package/lib/version.js

@@ -1 +1 @@
-export const version = "2.1.3";
+export const version = "2.2.1";

package/options.js

@@ -24,6 +24,8 @@
 import { version } from "./lib/version.js";
 import { Deno } from "./lib/deno-polyfill.js";
 
+const { args, build, exit } = Deno;
+
 const USAGE_TEXT = `single-file [url] [output]
 
 Positionals:
@@ -59,7 +61,7 @@ const OPTIONS_INFO = [{
 	"browser-debug": { description: "Enable debug mode", type: "boolean" },
 	"browser-arg": { description: "Argument passed to the browser", type: "string[]", alias: "browser-argument" },
 	"browser-args": { description: "Arguments provided as a JSON array and passed to the browser", type: "string" },
-	"browser-single-process": { description: "Run the browser as a single process", type: "boolean", defaultValue: true },
+	"browser-single-process": { description: "Run the browser as a single process (enabled by default on Windows only, current browsers on other platforms do not support this mode)", type: "boolean", defaultValue: build.os == "windows" },
 	"browser-start-minimized": { description: "Minimize the browser", type: "boolean" },
 	"browser-ignore-insecure-certs": { description: "Ignore HTTPs errors", type: "boolean" },
 	"browser-remote-debugging-URL": { description: "Remote debugging URL", type: "string" }
@@ -142,7 +144,7 @@ const OPTIONS_INFO = [{
 	"filename-template": { description: "Template used to generate the output filename (see https://github.com/gildas-lormeau/SingleFile/wiki/Template-variables-and-functions)", type: "string", defaultValue: "%if-empty<{page-title}|No title> ({date-locale} {time-locale}).{filename-extension}" },
 	"filename-conflict-action": { description: "Action when the filename is conflicting with existing one on the filesystem. The possible values are \"uniquify\" (default), \"overwrite\" and \"skip\"", type: "string", defaultValue: "uniquify" },
 	"filename-replacement-character": { description: "The character used for replacing invalid characters in filenames", type: "string", defaultValue: "_" },
-	"filename-replaced-character": { description: "The replaced character and the character(s) used for replacing the replacement character in filenames separated by a space, e.g. --filename-replaced-character \">\" _GT_ to replace \">\" with _GT_", type: "string[]", defaultValue: ["~ ～", "+ ＋", "? ？", "% ％", "* ＊", ": ：", "| ｜", "\" ＂", "< ＜", "> ＞", "\\\\ ＼", "\\x00-\\x1f _", "\x7F _"] },
+	"filename-replaced-character": { description: "Character to replace in filenames followed by the replacement character(s), both in a single value separated by a space, e.g. --filename-replaced-character \"> _GT_\" to replace \">\" with \"_GT_\" (repeat the option to replace multiple characters)", type: "string[]", defaultValue: ["~ ～", "+ ＋", "? ？", "% ％", "* ＊", ": ：", "| ｜", "\" ＂", "< ＜", "> ＞", "\\\\ ＼", "\\x00-\\x1f _", "\x7F _"] },
 	"filename-max-length": { description: "Specify the maximum length of the filename", type: "number", defaultValue: 192 },
 	"filename-max-length-unit": { description: "Specify the unit of the maximum length of the filename ('bytes' or 'chars')", type: "string", defaultValue: "bytes" },
 	"replace-emojis-in-filename": { description: "Replace emojis in the filename with their unicode text representation", type: "boolean" },
@@ -159,6 +161,10 @@ const OPTIONS_INFO = [{
 	"crawl-external-links-max-depth": { description: "Max depth when crawling pages found in external links (0: infinite)", type: "number", defaultValue: 1 },
 	"crawl-replace-URLs": { description: "Replace URLs of saved pages with relative paths of saved pages on the filesystem", type: "boolean" },
 	"crawl-rewrite-rule": { description: "Rewrite rule used to rewrite URLs of crawled pages", type: "string[]" },
+	"crawl-save-archive": { description: "Save all the crawled pages into a single (self-extracting) ZIP file, requires --compress-content", type: "boolean" },
+	"crawl-save-archive-dedup": { description: "Deduplicate identical resources shared between pages when using --crawl-save-archive", type: "boolean" },
+	"crawl-save-archive-mark-unarchived-links": { description: "Mark links to pages not saved in the archive when using --crawl-save-archive", type: "boolean" },
+	"crawl-save-archive-toc": { description: "Save a table of contents page into the archive when using --crawl-save-archive", type: "boolean" },
 }, {
 	"browser-script": { description: "Path of a script executed in the page (and all the frames) before it is loaded", type: "string[]" },
 	"browser-stylesheet": { description: "Path of a stylesheet file inserted into the page (and all the frames) after it is loaded", type: "string[]" },
@@ -202,7 +208,14 @@ const OPTIONS_INFO = [{
 	"version": { description: "Print the version number and exit.", type: "boolean" },
 }];
 
-const { args, exit } = Deno;
+const CRAWL_LINKS_DEPENDENT_OPTIONS = {
+	crawlInnerLinksOnly: "--crawl-inner-links-only",
+	crawlNoParent: "--crawl-no-parent",
+	crawlRemoveURLFragment: "--crawl-remove-URL-fragment",
+	crawlMaxDepth: "--crawl-max-depth",
+	crawlExternalLinksMaxDepth: "--crawl-external-links-max-depth",
+	crawlRewriteRules: "--crawl-rewrite-rule"
+};
 export { getOptions, parseArgs, applySettings, parseUrlsFile };
 
 function parseUrlsFile(content) {
@@ -295,6 +308,12 @@ function getOptions() {
 	if (urls.length > 2) {
 		errorMessages.push(`Unexpected arguments: ${urls.slice(2).join(", ")}`);
 	}
+	if (!options.crawlLinks) {
+		const explicitOptions = parseArgs(Array.from(args), false).options;
+		Object.keys(CRAWL_LINKS_DEPENDENT_OPTIONS)
+			.filter(optionKey => explicitOptions[optionKey] !== undefined)
+			.forEach(optionKey => errorMessages.push(`${CRAWL_LINKS_DEPENDENT_OPTIONS[optionKey]} requires --crawl-links`));
+	}
 	if (errorMessages.length) {
 		printUsage();
 		errorMessages.forEach(message => console.error(`Error: ${message}`)); // eslint-disable-line no-console

package/package.json

@@ -1,8 +1,13 @@
 {
 	"name": "single-file-cli",
-	"version": "2.1.3",
+	"version": "2.2.1",
 	"description": "SingleFile CLI",
 	"author": "Gildas Lormeau",
+	"license": "AGPL-3.0-or-later",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gildas-lormeau/single-file-cli.git"
+	},
 	"engines": {
 		"deno": ">=2.2",
 		"bun": ">=1.2",

package/single-file-cli-api.js

@@ -26,6 +26,7 @@
 import { Buffer } from "node:buffer";
 import * as backend from "./lib/cdp-client.js";
 import { getZipScriptSource } from "./lib/single-file-script.js";
+import { createPagesArchive } from "./lib/archive-packager.js";
 import { Deno, path } from "./lib/deno-polyfill.js";
 
 const VALID_URL_TEST = /^(https?|file):\/\//;
@@ -59,8 +60,8 @@ const DEFAULT_OPTIONS = {
 const STATE_PROCESSING = "processing";
 const STATE_PROCESSED = "processed";
 
-const { readTextFile, writeTextFile, writeFile, stdout, mkdir, stat, errors } = Deno;
-let tasks = [], maxParallelWorkers, sessionFilename;
+const { readTextFile, writeTextFile, readFile, writeFile, stdout, mkdir, makeTempDir, remove, stat, errors } = Deno;
+let tasks = [], maxParallelWorkers, sessionFilename, archiveTempDirectory;
 
 export { initialize };
 
@@ -69,6 +70,25 @@ async function initialize(options) {
 	if ((options.embedPdf || options.embeddedPdf || options.embedScreenshot || options.embeddedImage) && !options.compressContent) {
 		throw new Error("--embed-pdf, --embedded-pdf, --embed-screenshot and --embedded-image require --compress-content");
 	}
+	if (options.crawlSaveArchiveDedup && !options.crawlSaveArchive) {
+		throw new Error("--crawl-save-archive-dedup requires --crawl-save-archive");
+	}
+	if (options.crawlSaveArchiveMarkUnarchivedLinks && !options.crawlSaveArchive) {
+		throw new Error("--crawl-save-archive-mark-unarchived-links requires --crawl-save-archive");
+	}
+	if (options.crawlSaveArchiveToc && !options.crawlSaveArchive) {
+		throw new Error("--crawl-save-archive-toc requires --crawl-save-archive");
+	}
+	if (options.crawlSaveArchive) {
+		if (!options.compressContent) {
+			throw new Error("--crawl-save-archive requires --compress-content");
+		}
+		if (options.embedPdf || options.embeddedPdf || options.embedScreenshot || options.embeddedImage ||
+			options.outputJson || options.insertTextBody || options.password) {
+			throw new Error("--crawl-save-archive is not compatible with --embed-pdf, --embedded-pdf, --embed-screenshot, --embedded-image, --output-json, --insert-text-body and --password");
+		}
+		archiveTempDirectory = await makeTempDir();
+	}
 	maxParallelWorkers = options.maxParallelWorkers || 8;
 	try {
 		await backend.initialize(options);
@@ -128,6 +148,9 @@ async function capture(urls, options) {
 async function finish(options) {
 	const promiseTasks = tasks.map(task => task.promise);
 	await Promise.all(promiseTasks);
+	if (options.crawlSaveArchive) {
+		await savePagesArchive(options);
+	}
 	if (options.crawlReplaceURLs && !options.compressContent) {
 		for (const task of tasks) {
 			try {
@@ -155,6 +178,43 @@ async function finish(options) {
 	}
 }
 
+async function savePagesArchive(options) {
+	const archiveTasks = tasks.filter(task => task.archiveFilename);
+	if (archiveTasks.length) {
+		const pages = archiveTasks.map(task => ({
+			url: task.url,
+			originalUrls: task.originalUrls,
+			title: task.title,
+			getData: () => readFile(task.archiveFilename)
+		}));
+		const content = await createPagesArchive(pages, {
+			zipScript: getZipScriptSource(),
+			dedupPages: options.crawlSaveArchiveDedup,
+			markUnarchivedLinks: options.crawlSaveArchiveMarkUnarchivedLinks,
+			tocPage: options.crawlSaveArchiveToc,
+			selfExtractingArchive: options.selfExtractingArchive,
+			extractDataFromPage: options.extractDataFromPage,
+			preventAppendedData: options.preventAppendedData,
+			includeBOM: options.includeBOM,
+			insertMetaCSP: options.insertMetaCSP,
+			insertCanonicalLink: options.insertCanonicalLink,
+			insertMetaNoIndex: options.insertMetaNoIndex,
+			insertSingleFileComment: options.insertSingleFileComment,
+			removeSavedDate: options.removeSavedDate
+		});
+		if (options.dumpContent && !options.output) {
+			await stdout.write(content);
+		} else {
+			let outputFilename = options.output || archiveTasks[0].filename || "archive.html";
+			if (options.selfExtractingArchive) {
+				outputFilename = outputFilename.replace(/\.zip$/, ".html");
+			}
+			await writeOutputFile(outputFilename, content, options);
+		}
+	}
+	await remove(archiveTempDirectory, { recursive: true });
+}
+
 function runTasks() {
 	const availableTasks = tasks.filter(task => !task.status).length;
 	const processingTasks = tasks.filter(task => task.status == STATE_PROCESSING).length;
@@ -171,6 +231,12 @@ async function runNextTask() {
 		const options = task.options;
 		const taskOptions = JSON.parse(JSON.stringify(options));
 		taskOptions.url = task.url;
+		if (taskOptions.crawlSaveArchive) {
+			taskOptions.selfExtractingArchive = false;
+			taskOptions.extractDataFromPage = false;
+			taskOptions.createRootDirectory = false;
+			taskOptions.archiveFilename = archiveTempDirectory + "/" + tasks.indexOf(task) + ".zip";
+		}
 		task.status = STATE_PROCESSING;
 		await saveTasks();
 		task.promise = capturePage(taskOptions);
@@ -178,6 +244,8 @@ async function runNextTask() {
 		task.status = STATE_PROCESSED;
 		if (pageData) {
 			task.filename = pageData.filename;
+			task.title = pageData.title;
+			task.archiveFilename = pageData.archiveFilename;
 			if (options.crawlLinks && testMaxDepth(task)) {
 				const urls = pageData.links;
 				let newTasks = await Promise.all(urls.map(url => createTask(url, options, task, task.rootTaskURL || task.url)));
@@ -289,6 +357,11 @@ async function capturePage(options) {
 			await writeTextFile(options.debugMessagesFile, pageData.debugMessages.map(([timestamp, message]) =>
 				`[${new Date(timestamp).toISOString()}] ${message.join(" ")}`).join("\n"));
 		}
+		if (options.archiveFilename) {
+			await writeFile(options.archiveFilename, content);
+			pageData.archiveFilename = options.archiveFilename;
+			return pageData;
+		}
 		if (options.outputJson) {
 			if (content instanceof Uint8Array) {
 				pageData.content = undefined;

package/test/e2e/crawl-save-archive.test.js

@@ -0,0 +1,177 @@
+/* global URL, TextDecoder */
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { createServer } from "node:http";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { mkdtemp, readdir, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import process from "node:process";
+import { configure, ZipReader, Uint8ArrayReader, TextWriter } from "../../lib/single-file-archive.js";
+
+const execFileAsync = promisify(execFile);
+const cliDirectory = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+const TEST_TIMEOUT = 120000;
+
+const crawlPromises = new Map();
+
+test("crawled pages are merged into a single self-extracting archive", { timeout: TEST_TIMEOUT }, async () => {
+	const { filenames, entryNames, data, stderr } = await getCrawlResult();
+	assert.deepEqual(filenames, ["archive.html"], "stderr: " + stderr);
+	assert.ok(entryNames.includes("index.html"));
+	assert.ok(entryNames.includes("pages/2/index.html"));
+	assert.ok(entryNames.includes("pages/3/index.html"));
+	assert.ok(entryNames.includes("sfz-pages.json"));
+	const prelude = new TextDecoder("windows-1252").decode(data.subarray(0, 64));
+	assert.ok(prelude.startsWith("<!DOCTYPE html><html data-sfz>"));
+});
+
+test("the pages manifest maps paths to the crawled URLs", { timeout: TEST_TIMEOUT }, async () => {
+	const { manifest, origin } = await getCrawlResult();
+	assert.equal(manifest.pages.length, 3);
+	assert.equal(manifest.pages[0].path, "");
+	assert.equal(manifest.pages[0].url, origin + "/");
+	assert.equal(manifest.pages[0].title, "Top Page");
+	assert.equal(manifest.pages[1].path, "pages/2/");
+	assert.equal(manifest.pages[1].title, "Linked Page");
+	assert.equal(manifest.pages[2].path, "pages/3/");
+	assert.equal(manifest.pages[2].title, "Other & \"Page\"");
+	assert.ok(manifest.pages[1].originalUrls.includes(origin + "/page.html"));
+});
+
+test("merged page entries can be extracted", { timeout: TEST_TIMEOUT }, async () => {
+	const { entries } = await getCrawlResult();
+	const entry = entries.find(entry => entry.filename == "pages/2/index.html");
+	const content = await entry.getData(new TextWriter());
+	assert.ok(content.includes("Linked Page"));
+});
+
+test("--crawl-save-archive-dedup replaces duplicate resources with symlink aliases", { timeout: TEST_TIMEOUT }, async () => {
+	const { manifest, entries } = await getCrawlResult(true);
+	const aliasNames = Object.keys(manifest.aliases || {});
+	assert.equal(aliasNames.length, 2);
+	for (const aliasName of aliasNames) {
+		const canonicalFilename = manifest.aliases[aliasName];
+		assert.ok(!canonicalFilename.startsWith("pages/"));
+		assert.ok(entries.find(entry => entry.filename == canonicalFilename));
+		const aliasEntry = entries.find(entry => entry.filename == aliasName);
+		assert.equal(aliasEntry.unixMode & 0o170000, 0o120000);
+		assert.equal(aliasEntry.versionMadeBy >> 8, 3);
+		const target = await aliasEntry.getData(new TextWriter());
+		assert.equal(resolvePath(aliasName, target), canonicalFilename);
+	}
+});
+
+test("--crawl-save-archive-dedup requires --crawl-save-archive", { timeout: TEST_TIMEOUT }, async () => {
+	await assert.rejects(
+		execFileAsync(process.execPath, ["single-file-node.js", "http://localhost/", "--compress-content", "--crawl-save-archive-dedup"], { cwd: cliDirectory }),
+		error => error.stderr.includes("--crawl-save-archive-dedup requires --crawl-save-archive"));
+});
+
+test("--crawl-save-archive-mark-unarchived-links sets the manifest flag", { timeout: TEST_TIMEOUT }, async () => {
+	const { manifest } = await getCrawlResult(true);
+	assert.equal(manifest.markUnarchivedLinks, true);
+	const { manifest: defaultManifest } = await getCrawlResult();
+	assert.equal(defaultManifest.markUnarchivedLinks, undefined);
+});
+
+test("--crawl-save-archive-toc stores a table of contents page", { timeout: TEST_TIMEOUT }, async () => {
+	const { entries, entryNames } = await getCrawlResult(true);
+	assert.equal(entryNames.indexOf("sfz-toc.html"), entryNames.length - 2);
+	const tocEntry = entries.find(entry => entry.filename == "sfz-toc.html");
+	const content = await tocEntry.getData(new TextWriter());
+	assert.ok(content.includes("<a href=\"index.html\">Top Page</a>"));
+	assert.ok(content.includes("<a href=\"pages/2/index.html\">Linked Page</a>"));
+	assert.ok(content.includes("<a href=\"pages/3/index.html\">Other &amp; &quot;Page&quot;</a>"));
+	const { entryNames: defaultEntryNames } = await getCrawlResult();
+	assert.ok(!defaultEntryNames.includes("sfz-toc.html"));
+});
+
+test("--crawl-save-archive-toc requires --crawl-save-archive", { timeout: TEST_TIMEOUT }, async () => {
+	await assert.rejects(
+		execFileAsync(process.execPath, ["single-file-node.js", "http://localhost/", "--compress-content", "--crawl-save-archive-toc"], { cwd: cliDirectory }),
+		error => error.stderr.includes("--crawl-save-archive-toc requires --crawl-save-archive"));
+});
+
+test("--crawl-save-archive-mark-unarchived-links requires --crawl-save-archive", { timeout: TEST_TIMEOUT }, async () => {
+	await assert.rejects(
+		execFileAsync(process.execPath, ["single-file-node.js", "http://localhost/", "--compress-content", "--crawl-save-archive-mark-unarchived-links"], { cwd: cliDirectory }),
+		error => error.stderr.includes("--crawl-save-archive-mark-unarchived-links requires --crawl-save-archive"));
+});
+
+test("--crawl-save-archive requires --compress-content", { timeout: TEST_TIMEOUT }, async () => {
+	await assert.rejects(
+		execFileAsync(process.execPath, ["single-file-node.js", "http://localhost/", "--crawl-save-archive"], { cwd: cliDirectory }),
+		error => error.stderr.includes("--crawl-save-archive requires --compress-content"));
+});
+
+function getCrawlResult(dedup = false) {
+	if (!crawlPromises.has(dedup)) {
+		crawlPromises.set(dedup, runCrawl(dedup));
+	}
+	return crawlPromises.get(dedup);
+}
+
+async function runCrawl(dedup) {
+	const server = createServer((request, response) => {
+		const { pathname } = new URL(request.url, "http://localhost");
+		if (pathname === "/") {
+			servePage(response, "Top Page", `
+				<a href="/page.html">page</a>
+				<a href="/other.html">other</a>`);
+		} else if (pathname === "/page.html") {
+			servePage(response, "Linked Page");
+		} else if (pathname === "/other.html") {
+			servePage(response, "Other & \"Page\"");
+		} else if (pathname === "/shared.css") {
+			response.writeHead(200, { "content-type": "text/css" }).end("body { background-color: aliceblue; }");
+		} else {
+			response.writeHead(404).end();
+		}
+	});
+	await new Promise(resolve => server.listen(0, "localhost", resolve));
+	const directory = await mkdtemp(join(tmpdir(), "single-file-test-"));
+	try {
+		const origin = "http://localhost:" + server.address().port;
+		const { stderr } = await execFileAsync(process.execPath, [
+			"single-file-node.js", origin + "/", join(directory, "archive.html"),
+			"--crawl-links",
+			"--crawl-save-archive",
+			"--compress-content",
+			"--max-parallel-workers", "1",
+			...(dedup ? ["--crawl-save-archive-dedup", "--crawl-save-archive-mark-unarchived-links", "--crawl-save-archive-toc"] : [])
+		], { cwd: cliDirectory });
+		const filenames = await readdir(directory);
+		const data = new Uint8Array(await readFile(join(directory, "archive.html")));
+		configure({ useWebWorkers: false });
+		const zipReader = new ZipReader(new Uint8ArrayReader(data));
+		const entries = await zipReader.getEntries();
+		const entryNames = entries.map(entry => entry.filename);
+		const manifestEntry = entries.find(entry => entry.filename == "sfz-pages.json");
+		const manifest = manifestEntry ? JSON.parse(await manifestEntry.getData(new TextWriter())) : undefined;
+		return { filenames, entries, entryNames, manifest, data, origin, stderr };
+	} finally {
+		await rm(directory, { recursive: true });
+		server.close();
+	}
+}
+
+function resolvePath(baseFilename, relativePath) {
+	const segments = baseFilename.split("/").slice(0, -1);
+	for (const segment of relativePath.split("/")) {
+		if (segment == "..") {
+			segments.pop();
+		} else {
+			segments.push(segment);
+		}
+	}
+	return segments.join("/");
+}
+
+function servePage(response, title, body = "") {
+	response.writeHead(200, { "content-type": "text/html" })
+		.end(`<html><head><title>${title}</title><link rel="stylesheet" href="/shared.css"></head><body>${body}</body></html>`);
+}

package/test/e2e/crawl.test.js

@@ -75,6 +75,19 @@ test("mail and script links are not crawled as external links", { timeout: TEST_
 	}
 });
 
+test("crawl options require --crawl-links", { timeout: TEST_TIMEOUT }, async () => {
+	await assert.rejects(
+		execFileAsync(process.execPath, [
+			"single-file-node.js", "http://localhost/",
+			"--crawl-no-parent",
+			"--crawl-max-depth", "2",
+			"--crawl-rewrite-rule", "a b"
+		], { cwd: cliDirectory }),
+		error => error.stderr.includes("--crawl-no-parent requires --crawl-links") &&
+			error.stderr.includes("--crawl-max-depth requires --crawl-links") &&
+			error.stderr.includes("--crawl-rewrite-rule requires --crawl-links"));
+});
+
 function getCrawlResult() {
 	if (!crawlPromise) {
 		crawlPromise = runCrawl();

package/test/unit/archive-packager.test.js

@@ -0,0 +1,55 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { createPagesArchive } from "../../lib/archive-packager.js";
+import { configure, ZipWriter, ZipReader, Uint8ArrayReader, Uint8ArrayWriter, TextReader, TextWriter } from "../../lib/single-file-archive.js";
+
+configure({ useWebWorkers: false });
+
+test("the stored table of contents groups pages by URL path segments", async () => {
+	const archive = await createArchive([
+		{ url: "https://example.com/", title: "Home" },
+		{ url: "https://example.com/docs/api/reader.html", title: "Reader" },
+		{ url: "https://example.com/docs/api/writer.html", title: "" },
+		{ url: "https://example.com/docs/guide.html", title: "Guide <em> & \"quotes\"" }
+	]);
+	const toc = await readEntry(archive, "sfz-toc.html");
+	assert.ok(toc.includes("<a href=\"index.html\">Home</a>"));
+	assert.ok(toc.includes("<details open><summary>docs</summary>"));
+	assert.ok(toc.includes("<summary>api</summary>"));
+	assert.ok(toc.includes("<a href=\"pages/2/index.html\">Reader</a>"));
+	assert.ok(toc.includes(">https://example.com/docs/api/writer.html</a>"), "empty title falls back to the URL");
+	assert.ok(toc.includes("Guide &lt;em&gt; &amp; &quot;quotes&quot;"), "titles are escaped");
+});
+
+test("the table of contents groups by origin when the crawl crossed hosts", async () => {
+	const archive = await createArchive([
+		{ url: "https://example.com/", title: "Home" },
+		{ url: "https://other.example/about.html", title: "About" }
+	]);
+	const toc = await readEntry(archive, "sfz-toc.html");
+	assert.ok(toc.includes("<summary>https://example.com</summary>"));
+	assert.ok(toc.includes("<summary>https://other.example</summary>"));
+});
+
+async function createArchive(pages) {
+	return createPagesArchive(pages.map(page => ({
+		url: page.url,
+		originalUrls: [page.url],
+		title: page.title,
+		getData: () => createPageData(page)
+	})), { tocPage: true, selfExtractingArchive: false });
+}
+
+async function createPageData(page) {
+	const zipWriter = new ZipWriter(new Uint8ArrayWriter());
+	await zipWriter.add("index.html", new TextReader("<!DOCTYPE html><html><head><title>" + page.title + "</title></head><body></body></html>"));
+	return zipWriter.close();
+}
+
+async function readEntry(archive, filename) {
+	const zipReader = new ZipReader(new Uint8ArrayReader(archive));
+	const entries = await zipReader.getEntries();
+	const entry = entries.find(entry => entry.filename == filename);
+	assert.ok(entry, filename + " entry exists");
+	return entry.getData(new TextWriter());
+}

package/.github/workflows/docker-publish.yml

@@ -1,29 +0,0 @@
-name: Publish Docker image
-
-on:
-  release:
-    types: [published]
-
-jobs:
-  docker:
-    runs-on: ubuntu-latest
-    steps:
-      -
-        name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-      -
-        name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-      -
-        name: Login to Docker Hub
-        uses: docker/login-action@v3
-        with:
-          username: ${{ secrets.DOCKER_USERNAME }}
-          password: ${{ secrets.DOCKER_PASSWORD }}
-      -
-        name: Build and push
-        uses: docker/build-push-action@v6
-        with:
-          push: true
-          tags: ${{ secrets.DOCKER_USERNAME }}/singlefile:latest
-          platforms: linux/amd64,linux/arm64