single-file-core 1.5.115 → 1.5.117

package/doc/singlefile-archive.md

@@ -198,12 +198,54 @@ Notes on composition:
 
 ### 2.1 The charset rule
 
-The HTML face declares `<meta charset=utf-8>` when universal mode is off, and a
-single-byte charset when it is on — `windows-1252` in the reference writer. The
-declaration MUST appear within the first 1024 bytes of the file so the parser's
-encoding prescan finds it. The prescan reads exactly that many bytes and does not
-resume, so the whole `<meta>` tag has to fit: one that straddles the boundary is not
-seen, and the parser falls back to its default encoding.
+The HTML face declares `<meta charset=utf-8>` when universal mode is off. When
+universal mode is on it declares a single-byte charset instead — `windows-1252` in the
+reference writer. The declaration MUST appear within the first 1024 bytes of the file
+so the parser's encoding prescan finds it. That bound is the HTML standard's own
+authoring rule. The prescan it serves is weaker than the rule suggests: the standard
+makes it optional, and only *encourages* scanning the first 1024 bytes. Treat the
+number as a ceiling to write under, never as a budget a parser promises to read. The
+whole `<meta>` tag has to fit: one that straddles the boundary is not seen, and the
+parser falls back to its default encoding. Meeting the declaration later, during
+tokenization, does not rescue the file. The parser does not resume the prescan. It
+re-navigates the document under the new encoding instead, and a writer must not rely
+on that.
+
+The declaration decides the decoding only when nothing outranks it. Three things do,
+each returning an encoding with the standard's *certain* confidence, all of them ahead
+of the prescan: a byte order mark, a user's explicit encoding override, and a charset
+stated by the transport layer, which over HTTP means a `Content-Type` header carrying
+its own `charset`. Any of the three replaces the declared charset, the parsed text is
+then not what the writer encoded, and the region cannot be recovered from it. This is
+the one precondition universal mode has that the file cannot satisfy from within
+itself.
+
+Where it bites is narrower than that makes it sound, because the parsed text is the
+last rung, not the first. The bootstrap reads the file's raw bytes whenever it can
+(§4.1), and raw bytes carry no encoding; universal extraction is the fallback for when
+they are out of reach. Taking the three in turn:
+
+- A **transport charset** exists only over HTTP, and over HTTP the raw read is what
+  runs — the bootstrap requests its own URL and takes the response as bytes, which no
+  `Content-Type` can reinterpret. It reaches universal extraction only in a double
+  failure: the response has to defeat the raw read, through a network or CORS failure
+  or a non-200 status, *and* state a charset of its own.
+- A **BOM** is the writer's own doing. It is why universal and PNG variants never carry
+  one (§3.1): the reference writer emits a BOM for the plain variant only
+  (`includeBOM`), where nothing depends on the declared charset.
+- A **user override** is the one no software can prevent, and the rarest.
+
+On `file:` URLs the bootstrap goes straight to page-text extraction, since no raw read
+is available there (§4.1) — but there is also no transport layer, so the first of the
+three cannot arise on the very path that depends on the charset most.
+
+The failure is safe rather than silent, which is why the precondition is worth stating
+at all. Decoded under the wrong charset the reconstructed bytes are wrong, the payload
+checksum does not match, and the extractor MUST fail to the error message (§4.5)
+instead of displaying a corrupt page. A reader MAY tell the case apart from ordinary
+corruption by comparing the encoding the document was actually decoded with —
+`document.characterSet` in a browser — against the declared one, and say so in the
+error message. Nothing requires it, and the MUST is unaffected either way.
 
 Universal mode works in two parts, and the charset carries the first. The archive
 bytes themselves are recovered *from the parsed page text*: the browser decoded
@@ -267,7 +309,7 @@ face adds, then the regions the PNG face adds.
 
 | Region | Producer | Present | Contents |
 |---|---|---|---|
-| `html-prologue` | HTML | HTML face | Doctype, the root element start tag, an optional implementation-defined comment, `<meta charset>`, title, optional head elements (canonical link, `robots` meta, viewport, Content-Security-Policy), minimal CSS, `<body hidden>`, wait/error messages, optional table of contents, optional text body (§4.6). In the plain variant an optional UTF-8 BOM MAY precede the doctype (`includeBOM`); universal and PNG variants never carry one. In the PNG variants the region is split: everything through `<body hidden>` is the data of the `tEXt "PNG"` chunk, while the messages, the optional table of contents and the optional text body follow the `tEXt "ZIP"` chunk header; the doctype and the leading comment are dropped. |
+| `html-prologue` | HTML | HTML face | Doctype, the root element start tag, an optional implementation-defined comment, `<meta charset>`, title, optional head elements (canonical link, `robots` meta, viewport, Content-Security-Policy), minimal CSS, `<body hidden>`, wait/error messages, optional table of contents, optional text body (§4.6). The leading comment, the title, the canonical link and the text body are withheld when a password is set (§5.6). In the plain variant an optional UTF-8 BOM MAY precede the doctype (`includeBOM`); universal and PNG variants never carry one. In the PNG variants the region is split: everything through `<body hidden>` is the data of the `tEXt "PNG"` chunk, while the messages, the optional table of contents and the optional text body follow the `tEXt "ZIP"` chunk header; the doctype and the leading comment are dropped. |
 | `bootstrap` | HTML | HTML face | One inline `<script>`: the embedded ZIP reader, the extractor, the display routine, and the content-acquisition logic (§4.1). The wrapper start tag that opens the ZIP region follows it, directly or after a relocated `extra-data`. |
 | `<!--` / `-->` | HTML | HTML face | The wrapper tag pair hiding a binary region from the HTML parser — comment tags by default, another pair when the hidden bytes contain `-->` (§5.1). Drawn at each opening and closing position. The close tag is absent when appended data is prevented (`preventAppendedData`, or the `<plaintext>` wrapper which cannot close): no markup follows the archive and the wrapper runs to end-of-file. That does not mean the file ends at the EOCD — the PNG face's tail still follows, inside the wrapper, where it parses as text (§5.1). |
 | `zip-entries` | ZIP | always | The archive's local file headers and entry data, written by the ZIP writer. The central directory of an archive written by the reference writer lists `index.html` (the page) first, then `manifest.json` (a JSON description of the archive: original URL, title, save time, resource-to-URL map — informative; the page displays without it), then the resources; the *physical* order of the local headers inside the region is not guaranteed to match, and readers MUST NOT rely on either order — entries are addressed by name (§7.1). |
@@ -307,7 +349,12 @@ change.
 The HTML parser consumes the whole file as one document. Its encoding prescan finds
 the `<meta charset>` declaration within the first 1024 bytes (§2.1) and the file is
 decoded as a single text; every binary region therefore also exists as characters in
-the parsed document, which is what universal mode exploits (§4.5).
+the parsed document, which is what universal mode exploits (§4.5). This holds only
+while the declaration is what decides the decoding: a BOM, a user override or a
+transport-layer charset outranks it, and universal extraction then fails its checksum
+rather than recovering anything (§2.1). The acquisition order below keeps that off the
+common path — the raw bytes are read in preference to the parsed text wherever they
+can be, and no encoding applies to them.
 
 The binary regions are kept out of the rendered page by the wrapper tags. The
 default wrapper is an HTML comment, and the HTML standard defines exactly which
@@ -494,8 +541,10 @@ decoded image is exactly that image.
 
 The last reader is the format's own: the extraction path of universal mode, used
 when the raw bytes are unreachable (§4.1). Its input is not the file but the *parsed
-document* — the characters the HTML parser produced — and its output is the exact
-ZIP region, byte for byte.
+document* — the characters the HTML parser produced — and its output is the ZIP
+region reconstructed byte for byte, with one deliberate exception: the two bytes of
+the EOCD comment-length field, which the payload does not describe and the extractor
+always writes as zero (step 2 below, and the row in §7.4).
 
 It works in three steps:
 
@@ -968,6 +1017,24 @@ The payload itself is a sequence of little-endian 32-bit words — checksum, rec
 range length, newline count, then the codes packed 16 per word, least-significant pair
 first — raw-deflated and base64-encoded with the standard alphabet and padding.
 
+Those word widths cap what the payload can describe. A writer MUST NOT use universal
+mode for a ZIP region of 2^32 bytes or more, since the length field cannot express it.
+The cap is not enforced by the wire format itself: a writer that ignores it stores the
+length modulo 2^32 and produces a file that looks well-formed, and the mismatch
+surfaces only when a reader verifies the field (§4.5). The reference writer is in that
+position — it assigns the length into a `Uint32Array`, where the truncation is silent
+— and reaches the cap in no saved page. This bound and zip64 (§5.7) are separate
+things: zip64 is reachable at any archive size through the 65535-entry trigger and
+stays compatible with universal mode, and it is only a region large enough to need
+zip64's 64-bit *offsets* that runs past what the payload can describe.
+
+An engine limit binds long before the format's. The extractor holds the region as one
+JavaScript string, and the maximum string length is engine-specific: V8 caps it at
+2^29 − 24 characters, 536870888, measured on V8 15.0.245. A universal-mode archive
+whose ZIP region approaches half a gigabyte is therefore already unreadable in Chrome,
+Edge and Node, whatever the payload declares. Other engines set the limit elsewhere.
+The practical ceiling on universal mode is this one, not the 4 GiB above.
+
 ### 5.6 Password scope
 
 A password encrypts the *contents* of ZIP entries with AES, and nothing else. A reader
@@ -982,15 +1049,18 @@ gets no protection beyond that. Four consequences follow:
 - **Entry metadata is never encrypted.** Names, uncompressed sizes and dates remain
   readable in the central directory, so the resource list of an encrypted archive is
   public. This is standard ZIP behavior, not a property of this format; §7 restates it.
-- **What the writer withholds instead.** Three things are not forced into the clear by
-  the format and so are withheld when a password is set: the entry comments, which
-  would otherwise publish every resource's source URL (§4.2); the `<title>` element's
-  text, whose value `manifest.json` carries as an encrypted entry, leaving an empty
-  `<title></title>` in the prologue; and the optional
-  text body, which repeats the whole page text outside the archive (§4.6). Unlike the
-  PNG and PDF faces, none of the three is load-bearing for a reader, so a writer that
-  emits them in a password-protected archive publishes what the password is meant to
-  cover for no gain.
+- **What the writer withholds instead.** Five things are not forced into the clear by
+  the format, and so are withheld when a password is set. Three of them state a URL:
+  the entry comments, which publish every resource's source URL (§4.2), and two
+  prologue fields carrying the address the page was saved from — the provenance
+  comment an implementation may write there, and the canonical `<link>` among the head
+  elements (§3.1). The other two are the `<title>` element's text, leaving an empty
+  `<title></title>` in the prologue, and the optional text body, which repeats the
+  whole page text outside the archive (§4.6). Nothing is lost by leaving any of them
+  out: `manifest.json` holds the page URL, the title and the resource-URL map, and it
+  is an encrypted entry like the rest. Unlike the PNG and PDF faces, none of the five
+  is load-bearing for a reader, so a writer that emits them in a password-protected
+  archive publishes what the password is meant to cover for no gain.
 
 Encrypted entries are stamped AE-2, so their CRC-32 field is zero (§5.4). `page.pdf`
 stays unencrypted, so in a password-protected archive its checksum is the only one a
@@ -1018,6 +1088,12 @@ first by both Info-ZIP and the reference reader, the central directory offset in
 zip64 record points at the injected record, and extraction produces the same page as
 the non-zip64 build.
 
+zip64 does not conflict with universal mode. Its commonest trigger, 65535 entries or
+more, is reached at any archive size, and §4.5 gives the offset arithmetic for a
+recovered region whose EOCD fields are sentinels. What universal mode cannot carry is
+a ZIP region of 2^32 bytes or more, which the recovery payload's 32-bit length field
+cannot express (§5.5) — a size bound, not a zip64 one.
+
 ## 6. Writer algorithm
 
 This section specifies the reference writer's build order. It is normative in the
@@ -1049,9 +1125,11 @@ pages can stop at the first row; the files it produces are accepted by every rea
 2. **HTML prologue.** With the HTML face, emit the doctype (omitted under the PNG
    face, which owns the start of the file), the root element start tag, any comment the
    implementation adds, the `<meta charset>` required by §2.1, the head elements (the
-   `<title>` among them, unless a password is set (§5.6)), the CSS and `<body hidden>`,
+   `<title>` and the canonical link among them), the CSS and `<body hidden>`,
    the wait and error messages, the optional table of contents and text body, and the
-   bootstrap script. With the PNG face the head of this region,
+   bootstrap script. With a password, five of those are left out: the comment, the
+   title, the canonical link, the text body and the entry comments of step 6 (§5.6).
+   With the PNG face the head of this region,
    through `<body hidden>`, is the data of the `tEXt "PNG"` chunk and the remainder is
    emitted after the `tEXt "ZIP"` chunk header in step 12; with the PDF face the
    region is interrupted by step 3 as well.
@@ -1259,10 +1337,13 @@ alongside it.
   Software that displays either MUST do so in a sandboxed context, and MUST NOT run
   the bootstrap in a privileged one. The format's own display path replaces the
   document with the extracted page, which is not an isolation boundary by itself.
-- **A password protects entry contents only** (§5.6). Entry names, sizes, dates and
-  source URLs stay readable, and the PNG, PDF and text-body faces render the page
-  regardless. Software MUST NOT present a password-protected archive as an encrypted
-  document.
+- **A password protects entry contents only** (§5.6). Entry names, sizes and dates
+  stay readable in the central directory, and a name commonly states the resource's
+  filename. The PNG and PDF faces render the page regardless. A conforming writer
+  withholds the five fields of §5.6, the source URLs among them, but a reader MUST NOT
+  read their absence as protection: nothing in the format stops a writer from emitting
+  any of them, so an archive of unknown provenance may state every URL in the clear.
+  Software MUST NOT present a password-protected archive as an encrypted document.
 - **Sniffing disagrees with itself on these files.** `file(1)` reports HTML, PNG, PDF
   or "data" depending on the variant (§8.1), so a server that guesses the media type
   from content may serve a saved page as an image. Software that serves SingleFile
@@ -1285,7 +1366,7 @@ only if it affects the bytes the page is built from:
 | A `tEXt` chunk CRC does not match, or a chunk holds bytes PNG does not permit (§4.4) | Irrelevant to extraction; a reader of the archive MAY ignore both |
 | `page.pdf` is present but its data does not begin with `%PDF-` | Not an error. The entry is data like any other |
 | `index.html` is present without `manifest.json` | **MUST** still extract (§7.1) |
-| More than one node carries the `sfz-data` identifier | **MUST NOT** extract either silently. A conforming writer emits one (§5.1), so a second is a payload that escaped its wrapper — most often a nested archive written by a writer that emitted a face bare. Both candidates extract cleanly and check out, and the checksums say nothing about which one the file was built around |
+| More than one candidate carries the `sfz-data` identifier once §4.5's tie-break has been applied | **MUST NOT** extract either silently. The tie-break comes first and settles the ordinary pairing: an id-bearing element that is one of §5.1's wrapper rungs wins over a comment, and one that is not a rung loses to it, since the `id` is then something else in the page. What this row forbids is what the tie-break does not reach — two elements, or two comments, or an element and a comment that both survive it. A conforming writer emits one candidate (§5.1), so a second is a payload that escaped its wrapper, most often a nested archive written by a writer that emitted a face bare. Both extract cleanly and check out, and the checksums say nothing about which one the file was built around |
 | The recovered region (universal mode) disagrees with the same bytes read directly, in the EOCD's two comment-length bytes only | Expected, not an error. A recovered region always declares a zero-length comment (§4.5), so it differs here from any archive written in the declared form (§4.2). Compare the two only up to those bytes |
 | The recovered region (universal mode) disagrees with the same bytes read directly, anywhere else | The file is not well-formed, whichever side is at fault, and a reader that has both MUST NOT silently merge them or pick per entry. Prefer the direct read — it is the writer's own output, where the recovered region is a reconstruction of it — and surface the disagreement rather than displaying either as intact |
 
@@ -1485,6 +1566,7 @@ predicts.
 | August 2026 | Core 1.5.110: a PDF or PNG face whose payload names every rung is dropped instead of written bare (§5.1). Found by nesting an archive inside itself as both faces: the fifth level exhausts the ladder, and readers then extracted the fourth level's archive — checksums intact, no way to tell (§7.4) |
 | August 2026 | Core 1.5.110: a PNG face leaving the comment rung on its checksum resumes the rung search instead of taking the next rung untested (§5.1). Taking it put a payload holding `</script>` on the script rung, where its own bytes closed the wrapper 93 bytes in and left the image data, the chunk framing and the whole ZIP region to the parser |
 | August 2026 | Core 1.5.110: `<svg><![CDATA[` joins the ladder above `<plaintext>` (§5.1) — the one rung whose terminator, `]]>`, real payloads rarely carry. It gives a payload naming every element rung somewhere to go that does not cost the appended-data placement, and moves the self-nesting limit from the fifth level to the sixth |
+| August 2026 | Core 1.5.115: password-protected archives withhold the provenance comment and the canonical link as well (§5.6). Both wrote the page's own URL into the prologue, beside the title that was already withheld, so the address the archive was saved from stayed in the clear |
 
 This document was itself revised in August 2026, against core 1.5.108, after several
 independent reviews. One of them was a reader built from this specification alone, with
@@ -1506,3 +1588,18 @@ document; the limits of the reconstructed-`page.pdf` CRC check (§4.5); the dura
 ranking of the faces (§1.1); what each face costs a writer (§6); and the silent loss of
 the other faces to a pipeline that repacks the file (§7.2). One review found a live
 defect rather than a documentation one, the non-monotone retry step recorded above.
+
+A later pass found four places where the document contradicted itself or the standard
+it cites: §7.3 stated that source URLs stay readable under a password while §5.6 said
+the writer withholds them, §4.5 called the recovered region exact while excluding two
+bytes from it, §7.4 rejected a duplicate identifier that §4.5 resolves by tie-break,
+and §2.1 described the HTML encoding prescan as mandatory and 1024 bytes wide when the
+standard makes it optional and only encourages that bound. None of the four changes
+what a writer emits or a reader accepts.
+
+The same pass added the two boundaries universal mode had left unstated: that it
+recovers the region only where the declared charset is what decided the decoding, a
+BOM, a user override and a transport-layer charset all outranking it — narrow in
+practice, since the raw read comes first and no encoding applies to it (§2.1) — and that
+the recovery payload's 32-bit length field caps the region below 2^32 bytes, with
+engine string limits binding well before that (§5.5).

package/modules/css-fonts-minifier.js

@@ -41,7 +41,9 @@ const REGEXP_COMMA = /\s*,\s*/;
 const REGEXP_DASH = /-/;
 const REGEXP_QUESTION_MARK = /\?/g;
 const REGEXP_STARTS_U_PLUS = /^U\+/i;
-const REGEXP_CUSTOM_PROPERTY = /var\((--[^),]*)\)/g;
+const REGEXP_CUSTOM_PROPERTY = /var\(\s*(--[^\s,)]+)\s*(?:,[^)]*)?\)/g;
+const REGEXP_CUSTOM_PROPERTY_FAMILY = /^var\(\s*(--[^\s,)]+)\s*(?:,(.*))?\)$/;
+const REGEXP_CUSTOM_PROPERTY_NAME = /^--/;
 const VALID_FONT_STYLES = [/^normal$/, /^italic$/, /^oblique$/, /^oblique\s+/];
 // a family name kept when the "font" shorthand cannot be read: it resolves to nothing, so it
 // survives the substitution below and marks the fonts as undetermined instead of unused
@@ -54,9 +56,19 @@ export {
 function process(doc, stylesheets, styles, options) {
 	const stats = { rules: { processed: 0, discarded: 0 }, fonts: { processed: 0, discarded: 0 } };
 	const fontsInfo = { declared: [], used: [] };
+	const customProperties = new Map();
 	const workStyleElement = doc.createElement("style");
 	let docContent = "";
 	doc.body.appendChild(workStyleElement);
+	// the custom properties are collected first: a family or a "font" shorthand can be resolved
+	// with a property that a later stylesheet, or a style attribute, declares
+	stylesheets.forEach(stylesheetInfo => {
+		if (stylesheetInfo.stylesheet && stylesheetInfo.stylesheet.children) {
+			getCustomPropertiesInfo(stylesheetInfo.stylesheet.children, customProperties);
+		}
+	});
+	styles.forEach(declarations => getCustomProperties(declarations.children, customProperties));
+	options = Object.assign({}, options, { customProperties });
 	stylesheets.forEach(stylesheetInfo => {
 		if (stylesheetInfo.stylesheet) {
 			const cssRules = stylesheetInfo.stylesheet.children;
@@ -77,31 +89,36 @@ function process(doc, stylesheets, styles, options) {
 	});
 	workStyleElement.remove();
 	docContent += doc.body.innerText;
-	if (globalThis.getComputedStyle && options.doc) {
-		fontsInfo.used = fontsInfo.used.map(fontNames => fontNames.map(familyName => {
-			const matchedVar = familyName.match(/^var\((--.*)\)$/);
-			if (matchedVar && matchedVar[1]) {
-				const computedFamilyName = globalThis.getComputedStyle(options.doc.body).getPropertyValue(matchedVar[1]);
-				return (computedFamilyName && computedFamilyName.split(",").map(name => helper.normalizeFontFamily(name))) || familyName;
-			}
-			return familyName;
-		}));
-		fontsInfo.used = fontsInfo.used.map(fontNames => helper.flatten(fontNames));
-	}
+	fontsInfo.used = fontsInfo.used.map(fontNames => fontNames.map(familyName => resolveFamilyName(familyName, options)));
+	fontsInfo.used = fontsInfo.used.map(fontNames => helper.flatten(fontNames));
 	const variableFound = fontsInfo.used.find(fontNames => fontNames.find(fontName => fontName.match(/^var\(--/)));
+	// an empty list of rendered fonts does not mean the document uses none: every rendered element
+	// has a computed font-family, so an empty list means the computed styles could not be read at
+	// all. A frame whose contentDocument is unreachable is re-parsed from its srcdoc with
+	// DOMParser, and that document is never rendered, so it reports nothing and every face it
+	// declares would be dropped
+	const usedFontsUnknown = !options.usedFonts || !options.usedFonts.length;
 	let unusedFonts, filteredUsedFonts;
-	if (variableFound) {
+	if (usedFontsUnknown) {
 		unusedFonts = [];
 	} else {
 		filteredUsedFonts = new Map();
-		fontsInfo.used.forEach(fontNames => fontNames.forEach(familyName => {
-			if (fontsInfo.declared.find(fontInfo => fontInfo.fontFamily == familyName)) {
-				const optionalData = options.usedFonts && options.usedFonts.filter(fontInfo => fontInfo[0] == familyName);
-				if (optionalData && optionalData.length) {
-					filteredUsedFonts.set(familyName, optionalData);
-				}
-			}
-		}));
+		fontsInfo.used.forEach(fontNames => fontNames.forEach(familyName =>
+			keepDeclaredFontIfRendered(familyName, fontsInfo, filteredUsedFonts, options)));
+		// A family named through a value that could not be resolved cannot be looked up in the
+		// stylesheets — but the browser resolved it when it drew the page, so whatever it named is
+		// in the list of fonts actually rendered, and that list answers for it.
+		//
+		// Giving up on the whole document instead, which is what an unresolved name used to do,
+		// kept every declared face on any page holding one unreadable value anywhere while every
+		// other page pruned as usual. That was not a policy about uncertainty: a page that names
+		// its families plainly has always dropped a face it had not drawn yet, and only a page
+		// whose value happened not to parse was spared. The difference came from a parse failure,
+		// so it is the rendered list that decides in both cases now.
+		if (variableFound) {
+			fontsInfo.declared.forEach(fontInfo =>
+				keepDeclaredFontIfRendered(fontInfo.fontFamily, fontsInfo, filteredUsedFonts, options));
+		}
 		unusedFonts = fontsInfo.declared.filter(fontInfo => !filteredUsedFonts.has(fontInfo.fontFamily));
 	}
 	const docChars = Array.from(new Set(docContent)).map(char => char.charCodeAt(0)).sort((value1, value2) => value1 - value2);
@@ -117,6 +134,17 @@ function process(doc, stylesheets, styles, options) {
 	return stats;
 }
 
+// a face is kept when the page declares it and the browser reports having drawn with it: the
+// stylesheets say what exists, the rendered list says what was needed
+function keepDeclaredFontIfRendered(familyName, fontsInfo, filteredUsedFonts, options) {
+	if (fontsInfo.declared.find(fontInfo => fontInfo.fontFamily == familyName)) {
+		const optionalData = options.usedFonts.filter(fontInfo => fontInfo[0] == familyName);
+		if (optionalData.length) {
+			filteredUsedFonts.set(familyName, optionalData);
+		}
+	}
+}
+
 function getFontsInfo(cssRules, fontsInfo, options) {
 	cssRules.forEach(ruleData => {
 		if (ruleData.type == "Atrule" && (ruleData.name == "media" || ruleData.name == "supports" || ruleData.name == "layer" || ruleData.name == "container") && ruleData.block && ruleData.block.children) {
@@ -141,6 +169,126 @@ function getFontsInfo(cssRules, fontsInfo, options) {
 	});
 }
 
+function getCustomPropertiesInfo(cssRules, customProperties) {
+	cssRules.forEach(ruleData => {
+		if (ruleData.type == "Atrule" && ruleData.name == "import" && ruleData.prelude && ruleData.prelude.children && ruleData.prelude.children.head.data.importedChildren) {
+			getCustomPropertiesInfo(ruleData.prelude.children.head.data.importedChildren, customProperties);
+		} else if (ruleData.type == "Atrule" && (ruleData.name == "media" || ruleData.name == "supports" || ruleData.name == "layer" || ruleData.name == "container") && ruleData.block && ruleData.block.children) {
+			getCustomPropertiesInfo(ruleData.block.children, customProperties);
+		} else if (ruleData.type == "Rule" && ruleData.block && ruleData.block.children) {
+			getCustomProperties(ruleData.block.children, customProperties);
+		}
+	});
+}
+
+function getCustomProperties(declarations, customProperties) {
+	if (declarations) {
+		declarations.forEach(declaration => {
+			if (declaration.property && declaration.property.match(REGEXP_CUSTOM_PROPERTY_NAME)) {
+				try {
+					const value = cssTree.generate(declaration.value).trim();
+					if (value) {
+						let values = customProperties.get(declaration.property);
+						if (!values) {
+							values = new Set();
+							customProperties.set(declaration.property, values);
+						}
+						values.add(value);
+					}
+					// eslint-disable-next-line no-unused-vars
+				} catch (error) {
+					// ignored
+				}
+			}
+		});
+	}
+}
+
+function getCustomPropertyValues(name, options) {
+	let values;
+	if (globalThis.getComputedStyle && options.doc) {
+		const computedValue = globalThis.getComputedStyle(options.doc.body).getPropertyValue(name);
+		if (computedValue && computedValue.trim()) {
+			values = [computedValue];
+		}
+	}
+	if (!values) {
+		// the property is not inherited by the body: it is declared on a descendant, or in a
+		// media query that does not apply, so the value seen by the element using it cannot be
+		// determined here. Every value declared for it in the document is taken as a candidate,
+		// which still discards the fonts named by none of them
+		const declaredValues = options.customProperties && options.customProperties.get(name);
+		if (declaredValues && declaredValues.size) {
+			values = Array.from(declaredValues);
+		}
+	}
+	return values;
+}
+
+function resolveFamilyName(familyName, options, resolvedProperties = new Set()) {
+	const matchedVar = familyName.match(REGEXP_CUSTOM_PROPERTY_FAMILY);
+	if (matchedVar) {
+		const propertyName = matchedVar[1];
+		const fallback = matchedVar[2];
+		// a property naming itself, directly or through another one, would resolve for ever: the
+		// chain already walked is carried down the branch so it stops instead
+		if (!resolvedProperties.has(propertyName)) {
+			const properties = new Set(resolvedProperties);
+			properties.add(propertyName);
+			const values = getCustomPropertyValues(propertyName, options);
+			if (values) {
+				const families = helper.flatten(values.map(value => splitFamilyNames(value, options, properties)));
+				const fallbackFamilies = fallback ? splitFamilyNames(fallback, options, properties) : [];
+				// the browser takes the property or the fallback, so knowing one branch is not
+				// knowing the value: a var() left unresolved in either one keeps the family
+				// undetermined, exactly as it was before the nested one could be read at all
+				if (!families.concat(fallbackFamilies).some(testUnresolvedFamilyName)) {
+					return families.concat(fallbackFamilies);
+				}
+			}
+		}
+	}
+	return familyName;
+}
+
+function testUnresolvedFamilyName(familyName) {
+	return typeof familyName == "string" && familyName.startsWith("var(");
+}
+
+function splitFamilyNames(value, options, resolvedProperties) {
+	const familyNames = splitValues(value).map(familyName => normalizeFamilyName(familyName)).filter(familyName => familyName);
+	return options
+		? helper.flatten(familyNames.map(familyName => resolveFamilyName(familyName, options, resolvedProperties)))
+		: familyNames;
+}
+
+// a family list is split on its top-level commas only: the commas inside a var() belong to that
+// var(), and the ones inside a quoted name belong to the name. Splitting on every comma is what
+// made a var() nested in a fallback unreadable, and it also broke a family named "Foo, Bar"
+function splitValues(value) {
+	const values = [];
+	let depth = 0, quote, start = 0;
+	for (let index = 0; index < value.length; index++) {
+		const character = value.charAt(index);
+		if (quote) {
+			if (character == quote && value.charAt(index - 1) != "\\") {
+				quote = null;
+			}
+		} else if (character == "\"" || character == "'") {
+			quote = character;
+		} else if (character == "(") {
+			depth++;
+		} else if (character == ")") {
+			depth--;
+		} else if (character == "," && !depth) {
+			values.push(value.substring(start, index));
+			start = index + 1;
+		}
+	}
+	values.push(value.substring(start));
+	return values;
+}
+
 function filterUnusedFonts(cssRules, declaredFonts, unusedFonts, filteredUsedFonts, docChars) {
 	const removedRules = [];
 	for (let cssRule = cssRules.head; cssRule; cssRule = cssRule.next) {
@@ -266,7 +414,7 @@ function getFontFamilyNames(declarations, options) {
 		} else {
 			fontFamilyName = cssTree.generate(fontFamilyName.data.value);
 			if (fontFamilyName) {
-				fontFamilyNames.push(helper.normalizeFontFamily(fontFamilyName));
+				fontFamilyNames.push(normalizeFamilyName(fontFamilyName));
 			}
 		}
 	}
@@ -280,7 +428,7 @@ function getFontFamilyNames(declarations, options) {
 				value = cssTree.parse(resolvedFontValue, { context: "value" });
 			}
 			const parsedFont = fontPropertyParser.parse(value);
-			parsedFont.family.forEach(familyName => fontFamilyNames.push(helper.normalizeFontFamily(familyName)));
+			parsedFont.family.forEach(familyName => fontFamilyNames.push(normalizeFamilyName(familyName)));
 			// eslint-disable-next-line no-unused-vars
 		} catch (error) {
 			// the shorthand is unreadable, and dropping it here would count the fonts it names as
@@ -294,12 +442,17 @@ function getFontFamilyNames(declarations, options) {
 }
 
 function resolveCustomProperties(value, options) {
-	if (globalThis.getComputedStyle && options.doc) {
-		const computedStyle = globalThis.getComputedStyle(options.doc.body);
-		return value.replace(REGEXP_CUSTOM_PROPERTY, (property, name) => computedStyle.getPropertyValue(name) || property);
-	} else {
-		return value;
-	}
+	return value.replace(REGEXP_CUSTOM_PROPERTY, (property, name) => {
+		const values = getCustomPropertyValues(name, options);
+		// the shorthand is parsed as a whole, so it can only be substituted with a single value:
+		// with several candidates the families it names stay undetermined
+		return values && values.length == 1 ? values[0] : property;
+	});
+}
+
+function normalizeFamilyName(familyName = "") {
+	// custom property names are case-sensitive, unlike family names
+	return familyName.match(REGEXP_CUSTOM_PROPERTY_FAMILY) ? familyName.trim() : helper.normalizeFontFamily(familyName);
 }
 
 function parseFamilyNames(fontFamilyNameTokenData, fontFamilyNames) {
@@ -307,16 +460,19 @@ function parseFamilyNames(fontFamilyNameTokenData, fontFamilyNames) {
 	while (nextToken) {
 		if (nextToken.data.type == "Identifier") {
 			let familyName = nextToken.data.name;
+			// an unquoted family name is a sequence of identifiers, and the walk has to resume
+			// after the last of them: resuming after the first pushes every word but that one
+			// again as a family of its own, so "Foo Bar" also claims a font-face named "Bar"
 			let nextIdentifierToken = nextToken.next;
-			while (nextIdentifierToken && nextIdentifierToken.data.type != "Operator" && nextIdentifierToken.data.value != ",") {
+			while (nextIdentifierToken && nextIdentifierToken.data.type == "Identifier") {
 				familyName += " " + nextIdentifierToken.data.name;
 				nextIdentifierToken = nextIdentifierToken.next;
 			}
 			fontFamilyNames.push(helper.normalizeFontFamily(familyName));
-			nextToken = nextToken.next;
+			nextToken = nextIdentifierToken;
 		} else if (nextToken.data.type == "Function" && nextToken.data.name == "var" && nextToken.data.children) {
 			const varName = nextToken.data.children.head.data.name;
-			fontFamilyNames.push(helper.normalizeFontFamily("var(" + varName + ")"));
+			fontFamilyNames.push("var(" + varName + ")");
 			let nextValueToken = nextToken.data.children.head.next;
 			while (nextValueToken && nextValueToken.data.type == "Operator" && nextValueToken.data.value == ",") {
 				nextValueToken = nextValueToken.next;
@@ -326,7 +482,9 @@ function parseFamilyNames(fontFamilyNameTokenData, fontFamilyNames) {
 				if (fallbackToken.data.children) {
 					parseFamilyNames(fallbackToken.data, fontFamilyNames);
 				} else {
-					fontFamilyNames.push(helper.normalizeFontFamily(fallbackToken.data.value));
+					// the fallback of a var() is parsed as a single raw token, so it still has to
+					// be split into the list of families it may hold
+					splitFamilyNames(String(fallbackToken.data.value)).forEach(familyName => fontFamilyNames.push(familyName));
 				}
 			}
 			nextToken = nextToken.next;

package/modules/css-rules-minifier.js

@@ -51,6 +51,7 @@ const SELECTOR_LIST_CONTEXT = "selectorList";
 const STYLESHEET_CONTEXT = "stylesheet";
 const SELECTOR_CONTEXT = "selector";
 const DECLARATION_LIST_CONTEXT = "declarationList";
+const UNKNOWN_PROPERTY_ERROR_NAME = "SyntaxReferenceError";
 const PARSE_CSS_ERROR_MESSAGE = "Failed to parse CSS";
 const QSA_ERROR_MESSAGE = "Failed to match selector";
 const PRELUDE_SEPARATOR = ",";
@@ -69,9 +70,15 @@ const INVALID_CSS_ESCAPE_TEST = /\\(?![0-9a-fA-F]{1,6}\s|[^0-9a-zA-Z])/;
 const ANONYMOUS_LAYER_PLACEHOLDER = "\u0000";
 
 export {
-	process
+	process,
+	isUnsupportedPropertyValue
 };
 
+function isUnsupportedPropertyValue(property, value) {
+	const match = cssTree.lexer.matchProperty(property, value);
+	return Boolean(!match.matched && match.error && match.error.name !== UNKNOWN_PROPERTY_ERROR_NAME);
+}
+
 function process(doc, stylesheets) {
 	const docContext = {
 		doc,
@@ -493,7 +500,7 @@ function collectDeclarationItemsForElement(element, docContext) {
 				isInvalidValue = value.children.head.data.name.startsWith(VENDOR_PREFIX) || INVALID_CSS_ESCAPE_TEST.test(value.children.head.data.name);
 			} if (!property.startsWith(VENDOR_PREFIX) && value.children.head.data.value) {
 				try {
-					isInvalidValue = !cssTree.lexer.matchProperty(property, value).matched;
+					isInvalidValue = isUnsupportedPropertyValue(property, value);
 				} catch {
 					// ignored
 				}

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "single-file-core",
-  "version": "1.5.115",
+  "version": "1.5.117",
   "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",
+    "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",
     "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/processors/compression/compression-display.js

@@ -23,13 +23,34 @@
 
 /* global DOMParser, setTimeout */
 
-import { getDoctypeString } from "./../../core/lib/doctype.js";
-
 export {
 	display
 };
 
+// the functions below are serialized with toString() and pasted into the page the archive
+// generates, where module scope does not exist: everything they call must be declared inside
+// them. An import would survive bundling and then be an undefined free variable at runtime
 async function display(document, docContent, { disableFramePointerEvents, inPlace } = {}) {
+	function getDoctypeString(doc) {
+		const docType = doc.doctype;
+		let docTypeString = "";
+		if (docType) {
+			docTypeString = "<!DOCTYPE " + docType.nodeName;
+			if (docType.publicId) {
+				docTypeString += " PUBLIC \"" + docType.publicId + "\"";
+				if (docType.systemId) {
+					docTypeString += " \"" + docType.systemId + "\"";
+				}
+			} else if (docType.systemId) {
+				docTypeString += " SYSTEM \"" + docType.systemId + "\"";
+			}
+			if (docType.internalSubset) {
+				docTypeString += " [" + docType.internalSubset + "]";
+			}
+			docTypeString += ">";
+		}
+		return docTypeString;
+	}
 	docContent = docContent.replace(/<noscript/gi, "<template disabled-noscript");
 	docContent = docContent.replace(/<\/noscript/gi, "</template");
 	const doc = (new DOMParser()).parseFromString(docContent, "text/html");