single-file-core 1.6.0 → 1.6.2

package/test/sfz-harness/check-determinism.js

@@ -1,57 +0,0 @@
-import { makePageData, makeOptions, runProcess, freezeDate, buildZip, generateContent, sameBytes, firstDifference } from "./common.js";
-
-const SEED = 1;
-const SIZE = 512 * 1024;
-let failed = false;
-
-function report(label, ok, detail = "") {
-	console.log(`${ok ? "PASS" : "FAIL"} ${label}${detail ? " — " + detail : ""}`);
-	failed ||= !ok;
-}
-
-{
-	const restoreDate = freezeDate();
-	try {
-		const first = await runProcess(makePageData(SEED, SIZE), makeOptions());
-		const second = await runProcess(makePageData(SEED, SIZE), makeOptions());
-		report("process() deterministic with frozen Date", sameBytes(first.bytes, second.bytes),
-			`sizes ${first.bytes.length}/${second.bytes.length}, first diff at ${firstDifference(first.bytes, second.bytes)}`);
-	} finally {
-		restoreDate();
-	}
-}
-
-{
-	const first = await runProcess(makePageData(SEED, SIZE), makeOptions());
-	await new Promise(resolve => setTimeout(resolve, 5));
-	const second = await runProcess(makePageData(SEED, SIZE), makeOptions());
-	report("process() NON-deterministic with real Date (archiveTime)", !sameBytes(first.bytes, second.bytes),
-		"confirms archiveTime must be pinned across retries");
-}
-
-const content = generateContent(SEED, SIZE);
-const engines = [
-	{ label: "vendor CompressionStream", config: { useCompressionStream: true } },
-	{ label: "vendor level 1 (no CompressionStream)", config: { useCompressionStream: false, level: 1 } },
-	{ label: "vendor level 9 (no CompressionStream)", config: { useCompressionStream: false, level: 9 } }
-];
-const outputs = [];
-for (const { label, config } of engines) {
-	const first = await buildZip(content, config);
-	const second = await buildZip(content, config);
-	report(`${label} deterministic`, sameBytes(first, second), `${first.length} bytes`);
-	outputs.push({ label, bytes: first });
-}
-const storeFallback = outputs[1].bytes.length >= content.length;
-report("no silent store fallback without CompressionStream", !storeFallback, `${outputs[1].bytes.length} bytes for ${content.length} input`);
-const levelLever = !storeFallback && !sameBytes(await rawEntryData(outputs[1].bytes), await rawEntryData(outputs[2].bytes));
-console.log(`INFO level lever ${levelLever ? "AVAILABLE (levels produce distinct streams)" : "ABSENT (native streams ignore level; perturbation levers: store/deflate flip + text input tweaks)"}`);
-
-async function rawEntryData(bytes) {
-	const { ZipReader, BlobReader, Uint8ArrayWriter } = await import("../../vendor/zip/zip.js");
-	const reader = new ZipReader(new BlobReader(new Blob([bytes])));
-	const [entry] = await reader.getEntries();
-	return entry.getData(new Uint8ArrayWriter(), { passThrough: true });
-}
-
-Deno.exit(failed ? 1 : 0);

package/test/sfz-harness/common.js

@@ -1,154 +0,0 @@
-import { process } from "../../processors/compression/compression.js";
-import { configure, ZipWriter, BlobWriter, TextReader } from "../../vendor/zip/zip.js";
-
-configure({ useWebWorkers: false });
-
-const RealDate = Date;
-const FIXED_TIME = 1755129600000;
-const FIXED_DATE = new RealDate(FIXED_TIME);
-
-const WORDS = ("lorem ipsum dolor sit amet consectetur adipiscing elit sed do eiusmod tempor incididunt " +
-	"ut labore et dolore magna aliqua enim ad minim veniam quis nostrud exercitation ullamco").split(" ");
-
-export {
-	process,
-	RealDate,
-	FIXED_TIME,
-	FIXED_DATE,
-	mulberry32,
-	generateContent,
-	makePageData,
-	makeOptions,
-	runProcess,
-	freezeDate,
-	buildZip,
-	blobBytes,
-	sameBytes,
-	firstDifference,
-	scanDelimiters
-};
-
-function mulberry32(seed) {
-	let state = seed >>> 0;
-	return () => {
-		state = (state + 0x6D2B79F5) >>> 0;
-		let t = state;
-		t = Math.imul(t ^ (t >>> 15), t | 1);
-		t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
-		return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
-	};
-}
-
-function generateContent(seed, targetLength) {
-	const rand = mulberry32(seed);
-	const parts = ["seed " + seed];
-	let length = 0;
-	while (length < targetLength) {
-		const token = rand() < 0.25 ?
-			((rand() * 0x100000000) >>> 0).toString(36) :
-			WORDS[(rand() * WORDS.length) | 0];
-		parts.push(token);
-		length += token.length + 1;
-		if (!(parts.length % 16)) {
-			parts.push("\n");
-			length += 2;
-		}
-	}
-	return parts.join(" ");
-}
-
-function makePageData(seed, targetLength) {
-	return {
-		title: "fixture " + seed,
-		doctype: "<!DOCTYPE html>",
-		content: "<html><body><p>" + generateContent(seed, targetLength) + "</p></body></html>",
-		resources: {
-			stylesheets: [{ name: "styles.css", extension: ".css", content: "body { font-family: serif; color: rgb(20, 20, 20) }" }],
-			images: []
-		}
-	};
-}
-
-function makeOptions(overrides = {}) {
-	return {
-		selfExtractingArchive: true,
-		extractDataFromPage: true,
-		zipScript: "/* zip script stub */",
-		url: "https://example.com/",
-		...overrides
-	};
-}
-
-async function runProcess(pageData, options, lastModDate = FIXED_DATE) {
-	const blob = await process(pageData, options, lastModDate);
-	return {
-		bytes: await blobBytes(blob),
-		fallbackTag: options.extractDataFromPageTags ? options.extractDataFromPageTags[0] : null,
-		extractionDisabled: options.extractDataFromPage === false
-	};
-}
-
-function freezeDate() {
-	class FrozenDate extends RealDate {
-		constructor(...args) {
-			if (args.length) {
-				super(...args);
-			} else {
-				super(FIXED_TIME);
-			}
-		}
-		static now() {
-			return FIXED_TIME;
-		}
-	}
-	globalThis.Date = FrozenDate;
-	return () => {
-		globalThis.Date = RealDate;
-	};
-}
-
-async function buildZip(content, { useCompressionStream, level }) {
-	const writer = new ZipWriter(new BlobWriter("application/zip"), {
-		useCompressionStream,
-		level,
-		lastModDate: FIXED_DATE
-	});
-	await writer.add("data.txt", new TextReader(content));
-	return blobBytes(await writer.close());
-}
-
-async function blobBytes(blob) {
-	return new Uint8Array(await blob.arrayBuffer());
-}
-
-function sameBytes(a, b) {
-	if (a.length != b.length) {
-		return false;
-	}
-	return firstDifference(a, b) == -1;
-}
-
-function firstDifference(a, b) {
-	const length = Math.min(a.length, b.length);
-	for (let index = 0; index < length; index++) {
-		if (a[index] != b[index]) {
-			return index;
-		}
-	}
-	return a.length == b.length ? -1 : length;
-}
-
-function scanDelimiters(bytes) {
-	const text = new TextDecoder("windows-1252").decode(bytes);
-	const found = [];
-	for (const [name, regExp] of [
-		["comment open", /<!--/i],
-		["comment close", /--!?>/i]
-	]) {
-		const match = text.match(regExp);
-		if (match) {
-			found.push({ name, index: match.index });
-		}
-	}
-	return found;
-}

package/test/sfz-harness/content-type-sniffing.js

@@ -1,83 +0,0 @@
-// `core/util.js` used to trust any Content-Type the server sent and sniff the bytes only when the
-// header was missing or `application/octet-stream`. science.org serves its woff2 files as
-// `text/plain;charset=UTF-8` — 12 of them — and every one was embedded as `data:text/plain`, which
-// costs twice: a browser with no `format()` hint in the `@font-face` rule has nothing left to
-// identify the font by, and the SFZ writer deflates a file that is already Brotli-compressed
-// because it decides compression from the content type.
-//
-// The rule now: a magic-byte match wins over the header, and the header is kept only when nothing
-// matches. That raises the bar for the sniffer's own rules, which is why `video/mp2t` no longer
-// matches on a single `0x47` byte — as a last resort behind a missing header that was tolerable,
-// as an override of a correct header it would relabel any video whose first byte is `G`. It now
-// wants the sync byte at the 188-byte packet stride, and the case below is the regression guard.
-/* global Response */
-
-import "./dom-stub.js";
-// util.js pulls in the page-world hooks, which register a document listener as they are evaluated.
-// None of it is exercised here; the stubs exist so that importing util.js is possible at all
-globalThis.window = globalThis.window || {};
-globalThis.document = globalThis.document || {};
-globalThis.Document = globalThis.Document || class { };
-globalThis.MutationObserver = globalThis.MutationObserver || class {
-	observe() { }
-};
-const { getInstance } = await import("./../../core/util.js");
-
-const FONT_URL = "https://example.com/font";
-const WOFF2 = bytes([0x77, 0x4F, 0x46, 0x32], 64);
-const PNG = bytes([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A], 64);
-const AVIF = bytes([0, 0, 0, 0x20, 0x66, 0x74, 0x79, 0x70, 0x61, 0x76, 0x69, 0x66], 64);
-const WEBP2 = bytes([0x77, 0x70, 0x32, 0x20], 64);
-const HEIF_MIF1 = bytes([0, 0, 0, 0x20, 0x66, 0x74, 0x79, 0x70, 0x6D, 0x69, 0x66, 0x31], 64);
-const NOT_A_TRANSPORT_STREAM = bytes([0x47, 0x53, 0x54, 0x00], 512);
-
-let failed = false;
-
-// [label, bytes, expectedType, the Content-Type the server sent, the type that must reach the data URI]
-const CASES = [
-	["a woff2 served as text/plain is embedded as font/woff2", WOFF2, "font", "text/plain;charset=UTF-8", "font/woff2"],
-	["a woff2 served as font/woff2 is unchanged", WOFF2, "font", "font/woff2", "font/woff2"],
-	["a woff2 served with no type at all is embedded as font/woff2", WOFF2, "font", undefined, "font/woff2"],
-	["a png served as text/plain is embedded as image/png", PNG, "image", "text/plain", "image/png"],
-	["an avif served as application/octet-stream is embedded as image/avif", AVIF, "image", "application/octet-stream", "image/avif"],
-	// "mif1" is the generic HEIF brand and an AVIF may carry it too, so it identifies nothing on
-	// its own: claiming HEIC here would relabel an AVIF as a format no browser decodes
-	["an ambiguous HEIF brand keeps the type the server sent", HEIF_MIF1, "image", "image/avif", "image/avif"],
-	// nothing matches these bytes, so the header is all there is and it has to survive
-	["a format the sniffer does not know keeps the type the server sent", WEBP2, "image", "image/webp2", "image/webp2"],
-	["a format the sniffer does not know and no type falls back to octet-stream", WEBP2, "image", undefined, "application/octet-stream"],
-	// the byte is 0x47, the packet stride is not, so this is not a transport stream
-	["a video starting with G is not relabelled as mp2t", NOT_A_TRANSPORT_STREAM, "video", "video/quicktime", "video/quicktime"]
-];
-
-for (const [label, data, expectedType, sentContentType, expectedContentType] of CASES) {
-	const { data: dataURI } = await fetchContent(data, expectedType, sentContentType);
-	check(label, readDataURIType(dataURI), expectedContentType);
-}
-
-console.log(failed ? "\nsome checks FAILED" : "\nall checks passed");
-Deno.exit(failed ? 1 : 0);
-
-function fetchContent(data, expectedType, contentType) {
-	const util = getInstance({
-		fetch: async () => new Response(data, { headers: contentType ? { "content-type": contentType } : {} })
-	});
-	return util.getContent(FONT_URL, { asBinary: true, inline: true, expectedType });
-}
-
-function readDataURIType(dataURI) {
-	const indexSeparator = dataURI.indexOf(";");
-	return dataURI.substring("data:".length, indexSeparator == -1 ? dataURI.indexOf(",") : indexSeparator);
-}
-
-function bytes(signature, length) {
-	const value = new Uint8Array(length);
-	value.set(signature);
-	return value;
-}
-
-function check(label, actual, expected) {
-	const ok = actual === expected;
-	console.log(`${ok ? "PASS" : "FAIL"} ${label}: ${actual}${ok ? "" : " (expected " + expected + ")"}`);
-	failed ||= !ok;
-}

package/test/sfz-harness/css-fonts-minifier.js

@@ -1,235 +0,0 @@
-// removeUnusedFonts decides which @font-face rules to keep by reading the font-family declarations
-// out of the stylesheets. When a family is written as var(--name), the value has to be resolved
-// first, and the only resolution the module had was getComputedStyle(body).getPropertyValue(name).
-// Custom properties inherit downward, so that answers for a property declared on :root and returns
-// nothing for one declared on any descendant — and a single unresolved variable anywhere sets
-// unusedFonts to [], which switches pruning off for the WHOLE document. One declaration moved from
-// :root to .card took a probe page from 7,611 to 43,648 bytes with every unused font embedded.
-//
-// The fix keeps the computed value as the first answer and falls back to the union of every value
-// the document declares for that property. The union is a superset of what any one element sees,
-// so it can only keep too much, never too little — and options.usedFonts, which comes from the
-// rendered computed styles, gates the result anyway.
-//
-// What happens when even the union cannot answer changed with it. Switching pruning off for the
-// whole document was never a policy about uncertainty — a page naming its families plainly has
-// always dropped a face it had not drawn yet, and only a page holding one unreadable value anywhere
-// was spared, all of it. So the rendered list decides in that case too: a family the browser
-// resolved when it drew the page is in that list whatever the stylesheets can be made to say. The
-// one case that still keeps everything is the one where the rendering itself is missing.
-//
-// The other var() defects this pins, all found alongside it:
-//   - custom property names are case-sensitive; they were lowercased with the family names, so
-//     var(--ProbeFont) never resolved, not even from :root
-//   - the "font" shorthand's var() regexp required var(--name) exactly, so a fallback in it made
-//     the shorthand unreadable and switched pruning off
-//   - a var() fallback is one raw token, so a list in it was pushed as a single mangled name and
-//     the families it holds were dropped
-import * as cssTree from "../../vendor/css-tree.js";
-
-// the module reaches core/helper.js, which pulls in the frame hooks, and those install themselves
-// against window and document as they are evaluated: the stubs go in before the dynamic import
-globalThis.window = globalThis;
-globalThis.document = {};
-globalThis.Document = class Document { };
-globalThis.MutationObserver = class MutationObserver { observe() { } };
-const { process: removeUnusedFonts } = await import("../../modules/css-fonts-minifier.js");
-
-const FONT_FACES = `
-	@font-face{font-family:"UsedOne";src:url(one.woff2)}
-	@font-face{font-family:"UsedTwo";src:url(two.woff2)}
-	@font-face{font-family:"UsedThree";src:url(three.woff2)}
-	@font-face{font-family:"Unused";src:url(unused.woff2)}`;
-
-// what the rendered page reports as actually drawn: [family, weight, style, variant]. A family
-// missing from this list is dropped whatever the stylesheets say, so it holds every family the
-// tests below may legitimately keep
-const USED_FONTS = [
-	["usedone", "400", "normal", "normal"],
-	["usedtwo", "400", "normal", "normal"],
-	["usedthree", "400", "normal", "normal"]
-];
-
-const ALL_FAMILIES = ["usedone", "usedtwo", "usedthree", "unused"];
-
-// what survives when the stylesheets cannot say which family a value names: the faces the page
-// declares AND the rendering reports having drawn with. It is USED_FONTS that decides there, so a
-// face nothing drew is dropped even though nothing could be shown to name it either
-const RENDERED_FAMILIES = ["usedone", "usedtwo", "usedthree"];
-
-let failures = 0;
-
-check("a plain family name prunes the rest",
-	run({ rules: ".card p{font-family:\"UsedOne\",serif}" }),
-	["usedone"]);
-
-check("a property declared on :root resolves through the computed style",
-	run({ rules: ":root{--probe-font:\"UsedOne\"}.card p{font-family:var(--probe-font),serif}", computed: { "--probe-font": "\"UsedOne\"" } }),
-	["usedone"]);
-
-check("a property declared on a descendant resolves through the declared values",
-	run({ rules: ".card{--probe-font:\"UsedOne\"}.card p{font-family:var(--probe-font),serif}" }),
-	["usedone"]);
-
-check("a mixed-case property name is not lowercased away",
-	run({ rules: ".card{--ProbeFont:\"UsedOne\"}.card p{font-family:var(--ProbeFont),serif}" }),
-	["usedone"]);
-
-check("a property declared inside a media query resolves too",
-	run({ rules: "@media screen{.card{--probe-font:\"UsedOne\"}}.card p{font-family:var(--probe-font),serif}" }),
-	["usedone"]);
-
-check("several declared values are all kept as candidates",
-	run({ rules: ".card{--probe-font:\"UsedOne\"}.note{--probe-font:\"UsedTwo\"}p{font-family:var(--probe-font),serif}" }),
-	["usedone", "usedtwo"]);
-
-check("a fallback list is parsed as a list, not as one name",
-	run({ rules: ":root{--probe-font:\"UsedOne\"}.card p{font-family:var(--probe-font,\"UsedTwo\",\"UsedThree\"),serif}", computed: { "--probe-font": "\"UsedOne\"" } }),
-	["usedone", "usedtwo", "usedthree"]);
-
-check("the font shorthand resolves a uniquely declared property",
-	run({ rules: ".card{--probe-font:\"UsedOne\"}.card p{font:italic 1em var(--probe-font)}" }),
-	["usedone"]);
-
-check("the font shorthand resolves a property written with a fallback",
-	run({ rules: ".card{--probe-font:\"UsedOne\"}.card p{font:italic 1em var(--probe-font,serif)}" }),
-	["usedone"]);
-
-// The other half of the contract: what happens when the value genuinely cannot be determined. The
-// stylesheets no longer decide there — the rendering does. The browser resolved the value when it
-// drew the page, so whatever the property named is in the list of fonts reported as used, and a
-// face absent from that list was drawn by nothing.
-//
-// It used to keep EVERY declared face, and not as a decision about uncertainty: a page naming its
-// families plainly has always dropped a face it had not drawn yet, and only a page holding one
-// value that happened not to parse was spared — the whole document, over one unreadable name. The
-// case these checks still guard is the one below them, where the rendering itself is unavailable.
-check("a property declared nowhere falls back to the fonts that were drawn",
-	run({ rules: ".card p{font-family:var(--set-by-script),serif}" }),
-	RENDERED_FAMILIES);
-
-// the shorthand cannot be substituted with several candidate values, but its var() sits in family
-// position, so the parser hands it back as the family and the union answers it there instead
-check("a font shorthand with several candidates resolves through the family",
-	run({ rules: ".card{--probe-font:\"UsedOne\"}.note{--probe-font:\"UsedTwo\"}p{font:italic 1em var(--probe-font)}" }),
-	["usedone", "usedtwo"]);
-
-// a property holding the whole shorthand is the case the union must NOT touch: its values are not
-// family lists, and reading them as such would name families the document never had
-check("a property holding a whole shorthand falls back to the fonts that were drawn",
-	run({ rules: ".card{--font:italic 1em \"UsedOne\"}.note{--font:italic 1em \"UsedTwo\"}p{font:var(--font)}" }),
-	RENDERED_FAMILIES);
-
-check("a var() nested in a fallback falls back to the fonts that were drawn",
-	run({ rules: ".card{--probe-font:\"UsedOne\"}.card p{font-family:var(--other,var(--probe-font),serif)}" }),
-	RENDERED_FAMILIES);
-
-// the check above leaves the family undetermined because the OUTER property is declared nowhere.
-// A var() written in the font-family itself is split by the AST walk, which hands each branch over
-// separately, so nesting alone was never the problem there. The chain that did give up is a var()
-// inside a property VALUE: it was read one level deep and whatever it named stayed unresolved,
-// which switched pruning off for the whole document
-check("a property whose value is another declared property resolves through it",
-	run({ rules: ".card{--first-font:var(--second-font)}.note{--second-font:\"UsedOne\"}.card p{font-family:var(--first-font),serif}" }),
-	["usedone"]);
-
-// splitting that value on every comma cut this one into "var(--second-font" and "\"UsedTwo\")",
-// two names that resolve to nothing, and the document went undetermined over a value it holds in full
-check("a value holding a var() with its own fallback is split on the top-level comma",
-	run({ rules: ".card{--first-font:var(--second-font,\"UsedTwo\"),serif}.note{--second-font:\"UsedOne\"}.card p{font-family:var(--first-font)}" }),
-	["usedone", "usedtwo"]);
-
-// two properties naming each other resolve for ever without the guard: this check hangs rather
-// than fails when it regresses
-check("a property naming itself through another one falls back to the fonts that were drawn",
-	run({ rules: ".card{--first-font:var(--second-font)}.note{--second-font:var(--first-font)}.card p{font-family:var(--first-font),serif}" }),
-	RENDERED_FAMILIES);
-
-// The rendered-fonts list is what says a declared face is really drawn, and an EMPTY one is not
-// the same answer as a short one: every rendered element has a computed font-family, so an empty
-// list means the computed styles could not be read at all. It happens for real. A frame whose
-// contentDocument is unreachable is re-parsed from its srcdoc with DOMParser
-// (processors/frame-tree/content/content-frame-tree.js), and that document is never rendered, so
-// it reports no font and the frame lost EVERY face it declared — measured on derstandard.at,
-// where the newsletter box inside such a frame fell back to a system font, and on MDN, where the
-// text in the CSS-demo frame reflowed. The families are named right there in the frame's own CSS.
-check("a document that reports no rendered font keeps every font",
-	run({ rules: ".card p{font-family:\"UsedOne\",serif}", usedFonts: [] }),
-	ALL_FAMILIES);
-
-check("a property whose value is another undetermined property falls back to the fonts that were drawn",
-	run({ rules: ".card{--probe-font:var(--set-by-script)}.card p{font-family:var(--probe-font),serif}" }),
-	RENDERED_FAMILIES);
-
-// An unquoted family name is a sequence of identifier tokens, and the walk that joins them has to
-// resume after the LAST of them. Resuming after the first pushed every word but that one again as a
-// family in its own right, so "Helvetica Neue Light" also claimed fonts named "Neue Light" and
-// "Light". It only ever kept too much, which is why it went unnoticed; a page declaring a family
-// whose name is the tail of another one paid for it.
-const TAIL_FACES = `
-	@font-face{font-family:"Helvetica Neue Light";src:url(one.woff2)}
-	@font-face{font-family:"Neue Light";src:url(two.woff2)}
-	@font-face{font-family:"Light";src:url(three.woff2)}`;
-
-const TAIL_USED_FONTS = [
-	["helvetica neue light", "400", "normal", "normal"],
-	["neue light", "400", "normal", "normal"],
-	["light", "400", "normal", "normal"]
-];
-
-check("a multi-word family name is read whole",
-	run({ faces: TAIL_FACES, usedFonts: TAIL_USED_FONTS, rules: "p{font-family:Helvetica Neue Light,serif}" }),
-	["helvetica neue light"]);
-
-check("a quoted name is still matched by its quoted declaration",
-	run({ faces: TAIL_FACES, usedFonts: TAIL_USED_FONTS, rules: "p{font-family:\"Neue Light\",serif}" }),
-	["neue light"]);
-
-// the token that ends a name is not always the comma: a string or a number ends it too, and the
-// walk used to append the token's absent `name` to the family as the text "undefined"
-check("a name is ended by a token that is not an identifier",
-	run({ faces: TAIL_FACES, usedFonts: TAIL_USED_FONTS, rules: "p{font-family:Light \"Neue Light\"}" }),
-	["neue light", "light"]);
-
-console.log(failures ? `\n${failures} check(s) FAILED` : "\nall checks passed");
-Deno.exit(failures ? 1 : 0);
-
-function run({ rules, computed, faces = FONT_FACES, usedFonts = USED_FONTS }) {
-	const stylesheet = cssTree.parse(faces + rules);
-	const options = { usedFonts };
-	const originalGetComputedStyle = globalThis.getComputedStyle;
-	if (computed) {
-		options.doc = { body: {} };
-		globalThis.getComputedStyle = () => ({ getPropertyValue: name => computed[name] || "" });
-	}
-	try {
-		removeUnusedFonts(createStubDocument(), [{ stylesheet }], [], options);
-	} finally {
-		globalThis.getComputedStyle = originalGetComputedStyle;
-	}
-	const families = [];
-	stylesheet.children.forEach(ruleData => {
-		if (ruleData.type == "Atrule" && ruleData.name == "font-face") {
-			const declaration = ruleData.block.children.filter(node => node.property == "font-family").tail;
-			families.push(cssTree.generate(declaration.data.value).replace(/^"|"$/g, "").toLowerCase());
-		}
-	});
-	return families;
-}
-
-function check(label, actual, expected) {
-	const ok = actual.length == expected.length && actual.every((family, index) => family == expected[index]);
-	if (!ok) {
-		failures++;
-	}
-	console.log(`${ok ? "PASS" : "FAIL"} ${label}: ${actual.join(", ") || "(none)"}${ok ? "" : " (expected " + expected.join(", ") + ")"}`);
-}
-
-// the module only reaches the document to borrow a <style> element for unescaping content values
-// and to read the body text, so a full DOM is not needed here
-function createStubDocument() {
-	return {
-		createElement: () => ({ textContent: "", remove() { } }),
-		body: { appendChild() { }, innerText: "" }
-	};
-}

package/test/sfz-harness/css-property-filter.js

@@ -1,113 +0,0 @@
-// The CSS-removal option runs every declaration through css-tree's lexer and drops the ones it
-// judges invalid. css-tree reports two different failures the same way — a real value mismatch
-// (SyntaxMatchError) and a property it simply has no entry for (SyntaxReferenceError) — so the
-// original `!matchProperty(...).matched` deleted valid declarations whose property is missing from
-// the vendored dictionary. That silently flattened every CSS-defined SVG gradient: stop-opacity was
-// dropped, both stops became opaque, and the gradient rendered as a solid block. It hid for a long
-// time because stop-color survived alongside it — a var() value takes a different branch and is
-// never handed to the lexer at all, so the colour was right and only the fade was gone.
-//
-// 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, 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
-// practice; the last two are here as the moving target — any property newer than the vendored
-// dictionary lands in this bucket, and the list will keep growing
-const MUST_KEEP = [
-	["stop-color", "#2a78d6"],
-	["stop-opacity", ".20"],
-	["stop-opacity", "0"],
-	["flood-color", "red"],
-	["flood-opacity", "0.5"],
-	["lighting-color", "white"],
-	["text-box-trim", "trim-both"],
-	["corner-shape", "squircle"]
-];
-
-// declarations css-tree knows and correctly rejects. These keep the filter honest: the fix must not
-// turn the check off, only stop it firing on properties css-tree has never heard of
-const MUST_DROP = [
-	["margin-trim", "block"],
-	["opacity", "not-a-number"],
-	["color", "12px"]
-];
-
-// properties close enough to the broken ones to be worth stating outright, because they are the
-// reason the bug looked like an SVG quirk rather than a dictionary gap: css-tree does know these,
-// so gradients that used them were unaffected and the failure looked arbitrary
-const KNOWN_GOOD = [
-	["fill-opacity", "0.5"],
-	["stroke-opacity", "0.5"],
-	["fill", "red"],
-	["vector-effect", "non-scaling-stroke"]
-];
-
-let failed = false;
-
-function check(label, actual, expected) {
-	const ok = actual === expected;
-	console.log(`${ok ? "PASS" : "FAIL"} ${label}: ${actual}${ok ? "" : " (expected " + expected + ")"}`);
-	failed ||= !ok;
-}
-
-function isDropped(property, declaration) {
-	return isUnsupportedPropertyValue(property, cssTree.parse(declaration, { context: "value" }));
-}
-
-for (const [property, declaration] of MUST_KEEP) {
-	check(`kept: ${property}: ${declaration}`, isDropped(property, declaration), false);
-}
-
-for (const [property, declaration] of MUST_DROP) {
-	check(`dropped: ${property}: ${declaration}`, isDropped(property, declaration), true);
-}
-
-for (const [property, declaration] of KNOWN_GOOD) {
-	check(`kept: ${property}: ${declaration}`, isDropped(property, declaration), false);
-}
-
-// the distinction the fix rests on. If a css-tree upgrade ever collapses these two error types into
-// one, the predicate above cannot tell "unknown" from "wrong" any more and needs rewriting rather
-// than adjusting
-const unknownProperty = cssTree.lexer.matchProperty("stop-opacity", cssTree.parse("0", { context: "value" }));
-const wrongValue = cssTree.lexer.matchProperty("margin-trim", cssTree.parse("block", { context: "value" }));
-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);
-} else {
-	console.log("PASSED");
-}

package/test/sfz-harness/dom-stub.js

@@ -1,13 +0,0 @@
-// compression.js captures DOMParser from globalThis when the module is evaluated and Deno has
-// none, so this module is imported before it. The stub is enough to tell whether the text body
-// is written at all; it does not reproduce what a real DOM extraction produces.
-globalThis.DOMParser = class {
-	parseFromString(content) {
-		return {
-			body: {
-				innerText: content.replace(/<[^>]*>/g, " "),
-				querySelectorAll: () => []
-			}
-		};
-	}
-};