@stll/folio-core 0.0.1-placeholder.0 → 0.1.1

package/dist/docx/serializer/paragraphSerializer.js

@@ -0,0 +1,559 @@
+import { numPrEqual } from "../numberingParser.js";
+import { escapeXml, intAttr } from "./xmlUtils.js";
+import { reconcileRawSdtPr } from "../sdtPropertiesPatch.js";
+import { serializeBorder } from "./borderSerializer.js";
+import { serializeRun, serializeTextFormatting } from "./runSerializer.js";
+import { serializeSectionProperties } from "./sectionPropertiesSerializer.js";
+//#region src/docx/serializer/paragraphSerializer.ts
+/**
+* Serialize paragraph borders (w:pBdr)
+*/
+function serializeParagraphBorders(borders) {
+	if (!borders) return "";
+	const parts = [];
+	if (borders.top) {
+		const topXml = serializeBorder(borders.top, "top");
+		if (topXml) parts.push(topXml);
+	}
+	if (borders.left) {
+		const leftXml = serializeBorder(borders.left, "left");
+		if (leftXml) parts.push(leftXml);
+	}
+	if (borders.bottom) {
+		const bottomXml = serializeBorder(borders.bottom, "bottom");
+		if (bottomXml) parts.push(bottomXml);
+	}
+	if (borders.right) {
+		const rightXml = serializeBorder(borders.right, "right");
+		if (rightXml) parts.push(rightXml);
+	}
+	if (borders.between) {
+		const betweenXml = serializeBorder(borders.between, "between");
+		if (betweenXml) parts.push(betweenXml);
+	}
+	if (borders.bar) {
+		const barXml = serializeBorder(borders.bar, "bar");
+		if (barXml) parts.push(barXml);
+	}
+	if (parts.length === 0) return "";
+	return `<w:pBdr>${parts.join("")}</w:pBdr>`;
+}
+/**
+* Serialize shading properties (w:shd)
+*/
+function serializeShading(shading) {
+	if (!shading) return "";
+	const attrs = [];
+	if (shading.pattern) attrs.push(`w:val="${shading.pattern}"`);
+	else attrs.push("w:val=\"clear\"");
+	if (shading.color?.rgb) attrs.push(`w:color="${shading.color.rgb}"`);
+	else if (shading.color?.auto) attrs.push("w:color=\"auto\"");
+	if (shading.fill?.rgb) attrs.push(`w:fill="${shading.fill.rgb}"`);
+	else if (shading.fill?.auto) attrs.push("w:fill=\"auto\"");
+	if (shading.fill?.themeColor) attrs.push(`w:themeFill="${shading.fill.themeColor}"`);
+	if (shading.fill?.themeTint) attrs.push(`w:themeFillTint="${shading.fill.themeTint}"`);
+	if (shading.fill?.themeShade) attrs.push(`w:themeFillShade="${shading.fill.themeShade}"`);
+	if (attrs.length === 0) return "";
+	return `<w:shd ${attrs.join(" ")}/>`;
+}
+/**
+* Serialize tab stops (w:tabs)
+*/
+function serializeTabStops(tabs) {
+	if (!tabs || tabs.length === 0) return "";
+	return `<w:tabs>${tabs.map((tab) => {
+		const attrs = [`w:val="${tab.alignment}"`, `w:pos="${intAttr(tab.position)}"`];
+		if (tab.leader && tab.leader !== "none") attrs.push(`w:leader="${tab.leader}"`);
+		return `<w:tab ${attrs.join(" ")}/>`;
+	}).join("")}</w:tabs>`;
+}
+/**
+* Serialize spacing properties (w:spacing)
+*/
+function serializeSpacing(formatting) {
+	const attrs = [];
+	if (formatting.spaceBefore !== void 0) attrs.push(`w:before="${intAttr(formatting.spaceBefore)}"`);
+	if (formatting.spaceAfter !== void 0) attrs.push(`w:after="${intAttr(formatting.spaceAfter)}"`);
+	if (formatting.lineSpacing !== void 0) attrs.push(`w:line="${intAttr(formatting.lineSpacing)}"`);
+	if (formatting.lineSpacingRule) attrs.push(`w:lineRule="${formatting.lineSpacingRule}"`);
+	if (formatting.beforeAutospacing !== void 0) attrs.push(`w:beforeAutospacing="${formatting.beforeAutospacing ? "1" : "0"}"`);
+	if (formatting.afterAutospacing !== void 0) attrs.push(`w:afterAutospacing="${formatting.afterAutospacing ? "1" : "0"}"`);
+	if (attrs.length === 0) return "";
+	return `<w:spacing ${attrs.join(" ")}/>`;
+}
+/**
+* Serialize indentation properties (w:ind)
+*/
+function serializeIndentation(formatting) {
+	const attrs = [];
+	if (formatting.indentLeft !== void 0) attrs.push(`w:left="${intAttr(formatting.indentLeft)}"`);
+	if (formatting.indentRight !== void 0) attrs.push(`w:right="${intAttr(formatting.indentRight)}"`);
+	if (formatting.indentFirstLine !== void 0) {
+		if (formatting.hangingIndent) attrs.push(`w:hanging="${intAttr(Math.abs(formatting.indentFirstLine))}"`);
+		else if (formatting.indentFirstLine !== 0) attrs.push(`w:firstLine="${intAttr(formatting.indentFirstLine)}"`);
+	}
+	if (attrs.length === 0) return "";
+	return `<w:ind ${attrs.join(" ")}/>`;
+}
+/**
+* Serialize numbering properties (w:numPr)
+*/
+function serializeNumbering(numPr) {
+	if (!numPr) return "";
+	const parts = [];
+	if (numPr.ilvl !== void 0) parts.push(`<w:ilvl w:val="${intAttr(numPr.ilvl)}"/>`);
+	if (numPr.numId !== void 0) parts.push(`<w:numId w:val="${intAttr(numPr.numId)}"/>`);
+	if (parts.length === 0) return "";
+	return `<w:numPr>${parts.join("")}</w:numPr>`;
+}
+/**
+* Serialize frame properties (w:framePr)
+*/
+function serializeFrameProperties(frame) {
+	if (!frame) return "";
+	const attrs = [];
+	if (frame.width !== void 0) attrs.push(`w:w="${intAttr(frame.width)}"`);
+	if (frame.height !== void 0) attrs.push(`w:h="${intAttr(frame.height)}"`);
+	if (frame.hAnchor) attrs.push(`w:hAnchor="${frame.hAnchor}"`);
+	if (frame.vAnchor) attrs.push(`w:vAnchor="${frame.vAnchor}"`);
+	if (frame.x !== void 0) attrs.push(`w:x="${frame.x}"`);
+	if (frame.y !== void 0) attrs.push(`w:y="${frame.y}"`);
+	if (frame.xAlign) attrs.push(`w:xAlign="${frame.xAlign}"`);
+	if (frame.yAlign) attrs.push(`w:yAlign="${frame.yAlign}"`);
+	if (frame.wrap) attrs.push(`w:wrap="${frame.wrap}"`);
+	if (attrs.length === 0) return "";
+	return `<w:framePr ${attrs.join(" ")}/>`;
+}
+/**
+* Serialize paragraph formatting properties to w:pPr XML
+*/
+function serializeTrackedChangeAttrs(info) {
+	const parts = [`w:id="${info.id}"`, `w:author="${escapeXml(info.author)}"`];
+	if (info.date !== void 0) parts.push(`w:date="${escapeXml(info.date)}"`);
+	return parts.join(" ");
+}
+function serializeParagraphMarkChange(mark) {
+	const attrs = serializeTrackedChangeAttrs(mark.info);
+	return `<w:${mark.kind} ${attrs}/>`;
+}
+function serializeParagraphFormatting(formatting, propertyChanges, pPrMark) {
+	const parts = [];
+	const pushToggle = (name, value) => {
+		if (value === true) parts.push(`<w:${name}/>`);
+		else if (value === false) parts.push(`<w:${name} w:val="0"/>`);
+	};
+	if (formatting) {
+		if (formatting.styleId) parts.push(`<w:pStyle w:val="${escapeXml(formatting.styleId)}"/>`);
+		pushToggle("keepNext", formatting.keepNext);
+		pushToggle("keepLines", formatting.keepLines);
+		pushToggle("contextualSpacing", formatting.contextualSpacing);
+		pushToggle("pageBreakBefore", formatting.pageBreakBefore);
+		const frameXml = serializeFrameProperties(formatting.frame);
+		if (frameXml) parts.push(frameXml);
+		pushToggle("widowControl", formatting.widowControl);
+		const numPrXml = formatting.numPrFromStyle != null && numPrEqual(formatting.numPr, formatting.numPrFromStyle) ? "" : serializeNumbering(formatting.numPr);
+		if (numPrXml) parts.push(numPrXml);
+		const bordersXml = serializeParagraphBorders(formatting.borders);
+		if (bordersXml) parts.push(bordersXml);
+		const shadingXml = serializeShading(formatting.shading);
+		if (shadingXml) parts.push(shadingXml);
+		const tabsXml = serializeTabStops(formatting.tabs);
+		if (tabsXml) parts.push(tabsXml);
+		pushToggle("suppressLineNumbers", formatting.suppressLineNumbers);
+		pushToggle("suppressAutoHyphens", formatting.suppressAutoHyphens);
+		const spacingXml = serializeSpacing(formatting);
+		if (spacingXml) parts.push(spacingXml);
+		const indXml = serializeIndentation(formatting);
+		if (indXml) parts.push(indXml);
+		pushToggle("bidi", formatting.bidi);
+		if (formatting.alignment) parts.push(`<w:jc w:val="${formatting.alignment}"/>`);
+		if (formatting.outlineLevel !== void 0) parts.push(`<w:outlineLvl w:val="${formatting.outlineLevel}"/>`);
+		if (pPrMark || formatting.runProperties || formatting.runInWithNext) {
+			const fullInner = `${pPrMark ? serializeParagraphMarkChange(pPrMark) : ""}${formatting.runProperties ? extractRPrInner(serializeTextFormatting(formatting.runProperties)) : ""}${formatting.runInWithNext ? "<w:specVanish/>" : ""}`;
+			if (fullInner.length > 0) parts.push(`<w:rPr>${fullInner}</w:rPr>`);
+		}
+	} else if (pPrMark) parts.push(`<w:rPr>${serializeParagraphMarkChange(pPrMark)}</w:rPr>`);
+	if (propertyChanges && propertyChanges.length > 0) parts.push(...propertyChanges.map((change) => serializeParagraphPropertyChange(change)));
+	if (parts.length === 0) return "";
+	return `<w:pPr>${parts.join("")}</w:pPr>`;
+}
+function extractPPrInner(pPrXml) {
+	if (!pPrXml.startsWith("<w:pPr>") || !pPrXml.endsWith("</w:pPr>")) return "";
+	return pPrXml.slice(7, -8);
+}
+/**
+* Strip the outer `<w:rPr>...</w:rPr>` wrapper so callers can splice
+* additional rPr children (e.g. `<w:specVanish/>`) and re-emit a
+* single rPr element.
+*/
+function extractRPrInner(rPrXml) {
+	if (!rPrXml.startsWith("<w:rPr>") || !rPrXml.endsWith("</w:rPr>")) return "";
+	return rPrXml.slice(7, -8);
+}
+function serializeParagraphPropertyChange(change) {
+	const normalizedId = Number.isInteger(change.info.id) && change.info.id >= 0 ? change.info.id : 0;
+	const authorCandidate = typeof change.info.author === "string" ? change.info.author.trim() : "";
+	const normalizedAuthor = authorCandidate.length > 0 ? authorCandidate : "Unknown";
+	const normalizedDate = typeof change.info.date === "string" ? change.info.date.trim() : void 0;
+	const normalizedRsid = typeof change.info.rsid === "string" ? change.info.rsid.trim() : void 0;
+	const attrs = [`w:id="${normalizedId}"`, `w:author="${escapeXml(normalizedAuthor)}"`];
+	if (normalizedDate) attrs.push(`w:date="${escapeXml(normalizedDate)}"`);
+	if (normalizedRsid) attrs.push(`w:rsid="${escapeXml(normalizedRsid)}"`);
+	const previousPPrInner = extractPPrInner(serializeParagraphFormatting(change.previousFormatting) || "<w:pPr/>");
+	const normalizedPreviousPPr = previousPPrInner.length > 0 ? `<w:pPr>${previousPPrInner}</w:pPr>` : "<w:pPr/>";
+	return `<w:pPrChange ${attrs.join(" ")}>${normalizedPreviousPPr}</w:pPrChange>`;
+}
+/**
+* Serialize a hyperlink (w:hyperlink)
+*/
+function serializeHyperlink(hyperlink) {
+	const attrs = [];
+	if (hyperlink.rId) attrs.push(`r:id="${hyperlink.rId}"`);
+	if (hyperlink.anchor) attrs.push(`w:anchor="${escapeXml(hyperlink.anchor)}"`);
+	if (hyperlink.tooltip) attrs.push(`w:tooltip="${escapeXml(hyperlink.tooltip)}"`);
+	if (hyperlink.target) attrs.push(`w:tgtFrame="${escapeXml(hyperlink.target)}"`);
+	if (hyperlink.history === true) attrs.push("w:history=\"1\"");
+	else if (hyperlink.history === false) attrs.push("w:history=\"0\"");
+	if (hyperlink.docLocation) attrs.push(`w:docLocation="${escapeXml(hyperlink.docLocation)}"`);
+	const childrenXml = hyperlink.children.map((child) => {
+		if (child.type === "run") return serializeRun(child);
+		if (child.type === "bookmarkStart") return serializeBookmarkStart(child);
+		return serializeBookmarkEnd(child);
+	}).join("");
+	return `<w:hyperlink${attrs.length > 0 ? ` ${attrs.join(" ")}` : ""}>${childrenXml}</w:hyperlink>`;
+}
+/**
+* Serialize bookmark start (w:bookmarkStart)
+*/
+function serializeBookmarkStart(bookmark) {
+	const attrs = [`w:id="${bookmark.id}"`, `w:name="${escapeXml(bookmark.name)}"`];
+	if (bookmark.colFirst !== void 0) attrs.push(`w:colFirst="${bookmark.colFirst}"`);
+	if (bookmark.colLast !== void 0) attrs.push(`w:colLast="${bookmark.colLast}"`);
+	return `<w:bookmarkStart ${attrs.join(" ")}/>`;
+}
+/**
+* Serialize bookmark end (w:bookmarkEnd)
+*/
+function serializeBookmarkEnd(bookmark) {
+	return `<w:bookmarkEnd w:id="${bookmark.id}"/>`;
+}
+/**
+* Serialize a simple field as a complex field (fldChar begin/separate/end).
+* Complex field format is more widely supported by OOXML consumers
+* (Google Docs, Apple Pages) than w:fldSimple.
+*/
+function serializeSimpleField(field) {
+	const parts = [];
+	const firstRun = field.content.find((c) => c.type === "run");
+	const rPrXml = firstRun?.formatting ? serializeTextFormatting(firstRun.formatting) : "";
+	const beginAttrs = ["w:fldCharType=\"begin\""];
+	if (field.fldLock) beginAttrs.push("w:fldLock=\"true\"");
+	parts.push(`<w:r>${rPrXml}<w:fldChar ${beginAttrs.join(" ")}/></w:r>`);
+	const spaceAttr = field.instruction.startsWith(" ") || field.instruction.endsWith(" ") || field.instruction.includes("  ") ? " xml:space=\"preserve\"" : "";
+	parts.push(`<w:r>${rPrXml}<w:instrText${spaceAttr}>${escapeXml(field.instruction)}</w:instrText></w:r>`);
+	parts.push(`<w:r>${rPrXml}<w:fldChar w:fldCharType="separate"/></w:r>`);
+	for (const item of field.content) if (item.type === "run") parts.push(serializeRun(item));
+	parts.push(`<w:r>${rPrXml}<w:fldChar w:fldCharType="end"/></w:r>`);
+	return parts.join("");
+}
+/**
+* Serialize a complex field
+* Complex fields are represented by multiple runs with fldChar elements,
+* so we convert them back to that structure
+*/
+function serializeComplexField(field) {
+	const parts = [];
+	const structuralFormatting = field.formatting ?? field.fieldResult[0]?.formatting;
+	const rPrXml = structuralFormatting ? serializeTextFormatting(structuralFormatting) : "";
+	const beginAttrs = ["w:fldCharType=\"begin\""];
+	if (field.fldLock) beginAttrs.push("w:fldLock=\"true\"");
+	parts.push(`<w:r>${rPrXml}<w:fldChar ${beginAttrs.join(" ")}/></w:r>`);
+	if (field.fieldCode.length > 0) parts.push(...field.fieldCode.map((run) => serializeRun(run)));
+	else {
+		const spaceAttr = field.instruction.startsWith(" ") || field.instruction.endsWith(" ") || field.instruction.includes("  ") ? " xml:space=\"preserve\"" : "";
+		parts.push(`<w:r>${rPrXml}<w:instrText${spaceAttr}>${escapeXml(field.instruction)}</w:instrText></w:r>`);
+	}
+	parts.push(`<w:r>${rPrXml}<w:fldChar w:fldCharType="separate"/></w:r>`);
+	parts.push(...field.fieldResult.map((run) => serializeRun(run)));
+	parts.push(`<w:r>${rPrXml}<w:fldChar w:fldCharType="end"/></w:r>`);
+	return parts.join("");
+}
+/**
+* Synthesize a `<w:sdtPr>` from the modeled {@link SdtProperties}.
+*
+* Only reached for an inline SDT that carries no captured `rawPropertiesXml`
+* (constructed programmatically rather than parsed from a DOCX). Mirrors the
+* block-SDT fallback: emit `w:id` first so the parsed numeric id survives,
+* then the shared identity fields, then the type-defining marker.
+*/
+function synthesizeInlineSdtPr(props) {
+	const prParts = [];
+	if (typeof props.id === "number") prParts.push(`<w:id w:val="${props.id}"/>`);
+	if (props.alias) prParts.push(`<w:alias w:val="${escapeXml(props.alias)}"/>`);
+	if (props.tag) prParts.push(`<w:tag w:val="${escapeXml(props.tag)}"/>`);
+	if (props.lock && props.lock !== "unlocked") prParts.push(`<w:lock w:val="${props.lock}"/>`);
+	if (props.placeholder) prParts.push(`<w:placeholder><w:docPart w:val="${escapeXml(props.placeholder)}"/></w:placeholder>`);
+	if (props.showingPlaceholder) prParts.push("<w:showingPlcHdr/>");
+	switch (props.sdtType) {
+		case "plainText":
+			prParts.push("<w:text/>");
+			break;
+		case "date": {
+			const fullDateAttr = props.dateValueISO ? ` w:fullDate="${escapeXml(props.dateValueISO)}"` : "";
+			const formatChild = props.dateFormat ? `<w:dateFormat w:val="${escapeXml(props.dateFormat)}"/>` : "";
+			if (fullDateAttr || formatChild) prParts.push(`<w:date${fullDateAttr}>${formatChild}</w:date>`);
+			else prParts.push("<w:date/>");
+			break;
+		}
+		case "dropdown": {
+			const items = (props.listItems ?? []).map((i) => `<w:listItem w:displayText="${escapeXml(i.displayText)}" w:value="${escapeXml(i.value)}"/>`).join("");
+			prParts.push(`<w:dropDownList>${items}</w:dropDownList>`);
+			break;
+		}
+		case "comboBox": {
+			const items = (props.listItems ?? []).map((i) => `<w:listItem w:displayText="${escapeXml(i.displayText)}" w:value="${escapeXml(i.value)}"/>`).join("");
+			prParts.push(`<w:comboBox>${items}</w:comboBox>`);
+			break;
+		}
+		case "checkbox":
+			prParts.push(`<w14:checkbox><w14:checked w14:val="${props.checked ? "1" : "0"}"/></w14:checkbox>`);
+			break;
+		case "picture":
+			prParts.push("<w:picture/>");
+			break;
+		case "richText":
+		case "buildingBlockGallery":
+		case "group":
+		case "unknown": break;
+	}
+	return `<w:sdtPr>${prParts.join("")}</w:sdtPr>`;
+}
+/**
+* Serialize an inline SDT (w:sdt).
+*
+* Replays the captured `<w:sdtPr>` / `<w:sdtEndPr>` verbatim so unmodeled
+* OOXML features (`w:id`, `w:dataBinding`, `w15:*`, custom XML mappings)
+* survive the round-trip, mirroring the block-SDT serializer. Without this
+* the properties block was re-synthesized from the modeled projection alone,
+* silently dropping every unmodeled feature (and `w:sdtEndPr`) on save.
+*/
+function serializeInlineSdt(sdt) {
+	const props = sdt.properties;
+	const contentXml = sdt.content.map((item) => {
+		switch (item.type) {
+			case "run": return serializeRun(item);
+			case "hyperlink": return serializeHyperlink(item);
+			case "simpleField": return serializeSimpleField(item);
+			case "complexField": return serializeComplexField(item);
+			case "inlineSdt": return serializeInlineSdt(item);
+			case "mathEquation": return item.ommlXml || "";
+			default: return item;
+		}
+	}).join("");
+	const baseSdtPr = props.rawPropertiesXml ?? synthesizeInlineSdtPr(props);
+	const dateFullDate = props.sdtType === "date" && props.dateValueISO ? props.dateValueISO : void 0;
+	const dropdownLastValue = (props.sdtType === "dropdown" || props.sdtType === "comboBox") && typeof props.dropdownLastValue === "string" ? props.dropdownLastValue : void 0;
+	return `<w:sdt>${reconcileRawSdtPr(baseSdtPr, props, {
+		...dateFullDate !== void 0 ? { dateFullDate } : {},
+		...dropdownLastValue !== void 0 ? { dropdownLastValue } : {}
+	})}${props.rawEndPropertiesXml ?? ""}<w:sdtContent>${contentXml}</w:sdtContent></w:sdt>`;
+}
+function serializeMoveRangeStart(tag, marker) {
+	return `<w:${tag} ${[`w:id="${marker.id}"`, `w:name="${escapeXml(marker.name)}"`].join(" ")}/>`;
+}
+/**
+* Serialize a tracked change wrapper (ins/del/moveFrom/moveTo)
+*/
+function rewriteRunTextAsDeleted(xml) {
+	return xml.replace(/<w:t\b/gu, "<w:delText").replace(/<\/w:t>/gu, "</w:delText>").replace(/<w:instrText\b/gu, "<w:delInstrText").replace(/<\/w:instrText>/gu, "</w:delInstrText>");
+}
+function serializeTrackedChange(tag, change) {
+	const info = change.info;
+	const normalizedId = Number.isInteger(info.id) && info.id >= 0 ? info.id : 0;
+	const authorCandidate = typeof info.author === "string" ? info.author.trim() : "";
+	const normalizedAuthor = authorCandidate.length > 0 ? authorCandidate : "Unknown";
+	const normalizedDate = typeof info.date === "string" ? info.date.trim() : void 0;
+	const attrs = [`w:id="${normalizedId}"`, `w:author="${escapeXml(normalizedAuthor)}"`];
+	if (normalizedDate) attrs.push(`w:date="${escapeXml(normalizedDate)}"`);
+	const serializeDeletedRun = (run) => {
+		const xml = serializeRun(run);
+		if (!run.content.some((c) => c.type === "drawing" || c.type === "shape")) return rewriteRunTextAsDeleted(xml);
+		if (!run.content.some((c) => c.type !== "drawing" && c.type !== "shape")) return xml;
+		return run.content.map((content) => {
+			const contentXml = serializeRun({
+				...run,
+				content: [content]
+			});
+			if (content.type === "drawing" || content.type === "shape") return contentXml;
+			return rewriteRunTextAsDeleted(contentXml);
+		}).join("");
+	};
+	const contentXml = change.content.map((item) => {
+		if (item.type === "run") {
+			if (tag === "del" || tag === "moveFrom") return serializeDeletedRun(item);
+			return serializeRun(item);
+		}
+		return serializeHyperlink(item);
+	}).join("");
+	return `<w:${tag} ${attrs.join(" ")}>${contentXml}</w:${tag}>`;
+}
+/** Emit the `<w:commentReference>` run Word places after a comment range end. */
+function serializeCommentReferenceRun(id) {
+	return `<w:r><w:rPr><w:rStyle w:val="CommentReference"/></w:rPr><w:commentReference w:id="${id}"/></w:r>`;
+}
+/**
+* Serialize a single paragraph content item.
+*
+* `explicitCommentReferenceIds` holds the comment ids that already have their
+* own `commentReference` node in this paragraph (the parsed-from-Word shape).
+* For those, the `commentRangeEnd` marker must NOT also synthesize a reference
+* run, or a save→parse round-trip doubles the `<w:commentReference>`. The
+* editor (fromProseDoc) path emits range markers with no reference node, so the
+* synthetic run is still written when the id is absent from the set.
+*/
+function serializeParagraphContent(content, explicitCommentReferenceIds) {
+	switch (content.type) {
+		case "run": return serializeRun(content);
+		case "hyperlink": return serializeHyperlink(content);
+		case "bookmarkStart": return serializeBookmarkStart(content);
+		case "bookmarkEnd": return serializeBookmarkEnd(content);
+		case "simpleField": return serializeSimpleField(content);
+		case "complexField": return serializeComplexField(content);
+		case "inlineSdt": return serializeInlineSdt(content);
+		case "commentRangeStart": return `<w:commentRangeStart w:id="${content.id}"/>`;
+		case "commentRangeEnd": return explicitCommentReferenceIds.has(content.id) ? `<w:commentRangeEnd w:id="${content.id}"/>` : `<w:commentRangeEnd w:id="${content.id}"/>${serializeCommentReferenceRun(content.id)}`;
+		case "commentReference": return serializeCommentReferenceRun(content.id);
+		case "insertion": return serializeTrackedChange("ins", content);
+		case "deletion": return serializeTrackedChange("del", content);
+		case "moveFrom": return serializeTrackedChange("moveFrom", content);
+		case "moveTo": return serializeTrackedChange("moveTo", content);
+		case "moveFromRangeStart": return serializeMoveRangeStart("moveFromRangeStart", content);
+		case "moveFromRangeEnd": return `<w:moveFromRangeEnd w:id="${content.id}"/>`;
+		case "moveToRangeStart": return serializeMoveRangeStart("moveToRangeStart", content);
+		case "moveToRangeEnd": return `<w:moveToRangeEnd w:id="${content.id}"/>`;
+		case "mathEquation": return content.ommlXml || "";
+		default: return "";
+	}
+}
+/**
+* Serialize a paragraph to OOXML XML (w:p)
+*
+* @param paragraph - The paragraph to serialize
+* @returns XML string for the paragraph
+*/
+function serializeParagraph(paragraph) {
+	const parts = [];
+	const attrs = [];
+	if (paragraph.paraId) attrs.push(`w14:paraId="${paragraph.paraId}"`);
+	if (paragraph.textId) attrs.push(`w14:textId="${paragraph.textId}"`);
+	const attrsStr = attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
+	const pPrXml = serializeParagraphFormatting(paragraph.formatting, paragraph.propertyChanges, paragraph.pPrMark);
+	const sectionPropertiesXml = serializeSectionProperties(paragraph.sectionProperties);
+	if (pPrXml || sectionPropertiesXml) parts.push(`<w:pPr>${extractPPrInner(pPrXml)}${sectionPropertiesXml}</w:pPr>`);
+	const explicitCommentReferenceIds = /* @__PURE__ */ new Set();
+	for (const content of paragraph.content) if (content.type === "commentReference") explicitCommentReferenceIds.add(content.id);
+	let pendingRenderedPageBreak = paragraph.renderedPageBreakBefore === true;
+	for (const content of paragraph.content) {
+		let contentXml = serializeParagraphContent(content, explicitCommentReferenceIds);
+		if (contentXml) {
+			if (pendingRenderedPageBreak) {
+				const next = injectRenderedPageBreakIntoFirstRun(contentXml);
+				if (next) {
+					contentXml = next;
+					pendingRenderedPageBreak = false;
+				}
+			}
+			parts.push(contentXml);
+		}
+	}
+	return `<w:p${attrsStr}>${parts.join("")}</w:p>`;
+}
+function injectRenderedPageBreakIntoFirstRun(xml) {
+	const runOpeningTag = /<w:r(?=[\s>/])[^>]*>/u;
+	if (!runOpeningTag.test(xml)) return null;
+	return xml.replace(runOpeningTag, (match) => `${match}<w:lastRenderedPageBreak/>`);
+}
+/**
+* Serialize multiple paragraphs to OOXML XML
+*
+* @param paragraphs - The paragraphs to serialize
+* @returns XML string for all paragraphs
+*/
+function serializeParagraphs(paragraphs) {
+	return paragraphs.map(serializeParagraph).join("");
+}
+/**
+* Check if a paragraph has any content
+*/
+function hasParagraphContent(paragraph) {
+	return paragraph.content.length > 0;
+}
+/**
+* Check if a paragraph has formatting
+*/
+function hasParagraphFormatting(paragraph) {
+	return paragraph.formatting !== void 0 && Object.keys(paragraph.formatting).length > 0;
+}
+/**
+* Get plain text from a paragraph (for comparison/debugging)
+*/
+function getParagraphPlainText(paragraph) {
+	const texts = [];
+	for (const content of paragraph.content) if (content.type === "run") {
+		for (const item of content.content) if (item.type === "text") texts.push(item.text);
+		else if (item.type === "tab") texts.push("	");
+		else if (item.type === "break") texts.push("\n");
+	} else if (content.type === "hyperlink") {
+		for (const child of content.children) if (child.type === "run") {
+			for (const item of child.content) if (item.type === "text") texts.push(item.text);
+		}
+	} else if (content.type === "simpleField" || content.type === "inlineSdt" || content.type === "insertion" || content.type === "deletion" || content.type === "moveFrom" || content.type === "moveTo") {
+		for (const item of content.content) if (item.type === "run") {
+			for (const subItem of item.content) if (subItem.type === "text") texts.push(subItem.text);
+		}
+	} else if (content.type === "complexField") {
+		for (const run of content.fieldResult) for (const item of run.content) if (item.type === "text") texts.push(item.text);
+	}
+	return texts.join("");
+}
+/**
+* Create an empty paragraph
+*/
+function createEmptyParagraph(formatting) {
+	return {
+		type: "paragraph",
+		...formatting !== void 0 ? { formatting } : {},
+		content: []
+	};
+}
+/**
+* Create a paragraph with a single text run
+*/
+function createTextParagraph(text, paragraphFormatting, textFormatting) {
+	return {
+		type: "paragraph",
+		...paragraphFormatting !== void 0 ? { formatting: paragraphFormatting } : {},
+		content: [{
+			type: "run",
+			...textFormatting !== void 0 ? { formatting: textFormatting } : {},
+			content: [{
+				type: "text",
+				text
+			}]
+		}]
+	};
+}
+/**
+* Check if paragraph is a list item
+*/
+function isListParagraph(paragraph) {
+	return paragraph.formatting?.numPr !== void 0;
+}
+/**
+* Get list level of a paragraph (0-8, or -1 if not a list)
+*/
+function getListLevel(paragraph) {
+	return paragraph.formatting?.numPr?.ilvl ?? -1;
+}
+//#endregion
+export { createEmptyParagraph, createTextParagraph, getListLevel, getParagraphPlainText, hasParagraphContent, hasParagraphFormatting, isListParagraph, serializeParagraph, serializeParagraphFormatting, serializeParagraphs };

package/dist/docx/serializer/runSerializer.d.ts

@@ -0,0 +1,56 @@
+import { document_d_exports } from "../../types/document.js";
+
+//#region src/docx/serializer/runSerializer.d.ts
+/**
+ * Reset the auto-incrementing ID counter. Call before each serialization pass
+ * to keep IDs deterministic across saves.
+ */
+declare function resetAutoIdCounter(): void;
+/**
+ * Serialize text formatting properties to w:rPr XML
+ */
+declare function serializeTextFormatting(formatting: document_d_exports.TextFormatting | undefined): string;
+/**
+ * Serialize a run to OOXML XML (w:r)
+ *
+ * @param run - The run to serialize
+ * @returns XML string for the run
+ */
+declare function serializeRun(run: document_d_exports.Run): string;
+/**
+ * Serialize multiple runs to OOXML XML
+ *
+ * @param runs - The runs to serialize
+ * @returns XML string for all runs
+ */
+declare function serializeRuns(runs: document_d_exports.Run[]): string;
+/**
+ * Check if a run has any content
+ */
+declare function hasRunContent(run: document_d_exports.Run): boolean;
+/**
+ * Check if a run has formatting
+ */
+declare function hasRunFormatting(run: document_d_exports.Run): boolean;
+/**
+ * Get plain text from a run (for comparison/debugging)
+ */
+declare function getRunPlainText(run: document_d_exports.Run): string;
+/**
+ * Create an empty run
+ */
+declare function createEmptyRun(): document_d_exports.Run;
+/**
+ * Create a text run
+ */
+declare function createTextRun(text: string, formatting?: document_d_exports.TextFormatting): document_d_exports.Run;
+/**
+ * Create a break run
+ */
+declare function createBreakRun(breakType?: "page" | "column" | "textWrapping", formatting?: document_d_exports.TextFormatting): document_d_exports.Run;
+/**
+ * Create a tab run
+ */
+declare function createTabRun(formatting?: document_d_exports.TextFormatting): document_d_exports.Run;
+//#endregion
+export { createBreakRun, createEmptyRun, createTabRun, createTextRun, getRunPlainText, hasRunContent, hasRunFormatting, resetAutoIdCounter, serializeRun, serializeRuns, serializeTextFormatting };