@stll/folio-core 0.54.1 → 0.55.0

package/dist/docx/rezip.js

@@ -4,6 +4,7 @@ import { isAllowedExternalWatermarkImageUrl } from "../watermark/index.js";
 import { appVersionInSchemaForm, normalizeAppVersionInExtendedProperties } from "./appVersionNormalization.js";
 import { withoutOrphanCommentRanges } from "./commentRangeIntegrity.js";
 import { applyReplyThreadMarkers } from "./commentReplyMarkers.js";
+import { registerContentTypeParts } from "./contentTypeRegistry.js";
 import { readDocumentSectionFacts } from "./documentSectionFacts.js";
 import { normalizeDrawingIds } from "./drawingIdNormalization.js";
 import { rebindDrawingImageRelationship } from "./drawingRelationships.js";
@@ -15,6 +16,7 @@ import { parseNumbering } from "./numberingParser.js";
 import { paragraphNumberingReferenceId as paragraphNumberingReferenceId$1 } from "./numberingReference.js";
 import { isUnsafePackagePath, reconcilePackageReferences, removeUnsafeEntries } from "./packageParts.js";
 import { normalizeParaIdRangeInXmlParts } from "./paraIdRangeNormalization.js";
+import { cloneParagraphWithPropertySource } from "./paragraphPropertySource.js";
 import { BLOCK_TREE_DESCENT, visitBlockTreeRecords } from "./paragraphTraversal.js";
 import { RELATIONSHIP_TYPES, parseRelationships, resolveRelativePath } from "./relsParser.js";
 import { removeResolvedHeaderFooterParts } from "./removeHeaderFooterParts.js";
@@ -30,10 +32,12 @@ import { readRootNamespaceBindings, serializePartElement } from "./serializer/pa
 import { serializeSettingsXml } from "./serializer/settingsSerializer.js";
 import { serializeStyle, serializeStylesXml } from "./serializer/stylesSerializer.js";
 import { serializeThemeXml } from "./serializer/themeSerializer.js";
+import { updateEvenAndOddHeaders } from "./settingsHeaderFooterUpdate.js";
+import { parseSettings } from "./settingsParser.js";
 import { hasCanonicalWordprocessingPrefixes } from "./wordprocessingPrefixes.js";
 import { WORDPROCESSINGML_NAMESPACE_URIS, findChild, findChildByNamespaceUri, findChildrenByNamespaceUri, getAttribute, getAttributeByNamespaceUri, getChildElements, getLocalName, getNamespaceUri, matchesName, parseXml, parseXmlDocument } from "./xmlParser.js";
 import { TaggedError, panic } from "better-result";
-import { escapeXmlAttribute, escapeXmlText, validateDocxPackage } from "@stll/docx-core";
+import { assertValidOoxmlNumericIds, escapeXmlAttribute, escapeXmlText, validateDocxPackage } from "@stll/docx-core";
 import { mintRelationshipId } from "@stll/docx-core/model";
 import JSZip from "jszip";
 //#region src/docx/rezip.ts
@@ -529,12 +533,19 @@ async function processNewHyperlinks(parts, zip, compressionLevel) {
 */
 const normalizePackageIdsInZip = async (zip, compressionLevel) => {
 	const xmlParts = /* @__PURE__ */ new Map();
-	for (const [path, file] of Object.entries(zip.files)) if (!file.dir && path.startsWith("word/") && path.endsWith(".xml")) xmlParts.set(path, await file.async("text"));
+	for (const [path, file] of Object.entries(zip.files)) if (!file.dir && path.startsWith("word/") && path.endsWith(".xml")) {
+		const xml = await file.async("text");
+		assertValidOoxmlNumericIds(xml, path);
+		xmlParts.set(path, xml);
+	}
 	const normalizedParts = normalizeParaIdRangeInXmlParts(normalizeRevisionIdsInXmlParts(xmlParts));
-	for (const [path, xml] of normalizedParts) if (xml !== xmlParts.get(path)) zip.file(path, xml, {
-		compression: "DEFLATE",
-		compressionOptions: { level: compressionLevel }
-	});
+	for (const [path, xml] of normalizedParts) if (xml !== xmlParts.get(path)) {
+		assertValidOoxmlNumericIds(xml, path);
+		zip.file(path, xml, {
+			compression: "DEFLATE",
+			compressionOptions: { level: compressionLevel }
+		});
+	}
 };
 const EXTENDED_PROPERTIES_PATH = "docProps/app.xml";
 /**
@@ -628,8 +639,8 @@ const normalizeExportDrawingIds = ({ package: docxPackage }) => {
 		...docxPackage.endnotes !== void 0 ? { endnotes: docxPackage.endnotes } : {}
 	});
 };
-const finishRepack = async ({ document, originalZip, outputZip, originalDocument, originalCorePropertiesXml, compressionLevel, updateModifiedDate, modifiedBy, changedNoteParaIds, sectionEndpointRemoval, sectionReferenceRemovals }) => {
-	await materializeNewHeaderFooterParts(document, outputZip, compressionLevel);
+const finishRepack = async ({ document, originalZip, outputZip, originalDocument, originalCorePropertiesXml, compressionLevel, updateModifiedDate, modifiedBy, changedNoteParaIds, onDiagnostic, sectionEndpointRemoval, sectionReferenceRemovals }) => {
+	document = await materializeNewHeaderFooterParts(document, outputZip, compressionLevel);
 	await materializeEmbeddedMedia({
 		document,
 		zip: outputZip,
@@ -660,7 +671,12 @@ const finishRepack = async ({ document, originalZip, outputZip, originalDocument
 		compressionOptions: { level: compressionLevel }
 	});
 	await rebindWatermarkRelIds(document, outputZip, compressionLevel);
-	await serializeHeadersFootersToZip(document, outputZip, compressionLevel);
+	await serializeHeadersFootersToZip({
+		doc: document,
+		zip: outputZip,
+		compressionLevel,
+		onDiagnostic
+	});
 	await serializeNotesToZip({
 		doc: document,
 		originalZip,
@@ -670,6 +686,7 @@ const finishRepack = async ({ document, originalZip, outputZip, originalDocument
 	});
 	await serializeNumberingIntoZip(document, originalZip, outputZip, compressionLevel);
 	await serializeAddedStylesIntoZip(document, originalZip, outputZip, compressionLevel);
+	await serializeHeaderFooterSettingsIntoZip(document, outputZip, compressionLevel);
 	await serializeCommentsToZip(document, outputZip, compressionLevel);
 	await dropAttachedTemplateReference(outputZip, compressionLevel);
 	if (updateModifiedDate && originalCorePropertiesXml) {
@@ -700,6 +717,7 @@ async function repackDocxWithSectionEndpointRemoval({ document: doc, options, se
 		originalCorePropertiesXml,
 		compressionLevel,
 		updateModifiedDate,
+		onDiagnostic: options.onDiagnostic,
 		...modifiedBy !== void 0 ? { modifiedBy } : {},
 		...changedNoteParaIds !== void 0 ? { changedNoteParaIds } : {},
 		...sectionEndpointRemoval !== void 0 ? { sectionEndpointRemoval } : {},
@@ -726,7 +744,7 @@ function repackDocx(doc, options = {}) {
 */
 async function repackDocxFromRaw(doc, rawContent, options = {}) {
 	const { compressionLevel = 6, updateModifiedDate = true, modifiedBy, changedNoteParaIds } = options;
-	const exportDocument = withoutOrphanCommentRanges(doc);
+	let exportDocument = withoutOrphanCommentRanges(doc);
 	const newZip = new JSZip();
 	for (const [path, file] of Object.entries(rawContent.originalZip.files)) {
 		if (file.dir) {
@@ -740,7 +758,7 @@ async function repackDocxFromRaw(doc, rawContent, options = {}) {
 			compressionOptions: { level: compressionLevel }
 		});
 	}
-	await materializeNewHeaderFooterParts(exportDocument, newZip, compressionLevel);
+	exportDocument = await materializeNewHeaderFooterParts(exportDocument, newZip, compressionLevel);
 	await materializeEmbeddedMedia({
 		document: exportDocument,
 		zip: newZip,
@@ -763,7 +781,13 @@ async function repackDocxFromRaw(doc, rawContent, options = {}) {
 		compressionOptions: { level: compressionLevel }
 	});
 	await rebindWatermarkRelIds(exportDocument, newZip, compressionLevel);
-	await serializeHeadersFootersToZip(exportDocument, newZip, compressionLevel);
+	await serializeHeadersFootersToZip({
+		doc: exportDocument,
+		zip: newZip,
+		compressionLevel,
+		onDiagnostic: options.onDiagnostic
+	});
+	await serializeHeaderFooterSettingsIntoZip(exportDocument, newZip, compressionLevel);
 	await serializeNotesToZip({
 		doc: exportDocument,
 		originalZip: rawContent.originalZip,
@@ -1108,11 +1132,19 @@ function findMaxHeaderFooterNum(zip, prefix) {
 * relationship.
 */
 async function materializeNewHeaderFooterParts(doc, zip, compressionLevel) {
-	if (!hasUnmaterializedHeaderFooter(doc)) return;
-	doc.package.relationships ??= /* @__PURE__ */ new Map();
-	const rels = doc.package.relationships;
+	if (!doc.package.headers?.size && !doc.package.footers?.size) return doc;
+	doc = {
+		...doc,
+		package: {
+			...doc.package,
+			relationships: new Map(doc.package.relationships),
+			...doc.package.headers === void 0 ? {} : { headers: new Map(doc.package.headers) },
+			...doc.package.footers === void 0 ? {} : { footers: new Map(doc.package.footers) }
+		}
+	};
+	const rels = doc.package.relationships ?? panic("The export owns its relationship map.");
 	const relEntries = [];
-	const overrides = [];
+	const contentTypeParts = [];
 	let maxHeaderNum = findMaxHeaderFooterNum(zip, "header");
 	let maxFooterNum = findMaxHeaderFooterNum(zip, "footer");
 	const relsPath = "word/_rels/document.xml.rels";
@@ -1135,8 +1167,18 @@ async function materializeNewHeaderFooterParts(doc, zip, compressionLevel) {
 	const materialize = (map, relType, prefix, contentType, isHeader) => {
 		if (!map) return;
 		for (const rId of [...map.keys()]) {
-			const existing = rels.get(rId) ?? zipRels.get(rId);
-			if (existing && existing.type === relType && existing.target) continue;
+			const registered = zipRels.get(rId);
+			const existing = registered ?? rels.get(rId);
+			if (existing && existing.type === relType && existing.target) {
+				rels.set(rId, existing);
+				const path = resolveRelativePath(relsPath, existing.target);
+				contentTypeParts.push({
+					partName: `/${path}`,
+					contentType
+				});
+				if (!registered) relEntries.push(`<Relationship Id="${escapeXmlAttribute(rId)}" Type="${relType}" Target="${escapeXmlAttribute(existing.target)}"/>`);
+				continue;
+			}
 			let effectiveRId = rId;
 			if (existing) {
 				effectiveRId = `rId${++maxRId}`;
@@ -1145,6 +1187,12 @@ async function materializeNewHeaderFooterParts(doc, zip, compressionLevel) {
 					map.delete(rId);
 					map.set(effectiveRId, headerFooter);
 				}
+				const body = doc.package.document;
+				doc.package.document = {
+					...body,
+					content: body.content.map((block) => block.type === "paragraph" && block.sectionProperties !== void 0 ? cloneParagraphWithPropertySource(block, { sectionProperties: structuredClone(block.sectionProperties) }) : block),
+					...body.finalSectionProperties === void 0 ? {} : { finalSectionProperties: structuredClone(body.finalSectionProperties) }
+				};
 				for (const block of doc.package.document.content) if (block.type === "paragraph") remapRefs(isHeader ? block.sectionProperties?.headerReferences : block.sectionProperties?.footerReferences, rId, effectiveRId);
 				const finalProps = doc.package.document.finalSectionProperties;
 				remapRefs(isHeader ? finalProps?.headerReferences : finalProps?.footerReferences, rId, effectiveRId);
@@ -1156,32 +1204,29 @@ async function materializeNewHeaderFooterParts(doc, zip, compressionLevel) {
 				target: filename
 			});
 			relEntries.push(`<Relationship Id="${escapeXmlAttribute(effectiveRId)}" Type="${relType}" Target="${filename}"/>`);
-			overrides.push(`<Override PartName="/word/${filename}" ContentType="${contentType}"/>`);
+			contentTypeParts.push({
+				partName: `/word/${filename}`,
+				contentType
+			});
 		}
 	};
 	materialize(doc.package.headers, RELATIONSHIP_TYPES.header, "header", HEADER_CONTENT_TYPE, true);
 	materialize(doc.package.footers, RELATIONSHIP_TYPES.footer, "footer", FOOTER_CONTENT_TYPE, false);
-	if (relEntries.length === 0) return;
 	const compressionOptions = { level: compressionLevel };
-	zip.file(relsPath, relsXml.replace("</Relationships>", `${relEntries.join("")}</Relationships>`), {
+	if (relEntries.length > 0) zip.file(relsPath, relsXml.replace("</Relationships>", `${relEntries.join("")}</Relationships>`), {
 		compression: "DEFLATE",
 		compressionOptions
 	});
 	const ctFile = zip.file("[Content_Types].xml");
 	if (ctFile) {
-		let ctXml = await ctFile.async("text");
-		const missing = overrides.filter((override) => {
-			const partName = /PartName="(?<partName>[^"]+)"/u.exec(override)?.groups?.["partName"];
-			return partName ? !ctXml.includes(`PartName="${partName}"`) : true;
+		const original = await ctFile.async("text");
+		const updated = registerContentTypeParts(original, contentTypeParts);
+		if (updated !== original) zip.file("[Content_Types].xml", updated, {
+			compression: "DEFLATE",
+			compressionOptions
 		});
-		if (missing.length > 0) {
-			ctXml = ctXml.replace("</Types>", `${missing.join("")}</Types>`);
-			zip.file("[Content_Types].xml", ctXml, {
-				compression: "DEFLATE",
-				compressionOptions
-			});
-		}
 	}
+	return doc;
 }
 /**
 * A picture watermark is "model-driven" when its raw VML was cleared (so the
@@ -1292,13 +1337,7 @@ async function rebindWatermarkRelIds(doc, zip, compressionLevel) {
 		});
 	}
 }
-/**
-* Re-serialize every header/footer the model still owns, keyed by part path.
-*
-* `sourceZip` supplies each part as it stands before the save so the rebuilt
-* root can keep any prefix binding only the source document declared.
-*/
-async function collectHeaderFooterUpdates(doc, sourceZip) {
+async function collectHeaderFooterUpdates(doc, { sourceZip, onDiagnostic }) {
 	const updates = /* @__PURE__ */ new Map();
 	const rels = doc.package.relationships;
 	if (!rels) return updates;
@@ -1320,19 +1359,21 @@ async function collectHeaderFooterUpdates(doc, sourceZip) {
 				const bindings = sourceFile ? readRootNamespaceBindings(await sourceFile.async("text")) : /* @__PURE__ */ new Map();
 				updates.set(path, serializeHeaderFooter(headerFooter, {
 					path,
-					bindings
+					bindings,
+					onDiagnostic,
+					originalBuffer: doc.originalBuffer
 				}));
 			}
 		}
 	}
 	return updates;
 }
-/**
-* Serialize modified headers and footers into the ZIP
-*/
-async function serializeHeadersFootersToZip(doc, zip, compressionLevel) {
+async function serializeHeadersFootersToZip({ doc, zip, compressionLevel, onDiagnostic }) {
 	const compressionOptions = { level: compressionLevel };
-	for (const [filename, xml] of await collectHeaderFooterUpdates(doc, zip)) zip.file(filename, xml, {
+	for (const [filename, xml] of await collectHeaderFooterUpdates(doc, {
+		sourceZip: zip,
+		onDiagnostic
+	})) zip.file(filename, xml, {
 		compression: "DEFLATE",
 		compressionOptions
 	});
@@ -1343,7 +1384,7 @@ async function serializeNotesToZip({ doc, originalZip, newZip, compressionLevel,
 	if (footnotes.length > 0 || originalFootnotes) if (originalFootnotes) await patchNotePartIntoZip({
 		conventionalLowerPath: "word/footnotes.xml",
 		currentXml: serializeFootnotes(footnotes),
-		replacementXml: serializeNewFootnotesPart(footnotes),
+		replacementXml: serializeNewFootnotesPart(footnotes, doc),
 		baselineFrom: (xml) => serializeFootnotes(parseFootnotes(xml).getNormalFootnotes()),
 		elementName: "footnote",
 		changedNoteParaIds,
@@ -1356,7 +1397,7 @@ async function serializeNotesToZip({ doc, originalZip, newZip, compressionLevel,
 		newZip,
 		partPath: "word/footnotes.xml",
 		relationshipType: RELATIONSHIP_TYPES.footnotes,
-		serializedPart: serializeNewFootnotesPart(footnotes),
+		serializedPart: serializeNewFootnotesPart(footnotes, doc),
 		compressionLevel
 	});
 	const endnotes = doc.package.endnotes ?? [];
@@ -1364,7 +1405,7 @@ async function serializeNotesToZip({ doc, originalZip, newZip, compressionLevel,
 	if (endnotes.length > 0 || originalEndnotes) if (originalEndnotes) await patchNotePartIntoZip({
 		conventionalLowerPath: "word/endnotes.xml",
 		currentXml: serializeEndnotes(endnotes),
-		replacementXml: serializeNewEndnotesPart(endnotes),
+		replacementXml: serializeNewEndnotesPart(endnotes, doc),
 		baselineFrom: (xml) => serializeEndnotes(parseEndnotes(xml).getNormalEndnotes()),
 		elementName: "endnote",
 		changedNoteParaIds,
@@ -1377,7 +1418,7 @@ async function serializeNotesToZip({ doc, originalZip, newZip, compressionLevel,
 		newZip,
 		partPath: "word/endnotes.xml",
 		relationshipType: RELATIONSHIP_TYPES.endnotes,
-		serializedPart: serializeNewEndnotesPart(endnotes),
+		serializedPart: serializeNewEndnotesPart(endnotes, doc),
 		compressionLevel
 	});
 }
@@ -1406,6 +1447,32 @@ async function materializeNewNotePart({ contentType, newZip, partPath, relations
 		compressionOptions
 	});
 }
+/** Only this modeled switch changes on story lifecycle edits; preserve all other settings. */
+async function serializeHeaderFooterSettingsIntoZip(doc, zip, compressionLevel) {
+	if (!doc.package.settings) return;
+	const enabled = doc.package.settings.evenAndOddHeaders;
+	const file = zip.file(SETTINGS_PART);
+	if (!file) {
+		if (enabled === void 0) return;
+		await materializeNewNotePart({
+			contentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml",
+			newZip: zip,
+			partPath: "word/settings.xml",
+			relationshipType: RELATIONSHIP_TYPES.settings,
+			serializedPart: serializeSettingsXml(doc.package.settings),
+			compressionLevel
+		});
+		return;
+	}
+	const xml = await file.async("text");
+	if (parseSettings(xml).evenAndOddHeaders === enabled) return;
+	const patched = updateEvenAndOddHeaders(xml, enabled);
+	if (patched === null) throw new DocxPackageFidelityError("Cannot update malformed header/footer settings");
+	zip.file(file.name, patched, {
+		compression: "DEFLATE",
+		compressionOptions: { level: compressionLevel }
+	});
+}
 const numberingBaselines = /* @__PURE__ */ new WeakMap();
 async function serializeNumberingIntoZip(doc, originalZip, newZip, compressionLevel) {
 	const numbering = doc.package.numbering;
@@ -1600,7 +1667,7 @@ const notePartXmlFor = ({ patch, originalXml, replacementXml, hasDirtyParagraph,
 		return null;
 	};
 	switch (patch.type) {
-		case "patched": return patch.xml === originalXml ? keepOriginal() : patch.xml;
+		case "patched": return patch.xml === originalXml ? null : patch.xml;
 		case "refused": switch (patch.reason) {
 			case "comment-range-balance": return replacementXml;
 			case "unroutable-paragraph": return keepOriginal();
@@ -1800,7 +1867,8 @@ async function createDocx(doc, properties = {}) {
 			originalDocument: source.document,
 			originalCorePropertiesXml: source.corePropertiesXml,
 			compressionLevel: 6,
-			updateModifiedDate: true
+			updateModifiedDate: true,
+			onDiagnostic: properties.onDiagnostic
 		});
 	}
 	const zip = await createDocumentSeedZip(doc, properties);
@@ -1811,7 +1879,8 @@ async function createDocx(doc, properties = {}) {
 		originalDocument: void 0,
 		originalCorePropertiesXml: await zip.file("docProps/core.xml")?.async("text"),
 		compressionLevel: 6,
-		updateModifiedDate: true
+		updateModifiedDate: true,
+		onDiagnostic: properties.onDiagnostic
 	});
 }
 const createDocumentSeedZip = async (doc, properties) => {

package/dist/docx/runConsolidator.d.ts

@@ -1,62 +1,6 @@
 import { document_d_exports } from "../types/document.js";
+import { formattingEquals, isTextOnlyRun, runsMergeable } from "@stll/docx-core/ops";
 //#region src/docx/runConsolidator.d.ts
-/**
- * Every `TextFormatting` field, named so the comparison below is total.
- *
- * A field this comparison forgets is a field one of two merged runs loses,
- * silently and at parse time. Naming them turns a field added to the model
- * without a comparison into a compile error rather than a fidelity defect.
- */
-type ComparedTextFormattingField = "bold" | "boldCs" | "italic" | "italicCs" | "underline" | "strike" | "doubleStrike" | "vertAlign" | "smallCaps" | "allCaps" | "hidden" | "noProof" | "color" | "highlight" | "shading" | "fontSize" | "fontSizeCs" | "fontFamily" | "language" | "spacing" | "position" | "scale" | "kerning" | "effect" | "emphasisMark" | "emboss" | "imprint" | "outline" | "shadow" | "rtl" | "cs" | "styleId" | "preserved";
-type ComparedTextFormatting = document_d_exports.ExhaustiveFields<document_d_exports.TextFormatting, ComparedTextFormattingField>;
-/**
- * Check if two TextFormatting objects are equivalent
- *
- * Uses deep comparison of all properties to determine if runs
- * can be merged without losing formatting information.
- */
-declare function formattingEquals(a: ComparedTextFormatting | undefined, b: ComparedTextFormatting | undefined): boolean;
-/**
- * Check if a run contains only text content
- * (runs with special content like images, fields, etc. should not be merged)
- */
-declare function isTextOnlyRun(run: document_d_exports.Run): boolean;
-/**
- * Check if a run can be merged with another run
- * Runs with breaks, tabs, images, fields, etc. act as merge boundaries
- */
-declare function canMergeRun(run: document_d_exports.Run): boolean;
-/**
- * Every `Run` field, named by what a merge does with it.
- *
- * The merged run is the survivor spread whole, so a field added to the model
- * is carried over from one side by default. Naming each one here forces the
- * next field to state whether that default is right before it can compile.
- */
-type MergeDecidedRunField =
-/** Identical for every run. */
-"type" |
-/** Concatenated; see {@link mergeRunContent}. */
-"content" |
-/** Must be equal, and the survivor keeps it. */
-"formatting" |
-/** Must be equal, and the survivor keeps it. */
-"preservedAttributes" |
-/** Refuses the merge outright; see {@link canMergeRun}. */
-"propertyChanges";
-type MergeDecidedRun = document_d_exports.ExhaustiveFields<document_d_exports.Run, MergeDecidedRunField>;
-/**
- * May two adjacent runs become one?
- *
- * Every consolidation site asks this one question, because a merge that any
- * one site decides differently is a merge the next parse undoes. A run holds
- * three records a merged run can hold only one of: its typed formatting, the
- * attributes `w:r` carried that the model has no field for, and the `w:rPr`
- * children no reader took a value from. Merging two runs that disagree on any
- * of them discards the loser's copy, which is how both runs' `w:rsid*` used to
- * vanish at parse time — before the editor, before any gate could see it.
- */
-declare function runsMergeable(a: MergeDecidedRun, b: MergeDecidedRun): boolean;
 /**
  * Consolidate an array of runs by merging consecutive runs with identical formatting
  *
@@ -93,4 +37,4 @@ declare function getConsolidationStats(originalParagraphs: document_d_exports.Pa
   reductionPercentage: number;
 };
 //#endregion
-export { canMergeRun, consolidateParagraph, consolidateParagraphContent, consolidateRuns, countRuns, formattingEquals, getConsolidationStats, isTextOnlyRun, runsMergeable };
+export { consolidateParagraph, consolidateParagraphContent, consolidateRuns, countRuns, formattingEquals, getConsolidationStats, isTextOnlyRun, runsMergeable };

package/dist/docx/runConsolidator.js

@@ -1,180 +1,8 @@
 import { cloneParagraphWithPropertySource } from "./paragraphPropertySource.js";
 import { runHoldsPayload } from "./runPayload.js";
+import { formattingEquals, isTextOnlyRun, mergeRunContent, runsMergeable, runsMergeable as runsMergeable$1 } from "@stll/docx-core/ops";
 //#region src/docx/runConsolidator.ts
 /**
-* Check if two TextFormatting objects are equivalent
-*
-* Uses deep comparison of all properties to determine if runs
-* can be merged without losing formatting information.
-*/
-function formattingEquals(a, b) {
-	if (!a && !b) return true;
-	if (!a || !b) return false;
-	if (a.bold !== b.bold) return false;
-	if (a.boldCs !== b.boldCs) return false;
-	if (a.italic !== b.italic) return false;
-	if (a.italicCs !== b.italicCs) return false;
-	if (a.strike !== b.strike) return false;
-	if (a.doubleStrike !== b.doubleStrike) return false;
-	if (a.smallCaps !== b.smallCaps) return false;
-	if (a.allCaps !== b.allCaps) return false;
-	if (a.hidden !== b.hidden) return false;
-	if (a.noProof !== b.noProof) return false;
-	if (a.emboss !== b.emboss) return false;
-	if (a.imprint !== b.imprint) return false;
-	if (a.outline !== b.outline) return false;
-	if (a.shadow !== b.shadow) return false;
-	if (a.rtl !== b.rtl) return false;
-	if (a.cs !== b.cs) return false;
-	if (a.fontSize !== b.fontSize) return false;
-	if (a.fontSizeCs !== b.fontSizeCs) return false;
-	if (a.spacing !== b.spacing) return false;
-	if (a.position !== b.position) return false;
-	if (a.scale !== b.scale) return false;
-	if (a.kerning !== b.kerning) return false;
-	if (a.vertAlign !== b.vertAlign) return false;
-	if (a.highlight !== b.highlight) return false;
-	if (a.effect !== b.effect) return false;
-	if (a.emphasisMark !== b.emphasisMark) return false;
-	if (a.styleId !== b.styleId) return false;
-	if (!underlineEquals(a.underline, b.underline)) return false;
-	if (!colorEquals(a.color, b.color)) return false;
-	if (!shadingEquals(a.shading, b.shading)) return false;
-	if (!fontFamilyEquals(a.fontFamily, b.fontFamily)) return false;
-	if (!languageEquals(a.language, b.language)) return false;
-	if (!preservedMarkupEquals(a.preserved, b.preserved)) return false;
-	return true;
-}
-/**
-* Compare two verbatim sinks position by position.
-*
-* The sink is ordered — by `index`, then by source order within an index — and
-* the order is what puts the markup back between the same modelled siblings,
-* so equality is by sequence, not by set.
-*/
-function preservedMarkupEquals(a, b) {
-	const left = a?.children ?? [];
-	const right = b?.children ?? [];
-	if (left.length !== right.length) return false;
-	return left.every(({ index, xml }, position) => {
-		const other = right[position];
-		return other !== void 0 && other.index === index && other.xml === xml;
-	});
-}
-/**
-* Compare two attribute remainders as sets.
-*
-* An element cannot carry one expanded name twice, so (namespace, name) orders
-* a remainder totally and the sorted keys compare exactly. Order is a set
-* comparison rather than a sequence one because attribute order in XML says
-* nothing: two runs that spelled the same attributes in a different order
-* carry the same remainder and may still become one run.
-*/
-function preservedAttributesEqual(a, b) {
-	const left = canonicalRemainderKeys(a);
-	const right = canonicalRemainderKeys(b);
-	return left.length === right.length && left.every((key, index) => key === right[index]);
-}
-/** `\u0000` cannot appear in an XML name, namespace URI or attribute value. */
-const REMAINDER_KEY_SEPARATOR = "\0";
-const canonicalRemainderKeys = (attributes) => (attributes ?? []).map(({ namespace, name, value }) => [
-	namespace ?? "",
-	name,
-	value
-].join(REMAINDER_KEY_SEPARATOR)).sort();
-function languageEquals(a, b) {
-	return a?.val === b?.val && a?.eastAsia === b?.eastAsia && a?.bidi === b?.bidi;
-}
-/**
-* Compare underline settings
-*/
-function underlineEquals(a, b) {
-	if (!a && !b) return true;
-	if (!a || !b) return false;
-	if (a.style !== b.style) return false;
-	return colorEquals(a.color, b.color);
-}
-/**
-* Compare color values
-*/
-function colorEquals(a, b) {
-	if (!a && !b) return true;
-	if (!a || !b) return false;
-	return a.rgb === b.rgb && a.auto === b.auto && a.themeColor === b.themeColor && a.themeTint === b.themeTint && a.themeShade === b.themeShade;
-}
-/**
-* Compare shading properties
-*/
-function shadingEquals(a, b) {
-	if (!a && !b) return true;
-	if (!a || !b) return false;
-	if (a.pattern !== b.pattern) return false;
-	if (!colorEquals(a.color, b.color)) return false;
-	if (!colorEquals(a.fill, b.fill)) return false;
-	return true;
-}
-/**
-* Compare font family settings
-*/
-function fontFamilyEquals(a, b) {
-	if (!a && !b) return true;
-	if (!a || !b) return false;
-	return a.ascii === b.ascii && a.hAnsi === b.hAnsi && a.eastAsia === b.eastAsia && a.cs === b.cs && a.asciiTheme === b.asciiTheme && a.hAnsiTheme === b.hAnsiTheme && a.eastAsiaTheme === b.eastAsiaTheme && a.csTheme === b.csTheme;
-}
-/**
-* Check if a run contains only text content
-* (runs with special content like images, fields, etc. should not be merged)
-*/
-function isTextOnlyRun(run) {
-	return run.content.every((c) => c.type === "text" || c.type === "softHyphen" || c.type === "noBreakHyphen");
-}
-/**
-* Check if run content can be merged (simple text types)
-*/
-function isMergeableContent(content) {
-	return content.type === "text" || content.type === "softHyphen" || content.type === "noBreakHyphen";
-}
-/**
-* Check if a run can be merged with another run
-* Runs with breaks, tabs, images, fields, etc. act as merge boundaries
-*/
-function canMergeRun(run) {
-	if (run.propertyChanges && run.propertyChanges.length > 0) return false;
-	if (!runHoldsPayload(run)) return false;
-	return run.content.every(isMergeableContent);
-}
-/**
-* May two adjacent runs become one?
-*
-* Every consolidation site asks this one question, because a merge that any
-* one site decides differently is a merge the next parse undoes. A run holds
-* three records a merged run can hold only one of: its typed formatting, the
-* attributes `w:r` carried that the model has no field for, and the `w:rPr`
-* children no reader took a value from. Merging two runs that disagree on any
-* of them discards the loser's copy, which is how both runs' `w:rsid*` used to
-* vanish at parse time — before the editor, before any gate could see it.
-*/
-function runsMergeable(a, b) {
-	return canMergeRun(a) && canMergeRun(b) && formattingEquals(a.formatting, b.formatting) && preservedAttributesEqual(a.preservedAttributes, b.preservedAttributes);
-}
-/**
-* Merge the content of two runs into a single content array
-*/
-function mergeRunContent(content1, content2) {
-	const result = [];
-	for (const c of content1) result.push(c);
-	const lastText = result.at(-1);
-	const firstText = content2[0];
-	if (lastText?.type === "text" && firstText?.type === "text") {
-		result[result.length - 1] = {
-			type: "text",
-			text: lastText.text + firstText.text
-		};
-		for (let i = 1; i < content2.length; i++) result.push(content2[i]);
-	} else for (const c of content2) result.push(c);
-	return result;
-}
-/**
 * Consolidate an array of runs by merging consecutive runs with identical formatting
 *
 * @param runs - Array of runs to consolidate
@@ -200,7 +28,7 @@ function consolidateRuns(runs) {
 			};
 			continue;
 		}
-		if (runsMergeable(current, run)) current = {
+		if (runsMergeable$1(current, run)) current = {
 			...current,
 			content: mergeRunContent(current.content, run.content)
 		};
@@ -276,4 +104,4 @@ function getConsolidationStats(originalParagraphs, consolidatedParagraphs) {
 	};
 }
 //#endregion
-export { canMergeRun, consolidateParagraph, consolidateParagraphContent, consolidateRuns, countRuns, formattingEquals, getConsolidationStats, isTextOnlyRun, runsMergeable };
+export { consolidateParagraph, consolidateParagraphContent, consolidateRuns, countRuns, formattingEquals, getConsolidationStats, isTextOnlyRun, runsMergeable };

package/dist/docx/runParser.d.ts

@@ -60,7 +60,8 @@ declare const isBaselineVertAlign: (vertAlign: document_d_exports.TextFormatting
  * it beat are not kept.
  *
  * An element that states nothing at all still yields a record: `undefined` here
- * means the owner carried no `w:rPr`, never that the one it carried was empty.
+ * means the owner carried no `w:rPr`, or a paragraph-mark carrier contained
+ * only metadata owned by the paragraph. An authored empty set remains {}.
  */
 declare function parseRunProperties(rPr: XmlElement | null, theme: document_d_exports.Theme | null, owner: RunPropertyOwner): document_d_exports.TextFormatting | undefined;
 /**