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

package/dist/docx/serializer/runSerializer.js

@@ -0,0 +1,621 @@
+import { HIGHLIGHT_COLOR_VALUES } from "../../types/documentEnumValues.js";
+import { escapeXml, intAttr } from "./xmlUtils.js";
+import { serializeParagraph } from "./paragraphSerializer.js";
+import { panic } from "better-result";
+//#region src/docx/serializer/runSerializer.ts
+/**
+* Run Serializer - Serialize runs to OOXML XML
+*
+* Converts Run objects back to <w:r> XML format for DOCX files.
+* Handles all formatting properties and content types.
+*
+* OOXML Reference:
+* - Run: w:r
+* - Run properties: w:rPr
+* - Text content: w:t
+*/
+/**
+* Auto-incrementing counter for generating unique image/shape IDs.
+* Used as a fallback when `image.id` or `shape.id` is undefined (e.g., pasted images).
+* Starts high (100000) to avoid collisions with IDs parsed from existing DOCX content.
+*/
+let nextAutoId = 1e5;
+/**
+* Reset the auto-incrementing ID counter. Call before each serialization pass
+* to keep IDs deterministic across saves.
+*/
+function resetAutoIdCounter() {
+	nextAutoId = 1e5;
+}
+/** Get a unique positive integer ID, using the provided value or generating one */
+function getUniqueId(id) {
+	if (id !== void 0 && id !== "" && id !== 0) return String(id);
+	return String(nextAutoId++);
+}
+/** Valid OOXML highlight color names (ECMA-376 §17.18.40) */
+const VALID_HIGHLIGHT_COLORS = new Set(HIGHLIGHT_COLOR_VALUES.filter((color) => color !== "none"));
+/**
+* Serialize a color element (w:color)
+*/
+function serializeColorElement(color) {
+	if (!color) return "";
+	const attrs = [];
+	if (color.auto) attrs.push("w:val=\"auto\"");
+	else if (color.rgb) attrs.push(`w:val="${color.rgb}"`);
+	if (color.themeColor) attrs.push(`w:themeColor="${color.themeColor}"`);
+	if (color.themeTint) attrs.push(`w:themeTint="${color.themeTint}"`);
+	if (color.themeShade) attrs.push(`w:themeShade="${color.themeShade}"`);
+	if (attrs.length === 0) return "";
+	return `<w:color ${attrs.join(" ")}/>`;
+}
+/**
+* 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 text formatting properties to w:rPr XML
+*/
+function serializeTextFormatting(formatting) {
+	if (!formatting) return "";
+	const parts = [];
+	if (formatting.styleId) parts.push(`<w:rStyle w:val="${escapeXml(formatting.styleId)}"/>`);
+	if (formatting.fontFamily) {
+		const fontAttrs = [];
+		if (formatting.fontFamily.ascii) fontAttrs.push(`w:ascii="${escapeXml(formatting.fontFamily.ascii)}"`);
+		if (formatting.fontFamily.hAnsi) fontAttrs.push(`w:hAnsi="${escapeXml(formatting.fontFamily.hAnsi)}"`);
+		if (formatting.fontFamily.eastAsia) fontAttrs.push(`w:eastAsia="${escapeXml(formatting.fontFamily.eastAsia)}"`);
+		if (formatting.fontFamily.cs) fontAttrs.push(`w:cs="${escapeXml(formatting.fontFamily.cs)}"`);
+		if (formatting.fontFamily.asciiTheme) fontAttrs.push(`w:asciiTheme="${formatting.fontFamily.asciiTheme}"`);
+		if (formatting.fontFamily.hAnsiTheme) fontAttrs.push(`w:hAnsiTheme="${formatting.fontFamily.hAnsiTheme}"`);
+		if (formatting.fontFamily.eastAsiaTheme) fontAttrs.push(`w:eastAsiaTheme="${formatting.fontFamily.eastAsiaTheme}"`);
+		if (formatting.fontFamily.csTheme) fontAttrs.push(`w:cstheme="${formatting.fontFamily.csTheme}"`);
+		if (fontAttrs.length > 0) parts.push(`<w:rFonts ${fontAttrs.join(" ")}/>`);
+	}
+	if (formatting.bold === true) parts.push("<w:b/>");
+	else if (formatting.bold === false) parts.push("<w:b w:val=\"0\"/>");
+	if (formatting.boldCs === true) parts.push("<w:bCs/>");
+	else if (formatting.boldCs === false) parts.push("<w:bCs w:val=\"0\"/>");
+	if (formatting.italic === true) parts.push("<w:i/>");
+	else if (formatting.italic === false) parts.push("<w:i w:val=\"0\"/>");
+	if (formatting.italicCs === true) parts.push("<w:iCs/>");
+	else if (formatting.italicCs === false) parts.push("<w:iCs w:val=\"0\"/>");
+	if (formatting.allCaps === true) parts.push("<w:caps/>");
+	else if (formatting.allCaps === false) parts.push("<w:caps w:val=\"0\"/>");
+	if (formatting.smallCaps === true) parts.push("<w:smallCaps/>");
+	else if (formatting.smallCaps === false) parts.push("<w:smallCaps w:val=\"0\"/>");
+	if (formatting.strike === true) parts.push("<w:strike/>");
+	else if (formatting.strike === false) parts.push("<w:strike w:val=\"0\"/>");
+	if (formatting.doubleStrike === true) parts.push("<w:dstrike/>");
+	else if (formatting.doubleStrike === false) parts.push("<w:dstrike w:val=\"0\"/>");
+	if (formatting.outline === true) parts.push("<w:outline/>");
+	else if (formatting.outline === false) parts.push("<w:outline w:val=\"0\"/>");
+	if (formatting.shadow === true) parts.push("<w:shadow/>");
+	else if (formatting.shadow === false) parts.push("<w:shadow w:val=\"0\"/>");
+	if (formatting.emboss === true) parts.push("<w:emboss/>");
+	else if (formatting.emboss === false) parts.push("<w:emboss w:val=\"0\"/>");
+	if (formatting.imprint === true) parts.push("<w:imprint/>");
+	else if (formatting.imprint === false) parts.push("<w:imprint w:val=\"0\"/>");
+	if (formatting.hidden === true) parts.push("<w:vanish/>");
+	else if (formatting.hidden === false) parts.push("<w:vanish w:val=\"0\"/>");
+	const colorXml = serializeColorElement(formatting.color);
+	if (colorXml) parts.push(colorXml);
+	if (formatting.spacing !== void 0) parts.push(`<w:spacing w:val="${intAttr(formatting.spacing)}"/>`);
+	if (formatting.scale !== void 0) parts.push(`<w:w w:val="${intAttr(formatting.scale)}"/>`);
+	if (formatting.kerning !== void 0) parts.push(`<w:kern w:val="${intAttr(formatting.kerning)}"/>`);
+	if (formatting.position !== void 0) parts.push(`<w:position w:val="${intAttr(formatting.position)}"/>`);
+	if (formatting.fontSize !== void 0) parts.push(`<w:sz w:val="${intAttr(formatting.fontSize)}"/>`);
+	if (formatting.fontSizeCs !== void 0) parts.push(`<w:szCs w:val="${intAttr(formatting.fontSizeCs)}"/>`);
+	if (formatting.highlight && formatting.highlight !== "none") {
+		if (VALID_HIGHLIGHT_COLORS.has(formatting.highlight)) parts.push(`<w:highlight w:val="${formatting.highlight}"/>`);
+		else if (!formatting.shading) {
+			const hex = formatting.highlight.replace(/^#/u, "");
+			if (/^[0-9a-fA-F]{6}$/u.test(hex)) parts.push(`<w:shd w:val="clear" w:color="auto" w:fill="${hex}"/>`);
+		}
+	}
+	if (formatting.underline) {
+		const uAttrs = [`w:val="${formatting.underline.style}"`];
+		if (formatting.underline.color) {
+			if (formatting.underline.color.rgb) uAttrs.push(`w:color="${formatting.underline.color.rgb}"`);
+			if (formatting.underline.color.themeColor) uAttrs.push(`w:themeColor="${formatting.underline.color.themeColor}"`);
+			if (formatting.underline.color.themeTint) uAttrs.push(`w:themeTint="${formatting.underline.color.themeTint}"`);
+			if (formatting.underline.color.themeShade) uAttrs.push(`w:themeShade="${formatting.underline.color.themeShade}"`);
+		}
+		parts.push(`<w:u ${uAttrs.join(" ")}/>`);
+	}
+	if (formatting.effect && formatting.effect !== "none") parts.push(`<w:effect w:val="${formatting.effect}"/>`);
+	if (formatting.emphasisMark && formatting.emphasisMark !== "none") parts.push(`<w:em w:val="${formatting.emphasisMark}"/>`);
+	const shadingXml = serializeShading(formatting.shading);
+	if (shadingXml) parts.push(shadingXml);
+	if (formatting.vertAlign) parts.push(`<w:vertAlign w:val="${formatting.vertAlign}"/>`);
+	if (formatting.rtl === true) parts.push("<w:rtl/>");
+	else if (formatting.rtl === false) parts.push("<w:rtl w:val=\"0\"/>");
+	if (formatting.cs) parts.push("<w:cs/>");
+	if (parts.length === 0) return "";
+	return `<w:rPr>${parts.join("")}</w:rPr>`;
+}
+function extractRPrInner(rPrXml) {
+	if (!rPrXml.startsWith("<w:rPr>") || !rPrXml.endsWith("</w:rPr>")) return "";
+	return rPrXml.slice(7, -8);
+}
+function serializeRunPropertyChange(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 previousRPrXml = serializeTextFormatting(change.previousFormatting) || "<w:rPr/>";
+	return `<w:rPrChange ${attrs.join(" ")}>${previousRPrXml}</w:rPrChange>`;
+}
+function serializeRunProperties(formatting, propertyChanges) {
+	const currentRPrXml = serializeTextFormatting(formatting);
+	const combined = `${currentRPrXml ? extractRPrInner(currentRPrXml) : ""}${(propertyChanges ?? []).map(serializeRunPropertyChange).join("")}`;
+	if (!combined) return "";
+	return `<w:rPr>${combined}</w:rPr>`;
+}
+/**
+* Serialize text content (w:t)
+*/
+function serializeTextContent(content) {
+	return `<w:t${content.preserveSpace || content.text.startsWith(" ") || content.text.endsWith(" ") || content.text.includes("  ") ? " xml:space=\"preserve\"" : ""}>${escapeXml(content.text)}</w:t>`;
+}
+/**
+* Serialize tab content (w:tab)
+*/
+function serializeTabContent(_content) {
+	return "<w:tab/>";
+}
+/**
+* Serialize break content (w:br)
+*/
+function serializeBreakContent(content) {
+	const attrs = [];
+	if (content.breakType === "page") attrs.push("w:type=\"page\"");
+	else if (content.breakType === "column") attrs.push("w:type=\"column\"");
+	else if (content.breakType === "textWrapping") {
+		attrs.push("w:type=\"textWrapping\"");
+		if (content.clear && content.clear !== "none") attrs.push(`w:clear="${content.clear}"`);
+	}
+	if (attrs.length === 0) return "<w:br/>";
+	return `<w:br ${attrs.join(" ")}/>`;
+}
+/**
+* Serialize symbol content (w:sym)
+*/
+function serializeSymbolContent(content) {
+	return `<w:sym w:font="${escapeXml(content.font)}" w:char="${escapeXml(content.char)}"/>`;
+}
+/**
+* Serialize footnote/endnote reference
+*/
+function serializeNoteReference(content) {
+	if (content.type === "footnoteRef") return `<w:footnoteReference w:id="${content.id}"/>`;
+	return `<w:endnoteReference w:id="${content.id}"/>`;
+}
+/**
+* Serialize field character (w:fldChar)
+*/
+function serializeFieldChar(content) {
+	const attrs = [`w:fldCharType="${content.charType}"`];
+	if (content.fldLock) attrs.push("w:fldLock=\"true\"");
+	if (content.dirty) attrs.push("w:dirty=\"true\"");
+	return `<w:fldChar ${attrs.join(" ")}/>`;
+}
+/**
+* Serialize field instruction text (w:instrText)
+*/
+function serializeInstrText(content) {
+	return `<w:instrText${content.text.startsWith(" ") || content.text.endsWith(" ") || content.text.includes("  ") ? " xml:space=\"preserve\"" : ""}>${escapeXml(content.text)}</w:instrText>`;
+}
+/**
+* Serialize soft hyphen (w:softHyphen)
+*/
+function serializeSoftHyphen(_content) {
+	return "<w:softHyphen/>";
+}
+/**
+* Serialize non-breaking hyphen (w:noBreakHyphen)
+*/
+function serializeNoBreakHyphen(_content) {
+	return "<w:noBreakHyphen/>";
+}
+/** Serialize a color value to DrawingML a:srgbClr or a:schemeClr */
+function serializeDrawingColor(color) {
+	if (!color) return "";
+	if (color.rgb) return `<a:srgbClr val="${color.rgb.replace("#", "")}"/>`;
+	if (color.themeColor) {
+		let clr = `<a:schemeClr val="${color.themeColor}"`;
+		if (color.themeTint) clr += `><a:tint val="${color.themeTint}"/></a:schemeClr>`;
+		else if (color.themeShade) clr += `><a:shade val="${color.themeShade}"/></a:schemeClr>`;
+		else clr += `/>`;
+		return clr;
+	}
+	return "";
+}
+/** Serialize shape fill to DrawingML */
+function serializeFill(fill) {
+	if (!fill || fill.type === "none") return "<a:noFill/>";
+	if (fill.type === "solid" && fill.color) return `<a:solidFill>${serializeDrawingColor(fill.color)}</a:solidFill>`;
+	if (fill.type === "gradient" && fill.gradient) {
+		const g = fill.gradient;
+		return `<a:gradFill><a:gsLst>${g.stops.map((s) => `<a:gs pos="${s.position}">${serializeDrawingColor(s.color)}</a:gs>`).join("")}</a:gsLst>${(() => {
+			if (g.type === "linear") return `<a:lin ang="${(g.angle ?? 0) * 6e4}" scaled="1"/>`;
+			let path = "shape";
+			if (g.type === "radial") path = "circle";
+			else if (g.type === "rectangular") path = "rect";
+			return `<a:path path="${path}"/>`;
+		})()}</a:gradFill>`;
+	}
+	return "";
+}
+/** Serialize shape outline to DrawingML a:ln */
+function serializeLineCap(cap) {
+	if (cap === "round") return "rnd";
+	if (cap === "square") return "sq";
+	return "flat";
+}
+function serializeOutline(outline) {
+	if (!outline) return "";
+	const attrs = [];
+	if (typeof outline.width === "number") attrs.push(`w="${outline.width}"`);
+	if (outline.cap) attrs.push(`cap="${serializeLineCap(outline.cap)}"`);
+	const parts = [];
+	if (outline.color) parts.push(`<a:solidFill>${serializeDrawingColor(outline.color)}</a:solidFill>`);
+	if (outline.style && outline.style !== "solid") parts.push(`<a:prstDash val="${outline.style}"/>`);
+	if (outline.join === "bevel") parts.push("<a:bevel/>");
+	else if (outline.join === "round") parts.push("<a:round/>");
+	else if (outline.join === "miter") parts.push("<a:miter/>");
+	if (outline.headEnd) parts.push(`<a:headEnd type="${outline.headEnd.type}"${outline.headEnd.width ? ` w="${outline.headEnd.width}"` : ""}${outline.headEnd.length ? ` len="${outline.headEnd.length}"` : ""}/>`);
+	if (outline.tailEnd) parts.push(`<a:tailEnd type="${outline.tailEnd.type}"${outline.tailEnd.width ? ` w="${outline.tailEnd.width}"` : ""}${outline.tailEnd.length ? ` len="${outline.tailEnd.length}"` : ""}/>`);
+	if (parts.length === 0 && attrs.length === 0) return "";
+	return `<a:ln${attrs.length ? ` ${attrs.join(" ")}` : ""}>${parts.join("")}</a:ln>`;
+}
+/** Build wp:positionH and wp:positionV for floating drawings */
+function serializePosition(pos) {
+	const parts = [];
+	const h = pos.horizontal;
+	parts.push(`<wp:positionH relativeFrom="${h.relativeTo}">`);
+	if (h.alignment) parts.push(`<wp:align>${h.alignment}</wp:align>`);
+	else parts.push(`<wp:posOffset>${intAttr(h.posOffset)}</wp:posOffset>`);
+	parts.push("</wp:positionH>");
+	const v = pos.vertical;
+	parts.push(`<wp:positionV relativeFrom="${v.relativeTo}">`);
+	if (v.alignment) parts.push(`<wp:align>${v.alignment}</wp:align>`);
+	else parts.push(`<wp:posOffset>${intAttr(v.posOffset)}</wp:posOffset>`);
+	parts.push("</wp:positionV>");
+	return parts.join("");
+}
+/** Serialize wrap type to wp:wrap* element */
+function serializeWrap(wrap) {
+	const wrapText = wrap.wrapText ? ` wrapText="${wrap.wrapText}"` : " wrapText=\"bothSides\"";
+	switch (wrap.type) {
+		case "square": return `<wp:wrapSquare${wrapText}/>`;
+		case "tight": return `<wp:wrapTight${wrapText}><wp:wrapPolygon edited="0"><wp:start x="0" y="0"/><wp:lineTo x="0" y="21600"/><wp:lineTo x="21600" y="21600"/><wp:lineTo x="21600" y="0"/><wp:lineTo x="0" y="0"/></wp:wrapPolygon></wp:wrapTight>`;
+		case "through": return `<wp:wrapThrough${wrapText}><wp:wrapPolygon edited="0"><wp:start x="0" y="0"/><wp:lineTo x="0" y="21600"/><wp:lineTo x="21600" y="21600"/><wp:lineTo x="21600" y="0"/><wp:lineTo x="0" y="0"/></wp:wrapPolygon></wp:wrapThrough>`;
+		case "topAndBottom": return "<wp:wrapTopAndBottom/>";
+		case "behind":
+		case "inFront": return "<wp:wrapNone/>";
+		case "inline": return "<wp:wrapNone/>";
+	}
+}
+/** Build the common a:graphic > pic:pic element for images */
+function serializePicGraphic(image, sharedId) {
+	const cx = image.size.width;
+	const cy = image.size.height;
+	const rId = image.rId || "rId1";
+	const id = sharedId;
+	const name = image.filename || `image${id}`;
+	let xfrmAttrs = "";
+	if (image.transform?.rotation) xfrmAttrs += ` rot="${Math.round(image.transform.rotation * 6e4)}"`;
+	if (image.transform?.flipH) xfrmAttrs += " flipH=\"1\"";
+	if (image.transform?.flipV) xfrmAttrs += " flipV=\"1\"";
+	const cropAttrs = [];
+	if (image.crop?.left) cropAttrs.push(`l="${Math.round(image.crop.left * 1e5)}"`);
+	if (image.crop?.top) cropAttrs.push(`t="${Math.round(image.crop.top * 1e5)}"`);
+	if (image.crop?.right) cropAttrs.push(`r="${Math.round(image.crop.right * 1e5)}"`);
+	if (image.crop?.bottom) cropAttrs.push(`b="${Math.round(image.crop.bottom * 1e5)}"`);
+	const srcRectEl = cropAttrs.length > 0 ? `<a:srcRect ${cropAttrs.join(" ")}/>` : "";
+	const alphaChild = image.opacity !== void 0 && image.opacity < 1 ? `<a:alphaModFix amt="${Math.round(Math.max(0, image.opacity) * 1e5)}"/>` : "";
+	const blipEl = alphaChild ? `<a:blip r:embed="${rId}">${alphaChild}</a:blip>` : `<a:blip r:embed="${rId}"/>`;
+	return [
+		"<a:graphic xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\">",
+		"<a:graphicData uri=\"http://schemas.openxmlformats.org/drawingml/2006/picture\">",
+		"<pic:pic xmlns:pic=\"http://schemas.openxmlformats.org/drawingml/2006/picture\">",
+		"<pic:nvPicPr>",
+		`<pic:cNvPr id="${id}" name="${escapeXml(name)}"${image.alt ? ` descr="${escapeXml(image.alt)}"` : ""}/>`,
+		"<pic:cNvPicPr/>",
+		"</pic:nvPicPr>",
+		"<pic:blipFill>",
+		blipEl,
+		srcRectEl,
+		"<a:stretch><a:fillRect/></a:stretch>",
+		"</pic:blipFill>",
+		"<pic:spPr>",
+		`<a:xfrm${xfrmAttrs}>`,
+		"<a:off x=\"0\" y=\"0\"/>",
+		`<a:ext cx="${intAttr(cx)}" cy="${intAttr(cy)}"/>`,
+		"</a:xfrm>",
+		"<a:prstGeom prst=\"rect\"><a:avLst/></a:prstGeom>",
+		image.outline ? serializeOutline(image.outline) : "",
+		"</pic:spPr>",
+		"</pic:pic>",
+		"</a:graphicData>",
+		"</a:graphic>"
+	].join("");
+}
+/**
+* Serialize drawing/image content (w:drawing) to full DrawingML XML
+*/
+function serializeDrawingContent(content) {
+	const image = content.image;
+	const isFloating = image.wrap.type !== "inline";
+	const cx = image.size.width;
+	const cy = image.size.height;
+	const distT = image.wrap.distT ?? 0;
+	const distB = image.wrap.distB ?? 0;
+	const distL = image.wrap.distL ?? 0;
+	const distR = image.wrap.distR ?? 0;
+	const effL = image.padding?.left ?? 0;
+	const effT = image.padding?.top ?? 0;
+	const effR = image.padding?.right ?? 0;
+	const effB = image.padding?.bottom ?? 0;
+	const effectExtentEl = `<wp:effectExtent l="${intAttr(effL)}" t="${intAttr(effT)}" r="${intAttr(effR)}" b="${intAttr(effB)}"/>`;
+	const docPrId = getUniqueId(image.id);
+	const docPrName = image.title || image.filename || `Picture ${docPrId}`;
+	const graphic = serializePicGraphic(image, docPrId);
+	if (!isFloating) return [
+		"<w:drawing>",
+		`<wp:inline distT="${intAttr(distT)}" distB="${intAttr(distB)}" distL="${intAttr(distL)}" distR="${intAttr(distR)}">`,
+		`<wp:extent cx="${intAttr(cx)}" cy="${intAttr(cy)}"/>`,
+		effectExtentEl,
+		`<wp:docPr id="${docPrId}" name="${escapeXml(docPrName)}"${image.alt ? ` descr="${escapeXml(image.alt)}"` : ""}${image.decorative ? " hidden=\"1\"" : ""}/>`,
+		"<wp:cNvGraphicFramePr><a:graphicFrameLocks xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" noChangeAspect=\"1\"/></wp:cNvGraphicFramePr>",
+		graphic,
+		"</wp:inline>",
+		"</w:drawing>"
+	].join("");
+	const behindDoc = image.wrap.type === "behind" ? "1" : "0";
+	const position = image.position ? serializePosition(image.position) : "<wp:positionH relativeFrom=\"column\"><wp:posOffset>0</wp:posOffset></wp:positionH><wp:positionV relativeFrom=\"paragraph\"><wp:posOffset>0</wp:posOffset></wp:positionV>";
+	const wrap = serializeWrap(image.wrap);
+	const layoutInCellAttr = image.layoutInCell === false ? "0" : "1";
+	const allowOverlapAttr = image.allowOverlap === false ? "0" : "1";
+	return [
+		"<w:drawing>",
+		`<wp:anchor distT="${intAttr(distT)}" distB="${intAttr(distB)}" distL="${intAttr(distL)}" distR="${intAttr(distR)}" simplePos="0" relativeHeight="251658240" behindDoc="${behindDoc}" locked="0" layoutInCell="${layoutInCellAttr}" allowOverlap="${allowOverlapAttr}">`,
+		"<wp:simplePos x=\"0\" y=\"0\"/>",
+		position,
+		`<wp:extent cx="${intAttr(cx)}" cy="${intAttr(cy)}"/>`,
+		effectExtentEl,
+		wrap,
+		`<wp:docPr id="${docPrId}" name="${escapeXml(docPrName)}"${image.alt ? ` descr="${escapeXml(image.alt)}"` : ""}/>`,
+		"<wp:cNvGraphicFramePr><a:graphicFrameLocks xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" noChangeAspect=\"1\"/></wp:cNvGraphicFramePr>",
+		graphic,
+		"</wp:anchor>",
+		"</w:drawing>"
+	].join("");
+}
+/** Serialize text body content for shapes/textboxes */
+function serializeShapeTextBody(paragraphs) {
+	return paragraphs.map((p) => serializeParagraph(p)).join("");
+}
+/**
+* Serialize shape content to full DrawingML XML (wps:wsp inside w:drawing)
+*/
+function serializeShapeContent(content) {
+	const shape = content.shape;
+	const cx = shape.size.width;
+	const cy = shape.size.height;
+	const isTextBox = shape.shapeType === "textBox";
+	const isFloating = shape.wrap && shape.wrap.type !== "inline";
+	const distT = shape.wrap?.distT ?? 0;
+	const distB = shape.wrap?.distB ?? 0;
+	const distL = shape.wrap?.distL ?? 0;
+	const distR = shape.wrap?.distR ?? 0;
+	const docPrId = getUniqueId(shape.id);
+	const docPrName = shape.name || (isTextBox ? `TextBox ${docPrId}` : `Shape ${docPrId}`);
+	let xfrmAttrs = "";
+	if (shape.transform?.rotation) xfrmAttrs += ` rot="${Math.round(shape.transform.rotation * 6e4)}"`;
+	if (shape.transform?.flipH) xfrmAttrs += " flipH=\"1\"";
+	if (shape.transform?.flipV) xfrmAttrs += " flipV=\"1\"";
+	const spPr = [
+		"<wps:spPr>",
+		`<a:xfrm${xfrmAttrs}>`,
+		"<a:off x=\"0\" y=\"0\"/>",
+		`<a:ext cx="${intAttr(cx)}" cy="${intAttr(cy)}"/>`,
+		"</a:xfrm>",
+		`<a:prstGeom prst="${shape.shapeType === "textBox" ? "rect" : shape.shapeType}"><a:avLst/></a:prstGeom>`,
+		serializeFill(shape.fill),
+		serializeOutline(shape.outline),
+		"</wps:spPr>"
+	].join("");
+	let textBody = "";
+	if (shape.textBody) {
+		const tb = shape.textBody;
+		const bpAttrs = ["rot=\"0\"", "vert=\"horz\""];
+		if (tb.anchor) bpAttrs.push(`anchor="${tb.anchor === "middle" ? "ctr" : tb.anchor}"`);
+		if (tb.anchorCenter) bpAttrs.push("anchorCtr=\"1\"");
+		if (tb.margins) {
+			if (tb.margins.left != null) bpAttrs.push(`lIns="${intAttr(tb.margins.left)}"`);
+			if (tb.margins.top != null) bpAttrs.push(`tIns="${intAttr(tb.margins.top)}"`);
+			if (tb.margins.right != null) bpAttrs.push(`rIns="${intAttr(tb.margins.right)}"`);
+			if (tb.margins.bottom != null) bpAttrs.push(`bIns="${intAttr(tb.margins.bottom)}"`);
+		}
+		if (isTextBox) textBody = [
+			"<wps:txbx><w:txbxContent>",
+			serializeShapeTextBody(tb.content),
+			"</w:txbxContent></wps:txbx>",
+			`<wps:bodyPr ${bpAttrs.join(" ")}/>`
+		].join("");
+		else textBody = [`<wps:bodyPr ${bpAttrs.join(" ")}/>`].join("");
+	}
+	const graphic = [
+		"<a:graphic xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\">",
+		"<a:graphicData uri=\"http://schemas.microsoft.com/office/word/2010/wordprocessingShape\">",
+		[
+			"<wps:wsp>",
+			`<wps:cNvSpPr${isTextBox ? " txBox=\"1\"" : ""}/>`,
+			spPr,
+			textBody,
+			"</wps:wsp>"
+		].join(""),
+		"</a:graphicData>",
+		"</a:graphic>"
+	].join("");
+	if (!isFloating) return [
+		"<w:drawing>",
+		`<wp:inline distT="${intAttr(distT)}" distB="${intAttr(distB)}" distL="${intAttr(distL)}" distR="${intAttr(distR)}">`,
+		`<wp:extent cx="${intAttr(cx)}" cy="${intAttr(cy)}"/>`,
+		"<wp:effectExtent l=\"0\" t=\"0\" r=\"0\" b=\"0\"/>",
+		`<wp:docPr id="${docPrId}" name="${escapeXml(docPrName)}"/>`,
+		"<wp:cNvGraphicFramePr/>",
+		graphic,
+		"</wp:inline>",
+		"</w:drawing>"
+	].join("");
+	const behindDoc = shape.wrap?.type === "behind" ? "1" : "0";
+	const position = shape.position ? serializePosition(shape.position) : "<wp:positionH relativeFrom=\"column\"><wp:posOffset>0</wp:posOffset></wp:positionH><wp:positionV relativeFrom=\"paragraph\"><wp:posOffset>0</wp:posOffset></wp:positionV>";
+	if (!shape.wrap) panic("Floating shape must have a wrap property");
+	const wrap = serializeWrap(shape.wrap);
+	return [
+		"<w:drawing>",
+		`<wp:anchor distT="${intAttr(distT)}" distB="${intAttr(distB)}" distL="${intAttr(distL)}" distR="${intAttr(distR)}" simplePos="0" relativeHeight="251658240" behindDoc="${behindDoc}" locked="0" layoutInCell="1" allowOverlap="1">`,
+		"<wp:simplePos x=\"0\" y=\"0\"/>",
+		position,
+		`<wp:extent cx="${intAttr(cx)}" cy="${intAttr(cy)}"/>`,
+		"<wp:effectExtent l=\"0\" t=\"0\" r=\"0\" b=\"0\"/>",
+		wrap,
+		`<wp:docPr id="${docPrId}" name="${escapeXml(docPrName)}"/>`,
+		"<wp:cNvGraphicFramePr/>",
+		graphic,
+		"</wp:anchor>",
+		"</w:drawing>"
+	].join("");
+}
+/**
+* Serialize a single run content item
+*/
+function serializeRunContent(content) {
+	switch (content.type) {
+		case "text": return serializeTextContent(content);
+		case "tab": return serializeTabContent(content);
+		case "break": return serializeBreakContent(content);
+		case "symbol": return serializeSymbolContent(content);
+		case "footnoteRef":
+		case "endnoteRef": return serializeNoteReference(content);
+		case "fieldChar": return serializeFieldChar(content);
+		case "instrText": return serializeInstrText(content);
+		case "softHyphen": return serializeSoftHyphen(content);
+		case "noBreakHyphen": return serializeNoBreakHyphen(content);
+		case "drawing":
+			if (content.rawXml) return content.rawXml;
+			return serializeDrawingContent(content);
+		case "shape": return serializeShapeContent(content);
+		default: return "";
+	}
+}
+/**
+* Serialize a run to OOXML XML (w:r)
+*
+* @param run - The run to serialize
+* @returns XML string for the run
+*/
+function serializeRun(run) {
+	const parts = [];
+	const rPrXml = serializeRunProperties(run.formatting, run.propertyChanges);
+	if (rPrXml) parts.push(rPrXml);
+	for (const content of run.content) {
+		const contentXml = serializeRunContent(content);
+		if (contentXml) parts.push(contentXml);
+	}
+	return `<w:r>${parts.join("")}</w:r>`;
+}
+/**
+* Serialize multiple runs to OOXML XML
+*
+* @param runs - The runs to serialize
+* @returns XML string for all runs
+*/
+function serializeRuns(runs) {
+	return runs.map(serializeRun).join("");
+}
+/**
+* Check if a run has any content
+*/
+function hasRunContent(run) {
+	return run.content.length > 0;
+}
+/**
+* Check if a run has formatting
+*/
+function hasRunFormatting(run) {
+	return run.formatting !== void 0 && Object.keys(run.formatting).length > 0;
+}
+/**
+* Get plain text from a run (for comparison/debugging)
+*/
+function getRunPlainText(run) {
+	return run.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+}
+/**
+* Create an empty run
+*/
+function createEmptyRun() {
+	return {
+		type: "run",
+		content: []
+	};
+}
+/**
+* Create a text run
+*/
+function createTextRun(text, formatting) {
+	return {
+		type: "run",
+		...formatting !== void 0 ? { formatting } : {},
+		content: [{
+			type: "text",
+			text
+		}]
+	};
+}
+/**
+* Create a break run
+*/
+function createBreakRun(breakType, formatting) {
+	return {
+		type: "run",
+		...formatting !== void 0 ? { formatting } : {},
+		content: [{
+			type: "break",
+			...breakType !== void 0 ? { breakType } : {}
+		}]
+	};
+}
+/**
+* Create a tab run
+*/
+function createTabRun(formatting) {
+	return {
+		type: "run",
+		...formatting !== void 0 ? { formatting } : {},
+		content: [{ type: "tab" }]
+	};
+}
+//#endregion
+export { createBreakRun, createEmptyRun, createTabRun, createTextRun, getRunPlainText, hasRunContent, hasRunFormatting, resetAutoIdCounter, serializeRun, serializeRuns, serializeTextFormatting };

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

@@ -0,0 +1,6 @@
+import { document_d_exports } from "../../types/document.js";
+
+//#region src/docx/serializer/sectionPropertiesSerializer.d.ts
+declare function serializeSectionProperties(props: document_d_exports.SectionProperties | undefined): string;
+//#endregion
+export { serializeSectionProperties };