single-file-core 1.6.4 → 1.6.6

package/modules/css-fonts-minifier.js

@@ -48,6 +48,8 @@ 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+/];
+const NON_GLYPH_CHAR_CODES = [9, 10, 12, 13];
+const MAX_NON_GLYPH_CHAR_CODE = 13;
 // 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
 const UNRESOLVED_CUSTOM_PROPERTY_FAMILY = "var(--)";
@@ -125,11 +127,12 @@ function process(doc, stylesheets, styles, 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);
+	const usedFontsCharacters = getUsedFontsCharacters(options);
 	stylesheets.forEach(stylesheetInfo => {
 		if (stylesheetInfo.stylesheet) {
 			const cssRules = stylesheetInfo.stylesheet.children;
 			if (cssRules) {
-				filterUnusedFonts(cssRules, fontsInfo.declared, unusedFonts, filteredUsedFonts, docChars);
+				filterUnusedFonts(cssRules, fontsInfo.declared, unusedFonts, filteredUsedFonts, docChars, usedFontsCharacters);
 				stats.rules.discarded -= cssRules.size;
 			}
 		}
@@ -164,8 +167,9 @@ function getFontsInfo(cssRules, fontsInfo, options) {
 					const fontWeight = getDeclarationValue(ruleData.block.children, "font-weight") || "400";
 					const fontStyle = getDeclarationValue(ruleData.block.children, "font-style") || "normal";
 					const fontVariant = getDeclarationValue(ruleData.block.children, "font-variant") || "normal";
+					const unicodeRange = getDeclarationValue(ruleData.block.children, "unicode-range");
 					fontWeight.split(",").forEach(weightValue =>
-						fontsInfo.declared.push({ fontFamily, fontWeight: helper.getFontWeight(helper.removeQuotes(weightValue)), fontStyle, fontVariant }));
+						fontsInfo.declared.push({ fontFamily, fontWeight: helper.getFontWeight(helper.removeQuotes(weightValue)), fontStyle, fontVariant, unicodeRange, ruleData }));
 				}
 			}
 		}
@@ -292,19 +296,24 @@ function splitValues(value) {
 	return values;
 }
 
-function filterUnusedFonts(cssRules, declaredFonts, unusedFonts, filteredUsedFonts, docChars) {
+function filterUnusedFonts(cssRules, declaredFonts, unusedFonts, filteredUsedFonts, docChars, usedFontsCharacters) {
 	const removedRules = [];
 	for (let cssRule = cssRules.head; cssRule; cssRule = cssRule.next) {
 		const ruleData = cssRule.data;
 		if (ruleData.type == "Atrule" && ruleData.name == "import" && ruleData.prelude && ruleData.prelude.children && ruleData.prelude.children.head.data.importedChildren) {
-			filterUnusedFonts(ruleData.prelude.children.head.data.importedChildren, declaredFonts, unusedFonts, filteredUsedFonts, docChars);
+			filterUnusedFonts(ruleData.prelude.children.head.data.importedChildren, declaredFonts, unusedFonts, filteredUsedFonts, docChars, usedFontsCharacters);
 		} else if (ruleData.type == "Atrule" && (ruleData.name == "media" || ruleData.name == "supports" || ruleData.name == "layer" || ruleData.name == "container") && ruleData.block && ruleData.block.children) {
-			filterUnusedFonts(ruleData.block.children, declaredFonts, unusedFonts, filteredUsedFonts, docChars);
+			filterUnusedFonts(ruleData.block.children, declaredFonts, unusedFonts, filteredUsedFonts, docChars, usedFontsCharacters);
 		} else if (ruleData.type == "Atrule" && ruleData.name == "font-face") {
 			const fontFamily = helper.normalizeFontFamily(getDeclarationValue(ruleData.block.children, "font-family"));
 			if (fontFamily) {
 				const unicodeRange = getDeclarationValue(ruleData.block.children, "unicode-range");
-				if (unusedFonts.find(fontInfo => fontInfo.fontFamily == fontFamily) || !testUnicodeRange(docChars, unicodeRange) || !testUsedFont(ruleData, fontFamily, declaredFonts, filteredUsedFonts)) {
+				const laterUnicodeRanges = getLaterUnicodeRanges(declaredFonts, ruleData);
+				if (unusedFonts.find(fontInfo => fontInfo.fontFamily == fontFamily) ||
+					!testUnicodeRange(docChars, unicodeRange) ||
+					!testReachableUnicodeRange(docChars, unicodeRange, laterUnicodeRanges) ||
+					!testDrawnUnicodeRange(ruleData, fontFamily, unicodeRange, usedFontsCharacters) ||
+					!testUsedFont(ruleData, fontFamily, declaredFonts, filteredUsedFonts)) {
 					removedRules.push(cssRule);
 				}
 			}
@@ -322,6 +331,71 @@ function filterUnusedFonts(cssRules, declaredFonts, unusedFonts, filteredUsedFon
 	removedRules.forEach(cssRule => cssRules.remove(cssRule));
 }
 
+function getUsedFontsCharacters(options) {
+	const usedFontsCharacters = new Map();
+	if (options.usedFontsCharacters && options.usedFontsCharacters.length) {
+		options.usedFontsCharacters.forEach(([fontFamily, fontStyle, ranges, unknown]) => {
+			let buckets = usedFontsCharacters.get(fontFamily);
+			if (!buckets) {
+				buckets = [];
+				usedFontsCharacters.set(fontFamily, buckets);
+			}
+			buckets.push({ fontStyle, ranges: ranges || [], unknown: Boolean(unknown) });
+		});
+	}
+	return usedFontsCharacters;
+}
+
+function testDrawnUnicodeRange(ruleData, familyName, unicodeRange, usedFontsCharacters) {
+	if (!unicodeRange || !usedFontsCharacters || !usedFontsCharacters.size) {
+		return true;
+	}
+	const buckets = usedFontsCharacters.get(familyName);
+	if (!buckets || !buckets.length) {
+		return true;
+	}
+	const fontStyle = getDeclarationValue(ruleData.block.children, "font-style") || "normal";
+	if (!VALID_FONT_STYLES.find(rule => fontStyle.trim().match(rule))) {
+		return true;
+	}
+	const matchedBuckets = buckets.filter(bucket => testFontStyle(bucket.fontStyle, fontStyle));
+	if (!matchedBuckets.length || matchedBuckets.find(bucket => bucket.unknown)) {
+		return true;
+	}
+	if (!matchedBuckets.find(bucket => bucket.ranges.length)) {
+		return true;
+	}
+	const ranges = parseUnicodeRanges(unicodeRange);
+	if (!ranges.length) {
+		return true;
+	}
+	return Boolean(matchedBuckets.find(bucket =>
+		bucket.ranges.find(drawnRange =>
+			ranges.find(range => testDrawnGlyph(drawnRange, range)))));
+}
+
+// A tab or a newline is recorded as drawn like any other character, but neither can ever select a
+// glyph, so a face whose unicode-range meets the page in nothing else is dead however the page is
+// laid out. Google Fonts symbol subsets are exactly that shape: measured on a capture of
+// techcrunch.com, two Roboto faces worth 23,505 bytes matched the document in U+0009 and U+000A and
+// nothing more.
+function testDrawnGlyph(drawnRange, range) {
+	const fromCharCode = Math.max(drawnRange[0], range[0]);
+	const toCharCode = Math.min(drawnRange[1], range[1]);
+	if (fromCharCode > toCharCode) {
+		return false;
+	}
+	if (fromCharCode > MAX_NON_GLYPH_CHAR_CODE || toCharCode > MAX_NON_GLYPH_CHAR_CODE) {
+		return true;
+	}
+	for (let charCode = fromCharCode; charCode <= toCharCode; charCode++) {
+		if (!NON_GLYPH_CHAR_CODES.includes(charCode)) {
+			return true;
+		}
+	}
+	return false;
+}
+
 function testUsedFont(ruleData, familyName, declaredFonts, filteredUsedFonts) {
 	let test;
 	const optionalUsedFonts = filteredUsedFonts && filteredUsedFonts.get(familyName);
@@ -389,7 +463,7 @@ function testFontweight(fontWeight, usedFontWeights) {
 	for (const fontWeightValue of fontWeight.split(",")) {
 		let { min: fontWeightMin, max: fontWeightMax } = parseFontWeight(fontWeightValue);
 		if (!fontWeightMax) {
-			fontWeightMax = 900;
+			fontWeightMax = fontWeightMin;
 		}
 		test = test || usedFontWeights.find(usedFontWeight => {
 			let { min: usedFontWeightMin, max: usedFontWeightMax } = parseFontWeight(usedFontWeight);
@@ -631,6 +705,64 @@ function testUnicodeRange(docCharCodes, unicodeRange) {
 	return true;
 }
 
+function getLaterUnicodeRanges(declaredFonts, ruleData) {
+	const index = declaredFonts.findIndex(fontInfo => fontInfo.ruleData == ruleData);
+	if (index == -1) {
+		return [];
+	}
+	const { fontFamily, fontWeight, fontStyle } = declaredFonts[index];
+	return declaredFonts
+		.slice(index + 1)
+		.filter(fontInfo => fontInfo.ruleData != ruleData &&
+			fontInfo.fontFamily == fontFamily &&
+			fontInfo.fontWeight == fontWeight &&
+			fontInfo.fontStyle == fontStyle)
+		.map(fontInfo => fontInfo.unicodeRange);
+}
+
+function testReachableUnicodeRange(docCharCodes, unicodeRange, laterUnicodeRanges) {
+	if (!laterUnicodeRanges.length) {
+		return true;
+	}
+	const laterRanges = helper.flatten(laterUnicodeRanges.map(laterUnicodeRange => parseUnicodeRanges(laterUnicodeRange)));
+	if (!laterRanges.length) {
+		return true;
+	}
+	const ranges = parseUnicodeRanges(unicodeRange);
+	return Boolean(docCharCodes.find(charCode =>
+		(!ranges.length || ranges.find(range => testCharCodeInRange(charCode, range))) &&
+		!laterRanges.find(range => testCharCodeInRange(charCode, range))));
+}
+
+function testCharCodeInRange(charCode, range) {
+	return charCode >= range[0] && charCode <= range[1];
+}
+
+function parseUnicodeRanges(unicodeRange) {
+	const ranges = [];
+	if (unicodeRange) {
+		unicodeRange.split(REGEXP_COMMA).forEach(rangeValue => {
+			const range = rangeValue.split(REGEXP_DASH);
+			let min, max;
+			if (range.length == 2) {
+				min = transformRange(range[0]);
+				max = transformRange(range[1]);
+			} else if (range.length == 1 && range[0]) {
+				if (range[0].includes("?")) {
+					min = transformRange(range[0].replace(REGEXP_QUESTION_MARK, "0"));
+					max = transformRange(range[0].replace(REGEXP_QUESTION_MARK, "F"));
+				} else {
+					min = max = transformRange(range[0]);
+				}
+			}
+			if (Number.isInteger(min) && Number.isInteger(max)) {
+				ranges.push([min, max]);
+			}
+		});
+	}
+	return ranges;
+}
+
 function transformRange(range) {
 	range = range.replace(REGEXP_STARTS_U_PLUS, "");
 	return parseInt(range, 16);

package/modules/css-rules-minifier.js

@@ -24,11 +24,12 @@
 import * as cssTree from "./../vendor/css-tree.js";
 import { computeMaxSpecificity } from "./css-specificity.js";
 import { parsePrelude } from "./css-scope-prelude-parser.js";
-import { sanitizeSelector, matchUnqueryablePseudoClass } from "./css-selector-sanitizer.js";
+import { sanitizeSelector, matchUnqueryableAttributeSelector, matchUnqueryablePseudoClass } from "./css-selector-sanitizer.js";
 
 const DEBUG = false;
 
 const PSEUDO_ELEMENT_SYNONYMS = new Set(["after", "before", "first-letter", "first-line"]);
+const FUNCTIONAL_PSEUDO_CLASS_NAMES = new Set(["not", "is", "where", "has"]);
 const MEDIA_AT_RULE_NAME = "media";
 const SUPPORTS_AT_RULE_NAME = "supports";
 const CONDITIONAL_AT_RULE_NAMES = new Set([MEDIA_AT_RULE_NAME, SUPPORTS_AT_RULE_NAME, "container"]);
@@ -36,6 +37,7 @@ const RULE_TYPE = "Rule";
 const AT_RULE_TYPE = "Atrule";
 const NESTING_SELECTOR_TYPE = "NestingSelector";
 const PSEUDO_CLASS_SELECTOR_TYPE = "PseudoClassSelector";
+const ATTRIBUTE_SELECTOR_TYPE = "AttributeSelector";
 const DECLARATION_TYPE = "Declaration";
 const RAW_TYPE = "Raw";
 const VALUE_TYPE = "Value";
@@ -390,17 +392,20 @@ function processSelectors(ruleData, processingContext, docContext) {
 	for (let selector = ruleData.prelude.children.head, selectorIndex = 0; selector; selector = selector.next, selectorIndex++) {
 		const {
 			startsWithCombinator,
-			hasUnqueryableSelector
+			hasUnqueryableSelector,
+			hasNestedUnqueryablePseudoClass
 		} = analyzeSelector(selector.data);
 		if (hasUnqueryableSelector) {
 			ruleData.hasUnqueryableSelector = true;
 		}
 		registerSelector(selector, ruleData, processingContext, docContext);
-		if (!hasUnqueryableSelector && (!startsWithCombinator || !ancestorsSelectors || !ancestorsSelectors.length)) {
+		if (!startsWithCombinator || !ancestorsSelectors || !ancestorsSelectors.length) {
 			const matchedElements = matchElements(selector, ancestorsSelectors, processingContext.scopeStack, docContext);
 			if (matchedElements.length) {
-				updateMatchingSelectors(matchedElements, selector, docContext);
-			} else {
+				if (!hasUnqueryableSelector) {
+					updateMatchingSelectors(matchedElements, selector, docContext);
+				}
+			} else if (!hasNestedUnqueryablePseudoClass) {
 				removedSelectors.push(selector);
 			}
 		}
@@ -410,21 +415,42 @@ function processSelectors(ruleData, processingContext, docContext) {
 
 function analyzeSelector(selector) {
 	let hasUnqueryableSelector = false;
+	let hasNestedUnqueryablePseudoClass = false;
 	let startsWithCombinator = false;
+	let functionalPseudoClassDepth = 0;
 	cssTree.walk(selector, {
 		enter(node) {
 			if (node.type === PSEUDO_ELEMENT_SELECTOR_TYPE) {
 				hasUnqueryableSelector = true;
+				if (functionalPseudoClassDepth) {
+					hasNestedUnqueryablePseudoClass = true;
+				}
 			} else if (node.type === PSEUDO_CLASS_SELECTOR_TYPE) {
 				if (PSEUDO_ELEMENT_SYNONYMS.has(node.name) || matchUnqueryablePseudoClass(node)) {
 					hasUnqueryableSelector = true;
+					if (functionalPseudoClassDepth) {
+						hasNestedUnqueryablePseudoClass = true;
+					}
 				}
+				if (FUNCTIONAL_PSEUDO_CLASS_NAMES.has(node.name.toLowerCase())) {
+					functionalPseudoClassDepth++;
+				}
+			} else if (node.type === ATTRIBUTE_SELECTOR_TYPE && matchUnqueryableAttributeSelector(node)) {
+				hasUnqueryableSelector = true;
+				if (functionalPseudoClassDepth) {
+					hasNestedUnqueryablePseudoClass = true;
+				}
+			}
+		},
+		leave(node) {
+			if (node.type === PSEUDO_CLASS_SELECTOR_TYPE && FUNCTIONAL_PSEUDO_CLASS_NAMES.has(node.name.toLowerCase())) {
+				functionalPseudoClassDepth--;
 			}
 		}
 	});
 	const firstChild = selector.children.head.data;
 	startsWithCombinator = firstChild && firstChild.type === COMBINATOR_NAME;
-	return { hasUnqueryableSelector, startsWithCombinator };
+	return { hasUnqueryableSelector, hasNestedUnqueryablePseudoClass, startsWithCombinator };
 }
 
 function updateMatchingSelectors(matchedElements, selector, docContext) {

package/modules/css-selector-sanitizer.js

@@ -47,7 +47,11 @@ const FUNCTIONAL_PSEUDO_CLASSES = [
     "where",
     "has"
 ];
+const STATE_ATTRIBUTE_NAMES = [
+    "open"
+];
 export {
+    matchUnqueryableAttributeSelector,
     matchUnqueryablePseudoClass,
     sanitizeSelector,
 };
@@ -97,6 +101,10 @@ function normalizeSelectorNode(selector, ancestors) {
             if (matchUnqueryablePseudoClass(childNode)) {
                 removeNode(selector.children, current);
             }
+        } else if (childNode.type === "AttributeSelector") {
+            if (matchUnqueryableAttributeSelector(childNode)) {
+                removeNode(selector.children, current);
+            }
         } else if (childNode.type === "Selector") {
             normalizeSelectorNode(childNode, ancestors);
         }
@@ -112,6 +120,10 @@ function removeNode(list, item) {
     }
 }
 
+function matchUnqueryableAttributeSelector(attributeSelector) {
+    return Boolean(attributeSelector.name) && STATE_ATTRIBUTE_NAMES.includes(attributeSelector.name.name.toLowerCase());
+}
+
 function matchUnqueryablePseudoClass(pseudoClass) {
     const name = pseudoClass.name.toLowerCase();
     return pseudoClass.children ? (

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "single-file-core",
-	"version": "1.6.4",
+	"version": "1.6.6",
 	"description": "SingleFile Core",
 	"author": "Gildas Lormeau",
 	"license": "AGPL-3.0-or-later",

package/processors/compression/compression-packager.js

@@ -26,6 +26,7 @@
 import {
 	configure,
 	TextReader,
+	TextWriter,
 	Uint8ArrayReader,
 	Uint8ArrayWriter,
 	ZipReader
@@ -40,6 +41,7 @@ const browser = globalThis.browser;
 
 const PAGES_PREFIX = "pages/";
 const PAGES_FILENAME = "sfz-pages.json";
+const MANIFEST_FILENAME = "manifest.json";
 const TOC_FILENAME = "sfz-toc.html";
 const TOC_TITLE = "Table of contents";
 const TOC_STYLE = "body{font-family:system-ui,sans-serif;margin:2em auto;max-width:40em;padding:0 1em;background-color:#fff;color:#000}" +
@@ -102,6 +104,12 @@ async function createPagesArchive(pages, options) {
 			for (const entry of await zipReader.getEntries()) {
 				const filename = pagePath + entry.filename;
 				const rawData = entry.directory ? undefined : await entry.getData(new Uint8ArrayWriter(), { passThrough: true, checkCrc32: false });
+				if (entry.filename == MANIFEST_FILENAME && !entry.encrypted) {
+					const { archiveTime } = JSON.parse(await entry.getData(new TextWriter()));
+					if (archiveTime) {
+						manifest.pages[pageIndex].archiveTime = archiveTime;
+					}
+				}
 				const canonicalFilename = writtenEntries && findDuplicate(writtenEntries, filename, entry, rawData);
 				if (canonicalFilename === undefined) {
 					await zipWriter.add(filename, entry.directory ? null : new Uint8ArrayReader(rawData), {

package/processors/compression/compression.js

@@ -95,6 +95,7 @@ const MAX_ZIP_COMMENT_LENGTH = 65535;
 const PDF_ENTRY_FILENAME = "page.pdf";
 const PRESCAN_WINDOW_LENGTH = 1024;
 const PNG_TEXT_CHUNK_HEADER_LENGTH = 12;
+const PNG_LENGTH_PADDING_LENGTH = 1;
 const PNG_ZIP_CHUNK_TYPE_KEYWORD = new Uint8Array([0x74, 0x45, 0x58, 0x74, 0x5a, 0x49, 0x50, 0]);
 const MAX_HIDDEN_PNG_CHUNK_LENGTH = 0x2D000000;
 const WRAPPER_PATTERN_WINDOW_LENGTH = 12;
@@ -277,7 +278,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 > getMaxAppendedDataLength(options) - 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 + PNG_LENGTH_PADDING_LENGTH : 0)) {
 				if (!options.extraDataSize) {
 					options.preventAppendedData = true;
 					options.extraDataSize = getReservationSize(extraData.length);
@@ -288,7 +289,11 @@ async function buildArchive(pageData, options, script, entriesData, zipWriterOpt
 			}
 		}
 		pageContent += endTags;
-		await writeData(zipDataWriter.writable, (new TextEncoder()).encode(pageContent));
+		let pageContentData = new TextEncoder().encode(pageContent);
+		if (options.embeddedImage && !isChunkLengthHidden(data, embeddedImageDataOffset, zipDataWriter.offset + pageContentData.length - embeddedImageDataOffset - 4, imageChunk.tagIndex)) {
+			pageContentData = concatArrays(pageContentData, new Uint8Array(PNG_LENGTH_PADDING_LENGTH).fill(0x20));
+		}
+		await writeData(zipDataWriter.writable, pageContentData);
 	}
 	await zipDataWriter.writable.close();
 	const pageContent = await zipDataWriter.getData();
@@ -337,6 +342,15 @@ function isDeclaredLengthHidden(pageContent, zipDataEnd, appendedDataLength, opt
 	return !containsDataPattern(tail, EMBEDDED_DATA_PATTERNS[tagIndex]);
 }
 
+function isChunkLengthHidden(data, embeddedImageDataOffset, chunkLength, tagIndex) {
+	const lengthOffset = embeddedImageDataOffset - 4;
+	const window = concatArrays(
+		data.subarray(Math.max(0, lengthOffset - WRAPPER_PATTERN_WINDOW_LENGTH), lengthOffset),
+		getLength(chunkLength),
+		data.subarray(embeddedImageDataOffset, embeddedImageDataOffset + PNG_ZIP_CHUNK_TYPE_KEYWORD.length));
+	return !containsDataPattern(window, EMBEDDED_DATA_PATTERNS[tagIndex]);
+}
+
 function getCRC32(data, indexData = 0) {
 	const crcArray = new Uint8Array(4);
 	setUint32(crcArray, getCRC32Value(data, indexData));
@@ -723,7 +737,7 @@ function getImageHTMLChunk(pageData, options, lastModDate) {
 			findEmbeddedDataTagIndex(wrappedData, tagIndex) != tagIndex) {
 			tagIndex = findEmbeddedDataTagIndex(embeddedImageData, tagIndex + 1);
 		} else {
-			return { endTag, startHTMLData, htmlData, htmlDataCRC };
+			return { tagIndex, endTag, startHTMLData, htmlData, htmlDataCRC };
 		}
 	}
 }
@@ -798,6 +812,7 @@ function isCompressibleContentType(contentType) {
 async function getContent() {
 	const BASE64_TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 	const DATA_IDENTIFIER = "sfz-data";
+	const WRAPPER_TAG_NAMES = ["script", "style", "noframes", "noembed", "iframe", "xmp", "svg", "plaintext"];
 	const { Blob, XMLHttpRequest, NodeFilter, document, zip, location } = globalThis;
 	const characterMap = new Map([
 		[65533, 0], [8364, 128], [8218, 130], [402, 131], [8222, 132], [8230, 133], [8224, 134], [8225, 135], [710, 136], [8240, 137],
@@ -902,15 +917,22 @@ async function getContent() {
 		if (zipDataElement) {
 			const inflatedPayload = zip.inflateRaw(base64Decode(zipDataElement.textContent));
 			const payload = new DataView(inflatedPayload.buffer, inflatedPayload.byteOffset, inflatedPayload.length & -4);
-			const dataElement = document.getElementById(DATA_IDENTIFIER);
-			if (dataElement) {
-				return decodeZipData(dataElement, payload, 0);
-			}
-			const walker = document.createTreeWalker(document, NodeFilter.SHOW_COMMENT);
-			while (walker.nextNode()) {
-				if (walker.currentNode.data.startsWith(DATA_IDENTIFIER)) {
-					return decodeZipData(walker.currentNode, payload, DATA_IDENTIFIER.length);
+			const candidates = Array.from(document.querySelectorAll("[id=" + DATA_IDENTIFIER + "]")).filter(element => WRAPPER_TAG_NAMES.includes(element.localName));
+			let startIndex = 0;
+			if (!candidates.length) {
+				const walker = document.createTreeWalker(document, NodeFilter.SHOW_COMMENT);
+				while (walker.nextNode()) {
+					if (walker.currentNode.data.startsWith(DATA_IDENTIFIER)) {
+						candidates.push(walker.currentNode);
+					}
 				}
+				startIndex = DATA_IDENTIFIER.length;
+			}
+			if (candidates.length > 1) {
+				throw new Error("Multiple zip data candidates found");
+			}
+			if (candidates.length) {
+				return decodeZipData(candidates[0], payload, startIndex);
 			}
 		}
 		throw new Error("Extra zip data not found");

package/processors/frame-tree/content/content-frame-tree.js

@@ -231,6 +231,7 @@ function initResponse(message) {
 				frameData.posters = messageFrameData.posters;
 				frameData.videos = messageFrameData.videos;
 				frameData.usedFonts = messageFrameData.usedFonts;
+				frameData.usedFontsCharacters = messageFrameData.usedFontsCharacters;
 				frameData.shadowRoots = messageFrameData.shadowRoots;
 				frameData.processed = messageFrameData.processed;
 				frameData.scrollPosition = messageFrameData.scrollPosition;
@@ -453,6 +454,7 @@ function getFrameData(document, win, windowId, options, scrolling) {
 		posters: docData.posters,
 		videos: docData.videos,
 		usedFonts: docData.usedFonts,
+		usedFontsCharacters: docData.usedFontsCharacters,
 		shadowRoots: docData.shadowRoots,
 		scrollPosition: docData.scrollPosition,
 		scrolling,

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

@@ -586,7 +586,9 @@
 				if (adoptedStylesheetsData.has(stylesheet)) {
 					return adoptedStylesheetsData.get(stylesheet);
 				} else {
-					return Array.from(stylesheet.cssRules).map(cssRule => cssRule.cssText).join("\n");
+					const text = Array.from(stylesheet.cssRules).map(cssRule => cssRule.cssText).join("\n");
+					adoptedStylesheetsData.set(stylesheet, text);
+					return text;
 				}
 			});
 			if (adoptedStyleSheets.length) {

package/single-file-infobar.js

@@ -54,7 +54,7 @@ import { appendInfobar, refreshInfobarInfo, extractInfobarData } from "./core/in
 	}
 
 	async function displayIcon() {
-		let options = { displayInfobar: true };
+		let options = { displayInfobar: true, animateInfobar: true };
 		const infoData = extractInfobarData(document);
 		if (infoData && infoData.saveUrl) {
 			if (browser && browser.runtime && browser.runtime.sendMessage) {
@@ -67,6 +67,7 @@ import { appendInfobar, refreshInfobarInfo, extractInfobarData } from "./core/in
 			}
 			if (options.displayInfobar) {
 				infoData.openInfobar = options.openInfobar;
+				infoData.animateInfobar = options.animateInfobar;
 				infoData.infobarPositionAbsolute = options.infobarPositionAbsolute;
 				infoData.infobarPositionTop = options.infobarPositionTop;
 				infoData.infobarPositionRight = options.infobarPositionRight;