single-file-core 1.5.125 → 1.5.127

package/processors/compression/compression.js

@@ -40,9 +40,7 @@ import {
 	router
 } from "./compression-router.js";
 
-const { Blob, fetch, TextEncoder, TextDecoder, DOMParser } = globalThis;
-
-const TEXT_DECODER = new TextDecoder("windows-1252");
+const { Blob, fetch, TextEncoder, DOMParser } = globalThis;
 
 const COMPRESSIBLE_CONTENT_TYPES = ["application/javascript", "application/x-javascript", "application/ecmascript", "application/json", "application/ld+json", "application/manifest+json", "application/xml", "application/xhtml+xml", "application/rss+xml", "application/atom+xml", "image/svg+xml"];
 const TEXT_CONTENT_TYPE_PREFIX = "text/";
@@ -63,19 +61,20 @@ const EMBEDDED_DATA_TAGS = [
 	...EXTRA_DATA_TAGS,
 ];
 const DATA_IDENTIFIER = "sfz-data";
-const EXTRA_DATA_REGEXPS = [
-	[/<script/i, /<\/script[\t\n\f\r />]/i],
-	[/<style/i, /<\/style[\t\n\f\r />]/i],
-	[/<noframes/i, /<\/noframes[\t\n\f\r />]/i],
-	[/<noembed/i, /<\/noembed[\t\n\f\r />]/i],
-	[/<iframe/i, /<\/iframe[\t\n\f\r />]/i],
-	[/<xmp/i, /<\/xmp[\t\n\f\r />]/i],
-	[/<!\[CDATA\[/i, /\]\]>/],
-	[/<plaintext/i, /<\/plaintext[\t\n\f\r />]/i]
+const TAG_NAME_TERMINATORS = "\t\n\f\r />";
+const EXTRA_DATA_PATTERNS = [
+	[["<script"], ["</script", TAG_NAME_TERMINATORS]],
+	[["<style"], ["</style", TAG_NAME_TERMINATORS]],
+	[["<noframes"], ["</noframes", TAG_NAME_TERMINATORS]],
+	[["<noembed"], ["</noembed", TAG_NAME_TERMINATORS]],
+	[["<iframe"], ["</iframe", TAG_NAME_TERMINATORS]],
+	[["<xmp"], ["</xmp", TAG_NAME_TERMINATORS]],
+	[["<![CDATA["], ["]]>"]],
+	[["<plaintext"], ["</plaintext", TAG_NAME_TERMINATORS]]
 ];
-const EMBEDDED_DATA_REGEXPS = [
-	[/<!--/i, /--!?>|<!-$/i],
-	...EXTRA_DATA_REGEXPS,
+const EMBEDDED_DATA_PATTERNS = [
+	[["<!--"], ["-->"], ["--!>"], ["<!-", undefined, true]],
+	...EXTRA_DATA_PATTERNS,
 ];
 const CRC32_TABLE = new Uint32Array(256).map((_, indexTable) => {
 	let crc = indexTable;
@@ -89,7 +88,8 @@ const PNG_CHUNK_CRC_LENGTH = 4;
 const PNG_SIGNATURE_LENGTH = 8;
 const PNG_IHDR_LENGTH = 25;
 const COMMENT_LENGTH_FIELD_LENGTH = 2;
-const MAX_APPENDED_DATA_LENGTH = 65535;
+const MAX_ZIP_COMMENT_LENGTH = 65535;
+const DEFAULT_MAX_APPENDED_DATA_LENGTH = 16361;
 const PDF_ENTRY_FILENAME = "page.pdf";
 const PRESCAN_WINDOW_LENGTH = 1024;
 const PNG_TEXT_CHUNK_HEADER_LENGTH = 12;
@@ -105,7 +105,6 @@ const CENTRAL_FILE_HEADER_SIGNATURE = 0x02014b50;
 const END_OF_CENTRAL_DIR_SIGNATURE = 0x06054b50;
 const ZIP64_END_OF_CENTRAL_DIR_SIGNATURE = 0x06064b50;
 const ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE = 0x07064b50;
-const LANGUAGE_ENCODING_FLAG = 0x0800;
 
 const browser = globalThis.browser;
 
@@ -121,6 +120,7 @@ const PROCESS_OPTION_NAMES = [
 	"insertMetaCSP",
 	"insertMetaNoIndex",
 	"insertTextBody",
+	"maxAppendedDataLength",
 	"password",
 	"preventAppendedData",
 	"selfExtractingArchive",
@@ -227,18 +227,14 @@ async function buildArchive(pageData, options, script, entriesData, zipWriterOpt
 		const lfCodes = [];
 		let crc32 = -1;
 		if (!options.extractDataFromPageTags || options.extractDataFromPageTags[0] != "<plaintext>") {
-			const textContent = TEXT_DECODER.decode(data.subarray(startOffset));
+			const zipData = data.subarray(startOffset);
 			if (options.extractDataFromPageTags) {
 				const tagIndex = getExtraDataTagIndex(options.extractDataFromPageTags);
-				const regExpsTag = EXTRA_DATA_REGEXPS[tagIndex];
-				if (textContent.match(regExpsTag[0]) || textContent.match(regExpsTag[1])) {
-					return findExtraDataTags(textContent, pageData, options, script, entriesData, zipWriterOptions, tagIndex + 1);
-				}
-			} else {
-				const [startRegExp, endRegExp] = EMBEDDED_DATA_REGEXPS[0];
-				if (textContent.match(startRegExp) || textContent.match(endRegExp)) {
-					return findExtraDataTags(textContent, pageData, options, script, entriesData, zipWriterOptions);
+				if (containsDataPattern(zipData, EXTRA_DATA_PATTERNS[tagIndex])) {
+					return findExtraDataTags(zipData, pageData, options, script, entriesData, zipWriterOptions, tagIndex + 1);
 				}
+			} else if (containsDataPattern(zipData, EMBEDDED_DATA_PATTERNS[0])) {
+				return findExtraDataTags(zipData, pageData, options, script, entriesData, zipWriterOptions);
 			}
 		}
 		if (options.extractDataFromPage) {
@@ -278,7 +274,7 @@ async function buildArchive(pageData, options, script, entriesData, zipWriterOpt
 			const payloadView = new DataView(payload.buffer);
 			words.forEach((word, indexWord) => payloadView.setUint32(indexWord * 4, word, true));
 			extraData = "<sfz-extra-data>" + base64Encode(deflateRaw(payload)) + "</sfz-extra-data>";
-			if (options.preventAppendedData || extraData.length > MAX_APPENDED_DATA_LENGTH - pageContent.length - endTags.length - (options.embeddedImage ? PNG_IEND_LENGTH + PNG_CHUNK_CRC_LENGTH : 0)) {
+			if (options.preventAppendedData || extraData.length > getMaxAppendedDataLength(options) - pageContent.length - endTags.length - (options.embeddedImage ? PNG_IEND_LENGTH + PNG_CHUNK_CRC_LENGTH : 0)) {
 				if (!options.extraDataSize) {
 					options.preventAppendedData = true;
 					options.extraDataSize = getReservationSize(extraData.length);
@@ -304,7 +300,7 @@ async function buildArchive(pageData, options, script, entriesData, zipWriterOpt
 	if (options.declareAppendedData) {
 		const appendedDataLength = pageContent.length - data.length +
 			(options.embeddedImage ? PNG_CHUNK_CRC_LENGTH + PNG_IEND_LENGTH : 0);
-		if (appendedDataLength && appendedDataLength <= MAX_APPENDED_DATA_LENGTH && isDeclaredLengthHidden(pageContent, zipDataEnd, appendedDataLength, options)) {
+		if (appendedDataLength && appendedDataLength <= MAX_ZIP_COMMENT_LENGTH && isDeclaredLengthHidden(pageContent, zipDataEnd, appendedDataLength, options)) {
 			new DataView(pageContent.buffer, pageContent.byteOffset).setUint16(zipDataEnd, appendedDataLength, true);
 		}
 	}
@@ -324,6 +320,10 @@ async function buildArchive(pageData, options, script, entriesData, zipWriterOpt
 	}
 }
 
+function getMaxAppendedDataLength(options) {
+	return options.maxAppendedDataLength === undefined ? DEFAULT_MAX_APPENDED_DATA_LENGTH : options.maxAppendedDataLength;
+}
+
 function isDeclaredLengthHidden(pageContent, zipDataEnd, appendedDataLength, options) {
 	if (options.extractDataFromPageTags && options.extractDataFromPageTags[0] == "<plaintext>") {
 		return true;
@@ -331,9 +331,7 @@ function isDeclaredLengthHidden(pageContent, zipDataEnd, appendedDataLength, opt
 	const tail = pageContent.slice(zipDataEnd - WRAPPER_PATTERN_WINDOW_LENGTH, zipDataEnd + COMMENT_LENGTH_FIELD_LENGTH);
 	new DataView(tail.buffer).setUint16(WRAPPER_PATTERN_WINDOW_LENGTH, appendedDataLength, true);
 	const tagIndex = options.extractDataFromPageTags ? getExtraDataTagIndex(options.extractDataFromPageTags) + 1 : 0;
-	const [startRegExp, endRegExp] = EMBEDDED_DATA_REGEXPS[tagIndex];
-	const tailText = TEXT_DECODER.decode(tail);
-	return !tailText.match(startRegExp) && !tailText.match(endRegExp);
+	return !containsDataPattern(tail, EMBEDDED_DATA_PATTERNS[tagIndex]);
 }
 
 function getCRC32(data, indexData = 0) {
@@ -359,7 +357,6 @@ function getPDFEntry(embeddedPdf, lastModDate = new Date()) {
 	const localHeaderView = new DataView(localHeader.buffer);
 	localHeaderView.setUint32(0, LOCAL_FILE_HEADER_SIGNATURE, true);
 	localHeaderView.setUint16(4, 20, true);
-	localHeaderView.setUint16(6, LANGUAGE_ENCODING_FLAG, true);
 	localHeaderView.setUint16(10, dosTime, true);
 	localHeaderView.setUint16(12, dosDate, true);
 	localHeaderView.setUint32(14, crc32, true);
@@ -372,7 +369,6 @@ function getPDFEntry(embeddedPdf, lastModDate = new Date()) {
 	centralRecordView.setUint32(0, CENTRAL_FILE_HEADER_SIGNATURE, true);
 	centralRecordView.setUint16(4, 0x0300, true);
 	centralRecordView.setUint16(6, 20, true);
-	centralRecordView.setUint16(8, LANGUAGE_ENCODING_FLAG, true);
 	centralRecordView.setUint16(12, dosTime, true);
 	centralRecordView.setUint16(14, dosDate, true);
 	centralRecordView.setUint32(16, crc32, true);
@@ -546,8 +542,7 @@ function getStartHTMLArray(pageData, options, lastModDate, startTag = "") {
 		const embeddedPdf = new Uint8Array(options.embeddedPdf);
 		pdfEntry = options.preventEmbeddedPdfEntry ? undefined : getPDFEntry(embeddedPdf, lastModDate);
 		const localHeader = pdfEntry ? pdfEntry.localHeader : new Uint8Array(0);
-		const embeddedPdfText = TEXT_DECODER.decode(localHeader) + TEXT_DECODER.decode(embeddedPdf);
-		const pdfTagIndex = findEmbeddedDataTagIndex(embeddedPdfText);
+		const pdfTagIndex = findEmbeddedDataTagIndex(concatArrays(localHeader, embeddedPdf));
 		if (pdfTagIndex == -1) {
 			dropUnhiddenFace(options, "embeddedPdf", EMBEDDED_PDF_LABEL);
 			pdfEntry = undefined;
@@ -623,12 +618,11 @@ function getExtraDataTagIndex(extractDataFromPageTags) {
 	return tagIndex;
 }
 
-function findExtraDataTags(textContent, pageData, options, script, entriesData, zipWriterOptions, indexExtractDataFromPageTags = 0) {
-	const regExpsTag = EXTRA_DATA_REGEXPS[indexExtractDataFromPageTags];
+function findExtraDataTags(zipData, pageData, options, script, entriesData, zipWriterOptions, indexExtractDataFromPageTags = 0) {
 	const plaintextTag = EXTRA_DATA_TAGS[indexExtractDataFromPageTags][0] == "<plaintext>";
-	const matchTag = !plaintextTag && (textContent.match(regExpsTag[0]) || textContent.match(regExpsTag[1]));
+	const matchTag = !plaintextTag && containsDataPattern(zipData, EXTRA_DATA_PATTERNS[indexExtractDataFromPageTags]);
 	if (matchTag) {
-		return findExtraDataTags(textContent, pageData, options, script, entriesData, zipWriterOptions, indexExtractDataFromPageTags + 1);
+		return findExtraDataTags(zipData, pageData, options, script, entriesData, zipWriterOptions, indexExtractDataFromPageTags + 1);
 	} else {
 		options.extractDataFromPageTags = EXTRA_DATA_TAGS[indexExtractDataFromPageTags];
 		if (options.extractDataFromPageTags[0] == "<plaintext>") {
@@ -638,24 +632,93 @@ function findExtraDataTags(textContent, pageData, options, script, entriesData,
 	}
 }
 
-function findEmbeddedDataTagIndex(text, fromIndex = 0) {
-	const tagIndex = EMBEDDED_DATA_REGEXPS.slice(fromIndex, -1).findIndex(([startRegExp, endRegExp]) => !text.match(startRegExp) && !text.match(endRegExp));
+function findEmbeddedDataTagIndex(data, fromIndex = 0) {
+	const tagIndex = EMBEDDED_DATA_PATTERNS.slice(fromIndex, -1).findIndex(patterns => !containsDataPattern(data, patterns));
 	return tagIndex == -1 ? -1 : tagIndex + fromIndex;
 }
 
+function containsDataPattern(data, patterns) {
+	const patternsByCharCode = new Map();
+	for (const pattern of patterns) {
+		const [text, , atEnd] = pattern;
+		if (atEnd) {
+			if (matchesDataPatternAt(data, pattern, data.length - text.length)) {
+				return true;
+			}
+		} else {
+			const charCode = text.charCodeAt(0);
+			indexPatternByCharCode(patternsByCharCode, charCode, pattern);
+			const alternateCharCode = getAlternateCharCode(charCode);
+			if (alternateCharCode != -1) {
+				indexPatternByCharCode(patternsByCharCode, alternateCharCode, pattern);
+			}
+		}
+	}
+	for (const [charCode, candidates] of patternsByCharCode) {
+		for (let index = data.indexOf(charCode); index != -1; index = data.indexOf(charCode, index + 1)) {
+			for (let indexCandidate = 0; indexCandidate < candidates.length; indexCandidate++) {
+				if (matchesDataPatternAt(data, candidates[indexCandidate], index)) {
+					return true;
+				}
+			}
+		}
+	}
+	return false;
+}
+
+function indexPatternByCharCode(patternsByCharCode, charCode, pattern) {
+	if (!patternsByCharCode.has(charCode)) {
+		patternsByCharCode.set(charCode, []);
+	}
+	patternsByCharCode.get(charCode).push(pattern);
+}
+
+function matchesDataPatternAt(data, [text, terminators], index) {
+	const textLength = text.length;
+	if (index < 0 || index + textLength > data.length) {
+		return false;
+	}
+	for (let indexText = 0; indexText < textLength; indexText++) {
+		const charCode = text.charCodeAt(indexText);
+		const code = data[index + indexText];
+		if (code != charCode && code != getAlternateCharCode(charCode)) {
+			return false;
+		}
+	}
+	return terminators === undefined || isTerminatorCode(terminators, data[index + textLength]);
+}
+
+function isTerminatorCode(terminators, code) {
+	return code !== undefined && terminators.includes(String.fromCharCode(code));
+}
+
+function getAlternateCharCode(charCode) {
+	const lowerCharCode = charCode | 0x20;
+	return lowerCharCode >= 0x61 && lowerCharCode <= 0x7a ? charCode ^ 0x20 : -1;
+}
+
+function concatArrays(...arrays) {
+	const result = new Uint8Array(arrays.reduce((length, array) => length + array.length, 0));
+	let offset = 0;
+	arrays.forEach(array => {
+		result.set(array, offset);
+		offset += array.length;
+	});
+	return result;
+}
+
 function getImageHTMLChunk(pageData, options, lastModDate) {
-	const embeddedImageText = TEXT_DECODER.decode(getEmbeddedImageData(options.embeddedImage)) +
-		TEXT_DECODER.decode(new Uint8Array(4)) + TEXT_DECODER.decode(PNG_ZIP_CHUNK_TYPE_KEYWORD);
-	let tagIndex = findEmbeddedDataTagIndex(embeddedImageText);
+	const embeddedImageData = concatArrays(getEmbeddedImageData(options.embeddedImage), new Uint8Array(4), PNG_ZIP_CHUNK_TYPE_KEYWORD);
+	let tagIndex = findEmbeddedDataTagIndex(embeddedImageData);
 	while (tagIndex != -1) {
 		const [startTag, endTag] = EMBEDDED_DATA_TAGS[tagIndex];
 		const startHTMLData = getStartHTMLArray(pageData, options, lastModDate, startTag);
 		const htmlData = new Uint8Array([...getLength(startHTMLData.htmlArray.length + 4), ...[0x74, 0x45, 0x58, 0x74, 0x50, 0x4e, 0x47, 0], ...startHTMLData.htmlArray]);
 		const htmlDataCRC = getCRC32(htmlData, 4);
-		const wrappedText = TEXT_DECODER.decode(htmlDataCRC) + embeddedImageText;
+		const wrappedData = concatArrays(htmlDataCRC, embeddedImageData);
 		if ((tagIndex == 0 && (htmlDataCRC[0] == 0x3e || (htmlDataCRC[0] == 0x2d && htmlDataCRC[1] == 0x3e))) ||
-			findEmbeddedDataTagIndex(wrappedText, tagIndex) != tagIndex) {
-			tagIndex = findEmbeddedDataTagIndex(embeddedImageText, tagIndex + 1);
+			findEmbeddedDataTagIndex(wrappedData, tagIndex) != tagIndex) {
+			tagIndex = findEmbeddedDataTagIndex(embeddedImageData, tagIndex + 1);
 		} else {
 			return { endTag, startHTMLData, htmlData, htmlDataCRC };
 		}
@@ -747,11 +810,7 @@ async function getContent() {
 	});
 	return new Promise((resolve, reject) => {
 		let aborted = false;
-		if (location.protocol == "file:") {
-			extractDataFromDocument();
-		} else {
-			getPageData();
-		}
+		getPageData();
 
 		async function extractDataFromDocument() {
 			try {

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

@@ -242,39 +242,46 @@
 					}
 					return boundingRect;
 				};
+				Element.prototype.getBoundingClientRect.toString = function () { return "function getBoundingClientRect() { [native code] }"; };
+				setFunctionName(Element.prototype.getBoundingClientRect, "getBoundingClientRect");
 			}
 		}
 		if (!globalThis._singleFileImage) {
-			const Image = globalThis.Image;
-			globalThis._singleFileImage = globalThis.Image;
-			globalThis.__defineGetter__("Image", function () {
-				return function () {
-					const image = new Image(...arguments);
-					const result = new Image(...arguments);
-					result.__defineSetter__("src", value => {
-						image.src = value;
-						document.dispatchEvent(new CustomEvent(LOAD_IMAGE_EVENT, { detail: image.src }));
-					});
-					result.__defineGetter__("src", () => image.src);
-					result.__defineSetter__("srcset", value => {
-						document.dispatchEvent(new CustomEvent(LOAD_IMAGE_EVENT));
-						image.srcset = value;
-					});
-					result.__defineGetter__("srcset", () => image.srcset);
-					result.__defineGetter__("height", () => image.height);
-					result.__defineGetter__("width", () => image.width);
-					result.__defineGetter__("naturalHeight", () => image.naturalHeight);
-					result.__defineGetter__("naturalWidth", () => image.naturalWidth);
-					if (image.decode) {
-						result.__defineGetter__("decode", () => () => image.decode());
-					}
-					image.onload = image.onloadend = image.onerror = event => {
-						document.dispatchEvent(new CustomEvent(IMAGE_LOADED_EVENT, { detail: image.src }));
-						result.dispatchEvent(new Event(event.type, event));
-					};
-					return result;
+			const NativeImage = globalThis.Image;
+			globalThis._singleFileImage = NativeImage;
+			const ImageWrapper = function Image() {
+				const image = new NativeImage(...arguments);
+				const result = new NativeImage(...arguments);
+				result.__defineSetter__("src", value => {
+					image.src = value;
+					document.dispatchEvent(new CustomEvent(LOAD_IMAGE_EVENT, { detail: image.src }));
+				});
+				result.__defineGetter__("src", () => image.src);
+				result.__defineSetter__("srcset", value => {
+					document.dispatchEvent(new CustomEvent(LOAD_IMAGE_EVENT));
+					image.srcset = value;
+				});
+				result.__defineGetter__("srcset", () => image.srcset);
+				result.__defineGetter__("height", () => image.height);
+				result.__defineGetter__("width", () => image.width);
+				result.__defineGetter__("naturalHeight", () => image.naturalHeight);
+				result.__defineGetter__("naturalWidth", () => image.naturalWidth);
+				if (image.decode) {
+					const decode = function decode() { return image.decode(); };
+					decode.toString = function () { return "function decode() { [native code] }"; };
+					setFunctionName(decode, "decode");
+					result.__defineGetter__("decode", () => decode);
+				}
+				image.onload = image.onloadend = image.onerror = event => {
+					document.dispatchEvent(new CustomEvent(IMAGE_LOADED_EVENT, { detail: image.src }));
+					result.dispatchEvent(new Event(event.type, event));
 				};
-			});
+				return result;
+			};
+			ImageWrapper.prototype = NativeImage.prototype;
+			ImageWrapper.toString = function () { return "function Image() { [native code] }"; };
+			setFunctionName(ImageWrapper, "Image");
+			globalThis.__defineGetter__("Image", () => ImageWrapper);
 		}
 		const verticalZoomFactor = clientHeight / scrollHeight;
 		const horizontalZoomFactor = clientWidth / scrollWidth;
@@ -371,9 +378,10 @@
 
 	if (globalThis.CSS && globalThis.CSS.paintWorklet && globalThis.CSS.paintWorklet.addModule) {
 		const addModule = globalThis.CSS.paintWorklet.addModule;
-		globalThis.CSS.paintWorklet.addModule = function (moduleURL, options) {
+		globalThis.CSS.paintWorklet.addModule = function (moduleURL) {
 			try {
 				const result = addModule.apply(globalThis.CSS.paintWorklet, arguments);
+				const options = arguments[1];
 				moduleURL = new URL(moduleURL, document.baseURI).href;
 				document.dispatchEvent(new CustomEvent(NEW_WORKLET_EVENT, { detail: { moduleURL, options } }));
 				return result;
@@ -382,6 +390,8 @@
 				throw error;
 			}
 		};
+		globalThis.CSS.paintWorklet.addModule.toString = function () { return "function addModule() { [native code] }"; };
+		setFunctionName(globalThis.CSS.paintWorklet.addModule, "addModule");
 	}
 
 	if (globalThis.FontFace) {

package/test/sfz-harness/font-face-composite.js

@@ -0,0 +1,135 @@
+// Several @font-face rules that declare the same family with the same style descriptors are one
+// composite face, not a stack where the last rule wins. CSS Fonts 4 §5.2: "When the matched face is
+// a composite face, user agents must use the procedure above on each of the faces in the composite
+// face in reverse order of @font-face rule definition", selecting a face only "if the effective
+// character map supports the character in question". §4.5.1 says the same for the case where the
+// ranges are identical rather than merely overlapping: "If the unicode ranges overlap for a set of
+// @font-face rules with the same family and style descriptor values, the rules are ordered in the
+// reverse order they were defined; the last rule defined is the first to be checked for a given
+// character." So the later rule wins per character, and a character it has no glyph for falls back
+// to the earlier rule of the same family.
+//
+// Dropping the earlier rule therefore loses glyphs. science.org declares icomoon twice, weight 400
+// style normal in both, first a 103-codepoint icon set and then a 30-codepoint one holding only the
+// slideshow arrows. The banner close button is content:"\e928", which lives in the first font only,
+// so keeping the last rule alone rendered a tofu box reading "E9 28" where the X had been.
+//
+// Pooling the sources of every rule sharing a key breaks it the same way even when both rules are
+// kept: one winning source gets written into all of them, so both rules end up naming the same font
+// and the other one is gone just as surely. Each rule keeps its own sources.
+//
+// Rules that are duplicates outright, same key and same src, are still emitted once: they are the
+// same member of the composite declared twice, so dropping one changes nothing.
+import * as cssTree from "../../vendor/css-tree.js";
+
+// helper.js reaches the frame hooks, which 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 { getProcessorHelperCommonClass } = await import("../../core/lib/processor-helper-common.js");
+
+const ProcessorHelperCommon = getProcessorHelperCommonClass({}, cssTree);
+
+// the real subclasses pick one source out of the list and rewrite the rule with it; the contract
+// under test is which rules survive and which sources each one is handed, so this records that and
+// keeps every rule
+class TestProcessorHelper extends ProcessorHelperCommon {
+	constructor() {
+		super();
+		this.processedRules = [];
+	}
+	async processFontFaceRule(ruleData, fontInfo) {
+		this.processedRules.push({
+			family: this.getPropertyValue(ruleData, "font-family"),
+			sources: fontInfo.map(source => source.src)
+		});
+		return true;
+	}
+}
+
+async function run(css) {
+	const helper = new TestProcessorHelper();
+	const stylesheets = new Map([[0, { stylesheet: cssTree.parse(css) }]]);
+	await helper.removeAlternativeFonts({}, stylesheets, new Map(), new Map());
+	const remaining = [];
+	stylesheets.get(0).stylesheet.children.forEach(ruleData => {
+		if (ruleData.type == "Atrule" && ruleData.name == "font-face") {
+			remaining.push(helper.getPropertyValue(ruleData, "src"));
+		}
+	});
+	return { processed: helper.processedRules, remaining };
+}
+
+let failures = 0;
+
+// a rule that was dropped when it should have been kept leaves a hole in the list, and reporting
+// that as a failed comparison is more use than throwing on the way to the assertion
+function sourcesOf(processedRules, index) {
+	const rule = processedRules[index];
+	return rule ? rule.sources : null;
+}
+
+function check(label, actual, expected) {
+	const pass = JSON.stringify(actual) == JSON.stringify(expected);
+	console.log((pass ? "PASS " : "FAIL ") + label + ": " + JSON.stringify(actual));
+	if (!pass) {
+		console.log("     expected: " + JSON.stringify(expected));
+		failures++;
+	}
+}
+
+const TWO_FACES = `
+	@font-face{font-family:icomoon;src:url(big.ttf) format("truetype"),url(big.woff) format("woff");font-weight:400;font-style:normal}
+	@font-face{font-family:icomoon;src:url(small.ttf) format("truetype"),url(small.woff) format("woff");font-weight:400;font-style:normal}`;
+
+const two = await run(TWO_FACES);
+check("both members of the composite face are kept", two.processed.length, 2);
+check("the earlier rule keeps its own sources", sourcesOf(two.processed, 0).sort(), ["url(big.ttf)format(\"truetype\")", "url(big.woff)format(\"woff\")"]);
+check("the later rule keeps its own sources", (sourcesOf(two.processed, 1) || []).sort(), ["url(small.ttf)format(\"truetype\")", "url(small.woff)format(\"woff\")"]);
+check("neither rule is removed from the stylesheet", two.remaining.length, 2);
+
+const DUPLICATE = `
+	@font-face{font-family:icomoon;src:url(one.woff) format("woff");font-weight:400;font-style:normal}
+	@font-face{font-family:icomoon;src:url(one.woff) format("woff");font-weight:400;font-style:normal}`;
+
+const duplicate = await run(DUPLICATE);
+check("an outright duplicate rule is emitted once", duplicate.processed.length, 1);
+check("the duplicate is removed from the stylesheet", duplicate.remaining.length, 1);
+
+// unicode-range is part of the font key, so the subsetting idiom was never affected by the
+// shadowing bug; it is pinned here because the fix moved what the key is used for
+const RANGES = `
+	@font-face{font-family:sub;src:url(latin.woff2) format("woff2");unicode-range:U+0-7F}
+	@font-face{font-family:sub;src:url(greek.woff2) format("woff2");unicode-range:U+370-3FF}`;
+
+const ranges = await run(RANGES);
+check("faces split by unicode-range are all kept", ranges.processed.length, 2);
+check("each range keeps its own source", ranges.processed.map(rule => rule.sources), [["url(latin.woff2)format(\"woff2\")"], ["url(greek.woff2)format(\"woff2\")"]]);
+
+// a rule declaring the same source twice contributes it once, in the position its later declaration
+// gives it. The sources are compared after the separating comma is stripped, so a repeat is
+// recognised wherever it sits: the value is split by a regexp that keeps that comma, and comparing
+// the raw pieces made the last source in a list unequal to the same source anywhere before it
+const REPEATED = `
+	@font-face{font-family:repeat;src:url(a.woff) format("woff"),url(b.woff) format("woff"),url(a.woff) format("woff"),url(c.woff) format("woff");font-weight:400}`;
+
+const repeated = await run(REPEATED);
+check("a source repeated inside one rule is listed once", (sourcesOf(repeated.processed, 0) || []).length, 3);
+
+const REPEATED_LAST = `
+	@font-face{font-family:repeat;src:url(a.woff) format("woff"),url(b.woff) format("woff"),url(a.woff) format("woff");font-weight:400}`;
+
+const repeatedLast = await run(REPEATED_LAST);
+check("a repeat in last position is recognised too", (sourcesOf(repeatedLast.processed, 0) || []).length, 2);
+// the list is held in reverse of the order it is written back in, so the entry the rule declares
+// last comes first here: a.woff keeps the position its second declaration gives it
+check("the repeat keeps the position of its later declaration", sourcesOf(repeatedLast.processed, 0), ["url(a.woff)format(\"woff\")", "url(b.woff)format(\"woff\")"]);
+
+if (failures) {
+	console.log("\n" + failures + " check(s) failed");
+	Deno.exit(1);
+} else {
+	console.log("\nall checks passed");
+}

package/test/sfz-harness/format-rules.js

@@ -1,5 +1,5 @@
 import "./dom-stub.js";
-import { makePageData, makeOptions, runProcess, mulberry32 } from "./common.js";
+import { makePageData, makeOptions, runProcess, mulberry32, freezeDate } from "./common.js";
 import { ZipReader, ZipWriter, BlobReader } from "../../vendor/zip/zip.js";
 
 // the quote is there because the escaper the title shares with the table of contents encodes
@@ -239,6 +239,65 @@ function countIdentifiers(text) {
 	check("a relocated archive declares no comment", view.getUint16(bytes.length - 2, true), 0);
 }
 
+function makeNewlinePageData(seed, newlineCount) {
+	const pageData = makePageData(seed, 4 * 1024);
+	const rand = mulberry32(seed);
+	const newlines = ["\n", "\r", "\r\n"];
+	let content = "";
+	for (let index = 0; index < newlineCount; index++) {
+		content += newlines[(rand() * 3) | 0];
+	}
+	pageData.resources.stylesheets.push({ name: "newlines.txt", extension: ".txt", content, url: "https://example.com/newlines.txt" });
+	return pageData;
+}
+
+// libarchive gives up looking for the end of central directory record 16383 bytes from the end of
+// the file, so the default budget is 16361 appended bytes: that window minus the 22-byte record.
+// This fixture's payload lands between the default and the 65535-byte comment ceiling, which is
+// the range the old budget kept appended and bsdtar could not open.
+// The Date must be frozen: `archiveTime` (compression.js:155) puts an ISO timestamp in the
+// archive, whose milliseconds move a few newline bytes in and out of the recovered range and
+// therefore change the payload length build to build. The boundary checks below compare a budget
+// against a run measured in an EARLIER build, so without freezing they are off by a few bytes one
+// run in three. check-determinism.js asserts both halves of that
+{
+	const restoreDate = freezeDate();
+	try {
+		const wide = makeOptions({ disableCompression: true, maxAppendedDataLength: 65535 });
+		const { bytes: wideBytes } = await runProcess(makeNewlinePageData(43, 80 * 1000), wide);
+		const wideTail = readAppendedData(wideBytes).trailing;
+		check("a wider budget keeps the payload appended", wide.extraDataSize, undefined);
+		check("the fixture overflows the default budget", wideTail > 16361, true);
+		check("the fixture fits the comment ceiling", wideTail <= 65535, true);
+
+		const byDefault = makeOptions({ disableCompression: true });
+		const { bytes } = await runProcess(makeNewlinePageData(43, 80 * 1000), byDefault);
+		check("the default budget relocates the payload", byDefault.extraDataSize > 0, true);
+		check("the default budget keeps the record in libarchive's window", readAppendedData(bytes).trailing <= 16361, true);
+
+		const fitting = makeOptions({ disableCompression: true, maxAppendedDataLength: wideTail });
+		await runProcess(makeNewlinePageData(43, 80 * 1000), fitting);
+		check("a budget matching the run to the byte keeps it appended", fitting.extraDataSize, undefined);
+
+		const tight = makeOptions({ disableCompression: true, maxAppendedDataLength: wideTail - 1 });
+		await runProcess(makeNewlinePageData(43, 80 * 1000), tight);
+		check("one byte below the run relocates it", tight.extraDataSize > 0, true);
+	} finally {
+		restoreDate();
+	}
+}
+
+// the budget and the comment ceiling are two different limits, and only the second is a property
+// of the format. A budget raised past 65535 produces a run the comment-length field cannot hold,
+// which setUint16 would write back modulo 65536: the writer leaves it undeclared instead
+{
+	const options = makeOptions({ disableCompression: true, declareAppendedData: true, maxAppendedDataLength: Number.MAX_SAFE_INTEGER });
+	const { bytes } = await runProcess(makeNewlinePageData(44, 320 * 1000), options);
+	const { declared, trailing } = readAppendedData(bytes);
+	check("a run past the comment ceiling stays appended", trailing > 65535, true);
+	check("a run past the comment ceiling is left undeclared", declared, 0);
+}
+
 {
 	const options = makeOptions({ embeddedPdf: PDF });
 	const pageData = makePageData(15, 4 * 1024);
@@ -373,9 +432,13 @@ const ALL_FACE_RUNGS = "<!--sfz-data<script<style<noframes<noembed<iframe<xmp<![
 	check("no page.pdf entry is left behind", entries.some(entry => entry.filename.endsWith("page.pdf")), false);
 }
 
-// page.pdf is the only record the writer builds by hand, so it is the only place the
-// language encoding flag can go missing: without it a reader decodes that one name
-// through CP437 while reading every other name in the same archive as UTF-8
+// page.pdf is the only record the writer builds by hand, so it is the only place the language
+// encoding flag can disagree with the rest of the archive, and a reader would then decode that one
+// name through a different path than every other name in the same file. Which way the flag goes is
+// the ZIP writer's business, not this format's: it sets bit 11 only when a name or a comment holds
+// a byte outside printable ASCII, so every name in this fixture is flagless. What is asserted here
+// is the agreement, so this still fails if the hand-built record diverges and still passes if the
+// writer changes its rule again
 {
 	const options = makeOptions({ embeddedPdf: PDF });
 	const pageData = makePageData(23, 4 * 1024);
@@ -384,11 +447,14 @@ const ALL_FACE_RUNGS = "<!--sfz-data<script<style<noframes<noembed<iframe<xmp<![
 	const zipReader = new ZipReader(new BlobReader(new Blob([bytes])));
 	const entries = await zipReader.getEntries();
 	await zipReader.close();
-	check("the pdf entry is listed", entries.some(entry => entry.filename == "page.pdf"), true);
-	check("every central record declares utf-8 names", entries.every(entry => entry.filenameUTF8), true);
+	const pdfEntry = entries.find(entry => entry.filename == "page.pdf");
+	check("the pdf entry is listed", Boolean(pdfEntry), true);
+	check("the hand-built central record declares its name like the records the writer produces",
+		entries.every(entry => Boolean(entry.filenameUTF8) == Boolean(pdfEntry.filenameUTF8)), true);
 	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-	const localFlags = entries.map(entry => view.getUint16(entry.offset + 6, true));
-	check("every local header declares utf-8 names", localFlags.every(flags => Boolean(flags & 0x0800)), true);
+	const localFlags = new Map(entries.map(entry => [entry.filename, view.getUint16(entry.offset + 6, true) & 0x0800]));
+	check("the hand-built local header declares its name like the headers the writer produces",
+		[...localFlags.values()].every(flag => flag == localFlags.get("page.pdf")), true);
 }
 
 {