@stll/folio-core 0.52.0 → 0.54.0

package/dist/docx/unzip.js

@@ -1,4 +1,5 @@
 import { bytesToDataUrl } from "../utils/base64.js";
+import { compressionRatioLimitFor, countCentralDirectoryRecords, createInflationBudget, exceedsCompressionRatio, getZipEntrySizes, inflateEntryWithinLimits, isStoredZipEntry } from "./archiveInflation.js";
 import { DOCX_CONTAINER_TYPES, detectDocxContainerType } from "./encryption/containerFormat.js";
 import { openDocxBuffer } from "./encryption/openEncryptedDocx.js";
 import { decodeXmlBytes } from "./xmlEncoding.js";
@@ -60,6 +61,7 @@ const DEFAULT_UNZIP_LIMITS = {
 	maxMediaBytes: 25 * MEBIBYTE,
 	maxFontBytes: 10 * MEBIBYTE,
 	maxTotalUncompressedBytes: 250 * MEBIBYTE,
+	maxCompressionRatio: 200,
 	maxXmlElementsPerPart: FOLIO_XML_RESOURCE_LIMITS.maxElementsPerPart,
 	maxXmlAttributesPerPart: FOLIO_XML_RESOURCE_LIMITS.maxAttributesPerPart,
 	maxXmlElementsPerPackage: FOLIO_XML_RESOURCE_LIMITS.maxElementsPerPackage,
@@ -101,19 +103,23 @@ const ZIP_CENTRAL_DIRECTORY_FILE_HEADER_SIGNATURE = 33639248;
 const ZIP_END_OF_CENTRAL_DIRECTORY_SIZE = 22;
 const ZIP_END_OF_CENTRAL_DIRECTORY_WITH_COUNTS_SIZE = 12;
 const ZIP_CENTRAL_DIRECTORY_FILE_HEADER_SIZE = 46;
+/** Entries inflated at once; the rest wait for a slot. */
+const EXTRACTION_CONCURRENCY = 6;
 /**
 * Extract all content from a DOCX file
 *
 * @param buffer - DOCX file as ArrayBuffer
 * @returns Promise resolving to extracted content
 */
-async function unzipDocx(buffer, options = {}) {
+async function unzipDocx(buffer, options = {}, { verifyUnreadEntries = true } = {}) {
 	const limits = createUnzipLimits(options);
 	if (buffer.byteLength > limits.maxInputBytes) throw new DocxSecurityError("DOCX file exceeds the maximum allowed size");
 	const containerType = detectDocxContainerType(buffer);
 	const zipBuffer = containerType === DOCX_CONTAINER_TYPES.ZIP ? buffer : await openDocxBuffer(buffer, { password: options.password });
 	if (zipBuffer.byteLength > limits.maxInputBytes) throw new DocxSecurityError("DOCX file exceeds the maximum allowed size");
 	const wasEncrypted = containerType === DOCX_CONTAINER_TYPES.CFB;
+	const maxRecords = limits.maxFiles * 2;
+	if (countCentralDirectoryRecords(new Uint8Array(zipBuffer), maxRecords) > maxRecords) throw new DocxSecurityError("DOCX file contains too many entries");
 	const loaded = await loadDocxZip(zipBuffer, limits.maxFiles);
 	if (loaded.buffer.byteLength > limits.maxInputBytes) throw new DocxSecurityError("DOCX file exceeds the maximum allowed size");
 	const { zip } = loaded;
@@ -149,40 +155,78 @@ async function unzipDocx(buffer, options = {}) {
 		wasEncrypted
 	};
 	let totalUncompressedBytes = 0;
+	const inflationBudget = createInflationBudget(limits.maxTotalUncompressedBytes);
 	const extractionTasks = [];
+	const verifyEntry = (file, path) => {
+		if (!verifyUnreadEntries || isStoredZipEntry(file)) return;
+		extractionTasks.push(async () => {
+			await verifyEntryWithinLimits({
+				file,
+				path,
+				limits,
+				budget: inflationBudget
+			});
+			return null;
+		});
+	};
+	const inflate = async (file, maxEntryBytes) => await inflateEntryWithinLimits({
+		entry: file,
+		maxEntryBytes,
+		maxCompressionRatio: compressionRatioLimitFor(file.name, limits.maxCompressionRatio),
+		budget: inflationBudget
+	});
 	for (const [path, file] of entries) {
 		if (!isSafeDocxPath(path)) throw new DocxSecurityError("DOCX file contains an unsafe entry path");
-		const declaredSize = getEntryUncompressedSize(file);
+		const { compressedBytes, uncompressedBytes: declaredSize } = getZipEntrySizes(file);
 		if (declaredSize !== null) {
 			totalUncompressedBytes += declaredSize;
 			if (totalUncompressedBytes > limits.maxTotalUncompressedBytes) throw new DocxSecurityError("DOCX file expands beyond the maximum allowed size");
+			if (exceedsCompressionRatio({
+				inflatedBytes: declaredSize,
+				compressedBytes,
+				maxRatio: compressionRatioLimitFor(path, limits.maxCompressionRatio)
+			})) throw new DocxSecurityError(`DOCX entry exceeds the maximum compression ratio: ${path}`);
+		}
+		if (!isParsedDocxEntry(path)) {
+			verifyEntry(file, path);
+			continue;
 		}
-		if (!isParsedDocxEntry(path)) continue;
 		const lowerPath = path.toLowerCase();
 		if (lowerPath.endsWith(".xml") || lowerPath.endsWith(".rels")) {
 			assertEntrySize(path, declaredSize, limits.maxXmlBytes);
-			if (options.extractAllXml === false && !shouldExtractXmlPart(lowerPath)) continue;
-			extractionTasks.push(() => file.async("uint8array").then((xmlBytes) => {
-				assertExtractedSize(path, xmlBytes.byteLength, limits.maxXmlBytes);
+			if (options.extractAllXml === false && !shouldExtractXmlPart(lowerPath)) {
+				verifyEntry(file, path);
+				continue;
+			}
+			extractionTasks.push(async () => {
+				const result = await inflate(file, limits.maxXmlBytes);
+				if (!result.ok) throw inflationLimitError(result.limit, path);
 				return {
 					type: "xml",
 					path,
 					lowerPath,
-					content: decodeXmlBytes(xmlBytes)
+					content: decodeXmlBytes(result.bytes)
 				};
-			}));
+			});
 		} else if (lowerPath.startsWith("word/media/")) {
 			const mimeType = getMediaMimeType(path);
-			if (!limits.allowedMediaMimeTypes.has(mimeType)) continue;
+			if (!limits.allowedMediaMimeTypes.has(mimeType)) {
+				verifyEntry(file, path);
+				continue;
+			}
 			if (isEntryTooLarge(declaredSize, limits.maxMediaBytes)) {
 				content.warnings.push(`Skipped oversized media file: ${path}; original entry preserved for round-trip.`);
+				verifyEntry(file, path);
 				continue;
 			}
-			extractionTasks.push(() => file.async("arraybuffer").then((binaryContent) => {
-				if (binaryContent.byteLength > limits.maxMediaBytes) {
+			extractionTasks.push(async () => {
+				const result = await inflate(file, limits.maxMediaBytes);
+				if (!result.ok) {
+					if (result.limit !== "entry") throw inflationLimitError(result.limit, path);
 					content.warnings.push(`Skipped oversized media file: ${path}; original entry preserved for round-trip.`);
 					return null;
 				}
+				const binaryContent = result.bytes.buffer;
 				if (!isMediaContentAllowed(binaryContent, mimeType)) return null;
 				return {
 					type: "media",
@@ -190,21 +234,33 @@ async function unzipDocx(buffer, options = {}) {
 					mimeType,
 					content: binaryContent
 				};
-			}));
+			});
 		} else if (lowerPath.startsWith("word/fonts/")) {
-			if (isEntryTooLarge(declaredSize, limits.maxFontBytes)) continue;
-			extractionTasks.push(() => file.async("arraybuffer").then((binaryContent) => {
-				if (binaryContent.byteLength > limits.maxFontBytes) return null;
+			if (isEntryTooLarge(declaredSize, limits.maxFontBytes)) {
+				verifyEntry(file, path);
+				continue;
+			}
+			extractionTasks.push(async () => {
+				const result = await inflate(file, limits.maxFontBytes);
+				if (!result.ok) {
+					if (result.limit !== "entry") throw inflationLimitError(result.limit, path);
+					return null;
+				}
 				return {
 					type: "font",
 					path,
-					content: binaryContent
+					content: result.bytes.buffer
 				};
-			}));
-		}
+			});
+		} else verifyEntry(file, path);
 	}
+	if (exceedsCompressionRatio({
+		inflatedBytes: totalUncompressedBytes,
+		compressedBytes: loaded.buffer.byteLength,
+		maxRatio: limits.maxCompressionRatio
+	})) throw new DocxSecurityError("DOCX file exceeds the maximum compression ratio");
 	const xmlBudget = createXmlPackageBudget();
-	for (const extracted of await Promise.all(extractionTasks.map((extract) => extract()))) {
+	for (const extracted of await runExtractionTasks(extractionTasks, inflationBudget)) {
 		if (!extracted) continue;
 		if (extracted.type === "xml") {
 			assignXmlContent(content, extracted, limits, xmlBudget);
@@ -262,6 +318,62 @@ function assignXmlContent(content, { path, lowerPath, content: xmlContent }, lim
 		content.footers.set(filename, xmlContent);
 	}
 }
+function inflationLimitError(limit, path) {
+	switch (limit) {
+		case "declared-size": return new DocxSecurityError(`DOCX entry inflates past its declared size: ${path}`);
+		case "compression-ratio": return new DocxSecurityError(`DOCX entry exceeds the maximum compression ratio: ${path}`);
+		case "entry": return new DocxSecurityError(`DOCX entry exceeds maximum size: ${path}`);
+		case "total": return new DocxSecurityError("DOCX file expands beyond the maximum allowed size");
+		case "aborted": return new DocxSecurityError(`DOCX entry was not read after another entry failed: ${path}`);
+	}
+}
+/**
+* Run extraction tasks a few at a time, in order, keeping their results in
+* task order. The first failure marks the shared budget aborted, which stops
+* the streams still running at their next chunk and leaves the queued tasks
+* unstarted.
+*/
+async function runExtractionTasks(tasks, budget) {
+	const results = Array.from({ length: tasks.length }, () => null);
+	let next = 0;
+	const worker = async () => {
+		while (next < tasks.length && !budget.aborted) {
+			const index = next;
+			next += 1;
+			const task = tasks[index];
+			if (!task) return;
+			try {
+				results[index] = await task();
+			} catch (error) {
+				budget.aborted = true;
+				throw error;
+			}
+		}
+	};
+	await Promise.all(Array.from({ length: Math.min(EXTRACTION_CONCURRENCY, tasks.length) }, async () => await worker()));
+	return results;
+}
+/**
+* Inflate an entry without keeping it, to bound what a later read of it can
+* produce. A limit refuses the package. A corrupt entry does not: it was never
+* going to be read here, a later read stops at the same byte, and refusing
+* the whole document over a part folio does not model would be a regression.
+*/
+async function verifyEntryWithinLimits({ file, path, limits, budget }) {
+	let result;
+	try {
+		result = await inflateEntryWithinLimits({
+			entry: file,
+			maxEntryBytes: Number.POSITIVE_INFINITY,
+			maxCompressionRatio: compressionRatioLimitFor(path, limits.maxCompressionRatio),
+			budget,
+			retain: false
+		});
+	} catch {
+		return;
+	}
+	if (!result.ok) throw inflationLimitError(result.limit, path);
+}
 async function loadDocxZip(buffer, maxFiles) {
 	try {
 		return {
@@ -336,9 +448,12 @@ function findLastSignature(view, byteLength, signature) {
 	return -1;
 }
 function createUnzipLimits(options) {
+	const { maxCompressionRatio } = options;
+	if (maxCompressionRatio !== void 0 && (!Number.isSafeInteger(maxCompressionRatio) || maxCompressionRatio < 0)) throw new RangeError("DOCX compression ratio limit must be a non-negative safe integer");
 	return {
 		...DEFAULT_UNZIP_LIMITS,
 		...options,
+		maxCompressionRatio: maxCompressionRatio ?? DEFAULT_UNZIP_LIMITS.maxCompressionRatio,
 		allowedMediaMimeTypes: options.allowedMediaMimeTypes ? new Set(options.allowedMediaMimeTypes) : DEFAULT_UNZIP_LIMITS.allowedMediaMimeTypes
 	};
 }
@@ -375,8 +490,7 @@ function isParsedDocxEntry(path) {
 	return lowerPath === "[content_types].xml" || lowerPath.startsWith("_rels/") || lowerPath.startsWith("docprops/") || lowerPath.startsWith("word/") || lowerPath.startsWith("customxml/");
 }
 function getEntryUncompressedSize(file) {
-	const metadata = file._data;
-	return typeof metadata?.uncompressedSize === "number" ? metadata.uncompressedSize : null;
+	return getZipEntrySizes(file).uncompressedBytes;
 }
 function assertEntrySize(path, declaredSize, maxBytes) {
 	if (isEntryTooLarge(declaredSize, maxBytes)) throw new DocxSecurityError(`DOCX entry exceeds maximum size: ${path}`);
@@ -384,9 +498,6 @@ function assertEntrySize(path, declaredSize, maxBytes) {
 function isEntryTooLarge(declaredSize, maxBytes) {
 	return declaredSize !== null && declaredSize > maxBytes;
 }
-function assertExtractedSize(path, byteLength, maxBytes) {
-	if (byteLength > maxBytes) throw new DocxSecurityError(`DOCX entry exceeds maximum size: ${path}`);
-}
 function isMediaContentAllowed(data, mimeType) {
 	const bytes = new Uint8Array(data);
 	switch (mimeType) {
@@ -494,4 +605,4 @@ function getContentSummary(content) {
 	};
 }
 //#endregion
-export { DocxSecurityError, extractFile, getContentSummary, getFileList, getMediaMimeType, hasFile, mediaToDataUrl, unzipDocx };
+export { DocxSecurityError, extractFile, getContentSummary, getEntryUncompressedSize, getFileList, getMediaMimeType, hasFile, mediaToDataUrl, unzipDocx };

package/dist/docx/wordprocessingPrefixes.d.ts

@@ -0,0 +1,78 @@
+//#region src/docx/wordprocessingPrefixes.d.ts
+/**
+ * Which prefixes a WordprocessingML part spells its namespaces with.
+ *
+ * A prefix is an alias: `<w:p>`, `<x:p>` and an unprefixed `<p>` under a
+ * default namespace are the same paragraph when the prefix (or the default)
+ * is bound to the WordprocessingML URI. The parser resolves names by URI, so
+ * every such package opens. The patchers that work on part XML as a string
+ * (`ensureParaIds`, the selective-save splices) find elements by their
+ * literal tags instead, and a literal `<w:p` finds nothing in a part that
+ * spells it `<x:p`: the patch reports success having touched nothing.
+ *
+ * {@link resolveWordprocessingPrefixes} is the one place those patchers ask
+ * how a part spells WordprocessingML, the `w14` extensions and
+ * markup compatibility (`mc`). A patcher either scans with every prefix the
+ * part binds, or checks the names its literal scan needs in their namespace
+ * scope. A prefix conflict on one of those names is refused.
+ */
+/** How one part spells the namespaces a string-level patcher scans for. */
+type WordprocessingPrefixes = {
+  /**
+   * Prefixes bound to WordprocessingML (Transitional or Strict), `""` for the
+   * default namespace. Never empty: an undeclared part reads as `w`.
+   */
+  main: readonly string[];
+  /** Prefixes bound to the `w14` extensions namespace. */
+  w14: readonly string[];
+  /** Whether a `w14` prefix is declared on the root (else `w14` is assumed). */
+  w14Declared: boolean;
+  /** Prefixes bound to markup compatibility (`mc`). */
+  mc: readonly string[];
+  /** Whether an `mc` prefix is declared on the root (else `mc` is assumed). */
+  mcDeclared: boolean;
+  /**
+   * The spelling folio's serializer writes: WordprocessingML only as `w`,
+   * `w14` and `mc` under their conventional prefixes. Splicing serializer
+   * output into a part is only sound when this holds.
+   */
+  canonical: boolean;
+};
+type WordprocessingPrefixResolution = {
+  type: "resolved";
+  prefixes: WordprocessingPrefixes;
+} | {
+  type: "unsupported";
+  reason: string;
+};
+declare const resolveWordprocessingPrefixes: (xml: string) => WordprocessingPrefixResolution;
+/** Root spelling for a selective scan whose relevant nested names are checked separately. */
+declare const resolveSelectiveScanPrefixes: (xml: string) => WordprocessingPrefixResolution;
+/**
+ * Whether a patcher that reads `<w:…>` literally sees every element it looks
+ * for in `xml`, and may splice the serializer's `w:` markup into it.
+ *
+ * True for the canonical spelling. Also true when the part binds
+ * WordprocessingML under an extra prefix besides `w` but never spells the
+ * names the patcher scans under that alias, or binds markup compatibility
+ * under another prefix. Relevant nested names are checked in their own scope.
+ */
+declare const splicesAsCanonical: (xml: string, localNames: readonly string[]) => boolean;
+/** The names the paragraph splices scan for: paragraphs, their containers and ids. */
+declare const PARAGRAPH_SCAN_NAMES: readonly ["p", "tc", "txbxContent", "paraId", "textId"];
+/** Whether `xml` spells WordprocessingML the way folio's serializer does. */
+declare const hasCanonicalWordprocessingPrefixes: (xml: string) => boolean;
+/** `<p`, `<w:p`, … — the open-tag literal of `localName` under `prefix`. */
+declare const openTagLiteral: (prefix: string, localName: string) => string;
+/** `</p>`, `</w:p>`, … — the close-tag literal of `localName` under `prefix`. */
+declare const closeTagLiteral: (prefix: string, localName: string) => string;
+/**
+ * Whether `xml` opens `localName` under one of `prefixes` at `start`, and the
+ * length of the literal that matched (`-1` when none did). The character after
+ * the name must end it, so `<w:pPr` is not `<w:p`.
+ */
+declare const matchOpenTag: (xml: string, start: number, prefixes: readonly string[], localName: string) => number;
+/** The length of the close tag of `localName` under one of `prefixes` at `start`, or -1. */
+declare const matchCloseTag: (xml: string, start: number, prefixes: readonly string[], localName: string) => number;
+//#endregion
+export { PARAGRAPH_SCAN_NAMES, WordprocessingPrefixResolution, WordprocessingPrefixes, closeTagLiteral, hasCanonicalWordprocessingPrefixes, matchCloseTag, matchOpenTag, openTagLiteral, resolveSelectiveScanPrefixes, resolveWordprocessingPrefixes, splicesAsCanonical };

package/dist/docx/wordprocessingPrefixes.js

@@ -0,0 +1,286 @@
+import { NAMESPACES, WORDPROCESSINGML_NAMESPACE_URIS, getLocalName, getNamespacePrefix, getNamespaceUri, parseXmlDocument, resolveAttributeNamespaceUri } from "./xmlParser.js";
+//#region src/docx/wordprocessingPrefixes.ts
+/**
+* Which prefixes a WordprocessingML part spells its namespaces with.
+*
+* A prefix is an alias: `<w:p>`, `<x:p>` and an unprefixed `<p>` under a
+* default namespace are the same paragraph when the prefix (or the default)
+* is bound to the WordprocessingML URI. The parser resolves names by URI, so
+* every such package opens. The patchers that work on part XML as a string
+* (`ensureParaIds`, the selective-save splices) find elements by their
+* literal tags instead, and a literal `<w:p` finds nothing in a part that
+* spells it `<x:p`: the patch reports success having touched nothing.
+*
+* {@link resolveWordprocessingPrefixes} is the one place those patchers ask
+* how a part spells WordprocessingML, the `w14` extensions and
+* markup compatibility (`mc`). A patcher either scans with every prefix the
+* part binds, or checks the names its literal scan needs in their namespace
+* scope. A prefix conflict on one of those names is refused.
+*/
+const XMLNS = "xmlns";
+const isWhitespace = (character) => character === " " || character === "	" || character === "\n" || character === "\r";
+/** End offset (exclusive) of the tag opening at `start`, skipping quoted values. */
+const tagEnd = (xml, start) => {
+	let quote = null;
+	for (let index = start + 1; index < xml.length; index += 1) {
+		const character = xml[index];
+		if (quote !== null) {
+			if (character === quote) quote = null;
+			continue;
+		}
+		if (character === "\"" || character === "'") quote = character;
+		else if (character === ">") return index + 1;
+	}
+	return -1;
+};
+/** The `xmlns` / `xmlns:*` declarations written in one start tag. */
+const declarationsIn = (tag) => {
+	const declarations = [];
+	for (const match of tag.matchAll(/\sxmlns(?::(?<prefix>[^\s=/>]+))?\s*=\s*(?<quote>["'])(?<uri>[\s\S]*?)\k<quote>/gu)) declarations.push({
+		prefix: match.groups?.["prefix"] ?? "",
+		uri: match.groups?.["uri"] ?? ""
+	});
+	return declarations;
+};
+const OPAQUE_REGIONS = [
+	{
+		open: "<!--",
+		close: "-->"
+	},
+	{
+		open: "<![CDATA[",
+		close: "]]>"
+	},
+	{
+		open: "<?",
+		close: "?>"
+	}
+];
+/** Visit every start tag of `xml` that declares a namespace, root first. */
+const visitDeclaringStartTags = (xml, visit) => {
+	let seenRoot = false;
+	let pos = 0;
+	scan: while (pos < xml.length) {
+		const start = xml.indexOf("<", pos);
+		if (start === -1) break;
+		for (const { open, close } of OPAQUE_REGIONS) if (xml.startsWith(open, start)) {
+			const closeStart = xml.indexOf(close, start + open.length);
+			if (closeStart === -1) return false;
+			pos = closeStart + close.length;
+			continue scan;
+		}
+		const next = xml[start + 1];
+		if (next === "!" || next === "/") {
+			const end = xml.indexOf(">", start);
+			if (end === -1) return false;
+			pos = end + 1;
+			continue;
+		}
+		const end = tagEnd(xml, start);
+		if (end === -1) return false;
+		const isRoot = !seenRoot;
+		seenRoot = true;
+		const tag = xml.slice(start, end);
+		if (isRoot || tag.includes(XMLNS)) visit(tag, isRoot);
+		pos = end;
+	}
+	return seenRoot;
+};
+const MAIN_URIS = WORDPROCESSINGML_NAMESPACE_URIS;
+const W14_URI = NAMESPACES.w14;
+const MC_URI = NAMESPACES.mc;
+const NESTED_BINDINGS = {
+	strict: "strict",
+	scoped: "scoped"
+};
+const slotOf = (uri) => {
+	if (MAIN_URIS.has(uri)) return "main";
+	if (uri === W14_URI) return "w14";
+	if (uri === MC_URI) return "mc";
+	return null;
+};
+const CONVENTIONAL_PREFIX = {
+	main: "w",
+	w14: "w14",
+	mc: "mc"
+};
+/**
+* Resolve the prefixes `xml` binds to WordprocessingML, `w14` and `mc`.
+*
+* Root declarations decide. A namespace the root never declares is read under
+* its conventional prefix, the tolerant reading of a malformed part. A declaration on
+* a nested element is accepted only when it repeats a binding the scan already
+* uses; anything else changes what a literal tag means partway through the
+* part and is reported as unsupported.
+*/
+const resolvePrefixes = (xml, nestedBindings) => {
+	const bound = {
+		main: [],
+		w14: [],
+		mc: []
+	};
+	const rootPrefixes = /* @__PURE__ */ new Map();
+	const nested = [];
+	if (!visitDeclaringStartTags(xml, (tag, isRoot) => {
+		for (const declaration of declarationsIn(tag)) {
+			if (!isRoot) {
+				nested.push(declaration);
+				continue;
+			}
+			rootPrefixes.set(declaration.prefix, declaration.uri);
+			const slot = slotOf(declaration.uri);
+			if (slot !== null) bound[slot].push(declaration.prefix);
+		}
+	})) return {
+		type: "unsupported",
+		reason: "no root element or unterminated markup"
+	};
+	const declared = {
+		main: bound.main.length > 0,
+		w14: bound.w14.length > 0,
+		mc: bound.mc.length > 0
+	};
+	for (const slot of [
+		"main",
+		"w14",
+		"mc"
+	]) {
+		if (declared[slot]) {
+			if (slot !== "main" && bound[slot].includes("")) return {
+				type: "unsupported",
+				reason: `${slot} is bound only as the default namespace`
+			};
+			continue;
+		}
+		const conventional = CONVENTIONAL_PREFIX[slot];
+		if (rootPrefixes.has(conventional)) {
+			if (slot === "main") return {
+				type: "unsupported",
+				reason: `no WordprocessingML binding; ${conventional} is bound to another namespace`
+			};
+			continue;
+		}
+		bound[slot].push(conventional);
+	}
+	const inUse = /* @__PURE__ */ new Map();
+	for (const slot of [
+		"main",
+		"w14",
+		"mc"
+	]) for (const prefix of bound[slot]) inUse.set(prefix, slot);
+	for (const { prefix, uri } of nestedBindings === NESTED_BINDINGS.strict ? nested : []) {
+		const slot = slotOf(uri);
+		const spelling = prefix === "" ? "the default namespace" : `prefix ${prefix}`;
+		if (slot !== null) {
+			if (!bound[slot].includes(prefix)) return {
+				type: "unsupported",
+				reason: `a nested element binds ${slot} under ${spelling}`
+			};
+			continue;
+		}
+		if (inUse.has(prefix)) return {
+			type: "unsupported",
+			reason: `a nested element rebinds ${spelling} to ${uri === "" ? "no namespace" : uri}`
+		};
+	}
+	const only = (prefixes, prefix) => prefixes.length === 1 && prefixes[0] === prefix;
+	const canonical = only(bound.main, "w") && only(bound.w14, "w14") && only(bound.mc, "mc");
+	return {
+		type: "resolved",
+		prefixes: {
+			main: bound.main,
+			w14: bound.w14,
+			w14Declared: declared.w14,
+			mc: bound.mc,
+			mcDeclared: declared.mc,
+			canonical
+		}
+	};
+};
+const resolveWordprocessingPrefixes = (xml) => resolvePrefixes(xml, NESTED_BINDINGS.strict);
+/** Root spelling for a selective scan whose relevant nested names are checked separately. */
+const resolveSelectiveScanPrefixes = (xml) => resolvePrefixes(xml, NESTED_BINDINGS.scoped);
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+/**
+* Whether a patcher that reads `<w:…>` literally sees every element it looks
+* for in `xml`, and may splice the serializer's `w:` markup into it.
+*
+* True for the canonical spelling. Also true when the part binds
+* WordprocessingML under an extra prefix besides `w` but never spells the
+* names the patcher scans under that alias, or binds markup compatibility
+* under another prefix. Relevant nested names are checked in their own scope.
+*/
+const splicesAsCanonical = (xml, localNames) => {
+	const resolution = resolveWordprocessingPrefixes(xml);
+	if (resolution.type === "resolved" && resolution.prefixes.canonical) return true;
+	const relaxed = resolveSelectiveScanPrefixes(xml);
+	if (relaxed.type !== "resolved") return false;
+	const { prefixes } = relaxed;
+	const only = (list, prefix) => list.length === 1 && list[0] === prefix;
+	const aliases = prefixes.main.filter((prefix) => prefix !== "w");
+	if (!prefixes.main.includes("w") || aliases.includes("") || !only(prefixes.w14, "w14") || prefixes.mc.length === 0) return false;
+	const names = localNames.map(escapeRegExp).join("|");
+	if (!aliases.every((alias) => !new RegExp(`[<\\s/]${escapeRegExp(alias)}:(?:${names})[\\s/>=]`, "u").test(xml))) return false;
+	const root = parseXmlDocument(xml);
+	if (!root) return false;
+	const mainNames = new Set(localNames.filter((name) => name !== "paraId" && name !== "textId"));
+	const idNames = /* @__PURE__ */ new Set(["paraId", "textId"]);
+	const mcNames = /* @__PURE__ */ new Set(["Fallback", "AlternateContent"]);
+	const visit = (element) => {
+		if (element.type !== "element") return true;
+		const name = element.name ?? "";
+		const local = getLocalName(name);
+		const prefix = getNamespacePrefix(name) ?? "";
+		const uri = getNamespaceUri(element) ?? "";
+		if (prefix === "mc" && uri !== MC_URI || mainNames.has(local) && WORDPROCESSINGML_NAMESPACE_URIS.has(uri) !== (prefix === "w") || mcNames.has(local) && uri === MC_URI !== prefixes.mc.includes(prefix)) return false;
+		for (const attribute of Object.keys(element.attributes ?? {})) {
+			const attributePrefix = getNamespacePrefix(attribute);
+			if (attributePrefix === "mc" && resolveAttributeNamespaceUri(element, attribute) !== MC_URI) return false;
+			if (!idNames.has(getLocalName(attribute))) continue;
+			if (resolveAttributeNamespaceUri(element, attribute) === W14_URI !== (attributePrefix === "w14")) return false;
+		}
+		return (element.elements ?? []).every(visit);
+	};
+	return visit(root);
+};
+/** The names the paragraph splices scan for: paragraphs, their containers and ids. */
+const PARAGRAPH_SCAN_NAMES = [
+	"p",
+	"tc",
+	"txbxContent",
+	"paraId",
+	"textId"
+];
+/** Whether `xml` spells WordprocessingML the way folio's serializer does. */
+const hasCanonicalWordprocessingPrefixes = (xml) => {
+	const resolution = resolveWordprocessingPrefixes(xml);
+	return resolution.type === "resolved" && resolution.prefixes.canonical;
+};
+/** `<p`, `<w:p`, … — the open-tag literal of `localName` under `prefix`. */
+const openTagLiteral = (prefix, localName) => prefix === "" ? `<${localName}` : `<${prefix}:${localName}`;
+/** `</p>`, `</w:p>`, … — the close-tag literal of `localName` under `prefix`. */
+const closeTagLiteral = (prefix, localName) => prefix === "" ? `</${localName}>` : `</${prefix}:${localName}>`;
+/**
+* Whether `xml` opens `localName` under one of `prefixes` at `start`, and the
+* length of the literal that matched (`-1` when none did). The character after
+* the name must end it, so `<w:pPr` is not `<w:p`.
+*/
+const matchOpenTag = (xml, start, prefixes, localName) => {
+	for (const prefix of prefixes) {
+		const literal = openTagLiteral(prefix, localName);
+		if (!xml.startsWith(literal, start)) continue;
+		const after = xml[start + literal.length];
+		if (after === ">" || after === "/" || isWhitespace(after)) return literal.length;
+	}
+	return -1;
+};
+/** The length of the close tag of `localName` under one of `prefixes` at `start`, or -1. */
+const matchCloseTag = (xml, start, prefixes, localName) => {
+	for (const prefix of prefixes) {
+		const literal = closeTagLiteral(prefix, localName);
+		if (xml.startsWith(literal, start)) return literal.length;
+	}
+	return -1;
+};
+//#endregion
+export { PARAGRAPH_SCAN_NAMES, closeTagLiteral, hasCanonicalWordprocessingPrefixes, matchCloseTag, matchOpenTag, openTagLiteral, resolveSelectiveScanPrefixes, resolveWordprocessingPrefixes, splicesAsCanonical };

package/dist/fonts/embeddedFonts.js

@@ -130,7 +130,7 @@ function findFontTableRels(allXml) {
 * embedded fonts. See {@link getEmbeddedFontFaces} for `docNonce`.
 */
 async function extractEmbeddedFonts(buffer, docNonce = generateHexId()) {
-	const raw = await unzipDocx(buffer);
+	const raw = await unzipDocx(buffer, {}, { verifyUnreadEntries: false });
 	return getEmbeddedFontFaces({
 		fontTableXml: raw.fontTableXml,
 		fontTableRelsXml: findFontTableRels(raw.allXml),