@stll/folio-core 0.45.0 → 0.47.0

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

@@ -31,13 +31,5 @@ declare function createEmptyParagraph(formatting?: document_d_exports.ParagraphF
  * Create a paragraph with a single text run
  */
 declare function createTextParagraph(text: string, paragraphFormatting?: document_d_exports.ParagraphFormatting, textFormatting?: document_d_exports.TextFormatting): document_d_exports.Paragraph;
-/**
- * Check if paragraph is a list item
- */
-declare function isListParagraph(paragraph: document_d_exports.Paragraph): boolean;
-/**
- * Get list level of a paragraph (0-8, or -1 if not a list)
- */
-declare function getListLevel(paragraph: document_d_exports.Paragraph): number;
 //#endregion
-export { createEmptyParagraph, createTextParagraph, getListLevel, hasParagraphContent, hasParagraphFormatting, isListParagraph, serializeParagraph, serializeParagraphFormatting, serializeParagraphs };
+export { createEmptyParagraph, createTextParagraph, hasParagraphContent, hasParagraphFormatting, serializeParagraph, serializeParagraphFormatting, serializeParagraphs };

package/dist/docx/serializer/paragraphSerializer.js

@@ -1,19 +1,22 @@
-import { modelParagraphFormattingEmission } from "../../internal/paragraphFormattingSerialization.js";
+import { modelParagraphFormattingEmission, serializeParagraphPropertySet } from "../../internal/paragraphFormattingSerialization.js";
+import { serializePreservedAttributes } from "../attributeRemainder.js";
+import { CONTAINER_CHILDREN } from "../containerChildren.gen.js";
+import { fieldStateAttributes } from "../fieldState.js";
 import { getParagraphPropertySource, paragraphPropertySourceMatchesEmission } from "../paragraphPropertySource.js";
-import { reconcileRawSdtPr } from "../sdtPropertiesPatch.js";
 import { DATE_UTC_ATTRIBUTE } from "../trackedChangeInfo.js";
 import { toTransitionalNamespaceUri } from "../transitionalSpelling.js";
 import { captureVerbatimXml, sanitizeCapturedXmlElement } from "../verbatimCapture.js";
 import { NAMESPACES, OOXML_NAMESPACE_SCOPE, cloneElement, getChildElements, getLocalName, parseXml } from "../xmlParser.js";
-import { bookmarkRangeAttributes, markupRangeAttributes, moveBookmarkAttributes } from "./markupRangeAttributes.js";
+import { markupRangeAttributes, moveBookmarkAttributes, serializeBookmarkMarker } from "./markupRangeAttributes.js";
 import { serializeRun } from "./runSerializer.js";
+import { serializeSdtWrapper } from "./sdtPropertiesSerializer.js";
 import { serializeSectionProperties } from "./sectionPropertiesSerializer.js";
 import { serializeTextFormatting } from "./textFormattingSerializer.js";
 import { serializeTrackedChangeAttributes, trackedChangeAttributeRecord } from "./trackedChangeAttributes.js";
-import { isSingleWellFormedElement } from "./xmlUtils.js";
 import { panic } from "better-result";
 import { escapeXmlAttribute, escapeXmlText } from "@stll/docx-core";
 import { PARAGRAPH_MARK_CHANGE_KINDS } from "@stll/docx-core/model";
+import { SEQUENCE_CHILDREN } from "@stll/docx-core/schema";
 //#region src/docx/serializer/paragraphSerializer.ts
 /**
 * Serialize paragraph formatting properties to w:pPr XML
@@ -50,83 +53,26 @@ const PARAGRAPH_APPEND_PREFIXES = /* @__PURE__ */ new Map([
 	["r", NAMESPACES.r],
 	["w15", NAMESPACES.w15]
 ]);
-const PARAGRAPH_PROPERTY_CHILD_ORDER = new Map([
-	"pStyle",
-	"keepNext",
-	"keepLines",
-	"pageBreakBefore",
-	"framePr",
-	"widowControl",
-	"numPr",
-	"suppressLineNumbers",
-	"pBdr",
-	"shd",
-	"tabs",
-	"suppressAutoHyphens",
-	"kinsoku",
-	"wordWrap",
-	"overflowPunct",
-	"topLinePunct",
-	"autoSpaceDE",
-	"autoSpaceDN",
-	"bidi",
-	"adjustRightInd",
-	"snapToGrid",
-	"spacing",
-	"ind",
-	"contextualSpacing",
-	"mirrorIndents",
-	"suppressOverlap",
-	"jc",
-	"textDirection",
-	"textAlignment",
-	"textboxTightWrap",
-	"outlineLvl",
-	"divId",
-	"cnfStyle",
-	"rPr"
-].map((name, index) => [name, index]));
-const PARAGRAPH_MARK_BASE_CHILDREN = /* @__PURE__ */ new Set([
-	"rStyle",
-	"rFonts",
-	"b",
-	"bCs",
-	"i",
-	"iCs",
-	"caps",
-	"smallCaps",
-	"strike",
-	"dstrike",
-	"outline",
-	"shadow",
-	"emboss",
-	"imprint",
-	"snapToGrid",
-	"vanish",
-	"webHidden",
-	"color",
-	"spacing",
-	"w",
-	"kern",
-	"position",
-	"sz",
-	"szCs",
-	"noProof",
-	"highlight",
-	"u",
-	"effect",
-	"bdr",
-	"shd",
-	"fitText",
-	"vertAlign",
-	"rtl",
-	"cs",
-	"em",
-	"lang",
-	"eastAsianLayout",
-	"specVanish",
-	"oMath"
-]);
+/**
+* The order a replayed `w:pPr` has to already be in, from the generated table.
+*
+* This used to be the same list written out again, which is a mirror of the
+* order the writer emits: the two could disagree and a capture the gate let
+* through would then be markup the rebuild would never have written.
+* `w:sectPr` and `w:pPrChange` are in the generated list and are refused
+* before this map is consulted, because they have their own lifecycles.
+*/
+const PARAGRAPH_PROPERTY_CHILD_ORDER = new Map(SEQUENCE_CHILDREN["paragraph-properties"].map((name, index) => [name, index]));
+/**
+* `EG_RPrBase`: the paragraph mark's `w:rPr` children a replay may carry.
+*
+* Derived from the generated declared-child list rather than restated, so the
+* set a capture is checked against and the set the parser makes a decision for
+* are one list. The revisions `CT_ParaRPr` adds around it are excluded here
+* and refused by {@link RESERVED_PARAGRAPH_CAPTURE_CHILDREN}, which is what
+* keeps a replayed `w:pPr` from carrying a revision the model also writes.
+*/
+const PARAGRAPH_MARK_BASE_CHILDREN = new Set(CONTAINER_CHILDREN["run-properties"].filter((name) => !RESERVED_PARAGRAPH_CAPTURE_CHILDREN.has(name)));
 const PARAGRAPH_NESTED_PROPERTY_CHILDREN = /* @__PURE__ */ new Map([
 	["numPr", /* @__PURE__ */ new Set([
 		"ilvl",
@@ -304,15 +250,12 @@ const serializeParagraphFormattingWithOptions = (formatting, { propertyChanges,
 		const sourceWithMark = paragraphMarkChange ? withParagraphMarkChange(verifiedSource, paragraphMarkChange) : verifiedSource;
 		return withTrailingParagraphPropertyChildren(sourceWithMark, [sectionPropertiesXml, ...propertyChangesXml]);
 	}
-	const parts = [];
-	if (modeledFormatting.propertiesXml) parts.push(modeledFormatting.propertiesXml);
-	const paragraphMarkPropertiesInnerXml = `${paragraphMarkXml}${modeledFormatting.paragraphMarkPropertiesInnerXml ?? ""}`;
-	if (paragraphMarkPropertiesInnerXml) parts.push(`<w:rPr>${paragraphMarkPropertiesInnerXml}</w:rPr>`);
-	parts.push(sectionPropertiesXml);
-	if (propertyChangesXml.length > 0) parts.push(...propertyChangesXml);
-	const inner = parts.join("");
-	if (inner.length === 0) return "";
-	return `<w:pPr>${inner}</w:pPr>`;
+	return serializeParagraphPropertySet({
+		formatting,
+		markPropertiesPrefixXml: paragraphMarkXml,
+		sectionPropertiesXml,
+		propertyChangesXml
+	});
 };
 function serializeParagraphFormatting(formatting, propertyChanges, paragraphMarkChange) {
 	return serializeParagraphFormattingWithOptions(formatting, {
@@ -341,36 +284,36 @@ function hyperlinkAttributes(hyperlink) {
 	if (hyperlink.docLocation) attrs.push(`w:docLocation="${escapeXmlAttribute(hyperlink.docLocation)}"`);
 	return attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
 }
-/** One `w:hyperlink` child, with the caller deciding how a run is written. */
-function serializeHyperlinkChild(child, serializeChildRun) {
-	if (child.type === "run") return serializeChildRun(child);
-	return child.type === "bookmarkStart" ? serializeBookmarkStart(child) : serializeBookmarkEnd(child);
+/** One `w:hyperlink` child, written with the link's own disposition. */
+function serializeHyperlinkChild(child, disposition) {
+	switch (child.type) {
+		case "run": return serializeInlineRun(child, disposition);
+		case "bookmarkStart": return serializeBookmarkMarker(child);
+		case "bookmarkEnd": return serializeBookmarkMarker(child);
+		case "inlineWrapper": return serializeParagraphContent(child, disposition);
+		case "preservedInline": return child.xml;
+		default: return child;
+	}
 }
 /**
 * Serialize a hyperlink (w:hyperlink)
 */
-function serializeHyperlink(hyperlink) {
-	const childrenXml = hyperlink.children.map((child) => serializeHyperlinkChild(child, serializeRun)).join("");
+function serializeHyperlink(hyperlink, disposition = "kept") {
+	const childrenXml = hyperlink.children.map((child) => serializeHyperlinkChild(child, disposition)).join("");
 	return `<w:hyperlink${hyperlinkAttributes(hyperlink)}>${childrenXml}</w:hyperlink>`;
 }
-/**
-* Serialize bookmark start (w:bookmarkStart)
-*/
-function serializeBookmarkStart(bookmark) {
-	return `<w:bookmarkStart ${bookmarkRangeAttributes(bookmark).join(" ")}/>`;
-}
-/**
-* Serialize bookmark end (w:bookmarkEnd)
-*/
-function serializeBookmarkEnd(bookmark) {
-	return `<w:bookmarkEnd ${markupRangeAttributes(bookmark).join(" ")}/>`;
-}
 /** Serialize a simple field without changing its authored OOXML field form. */
 function serializeSimpleField(field) {
-	const attrs = [`w:instr="${escapeXmlAttribute(field.instruction)}"`];
-	if (field.fldLock) attrs.push("w:fldLock=\"true\"");
-	if (field.dirty) attrs.push("w:dirty=\"true\"");
-	const contentXml = field.content.map((item) => item.type === "run" ? serializeRun(item) : serializeHyperlink(item)).join("");
+	const attrs = [`w:instr="${escapeXmlAttribute(field.instruction)}"`, ...fieldStateAttributes(field)];
+	const contentXml = field.content.map((item) => {
+		switch (item.type) {
+			case "run": return serializeRun(item);
+			case "hyperlink": return serializeHyperlink(item);
+			case "inlineWrapper": return serializeParagraphContent(item);
+			case "preservedInline": return item.xml;
+			default: return item;
+		}
+	}).join("");
 	return `<w:fldSimple ${attrs.join(" ")}>${contentXml}</w:fldSimple>`;
 }
 /**
@@ -382,9 +325,7 @@ 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\"");
-	if (field.dirty) beginAttrs.push("w:dirty=\"true\"");
+	const beginAttrs = ["w:fldCharType=\"begin\"", ...fieldStateAttributes(field)];
 	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 if (field.instruction.length > 0) {
@@ -397,56 +338,6 @@ function serializeComplexField(field) {
 	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="${escapeXmlAttribute(props.alias)}"/>`);
-	if (props.tag) prParts.push(`<w:tag w:val="${escapeXmlAttribute(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="${escapeXmlAttribute(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="${escapeXmlAttribute(props.dateValueISO)}"` : "";
-			const formatChild = props.dateFormat ? `<w:dateFormat w:val="${escapeXmlAttribute(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="${escapeXmlAttribute(i.displayText)}" w:value="${escapeXmlAttribute(i.value)}"/>`).join("");
-			prParts.push(`<w:dropDownList>${items}</w:dropDownList>`);
-			break;
-		}
-		case "comboBox": {
-			const items = (props.listItems ?? []).map((i) => `<w:listItem w:displayText="${escapeXmlAttribute(i.displayText)}" w:value="${escapeXmlAttribute(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
@@ -455,30 +346,27 @@ function synthesizeInlineSdtPr(props) {
 * the properties block was re-synthesized from the modeled projection alone,
 * silently dropping every unmodeled feature (and `w:sdtEndPr`) on save.
 */
-function serializeInlineSdt(sdt) {
+function serializeInlineSdt(sdt, disposition = "kept") {
 	const props = sdt.properties;
-	const contentXml = sdt.content.map((item) => {
+	return serializeSdtWrapper(props, sdt.content.map((item) => {
 		switch (item.type) {
-			case "run": return serializeRun(item);
-			case "hyperlink": return serializeHyperlink(item);
+			case "run": return serializeInlineRun(item, disposition);
+			case "hyperlink": return serializeHyperlink(item, disposition);
 			case "simpleField": return serializeSimpleField(item);
 			case "complexField": return serializeComplexField(item);
-			case "inlineSdt": return serializeInlineSdt(item);
+			case "inlineSdt": return serializeInlineSdt(item, disposition);
+			case "inlineWrapper": return serializeParagraphContent(item, disposition);
+			case "bookmarkStart": return serializeBookmarkMarker(item);
+			case "bookmarkEnd": return serializeBookmarkMarker(item);
 			case "insertion": return serializeTrackedChange("ins", item);
 			case "deletion": return serializeTrackedChange("del", item);
 			case "moveFrom": return serializeTrackedChange("moveFrom", item);
 			case "moveTo": return serializeTrackedChange("moveTo", item);
 			case "mathEquation": return item.ommlXml || "";
+			case "preservedInline": return item.xml;
 			default: return item;
 		}
-	}).join("");
-	const baseSdtPr = props.rawPropertiesXml && isSingleWellFormedElement(props.rawPropertiesXml, "sdtPr") ? 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 && isSingleWellFormedElement(props.rawEndPropertiesXml, "sdtEndPr") ? props.rawEndPropertiesXml : ""}<w:sdtContent>${contentXml}</w:sdtContent></w:sdt>`;
+	}).join(""));
 }
 function serializeMoveRangeStart(tag, marker) {
 	return `<w:${tag} ${moveBookmarkAttributes(marker).join(" ")}/>`;
@@ -489,6 +377,22 @@ function serializeMoveRangeStart(tag, marker) {
 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 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("");
+}
+function serializeInlineRun(run, disposition) {
+	return disposition === "removed" ? serializeDeletedRun(run) : serializeRun(run);
+}
 function trackedChangeTag(change) {
 	switch (change.type) {
 		case "insertion": return "ins";
@@ -499,29 +403,28 @@ function trackedChangeTag(change) {
 }
 function serializeTrackedChange(tag, change) {
 	const attrs = serializeTrackedChangeAttributes(change.info);
-	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 serializeContentRun = (run) => tag === "del" || tag === "moveFrom" ? serializeDeletedRun(run) : serializeRun(run);
+	const disposition = tag === "del" || tag === "moveFrom" ? "removed" : "kept";
+	const serializeContentRun = (run) => serializeInlineRun(run, disposition);
 	const serializeWrappedItem = (item) => {
-		if (item.type === "run") return serializeContentRun(item);
-		if (item.type === "simpleField" || item.type === "complexField") {
-			const xml = item.type === "simpleField" ? serializeSimpleField(item) : serializeComplexField(item);
-			return tag === "del" || tag === "moveFrom" ? rewriteRunTextAsDeleted(xml) : xml;
+		switch (item.type) {
+			case "run": return serializeContentRun(item);
+			case "simpleField":
+			case "complexField": {
+				const xml = item.type === "simpleField" ? serializeSimpleField(item) : serializeComplexField(item);
+				return disposition === "removed" ? rewriteRunTextAsDeleted(xml) : xml;
+			}
+			case "mathEquation": return item.ommlXml;
+			case "insertion":
+			case "deletion":
+			case "moveFrom":
+			case "moveTo": return serializeTrackedChange(trackedChangeTag(item), item);
+			case "bookmarkStart":
+			case "bookmarkEnd": return serializeBookmarkMarker(item);
+			case "preservedInline": return item.xml;
+			case "inlineWrapper":
+			case "inlineSdt": return serializeParagraphContent(item, disposition);
+			default: return item;
 		}
-		if (item.type === "mathEquation") return item.ommlXml;
-		if (item.type === "insertion" || item.type === "deletion" || item.type === "moveFrom" || item.type === "moveTo") return serializeTrackedChange(trackedChangeTag(item), item);
-		return item.type === "bookmarkStart" ? serializeBookmarkStart(item) : serializeBookmarkEnd(item);
 	};
 	const open = `<w:${tag} ${attrs}>`;
 	const close = `</w:${tag}>`;
@@ -538,7 +441,7 @@ function serializeTrackedChange(tag, change) {
 	for (const item of change.content) {
 		if (item.type === "hyperlink") {
 			flushPending();
-			const childrenXml = item.children.map((child) => serializeHyperlinkChild(child, serializeContentRun)).join("");
+			const childrenXml = item.children.map((child) => serializeHyperlinkChild(child, disposition)).join("");
 			segments.push(`<w:hyperlink${hyperlinkAttributes(item)}>${open}${childrenXml}${close}</w:hyperlink>`);
 			continue;
 		}
@@ -547,6 +450,32 @@ function serializeTrackedChange(tag, change) {
 	flushPending();
 	return segments.join("");
 }
+const TAGGED_WRAPPER_PROPERTY_NAMES = {
+	smartTag: /* @__PURE__ */ new Set(["smartTagPr"]),
+	customXml: /* @__PURE__ */ new Set(["customXmlPr"])
+};
+/**
+* Emit a `w:smartTag` or a run-level `w:customXml` around content already written.
+*
+* `w:element` is required by both content models, so it is always spelled;
+* `w:uri` is written only when the source stated one, because inventing an
+* empty namespace would change what the tag names. The properties element
+* comes first, as both content models declare it.
+*
+* The captured properties are replayed only when they are structurally the one
+* element they claim to be. The layer rides a ProseMirror mark, so a paste from
+* outside the editor can put any string there, and a string that closed the
+* wrapper early would splice sibling markup into the part.
+*/
+function serializeTaggedWrapper(kind, wrapper, inner) {
+	const uri = wrapper.uri === void 0 ? "" : ` w:uri="${escapeXmlAttribute(wrapper.uri)}"`;
+	const properties = sanitizeCapturedXmlElement(wrapper.propertiesXml, {
+		allowedLocalNames: TAGGED_WRAPPER_PROPERTY_NAMES[kind],
+		allowedNamespaceUris: WORDPROCESSINGML_NAMESPACE,
+		inheritedNamespaceScope: OOXML_NAMESPACE_SCOPE
+	}) ?? "";
+	return `<w:${kind}${uri} w:element="${escapeXmlAttribute(wrapper.element)}">${properties}${inner}</w:${kind}>`;
+}
 /** 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>`;
@@ -554,27 +483,22 @@ function serializeCommentReferenceRun(id) {
 /**
 * 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.
+* A `commentRangeEnd` writes an end and nothing else. Where the comment's
+* reference run goes is authored data the model carries as its own item, and
+* `completeCommentReferences` fills it in for a model that arrived without
+* one; a guess made here from one paragraph cannot see the rest of the story.
 */
-function serializeParagraphContent(content, explicitCommentReferenceIds) {
+function serializeParagraphContent(content, disposition = "kept") {
 	switch (content.type) {
-		case "run": return serializeRun(content);
-		case "hyperlink": return serializeHyperlink(content);
-		case "bookmarkStart": return serializeBookmarkStart(content);
-		case "bookmarkEnd": return serializeBookmarkEnd(content);
+		case "run": return serializeInlineRun(content, disposition);
+		case "hyperlink": return serializeHyperlink(content, disposition);
+		case "bookmarkStart":
+		case "bookmarkEnd": return serializeBookmarkMarker(content);
 		case "simpleField": return serializeSimpleField(content);
 		case "complexField": return serializeComplexField(content);
-		case "inlineSdt": return serializeInlineSdt(content);
+		case "inlineSdt": return serializeInlineSdt(content, disposition);
 		case "commentRangeStart": return `<w:commentRangeStart ${markupRangeAttributes(content).join(" ")}/>`;
-		case "commentRangeEnd": {
-			const end = `<w:commentRangeEnd ${markupRangeAttributes(content).join(" ")}/>`;
-			return explicitCommentReferenceIds.has(content.id) ? end : `${end}${serializeCommentReferenceRun(content.id)}`;
-		}
+		case "commentRangeEnd": return `<w:commentRangeEnd ${markupRangeAttributes(content).join(" ")}/>`;
 		case "commentReference": return serializeCommentReferenceRun(content.id);
 		case "insertion": return serializeTrackedChange("ins", content);
 		case "deletion": return serializeTrackedChange("del", content);
@@ -584,11 +508,20 @@ function serializeParagraphContent(content, explicitCommentReferenceIds) {
 		case "moveFromRangeEnd": return `<w:moveFromRangeEnd ${markupRangeAttributes(content).join(" ")}/>`;
 		case "moveToRangeStart": return serializeMoveRangeStart("moveToRangeStart", content);
 		case "moveToRangeEnd": return `<w:moveToRangeEnd ${markupRangeAttributes(content).join(" ")}/>`;
-		case "bidiWrapper": {
-			const tag = content.control === "override" ? "bdo" : "dir";
-			return `<w:${tag}${content.direction === void 0 ? "" : ` w:val="${escapeXmlAttribute(content.direction)}"`}>${content.content.map((child) => serializeParagraphContent(child, explicitCommentReferenceIds)).join("")}</w:${tag}>`;
+		case "inlineWrapper": {
+			const inner = content.content.map((child) => serializeParagraphContent(child, disposition)).join("");
+			switch (content.kind) {
+				case "bidi": {
+					const tag = content.control === "override" ? "bdo" : "dir";
+					return `<w:${tag}${content.direction === void 0 ? "" : ` w:val="${escapeXmlAttribute(content.direction)}"`}>${inner}</w:${tag}>`;
+				}
+				case "smartTag": return serializeTaggedWrapper("smartTag", content, inner);
+				case "customXml": return serializeTaggedWrapper("customXml", content, inner);
+				default: return content;
+			}
 		}
 		case "mathEquation": return content.ommlXml || "";
+		case "preservedInline": return content.xml;
 		default: return "";
 	}
 }
@@ -604,18 +537,17 @@ function serializeParagraph(paragraph) {
 	if (paragraph.paraId) attrs.push(`w14:paraId="${escapeXmlAttribute(paragraph.paraId)}"`);
 	if (paragraph.textId) attrs.push(`w14:textId="${escapeXmlAttribute(paragraph.textId)}"`);
 	if (paragraph.reviewCarrier) attrs.push(`folio:reviewCarrier="${paragraph.reviewCarrier}"`);
-	const attrsStr = attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
+	const written = serializePreservedAttributes(attrs, paragraph.preservedAttributes);
+	const attrsStr = written.length > 0 ? ` ${written.join(" ")}` : "";
 	parts.push(serializeParagraphFormattingWithOptions(paragraph.formatting, {
 		propertyChanges: paragraph.propertyChanges,
 		paragraphMarkChange: paragraph.pPrMark,
 		propertySource: getParagraphPropertySource(paragraph),
 		sectionProperties: paragraph.sectionProperties
 	}));
-	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);
+		let contentXml = serializeParagraphContent(content);
 		if (contentXml) {
 			if (pendingRenderedPageBreak) {
 				const next = injectRenderedPageBreakIntoFirstRun(contentXml);
@@ -700,17 +632,5 @@ function createTextParagraph(text, paragraphFormatting, textFormatting) {
 		}]
 	};
 }
-/**
-* 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, hasParagraphContent, hasParagraphFormatting, isListParagraph, serializeParagraph, serializeParagraphFormatting, serializeParagraphs };
+export { createEmptyParagraph, createTextParagraph, hasParagraphContent, hasParagraphFormatting, serializeParagraph, serializeParagraphFormatting, serializeParagraphs };

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

@@ -19,10 +19,6 @@ declare function serializeRun(run: document_d_exports.Run): string;
  * @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
  */
@@ -48,4 +44,4 @@ declare function createBreakRun(breakType?: "page" | "column" | "textWrapping",
  */
 declare function createTabRun(formatting?: document_d_exports.TextFormatting): document_d_exports.Run;
 //#endregion
-export { createBreakRun, createEmptyRun, createTabRun, createTextRun, getRunPlainText, hasRunContent, hasRunFormatting, resetAutoIdCounter, serializeRun, serializeRuns };
+export { createBreakRun, createEmptyRun, createTabRun, createTextRun, getRunPlainText, hasRunFormatting, resetAutoIdCounter, serializeRun, serializeRuns };