single-file-core 1.5.48 → 1.5.49

package/processors/compression/compression.js

@@ -21,7 +21,7 @@
  *   Source.
  */
 
-/* global Node, FileReader */
+/* global Node */
 
 import {
 	configure,
@@ -167,11 +167,12 @@ async function process(pageData, options, lastModDate = new Date()) {
 		}
 		const endTags = options.preventAppendedData || options.embeddedImage ? "" : "</body></html>";
 		if (options.extractDataFromPage) {
-			const payload = await Promise.all([
-				arrayToBase64(insertionsCRLF),
-				arrayToBase64(substitutionsLF)
-			]);
-			extraData = "<sfz-extra-data>" + payload.join(",") + "</sfz-extra-data>";
+			const payload = new Uint32Array(insertionsCRLF.length + substitutionsLF.length + 2);
+			payload.set(new Uint32Array([insertionsCRLF.length]), 0);
+			payload.set(new Uint32Array(insertionsCRLF), 1);
+			payload.set(new Uint32Array([substitutionsLF.length]), insertionsCRLF.length + 1);
+			payload.set(new Uint32Array(substitutionsLF), insertionsCRLF.length + 2);
+			extraData = "<sfz-extra-data>" + compress(payload.buffer) + "</sfz-extra-data>";
 			if (options.preventAppendedData || extraData.length > 65535 - endTags.length - (options.embeddedImage ? PNG_IEND_LENGTH : 0)) {
 				if (!options.extraDataSize) {
 					options.extraDataSize = Math.floor(extraData.length * 1.001);
@@ -365,14 +366,6 @@ function findExtraDataTags(textContent, pageData, options, lastModDate, indexExt
 	}
 }
 
-async function arrayToBase64(data) {
-	const fileReader = new FileReader();
-	return await new Promise(resolve => {
-		fileReader.onload = event => resolve(event.target.result.substring(37));
-		fileReader.readAsDataURL(new Blob([new Uint32Array(data)], { type: "application/octet-stream" }));
-	});
-}
-
 async function writeData(writable, array) {
 	const streamWriter = writable.getWriter();
 	await streamWriter.ready;
@@ -425,7 +418,8 @@ async function addFile(zipWriter, prefixName, data) {
 }
 
 async function getContent() {
-	const { Blob, XMLHttpRequest, fetch, document, stop } = globalThis;
+	const BASE64_TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+	const { Blob, XMLHttpRequest, document, stop } = 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],
 		[352, 138], [8249, 139], [338, 140], [381, 142], [8216, 145], [8217, 146], [8220, 147], [8221, 148], [8226, 149], [8211, 150],
@@ -483,9 +477,11 @@ async function getContent() {
 				const charCode = textContent.charCodeAt(index);
 				zipData.push(charCode > 255 ? characterMap.get(charCode) : charCode);
 			}
-			const [insertionsCRLFData, substitutionsLFData] = zipDataElement.textContent.split(",");
-			const insertionsCRLF = await base64ToUint32Array(insertionsCRLFData);
-			const substitutionsLF = await base64ToUint32Array(substitutionsLFData);
+			const payload = new Uint32Array(decompress(zipDataElement.textContent).buffer);
+			const insertionsCRLFLength = payload[0];
+			const insertionsCRLF = payload.slice(1, 1 + insertionsCRLFLength);
+			const substitutionsLFLength = payload[1 + insertionsCRLFLength];
+			const substitutionsLF = payload.slice(2 + insertionsCRLFLength, 2 + insertionsCRLFLength + substitutionsLFLength);
 			insertionsCRLF.forEach(index => zipData.splice(index, 1, 13, 10));
 			substitutionsLF.forEach(index => zipData[index] = 13);
 			return new Blob([new Uint8Array(zipData)], { type: "application/octet-stream" });
@@ -493,7 +489,173 @@ async function getContent() {
 		throw new Error("Extra zip data data not found");
 	}
 
-	async function base64ToUint32Array(data) {
-		return new Uint32Array(await (await fetch("data:application/octet-stream;base64," + data)).arrayBuffer());
+	function decompress(src) {
+		src = base64Decode(src);
+		let out = new Uint8Array(1024);
+		let outLen = 0;
+		for (let i = 0; i < src.length;) {
+			const ctrl = src[i++];
+			if ((ctrl & 0x80) === 0) {
+				const L = ctrl;
+				ensure(outLen + L);
+				for (let j = 0; j < L && i < src.length; j++) {
+					out[outLen++] = src[i++];
+				}
+			} else {
+				const L = (ctrl & 0x7f) + 3;
+				const off = (src[i++] << 8) | src[i++];
+				const start = outLen - off;
+				ensure(outLen + L);
+				for (let k = 0; k < L; k++) {
+					out[outLen++] = out[start + k];
+				}
+			}
+		}
+		return new Uint8Array(out.buffer.slice(0, outLen));
+
+		function ensure(n) {
+			if (out.length < n) {
+				let nl = out.length * 2;
+				while (nl < n) {
+					nl *= 2;
+				}
+				const nbuf = new Uint8Array(nl);
+				nbuf.set(out.subarray(0, outLen));
+				out = nbuf;
+			}
+		};
+	}
+
+	function base64Decode(b64) {
+		b64 = String(b64).replace(/[^A-Za-z0-9+/=]/g, "");
+		const len = b64.length;
+		const out = [];
+		for (let i = 0; i < len; i += 4) {
+			const a = BASE64_TABLE.indexOf(b64[i]);
+			const b = BASE64_TABLE.indexOf(b64[i + 1]);
+			const c = BASE64_TABLE.indexOf(b64[i + 2]);
+			const d = BASE64_TABLE.indexOf(b64[i + 3]);
+			const n = (a << 18) | (b << 12) | ((c & 63) << 6) | (d & 63);
+			out.push((n >> 16) & 0xff);
+			if (b64[i + 2] !== "=") {
+				out.push((n >> 8) & 0xff);
+			}
+			if (b64[i + 3] !== "=") {
+				out.push(n & 0xff);
+			}
+		}
+		return new Uint8Array(out);
 	}
 }
+
+const BASE64_TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+function base64Encode(bytes) {
+	let out = "";
+	const len = bytes.length;
+	let i = 0;
+	for (; i + 2 < len; i += 3) {
+		const n = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2];
+		out += BASE64_TABLE[(n >> 18) & 63] + BASE64_TABLE[(n >> 12) & 63] + BASE64_TABLE[(n >> 6) & 63] + BASE64_TABLE[n & 63];
+	}
+	const rem = len - i;
+	if (rem === 1) {
+		const n = bytes[i] << 16;
+		out += BASE64_TABLE[(n >> 18) & 63] + BASE64_TABLE[(n >> 12) & 63] + "==";
+	} else if (rem === 2) {
+		const n = (bytes[i] << 16) | (bytes[i + 1] << 8);
+		out += BASE64_TABLE[(n >> 18) & 63] + BASE64_TABLE[(n >> 12) & 63] + BASE64_TABLE[(n >> 6) & 63] + "=";
+	}
+	return out;
+}
+
+function compress(input) {
+	const src = new Uint8Array(input);
+	const N = src.length;
+	const out = [];
+	const litBuf = [];
+	const MAX_OFFSET = 0xffff;
+	const MAX_MATCH = 130;
+	const MAX_CANDIDATES = 64;
+	const map = new Map();
+	let i = 0;
+	while (i < N) {
+		let bestLen = 0, bestOff = 0;
+		if (i + 2 < N) {
+			const key = (src[i] << 16) | (src[i + 1] << 8) | src[i + 2];
+			const cand = map.get(key) || [];
+			for (let c = cand.length - 1; c >= 0; c--) {
+				const j = cand[c];
+				const off = i - j;
+				if (off <= 0 || off > MAX_OFFSET) {
+					continue;
+				}
+				let k = 0;
+				while (k < MAX_MATCH && i + k < N && src[j + k] === src[i + k]) {
+					k++;
+				}
+				if (k > bestLen && k >= 3) {
+					bestLen = k; bestOff = off;
+					if (bestLen === MAX_MATCH) {
+						break;
+					}
+				}
+			}
+		}
+
+		if (bestLen >= 3) {
+			if (litBuf.length) {
+				flushLiterals();
+			}
+			let remain = bestLen;
+			let produced = 0;
+			while (remain > 0) {
+				const take = Math.min(remain, MAX_MATCH);
+				out.push(0x80 | ((take - 3) & 0x7f));
+				out.push((bestOff >> 8) & 0xff);
+				out.push(bestOff & 0xff);
+				remain -= take;
+				produced += take;
+			}
+			const start = i;
+			for (let p = start; p < start + produced; p++) {
+				addPos(p);
+			}
+			i += produced;
+		} else {
+			litBuf.push(src[i]);
+			addPos(i);
+			i++;
+			if (litBuf.length === 127) {
+				flushLiterals();
+			}
+		}
+	}
+	if (litBuf.length) {
+		flushLiterals();
+	}
+	const u8 = new Uint8Array(out);
+	return base64Encode(u8);
+
+	function flushLiterals() {
+		while (litBuf.length) {
+			const take = Math.min(127, litBuf.length);
+			out.push(take);
+			for (let t = 0; t < take; t++) {
+				out.push(litBuf.shift());
+			}
+		}
+	}
+
+	function addPos(pos) {
+		if (pos + 2 < N) {
+			const key = (src[pos] << 16) | (src[pos + 1] << 8) | src[pos + 2];
+			const arr = map.get(key) || [];
+			arr.push(pos);
+			if (arr.length > MAX_CANDIDATES) {
+				arr.shift();
+			}
+			map.set(key, arr);
+		}
+	}
+}

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

@@ -21,8 +21,6 @@
  *   Source.
  */
 
-/* global window */
-
 (globalThis => {
 
 	const LOAD_DEFERRED_IMAGES_START_EVENT = "single-file-load-deferred-images-start";
@@ -261,7 +259,7 @@
 		if (!keepZoomLevel) {
 			dispatchResizeEvent();
 			const docBoundingRect = scrollingElement.getBoundingClientRect();
-			if (window == window.top) {
+			if (globalThis.window == globalThis.window.top) {
 				[...observers].forEach(([intersectionObserver, observer]) => {
 					const getBoundingClientRectDefined = observer.options && observer.options.root && observer.options.root.getBoundingClientRect;
 					const rootBoundingRect = getBoundingClientRectDefined && observer.options.root.getBoundingClientRect();
@@ -446,4 +444,4 @@
 		}
 	}
 
-})(typeof globalThis == "object" ? globalThis : window);
+})(typeof globalThis == "object" ? globalThis : globalThis.window);

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

@@ -21,8 +21,6 @@
  *   Source.
  */
 
-/* global window */
-
 const LOAD_DEFERRED_IMAGES_START_EVENT = "single-file-load-deferred-images-start";
 const LOAD_DEFERRED_IMAGES_END_EVENT = "single-file-load-deferred-images-end";
 const LOAD_DEFERRED_IMAGES_KEEP_ZOOM_LEVEL_START_EVENT = "single-file-load-deferred-images-keep-zoom-level-start";
@@ -51,15 +49,15 @@ const JSON = globalThis.JSON;
 const MutationObserver = globalThis.MutationObserver;
 
 let fontFaces, worklets;
-if (window[FONT_FACE_PROPERTY_NAME]) {
-	fontFaces = window[FONT_FACE_PROPERTY_NAME];
+if (globalThis.window[FONT_FACE_PROPERTY_NAME]) {
+	fontFaces = globalThis.window[FONT_FACE_PROPERTY_NAME];
 } else {
-	fontFaces = window[FONT_FACE_PROPERTY_NAME] = new Map();
+	fontFaces = globalThis.window[FONT_FACE_PROPERTY_NAME] = new Map();
 }
-if (window[WORKLET_PROPERTY_NAME]) {
-	worklets = window[WORKLET_PROPERTY_NAME];
+if (globalThis.window[WORKLET_PROPERTY_NAME]) {
+	worklets = globalThis.window[WORKLET_PROPERTY_NAME];
 } else {
-	worklets = window[WORKLET_PROPERTY_NAME] = new Map();
+	worklets = globalThis.window[WORKLET_PROPERTY_NAME] = new Map();
 }
 
 init();

package/vendor/css-font-property-parser.js

@@ -49,25 +49,24 @@
  */
 
 import * as cssTree from "./css-tree.js";
-const REGEXP_SIMPLE_QUOTES_STRING = /^'(.*?)'$/;
-const REGEXP_DOUBLE_QUOTES_STRING = /^"(.*?)"$/;
+import { process as cssUnescape } from "./css-unescape.js";
 
-const globalKeywords = [
+const GLOBAL_KEYWORDS = new Set([
 	"inherit",
 	"initial",
 	"unset"
-];
+]);
 
-const systemFontKeywords = [
+const SYSTEM_FONT_KEYWORDS = new Set([
 	"caption",
 	"icon",
 	"menu",
 	"message-box",
 	"small-caption",
 	"status-bar"
-];
+]);
 
-const fontWeightKeywords = [
+const FONT_WEIGHT_KEYWORDS = new Set([
 	"normal",
 	"bold",
 	"bolder",
@@ -81,15 +80,20 @@ const fontWeightKeywords = [
 	"700",
 	"800",
 	"900"
-];
+]);
 
-const fontStyleKeywords = [
+const FONT_STYLE_KEYWORDS = new Set([
 	"normal",
 	"italic",
 	"oblique"
-];
+]);
 
-const fontStretchKeywords = [
+const FONT_VARIANT_KEYWORDS = new Set([
+	"normal",
+	"small-caps"
+]);
+
+const FONT_STRETCH_KEYWORDS = new Set([
 	"normal",
 	"condensed",
 	"semi-condensed",
@@ -99,7 +103,29 @@ const fontStretchKeywords = [
 	"semi-expanded",
 	"extra-expanded",
 	"ultra-expanded"
-];
+]);
+
+const SIZE_TYPES = new Set([
+	"Dimension",
+	"Identifier",
+	"Percentage",
+	"Number",
+	"Function",
+	"UnaryExpression"
+]);
+
+const FONT_DESCRIPTOR_KEYS = new Set([
+	"style",
+	"variant",
+	"weight",
+	"stretch"
+]);
+
+const OPERATOR_TYPE = "Operator";
+const IDENTIFIER_TYPE = "Identifier";
+const NORMAL_KEYWORD = "normal";
+const LINE_HEIGHT_SEPARATOR = "/";
+const FAMILY_SEPARATOR = ",";
 
 const errorPrefix = "[parse-css-font] ";
 
@@ -109,64 +135,67 @@ export {
 
 function parse(value) {
 	const stringValue = cssTree.generate(value);
-	if (systemFontKeywords.indexOf(stringValue) !== -1) {
+	const stringValueLower = stringValue.toLowerCase();
+	if (SYSTEM_FONT_KEYWORDS.has(stringValueLower)) {
 		return { system: stringValue };
 	}
+	if (GLOBAL_KEYWORDS.has(stringValueLower)) {
+		return { global: stringValue };
+	}
 	const tokens = value.children;
-
 	const font = {
-		lineHeight: "normal",
-		stretch: "normal",
-		style: "normal",
-		variant: "normal",
-		weight: "normal",
+		lineHeight: NORMAL_KEYWORD,
+		stretch: NORMAL_KEYWORD,
+		style: NORMAL_KEYWORD,
+		variant: NORMAL_KEYWORD,
+		weight: NORMAL_KEYWORD,
 	};
-
-	let isLocked = false;
+	const seen = { style: false, variant: false, weight: false, stretch: false };
 	for (let tokenNode = tokens.head; tokenNode; tokenNode = tokenNode.next) {
-		const token = cssTree.generate(tokenNode.data);
-		if (token === "normal" || globalKeywords.indexOf(token) !== -1) {
-			["style", "variant", "weight", "stretch"].forEach((prop) => {
-				font[prop] = token;
+		const tokenRaw = tokenNode.data.name || tokenNode.data.value || cssTree.generate(tokenNode.data);
+		const token = tokenRaw.toLowerCase();
+		if (token === NORMAL_KEYWORD) {
+			FONT_DESCRIPTOR_KEYS.forEach((prop) => {
+				if (!seen[prop]) {
+					font[prop] = tokenRaw;
+				}
 			});
-			isLocked = true;
 			continue;
 		}
-
-		if (fontWeightKeywords.indexOf(token) !== -1) {
-			if (isLocked) {
-				continue;
+		if (FONT_WEIGHT_KEYWORDS.has(token)) {
+			if (!seen.weight) {
+				font.weight = tokenRaw;
+				seen.weight = true;
 			}
-			font.weight = token;
 			continue;
 		}
-
-		if (fontStyleKeywords.indexOf(token) !== -1) {
-			if (isLocked) {
-				continue;
+		if (FONT_STYLE_KEYWORDS.has(token)) {
+			if (!seen.style) {
+				font.style = tokenRaw;
+				seen.style = true;
 			}
-			font.style = token;
 			continue;
 		}
-
-		if (fontStretchKeywords.indexOf(token) !== -1) {
-			if (isLocked) {
-				continue;
+		if (FONT_VARIANT_KEYWORDS.has(token)) {
+			if (!seen.variant) {
+				font.variant = tokenRaw;
+				seen.variant = true;
 			}
-			font.stretch = token;
 			continue;
 		}
-
-		if (tokenNode.data.type == "Dimension") {
+		if (FONT_STRETCH_KEYWORDS.has(token)) {
+			if (!seen.stretch) {
+				font.stretch = tokenRaw;
+				seen.stretch = true;
+			}
+			continue;
+		}
+		if (SIZE_TYPES.has(tokenNode.data.type)) {
 			font.size = cssTree.generate(tokenNode.data);
 			tokenNode = tokenNode.next;
-			if (tokenNode && tokenNode.data.type == "Operator" && tokenNode.data.value == "/" && tokenNode.next) {
-				tokenNode = tokenNode.next;
-				font.lineHeight = cssTree.generate(tokenNode.data);
-				tokenNode = tokenNode.next;
-			} else if (tokens.head.data.type == "Operator" && tokens.head.data.value == "/" && tokens.head.next) {
-				font.lineHeight = cssTree.generate(tokens.head.next.data);
-				tokenNode = tokens.head.next.next;
+			if (tokenNode && tokenNode.data.type == OPERATOR_TYPE && tokenNode.data.value == LINE_HEIGHT_SEPARATOR && tokenNode.next) {
+				font.lineHeight = cssTree.generate(tokenNode.next.data);
+				tokenNode = tokenNode.next.next;
 			}
 			if (!tokenNode) {
 				throw error("Missing required font-family.");
@@ -174,12 +203,12 @@ function parse(value) {
 			font.family = [];
 			let familyName = "";
 			while (tokenNode) {
-				while (tokenNode && tokenNode.data.type == "Operator" && tokenNode.data.value == ",") {
+				while (tokenNode && tokenNode.data.type == OPERATOR_TYPE && tokenNode.data.value == FAMILY_SEPARATOR) {
 					tokenNode = tokenNode.next;
 				}
 				if (tokenNode) {
-					if (tokenNode.data.type == "Identifier") {
-						while (tokenNode && tokenNode.data.type == "Identifier") {
+					if (tokenNode.data.type == IDENTIFIER_TYPE) {
+						while (tokenNode && tokenNode.data.type == IDENTIFIER_TYPE) {
 							familyName += " " + cssTree.generate(tokenNode.data);
 							tokenNode = tokenNode.next;
 						}
@@ -196,15 +225,7 @@ function parse(value) {
 			}
 			return font;
 		}
-
-		if (font.variant !== "normal") {
-			throw error("Unknown or unsupported font token: " + font.variant);
-		}
-
-		if (isLocked) {
-			continue;
-		}
-		font.variant = token;
+		throw error("Unknown or unsupported font token: " + tokenRaw);
 	}
 
 	throw error("Missing required font-size.");
@@ -215,10 +236,9 @@ function error(message) {
 }
 
 function removeQuotes(string) {
-	if (string.match(REGEXP_SIMPLE_QUOTES_STRING)) {
-		string = string.replace(REGEXP_SIMPLE_QUOTES_STRING, "$1");
-	} else {
-		string = string.replace(REGEXP_DOUBLE_QUOTES_STRING, "$1");
+	if (!string) return string;
+	if ((string[0] === "\"" && string[string.length - 1] === "\"") || (string[0] === "'" && string[string.length - 1] === "'")) {
+		string = string.slice(1, -1);
 	}
-	return string.trim();
+	return cssUnescape(string).trim();
 }