@stll/folio-core 0.35.1 → 0.37.0

package/dist/docx/documentClone.js

@@ -0,0 +1,2 @@
+import { cloneDocumentWithParagraphPropertySources } from "./paragraphPropertySource.js";
+export { cloneDocumentWithParagraphPropertySources };

package/dist/docx/ensureParaIds.js

@@ -392,10 +392,15 @@ const ensureParaIdsInternal = async (docx, options) => {
 	};
 	const zip = await JSZip.loadAsync(docx);
 	if (hasDigitalSignatureParts(zip) && options.allowSignedPackageMutation !== true) throw createEnsureParaIdsError("Refusing to normalize a digitally signed package because rewriting OOXML invalidates its signatures. Warn the user and pass allowSignedPackageMutation only if invalidation is acceptable.");
-	for (const [partPath, content] of updates) zip.file(partPath, content, {
-		compression: "DEFLATE",
-		compressionOptions: { level: 6 }
-	});
+	for (const [partPath, content] of updates) {
+		const sourceEntry = zip.file(partPath);
+		if (sourceEntry === null) throw createEnsureParaIdsError(`Package part disappeared during normalization: ${partPath}`);
+		zip.file(partPath, content, {
+			compression: "DEFLATE",
+			compressionOptions: { level: 6 },
+			date: sourceEntry.date
+		});
+	}
 	return {
 		docx: await zip.generateAsync({
 			type: "uint8array",

package/dist/docx/headerFooterParser.js

@@ -1,6 +1,7 @@
 import { parseBlockContent } from "./blockContentParser.js";
 import { parseFooterReference, parseFooterReferences, parseHeaderReference, parseHeaderReferences } from "./headerFooterRefParser.js";
 import { assignHeaderFooterVerbatimXml } from "./headerFooterVerbatim.js";
+import { cloneParagraphWithPropertySource } from "./paragraphPropertySource.js";
 import { parseWatermark } from "./watermarkParser.js";
 import { collectXmlnsDeclarations, parseXml } from "./xmlParser.js";
 //#region src/docx/headerFooterParser.ts
@@ -37,10 +38,7 @@ function parseHeader(headerXml, hdrFtrType = "default", styles = null, theme = n
 	});
 	if (watermarkResult) {
 		const host = result.content.at(watermarkResult.blockIndex);
-		if (host?.type === "paragraph") result.content[watermarkResult.blockIndex] = {
-			...host,
-			content: []
-		};
+		if (host?.type === "paragraph") result.content[watermarkResult.blockIndex] = cloneParagraphWithPropertySource(host, { content: [] });
 	}
 	assignHeaderFooterVerbatimXml(result, headerXml);
 	return result;

package/dist/docx/normalizeBaseDirection.js

@@ -1,5 +1,6 @@
 import { createStyleResolver } from "../prosemirror/styles/styleResolver.js";
 import { detectBaseDirection } from "../utils/baseDirection.js";
+import { cloneParagraphWithoutPropertySource } from "./paragraphPropertySource.js";
 //#region src/docx/normalizeBaseDirection.ts
 const runText = (run) => {
 	let text = "";
@@ -32,13 +33,10 @@ const paragraphText = (paragraph) => paragraphContentText(paragraph.content);
 const normalizeParagraph = (paragraph, styles) => {
 	if ((paragraph.formatting?.bidi ?? styles.resolveParagraphStyle(paragraph.formatting?.styleId).paragraphFormatting?.bidi) != null) return paragraph;
 	if (detectBaseDirection(paragraphText(paragraph)) !== "rtl") return paragraph;
-	return {
-		...paragraph,
-		formatting: {
-			...paragraph.formatting,
-			bidi: true
-		}
-	};
+	return cloneParagraphWithoutPropertySource(paragraph, { formatting: {
+		...paragraph.formatting,
+		bidi: true
+	} });
 };
 const normalizeTable = (table, styles) => ({
 	...table,

package/dist/docx/numberingParser.d.ts

@@ -80,5 +80,7 @@ declare function getBulletCharacter(level: document_d_exports.ListLevel): string
  * Check if a list level is a bullet (not numbered)
  */
 declare function isBulletLevel(level: document_d_exports.ListLevel): boolean;
+/** Whether a numbering level reserves horizontal space for a visible marker. */
+declare const numberingLevelHasMarkerSlot: (level: Pick<document_d_exports.ListLevel, "numFmt">) => boolean;
 //#endregion
-export { NumberingMap, computeListRendering, createNumberingMap, formatOoxmlCounter as formatNumber, getBulletCharacter, getCachedNumberingMap, isBulletLevel, markerFormattingFromLevel, numPrEqual, padDecimal, parseNumbering, renderListMarker };
+export { NumberingMap, computeListRendering, createNumberingMap, formatOoxmlCounter as formatNumber, getBulletCharacter, getCachedNumberingMap, isBulletLevel, markerFormattingFromLevel, numPrEqual, numberingLevelHasMarkerSlot, padDecimal, parseNumbering, renderListMarker };

package/dist/docx/numberingParser.js

@@ -542,6 +542,7 @@ function computeListRendering(numPr, numbering) {
 		level: ilvl,
 		numId,
 		marker: level.lvlText,
+		markerTemplate: level.lvlText,
 		isBullet: level.numFmt === "bullet",
 		numFmt: level.isLgl ? "decimal" : level.numFmt,
 		levelNumFmts,
@@ -609,5 +610,7 @@ function getBulletCharacter(level) {
 function isBulletLevel(level) {
 	return level.numFmt === "bullet" || level.numFmt === "none";
 }
+/** Whether a numbering level reserves horizontal space for a visible marker. */
+const numberingLevelHasMarkerSlot = (level) => level.numFmt !== "none";
 //#endregion
-export { computeListRendering, createNumberingMap, formatOoxmlCounter as formatNumber, getBulletCharacter, getCachedNumberingMap, isBulletLevel, markerFormattingFromLevel, numPrEqual, padDecimal, parseNumbering, renderListMarker };
+export { computeListRendering, createNumberingMap, formatOoxmlCounter as formatNumber, getBulletCharacter, getCachedNumberingMap, isBulletLevel, markerFormattingFromLevel, numPrEqual, numberingLevelHasMarkerSlot, padDecimal, parseNumbering, renderListMarker };

package/dist/docx/paragraphParser.js

@@ -1,19 +1,22 @@
+import { canonicalJson } from "../utils/canonicalJson.js";
 import { isValidHexColor } from "../utils/colorResolver.js";
 import { isValidHexId } from "../utils/hexId.js";
 import { parseBookmarkEnd as parseBookmarkEnd$1, parseBookmarkStart as parseBookmarkStart$1 } from "./bookmarkParser.js";
 import { parseFieldType } from "./fieldParser.js";
 import { parseHyperlink as parseHyperlink$1, parseHyperlinkChild } from "./hyperlinkParser.js";
-import { markerFormattingFromLevel } from "./numberingParser.js";
+import { markerFormattingFromLevel, numberingLevelHasMarkerSlot } from "./numberingParser.js";
 import { paraIdInRange } from "./paraIdRangeNormalization.js";
+import { assignParagraphPropertySource } from "./paragraphPropertySource.js";
 import { BorderStyleSchema, FrameWrapSchema, FrameXAlignSchema, FrameYAlignSchema, LineSpacingRuleSchema, ParagraphAlignmentSchema, ShadingPatternSchema, TabLeaderSchema, TabStopAlignmentSchema, ThemeColorSlotSchema, narrowEnum } from "./parserEnums.js";
 import { consolidateParagraphContent } from "./runConsolidator.js";
 import { parseRun, parseRunProperties } from "./runParser.js";
 import { parseSdtProperties } from "./sdtProperties.js";
 import { parseSectionProperties } from "./sectionParser.js";
+import { parsePropertyChangeInfo, parseTrackedChangeInfo } from "./trackedChangeInfo.js";
 import { captureVerbatimXml } from "./verbatimCapture.js";
-import { WORDPROCESSINGML_NAMESPACE_URIS, findChild, findChildByNamespaceUri, findChildren, getAttribute, getChildElements, getLocalName, matchesName, mergeXmlnsDeclarations, parseBooleanElement, parseNumberingLevelAttribute, parseNumericAttribute } from "./xmlParser.js";
+import { WORDPROCESSINGML_NAMESPACE_URIS, cloneElement, findChild, findChildByNamespaceUri, findChildren, findChildrenByNamespaceUri, getAttribute, getChildElements, getLocalName, matchesName, mergeXmlnsDeclarations, parseBooleanElement, parseNumberingLevelAttribute, parseNumericAttribute } from "./xmlParser.js";
 import { panic } from "better-result";
-import { PARAGRAPH_MARK_CHANGE_KINDS, normalizeRevisionId } from "@stll/docx-core/model";
+import { PARAGRAPH_MARK_CHANGE_KINDS } from "@stll/docx-core/model";
 //#region src/docx/paragraphParser.ts
 /**
 * Extract plain text from a math element (recursive text content extraction)
@@ -373,6 +376,21 @@ function parseParagraphProperties(pPr, theme, styles) {
 	}
 	return Object.keys(formatting).length > 0 ? formatting : void 0;
 }
+/**
+* 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) => {
+	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) => {
+		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);
+	}) })];
+}) }));
 const RENDERED_BREAK_INLINE_WRAPPERS = /* @__PURE__ */ new Set([
 	"hyperlink",
 	"smartTag",
@@ -477,39 +495,15 @@ function normalizeDeletionContentElement(node) {
 	let mappedName = node.name;
 	if (localName === "delText") mappedName = replaceLocalName(node.name, "t");
 	else if (localName === "delInstrText") mappedName = replaceLocalName(node.name, "instrText");
-	const result = { ...node };
-	if (mappedName !== void 0) result.name = mappedName;
-	if (node.elements) result.elements = node.elements.map(normalizeDeletionContentElement);
-	return result;
-}
-function parseTrackedChangeInfo(node) {
-	const rawId = getAttribute(node, "w", "id");
-	const parsedId = rawId ? Number.parseInt(rawId, 10) : 0;
-	const rawAuthor = getAttribute(node, "w", "author");
-	const rawDate = getAttribute(node, "w", "date");
-	const author = rawAuthor?.trim() ?? "";
-	const date = rawDate?.trim() ?? "";
-	const initials = (getAttribute(node, "w", "initials") ?? "").trim();
-	const info = {
-		id: normalizeRevisionId(parsedId),
-		author: author.length > 0 ? author : "Unknown"
-	};
-	if (date.length > 0) info.date = date;
-	if (initials.length > 0) info.initials = initials;
-	return info;
-}
-function parsePropertyChangeInfo(node) {
-	const base = parseTrackedChangeInfo(node);
-	const rsid = (getAttribute(node, "w", "rsid") ?? "").trim();
-	return rsid.length > 0 ? {
-		...base,
-		rsid
-	} : base;
+	return cloneElement(node, {
+		...mappedName !== void 0 ? { name: mappedName } : {},
+		...node.elements ? { elements: node.elements.map(normalizeDeletionContentElement) } : {}
+	});
 }
 function parseParagraphPropertyChanges(pPr, theme, styles, currentFormatting) {
 	if (!pPr) return;
-	const changes = findChildren(pPr, "w", "pPrChange").map((changeElement) => {
-		const previousFormatting = parseParagraphProperties(findChild(changeElement, "w", "pPr"), theme, styles ?? void 0);
+	const changes = findChildrenByNamespaceUri(pPr, WORDPROCESSINGML_NAMESPACE_URIS, "pPrChange").map((changeElement) => {
+		const previousFormatting = parseParagraphProperties(findChildByNamespaceUri(changeElement, WORDPROCESSINGML_NAMESPACE_URIS, "pPr"), theme, styles ?? void 0);
 		const change = {
 			type: "paragraphPropertyChange",
 			info: parsePropertyChangeInfo(changeElement)
@@ -528,7 +522,7 @@ function parseParagraphPropertyChanges(pPr, theme, styles, currentFormatting) {
 */
 function parseParagraphMarkChange(pPr) {
 	if (!pPr) return;
-	const rPr = findChild(pPr, "w", "rPr");
+	const rPr = findChildByNamespaceUri(pPr, WORDPROCESSINGML_NAMESPACE_URIS, "rPr");
 	if (!rPr) return;
 	for (const kind of PARAGRAPH_MARK_CHANGE_KINDS) {
 		const element = findChildByNamespaceUri(rPr, WORDPROCESSINGML_NAMESPACE_URIS, kind);
@@ -1128,6 +1122,7 @@ function parseParagraph(node, styles, theme, numbering, rels = null, media = nul
 					level: ilvl,
 					numId,
 					marker: level.lvlText,
+					markerTemplate: level.lvlText,
 					isBullet: level.numFmt === "bullet",
 					levelNumFmts,
 					levelStarts
@@ -1192,7 +1187,7 @@ function parseParagraph(node, styles, theme, numbering, rels = null, media = nul
 					const directHanging = directInd ? parseNumericAttribute(directInd, "w", "hanging") : void 0;
 					const hasDirectFirstLineOrHanging = directFirstLine !== void 0 && directFirstLine !== 0 || directHanging !== void 0 && directHanging !== 0;
 					if (!hasDirectLeft && !chainInd.left && level.pPr.indentLeft !== void 0) paragraph.formatting.indentLeft = level.pPr.indentLeft;
-					if (!hasDirectFirstLineOrHanging && !chainInd.firstLine) {
+					if (!hasDirectFirstLineOrHanging && !chainInd.firstLine && numberingLevelHasMarkerSlot(level)) {
 						if (level.pPr.indentFirstLine !== void 0) paragraph.formatting.indentFirstLine = level.pPr.indentFirstLine;
 						if (level.pPr.hangingIndent !== void 0) paragraph.formatting.hangingIndent = level.pPr.hangingIndent;
 					}
@@ -1200,6 +1195,10 @@ function parseParagraph(node, styles, theme, numbering, rels = null, media = nul
 			}
 		}
 	}
+	if (pPr) assignParagraphPropertySource(paragraph, {
+		xml: captureParagraphPropertySource(pPr),
+		formattingJson: canonicalJson(paragraph.formatting ?? {})
+	});
 	return paragraph;
 }
 /**

package/dist/docx/paragraphPropertySource.d.ts

@@ -0,0 +1,49 @@
+import { document_d_exports } from "../types/document.js";
+import { Transaction } from "prosemirror-state";
+import { Fragment, Mark, Node } from "prosemirror-model";
+//#region src/docx/paragraphPropertySource.d.ts
+type ParagraphPropertySource = {
+  xml: string;
+  formattingJson: string;
+};
+declare const assignParagraphPropertySource: (paragraph: document_d_exports.Paragraph, source: ParagraphPropertySource) => void;
+declare const getParagraphPropertySource: (paragraph: document_d_exports.Paragraph) => ParagraphPropertySource | undefined;
+declare const copyParagraphPropertySource: (target: document_d_exports.Paragraph, source: document_d_exports.Paragraph) => void;
+type ParagraphCloneOverrides = Omit<Partial<document_d_exports.Paragraph>, "type">;
+/** Clone a paragraph while deliberately retaining its parsed `w:pPr` owner. */
+declare const cloneParagraphWithPropertySource: (paragraph: document_d_exports.Paragraph, overrides: ParagraphCloneOverrides) => document_d_exports.Paragraph;
+/** Clone a paragraph whose formatting provenance is deliberately no longer applicable. */
+declare const cloneParagraphWithoutPropertySource: (paragraph: document_d_exports.Paragraph, overrides: ParagraphCloneOverrides) => document_d_exports.Paragraph;
+/**
+ * Deep-clone a document and transfer each private paragraph capture across the
+ * exact graph clone. `structuredClone` preserves graph topology, so any count
+ * mismatch is an internal invariant failure rather than a position heuristic.
+ */
+declare const cloneDocumentWithParagraphPropertySources: (document: document_d_exports.Document) => document_d_exports.Document;
+declare const linkProseParagraphPropertySource: (proseParagraph: Node, sourceParagraph: document_d_exports.Paragraph) => void;
+type RecreateProseNodeOptions = {
+  attrs?: Node["attrs"];
+  content?: Fragment | Node | readonly Node[] | null;
+  marks?: readonly Mark[];
+};
+/** Rebuild a PM node and retain paragraph provenance when the node is one. */
+declare const recreateProseNodeWithParagraphPropertySource: (source: Node, options?: RecreateProseNodeOptions) => Node;
+type SetProseParagraphMarkupOptions = {
+  attrs: Node["attrs"];
+  ownership: "preserve" | "transfer-allocated-id";
+  pos: number;
+  transaction: Transaction;
+};
+/** Replace paragraph markup without losing its private parser-owner link. */
+declare const setProseParagraphMarkupWithPropertySource: ({ attrs, ownership, pos, transaction }: SetProseParagraphMarkupOptions) => void;
+/**
+ * Carry the parser-owned source identity across load-time paraId allocation.
+ * The generated id is safe to use later because it was assigned while the
+ * ProseMirror node still had an unambiguous source paragraph owner.
+ */
+declare const transferProseParagraphPropertySource: (target: Node, source: Node, paraId: string) => void;
+declare const linkParagraphPropertySourceCandidate: (target: document_d_exports.Paragraph, source: Node) => void;
+declare const getParagraphPropertySourceCandidate: (paragraph: document_d_exports.Paragraph) => document_d_exports.Paragraph | undefined;
+declare const getParagraphPropertySourceTransferId: (paragraph: document_d_exports.Paragraph) => string | undefined;
+//#endregion
+export { assignParagraphPropertySource, cloneDocumentWithParagraphPropertySources, cloneParagraphWithPropertySource, cloneParagraphWithoutPropertySource, copyParagraphPropertySource, getParagraphPropertySource, getParagraphPropertySourceCandidate, getParagraphPropertySourceTransferId, linkParagraphPropertySourceCandidate, linkProseParagraphPropertySource, recreateProseNodeWithParagraphPropertySource, setProseParagraphMarkupWithPropertySource, transferProseParagraphPropertySource };

package/dist/docx/paragraphPropertySource.js

@@ -0,0 +1,113 @@
+import { visitDocxParagraphs } from "./paragraphTraversal.js";
+import { panic } from "better-result";
+//#region src/docx/paragraphPropertySource.ts
+const paragraphPropertySources = /* @__PURE__ */ new WeakMap();
+const paragraphPropertySourceOwners = /* @__PURE__ */ new WeakMap();
+const proseParagraphSourceOwners = /* @__PURE__ */ new WeakMap();
+const paragraphPropertySourceCandidates = /* @__PURE__ */ new WeakMap();
+const paragraphPropertySourceTransferIds = /* @__PURE__ */ new WeakMap();
+const assignParagraphPropertySource = (paragraph, source) => {
+	paragraphPropertySources.set(paragraph, source);
+	paragraphPropertySourceOwners.set(paragraph, paragraph);
+};
+const getParagraphPropertySource = (paragraph) => paragraphPropertySources.get(paragraph);
+const copyParagraphPropertySource = (target, source) => {
+	const propertySource = paragraphPropertySources.get(source);
+	if (propertySource) {
+		paragraphPropertySources.set(target, { ...propertySource });
+		paragraphPropertySourceOwners.set(target, paragraphPropertySourceOwners.get(source) ?? source);
+	}
+	const transferId = paragraphPropertySourceTransferIds.get(source);
+	if (transferId) paragraphPropertySourceTransferIds.set(target, transferId);
+	const candidate = paragraphPropertySourceCandidates.get(source);
+	if (candidate) paragraphPropertySourceCandidates.set(target, candidate);
+};
+/** Clone a paragraph while deliberately retaining its parsed `w:pPr` owner. */
+const cloneParagraphWithPropertySource = (paragraph, overrides) => {
+	const cloned = {
+		...paragraph,
+		...overrides
+	};
+	copyParagraphPropertySource(cloned, paragraph);
+	return cloned;
+};
+/** Clone a paragraph whose formatting provenance is deliberately no longer applicable. */
+const cloneParagraphWithoutPropertySource = (paragraph, overrides) => ({
+	...paragraph,
+	...overrides
+});
+const paragraphsIn = (document) => {
+	const paragraphs = [];
+	visitDocxParagraphs({
+		documentBody: document.package.document,
+		headers: document.package.headers,
+		footers: document.package.footers,
+		footnotes: document.package.footnotes,
+		endnotes: document.package.endnotes
+	}, (paragraph) => paragraphs.push(paragraph));
+	return paragraphs;
+};
+/**
+* Deep-clone a document and transfer each private paragraph capture across the
+* exact graph clone. `structuredClone` preserves graph topology, so any count
+* mismatch is an internal invariant failure rather than a position heuristic.
+*/
+const cloneDocumentWithParagraphPropertySources = (document) => {
+	const cloned = structuredClone(document);
+	const sources = paragraphsIn(document);
+	const targets = paragraphsIn(cloned);
+	if (sources.length !== targets.length) panic("The cloned document changed paragraph graph ownership.");
+	for (const [index, source] of sources.entries()) {
+		const target = targets.at(index);
+		if (!target) panic("The cloned document lost a paragraph owner.");
+		copyParagraphPropertySource(target, source);
+	}
+	return cloned;
+};
+const linkProseParagraphPropertySource = (proseParagraph, sourceParagraph) => {
+	if (paragraphPropertySources.has(sourceParagraph)) proseParagraphSourceOwners.set(proseParagraph, paragraphPropertySourceOwners.get(sourceParagraph) ?? sourceParagraph);
+};
+/** Carry a parser-linked paragraph owner across an immutable PM node rebuild. */
+const copyProseParagraphPropertySource = (target, source) => {
+	if (target.type.name !== "paragraph" || source.type.name !== "paragraph") return;
+	const sourceOwner = proseParagraphSourceOwners.get(source);
+	if (sourceOwner) proseParagraphSourceOwners.set(target, sourceOwner);
+};
+/** Rebuild a PM node and retain paragraph provenance when the node is one. */
+const recreateProseNodeWithParagraphPropertySource = (source, options = {}) => {
+	const target = source.type.create(options.attrs ?? source.attrs, options.content === void 0 ? source.content : options.content, options.marks ?? source.marks);
+	copyProseParagraphPropertySource(target, source);
+	return target;
+};
+/** Replace paragraph markup without losing its private parser-owner link. */
+const setProseParagraphMarkupWithPropertySource = ({ attrs, ownership, pos, transaction }) => {
+	const source = transaction.doc.nodeAt(pos);
+	transaction.setNodeMarkup(pos, void 0, attrs);
+	const target = transaction.doc.nodeAt(pos);
+	if (!source || !target) return;
+	if (ownership === "preserve") {
+		copyProseParagraphPropertySource(target, source);
+		return;
+	}
+	const paraId = target.attrs["paraId"];
+	if (typeof paraId === "string") transferProseParagraphPropertySource(target, source, paraId);
+};
+/**
+* Carry the parser-owned source identity across load-time paraId allocation.
+* The generated id is safe to use later because it was assigned while the
+* ProseMirror node still had an unambiguous source paragraph owner.
+*/
+const transferProseParagraphPropertySource = (target, source, paraId) => {
+	const sourceOwner = proseParagraphSourceOwners.get(source);
+	if (!sourceOwner) return;
+	proseParagraphSourceOwners.set(target, sourceOwner);
+	paragraphPropertySourceTransferIds.set(sourceOwner, paraId);
+};
+const linkParagraphPropertySourceCandidate = (target, source) => {
+	const sourceOwner = proseParagraphSourceOwners.get(source);
+	if (sourceOwner) paragraphPropertySourceCandidates.set(target, sourceOwner);
+};
+const getParagraphPropertySourceCandidate = (paragraph) => paragraphPropertySourceCandidates.get(paragraph);
+const getParagraphPropertySourceTransferId = (paragraph) => paragraphPropertySourceTransferIds.get(paragraph);
+//#endregion
+export { assignParagraphPropertySource, cloneDocumentWithParagraphPropertySources, cloneParagraphWithPropertySource, cloneParagraphWithoutPropertySource, copyParagraphPropertySource, getParagraphPropertySource, getParagraphPropertySourceCandidate, getParagraphPropertySourceTransferId, linkParagraphPropertySourceCandidate, linkProseParagraphPropertySource, recreateProseNodeWithParagraphPropertySource, setProseParagraphMarkupWithPropertySource, transferProseParagraphPropertySource };

package/dist/docx/paragraphTraversal.js

@@ -1,41 +1,37 @@
 //#region src/docx/paragraphTraversal.ts
 /** Visit every run directly owned by a paragraph's inline-content tree. */
 const visitParagraphRuns = (paragraph, visit) => {
-	const visitRun = (run) => {
-		visit(run);
-	};
-	const visitHyperlink = (hyperlink) => {
-		for (const child of hyperlink.children) if (child.type === "run") visitRun(child);
-	};
-	const visitInlineContent = (content) => {
-		for (const child of content) {
-			if (child.type === "run") {
-				visitRun(child);
-				continue;
-			}
-			if (child.type === "hyperlink") visitHyperlink(child);
-		}
-	};
 	const visitParagraphContent = (content) => {
-		if (content.type === "run") {
-			visitRun(content);
-			return;
-		}
-		if (content.type === "hyperlink") {
-			visitHyperlink(content);
-			return;
-		}
-		if (content.type === "simpleField" || content.type === "insertion" || content.type === "deletion" || content.type === "moveFrom" || content.type === "moveTo") {
-			visitInlineContent(content.content);
-			return;
-		}
-		if (content.type === "inlineSdt") {
-			for (const child of content.content) visitParagraphContent(child);
-			return;
-		}
-		if (content.type === "complexField") {
-			for (const run of content.fieldCode) visitRun(run);
-			for (const run of content.fieldResult) visitRun(run);
+		switch (content.type) {
+			case "run":
+				visit(content);
+				return;
+			case "hyperlink":
+				for (const child of content.children) visitParagraphContent(child);
+				return;
+			case "simpleField":
+			case "insertion":
+			case "deletion":
+			case "moveFrom":
+			case "moveTo":
+			case "inlineSdt":
+				for (const child of content.content) visitParagraphContent(child);
+				return;
+			case "complexField":
+				for (const run of content.fieldCode) visit(run);
+				for (const run of content.fieldResult) visit(run);
+				return;
+			case "bookmarkStart":
+			case "bookmarkEnd":
+			case "commentRangeStart":
+			case "commentRangeEnd":
+			case "commentReference":
+			case "moveFromRangeStart":
+			case "moveFromRangeEnd":
+			case "moveToRangeStart":
+			case "moveToRangeEnd":
+			case "mathEquation": return;
+			default: return content;
 		}
 	};
 	for (const content of paragraph.content) visitParagraphContent(content);

package/dist/docx/rezip.d.ts

@@ -28,14 +28,6 @@ type RepackOptions = {
   /** Changed note paragraphs that must be serialized even without source paraIds. */
   changedNoteParaIds?: ReadonlySet<string>;
 };
-/**
- * Repack a Document into a valid DOCX file
- *
- * @param doc - Document with modified content
- * @param options - Optional repack options
- * @returns Promise resolving to DOCX as ArrayBuffer
- * @throws {Error} if document has no original buffer for round-trip
- */
 declare function repackDocx(doc: document_d_exports.Document, options?: RepackOptions): Promise<ArrayBuffer>;
 /**
  * Repack a Document using raw content for more control

package/dist/docx/rezip.js

@@ -1,3 +1,4 @@
+import { consumeTrackedSectionEndpointRemoval } from "../internal/sectionEndpointResolution.js";
 import { isAllowedExternalWatermarkImageUrl } from "../watermark/index.js";
 import { normalizeAppVersionInExtendedProperties } from "./appVersionNormalization.js";
 import { withoutOrphanCommentRanges } from "./commentRangeIntegrity.js";
@@ -115,11 +116,34 @@ const extractHeaderFooterReferences = (xml) => {
 const hasParsedHeaderFooterPart = (doc, ref) => {
 	return (ref.element === "headerReference" ? doc.package.headers : doc.package.footers)?.has(ref.rId) ?? false;
 };
-function assertDocumentPackageFidelity(originalDocumentXml, serializedDocumentXml, doc) {
+const headerFooterReferenceKey = ({ element, type, rId }) => `${element}:${type}:${rId}`;
+const incrementReferenceCount = (counts, key) => {
+	counts.set(key, (counts.get(key) ?? 0) + 1);
+};
+const consumeReferenceCount = (counts, key) => {
+	const count = counts.get(key) ?? 0;
+	if (count === 0) return false;
+	counts.set(key, count - 1);
+	return true;
+};
+function assertDocumentPackageFidelity(originalDocumentXml, serializedDocumentXml, doc, sectionEndpointRemoval) {
 	const originalSectionCount = countDocumentSections(originalDocumentXml);
-	if (countDocumentSections(serializedDocumentXml) < originalSectionCount) throw new DocxPackageFidelityError("Full DOCX repack would drop section properties. Use selective patching instead.");
-	const serializedRefs = new Set(extractHeaderFooterReferences(serializedDocumentXml).map((ref) => `${ref.element}:${ref.type}:${ref.rId}`));
-	if (extractHeaderFooterReferences(originalDocumentXml).filter((ref) => hasParsedHeaderFooterPart(doc, ref) && !serializedRefs.has(`${ref.element}:${ref.type}:${ref.rId}`)).length > 0) throw new DocxPackageFidelityError("Full DOCX repack would drop header/footer references. Use selective patching instead.");
+	const serializedSectionCount = countDocumentSections(serializedDocumentXml);
+	const trackedRemovedSectionCount = sectionEndpointRemoval ? sectionEndpointRemoval.sourceParagraphEndpointCount - sectionEndpointRemoval.expectedParagraphEndpointCount : 0;
+	const exactTrackedSectionRemoval = trackedRemovedSectionCount > 0 && originalSectionCount - trackedRemovedSectionCount === serializedSectionCount && serializedSectionCount < originalSectionCount;
+	if (serializedSectionCount < originalSectionCount && !exactTrackedSectionRemoval) throw new DocxPackageFidelityError("Full DOCX repack would drop section properties. Use selective patching instead.");
+	const serializedReferenceCounts = /* @__PURE__ */ new Map();
+	for (const reference of extractHeaderFooterReferences(serializedDocumentXml)) incrementReferenceCount(serializedReferenceCounts, headerFooterReferenceKey(reference));
+	const removedReferenceCounts = /* @__PURE__ */ new Map();
+	if (exactTrackedSectionRemoval && sectionEndpointRemoval) for (const { part, type, relationshipId } of sectionEndpointRemoval.removedReferences) incrementReferenceCount(removedReferenceCounts, `${part}Reference:${type}:${relationshipId}`);
+	const missingRefs = [];
+	for (const reference of extractHeaderFooterReferences(originalDocumentXml)) {
+		if (!hasParsedHeaderFooterPart(doc, reference)) continue;
+		const key = headerFooterReferenceKey(reference);
+		if (consumeReferenceCount(serializedReferenceCounts, key) || consumeReferenceCount(removedReferenceCounts, key)) continue;
+		missingRefs.push(reference);
+	}
+	if (missingRefs.length > 0) throw new DocxPackageFidelityError("Full DOCX repack would drop header/footer references. Use selective patching instead.");
 }
 async function serializeCommentsToZip(doc, zip, compressionLevel) {
 	const comments = doc.package.document.comments ?? [];
@@ -488,7 +512,7 @@ const cloneDocxZip = (source) => {
 	clone.files = { ...source.files };
 	return clone;
 };
-const finishRepack = async ({ document, originalZip, outputZip, originalDocumentXml, originalCorePropertiesXml, compressionLevel, updateModifiedDate, modifiedBy, changedNoteParaIds }) => {
+const finishRepack = async ({ document, originalZip, outputZip, originalDocumentXml, originalCorePropertiesXml, compressionLevel, updateModifiedDate, modifiedBy, changedNoteParaIds, sectionEndpointRemoval }) => {
 	await materializeNewHeaderFooterParts(document, outputZip, compressionLevel);
 	const parts = collectDocxParts(document, outputZip);
 	await processNewImages(parts, outputZip, compressionLevel);
@@ -496,7 +520,7 @@ const finishRepack = async ({ document, originalZip, outputZip, originalDocument
 	assertValidFolioDocumentModel(document, "Cannot repack invalid DOCX document model");
 	applyReplyThreadMarkers(document);
 	const documentXml = serializeDocument(document, originalDocumentXml === void 0 ? void 0 : readRootNamespaceBindings(originalDocumentXml));
-	if (originalDocumentXml) assertDocumentPackageFidelity(originalDocumentXml, documentXml, document);
+	if (originalDocumentXml) assertDocumentPackageFidelity(originalDocumentXml, documentXml, document, sectionEndpointRemoval);
 	outputZip.file("word/document.xml", documentXml, {
 		compression: "DEFLATE",
 		compressionOptions: { level: compressionLevel }
@@ -526,15 +550,7 @@ const finishRepack = async ({ document, originalZip, outputZip, originalDocument
 	}
 	return generateDocxZip(outputZip, compressionLevel);
 };
-/**
-* Repack a Document into a valid DOCX file
-*
-* @param doc - Document with modified content
-* @param options - Optional repack options
-* @returns Promise resolving to DOCX as ArrayBuffer
-* @throws {Error} if document has no original buffer for round-trip
-*/
-async function repackDocx(doc, options = {}) {
+async function repackDocxWithSectionEndpointRemoval({ document: doc, options, sectionEndpointRemoval }) {
 	if (!doc.originalBuffer) panic("Cannot repack document: no original buffer for round-trip. Use createDocx() for new documents.");
 	const { compressionLevel = 6, updateModifiedDate = true, modifiedBy, changedNoteParaIds } = options;
 	const exportDocument = withoutOrphanCommentRanges(doc);
@@ -551,7 +567,16 @@ async function repackDocx(doc, options = {}) {
 		compressionLevel,
 		updateModifiedDate,
 		...modifiedBy !== void 0 ? { modifiedBy } : {},
-		...changedNoteParaIds !== void 0 ? { changedNoteParaIds } : {}
+		...changedNoteParaIds !== void 0 ? { changedNoteParaIds } : {},
+		...sectionEndpointRemoval !== void 0 ? { sectionEndpointRemoval } : {}
+	});
+}
+function repackDocx(doc, options = {}) {
+	const sectionEndpointRemoval = consumeTrackedSectionEndpointRemoval(doc);
+	return repackDocxWithSectionEndpointRemoval({
+		document: doc,
+		options,
+		...sectionEndpointRemoval ? { sectionEndpointRemoval } : {}
 	});
 }
 /**

package/dist/docx/runConsolidator.js

@@ -1,3 +1,4 @@
+import { cloneParagraphWithPropertySource } from "./paragraphPropertySource.js";
 //#region src/docx/runConsolidator.ts
 /**
 * Check if two TextFormatting objects are equivalent
@@ -193,10 +194,7 @@ function consolidateParagraphContent(content) {
 */
 function consolidateParagraph(paragraph) {
 	if (paragraph.content.length === 0) return paragraph;
-	return {
-		...paragraph,
-		content: consolidateParagraphContent(paragraph.content)
-	};
+	return cloneParagraphWithPropertySource(paragraph, { content: consolidateParagraphContent(paragraph.content) });
 }
 /**
 * Get the number of runs in a paragraph (for debugging/metrics)

package/dist/docx/runParser.js

@@ -7,10 +7,11 @@ import { parseShapeFromDrawing, shouldPreserveRawShapeDrawing } from "./shapePar
 import { isTextBoxDrawing } from "./textBoxParser.js";
 import { requiresXmlSpacePreserve } from "./textWhitespace.js";
 import { resolveThemeFontRef } from "./themeParser.js";
+import { parsePropertyChangeInfo } from "./trackedChangeInfo.js";
 import { captureVerbatimXml } from "./verbatimCapture.js";
 import { parseVmlImageContent } from "./vmlImageParser.js";
 import { cloneWithXmlnsDeclarations, findAllDeep, findChild, findChildren, getAttribute, getChildElements, getLocalName, getTextContent, mergeXmlnsDeclarations, parseBooleanElement, parseNumericAttribute } from "./xmlParser.js";
-import { DRAWING_RAW_XML_MODES, normalizeRevisionId } from "@stll/docx-core/model";
+import { DRAWING_RAW_XML_MODES } from "@stll/docx-core/model";
 //#region src/docx/runParser.ts
 /**
 * Sanity cap on `w:lang` `@w:val`/`@w:eastAsia`/`@w:bidi` tag length. BCP-47
@@ -40,9 +41,11 @@ function parseShadingProperties(shd) {
 	if (!shd) return;
 	const props = {};
 	const color = getAttribute(shd, "w", "color");
-	if (color && color !== "auto" && isValidHexColor(color)) props.color = { rgb: color };
+	if (color === "auto") props.color = { auto: true };
+	else if (color && isValidHexColor(color)) props.color = { rgb: color };
 	const fill = getAttribute(shd, "w", "fill");
-	if (fill && fill !== "auto" && isValidHexColor(fill)) props.fill = { rgb: fill };
+	if (fill === "auto") props.fill = { auto: true };
+	else if (fill && isValidHexColor(fill)) props.fill = { rgb: fill };
 	const validatedThemeFill = narrowEnum(getAttribute(shd, "w", "themeFill"), ThemeColorSlotSchema);
 	if (validatedThemeFill) {
 		if (!props.fill) props.fill = {};
@@ -341,20 +344,6 @@ function parseRunProperties(rPr, theme, _styles) {
 	}
 	return Object.keys(formatting).length > 0 ? formatting : void 0;
 }
-function parsePropertyChangeInfo(changeElement) {
-	const rawId = getAttribute(changeElement, "w", "id");
-	const parsedId = rawId ? Number.parseInt(rawId, 10) : 0;
-	const author = (getAttribute(changeElement, "w", "author") ?? "").trim();
-	const date = (getAttribute(changeElement, "w", "date") ?? "").trim();
-	const rsid = (getAttribute(changeElement, "w", "rsid") ?? "").trim();
-	const info = {
-		id: normalizeRevisionId(parsedId),
-		author: author.length > 0 ? author : "Unknown"
-	};
-	if (date.length > 0) info.date = date;
-	if (rsid.length > 0) info.rsid = rsid;
-	return info;
-}
 function parseRunPropertyChanges(rPr, theme, styles, currentFormatting) {
 	if (!rPr) return;
 	const changes = findChildren(rPr, "w", "rPrChange").map((changeElement) => {