@stll/folio-core 0.48.0 → 0.49.0

package/dist/docx/selectiveXmlPatch.js

@@ -108,24 +108,53 @@ function buildParagraphOffsetIndex(xml) {
 	for (const [id, range] of ranges) if (seenCount.get(id) === 1) index.set(id, range);
 	return index;
 }
+/** The containers {@link scanParagraphs} tracks, by the literal tag the part writes. */
+const TRACKED_CONTAINERS = [
+	{
+		name: "mc:Fallback",
+		key: "fallback"
+	},
+	{
+		name: "mc:AlternateContent",
+		key: "alternateContent"
+	},
+	{
+		name: "w:txbxContent",
+		key: "textBox"
+	},
+	{
+		name: "w:tc",
+		key: "tableCell"
+	}
+].map(({ name, key }) => ({
+	key,
+	open: `<${name}`,
+	close: `</${name}>`
+}));
 /**
 * Every `<w:p>` element of `xml`, in the document order of its opening tags,
-* with the `w14:paraId` that tag carries.
+* with the `w14:paraId` that tag carries and the containers around it.
 *
-* Document order is what makes the array an ordinal space: the *n*th entry of
-* the source part and the *n*th entry of the model's serialization name the
-* same paragraph, which is the only way to address a paragraph the producer
-* gave no id. A `<w:p>` nested inside another (inside `mc:AlternateContent`,
-* a text box) is one entry of its own, exactly as
-* {@link countParagraphElements} counts it, so the two never disagree about
-* what an ordinal is. An unterminated paragraph keeps `end === start`: it
-* occupies its ordinal but no splice can be built from it.
+* Document order is what makes the array an ordinal space: within one story
+* (see {@link ParagraphContainer}), the *n*th paragraph of the source part and
+* the *n*th paragraph of the model's serialization name the same paragraph,
+* which is the only way to address a paragraph the producer gave no id. A
+* `<w:p>` nested inside another (inside `mc:AlternateContent`, a text box) is
+* one entry of its own, exactly as {@link countParagraphElements} counts it.
+* An unterminated paragraph keeps `end === start`: it occupies its ordinal but
+* no splice can be built from it.
 */
 function scanParagraphs(xml) {
 	const paragraphs = [];
 	const open = [];
+	const depth = {
+		fallback: 0,
+		alternateContent: 0,
+		textBox: 0,
+		tableCell: 0
+	};
 	let pos = 0;
-	while (pos < xml.length) {
+	scan: while (pos < xml.length) {
 		const tagStart = xml.indexOf("<", pos);
 		if (tagStart === -1) break;
 		if (xml.startsWith("</w:p>", tagStart)) {
@@ -136,6 +165,20 @@ function scanParagraphs(xml) {
 			pos = end;
 			continue;
 		}
+		for (const { key, open: openLiteral, close } of TRACKED_CONTAINERS) {
+			if (xml.startsWith(close, tagStart)) {
+				depth[key] = Math.max(0, depth[key] - 1);
+				pos = tagStart + close.length;
+				continue scan;
+			}
+			if (xml.startsWith(openLiteral, tagStart) && isXmlNameBoundary(xml[tagStart + openLiteral.length])) {
+				const tagEnd = xml.indexOf(">", tagStart);
+				if (tagEnd === -1) break scan;
+				if (xml[tagEnd - 1] !== "/") depth[key] += 1;
+				pos = tagEnd + 1;
+				continue scan;
+			}
+		}
 		if (!xml.startsWith("<w:p", tagStart) || !isXmlNameBoundary(xml[tagStart + 4])) {
 			pos = tagStart + 1;
 			continue;
@@ -144,17 +187,25 @@ function scanParagraphs(xml) {
 		if (tagEnd === -1) break;
 		const openTag = xml.slice(tagStart, tagEnd + 1);
 		const paraId = /\bw14:paraId="(?<id>[^"]+)"/u.exec(openTag)?.groups?.["id"];
+		const container = {
+			inFallback: depth.fallback > 0,
+			inAlternateContent: depth.alternateContent > 0,
+			textBoxDepth: depth.textBox,
+			tableDepth: depth.tableCell
+		};
 		if (xml[tagEnd - 1] === "/") paragraphs.push({
 			start: tagStart,
 			end: tagEnd + 1,
-			paraId
+			paraId,
+			container
 		});
 		else {
 			open.push(paragraphs.length);
 			paragraphs.push({
 				start: tagStart,
 				end: tagStart,
-				paraId
+				paraId,
+				container
 			});
 		}
 		pos = tagEnd + 1;
@@ -208,98 +259,169 @@ const withoutMintedIds = (paragraphXml, sourceOpenTag) => {
 	if (tagEnd === -1) return paragraphXml;
 	return paragraphXml.slice(0, tagEnd + 1).replace(MINTED_PARA_ID_ATTRIBUTE, (attribute) => sourceOpenTag.includes(attribute.trim()) ? attribute : "") + paragraphXml.slice(tagEnd + 1);
 };
+const storyOf = ({ textBoxDepth }) => textBoxDepth > 0 ? "text-box" : "main";
+const sameContainer = (a, b) => a.inAlternateContent === b.inAlternateContent && a.textBoxDepth === b.textBoxDepth && a.tableDepth === b.tableDepth;
+const addressableParagraphs = (xml) => {
+	const stories = /* @__PURE__ */ new Map();
+	const ordinals = /* @__PURE__ */ new Map();
+	const byParaId = /* @__PURE__ */ new Map();
+	for (const paragraph of scanParagraphs(xml)) {
+		if (paragraph.container.inFallback) continue;
+		const story = storyOf(paragraph.container);
+		const sequence = stories.get(story) ?? [];
+		ordinals.set(paragraph, sequence.length);
+		sequence.push(paragraph);
+		stories.set(story, sequence);
+		if (paragraph.paraId !== void 0) {
+			const named = byParaId.get(paragraph.paraId) ?? [];
+			named.push(paragraph);
+			byParaId.set(paragraph.paraId, named);
+		}
+	}
+	return {
+		stories,
+		ordinals,
+		byParaId
+	};
+};
+/** The paraIds written on `<w:p>` elements inside `mc:Fallback`. */
+const fallbackParaIds = (xml) => new Set(scanParagraphs(xml).filter(({ container, paraId }) => container.inFallback && paraId !== void 0).map(({ paraId }) => paraId));
+/**
+* The prefix of the part's root element. The scan reads WordprocessingML by
+* its conventional `w:` prefix, so a part that binds it to another prefix has
+* no paragraphs the scan can see, and a spliced `w:` paragraph would not
+* resolve under its root.
+*/
+const rootElementName = (xml) => /<(?<name>[A-Za-z_][\w.-]*(?::[\w.-]+)?)/u.exec(xml)?.groups?.["name"];
+/**
+* The id of the nearest paragraph on one side of `paragraph` in its story that
+* both parts name exactly once: the witness that places it in its story.
+*/
+const nearestSharedParaId = (own, other, paragraph, step) => {
+	const sequence = own.stories.get(storyOf(paragraph.container)) ?? [];
+	for (let ordinal = (own.ordinals.get(paragraph) ?? -1) + step; ordinal >= 0 && ordinal < sequence.length; ordinal += step) {
+		const paraId = sequence[ordinal]?.paraId;
+		if (paraId !== void 0 && own.byParaId.get(paraId)?.length === 1 && other.byParaId.get(paraId)?.length === 1) return paraId;
+	}
+	return null;
+};
 /**
 * Route every changed paragraph from the model's serialization to its region
 * of the source part.
 *
 * One owner for the question the patch turns on: *which paragraph of the file
-* is this model paragraph?* {@link resolveParagraphIdentities} answers it per
-* paragraph, and the union is consumed exhaustively here, so a paragraph the
-* source names by id keeps the id lookup — robust to any reordering — and one
-* the source never named falls back to its ordinal, which is sound exactly
-* when the identity plan says the two sequences line up. A package with ids on
-* some paragraphs and not others therefore needs no special case: its authored
-* ids are the witnesses that prove the ordinals for the rest.
+* is this model paragraph?* The answer is local to the paragraph. A paraId the
+* source writes once names it, robust to anything the model does elsewhere; a
+* paragraph the source never named is located by its ordinal within its story,
+* which is sound exactly when {@link resolveParagraphIdentities} says that
+* story lines up. Nothing else in the part has to agree: the model may drop a
+* text box it cannot read or write a Fallback it does not own, and an edit in
+* the main flow is still one paragraph of the main flow.
+*
+* What the routing still refuses is a paragraph it cannot place with
+* certainty, or one whose place changed:
+* - a paraId missing from, or written twice by, either part (among the
+*   paragraphs outside `mc:Fallback`);
+* - an id the source writes only inside `mc:Fallback`, which the model does
+*   not own;
+* - a paragraph inside `mc:AlternateContent`, whose Fallback repeats it and
+*   would contradict the edited Choice;
+* - a paragraph whose container (table-cell nesting, text box, alternate
+*   content) differs between the two parts;
+* - an authored paragraph whose nearest shared neighbours differ, i.e. that
+*   moved within its story;
+* - an id-less paragraph whose story's ordinals do not line up.
 */
 const routeChangedParagraphs = (originalXml, serializedXml, changedIds) => {
-	const original = scanParagraphs(originalXml);
-	const serialized = scanParagraphs(serializedXml);
-	const { identities, ordinalsAligned } = resolveParagraphIdentities({
-		sourceParaIds: original.map(({ paraId }) => paraId),
-		serializedParaIds: serialized.map(({ paraId }) => paraId)
-	});
-	const originalParaIds = collectParaIds(originalXml);
-	const serializedParaIds = collectParaIds(serializedXml);
-	const identityByParaId = /* @__PURE__ */ new Map();
-	for (const identity of identities) if (identity.type !== "anonymous" && serializedParaIds.get(identity.paraId) === 1) identityByParaId.set(identity.paraId, identity);
+	const rootName = rootElementName(originalXml);
+	if (rootName !== void 0 && !rootName.startsWith("w:")) return {
+		type: "refused",
+		reason: `non-canonical-wordprocessingml-prefix: ${rootName}`
+	};
+	const original = addressableParagraphs(originalXml);
+	const serialized = addressableParagraphs(serializedXml);
+	let originalFallbackIds;
+	const storyAlignment = /* @__PURE__ */ new Map();
+	const storyAligned = (story) => {
+		let aligned = storyAlignment.get(story);
+		if (aligned === void 0) {
+			aligned = resolveParagraphIdentities({
+				sourceParaIds: (original.stories.get(story) ?? []).map(({ paraId }) => paraId),
+				serializedParaIds: (serialized.stories.get(story) ?? []).map(({ paraId }) => paraId)
+			}).ordinalsAligned;
+			storyAlignment.set(story, aligned);
+		}
+		return aligned;
+	};
 	const splices = [];
 	for (const id of changedIds) {
-		const originalCount = originalParaIds.get(id) ?? 0;
-		if (originalCount > 1) return {
+		const inOriginal = original.byParaId.get(id) ?? [];
+		const inSerialized = serialized.byParaId.get(id) ?? [];
+		if (inOriginal.length > 1) return {
 			type: "refused",
 			reason: `duplicate-paraId-in-original: ${id}`
 		};
-		const serializedCount = serializedParaIds.get(id) ?? 0;
-		if (originalCount === 1 && serializedCount === 0) return {
+		if (inOriginal.length === 1 && inSerialized.length === 0) return {
 			type: "refused",
 			reason: `paraId-not-found-in-serialized: ${id}`
 		};
-		if (serializedCount === 0) return {
+		if (inSerialized.length === 0) return {
 			type: "refused",
 			reason: `paraId-not-found-in-original: ${id}`
 		};
-		if (serializedCount > 1) return {
+		if (inSerialized.length > 1) return {
 			type: "refused",
 			reason: `duplicate-paraId-in-serialized: ${id}`
 		};
-		const identity = identityByParaId.get(id);
-		if (!identity) return {
-			type: "refused",
-			reason: `paraId-not-found-in-serialized: ${id}`
-		};
-		const replacement = serialized[identity.ordinal];
-		if (!replacement || replacement.end <= replacement.start) return {
+		const replacement = inSerialized[0];
+		if (replacement.end <= replacement.start) return {
 			type: "refused",
 			reason: `unterminated-paragraph: ${id}`
 		};
 		const newXml = serializedXml.slice(replacement.start, replacement.end);
-		switch (identity.type) {
-			case "authored": {
-				const offsets = findParagraphOffsets(originalXml, identity.paraId);
-				if (!offsets) return {
-					type: "refused",
-					reason: `paraId-not-found-in-original: ${id}`
-				};
-				splices.push({
-					start: offsets.start,
-					end: offsets.end,
-					newXml
-				});
-				break;
-			}
-			case "minted": {
-				if (!ordinalsAligned) return {
-					type: "refused",
-					reason: `unaligned-paragraph-ordinals: ${id}`
-				};
-				const source = original[identity.ordinal];
-				if (!source || source.end <= source.start) return {
-					type: "refused",
-					reason: `paraId-not-found-in-original: ${id}`
-				};
-				splices.push({
-					start: source.start,
-					end: source.end,
-					newXml: withoutMintedIds(newXml, originalXml.slice(source.start, source.end))
-				});
-				break;
-			}
-			case "anonymous": return {
+		const authored = inOriginal[0];
+		let source;
+		if (authored) source = authored;
+		else {
+			originalFallbackIds ??= fallbackParaIds(originalXml);
+			if (originalFallbackIds.has(id)) return {
+				type: "refused",
+				reason: `paraId-only-in-fallback: ${id}`
+			};
+			const story = storyOf(replacement.container);
+			if (!storyAligned(story)) return {
 				type: "refused",
-				reason: `paraId-not-found-in-serialized: ${id}`
+				reason: `unaligned-paragraph-ordinals: ${id}`
 			};
-			default: return identity;
+			const positional = original.stories.get(story)?.[serialized.ordinals.get(replacement) ?? -1];
+			if (!positional) return {
+				type: "refused",
+				reason: `paraId-not-found-in-original: ${id}`
+			};
+			source = positional;
 		}
+		if (source.end <= source.start) return {
+			type: "refused",
+			reason: `unterminated-paragraph: ${id}`
+		};
+		if (source.container.inAlternateContent) return {
+			type: "refused",
+			reason: `paragraph-in-alternate-content: ${id}`
+		};
+		if (!sameContainer(source.container, replacement.container)) return {
+			type: "refused",
+			reason: `container-changed: ${id}`
+		};
+		if (authored && (nearestSharedParaId(original, serialized, source, -1) !== nearestSharedParaId(serialized, original, replacement, -1) || nearestSharedParaId(original, serialized, source, 1) !== nearestSharedParaId(serialized, original, replacement, 1))) return {
+			type: "refused",
+			reason: `paragraph-moved: ${id}`
+		};
+		const sourceXml = originalXml.slice(source.start, source.end);
+		splices.push({
+			start: source.start,
+			end: source.end,
+			newXml: authored ? newXml : withoutMintedIds(newXml, sourceXml)
+		});
 	}
 	return {
 		type: "routed",
@@ -307,60 +429,56 @@ const routeChangedParagraphs = (originalXml, serializedXml, changedIds) => {
 	};
 };
 /**
-* Validate that a selective patch can be safely applied.
+* Validate that a selective patch can be safely applied: every changed
+* paragraph routes to exactly one region of the original part (see
+* {@link routeChangedParagraphs} for what is refused and why).
 *
-* Checks:
-* - Every changed paraId routes to one region of the original XML, by its
-*   authored id or, when the producer wrote none, by its paragraph ordinal
-* - All changed paraIds exist in serialized XML (exactly once)
-* - Paragraph count matches between original and serialized (unless disabled)
+* The rest of the part does not have to match the model's serialization. The
+* splice keeps every unchanged byte of the source, so a paragraph the model
+* represents differently elsewhere (a text box it re-reads, a Fallback it
+* does not own) is simply kept as the source wrote it.
 */
-function validatePatchSafety(originalXml, serializedXml, changedIds, options = {}) {
+function validatePatchSafety(originalXml, serializedXml, changedIds) {
 	if (changedIds.size === 0) return { safe: true };
 	const routing = routeChangedParagraphs(originalXml, serializedXml, changedIds);
-	if (routing.type === "refused") return {
+	return routing.type === "refused" ? {
 		safe: false,
 		reason: routing.reason
-	};
-	if (options.checkParagraphCount === false) return { safe: true };
-	const originalCount = countParagraphElements(originalXml);
-	const serializedCount = countParagraphElements(serializedXml);
-	if (originalCount !== serializedCount) return {
-		safe: false,
-		reason: `paragraph-count-mismatch: original=${originalCount}, serialized=${serializedCount}`
-	};
-	return { safe: true };
+	} : { safe: true };
 }
 /**
 * Build a patched document.xml by splicing new paragraph XML into
 * the original at the correct offsets. Only changed paragraphs
 * are replaced; everything else is preserved byte-for-byte.
 *
-* Returns null if any step fails.
+* Returns null when a changed paragraph cannot be routed (see
+* {@link validatePatchSafety}) or {@link spliceXml} refuses the result; the
+* caller then falls back to a full repack, whose parts are all re-serialized
+* from one model.
 */
 function buildPatchedDocumentXml(originalXml, serializedXml, changedIds) {
 	if (changedIds.size === 0) return originalXml;
-	if (!validatePatchSafety(originalXml, serializedXml, changedIds).safe) return null;
-	return spliceChangedParagraphs(originalXml, serializedXml, changedIds);
+	const routing = routeChangedParagraphs(originalXml, serializedXml, changedIds);
+	return routing.type === "refused" ? null : spliceXml(originalXml, routing.splices);
 }
 /**
 * Build a patched note part (word/footnotes.xml / word/endnotes.xml) by
 * splicing edited note paragraphs into the original, preserving unchanged
 * content byte-for-byte.
 *
-* Unlike {@link buildPatchedDocumentXml} this does NOT require the paragraph
-* counts to match: the document model only retains the normal notes, so the
-* serialized note XML omits the separator / continuationSeparator paragraphs
-* the original part still carries. Splicing by `paraId` keeps those separators
-* and every unedited note byte-exact while replacing only the edited ones.
+* The routing is the document's: the model only retains the normal notes, so
+* the serialized note XML omits the separator / continuationSeparator
+* paragraphs the original part still carries, and splicing by `paraId` keeps
+* those separators and every unedited note byte-exact while replacing only the
+* edited ones. (An id-less note paragraph does not route here, because the
+* separators misalign its story's ordinals; {@link buildPatchedNotePartXml}
+* addresses it by note instead.)
 *
 * Returns null if any changed id is missing or ambiguous in either input, so
 * the caller can fall back to preserving the original part verbatim.
 */
 function buildPatchedNoteXml(originalXml, serializedXml, changedIds) {
-	if (changedIds.size === 0) return originalXml;
-	if (!validatePatchSafety(originalXml, serializedXml, changedIds, { checkParagraphCount: false }).safe) return null;
-	return spliceChangedParagraphs(originalXml, serializedXml, changedIds);
+	return buildPatchedDocumentXml(originalXml, serializedXml, changedIds);
 }
 /**
 * Apply `splices` to `xml`, end-to-start so earlier offsets stay valid.
@@ -379,17 +497,6 @@ const spliceXml = (xml, splices) => {
 	return patchBreaksCommentRangeBalance(xml, result) ? null : result;
 };
 /**
-* Replace each changed paragraph in `originalXml` with its re-serialized form
-* extracted from `serializedXml`. Assumes safety has already been validated.
-* Returns null if an offset or extraction unexpectedly fails, or if
-* {@link spliceXml} refuses the result; the caller then falls back to a full
-* repack, whose parts are all re-serialized from one model.
-*/
-function spliceChangedParagraphs(originalXml, serializedXml, changedIds) {
-	const routing = routeChangedParagraphs(originalXml, serializedXml, changedIds);
-	return routing.type === "refused" ? null : spliceXml(originalXml, routing.splices);
-}
-/**
 * Depth-count the end of the element that opens at `start` (an `<openLiteral…>`
 * offset), returning its full range. Nested same-name opens increment depth;
 * the matching `closeTag` (or a self-close) at depth 0 ends it. The boundary

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

@@ -0,0 +1,12 @@
+import { document_d_exports } from "../../types/document.js";
+//#region src/docx/serializer/groupTextBoxWriteBack.d.ts
+type SerializeTextBody = (blocks: document_d_exports.ShapeTextBody["content"]) => string;
+/**
+ * The paragraph content as it should be written: lifted text boxes dropped,
+ * and the drawing of each group whose text changed carrying the new text.
+ *
+ * Returns the paragraph's own content when it holds no lifted text box.
+ */
+declare const writeGroupTextBoxesBack: (paragraph: document_d_exports.Paragraph, serializeTextBody: SerializeTextBody) => readonly document_d_exports.ParagraphContent[];
+//#endregion
+export { writeGroupTextBoxesBack };

package/dist/docx/serializer/groupTextBoxWriteBack.js

@@ -0,0 +1,101 @@
+import { groupTextContentFingerprint, groupXmlFingerprint, replaceGroupTextBoxContent } from "../drawingGroupChildren.js";
+//#region src/docx/serializer/groupTextBoxWriteBack.ts
+/** Every run in document order, through the containers a text box is lifted from. */
+const forEachRun = (content, onRun) => {
+	for (const item of content) switch (item.type) {
+		case "run":
+			onRun(item);
+			break;
+		case "hyperlink":
+			forEachRun(item.children, onRun);
+			break;
+		case "inlineSdt":
+		case "insertion":
+		case "deletion":
+		case "moveFrom":
+		case "moveTo":
+			forEachRun(item.content, onRun);
+			break;
+		default: break;
+	}
+};
+/** The same walk, rebuilding each container whose runs changed. */
+const mapRuns = (content, mapRun) => content.map((item) => {
+	switch (item.type) {
+		case "run": return mapRun(item);
+		case "hyperlink": return {
+			...item,
+			children: mapRuns(item.children, mapRun)
+		};
+		case "inlineSdt":
+		case "insertion":
+		case "deletion":
+		case "moveFrom":
+		case "moveTo": return {
+			...item,
+			content: mapRuns(item.content, mapRun)
+		};
+		default: return item;
+	}
+});
+const isGroupDrawing = (content) => content.type === "drawing" && content.rawXml !== void 0 && content.rawXml.includes("wgp");
+const isGroupChild = (content) => content.type === "shape" && content.shape.groupChild !== void 0;
+/**
+* The paragraph content as it should be written: lifted text boxes dropped,
+* and the drawing of each group whose text changed carrying the new text.
+*
+* Returns the paragraph's own content when it holds no lifted text box.
+*/
+const writeGroupTextBoxesBack = (paragraph, serializeTextBody) => {
+	const members = [];
+	const groups = [];
+	forEachRun(paragraph.content, (run) => {
+		for (const content of run.content) if (isGroupDrawing(content)) groups.push({
+			drawing: content,
+			fingerprint: groupXmlFingerprint(content.rawXml)
+		});
+		else if (isGroupChild(content)) {
+			const wanted = content.shape.groupChild?.group;
+			members.push({
+				member: content,
+				group: groups.findLast((candidate) => candidate.fingerprint === wanted)
+			});
+		}
+	});
+	if (members.length === 0) return paragraph.content;
+	const absorbed = /* @__PURE__ */ new Set();
+	const editsByDrawing = /* @__PURE__ */ new Map();
+	const claimedPaths = /* @__PURE__ */ new Map();
+	for (const { member, group } of members) {
+		const groupChild = member.shape.groupChild;
+		if (!group || !groupChild) continue;
+		const pathKey = groupChild.path.join("/");
+		const claimed = claimedPaths.get(group.drawing) ?? /* @__PURE__ */ new Set();
+		if (claimed.has(pathKey)) continue;
+		claimed.add(pathKey);
+		claimedPaths.set(group.drawing, claimed);
+		absorbed.add(member);
+		const content = member.shape.textBody?.content ?? [];
+		if (groupTextContentFingerprint(content) === groupChild.content) continue;
+		const edits = editsByDrawing.get(group.drawing) ?? [];
+		edits.push({
+			path: groupChild.path,
+			contentXml: serializeTextBody(content)
+		});
+		editsByDrawing.set(group.drawing, edits);
+	}
+	const rewritten = /* @__PURE__ */ new Map();
+	for (const [drawing, edits] of editsByDrawing) {
+		const rawXml = drawing.rawXml === void 0 ? void 0 : replaceGroupTextBoxContent(drawing.rawXml, edits);
+		if (rawXml !== void 0) rewritten.set(drawing, {
+			...drawing,
+			rawXml
+		});
+	}
+	return mapRuns(paragraph.content, (run) => run.content.some((content) => absorbed.has(content) || rewritten.has(content)) ? {
+		...run,
+		content: run.content.filter((content) => !absorbed.has(content)).map((content) => rewritten.get(content) ?? content)
+	} : run);
+};
+//#endregion
+export { writeGroupTextBoxesBack };

package/dist/docx/serializer/paragraphSerializer.js

@@ -7,8 +7,9 @@ import { DATE_UTC_ATTRIBUTE } from "../trackedChangeInfo.js";
 import { toTransitionalNamespaceUri } from "../transitionalSpelling.js";
 import { captureVerbatimXml, createCapturedXmlSanitizer } from "../verbatimCapture.js";
 import { NAMESPACES, OOXML_NAMESPACE_SCOPE, cloneElement, getChildElements, getLocalName, parseXml } from "../xmlParser.js";
+import { writeGroupTextBoxesBack } from "./groupTextBoxWriteBack.js";
 import { markupRangeAttributes, moveBookmarkAttributes, serializeBookmarkMarker } from "./markupRangeAttributes.js";
-import { serializeRun } from "./runSerializer.js";
+import { serializeRun, serializeShapeTextBody } from "./runSerializer.js";
 import { serializeSdtWrapper } from "./sdtPropertiesSerializer.js";
 import { serializeSectionProperties } from "./sectionPropertiesSerializer.js";
 import { serializeTextFormatting } from "./textFormattingSerializer.js";
@@ -321,7 +322,7 @@ function serializeSimpleField(field) {
 */
 function serializeComplexField(field) {
 	const parts = [];
-	const structuralFormatting = field.formatting ?? field.fieldResult[0]?.formatting;
+	const structuralFormatting = field.formatting ?? (field.fieldResultIsFallback ? void 0 : field.fieldResult[0]?.formatting);
 	const rPrXml = structuralFormatting ? serializeTextFormatting(structuralFormatting) : "";
 	const beginAttrs = ["w:fldCharType=\"begin\"", ...fieldStateAttributes(field)];
 	parts.push(`<w:r>${rPrXml}<w:fldChar ${beginAttrs.join(" ")}/></w:r>`);
@@ -331,7 +332,7 @@ function serializeComplexField(field) {
 		parts.push(`<w:r>${rPrXml}<w:instrText${spaceAttr}>${escapeXmlText(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)));
+	if (!field.fieldResultIsFallback) parts.push(...field.fieldResult.map((run) => serializeRun(run)));
 	parts.push(`<w:r>${rPrXml}<w:fldChar w:fldCharType="end"/></w:r>`);
 	return parts.join("");
 }
@@ -558,7 +559,7 @@ function serializeParagraph(paragraph) {
 		sectionProperties: paragraph.sectionProperties
 	}));
 	let pendingRenderedPageBreak = paragraph.renderedPageBreakBefore === true;
-	for (const content of paragraph.content) {
+	for (const content of writeGroupTextBoxesBack(paragraph, serializeShapeTextBody)) {
 		let contentXml = serializeParagraphContent(content);
 		if (contentXml) {
 			if (pendingRenderedPageBreak) {

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

@@ -5,6 +5,10 @@ import { document_d_exports } from "../../types/document.js";
  * to keep IDs deterministic across saves.
  */
 declare function resetAutoIdCounter(): void;
+/** Serialize text body content for shapes/textboxes */
+declare function serializeShapeTextBody(blocks: Extract<document_d_exports.BlockContent, {
+  type: "paragraph" | "table";
+}>[]): string;
 /**
  * Serialize a run to OOXML XML (w:r)
  *
@@ -44,4 +48,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, hasRunFormatting, resetAutoIdCounter, serializeRun, serializeRuns };
+export { createBreakRun, createEmptyRun, createTabRun, createTextRun, getRunPlainText, hasRunFormatting, resetAutoIdCounter, serializeRun, serializeRuns, serializeShapeTextBody };

package/dist/docx/serializer/runSerializer.js

@@ -8,6 +8,7 @@ import { DECORATIVE_EXTENSION_URI, DECORATIVE_NAMESPACE } from "../imageParser.j
 import { canReplayEditableImageRawXml } from "../imageRawXml.js";
 import { serializeNonVisualDrawingNames } from "../nonVisualDrawingProps.js";
 import { runHoldsPayload } from "../runPayload.js";
+import { replayableShapeAlternateContent } from "../shapeAlternateContent.js";
 import { requiredWrapPolygon, serializeWrapPolygon } from "../wrapPolygon.js";
 import { serializeParagraph } from "./paragraphSerializer.js";
 import { serializeTable } from "./tableSerializer.js";
@@ -148,7 +149,7 @@ function serializeFill(fill) {
 	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"/>`;
+			if (g.type === "linear") return `<a:lin ang="${(g.angle ?? 0) * 6e4}" scaled="${g.scaled === false ? 0 : 1}"/>`;
 			let path = "shape";
 			if (g.type === "radial") path = "circle";
 			else if (g.type === "rectangular") path = "rect";
@@ -544,7 +545,7 @@ function serializeRunContent(content) {
 		case "drawing":
 			if (content.rawXml && canReplayEditableImageRawXml(content)) return content.rawXml;
 			return serializeDrawingContent(content);
-		case "shape": return serializeShapeContent(content);
+		case "shape": return replayableShapeAlternateContent(content) ?? serializeShapeContent(content);
 		default: return "";
 	}
 }
@@ -633,4 +634,4 @@ function createTabRun(formatting) {
 	};
 }
 //#endregion
-export { createBreakRun, createEmptyRun, createTabRun, createTextRun, getRunPlainText, hasRunFormatting, resetAutoIdCounter, serializeRun, serializeRuns };
+export { createBreakRun, createEmptyRun, createTabRun, createTextRun, getRunPlainText, hasRunFormatting, resetAutoIdCounter, serializeRun, serializeRuns, serializeShapeTextBody };