@stll/folio-core 0.52.0 → 0.54.0

package/dist/docx/serializer/paragraphSerializer.js

@@ -14,7 +14,7 @@ import { serializeSdtWrapper } from "./sdtPropertiesSerializer.js";
 import { serializeSectionProperties } from "./sectionPropertiesSerializer.js";
 import { serializeTextFormatting } from "./textFormattingSerializer.js";
 import { serializeTrackedChangeAttributes, trackedChangeAttributeRecord } from "./trackedChangeAttributes.js";
-import { panic } from "better-result";
+import { TaggedError, panic } from "better-result";
 import { escapeXmlAttribute, escapeXmlText } from "@stll/docx-core";
 import { PARAGRAPH_MARK_CHANGE_KINDS } from "@stll/docx-core/model";
 import { SEQUENCE_CHILDREN } from "@stll/docx-core/schema";
@@ -315,27 +315,51 @@ function serializeSimpleField(field) {
 	}).join("");
 	return `<w:fldSimple ${attrs.join(" ")}>${contentXml}</w:fldSimple>`;
 }
-/**
-* Serialize a complex field
-* Complex fields are represented by multiple runs with fldChar elements,
-* so we convert them back to that structure
-*/
+const replayableFormFieldDataXml = createCapturedXmlSanitizer({
+	allowedLocalNames: /* @__PURE__ */ new Set(["ffData"]),
+	allowedNamespaceUris: WORDPROCESSINGML_NAMESPACE,
+	inheritedNamespaceScope: OOXML_NAMESPACE_SCOPE
+});
+/** Serialize a complex field as structural fldChar runs and its content runs. */
 function serializeComplexField(field) {
 	const parts = [];
 	const structuralFormatting = field.formatting ?? (field.fieldResultIsFallback ? void 0 : field.fieldResult[0]?.formatting);
 	const rPrXml = structuralFormatting ? serializeTextFormatting(structuralFormatting) : "";
 	const beginAttrs = ["w:fldCharType=\"begin\"", ...fieldStateAttributes(field)];
-	parts.push(`<w:r>${rPrXml}<w:fldChar ${beginAttrs.join(" ")}/></w:r>`);
+	const formFieldDataXml = replayableFormFieldDataXml(field.formFieldDataXml);
+	const begin = formFieldDataXml ? `<w:fldChar ${beginAttrs.join(" ")}>${formFieldDataXml}</w:fldChar>` : `<w:fldChar ${beginAttrs.join(" ")}/>`;
+	parts.push(`<w:r>${rPrXml}${begin}</w:r>`);
 	if (field.fieldCode.length > 0) parts.push(...field.fieldCode.map((run) => serializeRun(run)));
 	else if (field.instruction.length > 0) {
 		const spaceAttr = field.instruction.startsWith(" ") || field.instruction.endsWith(" ") || field.instruction.includes("  ") ? " xml:space=\"preserve\"" : "";
 		parts.push(`<w:r>${rPrXml}<w:instrText${spaceAttr}>${escapeXmlText(field.instruction)}</w:instrText></w:r>`);
 	}
 	parts.push(`<w:r>${rPrXml}<w:fldChar w:fldCharType="separate"/></w:r>`);
-	if (!field.fieldResultIsFallback) parts.push(...field.fieldResult.map((run) => serializeRun(run)));
+	if (!field.fieldResultIsFallback || !formFieldDataXml) parts.push(...field.fieldResult.map((run) => serializeRun(run)));
 	parts.push(`<w:r>${rPrXml}<w:fldChar w:fldCharType="end"/></w:r>`);
 	return parts.join("");
 }
+var UnrepresentableTrackedSimpleFieldError = class extends TaggedError("UnrepresentableTrackedSimpleFieldError") {};
+/** A revision can contain run-level field characters, but not `w:fldSimple`. */
+function serializeTrackedSimpleField(field) {
+	const fieldResult = [];
+	for (const item of field.content) {
+		if (item.type !== "run") throw new UnrepresentableTrackedSimpleFieldError({
+			message: `A tracked simple field with ${item.type} result content cannot be serialized as valid OOXML.`,
+			contentType: item.type
+		});
+		fieldResult.push(item);
+	}
+	return serializeComplexField({
+		type: "complexField",
+		instruction: field.instruction,
+		fieldType: field.fieldType,
+		fieldCode: [],
+		fieldResult,
+		...field.fldLock !== void 0 && { fldLock: field.fldLock },
+		...field.dirty !== void 0 && { dirty: field.dirty }
+	});
+}
 /**
 * Serialize an inline SDT (w:sdt).
 *
@@ -413,7 +437,7 @@ function serializeTrackedChange(tag, change) {
 			case "run": return serializeContentRun(item);
 			case "simpleField":
 			case "complexField": {
-				const xml = item.type === "simpleField" ? serializeSimpleField(item) : serializeComplexField(item);
+				const xml = item.type === "simpleField" ? serializeTrackedSimpleField(item) : serializeComplexField(item);
 				return disposition === "removed" ? rewriteRunTextAsDeleted(xml) : xml;
 			}
 			case "mathEquation": return item.ommlXml;

package/dist/docx/serializer/tableSerializer.js

@@ -6,6 +6,7 @@ import { TRANSITIONAL_NAME_BY_STRICT_NAME } from "../strictNames.gen.js";
 import { TABLE_LOOK_FLAGS } from "../tableLook.js";
 import { parseTableCellProperties, parseTableGrid, parseTableProperties, parseTablePropertyExceptions, parseTableRowProperties } from "../tableParser.js";
 import { OOXML_NAMESPACE_SCOPE, parseXml } from "../xmlParser.js";
+import { serializeBlockCustomXml } from "./blockCustomXmlSerializer.js";
 import { serializeBlockSdt } from "./blockSdtSerializer.js";
 import { serializeBorder } from "./borderSerializer.js";
 import { serializeBookmarkMarker } from "./markupRangeAttributes.js";
@@ -456,56 +457,40 @@ const serializeTableGridChange = ({ id, columnWidths }) => {
 	const columns = columnWidths.map((width) => width === void 0 ? "<w:gridCol/>" : `<w:gridCol w:w="${intAttr(width)}"/>`).join("");
 	return `<w:tblGridChange w:id="${intAttr(id)}"><w:tblGrid>${columns}</w:tblGrid></w:tblGridChange>`;
 };
-/**
-* What makes two rows members of the same control.
-*
-* The control's record is on every child it held, so the wrapper is rebuilt
-* by grouping consecutive children that name the same control. Equality is
-* the record's canonical spelling rather than object identity, because the
-* editor carries these records through JSON — a Yjs sync, a snapshot, a
-* structured clone — and hands back an equal record rather than the same one.
-* A wrapper that split in two there would mint a second `w:id` for one
-* control, which is the defect, not the fix.
-*
-* The cost is the other direction: two adjacent rows the author put in two
-* separate but identically spelled controls come back as one. Word mints a
-* distinct `w:id` per control, so that needs a producer that writes none; the
-* inline wrapper stack makes the same trade for the same reason.
-*/
-const contentControlKey = (properties) => canonicalJson(properties);
-/**
-* Re-open each control around the run of children that named it, outermost
-* first.
-*
-* @param depth which layer of the stack this call is opening
-*/
-const serializeControlledChildren = (children, depth) => {
+const tableCarrierKey = (carrier) => carrier.type === "customXml" ? `customXml:${String(carrier.wrapper.id)}` : `sdt:${canonicalJson(carrier.properties)}`;
+const serializeTableCarriers = (children, depth = 0) => {
 	const parts = [];
 	let index = 0;
 	while (index < children.length) {
 		const child = children[index];
-		const control = child.controls[depth];
-		if (control === void 0) {
+		if (!child) break;
+		const carrier = child.carriers[depth];
+		if (!carrier) {
 			parts.push(child.xml);
 			index += 1;
 			continue;
 		}
-		const key = contentControlKey(control);
+		const carrierKey = tableCarrierKey(carrier);
 		let end = index + 1;
 		while (end < children.length) {
-			const next = children[end]?.controls[depth];
-			if (next === void 0 || contentControlKey(next) !== key) break;
+			const next = children[end]?.carriers[depth];
+			if ((next ? tableCarrierKey(next) : void 0) !== carrierKey) break;
 			end += 1;
 		}
-		const inner = serializeControlledChildren(children.slice(index, end), depth + 1);
-		parts.push(serializeSdtWrapper(control, inner));
+		const inner = serializeTableCarriers(children.slice(index, end), depth + 1);
+		if (carrier.type === "customXml") parts.push(`${carrier.wrapper.openingXml}${inner}${carrier.wrapper.closingXml}`);
+		else parts.push(serializeSdtWrapper(carrier.properties, inner));
 		index = end;
 	}
 	return parts.join("");
 };
+const carriersFor = (value) => value.carrierStack ?? [...(value.contentControls ?? []).map((properties) => ({
+	type: "sdt",
+	properties
+}))];
 /** A capture from the sink, with the controls it sat inside when parsed. */
 const preservedChild = (xml, child) => ({
-	controls: child.contentControls ?? [],
+	carriers: carriersFor(child),
 	xml
 });
 /**
@@ -517,6 +502,7 @@ function serializeCellContent(content, serializeParagraph) {
 			case "paragraph": return serializeParagraph(block);
 			case "table": return serializeTable(block, serializeParagraph);
 			case "blockSdt": return serializeBlockSdt(block, serializeCellBlock);
+			case "blockCustomXml": return serializeBlockCustomXml(block, serializeCellBlock);
 			case "preservedBlock": return block.xml;
 			case "bookmarkStart":
 			case "bookmarkEnd": return serializeBookmarkMarker(block);
@@ -549,10 +535,11 @@ function serializeTableCell(cell, serializeParagraph) {
 */
 const positionedChildren = (preserved, bookmarks) => {
 	if (bookmarks === void 0 || bookmarks.length === 0) return preserved;
-	return { children: [...preserved?.children ?? [], ...bookmarks.map(({ index, marker, contentControls }) => ({
+	return { children: [...preserved?.children ?? [], ...bookmarks.map(({ index, marker, contentControls, carrierStack }) => ({
 		index,
 		xml: serializeBookmarkMarker(marker),
-		...contentControls === void 0 ? {} : { contentControls }
+		...contentControls === void 0 ? {} : { contentControls },
+		...carrierStack === void 0 ? {} : { carrierStack }
 	}))] };
 };
 /**
@@ -564,8 +551,8 @@ function serializeTableRow(row, serializeParagraph) {
 	if (tblPrExXml) parts.push(tblPrExXml);
 	const trPrXml = serializeTableRowFormatting(row.formatting, row.propertyChanges, row.structuralChange);
 	if (trPrXml) parts.push(trPrXml);
-	parts.push(serializeControlledChildren(withPreservedChildren(row.cells.map((cell) => ({
-		controls: cell.contentControls ?? [],
+	parts.push(serializeTableCarriers(withPreservedChildren(row.cells.map((cell) => ({
+		carriers: carriersFor(cell),
 		xml: serializeTableCell(cell, serializeParagraph)
 	})), positionedChildren(row.preserved, row.bookmarks), preservedChild), 0));
 	const attrs = serializePreservedAttributes([], row.preservedAttributes);
@@ -581,8 +568,8 @@ function serializeTable(table, serializeParagraph) {
 	return `<w:tbl>${[
 		serializeTableFormatting(table.formatting, table.propertyChanges) || "<w:tblPr/>",
 		serializeTableGrid(table),
-		serializeControlledChildren(withPreservedChildren(table.rows.map((row) => ({
-			controls: row.contentControls ?? [],
+		serializeTableCarriers(withPreservedChildren(table.rows.map((row) => ({
+			carriers: carriersFor(row),
 			xml: serializeTableRow(row, serializeParagraph)
 		})), positionedChildren(table.preserved, table.bookmarks), preservedChild), 0)
 	].join("")}</w:tbl>`;

package/dist/docx/server/boundedArchive.d.ts

@@ -1,17 +1,5 @@
 import { XmlResourceLimits } from "../xmlResourceLimits.js";
-import JSZip from "jszip";
 //#region src/docx/server/boundedArchive.d.ts
-declare module "jszip" {
-  interface JSZipObject {
-    /**
-     * Chunked read of the entry content, missing from the published typings.
-     * `nodeStream` is this stream wrapped in a Node.js `Readable`, which
-     * browsers and web workers cannot provide; the stream itself is
-     * platform-neutral.
-     */
-    internalStream(type: "uint8array"): JSZip.JSZipStreamHelper<Uint8Array>;
-  }
-}
 declare const DOCX_MAX_ENTRY_BYTES: number;
 declare const DOCX_MAX_TOTAL_BYTES: number;
 declare const DOCX_MAX_ENTRIES = 4096;
@@ -20,7 +8,7 @@ declare const DocxArchiveError_base: import("better-result").TaggedErrorClass<"D
 /** Error raised when a DOCX archive cannot be loaded within configured limits. */
 declare class DocxArchiveError extends DocxArchiveError_base<{
   message: string;
-  reason: "load-failed" | "input-too-large" | "too-many-entries" | "entry-too-large" | "total-too-large" | "invalid-options";
+  reason: "load-failed" | "input-too-large" | "too-many-entries" | "entry-too-large" | "total-too-large" | "compression-ratio-exceeded" | "invalid-options";
   cause?: unknown;
 }> {}
 type DocxArchiveOptions = {
@@ -28,6 +16,13 @@ type DocxArchiveOptions = {
   maxEntryBytes?: number;
   maxTotalBytes?: number;
   maxEntries?: number;
+  /**
+   * Most inflated bytes allowed per compressed byte, for each markup or text
+   * entry and for the package as a whole. Binary entries are bounded by the
+   * byte limits and the package ratio only, and entries and packages under
+   * 4 MiB inflated are exempt. Defaults to 200.
+   */
+  maxCompressionRatio?: number;
   /**
    * Bounds on parsed XML structure, applied to every XML part this archive
    * hands out as a string.

package/dist/docx/server/boundedArchive.js

@@ -1,3 +1,4 @@
+import { compressionRatioLimitFor, countCentralDirectoryRecords, createInflationBudget, exceedsCompressionRatio, getZipEntrySizes, inflateEntryWithinLimits } from "../archiveInflation.js";
 import { FOLIO_XML_RESOURCE_LIMITS, assertXmlResourceLimits, createXmlPackageBudget } from "../xmlResourceLimits.js";
 import { TaggedError } from "better-result";
 import JSZip from "jszip";
@@ -8,49 +9,26 @@ const DOCX_MAX_ENTRIES = 4096;
 const DOCX_MAX_INPUT_BYTES = 50 * 1024 * 1024;
 /** Error raised when a DOCX archive cannot be loaded within configured limits. */
 var DocxArchiveError = class extends TaggedError("DocxArchiveError") {};
-const concatChunks = (chunks) => {
-	let totalBytes = 0;
-	for (const chunk of chunks) totalBytes += chunk.length;
-	const merged = new Uint8Array(totalBytes);
-	let offset = 0;
-	for (const chunk of chunks) {
-		merged.set(chunk, offset);
-		offset += chunk.length;
+const readLimitError = ({ limit, path, maxEntryBytes, maxTotalBytes, maxCompressionRatio }) => {
+	switch (limit) {
+		case "declared-size": return new DocxArchiveError({
+			message: `DOCX entry "${path}" inflated past its declared size`,
+			reason: "entry-too-large"
+		});
+		case "compression-ratio": return new DocxArchiveError({
+			message: `DOCX entry "${path}" exceeded the ${maxCompressionRatio}:1 compression ratio limit`,
+			reason: "compression-ratio-exceeded"
+		});
+		case "entry": return new DocxArchiveError({
+			message: `DOCX entry "${path}" exceeded the ${maxEntryBytes}-byte limit`,
+			reason: "entry-too-large"
+		});
+		case "total":
+		case "aborted": return new DocxArchiveError({
+			message: `DOCX archive exceeded the ${maxTotalBytes}-byte cumulative limit while reading "${path}"`,
+			reason: "total-too-large"
+		});
 	}
-	return merged;
-};
-/**
-* Accumulate an entry chunk by chunk, checking both caps before each chunk is
-* retained. Pausing the stream abandons a decompression bomb mid-inflate, so
-* the caps bound memory instead of merely reporting the overrun afterwards.
-*/
-const collectStream = async ({ stream, maxEntryBytes, remainingBytes, maxTotalBytes, path }) => await new Promise((resolve, reject) => {
-	const chunks = [];
-	let entryBytes = 0;
-	const fail = (reason, message) => {
-		stream.pause();
-		reject(new DocxArchiveError({
-			message,
-			reason
-		}));
-	};
-	stream.on("data", (chunk) => {
-		entryBytes += chunk.length;
-		if (entryBytes > maxEntryBytes) {
-			fail("entry-too-large", `DOCX entry "${path}" exceeded the ${maxEntryBytes}-byte limit`);
-			return;
-		}
-		if (entryBytes > remainingBytes) {
-			fail("total-too-large", `DOCX archive exceeded the ${maxTotalBytes}-byte cumulative limit while reading "${path}"`);
-			return;
-		}
-		chunks.push(chunk);
-	}).on("end", () => resolve(concatChunks(chunks))).on("error", reject).resume();
-});
-const getDeclaredUncompressedBytes = (entry) => {
-	const data = "_data" in entry ? entry._data : void 0;
-	const declaredBytes = typeof data === "object" && data !== null && "uncompressedSize" in data ? data.uncompressedSize : void 0;
-	return typeof declaredBytes === "number" && Number.isFinite(declaredBytes) ? declaredBytes : null;
 };
 const resolveByteLimit = ({ value, fallback, name }) => {
 	const limit = value ?? fallback;
@@ -60,6 +38,7 @@ const resolveByteLimit = ({ value, fallback, name }) => {
 	});
 	return limit;
 };
+const asBytes = (bytes) => bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
 const loadDocxArchive = async (bytes, options = {}) => {
 	const maxInputBytes = resolveByteLimit({
 		value: options.maxInputBytes,
@@ -81,10 +60,19 @@ const loadDocxArchive = async (bytes, options = {}) => {
 		fallback: DOCX_MAX_ENTRIES,
 		name: "DOCX entry limit"
 	});
+	const maxCompressionRatio = resolveByteLimit({
+		value: options.maxCompressionRatio,
+		fallback: 200,
+		name: "DOCX compression ratio limit"
+	});
 	if (bytes.byteLength > maxInputBytes) throw new DocxArchiveError({
 		message: `DOCX input contains ${bytes.byteLength} bytes (max ${maxInputBytes})`,
 		reason: "input-too-large"
 	});
+	if (countCentralDirectoryRecords(asBytes(bytes), maxEntries) > maxEntries) throw new DocxArchiveError({
+		message: `DOCX archive holds more than ${maxEntries} entries`,
+		reason: "too-many-entries"
+	});
 	let zip;
 	try {
 		zip = await JSZip.loadAsync(bytes);
@@ -101,30 +89,47 @@ const loadDocxArchive = async (bytes, options = {}) => {
 		reason: "too-many-entries"
 	});
 	let declaredTotalBytes = 0;
+	let declaredTotalKnown = true;
 	for (const entry of archiveEntries) {
 		if (entry.dir) continue;
-		const declaredBytes = getDeclaredUncompressedBytes(entry);
-		if (declaredBytes === null) {
-			declaredTotalBytes = NaN;
-			break;
+		const { compressedBytes, uncompressedBytes } = getZipEntrySizes(entry);
+		if (uncompressedBytes === null) {
+			declaredTotalKnown = false;
+			continue;
 		}
-		if (declaredBytes > maxEntryBytes) throw new DocxArchiveError({
-			message: `DOCX entry "${entry.name}" declares ${declaredBytes} bytes (max ${maxEntryBytes})`,
+		if (uncompressedBytes > maxEntryBytes) throw new DocxArchiveError({
+			message: `DOCX entry "${entry.name}" declares ${uncompressedBytes} bytes (max ${maxEntryBytes})`,
 			reason: "entry-too-large"
 		});
-		declaredTotalBytes += declaredBytes;
+		if (exceedsCompressionRatio({
+			inflatedBytes: uncompressedBytes,
+			compressedBytes,
+			maxRatio: compressionRatioLimitFor(entry.name, maxCompressionRatio)
+		})) throw new DocxArchiveError({
+			message: `DOCX entry "${entry.name}" declares more than ${maxCompressionRatio} bytes per compressed byte`,
+			reason: "compression-ratio-exceeded"
+		});
+		declaredTotalBytes += uncompressedBytes;
 	}
-	if (Number.isFinite(declaredTotalBytes) && declaredTotalBytes > maxTotalBytes) throw new DocxArchiveError({
+	if (declaredTotalKnown && declaredTotalBytes > maxTotalBytes) throw new DocxArchiveError({
 		message: `DOCX archive declares ${declaredTotalBytes} cumulative bytes (max ${maxTotalBytes})`,
 		reason: "total-too-large"
 	});
+	if (exceedsCompressionRatio({
+		inflatedBytes: declaredTotalBytes,
+		compressedBytes: bytes.byteLength,
+		maxRatio: maxCompressionRatio
+	})) throw new DocxArchiveError({
+		message: `DOCX archive declares more than ${maxCompressionRatio} bytes per archive byte`,
+		reason: "compression-ratio-exceeded"
+	});
 	const xmlLimits = {
 		...FOLIO_XML_RESOURCE_LIMITS,
 		...options.xmlLimits
 	};
 	const xmlBudget = createXmlPackageBudget();
 	const countedParts = /* @__PURE__ */ new Set();
-	let totalBytesRead = 0;
+	const inflationBudget = createInflationBudget(maxTotalBytes);
 	let readChain = Promise.resolve();
 	const readEntry = async (path, readOptions = {}) => {
 		const requestedMaxBytes = resolveByteLimit({
@@ -135,15 +140,21 @@ const loadDocxArchive = async (bytes, options = {}) => {
 		const work = async () => {
 			const entry = zip.file(path);
 			if (!entry) return null;
-			const content = await collectStream({
-				stream: entry.internalStream("uint8array"),
-				maxEntryBytes: Math.min(requestedMaxBytes, maxEntryBytes),
-				remainingBytes: maxTotalBytes - totalBytesRead,
+			const entryLimit = Math.min(requestedMaxBytes, maxEntryBytes);
+			const result = await inflateEntryWithinLimits({
+				entry,
+				maxEntryBytes: entryLimit,
+				maxCompressionRatio: compressionRatioLimitFor(path, maxCompressionRatio),
+				budget: inflationBudget
+			});
+			if (!result.ok) throw readLimitError({
+				limit: result.limit,
+				path,
+				maxEntryBytes: entryLimit,
 				maxTotalBytes,
-				path
+				maxCompressionRatio
 			});
-			totalBytesRead += content.length;
-			return content;
+			return result.bytes;
 		};
 		const next = readChain.then(work, work);
 		readChain = next.then(() => void 0, () => void 0);
@@ -154,7 +165,7 @@ const loadDocxArchive = async (bytes, options = {}) => {
 		entryMetadata: Object.freeze(archiveEntries.map((entry) => ({
 			path: entry.name,
 			directory: entry.dir,
-			declaredUncompressedBytes: getDeclaredUncompressedBytes(entry)
+			declaredUncompressedBytes: getZipEntrySizes(entry).uncompressedBytes
 		}))),
 		async readEntryString(path) {
 			const content = await readEntry(path);

package/dist/docx/server/createBilingualDocument.js

@@ -203,7 +203,7 @@ const flattenBlocks = (content) => {
 			out.push(block);
 			return;
 		}
-		if (block.type !== "blockSdt") return;
+		if (block.type !== "blockSdt" && block.type !== "blockCustomXml") return;
 		for (const child of block.content) visit(child);
 	};
 	for (const block of content) visit(block);
@@ -467,7 +467,7 @@ const collectTableParagraphs = (table) => {
 	const collectBlocks = (blocks) => {
 		for (const item of blocks) if (item.type === "paragraph") out.push(item);
 		else if (item.type === "table") out.push(...collectTableParagraphs(item));
-		else if (item.type === "blockSdt") collectBlocks(item.content);
+		else if (item.type === "blockSdt" || item.type === "blockCustomXml") collectBlocks(item.content);
 	};
 	for (const row of table.rows) for (const cell of row.cells) collectBlocks(cell.content);
 	return out;
@@ -476,7 +476,7 @@ const cloneTableForTarget = ({ table, editableParagraphIds, paraIds, styleCloner
 	const paragraphs = [];
 	const cloneBlocks = (blocks) => blocks.map((item) => {
 		if (item.type === "table") return cloneTable(item);
-		if (item.type === "blockSdt") return {
+		if (item.type === "blockSdt" || item.type === "blockCustomXml") return {
 			...structuredClone(item),
 			content: cloneBlocks(item.content)
 		};

package/dist/docx/server/extractDocxText.d.ts

@@ -1,3 +1,4 @@
+import { DocxArchiveOptions } from "./boundedArchive.js";
 //#region src/docx/server/extractDocxText.d.ts
 /** Document part containing an extracted paragraph. */
 type DocxParagraphSource = "header" | "body" | "footer";
@@ -59,7 +60,12 @@ type ExtractedDocxText = {
   charCount: number;
   view: "accepted";
 };
+/** Options for {@link extractDocxText}. */
+type ExtractDocxTextOptions = {
+  /** Archive limits, applied before and while each part is inflated. */
+  readonly archive?: DocxArchiveOptions;
+};
 /** Extract paragraph text and formatting metadata from a DOCX archive. */
-declare const extractDocxText: (bytes: ArrayBuffer | Uint8Array) => Promise<ExtractedDocxText>;
+declare const extractDocxText: (bytes: ArrayBuffer | Uint8Array, options?: ExtractDocxTextOptions) => Promise<ExtractedDocxText>;
 //#endregion
-export { DocxParagraphSource, DocxTableRowKind, DocxTableRowPosition, ExtractedDocxParagraph, ExtractedDocxTableCell, ExtractedDocxTableCellParagraph, ExtractedDocxText, extractDocxText };
+export { DocxParagraphSource, DocxTableRowKind, DocxTableRowPosition, ExtractDocxTextOptions, ExtractedDocxParagraph, ExtractedDocxTableCell, ExtractedDocxTableCellParagraph, ExtractedDocxText, extractDocxText };

package/dist/docx/server/extractDocxText.js

@@ -504,8 +504,8 @@ const createEmptyResult = () => ({
 	view: "accepted"
 });
 /** Extract paragraph text and formatting metadata from a DOCX archive. */
-const extractDocxText = async (bytes) => {
-	const archive = await loadDocxArchive(bytes);
+const extractDocxText = async (bytes, options = {}) => {
+	const archive = await loadDocxArchive(bytes, options.archive);
 	const documentXml = await archive.readEntryString("word/document.xml");
 	if (documentXml === null) return createEmptyResult();
 	const root = parseXml(documentXml);

package/dist/docx/server/validateDocxConformance.d.ts

@@ -4,7 +4,7 @@ import { DocxArchiveOptions } from "./boundedArchive.js";
 declare const FOLIO_DOCX_CONFORMANCE_REPORT_VERSION: 1;
 declare const FOLIO_DOCX_CONFORMANCE_PROFILE: "folio-supported-v1";
 declare const FOLIO_DOCX_CONFORMANCE_CHECKS: readonly ["archive-safety", "required-parts", "xml-well-formedness", "package-roots", "conformance-class", "canonical-model"];
-declare const FOLIO_DOCX_CONFORMANCE_ISSUE_CODES: readonly ["archive-load-failed", "archive-invalid-options", "archive-input-too-large", "archive-too-many-entries", "archive-entry-too-large", "archive-total-too-large", "required-part-missing", "xml-doctype-forbidden", "xml-not-well-formed", "xml-read-failed", "required-xml-unreadable", "package-root-invalid", "conformance-class-unknown", "model-invalid", "model-warning", "parser-recovery", "parser-unsupported", "parser-failed", "encrypted-container", "container-not-zip"];
+declare const FOLIO_DOCX_CONFORMANCE_ISSUE_CODES: readonly ["archive-load-failed", "archive-invalid-options", "archive-input-too-large", "archive-too-many-entries", "archive-entry-too-large", "archive-total-too-large", "archive-compression-ratio-exceeded", "required-part-missing", "xml-doctype-forbidden", "xml-not-well-formed", "xml-read-failed", "required-xml-unreadable", "package-root-invalid", "conformance-class-unknown", "model-invalid", "model-warning", "parser-recovery", "parser-unsupported", "parser-failed", "encrypted-container", "container-not-zip"];
 type FolioDocxConformanceCheckId = (typeof FOLIO_DOCX_CONFORMANCE_CHECKS)[number];
 type FolioDocxConformanceIssueCode = (typeof FOLIO_DOCX_CONFORMANCE_ISSUE_CODES)[number];
 type FolioDocxConformanceCheckStatus = "passed" | "failed" | "indeterminate" | "not-run";

package/dist/docx/server/validateDocxConformance.js

@@ -25,6 +25,7 @@ const FOLIO_DOCX_CONFORMANCE_ISSUE_CODES = Object.freeze([
 	"archive-too-many-entries",
 	"archive-entry-too-large",
 	"archive-total-too-large",
+	"archive-compression-ratio-exceeded",
 	"required-part-missing",
 	"xml-doctype-forbidden",
 	"xml-not-well-formed",