@stll/folio-core 0.60.0 → 0.61.0

package/dist/docx/commentTextParagraph.js

@@ -0,0 +1,15 @@
+//#region src/docx/commentTextParagraph.ts
+/** Plain comment text has no authored paragraph formatting. */
+const commentTextParagraph = (text) => ({
+	type: "paragraph",
+	content: [{
+		type: "run",
+		formatting: {},
+		content: [{
+			type: "text",
+			text
+		}]
+	}]
+});
+//#endregion
+export { commentTextParagraph };

package/dist/docx/conformance.js

@@ -1,3 +1,4 @@
+import { sliceText } from "../utils/sliceText.js";
 import { getLocalName, getNamespacePrefix, parseXmlDocument } from "./xmlParser.js";
 import { DOCX_CONFORMANCE_CLASSES } from "@stll/docx-core/model";
 //#region src/docx/conformance.ts
@@ -62,7 +63,11 @@ function scanRootStartTag(scanTarget) {
 }
 const detectDocxConformanceClass = (documentXml) => {
 	if (documentXml === null) return DOCX_CONFORMANCE_CLASSES.UNKNOWN;
-	const rootStartTag = scanRootStartTag(documentXml.length <= ROOT_START_TAG_SCAN_LIMIT ? documentXml : documentXml.slice(0, ROOT_START_TAG_SCAN_LIMIT));
+	const rootStartTag = scanRootStartTag(documentXml.length <= ROOT_START_TAG_SCAN_LIMIT ? documentXml : sliceText({
+		text: documentXml,
+		units: "codeUnits",
+		end: ROOT_START_TAG_SCAN_LIMIT
+	}));
 	const root = (rootStartTag === void 0 ? null : parseXmlDocument(rootStartTag.endsWith("/>") ? rootStartTag : `${rootStartTag.slice(0, -1)}/>`)) ?? parseXmlDocument(documentXml);
 	return detectDocxConformanceClassFromRoot(root);
 };

package/dist/docx/diagramPreview.js

@@ -1,3 +1,4 @@
+import { decodeText } from "../utils/textEncoding.js";
 import { resolveRelationshipIdOfType, resolveRelativePath } from "./relsParser.js";
 import { OFFICE_RELATIONSHIP_NAMESPACE_URIS, findChildByNamespaceUri, getAttribute, getAttributeByNamespaceUri, getLocalName, parseNumericAttribute, parseXmlDocument } from "./xmlParser.js";
 //#region src/docx/diagramPreview.ts
@@ -31,7 +32,7 @@ const partByRelationshipId = ({ rels, media, rId, type, cache }) => {
 	const cached = cache.get(path);
 	if (cached !== void 0) return cached;
 	const file = media.get(path);
-	const parsed = file?.data ? parseXmlDocument(new TextDecoder().decode(file.data)) : null;
+	const parsed = file?.data ? parseXmlDocument(decodeText(new Uint8Array(file.data))) : null;
 	cache.set(path, parsed);
 	return parsed;
 };

package/dist/docx/documentParser.d.ts

@@ -19,6 +19,18 @@ declare function extractTemplateVariables(text: string): string[];
  * @returns Array of unique variable names
  */
 declare function extractAllTemplateVariables(content: document_d_exports.BlockContent[]): string[];
+/**
+ * Build sections from content based on section properties in paragraphs
+ *
+ * In OOXML, sections are delimited by:
+ * 1. w:pPr/w:sectPr within a paragraph (marks end of a section)
+ * 2. w:body/w:sectPr (final section properties)
+ *
+ * @param content - All block content
+ * @param finalSectPr - Final section properties from body
+ * @returns Array of sections
+ */
+declare function buildSections(content: document_d_exports.BlockContent[], finalSectPr: document_d_exports.SectionProperties | undefined): document_d_exports.Section[];
 /**
  * Parse document.xml body content
  *
@@ -67,4 +79,4 @@ declare function getSectionCount(body: document_d_exports.DocumentBody): number;
  */
 declare function hasTemplateVariables(body: document_d_exports.DocumentBody): boolean;
 //#endregion
-export { extractAllTemplateVariables, extractTemplateVariables, getAllParagraphs, getAllTables, getParagraphCount, getSectionCount, hasTemplateVariables, parseDocumentBody, parseDocumentBodyTree };
+export { buildSections, extractAllTemplateVariables, extractTemplateVariables, getAllParagraphs, getAllTables, getParagraphCount, getSectionCount, hasTemplateVariables, parseDocumentBody, parseDocumentBodyTree };

package/dist/docx/documentParser.js

@@ -257,4 +257,4 @@ function hasTemplateVariables(body) {
 	return extractAllTemplateVariables(body.content).length > 0;
 }
 //#endregion
-export { extractAllTemplateVariables, extractTemplateVariables, getAllParagraphs, getAllTables, getParagraphCount, getSectionCount, hasTemplateVariables, parseDocumentBody, parseDocumentBodyTree };
+export { buildSections, extractAllTemplateVariables, extractTemplateVariables, getAllParagraphs, getAllTables, getParagraphCount, getSectionCount, hasTemplateVariables, parseDocumentBody, parseDocumentBodyTree };

package/dist/docx/encryption/compoundFile.d.ts

@@ -1,12 +1,4 @@
 //#region src/docx/encryption/compoundFile.d.ts
-/**
- * Read-only MS-CFB compound file access for encrypted OOXML packages.
- *
- * Encrypted `.docx` files store `EncryptionInfo` and `EncryptedPackage` streams
- * at the compound-file root. This reader implements only what MS-OFFCRYPTO needs.
- *
- * @see https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-cfb/
- */
 type CompoundFileReader = {
   readStream: (absolutePath: string) => Uint8Array | null;
 };

package/dist/docx/encryption/compoundFile.js

@@ -1,3 +1,4 @@
+import { decodeText } from "../../utils/textEncoding.js";
 import { joinBytes } from "./cryptoBytes.js";
 //#region src/docx/encryption/compoundFile.ts
 /**
@@ -39,7 +40,7 @@ const u64 = (view, offset) => {
 	return BigInt(view.getUint32(offset + 4, true)) << 32n | low;
 };
 const decodeName = (nameBytes) => {
-	const decoded = new TextDecoder("utf-16le").decode(nameBytes);
+	const decoded = decodeText(nameBytes, { encoding: "utf-16le" });
 	let end = decoded.length;
 	while (end > 0 && decoded.charCodeAt(end - 1) === 0) end--;
 	return decoded.slice(0, end);

package/dist/docx/encryption/cryptoBytes.d.ts

@@ -2,10 +2,10 @@
 /** Byte helpers shared by MS-CFB and MS-OFFCRYPTO agile decryption. */
 declare const joinBytes: (parts: readonly Uint8Array[]) => Uint8Array;
 declare const writeUint32Le: (value: number) => Uint8Array;
-declare const passwordToUtf16Le: (password: string) => Uint8Array;
+declare const passwordToUtf16Le: (text: string) => Uint8Array<ArrayBuffer>;
 declare const bytesEqual: (left: Uint8Array, right: Uint8Array) => boolean;
 declare const toArrayBuffer: (bytes: Uint8Array) => ArrayBuffer;
-declare const decodeBase64: (encoded: string) => Uint8Array;
+declare const decodeBase64: (text: string) => Uint8Array<ArrayBuffer>;
 declare const padToBlock: (bytes: Uint8Array, blockSize: number, padByte?: number) => Uint8Array;
 //#endregion
 export { bytesEqual, decodeBase64, joinBytes, padToBlock, passwordToUtf16Le, toArrayBuffer, writeUint32Le };

package/dist/docx/encryption/cryptoBytes.js

@@ -1,3 +1,4 @@
+import { base64ToBytes, encodeUtf16LE } from "../../utils/textEncoding.js";
 //#region src/docx/encryption/cryptoBytes.ts
 /** Byte helpers shared by MS-CFB and MS-OFFCRYPTO agile decryption. */
 const joinBytes = (parts) => {
@@ -19,15 +20,7 @@ const writeUint32Le = (value) => {
 	out[3] = value >>> 24 & 255;
 	return out;
 };
-const passwordToUtf16Le = (password) => {
-	const out = new Uint8Array(password.length * 2);
-	for (let i = 0; i < password.length; i++) {
-		const code = password.charCodeAt(i);
-		out[i * 2] = code & 255;
-		out[i * 2 + 1] = code >> 8;
-	}
-	return out;
-};
+const passwordToUtf16Le = encodeUtf16LE;
 const bytesEqual = (left, right) => {
 	if (left.length !== right.length) return false;
 	let mismatch = 0;
@@ -38,15 +31,7 @@ const toArrayBuffer = (bytes) => {
 	if (bytes.buffer instanceof ArrayBuffer && bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength) return bytes.buffer;
 	return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
 };
-const decodeBase64 = (encoded) => {
-	if (typeof atob === "function") {
-		const binary = atob(encoded);
-		const out = new Uint8Array(binary.length);
-		for (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i);
-		return out;
-	}
-	return new Uint8Array(Buffer.from(encoded, "base64"));
-};
+const decodeBase64 = base64ToBytes;
 const padToBlock = (bytes, blockSize, padByte = 54) => {
 	if (bytes.length >= blockSize) return bytes.subarray(0, blockSize);
 	const out = new Uint8Array(blockSize);

package/dist/docx/encryption/encryptionInfo.d.ts

@@ -1,9 +1,4 @@
 //#region src/docx/encryption/encryptionInfo.d.ts
-/**
- * Parse the EncryptionInfo stream for Agile Encryption (Office 2010+).
- *
- * @see https://learn.microsoft.com/en-us/openspecs/office_file_formats/ms-offcrypto/87020a34-e73f-4139-99bc-bbdf6cf6fa55
- */
 type AgileKeyMaterial = {
   packageSalt: Uint8Array;
   packageKeyBits: number;

package/dist/docx/encryption/encryptionInfo.js

@@ -1,3 +1,4 @@
+import { decodeText } from "../../utils/textEncoding.js";
 import { decodeBase64 } from "./cryptoBytes.js";
 import { DOCX_ENCRYPTION_ERROR_CODES, DocxEncryptionError } from "./errors.js";
 //#region src/docx/encryption/encryptionInfo.ts
@@ -85,7 +86,7 @@ const requireSpinCount = (attrs, element) => {
 	return spinCount;
 };
 const parseAgileXml = (xmlBytes) => {
-	const xml = new TextDecoder("utf-8").decode(xmlBytes);
+	const xml = decodeText(xmlBytes, { encoding: "utf-8" });
 	const keyDataTag = findElement(xml, "keyData");
 	const integrityTag = findElement(xml, "dataIntegrity");
 	const encryptedKeyTag = findElement(xml, "encryptedKey");

package/dist/docx/ensureParaIds.js

@@ -1,4 +1,5 @@
 import { deterministicHexId } from "../utils/hexId.js";
+import { encodeUtf8 } from "../utils/textEncoding.js";
 import { resolvePackageRelationshipTarget } from "./packageParts.js";
 import { spliceXml } from "./selectiveXmlPatch.js";
 import { loadDocxArchive } from "./server/boundedArchive.js";
@@ -390,7 +391,7 @@ const ensureParaIdsInternal = async (docx, options) => {
 		writeZipPart({
 			zip,
 			path: partPath,
-			data: content,
+			data: encodeUtf8(content),
 			options: {
 				compression: "DEFLATE",
 				compressionOptions: { level: 6 },

package/dist/docx/groupDrawingParser.js

@@ -1,3 +1,4 @@
+import { sliceText } from "../utils/sliceText.js";
 import { emuToPixels } from "../utils/units.js";
 import { collectGroupTextBoxes, readTransform } from "./drawingGroupChildren.js";
 import { parseImage, resolveImageData } from "./imageParser.js";
@@ -142,7 +143,11 @@ const renderTextBox = (wsp, unitScale) => {
 	const color = colorFrom(findAllDeep(wsp, "w", "color").at(0) ?? null, DEFAULT_TEXT_COLOR);
 	const fontSize = halfPoints * HALF_POINT_TO_EMU / unitScale;
 	const maxCharacters = Math.max(1, Math.floor(width / (fontSize * .38)));
-	const lines = paragraphs.flatMap((paragraph) => wrapLine(getTextContent(paragraph).slice(0, MAX_TEXT_CHARACTERS), maxCharacters)).map(escapeXmlText);
+	const lines = paragraphs.flatMap((paragraph) => wrapLine(sliceText({
+		text: getTextContent(paragraph),
+		units: "codeUnits",
+		end: MAX_TEXT_CHARACTERS
+	}), maxCharacters)).map(escapeXmlText);
 	if (lines.length === 0) return "";
 	const lineHeight = fontSize * 1.15;
 	const svgFontSize = 1e3;

package/dist/docx/listModelNormalization.d.ts

@@ -0,0 +1,10 @@
+import { document_d_exports } from "../types/document.js";
+import { DocumentOp } from "@stll/docx-core/ops";
+//#region src/docx/listModelNormalization.d.ts
+type CanonicalListNormalization = {
+  document: document_d_exports.Document;
+  inverse: DocumentOp[];
+};
+declare const normalizeListModelRendering: (document: document_d_exports.Document) => CanonicalListNormalization;
+//#endregion
+export { normalizeListModelRendering };

package/dist/docx/listModelNormalization.js

@@ -0,0 +1,166 @@
+import { effectiveParagraphNumberingReference, paragraphNumberingSourcesFromBoundary } from "../prosemirror/numberingAttr.js";
+import { paragraphIndentationFromFormatting } from "../prosemirror/paragraphIndentation.js";
+import { listIndentationProvenancePatch } from "../prosemirror/styles/resolvedStyleAttrs.js";
+import { createStyleResolver } from "../prosemirror/styles/styleResolver.js";
+import { canonicalJson } from "../utils/canonicalJson.js";
+import { foldListNumberFields, planParagraphListNumberFold, unfoldedListNumberContent } from "./foldedListNumberFields.js";
+import { computeListMarker } from "./listMarkerComputation.js";
+import { listRenderingDefinitionsMatch } from "./listRendering.js";
+import { computeListRendering, getCachedNumberingMap } from "./numberingParser.js";
+import { assignParagraphIndentationProjection, cloneParagraphWithPropertySource, paragraphFormattingWithAuthoredIndentation, sameParagraphIndentationProjection } from "./paragraphPropertySource.js";
+import { panic } from "better-result";
+import { DOCUMENT_OP_TYPES, EMPTY_PROPERTY_SETS, OP_STORIES, registerParagraphPropertySnapshot, withBodyContent } from "@stll/docx-core/ops";
+//#region src/docx/listModelNormalization.ts
+/** Canonical edits retain authored fields; list rendering follows the current numbering. */
+const normalizeListModelRendering = (document) => {
+	const inverse = [];
+	const styles = createStyleResolver(document.package.styles);
+	const numbering = document.package.numbering === void 0 ? null : getCachedNumberingMap(document.package.numbering);
+	const normalizeBody = (body, story) => {
+		const counters = {
+			numbering,
+			listCounters: /* @__PURE__ */ new Map(),
+			abstractCounters: /* @__PURE__ */ new Map(),
+			restartedNumIds: /* @__PURE__ */ new Set(),
+			previousList: {
+				abstractNumId: null,
+				fromStyle: false,
+				numId: null
+			}
+		};
+		const content = body.content.map((paragraph) => {
+			if (paragraph.type !== "paragraph") return paragraph;
+			registerParagraphPropertySnapshot({
+				paragraph,
+				snapshot: paragraphFormattingWithAuthoredIndentation(paragraph)
+			});
+			const formatting = paragraph.formatting;
+			const next = cloneParagraphWithPropertySource(paragraph, {});
+			const styleNumbering = formatting?.styleId ? styles.resolveParagraphStyle(formatting.styleId).paragraphFormatting?.numPr : void 0;
+			if (styleNumbering !== void 0 && (formatting?.numPr === void 0 || formatting.numPr.kind === "levelOnly")) next.formatting = {
+				...formatting,
+				numPrFromStyle: styleNumbering
+			};
+			if (formatting?.numPrFromStyle !== void 0 && (formatting.styleId !== void 0 && styleNumbering === void 0 || formatting.numPr?.kind === "reference" || formatting.numPr?.kind === "none")) {
+				next.formatting = { ...formatting };
+				delete next.formatting.numPrFromStyle;
+			}
+			if (canonicalJson(next.formatting?.numPrFromStyle) !== canonicalJson(formatting?.numPrFromStyle)) inverse.unshift({
+				type: DOCUMENT_OP_TYPES.SET_PARAGRAPH_PROPS,
+				story,
+				blockId: paragraph.paraId ?? panic("List normalization requires paragraph identities."),
+				patch: { numPrFromStyle: formatting?.numPrFromStyle ?? null },
+				whenEmpty: formatting === void 0 ? EMPTY_PROPERTY_SETS.OMIT : EMPTY_PROPERTY_SETS.KEEP
+			});
+			const numPr = effectiveParagraphNumberingReference(paragraphNumberingSourcesFromBoundary({
+				numPr: next.formatting?.numPr,
+				numPrFromStyle: next.formatting?.numPrFromStyle
+			}));
+			if (paragraph.listRendering === void 0 && formatting?.numPrFromStyle === void 0 && next.formatting?.numPrFromStyle === void 0 && (numPr?.kind !== "reference" || numbering === null)) {
+				computeListMarker(paragraph, counters);
+				return paragraph;
+			}
+			const definition = numPr?.kind === "reference" && numbering !== null ? computeListRendering(numPr, numbering) : null;
+			const cached = paragraph.listRendering;
+			const rendering = definition !== null && cached !== void 0 && listRenderingDefinitionsMatch(cached, definition) ? { ...cached } : definition;
+			const authoredFormatting = paragraphFormattingWithAuthoredIndentation(next);
+			assignParagraphIndentationProjection({
+				paragraph: next,
+				authored: authoredFormatting,
+				inherited: paragraphIndentationFromFormatting(listIndentationProvenancePatch({
+					direct: paragraphIndentationFromFormatting(authoredFormatting),
+					styleFormatting: styles.resolveParagraphStyle(next.formatting?.styleId).paragraphFormatting,
+					numberingSource: next.formatting?.numPr?.kind === "reference" || next.formatting?.numPrFromStyle === void 0 ? "paragraph" : "style",
+					numPr: numPr?.kind === "reference" ? {
+						numId: numPr.numId,
+						ilvl: numPr.ilvl ?? 0
+					} : void 0,
+					numbering
+				})._resolvedFormatting) ?? {}
+			});
+			if (canonicalJson(paragraphIndentationFromFormatting(next.formatting)) !== canonicalJson(paragraphIndentationFromFormatting(formatting))) inverse.unshift({
+				type: DOCUMENT_OP_TYPES.SET_PARAGRAPH_PROPS,
+				story,
+				blockId: paragraph.paraId ?? panic("Canonical numbering normalization requires paragraph identities."),
+				patch: {
+					indentLeft: formatting?.indentLeft ?? null,
+					indentRight: formatting?.indentRight ?? null,
+					indentFirstLine: formatting?.indentFirstLine ?? null,
+					hangingIndent: formatting?.hangingIndent ?? null
+				},
+				whenEmpty: formatting === void 0 ? EMPTY_PROPERTY_SETS.OMIT : EMPTY_PROPERTY_SETS.KEEP
+			});
+			if (rendering === null) delete next.listRendering;
+			else {
+				const fields = foldListNumberFields(paragraph.content.map(unfoldedListNumberContent), () => void 0).fieldCount;
+				if (fields === 0) delete rendering.implicitChildLevelAdvances;
+				else rendering.implicitChildLevelAdvances = fields;
+				const template = rendering.markerTemplate ?? rendering.marker;
+				const fold = planParagraphListNumberFold(paragraph.content, !rendering.isBullet && template !== "" && !template.includes("	"));
+				if (fold.suffix === void 0) delete rendering.foldedMarkerSuffix;
+				else rendering.foldedMarkerSuffix = fold.suffix;
+				const child = numbering?.getLevel(rendering.numId, rendering.level + 1)?.pPr;
+				if (fold.suffix !== void 0 && child?.hangingIndent === true && child.indentFirstLine !== void 0 && child.indentFirstLine < 0) rendering.markerSecondSlotOffsetTwips = -child.indentFirstLine;
+				else delete rendering.markerSecondSlotOffsetTwips;
+				rendering.marker = rendering.foldedMarkerSuffix !== void 0 && !template.includes("	") ? `${template}\t${rendering.foldedMarkerSuffix}` : template;
+				next.listRendering = rendering;
+			}
+			computeListMarker(next, counters);
+			registerParagraphPropertySnapshot({
+				paragraph: next,
+				snapshot: authoredFormatting
+			});
+			if (sameParagraphIndentationProjection({
+				left: next,
+				right: paragraph
+			}) && canonicalJson(next.formatting) === canonicalJson(formatting) && canonicalJson(next.listRendering) === canonicalJson(cached)) return paragraph;
+			return next;
+		});
+		return content.every((paragraph, index) => paragraph === body.content[index]) ? body : {
+			...body,
+			...withBodyContent(body, content)
+		};
+	};
+	const pkg = document.package;
+	const body = normalizeBody(pkg.document, OP_STORIES.MAIN);
+	const normalizeParts = (parts, kind) => {
+		if (parts === void 0) return parts;
+		const normalized = new Map([...parts].map(([id, part]) => [id, normalizeBody(part, {
+			kind,
+			rId: id
+		})]));
+		return [...normalized].every(([id, part]) => part === parts.get(id)) ? parts : normalized;
+	};
+	const normalizeNotes = (notes, kind) => {
+		if (notes === void 0) return notes;
+		const normalized = notes.map((note) => normalizeBody(note, {
+			kind,
+			id: note.id
+		}));
+		return normalized.every((note, index) => note === notes[index]) ? notes : normalized;
+	};
+	const headers = normalizeParts(pkg.headers, "header");
+	const footers = normalizeParts(pkg.footers, "footer");
+	const footnotes = normalizeNotes(pkg.footnotes, "footnote");
+	const endnotes = normalizeNotes(pkg.endnotes, "endnote");
+	if (body === pkg.document && headers === pkg.headers && footers === pkg.footers && footnotes === pkg.footnotes && endnotes === pkg.endnotes) return {
+		document,
+		inverse
+	};
+	return {
+		inverse,
+		document: {
+			...document,
+			package: {
+				...pkg,
+				document: body,
+				...headers === void 0 ? {} : { headers },
+				...footers === void 0 ? {} : { footers },
+				...footnotes === void 0 ? {} : { footnotes },
+				...endnotes === void 0 ? {} : { endnotes }
+			}
+		}
+	};
+};
+//#endregion
+export { normalizeListModelRendering };

package/dist/docx/metadataPrivacy.js

@@ -1,3 +1,4 @@
+import { decodeText, encodeUtf8 } from "../utils/textEncoding.js";
 import { countCentralDirectoryRecords, createInflationBudget, inflateEntryWithinLimits } from "./archiveInflation.js";
 import { elementToXml, getLocalName, parseXmlDocument } from "./xmlParser.js";
 import { TaggedError } from "better-result";
@@ -131,7 +132,7 @@ const readCoreProperties = async (entry) => {
 		message: "Document privacy core properties exceeded the part-size limit",
 		reason: "core-properties-too-large"
 	});
-	return new TextDecoder("utf-8", { ignoreBOM: true }).decode(result.bytes);
+	return decodeText(result.bytes, { ignoreBOM: true });
 };
 /** Rewrite selected package metadata fields without changing other package parts. */
 const rewriteDocxMetadataPrivacy = async (buffer, { transforms }) => {
@@ -156,7 +157,7 @@ const rewriteDocxMetadataPrivacy = async (buffer, { transforms }) => {
 	writeZipPart({
 		zip,
 		path: coreProperties.name,
-		data: rewritten.xml
+		data: encodeUtf8(rewritten.xml)
 	});
 	return {
 		buffer: await zip.generateAsync({

package/dist/docx/metafileRaster.js

@@ -1,3 +1,4 @@
+import { decodeText } from "../utils/textEncoding.js";
 //#region src/docx/metafileRaster.ts
 function indexOfBytes(haystack, needle, from = 0) {
 	outer: for (let i = from; i + needle.length <= haystack.length; i++) {
@@ -25,7 +26,7 @@ function extractPng(bytes) {
 		const b2 = bytes[off + 2];
 		const b3 = bytes[off + 3];
 		const len = b0 << 24 | b1 << 16 | b2 << 8 | b3;
-		const type = String.fromCharCode(bytes[off + 4], bytes[off + 5], bytes[off + 6], bytes[off + 7]);
+		const type = decodeText(bytes.subarray(off + 4, off + 8), { encoding: "binary" });
 		const next = off + 12 + (len >>> 0);
 		if (type === "IEND") return bytes.slice(start, off + 12);
 		if (next <= off || next > bytes.length) break;

package/dist/docx/packageParts.js

@@ -1,3 +1,4 @@
+import { decodeText, encodeUtf8 } from "../utils/textEncoding.js";
 import { Result } from "better-result";
 import { writeZipPart } from "@stll/docx-core/zip";
 //#region src/docx/packageParts.ts
@@ -124,7 +125,7 @@ const readRelationshipParts = async (zip) => {
 		if (file.dir || !normalizePartPath(path).endsWith(".rels")) continue;
 		parts.push({
 			path,
-			xml: await file.async("text")
+			xml: await file.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }))
 		});
 	}
 	return parts;
@@ -133,7 +134,7 @@ const writePart = ({ zip, path, xml, compressionLevel }) => {
 	writeZipPart({
 		zip,
 		path,
-		data: xml,
+		data: encodeUtf8(xml),
 		options: {
 			compression: "DEFLATE",
 			compressionOptions: { level: compressionLevel }
@@ -186,7 +187,7 @@ const reconcilePackageReferences = async (zip, compressionLevel) => {
 		if (!file) continue;
 		const idPattern = [...ids].map((id) => escapeRegExp(id)).join("|");
 		const referencePattern = new RegExp(`\\s+r:[A-Za-z]+\\s*=\\s*(?<quote>["'])(?<id>${idPattern})\\k<quote>`, "gu");
-		const xml = await file.async("text");
+		const xml = await file.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 		const removedIds = /* @__PURE__ */ new Set();
 		const scrubbed = xml.replaceAll(referencePattern, (...args) => {
 			const groups = args.at(-1);
@@ -206,7 +207,7 @@ const reconcilePackageReferences = async (zip, compressionLevel) => {
 	const contentTypes = zip.file(CONTENT_TYPES_PATTERN)[0];
 	if (!contentTypes) return repair;
 	let droppedOverride = false;
-	const prunedContentTypes = (await contentTypes.async("text")).replaceAll(CONTENT_TYPE_ELEMENT, (element) => {
+	const prunedContentTypes = (await contentTypes.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }))).replaceAll(CONTENT_TYPE_ELEMENT, (element) => {
 		const partName = PART_NAME_ATTRIBUTE.exec(element)?.groups?.["value"];
 		if (partName === void 0 || isPresent(present, partName)) return element;
 		repair.danglingOverrides.push(normalizePartPath(decodePartName(partName) ?? partName));
@@ -256,7 +257,7 @@ const checkPackageIntegrity = async (zip) => {
 	}
 	for (const [path, file] of Object.entries(zip.files)) {
 		if (file.dir || !normalizePartPath(path).endsWith(".xml")) continue;
-		const xml = await file.async("text");
+		const xml = await file.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 		const ids = idsByOwningPart.get(path);
 		for (const match of xml.matchAll(REFERENCE_ATTRIBUTE)) {
 			const id = match.groups?.["id"];

package/dist/docx/paragraphParser.js

@@ -52,16 +52,18 @@ function extractMathText(el) {
 * Capture the authored paragraph properties separately from structural and
 * revision children, which have their own model fields and lifecycles.
 */
-const captureParagraphPropertySource = (pPr) => captureVerbatimXml(cloneElement(pPr, { elements: (pPr.elements ?? []).flatMap((child) => {
+const captureParagraphPropertySource = (pPr, paragraph) => captureVerbatimXml(cloneElement(pPr, { elements: (pPr.elements ?? []).flatMap((child) => {
 	if (child.type !== "element") return [child];
 	const localName = getLocalName(child.name);
 	if (WORDPROCESSINGML_NAMESPACE_URIS.has(child.namespaceUri ?? "") && (localName === "sectPr" || localName === "pPrChange")) return [];
 	if (localName !== "rPr" || !WORDPROCESSINGML_NAMESPACE_URIS.has(child.namespaceUri ?? "")) return [child];
-	return [cloneElement(child, { elements: (child.elements ?? []).filter((runProperty) => {
+	const elements = (child.elements ?? []).filter((runProperty) => {
 		if (runProperty.type !== "element") return true;
 		const runPropertyName = getLocalName(runProperty.name);
 		return !WORDPROCESSINGML_NAMESPACE_URIS.has(runProperty.namespaceUri ?? "") || !PARAGRAPH_MARK_CHANGE_KINDS.some((kind) => kind === runPropertyName);
-	}) })];
+	});
+	if (paragraph.formatting?.runProperties === void 0 && elements.every((element) => element.type === "text" && (element.text === void 0 || typeof element.text === "string" && element.text.trim() === ""))) return [];
+	return [cloneElement(child, { elements })];
 }) }));
 const RENDERED_BREAK_INLINE_WRAPPERS = /* @__PURE__ */ new Set([
 	"hyperlink",
@@ -1328,7 +1330,7 @@ function parseParagraph(node, styles, theme, numbering, rels = null, media = nul
 			}
 		}
 	}
-	if (pPr) assignParagraphPropertySource(paragraph, captureParagraphPropertySource(pPr));
+	if (pPr) assignParagraphPropertySource(paragraph, captureParagraphPropertySource(pPr, paragraph));
 	return paragraph;
 }
 /**

package/dist/docx/parser.js

@@ -1,5 +1,6 @@
 import { toArrayBuffer } from "../utils/docxInput.js";
 import { loadFontsWithMapping } from "../utils/fontLoader.js";
+import { decodeText, encodeUtf8 } from "../utils/textEncoding.js";
 import { MAX_PACKAGE_TIFF_PIXELS, convertTiffToPngDataUrl, isTiffMimeType } from "../utils/tiffConverter.js";
 import { ALT_CHUNK_PLAIN_TEXT_LIMIT_BYTES, getAltChunkRelationshipId, isAltChunkMarkup } from "./altChunk.js";
 import { normalizeBookmarkIdsInXmlParts } from "./bookmarkIdNormalization.js";
@@ -122,7 +123,7 @@ const extractAltChunkPlainText = async (xml, context) => {
 	if (bytes.byteLength > context.budget.remainingBytes) return;
 	context.budget.remainingBytes -= bytes.byteLength;
 	try {
-		return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+		return decodeText(bytes, { fatal: true });
 	} catch {
 		return;
 	}
@@ -560,7 +561,7 @@ async function buildMediaMap(raw, rels) {
 		}
 		const emfSvg = isReferenced && mimeType === EMF_MIME_TYPE && remainingEmfPreviewBytes > 0 ? renderEmfSvg(data) : null;
 		if (emfSvg) {
-			const svgBytes = new TextEncoder().encode(emfSvg);
+			const svgBytes = encodeUtf8(emfSvg);
 			if (svgBytes.byteLength <= remainingEmfPreviewBytes) {
 				remainingEmfPreviewBytes -= svgBytes.byteLength;
 				const mediaFile = {
@@ -589,8 +590,8 @@ async function buildMediaMap(raw, rels) {
 		if (normalizedPath !== path) media.set(normalizedPath, mediaFile);
 	}
 	for (const [path, xml] of raw.allXml.entries()) {
-		if (!/^word\/diagrams\/[^/]+\.xml$/iu.test(path) || new TextEncoder().encode(xml).byteLength > FOLIO_XML_RESOURCE_LIMITS.maxBytes) continue;
-		const data = new TextEncoder().encode(xml).buffer;
+		if (!/^word\/diagrams\/[^/]+\.xml$/iu.test(path) || encodeUtf8(xml).byteLength > FOLIO_XML_RESOURCE_LIMITS.maxBytes) continue;
+		const data = encodeUtf8(xml).buffer;
 		const file = {
 			path,
 			filename: path.split("/").pop() ?? path,

package/dist/docx/preservedRunContent.js

@@ -1,3 +1,4 @@
+import { sliceText } from "../utils/sliceText.js";
 import { captureVerbatimXml } from "./verbatimCapture.js";
 import { findChildrenByLocalName, getChildElements, getLocalName, getTextContent } from "./xmlParser.js";
 //#region src/docx/preservedRunContent.ts
@@ -31,7 +32,11 @@ const preservedRunChildText = (element) => {
 	if (sources === void 0) return "";
 	const parts = [];
 	for (const localName of sources) for (const source of findChildrenByLocalName(element, localName)) collectTextContent(source, parts);
-	return parts.join("").slice(0, MAX_PRESERVED_TEXT_LENGTH);
+	return sliceText({
+		text: parts.join(""),
+		units: "codeUnits",
+		end: MAX_PRESERVED_TEXT_LENGTH
+	});
 };
 /**
 * Capture one unmodelled run child.
@@ -90,7 +95,11 @@ const preserveInlineChild = (element) => {
 	return {
 		type: "preservedInline",
 		xml: captureVerbatimXml(element),
-		text: parts.join("").slice(0, MAX_PRESERVED_TEXT_LENGTH)
+		text: sliceText({
+			text: parts.join(""),
+			units: "codeUnits",
+			end: MAX_PRESERVED_TEXT_LENGTH
+		})
 	};
 };
 //#endregion