@stll/folio-core 0.59.0 → 0.61.0

package/dist/docx/importedIdCollisions.d.ts

@@ -0,0 +1,136 @@
+import { ParseContext } from "./parseContext.js";
+//#region src/docx/importedIdCollisions.d.ts
+/** Definition sites only: paired markers and references never claim an identity. */
+declare const IMPORTED_ID_COLLISION_REGISTRY: {
+  readonly bookmark: {
+    readonly kind: "bookmark";
+    readonly scope: "part";
+    readonly sites: readonly [{
+      readonly namespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+      readonly elements: Set<string>;
+    }];
+    readonly attribute: "id";
+    readonly attributeNamespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+    readonly encoding: "decimal";
+  };
+  readonly comment: {
+    readonly kind: "comment";
+    readonly scope: "part";
+    readonly sites: readonly [{
+      readonly namespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+      readonly elements: Set<string>;
+    }];
+    readonly attribute: "id";
+    readonly attributeNamespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+    readonly encoding: "decimal";
+  };
+  readonly footnote: {
+    readonly kind: "footnote";
+    readonly scope: "part";
+    readonly sites: readonly [{
+      readonly namespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+      readonly elements: Set<string>;
+    }];
+    readonly attribute: "id";
+    readonly attributeNamespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+    readonly encoding: "decimal";
+  };
+  readonly endnote: {
+    readonly kind: "endnote";
+    readonly scope: "part";
+    readonly sites: readonly [{
+      readonly namespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+      readonly elements: Set<string>;
+    }];
+    readonly attribute: "id";
+    readonly attributeNamespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+    readonly encoding: "decimal";
+  };
+  readonly revision: {
+    readonly kind: "revision";
+    readonly scope: "package";
+    readonly sites: readonly [{
+      readonly namespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+      readonly elements: Set<string>;
+    }];
+    readonly attribute: "id";
+    readonly attributeNamespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+    readonly encoding: "decimal";
+  };
+  readonly paraId: {
+    readonly kind: "paraId";
+    readonly scope: "part";
+    readonly sites: readonly [{
+      readonly namespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+      readonly elements: Set<string>;
+    }, {
+      readonly namespace: "http://schemas.microsoft.com/office/word/2012/wordml";
+      readonly elements: Set<string>;
+    }, {
+      readonly namespace: string;
+      readonly elements: Set<string>;
+    }];
+    readonly attribute: "paraId";
+    readonly attributeNamespace: "http://schemas.microsoft.com/office/word/2010/wordml";
+    readonly encoding: "hex";
+  };
+  readonly textId: {
+    readonly kind: "textId";
+    readonly scope: "part";
+    readonly sites: readonly [{
+      readonly namespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+      readonly elements: Set<string>;
+    }];
+    readonly attribute: "textId";
+    readonly attributeNamespace: "http://schemas.microsoft.com/office/word/2010/wordml";
+    readonly encoding: "hex";
+  };
+  readonly numId: {
+    readonly kind: "numId";
+    readonly scope: "part";
+    readonly sites: readonly [{
+      readonly namespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+      readonly elements: Set<string>;
+    }];
+    readonly attribute: "numId";
+    readonly attributeNamespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+    readonly encoding: "decimal";
+  };
+  readonly abstractNumId: {
+    readonly kind: "abstractNumId";
+    readonly scope: "part";
+    readonly sites: readonly [{
+      readonly namespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+      readonly elements: Set<string>;
+    }];
+    readonly attribute: "abstractNumId";
+    readonly attributeNamespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+    readonly encoding: "decimal";
+  };
+  readonly drawing: {
+    readonly kind: "drawing";
+    readonly scope: "package";
+    readonly sites: readonly [{
+      readonly namespace: "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing";
+      readonly elements: Set<string>;
+    }];
+    readonly attribute: "id";
+    readonly attributeNamespace: null;
+    readonly encoding: "decimal";
+  };
+  readonly relationship: {
+    readonly kind: "relationship";
+    readonly scope: "part";
+    readonly sites: readonly [{
+      readonly namespace: "http://schemas.openxmlformats.org/package/2006/relationships";
+      readonly elements: Set<string>;
+    }];
+    readonly attribute: "Id";
+    readonly attributeNamespace: null;
+    readonly encoding: "string";
+  };
+};
+/** Reports repeated source definitions without changing the package or choosing a winner. */
+declare const diagnoseImportedIdCollisions: (parts: ReadonlyMap<string, string>, context: ParseContext) => void;
+//#endregion
+export { IMPORTED_ID_COLLISION_REGISTRY, diagnoseImportedIdCollisions };

package/dist/docx/importedIdCollisions.js

@@ -0,0 +1,215 @@
+import { paraIdAttribute, textIdAttribute } from "./paraIdAttribute.js";
+import { REVISION_ELEMENT_NAMES } from "./revisionIdNormalization.js";
+import { scanSelectedStreamingXmlElements } from "./selectedXmlIdentityScan.js";
+import { OOXML_NAMESPACES } from "./serializer/partNamespaces.js";
+import { toTransitionalNamespaceUri } from "./transitionalSpelling.js";
+import { resolveNamespaceUri } from "./xmlNamespaceContext.js";
+import { NAMESPACES, getLocalName, getNamespaceUri } from "./xmlParser.js";
+import { panic } from "better-result";
+import { IMPORTED_ID_COLLISION_KINDS, PARSE_WARNING_CODES } from "@stll/docx-core/model";
+//#region src/docx/importedIdCollisions.ts
+const WORD_2010_NAMESPACE = "http://schemas.microsoft.com/office/word/2010/wordml";
+const PACKAGE_RELATIONSHIP_NAMESPACE = "http://schemas.openxmlformats.org/package/2006/relationships";
+const paragraphIdentityForKind = (kind, element) => {
+	switch (kind) {
+		case IMPORTED_ID_COLLISION_KINDS.paraId: return paraIdAttribute(element);
+		case IMPORTED_ID_COLLISION_KINDS.textId: return textIdAttribute(element);
+		default: return;
+	}
+};
+/** Definition sites only: paired markers and references never claim an identity. */
+const IMPORTED_ID_COLLISION_REGISTRY = {
+	bookmark: {
+		kind: IMPORTED_ID_COLLISION_KINDS.bookmark,
+		scope: "part",
+		sites: [{
+			namespace: NAMESPACES.w,
+			elements: /* @__PURE__ */ new Set(["bookmarkStart"])
+		}],
+		attribute: "id",
+		attributeNamespace: NAMESPACES.w,
+		encoding: "decimal"
+	},
+	comment: {
+		kind: IMPORTED_ID_COLLISION_KINDS.comment,
+		scope: "part",
+		sites: [{
+			namespace: NAMESPACES.w,
+			elements: /* @__PURE__ */ new Set(["comment"])
+		}],
+		attribute: "id",
+		attributeNamespace: NAMESPACES.w,
+		encoding: "decimal"
+	},
+	footnote: {
+		kind: IMPORTED_ID_COLLISION_KINDS.footnote,
+		scope: "part",
+		sites: [{
+			namespace: NAMESPACES.w,
+			elements: /* @__PURE__ */ new Set(["footnote"])
+		}],
+		attribute: "id",
+		attributeNamespace: NAMESPACES.w,
+		encoding: "decimal"
+	},
+	endnote: {
+		kind: IMPORTED_ID_COLLISION_KINDS.endnote,
+		scope: "part",
+		sites: [{
+			namespace: NAMESPACES.w,
+			elements: /* @__PURE__ */ new Set(["endnote"])
+		}],
+		attribute: "id",
+		attributeNamespace: NAMESPACES.w,
+		encoding: "decimal"
+	},
+	revision: {
+		kind: IMPORTED_ID_COLLISION_KINDS.revision,
+		scope: "package",
+		sites: [{
+			namespace: NAMESPACES.w,
+			elements: REVISION_ELEMENT_NAMES
+		}],
+		attribute: "id",
+		attributeNamespace: NAMESPACES.w,
+		encoding: "decimal"
+	},
+	paraId: {
+		kind: IMPORTED_ID_COLLISION_KINDS.paraId,
+		scope: "part",
+		sites: [
+			{
+				namespace: NAMESPACES.w,
+				elements: /* @__PURE__ */ new Set(["p"])
+			},
+			{
+				namespace: NAMESPACES.w15,
+				elements: /* @__PURE__ */ new Set(["commentEx"])
+			},
+			{
+				namespace: OOXML_NAMESPACES.w16cex.uri,
+				elements: /* @__PURE__ */ new Set(["comment"])
+			}
+		],
+		attribute: "paraId",
+		attributeNamespace: WORD_2010_NAMESPACE,
+		encoding: "hex"
+	},
+	textId: {
+		kind: IMPORTED_ID_COLLISION_KINDS.textId,
+		scope: "part",
+		sites: [{
+			namespace: NAMESPACES.w,
+			elements: /* @__PURE__ */ new Set(["p"])
+		}],
+		attribute: "textId",
+		attributeNamespace: WORD_2010_NAMESPACE,
+		encoding: "hex"
+	},
+	numId: {
+		kind: IMPORTED_ID_COLLISION_KINDS.numId,
+		scope: "part",
+		sites: [{
+			namespace: NAMESPACES.w,
+			elements: /* @__PURE__ */ new Set(["num"])
+		}],
+		attribute: "numId",
+		attributeNamespace: NAMESPACES.w,
+		encoding: "decimal"
+	},
+	abstractNumId: {
+		kind: IMPORTED_ID_COLLISION_KINDS.abstractNumId,
+		scope: "part",
+		sites: [{
+			namespace: NAMESPACES.w,
+			elements: /* @__PURE__ */ new Set(["abstractNum"])
+		}],
+		attribute: "abstractNumId",
+		attributeNamespace: NAMESPACES.w,
+		encoding: "decimal"
+	},
+	drawing: {
+		kind: IMPORTED_ID_COLLISION_KINDS.drawing,
+		scope: "package",
+		sites: [{
+			namespace: NAMESPACES.wp,
+			elements: /* @__PURE__ */ new Set(["docPr"])
+		}],
+		attribute: "id",
+		attributeNamespace: null,
+		encoding: "decimal"
+	},
+	relationship: {
+		kind: IMPORTED_ID_COLLISION_KINDS.relationship,
+		scope: "part",
+		sites: [{
+			namespace: PACKAGE_RELATIONSHIP_NAMESPACE,
+			elements: /* @__PURE__ */ new Set(["Relationship"])
+		}],
+		attribute: "Id",
+		attributeNamespace: null,
+		encoding: "string"
+	}
+};
+const normalizedIdentity = (value, encoding) => {
+	if (encoding === "string") return value;
+	if (encoding === "hex") return /^[0-9a-f]{8}$/iu.test(value) ? value.toUpperCase() : void 0;
+	const spelling = value.trim();
+	if (!/^[+-]?\d+$/u.test(spelling)) return void 0;
+	const digits = spelling.replace(/^[+-]?0*/u, "");
+	return digits === "" ? "0" : `${spelling.startsWith("-") ? "-" : ""}${digits}`;
+};
+/** Reports repeated source definitions without changing the package or choosing a winner. */
+const diagnoseImportedIdCollisions = (parts, context) => {
+	const rules = Object.values(IMPORTED_ID_COLLISION_REGISTRY);
+	const packageSeen = /* @__PURE__ */ new Map();
+	for (const [part, xml] of parts) {
+		const partSeen = /* @__PURE__ */ new Map();
+		const scoped = context.scoped({ part });
+		scanSelectedStreamingXmlElements(xml, ({ element, attributeValueSpans }) => {
+			if (element.name === void 0) return;
+			const namespace = toTransitionalNamespaceUri(getNamespaceUri(element) ?? "");
+			const localName = getLocalName(element.name);
+			for (const rule of rules) {
+				const kind = rule.kind;
+				if (!rule.sites.some((site) => namespace === site.namespace && site.elements.has(localName))) continue;
+				const paragraphIdentity = paragraphIdentityForKind(kind, element);
+				const seen = rule.scope === "package" ? packageSeen : partSeen;
+				for (const [name, rawValue] of Object.entries(element.attributes ?? {})) {
+					if (getLocalName(name) !== rule.attribute || rawValue === void 0) continue;
+					const colon = name.indexOf(":");
+					const attributeNamespace = colon < 0 ? null : toTransitionalNamespaceUri(resolveNamespaceUri(element.namespaceScope, name.slice(0, colon)) ?? "");
+					if (rule.encoding === "hex") {
+						if (String(rawValue) !== paragraphIdentity) continue;
+					} else if (attributeNamespace !== rule.attributeNamespace) continue;
+					const value = String(rawValue);
+					const identity = normalizedIdentity(value, rule.encoding);
+					if (identity === void 0) continue;
+					const key = `${kind}:${identity}`;
+					const span = attributeValueSpans.get(name);
+					if (span === void 0) panic("Missing imported identity source span");
+					const offset = span.start;
+					const first = seen.get(key);
+					if (first === void 0) {
+						seen.set(key, {
+							part,
+							offset
+						});
+						break;
+					}
+					scoped.warn({
+						code: PARSE_WARNING_CODES.duplicateImportedId,
+						identityKind: kind,
+						element: element.name,
+						at: `offset ${offset}`,
+						value,
+						detail: `${kind} identity repeats the definition at offset ${first.offset} in ${first.part}.`
+					});
+					break;
+				}
+			}
+		});
+	}
+};
+//#endregion
+export { IMPORTED_ID_COLLISION_REGISTRY, diagnoseImportedIdCollisions };

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/numberingParser.js

@@ -398,9 +398,9 @@ function getCachedNumberingMap(definitions) {
 */
 function createNumberingMap(definitions) {
 	const abstractMap = /* @__PURE__ */ new Map();
-	for (const abs of definitions.abstractNums) abstractMap.set(abs.abstractNumId, abs);
+	for (const abs of definitions.abstractNums) if (!abstractMap.has(abs.abstractNumId)) abstractMap.set(abs.abstractNumId, abs);
 	const numMap = /* @__PURE__ */ new Map();
-	for (const num of definitions.nums) numMap.set(num.numId, num);
+	for (const num of definitions.nums) if (!numMap.has(num.numId)) numMap.set(num.numId, num);
 	return {
 		definitions,
 		getLevel(numId, ilvl) {

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;
 }
 /**