@stll/folio-core 0.64.1 → 0.66.0

package/dist/docx/unzip.js

@@ -1,13 +1,12 @@
 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";
+import { Result } 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/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,7 +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
 	};
 }
-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.js

@@ -2,10 +2,10 @@ import { TRANSITIONAL_NAMESPACE_BY_STRICT_URI } from "./strictValueEncodings.gen
 import { NUMBERS_PER_PERCENT, isStrictNamespaceUri, percentageSpelling, toTransitionalNamespaceUri, transitionalSlotEncoding } from "./transitionalSpelling.js";
 import { roundHalfAwayFromZero, universalMeasureAs } from "./universalMeasure.js";
 import { NAMESPACES, OOXML_NAMESPACE_SCOPE, WORDPROCESSINGML_NAMESPACE_URIS, cloneElement, elementToXml, getAttributeByNamespaceUri, getChildElements, getLocalName, getNamespacePrefix, parseXml, resolveAttributeNamespaceUri } from "./xmlParser.js";
-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";
+import { assertXmlResourceLimits } from "@stll/docx-core/xml/limits";
 // src/docx/verbatimCapture.ts
 /**
 * The one way to turn parsed markup into a string a rebuilt part replays.

package/dist/docx/xmlParser.d.ts

@@ -1,32 +1,5 @@
 import { ParseContext } from "./parseContext.js";
-/**
- * XML element tree node — drop-in replacement for the `Element` type
- * previously imported from `xml-js`. Every consumer imports this from
- * `xmlParser.ts`, so the shape must stay identical.
- */
-export type XmlElement = {
-  declaration?: {
-    attributes?: Record<string, string | number>;
-  };
-  instruction?: string;
-  attributes?: Record<string, string | number | undefined>;
-  cdata?: string;
-  doctype?: string;
-  comment?: string;
-  text?: string | number | boolean;
-  type?: string;
-  name?: string;
-  /** Resolved namespace URI; non-enumerable so legacy structural comparisons stay stable. */
-  namespaceUri?: string;
-  /** In-scope namespace declarations; non-enumerable so legacy comparisons stay stable. */
-  namespaceScope?: XmlNamespaceScope;
-  elements?: XmlElement[];
-};
-/** Parent-linked XML namespace declarations; each scope stores only local overrides. */
-export type XmlNamespaceScope = {
-  bindings: ReadonlyMap<string, string>;
-  parent?: XmlNamespaceScope;
-};
+import { XmlElement, XmlNamespaceScope } from "@stll/docx-core/xml";
 /**
  * Common OOXML namespace URIs — re-exported from @stll/docx-utils.
  */
@@ -67,16 +40,11 @@ export declare const NAMESPACES: {
  */
 export declare const OOXML_NAMESPACE_SCOPE: XmlNamespaceScope;
 export declare function parseXml(xml: string, inheritedNamespaceScope?: XmlNamespaceScope): XmlElement;
-/**
- * The general-purpose reader {@link parseXml} falls back to, and the reference
- * the streaming reader's equivalence tests compare against.
- */
-export declare function parseXmlWithFastXmlParser(xml: string, inheritedNamespaceScope?: XmlNamespaceScope): XmlElement;
 /**
  * Serialize an XmlElement back to an XML string.
  *
- * Written here rather than handed to `fast-xml-parser`'s builder for two
- * reasons. The builder writes a tab or a newline inside an attribute value
+ * Written here rather than handed to a general-purpose XML builder (the one
+ * folio used before) for two reasons. The builder writes a tab or a newline inside an attribute value
  * literally, and XML 1.0 §3.3.3 has every conformant reader normalise those to
  * a space: a `descr="two lines&#xA;"` a source file wrote came back as
  * `descr="two lines "`. `escapeXmlAttribute` writes the character references
@@ -405,4 +373,5 @@ export declare function cloneWithXmlnsDeclarations(element: XmlElement, xmlnsDec
  * original's scope leaves resolution unchanged whether or not the clone
  * carries `xmlns` attributes of its own.
  */
-export declare function cloneElement(element: XmlElement, overrides: Partial<XmlElement>): XmlElement;
+export declare function cloneElement(element: XmlElement, overrides: Partial<XmlElement>): XmlElement;
+export type { XmlElement, XmlNamespaceScope };

package/dist/docx/xmlParser.js

@@ -1,10 +1,9 @@
-import { parseStreamingXml } from "./streamingXmlParser.js";
 import { NUMBERS_PER_PERCENT, percentageSpelling, transitionalSlotEncoding } from "./transitionalSpelling.js";
 import { universalMeasureAs } from "./universalMeasure.js";
-import { EMPTY_NAMESPACE_SCOPE, attachXmlNamespaceContext, resolveNamespaceUri } from "./xmlNamespaceContext.js";
 import { escapeXmlAttribute, escapeXmlText } from "@stll/docx-core";
 import { PARSE_WARNING_CODES } from "@stll/docx-core/model";
-import { XMLParser } from "fast-xml-parser";
+import { XmlReadError, readXml } from "@stll/docx-core/xml";
+import { EMPTY_NAMESPACE_SCOPE, attachXmlNamespaceContext, resolveNamespaceUri } from "@stll/docx-core/xml/namespaces";
 import { OOXML_NS } from "@stll/docx-utils";
 // src/docx/xmlParser.ts
 /**
@@ -27,69 +26,6 @@ import { OOXML_NS } from "@stll/docx-utils";
 * - o:  Office (extensions)
 * - pic: Pictures
 */
-const fxpParserOptions = {
-	preserveOrder: true,
-	ignoreAttributes: false,
-	attributeNamePrefix: "",
-	trimValues: false,
-	textNodeName: "#text",
-	parseTagValue: false,
-	parseAttributeValue: false,
-	ignoreDeclaration: true,
-	ignorePiTags: true,
-	jPath: false,
-	processEntities: true,
-	htmlEntities: true
-};
-const fxpParserOptionsWithStopNodes = {
-	...fxpParserOptions,
-	stopNodes: ["*.w:binData"]
-};
-const fxpParser = new XMLParser(fxpParserOptions);
-const fxpParserWithStopNodes = new XMLParser(fxpParserOptionsWithStopNodes);
-/** Text node key used by fast-xml-parser in preserveOrder mode. */
-const TEXT_KEY = "#text";
-/** Attribute group key used by fast-xml-parser in preserveOrder mode. */
-const ATTR_KEY = ":@";
-/**
-* Convert a fast-xml-parser preserveOrder node into an XmlElement.
-*
-* In preserveOrder mode every node is an object with exactly one "real" key
-* (the tag name or `#text`) whose value is the children array, plus an
-* optional `:@` key holding the attributes object.
-*/
-function fxpNodeToElement(node, inheritedNamespaceScope = EMPTY_NAMESPACE_SCOPE) {
-	if (TEXT_KEY in node) return {
-		type: "text",
-		text: node[TEXT_KEY]
-	};
-	const attrs = node[ATTR_KEY];
-	for (const key in node) {
-		if (key === ATTR_KEY) continue;
-		const children = node[key];
-		const element = {
-			type: "element",
-			name: key
-		};
-		if (attrs) element.attributes = attrs;
-		const namespaceScope = attachXmlNamespaceContext(element, inheritedNamespaceScope);
-		if (children.length > 0) {
-			for (let index = 0; index < children.length; index += 1) children[index] = fxpNodeToElement(children[index], namespaceScope);
-			element.elements = children;
-		}
-		return element;
-	}
-	return { type: "element" };
-}
-/**
-* Convert the top-level fast-xml-parser preserveOrder array into an
-* XmlElement that matches xml-js's non-compact root structure:
-* `{ elements: [...] }`.
-*/
-function fxpToRootElement(nodes, inheritedNamespaceScope = EMPTY_NAMESPACE_SCOPE) {
-	for (let index = 0; index < nodes.length; index += 1) nodes[index] = fxpNodeToElement(nodes[index], inheritedNamespaceScope);
-	return { elements: nodes };
-}
 /**
 * Common OOXML namespace URIs — re-exported from @stll/docx-utils.
 */
@@ -112,21 +48,21 @@ const NAMESPACES = OOXML_NS;
 */
 const OOXML_NAMESPACE_SCOPE = { bindings: new Map(Object.entries(OOXML_NS)) };
 function parseXml(xml, inheritedNamespaceScope = EMPTY_NAMESPACE_SCOPE) {
-	const streamed = parseStreamingXml(xml, inheritedNamespaceScope);
-	return streamed.status === "parsed" ? streamed.value : parseXmlWithFastXmlParser(xml, inheritedNamespaceScope);
-}
-/**
-* The general-purpose reader {@link parseXml} falls back to, and the reference
-* the streaming reader's equivalence tests compare against.
-*/
-function parseXmlWithFastXmlParser(xml, inheritedNamespaceScope = EMPTY_NAMESPACE_SCOPE) {
-	return fxpToRootElement((xml.includes("binData") ? fxpParserWithStopNodes : fxpParser).parse(xml), inheritedNamespaceScope);
+	const read = readXml(xml, {
+		conformance: "tolerant",
+		inheritedNamespaceScope
+	});
+	if (read.status === "rejected") throw new XmlReadError({
+		message: `XML part could not be read: ${read.reason}`,
+		reason: read.reason
+	});
+	return read.value;
 }
 /**
 * Serialize an XmlElement back to an XML string.
 *
-* Written here rather than handed to `fast-xml-parser`'s builder for two
-* reasons. The builder writes a tab or a newline inside an attribute value
+* Written here rather than handed to a general-purpose XML builder (the one
+* folio used before) for two reasons. The builder writes a tab or a newline inside an attribute value
 * literally, and XML 1.0 §3.3.3 has every conformant reader normalise those to
 * a space: a `descr="two lines&#xA;"` a source file wrote came back as
 * `descr="two lines "`. `escapeXmlAttribute` writes the character references
@@ -853,4 +789,4 @@ function cloneElement(element, overrides) {
 	attachXmlNamespaceContext(clone, element.namespaceScope);
 	return clone;
 }
-export { NAMESPACES, OFFICE_RELATIONSHIP_NAMESPACE_URIS, OOXML_NAMESPACE_SCOPE, WORDPROCESSINGML_NAMESPACE_URIS, cloneElement, cloneWithXmlnsDeclarations, collectXmlnsDeclarations, elementToXml, findAllDeep, findAttributeByNamespaceUri, findByFullName, findChild, findChildByLocalName, findChildByNamespaceUri, findChildren, findChildrenByLocalName, findChildrenByNamespaceUri, findDeep, findWordprocessingChild, getAttribute, getAttributeAny, getAttributeAnyPrefix, getAttributeByNamespaceUri, getAttributes, getChildElements, getLocalName, getNamespacePrefix, getNamespaceUri, getTextContent, hasChild, matchesName, mergeXmlnsDeclarations, parseBooleanElement, parseColorElement, parseNumberingLevelAttribute, parseNumericAttribute, parseOnOffAttribute, parseOnOffChild, parseOnOffValue, parseTableMeasurementValue, parseXml, parseXmlDocument, parseXmlWithFastXmlParser, resolveAttributeNamespaceUri, selectAlternateContentBranch };
+export { NAMESPACES, OFFICE_RELATIONSHIP_NAMESPACE_URIS, OOXML_NAMESPACE_SCOPE, WORDPROCESSINGML_NAMESPACE_URIS, cloneElement, cloneWithXmlnsDeclarations, collectXmlnsDeclarations, elementToXml, findAllDeep, findAttributeByNamespaceUri, findByFullName, findChild, findChildByLocalName, findChildByNamespaceUri, findChildren, findChildrenByLocalName, findChildrenByNamespaceUri, findDeep, findWordprocessingChild, getAttribute, getAttributeAny, getAttributeAnyPrefix, getAttributeByNamespaceUri, getAttributes, getChildElements, getLocalName, getNamespacePrefix, getNamespaceUri, getTextContent, hasChild, matchesName, mergeXmlnsDeclarations, parseBooleanElement, parseColorElement, parseNumberingLevelAttribute, parseNumericAttribute, parseOnOffAttribute, parseOnOffChild, parseOnOffValue, parseTableMeasurementValue, parseXml, parseXmlDocument, resolveAttributeNamespaceUri, selectAlternateContentBranch };

package/dist/docx/xmlSafety.js

@@ -1,4 +1,4 @@
-import { XMLValidator } from "fast-xml-parser";
+import { wellFormedXmlIssue } from "@stll/docx-core/xml";
 // src/docx/xmlSafety.ts
 const DOCTYPE_PATTERN = /<!DOCTYPE(?:\s|>)/iu;
 const BUILT_IN_ENTITIES = /* @__PURE__ */ new Set([
@@ -75,9 +75,9 @@ const scanName = (xml, start) => {
 	} : null;
 };
 /**
-* Reject lexical forms that fast-xml-parser's permissive validator repairs.
-* This is deliberately a small XML lexer, not a second tree parser: structural
-* nesting remains XMLValidator's job.
+* Reject lexical forms with a DOCX-specific verdict before the reader's
+* well-formedness check. This is deliberately a small XML lexer, not a second
+* tree parser: structural nesting remains the reader's job.
 */
 const hasInvalidXmlLexicalForm = (xml) => {
 	if (!containsOnlyXmlCharacters(xml)) return true;
@@ -160,6 +160,6 @@ const getDocxXmlSafetyIssue = (xml) => {
 	if (DOCTYPE_PATTERN.test(xml)) return "doctype-forbidden";
 	if (hasForbiddenEntity(xml)) return "entity-forbidden";
 	if (hasInvalidXmlLexicalForm(xml)) return "not-well-formed";
-	return XMLValidator.validate(xml) === true ? null : "not-well-formed";
+	return wellFormedXmlIssue(xml) === null ? null : "not-well-formed";
 };
 export { getDocxXmlSafetyIssue };

package/dist/layout-painter/renderPage.js

@@ -1124,7 +1124,8 @@ function renderPage(page, context, options = {}) {
 		}
 		if (shouldClipHeader) {
 			headerEl.style.maxHeight = `${availableHeaderHeight}px`;
-			headerEl.style.overflow = "clip";
+			headerEl.style.overflowX = "visible";
+			headerEl.style.overflowY = "clip";
 			headerEl.style.overflowClipMargin = `${HEADER_FOOTER_RULE_CLIP_MARGIN}px`;
 		}
 		pageEl.append(headerEl);
@@ -1177,7 +1178,8 @@ function renderPage(page, context, options = {}) {
 		}
 		if (shouldClipFooter) {
 			footerEl.style.maxHeight = `${availableFooterHeight}px`;
-			footerEl.style.overflow = "clip";
+			footerEl.style.overflowX = "visible";
+			footerEl.style.overflowY = "clip";
 			footerEl.style.overflowClipMargin = `${HEADER_FOOTER_RULE_CLIP_MARGIN}px`;
 		}
 		pageEl.append(footerEl);