single-file-core 1.5.117 → 1.5.118

package/modules/css-rules-minifier.js

@@ -71,7 +71,8 @@ const ANONYMOUS_LAYER_PLACEHOLDER = "\u0000";
 
 export {
 	process,
-	isUnsupportedPropertyValue
+	isUnsupportedPropertyValue,
+	isUnsupportedVendorValue
 };
 
 function isUnsupportedPropertyValue(property, value) {
@@ -79,6 +80,30 @@ function isUnsupportedPropertyValue(property, value) {
 	return Boolean(!match.matched && match.error && match.error.name !== UNKNOWN_PROPERTY_ERROR_NAME);
 }
 
+// A vendor-prefixed VALUE is dropped only when this browser cannot actually use it. Dropping every
+// one of them was the overreach: `display:-ms-flexbox` is genuinely dead here and worth removing,
+// but `display:-webkit-box` is alive and load-bearing — `-webkit-line-clamp` does nothing without
+// it, so a page keeps its clamp rules and silently stops clamping. On anandabazar.com that expanded
+// 80 clamped headlines by a line each and moved the page 150px, with nothing wrong-looking left in
+// the saved CSS. Four of the five sites in a fifteen-site sweep that use line-clamp were affected.
+function isUnsupportedVendorValue(property, name) {
+	if (!name.startsWith(VENDOR_PREFIX)) {
+		return false;
+	}
+	// unknown fails open, the same rule the unknown-property branch follows: a dropped valid
+	// declaration breaks rendering, a kept invalid one is ignored. With no browser to ask, keep.
+	if (!globalThis.CSS || !globalThis.CSS.supports) {
+		return false;
+	}
+	try {
+		return !globalThis.CSS.supports(property, name);
+	// eslint-disable-next-line no-unused-vars
+	} catch (error) {
+		// a value CSS.supports will not even take as an argument tells us nothing either way
+		return false;
+	}
+}
+
 function process(doc, stylesheets) {
 	const docContext = {
 		doc,
@@ -497,7 +522,8 @@ function collectDeclarationItemsForElement(element, docContext) {
 			hasValueChildNodes &&
 			value.children.size == 1) {
 			if (value.children.head.data.name) {
-				isInvalidValue = value.children.head.data.name.startsWith(VENDOR_PREFIX) || INVALID_CSS_ESCAPE_TEST.test(value.children.head.data.name);
+				const name = value.children.head.data.name;
+				isInvalidValue = isUnsupportedVendorValue(property, name) || INVALID_CSS_ESCAPE_TEST.test(name);
 			} if (!property.startsWith(VENDOR_PREFIX) && value.children.head.data.value) {
 				try {
 					isInvalidValue = isUnsupportedPropertyValue(property, value);

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "single-file-core",
-  "version": "1.5.117",
+  "version": "1.5.118",
   "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",
+    "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",
     "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/test/sfz-harness/README.md

@@ -29,6 +29,8 @@ any check failed.
 | `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. |
 | `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/css-property-filter.js

@@ -10,7 +10,7 @@
 // The rule this pins: unknown must fail open. A dropped valid declaration breaks rendering; a kept
 // invalid one is ignored by the browser.
 import * as cssTree from "../../vendor/css-tree.js";
-import { isUnsupportedPropertyValue } from "../../modules/css-rules-minifier.js";
+import { isUnsupportedPropertyValue, isUnsupportedVendorValue } from "../../modules/css-rules-minifier.js";
 
 // valid declarations whose property the vendored css-tree does not know. Every one of these was
 // deleted before the fix. The SVG paint-server and filter properties are the ones that matter in
@@ -77,6 +77,34 @@ const wrongValue = cssTree.lexer.matchProperty("margin-trim", cssTree.parse("blo
 check("unknown property reports SyntaxReferenceError", unknownProperty.error && unknownProperty.error.name, "SyntaxReferenceError");
 check("wrong value reports SyntaxMatchError", wrongValue.error && wrongValue.error.name, "SyntaxMatchError");
 
+// The same failure as above, one step earlier and on VALUES rather than properties. Before the fix
+// the call site dropped any single-identifier value beginning with "-", asking nothing: the test
+// for a dead `display:-ms-flexbox` also deleted a live `display:-webkit-box`. That one costs more
+// than it looks, because `-webkit-line-clamp` does nothing without it and both of ITS declarations
+// survive — being unknown properties, they already fail open — so the rule keeps a clamp it no
+// longer applies. Four of the five sites in a fifteen-site sweep that use line-clamp were affected;
+// on one of them 80 headlines each grew a line and the page moved 150px.
+//
+// CSS.supports is the authority and Deno has none, so it is stubbed here. That is also the point of
+// the last group: with no browser to ask, this must KEEP, which is the same fail-open rule as above.
+const CHROME_SUPPORTS = new Set(["display:-webkit-box", "display:-webkit-inline-box", "-webkit-box-orient:vertical"]);
+const originalCSS = globalThis.CSS;
+globalThis.CSS = { supports: (property, value) => CHROME_SUPPORTS.has(property + ":" + value) };
+try {
+	// alive in this browser, and load-bearing
+	check("vendor value kept: display: -webkit-box", isUnsupportedVendorValue("display", "-webkit-box"), false);
+	check("vendor value kept: display: -webkit-inline-box", isUnsupportedVendorValue("display", "-webkit-inline-box"), false);
+	// dead in this browser, and the reason the check exists at all — the fix must not disable it
+	check("vendor value dropped: display: -ms-flexbox", isUnsupportedVendorValue("display", "-ms-flexbox"), true);
+	check("vendor value dropped: display: -moz-box", isUnsupportedVendorValue("display", "-moz-box"), true);
+	// not vendor-prefixed, so this predicate must not have an opinion either way
+	check("non-vendor value untouched: display: flex", isUnsupportedVendorValue("display", "flex"), false);
+	check("non-vendor value untouched: color: nonsense", isUnsupportedVendorValue("color", "nonsense"), false);
+} finally {
+	globalThis.CSS = originalCSS;
+}
+check("no browser to ask keeps the value", isUnsupportedVendorValue("display", "-ms-flexbox"), false);
+
 if (failed) {
 	console.log("FAILED");
 	Deno.exit(1);

package/test/sfz-harness/pages-archive.js

@@ -0,0 +1,177 @@
+// createPagesArchive packs several single-page archives into one. Nothing exercised it until this
+// file: the module was reachable only through a crawl, so a change to the folder layout, the
+// manifest, the deduplication or the table of contents broke nothing that anyone ran.
+//
+// Three of its rules are worth stating, because they look arbitrary in the code:
+//
+//   - the first page is stored at the ROOT and the others under pages/N/. The root page is what a
+//     reader opens, so it cannot be moved into a folder without changing every relative URL the
+//     capture already resolved.
+//   - a duplicate entry becomes a SYMLINK rather than being dropped. The router resolves it from
+//     the alias map in the manifest and never reads it, but a plain unzip has to produce complete
+//     page folders, and only a symlink gives both.
+//   - the titles written into the table of contents are CRAWLED, so they are attacker-controlled
+//     text going into an href attribute and into element content. Both escapers are checked here.
+import "./dom-stub.js";
+import { makePageData, makeOptions, runProcess } from "./common.js";
+import { createPagesArchive } from "../../processors/compression/compression-packager.js";
+import { ZipReader, BlobReader, TextWriter } from "../../vendor/zip/zip.js";
+
+// a title as it comes back from a crawl: the quote closes the href it is written into, the angle
+// bracket opens an element, and the ampersand is what a naive escaper double-encodes
+const HOSTILE_TITLE = "Intro & \"start\" <b>";
+const SYMLINK_UNIX_MODE = 0o120777;
+
+let failed = false;
+
+const pages = [
+	await makePage(1, { url: "https://example.com/docs/intro.html", title: HOSTILE_TITLE, originalUrls: ["https://example.com/docs/"] }),
+	await makePage(2, { url: "https://example.com/docs/api/reference.html", title: "Reference" })
+];
+
+{
+	const entries = await readArchive(await createPagesArchive(pages, packagerOptions()));
+	const manifest = JSON.parse(await readEntry(entries, "sfz-pages.json"));
+	check("the first page is stored at the root of the archive", entries.has("index.html"), true);
+	check("a later page is stored in a folder of its own", entries.has("pages/2/index.html"), true);
+	check("the manifest names the path of every page",
+		manifest.pages.map(page => page.path).join(" "), " pages/2/");
+	check("the manifest names the url of every page",
+		manifest.pages.map(page => page.url).join(" "), "https://example.com/docs/intro.html https://example.com/docs/api/reference.html");
+	check("the manifest keeps the title a page was saved with", manifest.pages[0].title, HOSTILE_TITLE);
+	// a page reached through several urls has to answer to all of them, or a link to the url the
+	// crawler did not settle on leaves the archive
+	check("the manifest keeps the urls a page was reached by",
+		(manifest.pages[0].originalUrls || []).join(" "), "https://example.com/docs/");
+}
+
+// the router reads these two out of the manifest, and "auto" is the absence of a choice rather
+// than a value: writing it would pin the default of the day into every archive
+{
+	const entries = await readArchive(await createPagesArchive(pages, packagerOptions({ markUnarchivedLinks: true, pageTransitions: "slide" })));
+	const manifest = JSON.parse(await readEntry(entries, "sfz-pages.json"));
+	check("the manifest records that unarchived links are marked", manifest.markUnarchivedLinks, true);
+	check("the manifest records the page transition it was given", manifest.pageTransitions, "slide");
+}
+
+{
+	const entries = await readArchive(await createPagesArchive(pages, packagerOptions({ pageTransitions: "auto" })));
+	const manifest = JSON.parse(await readEntry(entries, "sfz-pages.json"));
+	check("the default page transition is not written to the manifest", "pageTransitions" in manifest, false);
+}
+
+// Both fixtures declare the same stylesheet, so pages/2/styles.css is byte-for-byte the entry
+// already written at the root.
+{
+	const entries = await readArchive(await createPagesArchive(pages, packagerOptions({ dedupPages: true })));
+	const manifest = JSON.parse(await readEntry(entries, "sfz-pages.json"));
+	const duplicate = entries.get("pages/2/styles.css");
+	check("a repeated entry is still present after deduplication", Boolean(duplicate), true);
+	check("the repeated entry points at the one that was kept",
+		await readEntry(entries, "pages/2/styles.css"), "../../styles.css");
+	// without the mode, tar and unzip write the path as the FILE CONTENT and the page folder ends
+	// up holding a text file where a stylesheet belongs
+	check("the repeated entry carries the unix symlink mode",
+		duplicate.externalFileAttributes >>> 16, SYMLINK_UNIX_MODE);
+	// read through a default, so that a manifest with no aliases at all reports as a failed check
+	// rather than throwing and taking every check after it down with it
+	check("the manifest maps the repeated entry to the one it aliases",
+		(manifest.aliases || {})["pages/2/styles.css"], "styles.css");
+	check("an entry that is not repeated is left alone",
+		"pages/2/index.html" in (manifest.aliases || {}), false);
+}
+
+{
+	const entries = await readArchive(await createPagesArchive(pages, packagerOptions()));
+	const manifest = JSON.parse(await readEntry(entries, "sfz-pages.json"));
+	check("nothing is aliased when deduplication is off", "aliases" in manifest, false);
+	check("a repeated entry is stored whole when deduplication is off",
+		(await readEntry(entries, "pages/2/styles.css")).includes("font-family"), true);
+}
+
+{
+	const entries = await readArchive(await createPagesArchive(pages, packagerOptions({ tocPage: true })));
+	const toc = await readEntry(entries, "sfz-toc.html");
+	check("the table of contents page is stored when it is asked for", entries.has("sfz-toc.html"), true);
+	check("the table of contents links to the page at the root", toc.includes("href=\"index.html\""), true);
+	check("the table of contents links to the page in its folder", toc.includes("href=\"pages/2/index.html\""), true);
+	// the escaped form has to be there AND the raw form has to be absent: a title written twice,
+	// once escaped and once not, passes any check that only looks for the escaped one
+	check("a crawled title is escaped into the table of contents",
+		toc.includes("Intro &amp; &quot;start&quot; &lt;b&gt;"), true);
+	check("a crawled title is not also written raw", toc.includes(HOSTILE_TITLE), false);
+	// the groups are details/summary and nothing else on purpose: the page has to stay usable
+	// after a plain unzip, where no script runs
+	check("pages are grouped by the segments of their path",
+		toc.includes("<details open><summary>docs</summary>"), true);
+	check("the table of contents needs no script", toc.includes("<script"), false);
+}
+
+{
+	const entries = await readArchive(await createPagesArchive(pages, packagerOptions()));
+	check("no table of contents page is stored when it is not asked for", entries.has("sfz-toc.html"), false);
+}
+
+// one origin is the whole archive's origin and adding it to every path would say nothing; two
+// origins make it the first thing that tells two pages apart
+{
+	const mixedPages = [pages[0], await makePage(3, { url: "https://other.example.org/notes.html", title: "Notes" })];
+	const entries = await readArchive(await createPagesArchive(mixedPages, packagerOptions({ tocPage: true })));
+	const toc = await readEntry(entries, "sfz-toc.html");
+	check("pages from several origins are grouped by origin",
+		toc.includes("<summary>https://example.com</summary>"), true);
+}
+
+// the prelude list is read without decompressing anything, by tools that never extract the
+// archive, so it is the only place the pages are named in plain text
+{
+	const bytes = await createPagesArchive(pages, packagerOptions({ pageList: true }));
+	const prelude = new TextDecoder("windows-1252").decode(bytes);
+	check("the prelude lists the pages when the page list is asked for",
+		prelude.includes("<a href=\"https://example.com/docs/api/reference.html\">Reference</a>"), true);
+	// anchored on the link, not on the escaped text alone: the same title is also written into the
+	// wrapper's own <title>, which the writer escapes the same way, so a search for the escaped
+	// form anywhere in the archive passes even when the page list itself is written raw
+	check("the prelude escapes a crawled title too",
+		prelude.includes("<a href=\"https://example.com/docs/intro.html\">Intro &#38; &#34;start&#34; &#60;b&#62;</a>"), true);
+	check("the prelude is not written when the page list is not asked for",
+		new TextDecoder("windows-1252").decode(await createPagesArchive(pages, packagerOptions())).includes("<nav><ul>"), false);
+}
+
+console.log(failed ? "\nsome checks FAILED" : "\nall checks passed");
+Deno.exit(failed ? 1 : 0);
+
+// each page of a multi-page archive is a single-page archive, so the fixtures are built by the
+// writer the rest of the harness already covers
+async function makePage(seed, { url, title, originalUrls }) {
+	const pageData = makePageData(seed, 2 * 1024);
+	pageData.title = title;
+	const { bytes } = await runProcess(pageData, makeOptions({ url }));
+	return { url, title, originalUrls, getData: async () => bytes };
+}
+
+function packagerOptions(overrides = {}) {
+	return {
+		selfExtractingArchive: true,
+		extractDataFromPage: true,
+		zipScript: "/* zip script stub */",
+		...overrides
+	};
+}
+
+async function readArchive(bytes) {
+	const zipReader = new ZipReader(new BlobReader(new Blob([bytes])));
+	const entries = await zipReader.getEntries();
+	await zipReader.close();
+	return new Map(entries.map(entry => [entry.filename, entry]));
+}
+
+function readEntry(entries, filename) {
+	return entries.get(filename).getData(new TextWriter());
+}
+
+function check(label, actual, expected) {
+	const ok = actual === expected;
+	console.log(`${ok ? "PASS" : "FAIL"} ${label}: ${actual}${ok ? "" : " (expected " + expected + ")"}`);
+	failed ||= !ok;
+}