@stll/folio-core 0.64.0 → 0.65.0

package/dist/docx/trackedChangeInfo.js

@@ -1,6 +1,6 @@
 import { WORDPROCESSINGML_NAMESPACE_URIS, findAttributeByNamespaceUri, getAttributeByNamespaceUri } from "./xmlParser.js";
 import { normalizeRevisionId } from "@stll/docx-core/model";
-//#region src/docx/trackedChangeInfo.ts
+// src/docx/trackedChangeInfo.ts
 const DATE_UTC_NAMESPACE_URI = "http://schemas.microsoft.com/office/word/2023/wordml/word16du";
 const DATE_UTC_ATTRIBUTE = "w16du:dateUtc";
 const DATE_UTC_NAMESPACE_URIS = /* @__PURE__ */ new Set([DATE_UTC_NAMESPACE_URI]);
@@ -34,5 +34,4 @@ const parsePropertyChangeInfo = (node) => {
 		rsid
 	} : info;
 };
-//#endregion
 export { DATE_UTC_ATTRIBUTE, DATE_UTC_NAMESPACE_URI, parsePropertyChangeInfo, parseTrackedChangeInfo };

package/dist/docx/trackedMoveRangeNormalization.d.ts

@@ -1,5 +1,4 @@
 import { document_d_exports } from "../types/document.js";
-//#region src/docx/trackedMoveRangeNormalization.d.ts
 /** The code this normalisation is reported under, owned here, not at the caller. */
 export declare const UNBALANCED_MOVE_RANGE_WARNING: "unbalanced-move-range";
 type NormalizeTrackedMoveRangesInput = {
@@ -13,5 +12,4 @@ type NormalizeTrackedMoveRangesResult = {
   removedUnbalancedMoveRangeMarkers: number;
 };
 export declare const normalizeTrackedMoveRanges: ({ documentBody, headers, footers, footnotes, endnotes }: NormalizeTrackedMoveRangesInput) => NormalizeTrackedMoveRangesResult;
-//#endregion
 export {};

package/dist/docx/trackedMoveRangeNormalization.js

@@ -3,7 +3,7 @@ import { InlineContentRemovals } from "./inlineContentRemovals.js";
 import { visitDocxContentSlots } from "./paragraphTraversal.js";
 import { panic } from "better-result";
 import { PARSE_WARNING_CODES } from "@stll/docx-core/model";
-//#region src/docx/trackedMoveRangeNormalization.ts
+// src/docx/trackedMoveRangeNormalization.ts
 /** The code this normalisation is reported under, owned here, not at the caller. */
 const UNBALANCED_MOVE_RANGE_WARNING = PARSE_WARNING_CODES.unbalancedMoveRange;
 const normalizeTrackedMoveRanges = ({ documentBody, headers, footers, footnotes, endnotes }) => {
@@ -118,5 +118,4 @@ const toMoveRangeMarkerRef = (slot) => {
 	};
 	return null;
 };
-//#endregion
 export { UNBALANCED_MOVE_RANGE_WARNING, normalizeTrackedMoveRanges };

package/dist/docx/transitionalSpelling.d.ts

@@ -1,5 +1,4 @@
 import { PercentUnit, SlotEncoding } from "./strictValueEncodings.gen.js";
-//#region src/docx/transitionalSpelling.d.ts
 /**
  * The Transitional URI a Strict one stands for, or the URI unchanged.
  *
@@ -29,5 +28,4 @@ export declare const percentageSpelling: (value: string) => number | undefined;
  * `namespaceUri` is the element's, in either conformance class; the lookup
  * translates it. Omit `attributeLocalName` for element text content.
  */
-export declare const transitionalSlotEncoding: (namespaceUri: string | undefined, elementLocalName: string, attributeLocalName?: string) => SlotEncoding | undefined;
-//#endregion
+export declare const transitionalSlotEncoding: (namespaceUri: string | undefined, elementLocalName: string, attributeLocalName?: string) => SlotEncoding | undefined;

package/dist/docx/transitionalSpelling.js

@@ -1,5 +1,5 @@
 import { TRANSITIONAL_NAMESPACE_BY_STRICT_URI, TRANSITIONAL_SLOT_ENCODINGS } from "./strictValueEncodings.gen.js";
-//#region src/docx/transitionalSpelling.ts
+// src/docx/transitionalSpelling.ts
 /**
 * Reading a Strict-spelled value as the Transitional number it stands for.
 *
@@ -54,5 +54,4 @@ const transitionalSlotEncoding = (namespaceUri, elementLocalName, attributeLocal
 	const slot = `${toTransitionalNamespaceUri(namespaceUri)} ${elementLocalName}`;
 	return TRANSITIONAL_SLOT_ENCODINGS.get(attributeLocalName === void 0 ? slot : `${slot} @${attributeLocalName}`);
 };
-//#endregion
 export { NUMBERS_PER_PERCENT, STRICT_URI_PREFIX, isStrictNamespaceUri, percentageSpelling, toTransitionalNamespaceUri, transitionalSlotEncoding };

package/dist/docx/universalMeasure.d.ts

@@ -1,4 +1,3 @@
-//#region src/docx/universalMeasure.d.ts
 /**
  * ECMA-376's unit-carrying length, and the numbers Transitional counts it in.
  *
@@ -15,5 +14,4 @@ export declare const roundHalfAwayFromZero: (value: number) => number;
 /** The value of a universal measure in points, or `undefined` if it is not one. */
 export declare const universalMeasureInPoints: (value: string) => number | undefined;
 /** A universal measure as the whole number a Transitional attribute of `unit` holds. */
-export declare const universalMeasureAs: (value: string, unit: MeasureUnit) => number | undefined;
-//#endregion
+export declare const universalMeasureAs: (value: string, unit: MeasureUnit) => number | undefined;

package/dist/docx/universalMeasure.js

@@ -1,4 +1,4 @@
-//#region src/docx/universalMeasure.ts
+// src/docx/universalMeasure.ts
 /** `-?123.45pt`: the one shape ECMA-376 gives a length that carries its unit. */
 const UNIVERSAL_MEASURE = /^(-?[0-9]+(?:\.[0-9]+)?)(mm|cm|in|pt|pc|pi)$/u;
 const POINTS_PER_UNIT = {
@@ -28,5 +28,4 @@ const universalMeasureAs = (value, unit) => {
 	const points = universalMeasureInPoints(value);
 	return points === void 0 ? void 0 : roundHalfAwayFromZero(points * NUMBERS_PER_POINT[unit]);
 };
-//#endregion
 export { roundHalfAwayFromZero, universalMeasureAs, universalMeasureInPoints };

package/dist/docx/unzip.d.ts

@@ -1,5 +1,4 @@
-import JSZip from "jszip";
-//#region src/docx/unzip.d.ts
+import { ZipArchive } from "@stll/docx-core/zip";
 export declare class DocxSecurityError extends Error {
   constructor(message: string);
 }
@@ -76,7 +75,7 @@ export type RawDocxContent = {
   media: Map<string, ArrayBuffer>;
   fonts: Map<string, ArrayBuffer>;
   allXml: Map<string, string>;
-  originalZip: JSZip;
+  originalZip: ZipArchive;
   originalBuffer: ArrayBuffer;
   warnings: string[];
   /** True when the input was a password-protected CFB container. */
@@ -101,7 +100,6 @@ export type UnzipDocxBehavior = {
 export declare function unzipDocx(buffer: ArrayBuffer, options?: DocxUnzipOptions, { verifyUnreadEntries }?: UnzipDocxBehavior): Promise<RawDocxContent>;
 /** Keep extracted projections and the source ZIP aligned after parser normalization. */
 export declare const replaceRawDocxXmlParts: (content: RawDocxContent, parts: ReadonlyMap<string, string>) => Promise<void>;
-export declare function getEntryUncompressedSize(file: JSZip.JSZipObject): number | null;
 /**
  * Get a list of all files in the DOCX
  *
@@ -160,5 +158,4 @@ export declare function getContentSummary(content: RawDocxContent): {
   mediaCount: number;
   fontCount: number;
   totalFiles: number;
-};
-//#endregion
+};

package/dist/docx/unzip.js

@@ -1,14 +1,13 @@
 import { bytesToDataUrl } from "../utils/base64.js";
-import { encodeUtf8 } from "../utils/textEncoding.js";
-import { compressionRatioLimitFor, countCentralDirectoryRecords, createInflationBudget, exceedsCompressionRatio, getZipEntrySizes, inflateEntryWithinLimits, isStoredZipEntry } from "./archiveInflation.js";
+import { DOCX_COMPRESSION_RATIO_GRACE_BYTES, isRatioBoundedPart } from "./archiveInflation.js";
 import { DOCX_CONTAINER_TYPES, detectDocxContainerType } from "./encryption/containerFormat.js";
 import { openDocxBuffer } from "./encryption/openEncryptedDocx.js";
 import { RASTER_MIME_TYPES, detectRasterMimeType } from "./rasterMime.js";
 import { decodeXmlBytes } from "./xmlEncoding.js";
 import { FOLIO_XML_RESOURCE_LIMITS, assertXmlResourceLimits, createXmlPackageBudget } from "./xmlResourceLimits.js";
-import JSZip from "jszip";
-import { writeZipPart } from "@stll/docx-core/zip";
-//#region src/docx/unzip.ts
+import { Result } from "better-result";
+import { ZipArchive, ZipError } from "@stll/docx-core/zip";
+// src/docx/unzip.ts
 /**
 * DOCX Unzipper
 *
@@ -116,12 +115,10 @@ async function unzipDocx(buffer, options = {}, { verifyUnreadEntries = true } =
 	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);
+	const loaded = await loadDocxZip(zipBuffer, limits);
 	if (loaded.buffer.byteLength > limits.maxInputBytes) throw new DocxSecurityError("DOCX file exceeds the maximum allowed size");
 	const { zip } = loaded;
-	const entries = Object.entries(zip.files).filter(([, file]) => !file.dir);
+	const entries = zip.entries();
 	if (entries.length > limits.maxFiles) throw new DocxSecurityError("DOCX file contains too many entries");
 	const content = {
 		documentXml: null,
@@ -152,79 +149,46 @@ async function unzipDocx(buffer, options = {}, { verifyUnreadEntries = true } =
 		warnings: [],
 		wasEncrypted
 	};
-	let totalUncompressedBytes = 0;
-	const inflationBudget = createInflationBudget(limits.maxTotalUncompressedBytes);
 	const extractionTasks = [];
-	const verifyEntry = (file, path) => {
-		if (!verifyUnreadEntries || isStoredZipEntry(file)) return;
+	const verifyEntry = (file) => {
+		if (!verifyUnreadEntries) return;
 		extractionTasks.push(async () => {
-			await verifyEntryWithinLimits({
-				file,
-				path,
-				limits,
-				budget: inflationBudget
-			});
+			await verifyEntryData(file);
 			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 { 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}`);
-		}
+	for (const file of entries) {
+		const { path, size: declaredSize } = file;
 		if (!isParsedDocxEntry(path)) {
-			verifyEntry(file, path);
+			verifyEntry(file);
 			continue;
 		}
 		const lowerPath = path.toLowerCase();
 		if (lowerPath.endsWith(".xml") || lowerPath.endsWith(".rels")) {
 			assertEntrySize(path, declaredSize, limits.maxXmlBytes);
 			if (options.extractAllXml === false && !shouldExtractXmlPart(lowerPath)) {
-				verifyEntry(file, path);
+				verifyEntry(file);
 				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(result.bytes)
-				};
-			});
+			extractionTasks.push(async () => ({
+				type: "xml",
+				path,
+				lowerPath,
+				content: decodeXmlBytes(await readEntry(file))
+			}));
 		} else if (lowerPath.startsWith("word/media/")) {
 			const mimeType = getMediaMimeType(path);
 			if (!limits.allowedMediaMimeTypes.has(mimeType)) {
-				verifyEntry(file, path);
+				verifyEntry(file);
 				continue;
 			}
 			if (isEntryTooLarge(declaredSize, limits.maxMediaBytes)) {
 				content.warnings.push(`Skipped oversized media file: ${path}; original entry preserved for round-trip.`);
-				verifyEntry(file, path);
+				verifyEntry(file);
 				continue;
 			}
 			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;
+				const binaryContent = (await readEntry(file)).buffer;
 				const effectiveMimeType = RASTER_MIME_TYPES.has(mimeType) ? detectRasterMimeType(binaryContent) : mimeType;
 				if (!effectiveMimeType || !limits.allowedMediaMimeTypes.has(effectiveMimeType) || !isMediaContentAllowed(binaryContent, effectiveMimeType)) return null;
 				return {
@@ -236,30 +200,18 @@ async function unzipDocx(buffer, options = {}, { verifyUnreadEntries = true } =
 			});
 		} else if (lowerPath.startsWith("word/fonts/")) {
 			if (isEntryTooLarge(declaredSize, limits.maxFontBytes)) {
-				verifyEntry(file, path);
+				verifyEntry(file);
 				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: result.bytes.buffer
-				};
-			});
-		} else verifyEntry(file, path);
+			extractionTasks.push(async () => ({
+				type: "font",
+				path,
+				content: (await readEntry(file)).buffer
+			}));
+		} else verifyEntry(file);
 	}
-	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 runExtractionTasks(extractionTasks, inflationBudget)) {
+	for (const extracted of await runExtractionTasks(extractionTasks)) {
 		if (!extracted) continue;
 		if (extracted.type === "xml") {
 			assignXmlContent(content, extracted, limits, xmlBudget);
@@ -284,18 +236,10 @@ const replaceRawDocxXmlParts = async (content, parts) => {
 			lowerPath: path.toLowerCase(),
 			content: xmlContent
 		});
-		writeZipPart({
-			zip: content.originalZip,
-			path,
-			data: encodeUtf8(xmlContent)
-		});
+		content.originalZip.set(path, xmlContent);
 		identitiesChanged = true;
 	}
-	if (identitiesChanged) content.originalBuffer = await content.originalZip.generateAsync({
-		type: "arraybuffer",
-		compression: "DEFLATE",
-		compressionOptions: { level: 1 }
-	});
+	if (identitiesChanged) content.originalBuffer = (await content.originalZip.generate({ level: 1 })).buffer;
 };
 /**
 * Preflight every XML part the unzip retains, not a named few.
@@ -349,80 +293,111 @@ const indexXmlContent = (content, { path, lowerPath, content: xmlContent }) => {
 		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}`);
+/** The error the unzip reports for an archive or entry the reader refused. */
+function docxErrorFor(error) {
+	const path = error.path ?? "";
+	switch (error.reason) {
+		case "declared-size-exceeded": return new DocxSecurityError(`DOCX entry inflates past its declared size: ${path}`);
+		case "compression-ratio": return new DocxSecurityError(error.path === void 0 ? "DOCX file exceeds the maximum compression ratio" : `DOCX entry exceeds the maximum compression ratio: ${path}`);
+		case "too-many-entries": return new DocxSecurityError("DOCX file contains too many entries");
+		case "entry-too-large":
+		case "total-too-large": return new DocxSecurityError("DOCX file expands beyond the maximum allowed size");
+		case "invalid-entry-name": return new DocxSecurityError("DOCX file contains an unsafe entry path");
+		case "malformed":
+		case "unsupported":
+		case "duplicate-entry":
+		case "corrupt-entry": return error;
 	}
 }
+const rethrowRead = (error) => {
+	throw error instanceof ZipError ? docxErrorFor(error) : error;
+};
+/** An extracted entry's bytes; inflation stops at its declared size. */
+async function readEntry(file) {
+	const read = await Result.tryPromise({
+		try: async () => await file.bytes(),
+		catch: (cause) => cause
+	});
+	return Result.isOk(read) ? read.value : rethrowRead(read.error);
+}
+/**
+* Inflate an entry without keeping it, to bound what a later read of it can
+* produce. Data past the declared size refuses the package. A corrupt entry
+* does not: it was never going to be read here, a later read fails the same
+* way, and refusing the whole document over a part folio does not model
+* would be a regression.
+*/
+async function verifyEntryData(file) {
+	const read = await Result.tryPromise({
+		try: async () => await file.bytes(),
+		catch: (cause) => cause
+	});
+	if (Result.isOk(read)) return;
+	const error = read.error;
+	if (!(error instanceof ZipError) || error.reason === "declared-size-exceeded") rethrowRead(error);
+}
 /**
 * 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.
+* task order. The first failure leaves the queued tasks unstarted.
 */
-async function runExtractionTasks(tasks, budget) {
+async function runExtractionTasks(tasks) {
 	const results = Array.from({ length: tasks.length }, () => null);
 	let next = 0;
+	let aborted = false;
 	const worker = async () => {
-		while (next < tasks.length && !budget.aborted) {
+		while (next < tasks.length && !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;
+			const result = await Result.tryPromise({
+				try: async () => await task(),
+				catch: (cause) => cause
+			});
+			if (Result.isError(result)) {
+				aborted = true;
+				throw result.error;
 			}
+			results[index] = result.value;
 		}
 	};
 	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 {
-			zip: await JSZip.loadAsync(buffer),
-			buffer
-		};
-	} catch (error) {
-		const repairedBuffer = repairTruncatedEndOfCentralDirectory(buffer, maxFiles);
-		if (!repairedBuffer) throw error;
-		try {
-			return {
-				zip: await JSZip.loadAsync(repairedBuffer),
-				buffer: repairedBuffer
-			};
-		} catch {
-			throw error;
-		}
-	}
+/** Package limits as the archive reader enforces them. */
+const zipReadOptionsFor = (limits) => ({
+	limits: {
+		maxEntries: limits.maxFiles * 2,
+		maxEntryBytes: limits.maxTotalUncompressedBytes,
+		maxTotalBytes: limits.maxTotalUncompressedBytes,
+		maxCompressionRatio: limits.maxCompressionRatio,
+		compressionRatioGraceBytes: DOCX_COMPRESSION_RATIO_GRACE_BYTES
+	},
+	isCompressionRatioExempt: (path) => !isRatioBoundedPart(path)
+});
+async function loadDocxZip(buffer, limits) {
+	const options = zipReadOptionsFor(limits);
+	const read = await Result.tryPromise({
+		try: async () => await ZipArchive.read(buffer, options),
+		catch: (cause) => cause
+	});
+	if (Result.isOk(read)) return {
+		zip: read.value,
+		buffer
+	};
+	const error = read.error;
+	if (!(error instanceof ZipError) || error.reason !== "malformed") return rethrowRead(error);
+	const repairedBuffer = repairTruncatedEndOfCentralDirectory(buffer, limits.maxFiles);
+	if (!repairedBuffer) throw error;
+	const repaired = await Result.tryPromise({
+		try: async () => await ZipArchive.read(repairedBuffer, options),
+		catch: (cause) => cause
+	});
+	if (Result.isOk(repaired)) return {
+		zip: repaired.value,
+		buffer: repairedBuffer
+	};
+	throw error;
 }
 function repairTruncatedEndOfCentralDirectory(buffer, maxFiles) {
 	const bytes = new Uint8Array(buffer);
@@ -520,14 +495,11 @@ function isParsedDocxEntry(path) {
 	if (!(lowerPath.endsWith(".xml") || lowerPath.endsWith(".rels"))) return false;
 	return lowerPath === "[content_types].xml" || lowerPath.startsWith("_rels/") || lowerPath.startsWith("docprops/") || lowerPath.startsWith("word/") || lowerPath.startsWith("customxml/");
 }
-function getEntryUncompressedSize(file) {
-	return getZipEntrySizes(file).uncompressedBytes;
-}
 function assertEntrySize(path, declaredSize, maxBytes) {
 	if (isEntryTooLarge(declaredSize, maxBytes)) throw new DocxSecurityError(`DOCX entry exceeds maximum size: ${path}`);
 }
 function isEntryTooLarge(declaredSize, maxBytes) {
-	return declaredSize !== null && declaredSize > maxBytes;
+	return declaredSize > maxBytes;
 }
 function isMediaContentAllowed(data, mimeType) {
 	if (RASTER_MIME_TYPES.has(mimeType)) return detectRasterMimeType(data) === mimeType;
@@ -548,7 +520,7 @@ function isMediaContentAllowed(data, mimeType) {
 */
 function getFileList(content) {
 	const files = [];
-	for (const path of Object.keys(content.originalZip.files)) if (!content.originalZip.files[path]?.dir && isParsedDocxEntry(path)) files.push(path);
+	for (const path of content.originalZip.paths()) if (isParsedDocxEntry(path)) files.push(path);
 	return files.toSorted();
 }
 /**
@@ -591,11 +563,11 @@ function mediaToDataUrl(data, mimeType) {
 * @returns File content as string or ArrayBuffer, or null if not found
 */
 function extractFile(content, path) {
-	const file = content.originalZip.file(path);
+	const file = content.originalZip.entry(path);
 	if (!file || !isParsedDocxEntry(path)) return Promise.resolve(null);
 	const lowerPath = path.toLowerCase();
-	if (lowerPath.endsWith(".xml") || lowerPath.endsWith(".rels")) return file.async("uint8array").then(decodeXmlBytes);
-	return file.async("arraybuffer");
+	if (lowerPath.endsWith(".xml") || lowerPath.endsWith(".rels")) return file.bytes().then(decodeXmlBytes);
+	return file.arrayBuffer();
 }
 /**
 * Check if a file exists in the DOCX
@@ -605,7 +577,7 @@ function extractFile(content, path) {
 * @returns true if file exists
 */
 function hasFile(content, path) {
-	return content.originalZip.file(path) !== null;
+	return content.originalZip.has(path);
 }
 /**
 * Get summary of DOCX content
@@ -627,8 +599,7 @@ function getContentSummary(content) {
 		footerCount: content.footers.size,
 		mediaCount: content.media.size,
 		fontCount: content.fonts.size,
-		totalFiles: Object.keys(content.originalZip.files).filter((p) => !content.originalZip.files[p]?.dir).length
+		totalFiles: content.originalZip.paths().length
 	};
 }
-//#endregion
-export { DocxSecurityError, extractFile, getContentSummary, getEntryUncompressedSize, getFileList, getMediaMimeType, hasFile, mediaToDataUrl, replaceRawDocxXmlParts, unzipDocx };
+export { DocxSecurityError, extractFile, getContentSummary, getFileList, getMediaMimeType, hasFile, mediaToDataUrl, replaceRawDocxXmlParts, unzipDocx };

package/dist/docx/verbatimCapture.d.ts

@@ -1,7 +1,6 @@
 import { document_d_exports } from "../types/document.js";
 import { XmlElement, XmlNamespaceScope } from "./xmlParser.js";
 import { TaggedErrorClass } from "better-result";
-//#region src/docx/verbatimCapture.d.ts
 declare const UntranslatableStrictNamespaceErrorBase: TaggedErrorClass<"UntranslatableStrictNamespaceError">;
 /** A Strict fragment uses a namespace that has no Transitional counterpart. */
 export declare class UntranslatableStrictNamespaceError extends UntranslatableStrictNamespaceErrorBase<{
@@ -32,5 +31,4 @@ export declare const isSafeCapturedXmlDocument: (xml: string) => boolean;
  */
 export declare const createCapturedXmlSanitizer: (options: SanitizeCapturedXmlOptions) => ((xml: string | undefined) => string | null);
 export declare const captureSourceProfileXml: (element: XmlElement, conformance: document_d_exports.DocxConformanceClass | undefined) => string;
-//#endregion
 export {};

package/dist/docx/verbatimCapture.js

@@ -6,7 +6,7 @@ import { assertXmlResourceLimits } from "./xmlResourceLimits.js";
 import { getDocxXmlSafetyIssue } from "./xmlSafety.js";
 import { TaggedError, panic } from "better-result";
 import { DOCX_CONFORMANCE_CLASSES } from "@stll/docx-core/model";
-//#region src/docx/verbatimCapture.ts
+// src/docx/verbatimCapture.ts
 /**
 * The one way to turn parsed markup into a string a rebuilt part replays.
 *
@@ -408,5 +408,4 @@ const captureSourceProfileXml = (element, conformance) => {
 	if (!isSafeCapturedXmlDocument(xml)) panic("Generated source-profile markup is unsafe.");
 	return xml;
 };
-//#endregion
 export { UntranslatableStrictNamespaceError, captureSourceProfileXml, captureVerbatimXml, createCapturedXmlSanitizer, isSafeCapturedXmlDocument };

package/dist/docx/verticalMergeProjection.d.ts

@@ -1,5 +1,4 @@
 import { document_d_exports } from "../types/document.js";
-//#region src/docx/verticalMergeProjection.d.ts
 /** The reader and revision resolver share which continuation cells remain visible. */
 export type RowSpanInfo = {
   rowSpan: number;
@@ -12,5 +11,4 @@ export declare function calculateRowSpans(table: document_d_exports.Table): Map<
  * Whether a cell carries content a vertical-merge continuation must not hide.
  * The reader keeps such a continuation as a cell of its own.
  */
-export declare function tableCellHasMeaningfulContent(cell: document_d_exports.TableCell): boolean;
-//#endregion
+export declare function tableCellHasMeaningfulContent(cell: document_d_exports.TableCell): boolean;

package/dist/docx/verticalMergeProjection.js

@@ -1,5 +1,5 @@
 import { isCellMergeContinuation } from "./tableParser.js";
-//#region src/docx/verticalMergeProjection.ts
+// src/docx/verticalMergeProjection.ts
 function calculateRowSpans(table) {
 	const result = /* @__PURE__ */ new Map();
 	const numRows = table.rows.length;
@@ -116,5 +116,4 @@ function paragraphContentHasMeaningfulContent(content) {
 	if (content.type === "insertion" || content.type === "deletion" || content.type === "moveFrom" || content.type === "moveTo") return content.content.some(paragraphContentHasMeaningfulContent);
 	return true;
 }
-//#endregion
 export { calculateRowSpans, tableCellHasMeaningfulContent };

package/dist/docx/vmlImageParser.d.ts

@@ -1,7 +1,6 @@
 import { document_d_exports } from "../types/document.js";
 import { XmlElement } from "./xmlParser.js";
 import { PreviewLedger } from "./previewBudget.js";
-//#region src/docx/vmlImageParser.d.ts
 /**
  * Whether a `w:pict` that resolved to no image must still be kept verbatim.
  *
@@ -47,5 +46,4 @@ export declare function parseVmlImageContent(pictElement: XmlElement, rels: docu
  * either result: a preview built here would be registered against the package
  * budget for a drawing the model never holds.
  */
-export declare const isVmlPictParsedByRunParser: (pictElement: XmlElement, rels: document_d_exports.RelationshipMap | null, media: Map<string, document_d_exports.MediaFile> | null) => boolean;
-//#endregion
+export declare const isVmlPictParsedByRunParser: (pictElement: XmlElement, rels: document_d_exports.RelationshipMap | null, media: Map<string, document_d_exports.MediaFile> | null) => boolean;

package/dist/docx/vmlImageParser.js

@@ -7,7 +7,7 @@ import { fitsVmlSvgCap, isValidVmlPreviewDimension, parseVmlNumber, parseVmlStyl
 import { isWatermarkShape } from "./watermarkParser.js";
 import { cloneWithXmlnsDeclarations, findAllDeep, findChild, findDeep, getAttribute, getChildElements, getLocalName } from "./xmlParser.js";
 import { DRAWING_RAW_XML_MODES, relationshipIdOf } from "@stll/docx-core/model";
-//#region src/docx/vmlImageParser.ts
+// src/docx/vmlImageParser.ts
 /**
 * VML image parser — legacy `w:pict` inline pictures.
 *
@@ -274,5 +274,4 @@ function parseVmlImageContent(pictElement, rels, media, previews, rootXmlns = {}
 * budget for a drawing the model never holds.
 */
 const isVmlPictParsedByRunParser = (pictElement, rels, media) => vmlPictPicture(pictElement, rels, media) !== null || vmlPictPreview(pictElement) !== null || shouldPreserveRawVmlPict(pictElement);
-//#endregion
 export { isVmlPictParsedByRunParser, parseVmlImageContent, shouldPreserveRawVmlPict };

package/dist/docx/vmlPreview.d.ts

@@ -1,5 +1,4 @@
 import { XmlElement } from "./xmlParser.js";
-//#region src/docx/vmlPreview.d.ts
 export type VmlPreviewResult = {
   type: "rendered";
   svg: string;
@@ -24,5 +23,4 @@ export declare const fitsVmlSvgCap: (svg: string) => boolean;
 /** Render a bounded standalone VML rectangle or oval preview. */
 export declare const renderStandaloneVmlPreview: (shape: XmlElement) => VmlPreviewResult;
 /** Render a VML group through bounded, non-clipping local-coordinate transforms. */
-export declare const renderVmlGroupPreview: (group: XmlElement) => VmlPreviewResult;
-//#endregion
+export declare const renderVmlGroupPreview: (group: XmlElement) => VmlPreviewResult;