@stll/folio-core 0.64.1 → 0.66.0

package/dist/docx/server/boundedArchive.js

@@ -1,8 +1,8 @@
 import { decodeText } from "../../utils/textEncoding.js";
-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";
+import { DOCX_COMPRESSION_RATIO_GRACE_BYTES, isRatioBoundedPart } from "../archiveInflation.js";
+import { Result, TaggedError } from "better-result";
+import { FOLIO_XML_RESOURCE_LIMITS, assertXmlResourceLimits, createXmlPackageBudget } from "@stll/docx-core/xml/limits";
+import { ZipArchive, ZipError } from "@stll/docx-core/zip";
 // src/docx/server/boundedArchive.ts
 const DOCX_MAX_ENTRY_BYTES = 134217728;
 const DOCX_MAX_TOTAL_BYTES = 268435456;
@@ -11,27 +11,42 @@ const DOCX_MAX_INPUT_BYTES = 52428800;
 const DocxArchiveErrorBase = TaggedError("DocxArchiveError");
 /** Error raised when a DOCX archive cannot be loaded within configured limits. */
 var DocxArchiveError = class extends DocxArchiveErrorBase {};
-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"
+/** The archive error for a read the ZIP reader refused. */
+const archiveErrorFor = (error, { maxEntryBytes, maxTotalBytes, maxEntries, maxCompressionRatio }) => {
+	const entry = error.path === void 0 ? "" : ` "${error.path}"`;
+	switch (error.reason) {
+		case "too-many-entries": return new DocxArchiveError({
+			message: `DOCX archive holds more than ${maxEntries} entries`,
+			reason: "too-many-entries"
 		});
-		case "compression-ratio": return new DocxArchiveError({
-			message: `DOCX entry "${path}" exceeded the ${maxCompressionRatio}:1 compression ratio limit`,
-			reason: "compression-ratio-exceeded"
+		case "entry-too-large": return new DocxArchiveError({
+			message: `DOCX entry${entry} declares more than ${maxEntryBytes} bytes`,
+			reason: "entry-too-large"
 		});
-		case "entry": return new DocxArchiveError({
-			message: `DOCX entry "${path}" exceeded the ${maxEntryBytes}-byte limit`,
+		case "declared-size-exceeded": return new DocxArchiveError({
+			message: `DOCX entry${entry} inflated past its declared size`,
 			reason: "entry-too-large"
 		});
-		case "total":
-		case "aborted": return new DocxArchiveError({
-			message: `DOCX archive exceeded the ${maxTotalBytes}-byte cumulative limit while reading "${path}"`,
+		case "total-too-large": return new DocxArchiveError({
+			message: `DOCX archive declares more than ${maxTotalBytes} cumulative bytes`,
 			reason: "total-too-large"
 		});
+		case "compression-ratio": return new DocxArchiveError({
+			message: error.path === void 0 ? `DOCX archive declares more than ${maxCompressionRatio} bytes per archive byte` : `DOCX entry${entry} declares more than ${maxCompressionRatio} bytes per compressed byte`,
+			reason: "compression-ratio-exceeded"
+		});
+		case "malformed":
+		case "unsupported":
+		case "invalid-entry-name":
+		case "duplicate-entry":
+		case "corrupt-entry": return new DocxArchiveError({
+			message: "Failed to parse DOCX archive",
+			reason: "load-failed",
+			cause: error
+		});
 	}
 };
+const toArchiveError = (cause, limits) => cause instanceof ZipError ? archiveErrorFor(cause, limits) : cause;
 const resolveByteLimit = ({ value, fallback, name }) => {
 	const limit = value ?? fallback;
 	if (!Number.isSafeInteger(limit) || limit < 0) throw new DocxArchiveError({
@@ -40,7 +55,6 @@ 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,
@@ -71,103 +85,68 @@ const loadDocxArchive = async (bytes, options = {}) => {
 		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);
-	} catch (cause) {
-		throw new DocxArchiveError({
-			message: "Failed to parse DOCX archive",
-			reason: "load-failed",
-			cause
-		});
-	}
-	const archiveEntries = Object.values(zip.files);
-	if (archiveEntries.length > maxEntries) throw new DocxArchiveError({
-		message: `DOCX archive declares ${archiveEntries.length} entries (max ${maxEntries})`,
-		reason: "too-many-entries"
-	});
-	let declaredTotalBytes = 0;
-	let declaredTotalKnown = true;
-	for (const entry of archiveEntries) {
-		if (entry.dir) continue;
-		const { compressedBytes, uncompressedBytes } = getZipEntrySizes(entry);
-		if (uncompressedBytes === null) {
-			declaredTotalKnown = false;
-			continue;
-		}
-		if (uncompressedBytes > maxEntryBytes) throw new DocxArchiveError({
-			message: `DOCX entry "${entry.name}" declares ${uncompressedBytes} bytes (max ${maxEntryBytes})`,
-			reason: "entry-too-large"
-		});
-		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 (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 limits = {
+		maxEntryBytes,
+		maxTotalBytes,
+		maxEntries,
+		maxCompressionRatio
+	};
+	const read = await Result.tryPromise({
+		try: async () => await ZipArchive.read(bytes, {
+			limits: {
+				maxEntries,
+				maxEntryBytes,
+				maxTotalBytes,
+				maxCompressionRatio,
+				compressionRatioGraceBytes: DOCX_COMPRESSION_RATIO_GRACE_BYTES
+			},
+			isCompressionRatioExempt: (path) => !isRatioBoundedPart(path)
+		}),
+		catch: (cause) => toArchiveError(cause, limits)
 	});
+	if (Result.isError(read)) throw read.error;
+	const zip = read.value;
+	const archiveEntries = zip.entries();
 	const xmlLimits = {
 		...FOLIO_XML_RESOURCE_LIMITS,
 		...options.xmlLimits
 	};
 	const xmlBudget = createXmlPackageBudget();
 	const countedParts = /* @__PURE__ */ new Set();
-	const inflationBudget = createInflationBudget(maxTotalBytes);
-	let readChain = Promise.resolve();
+	let readBytes = 0;
 	const readEntry = async (path, readOptions = {}) => {
 		const requestedMaxBytes = resolveByteLimit({
 			value: readOptions.maxBytes,
 			fallback: maxEntryBytes,
 			name: "DOCX entry read byte limit"
 		});
-		const work = async () => {
-			const entry = zip.file(path);
-			if (!entry) return null;
-			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,
-				maxCompressionRatio
-			});
-			return result.bytes;
-		};
-		const next = readChain.then(work, work);
-		readChain = next.then(() => void 0, () => void 0);
-		return await next;
+		const entry = zip.entry(path);
+		if (!entry) return null;
+		const entryLimit = Math.min(requestedMaxBytes, maxEntryBytes);
+		if (entry.size > entryLimit) throw new DocxArchiveError({
+			message: `DOCX entry "${path}" exceeded the ${entryLimit}-byte limit`,
+			reason: "entry-too-large"
+		});
+		if (readBytes + entry.size > maxTotalBytes) throw new DocxArchiveError({
+			message: `DOCX archive exceeded the ${maxTotalBytes}-byte cumulative limit while reading "${path}"`,
+			reason: "total-too-large"
+		});
+		readBytes += entry.size;
+		const content = await Result.tryPromise({
+			try: async () => await entry.bytes(),
+			catch: (cause) => toArchiveError(cause, limits)
+		});
+		if (Result.isError(content)) {
+			readBytes -= entry.size;
+			throw content.error;
+		}
+		return content.value;
 	};
 	return {
-		entries: Object.freeze(archiveEntries.map(({ name }) => name)),
+		entries: Object.freeze(archiveEntries.map(({ path }) => path)),
 		entryMetadata: Object.freeze(archiveEntries.map((entry) => ({
-			path: entry.name,
-			directory: entry.dir,
-			declaredUncompressedBytes: getZipEntrySizes(entry).uncompressedBytes
+			path: entry.path,
+			declaredUncompressedBytes: entry.size
 		}))),
 		async readEntryString(path) {
 			const content = await readEntry(path);

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

@@ -30,7 +30,7 @@ export type FolioDocxPackagePart = {
   readonly path: string;
   readonly kind: FolioDocxPackagePartKind;
   readonly contentType: string | null;
-  readonly declaredUncompressedBytes: number | null;
+  readonly declaredUncompressedBytes: number;
 };
 export type FolioDocxInspectedXmlPart = {
   readonly path: string;

package/dist/docx/server/inspectDocxPackage.js

@@ -200,7 +200,7 @@ const inspectDocxPackage = async (bytes, options = {}) => {
 	const archive = await loadDocxArchive(bytes, options.archive);
 	const contentTypesBytes = await archive.readEntryUint8(CONTENT_TYPES_PATH, { maxBytes: CONTENT_TYPES_READ_LIMIT });
 	const declarations = parseContentTypes(contentTypesBytes === null ? null : decodeXml(contentTypesBytes, CONTENT_TYPES_PATH));
-	const parts = archive.entryMetadata.filter(({ directory }) => !directory).map((entry) => toPackagePart(entry, declarations)).toSorted(({ path: left }, { path: right }) => comparePackagePaths(left, right));
+	const parts = archive.entryMetadata.map((entry) => toPackagePart(entry, declarations)).toSorted(({ path: left }, { path: right }) => comparePackagePaths(left, right));
 	const partsByPath = new Map(parts.map((part) => [part.path, part]));
 	validateRequestedParts({
 		requestedPaths,

package/dist/docx/server/validateDocxConformance.js

@@ -4,10 +4,10 @@ import { DOCX_CONTAINER_TYPES, detectDocxContainerType } from "../encryption/con
 import { DocxModelValidationError, validateFolioDocumentModel } from "../modelValidation.js";
 import { DocxParseError, parseDocx } from "../parser.js";
 import { findChildByLocalName, getAttributeAnyPrefix, getLocalName, getNamespacePrefix, parseXmlDocument } from "../xmlParser.js";
-import { XmlResourceLimitError } from "../xmlResourceLimits.js";
 import { getDocxXmlSafetyIssue } from "../xmlSafety.js";
 import { DocxArchiveError, loadDocxArchive } from "./boundedArchive.js";
 import { DOCX_CONFORMANCE_CLASSES } from "@stll/docx-core/model";
+import { XmlResourceLimitError } from "@stll/docx-core/xml/limits";
 // src/docx/server/validateDocxConformance.ts
 const FOLIO_DOCX_CONFORMANCE_REPORT_VERSION = 1;
 const FOLIO_DOCX_CONFORMANCE_PROFILE = "folio-supported-v1";

package/dist/docx/shapeAlternateContent.js

@@ -1,8 +1,8 @@
 import { canonicalJson } from "../utils/canonicalJson.js";
 import { captureVerbatimXml, isSafeCapturedXmlDocument } from "./verbatimCapture.js";
 import { NAMESPACES, WORDPROCESSINGML_NAMESPACE_URIS, cloneWithXmlnsDeclarations, getChildElements, getLocalName, getNamespacePrefix, getNamespaceUri, parseXmlDocument } from "./xmlParser.js";
-import { assertXmlResourceLimits } from "./xmlResourceLimits.js";
 import { panic } from "better-result";
+import { assertXmlResourceLimits } from "@stll/docx-core/xml/limits";
 // src/docx/shapeAlternateContent.ts
 /**
 * Every modeled field, text body included: the Fallback repeats the shape's

package/dist/docx/storyBlockReplay.js

@@ -1,11 +1,11 @@
 import { canonicalJson } from "../utils/canonicalJson.js";
 import { spliceXml } from "./selectiveXmlPatch.js";
-import { getXmlSourceRange, parseStreamingXmlWithSourceRanges } from "./streamingXmlParser.js";
 import { TRANSITIONAL_NAMESPACE_BY_STRICT_URI } from "./strictValueEncodings.gen.js";
 import { captureSourceProfileXml, isSafeCapturedXmlDocument } from "./verbatimCapture.js";
 import { WORDPROCESSINGML_NAMESPACE_URIS, getAttributeByNamespaceUri, getChildElements, getLocalName, getNamespaceUri } from "./xmlParser.js";
 import { escapeXmlAttribute } from "@stll/docx-core";
 import { DOCX_CONFORMANCE_CLASSES } from "@stll/docx-core/model";
+import { getXmlSourceRange, parseStreamingXmlWithSourceRanges } from "@stll/docx-core/xml";
 // src/docx/storyBlockReplay.ts
 const BLOCK_ELEMENT_NAMES = {
 	paragraph: "p",

package/dist/docx/unzip.d.ts

@@ -1,4 +1,4 @@
-import JSZip from "jszip";
+import { ZipArchive } from "@stll/docx-core/zip";
 export declare class DocxSecurityError extends Error {
   constructor(message: string);
 }
@@ -75,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. */
@@ -100,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
  *