@stll/folio-core 0.51.0 → 0.53.0

package/dist/internal/wholeStoryRevisionResolution.js

@@ -0,0 +1,530 @@
+import { getProseParagraphPropertySourceToken, recreateProseNodeWithParagraphPropertySource } from "../docx/paragraphPropertySource.js";
+import { anchoredTextBoxId, droppedTextBoxAnchorIds } from "../prosemirror/anchoredTextBoxes.js";
+import { expectParagraphAttrs } from "../prosemirror/attrs/index.js";
+import { inlineBookmarksOf } from "../prosemirror/commands/paragraphBookmarkJoin.js";
+import { resolveAllTableChanges } from "../prosemirror/commands/resolveAllTableChanges.js";
+import { resolveAllNodePropertyChangeAttrs } from "../prosemirror/commands/resolveNodePropertyChangeAttrs.js";
+import { resolveParagraphChangeAttrs } from "../prosemirror/commands/resolveParagraphProperties.js";
+import { expandRunFormattingCarrier } from "../prosemirror/runFormattingInlineCarriers.js";
+import { readAuthoredRunFormatting, reconcileRunFormattingMarks } from "../prosemirror/runFormattingReconciliation.js";
+import { paragraphRunStyleContext } from "../prosemirror/runStyleFormatting.js";
+import { holdsNoContent } from "../prosemirror/zeroWidthAnchors.js";
+import { recordNodeResolution } from "./revisionResolutionEdits.js";
+import { resolveInlineRevisions } from "./revisionResolutionInline.js";
+import { composeRevisionResolutionMaps } from "./revisionResolutionStep.js";
+import { REVIEW_CARRIERS } from "@stll/docx-core/model";
+import { Fragment, Slice } from "prosemirror-model";
+import { Mapping, ReplaceStep, StepMap } from "prosemirror-transform";
+//#region src/internal/wholeStoryRevisionResolution.ts
+const resolveProperties = ({ doc, mode, styleResolver, numbering, steps, changedRanges }) => {
+	let structural = false;
+	const walk = (node, position) => {
+		if (node.isText) return node;
+		const nextAttrs = node.type.name === "paragraph" ? resolveParagraphChangeAttrs({
+			node,
+			mode,
+			boundaryCovered: true,
+			revisionSet: null,
+			styleResolver,
+			numbering
+		}) : null;
+		let resolved = node;
+		if (nextAttrs) resolved = recreateProseNodeWithParagraphPropertySource(node, { attrs: nextAttrs });
+		else if (node.type.name !== "paragraph") resolved = resolveAllNodePropertyChangeAttrs(node, mode);
+		if (resolved !== node) {
+			if (node.type.name === "paragraph") changedRanges.push({
+				from: position,
+				to: position + node.nodeSize
+			});
+			structural ||= node.type.name !== "paragraph";
+		}
+		if (position >= 0) recordNodeResolution({
+			before: node,
+			after: resolved,
+			position,
+			steps
+		});
+		const rebased = /* @__PURE__ */ new Map();
+		if (node.type.name === "paragraph" && styleResolver && nextAttrs && nextAttrs["styleId"] !== node.attrs["styleId"]) {
+			const previousContext = paragraphRunStyleContext(node, styleResolver);
+			const nextContext = paragraphRunStyleContext(resolved, styleResolver);
+			node.descendants((inline, pos) => {
+				if (!inline.isInline) return true;
+				const carrier = expandRunFormattingCarrier(inline, pos);
+				if (!carrier) return !inline.isAtom;
+				for (const { node: representation } of carrier.representations) {
+					if (mode === "reject" && representation.marks.some(({ type }) => type.name === "deletion") && representation.marks.some(({ type }) => type.name === "runFormattingOverride")) continue;
+					const marks = reconcileRunFormattingMarks({
+						authoredFormatting: readAuthoredRunFormatting({
+							context: previousContext,
+							marks: representation.marks,
+							styleResolver
+						}),
+						context: nextContext,
+						node: representation,
+						styleResolver
+					});
+					rebased.set(representation, representation.mark(marks));
+				}
+				return false;
+			});
+		}
+		const children = [];
+		let changed = false;
+		const visitChild = (child, childPosition) => {
+			const replacement = rebased.get(child) ?? child;
+			if (rebased.size === 0) return walk(replacement, childPosition);
+			recordNodeResolution({
+				before: child,
+				after: replacement,
+				position: childPosition,
+				steps
+			});
+			if (replacement.isLeaf) return replacement;
+			const nested = [];
+			replacement.forEach((inner, offset) => nested.push(visitChild(inner, childPosition + 1 + offset)));
+			return recreateProseNodeWithParagraphPropertySource(replacement, { content: nested });
+		};
+		resolved.forEach((child, offset) => {
+			const result = visitChild(child, position + 1 + offset);
+			children.push(result);
+			changed ||= result !== child;
+		});
+		return changed ? recreateProseNodeWithParagraphPropertySource(resolved, { content: children }) : resolved;
+	};
+	return {
+		resolved: walk(doc, -1),
+		structural
+	};
+};
+const structuralReplacementMap = ({ replacements, tables, bookmarkJoins, origin }) => {
+	const tablesByPosition = new Map(tables.map((table) => [table.position, table]));
+	const bookmarkJoinsByPosition = new Map(bookmarkJoins.map((join) => [join.from, join]));
+	const ranges = [];
+	const mapFor = ({ from, to, slice }) => {
+		const table = tablesByPosition.get(from);
+		if (table && table.sourceNodeSize === to - from) {
+			const tableRanges = [];
+			table.positionMap.forEach((oldStart, oldEnd, newStart, newEnd) => {
+				tableRanges.push(from - origin + oldStart, oldEnd - oldStart, newEnd - newStart);
+			});
+			return new StepMap(tableRanges);
+		}
+		const bookmarkJoin = bookmarkJoinsByPosition.get(from);
+		if (bookmarkJoin?.to === to) {
+			const joinRanges = [];
+			bookmarkJoin.positionMap.forEach((oldStart, oldEnd, newStart, newEnd) => {
+				joinRanges.push(from - origin + oldStart, oldEnd - oldStart, newEnd - newStart);
+			});
+			return new StepMap(joinRanges);
+		}
+		return new StepMap([
+			from - origin,
+			to - from,
+			slice.size
+		]);
+	};
+	const isDeletion = ({ from, to, slice }) => slice.size === 0 && !tablesByPosition.has(from) && to > from;
+	const groupMap = (group) => {
+		if (group.every(isDeletion)) {
+			const first = group.at(0);
+			if (!first) return StepMap.empty;
+			let end = first.to;
+			for (const replacement of group.slice(1)) end += replacement.to - replacement.from;
+			return new StepMap([
+				first.from - origin,
+				end - first.from,
+				0
+			]);
+		}
+		let maps = group.toReversed().map(mapFor);
+		while (maps.length > 1) {
+			const combined = [];
+			for (let index = 0; index < maps.length; index += 2) {
+				const first = maps.at(index);
+				const second = maps.at(index + 1);
+				if (!first) break;
+				combined.push(second ? composeRevisionResolutionMaps(first, second) : first);
+			}
+			maps = combined;
+		}
+		return maps.at(0) ?? StepMap.empty;
+	};
+	let group = [];
+	let influenceEnd = -1;
+	const flush = () => {
+		groupMap(group).forEach((oldStart, oldEnd, newStart, newEnd) => {
+			const last = ranges.length - 3;
+			const previousStart = ranges.at(last);
+			const previousOldSize = ranges.at(last + 1);
+			if (last >= 0 && previousStart !== void 0 && previousOldSize !== void 0 && ranges.at(last + 2) === 0 && newEnd === newStart && previousStart + previousOldSize === oldStart) {
+				ranges[last + 1] = previousOldSize + oldEnd - oldStart;
+				return;
+			}
+			ranges.push(oldStart, oldEnd - oldStart, newEnd - newStart);
+		});
+	};
+	for (const replacement of replacements) {
+		if (group.length > 0 && replacement.from >= influenceEnd) {
+			flush();
+			group = [];
+		}
+		if (group.length === 0) {
+			group.push(replacement);
+			influenceEnd = replacement.to;
+			continue;
+		}
+		group.push(replacement);
+		influenceEnd += replacement.to - replacement.from;
+	}
+	if (group.length > 0) flush();
+	return new StepMap(ranges);
+};
+const removedEndpoint = (node, context) => {
+	const properties = expectParagraphAttrs(node)._sectionProperties;
+	if (properties === void 0) return;
+	context.removedEndpointCount++;
+	for (const { type, rId } of properties?.headerReferences ?? []) context.removedReferences.push({
+		part: "header",
+		type,
+		relationshipId: rId
+	});
+	for (const { type, rId } of properties?.footerReferences ?? []) context.removedReferences.push({
+		part: "footer",
+		type,
+		relationshipId: rId
+	});
+};
+const resolveStructure = ({ node, position, context }) => {
+	if (node.isLeaf) return node;
+	const textBoxAnchor = anchoredTextBoxId(node);
+	if (textBoxAnchor !== void 0 && context.droppedTextBoxAnchors.has(textBoxAnchor)) {
+		context.structural = true;
+		return null;
+	}
+	const structuralStart = {
+		steps: context.steps.length,
+		deleted: context.deleted.length,
+		replacements: context.replacements.length,
+		tableRanges: context.tableRanges.length,
+		bookmarkJoins: context.bookmarkJoins.length
+	};
+	const entries = [];
+	node.forEach((child, offset) => entries.push({
+		node: resolveStructure({
+			node: child,
+			position: position + 1 + offset,
+			context
+		}),
+		original: child,
+		position: position + 1 + offset
+	}));
+	const reversed = [];
+	let chain = null;
+	let pendingBookmarks = [];
+	let followingContainerChild = false;
+	const flush = () => {
+		if (!chain) return;
+		let final = chain.node;
+		if (chain.chunks.length > 1) {
+			const children = [];
+			for (let index = chain.chunks.length - 1; index >= 0; index--) chain.chunks[index]?.forEach((child) => children.push(child));
+			final = recreateProseNodeWithParagraphPropertySource(chain.node, { content: Fragment.fromArray(children) });
+		}
+		if (!chain.before.sameMarkup(final)) context.changedRanges.push({
+			from: chain.position,
+			to: chain.position + chain.before.nodeSize
+		});
+		recordNodeResolution({
+			before: chain.before,
+			after: final,
+			position: chain.position,
+			steps: context.steps
+		});
+		for (const { closing, bookmarks } of chain.joinBoundaries) {
+			if (bookmarks.size === 0) {
+				context.deleted.push({
+					from: closing,
+					to: closing + 2
+				});
+				continue;
+			}
+			const to = closing + bookmarks.size + 2;
+			context.replacements.push({
+				from: closing,
+				to,
+				slice: new Slice(bookmarks, 0, 0)
+			});
+			context.bookmarkJoins.push({
+				from: closing,
+				to,
+				positionMap: new StepMap([
+					0,
+					1,
+					0,
+					bookmarks.size + 1,
+					1,
+					0
+				])
+			});
+		}
+		reversed.push(chain.chunks.length === 1 && final.eq(chain.before) ? chain.before : final);
+		chain = null;
+	};
+	const flushBookmarks = () => {
+		flush();
+		for (const bookmark of pendingBookmarks) reversed.push(bookmark);
+		pendingBookmarks = [];
+	};
+	for (let index = entries.length - 1; index >= 0; index--) {
+		const entry = entries[index];
+		if (!entry) continue;
+		let paragraph = entry.node;
+		if (paragraph === null) {
+			const filler = index + reversed.length + pendingBookmarks.length + (chain ? 1 : 0) > 0 ? null : node.type.schema.nodes["paragraph"]?.createAndFill();
+			context.replacements.push({
+				from: entry.position,
+				to: entry.position + entry.original.nodeSize,
+				slice: filler ? new Slice(Fragment.from(filler), 0, 0) : Slice.empty
+			});
+			if (!filler) continue;
+			paragraph = filler;
+		}
+		if (paragraph.type.name !== "paragraph") {
+			if (paragraph.type.name === "blockBookmarkBoundary") {
+				pendingBookmarks.push(paragraph);
+				continue;
+			}
+			flushBookmarks();
+			reversed.push(paragraph);
+			followingContainerChild ||= paragraph.type.spec["tableRole"] === "table";
+			continue;
+		}
+		const marker = expectParagraphAttrs(paragraph).pPrMark;
+		const markWasAdded = marker?.kind === "ins" || marker?.kind === "moveTo";
+		const joins = marker && markWasAdded !== (context.mode === "accept");
+		if (joins && chain) {
+			const boundaries = pendingBookmarks.toReversed();
+			let bookmarks = Fragment.empty;
+			if (boundaries.length > 0) {
+				const inline = inlineBookmarksOf(boundaries);
+				if (!inline) {
+					context.failed = true;
+					return null;
+				}
+				bookmarks = Fragment.fromArray(inline);
+				chain.chunks.push(bookmarks);
+				pendingBookmarks = [];
+			}
+			const empty = holdsNoContent(paragraph);
+			const owner = empty ? chain.node : paragraph;
+			const next = chain.node;
+			if (empty) {
+				const displacedToken = getProseParagraphPropertySourceToken(paragraph);
+				const selectedToken = getProseParagraphPropertySourceToken(next);
+				context.transfers.push({
+					displacedToken: typeof displacedToken === "string" ? displacedToken : null,
+					selectedToken: typeof selectedToken === "string" ? selectedToken : null
+				});
+			}
+			chain.node = recreateProseNodeWithParagraphPropertySource(owner, { attrs: {
+				...owner.attrs,
+				pPrMark: next.attrs["pPrMark"],
+				_sectionProperties: next.attrs["_sectionProperties"]
+			} });
+			chain.chunks.push(paragraph.content);
+			chain.position = entry.position;
+			chain.before = paragraph;
+			chain.joinBoundaries.push({
+				closing: entry.position + paragraph.nodeSize - 1,
+				bookmarks
+			});
+			removedEndpoint(paragraph, context);
+			continue;
+		}
+		flushBookmarks();
+		if (joins && holdsNoContent(paragraph) && (markWasAdded || followingContainerChild) && index + reversed.length + 1 > 1) {
+			context.deleted.push({
+				from: entry.position,
+				to: entry.position + paragraph.nodeSize
+			});
+			removedEndpoint(paragraph, context);
+			continue;
+		}
+		const resolved = marker ? recreateProseNodeWithParagraphPropertySource(paragraph, { attrs: {
+			...paragraph.attrs,
+			pPrMark: null
+		} }) : paragraph;
+		chain = {
+			node: resolved,
+			chunks: [resolved.content],
+			position: entry.position,
+			before: paragraph,
+			joinBoundaries: []
+		};
+		followingContainerChild = true;
+	}
+	flushBookmarks();
+	reversed.reverse();
+	if (node.type.name === "doc") {
+		const carrier = reversed.at(-1);
+		if (carrier?.type.name === "paragraph" && carrier.attrs["reviewCarrier"] === REVIEW_CARRIERS.TERMINAL_TABLE) {
+			const table = reversed.findLast((child) => child.type.name === "table");
+			let pending = false;
+			table?.descendants((child) => {
+				pending ||= child.type.name === "tableRow" && child.attrs["trDel"] !== null && typeof child.attrs["trDel"] === "object" || child.type.name !== "tableRow" && child.marks.some((mark) => mark.type.name === "deletion");
+				return !pending;
+			});
+			const entry = entries.at(-1);
+			if (!pending && entry) if (context.mode === "accept") {
+				const cleared = recreateProseNodeWithParagraphPropertySource(carrier, { attrs: {
+					...carrier.attrs,
+					reviewCarrier: void 0
+				} });
+				recordNodeResolution({
+					before: carrier,
+					after: cleared,
+					position: entry.position,
+					steps: context.steps
+				});
+				context.changedRanges.push({
+					from: entry.position,
+					to: entry.position + carrier.nodeSize
+				});
+				reversed[reversed.length - 1] = cleared;
+			} else if (reversed.length > 1) {
+				reversed.pop();
+				context.deleted.push({
+					from: entry.position,
+					to: entry.position + carrier.nodeSize
+				});
+			} else {
+				const filler = node.type.schema.nodes["paragraph"]?.createAndFill();
+				if (filler) {
+					reversed[0] = filler;
+					context.replacements.push({
+						from: entry.position,
+						to: entry.position + carrier.nodeSize,
+						slice: new Slice(Fragment.from(filler), 0, 0)
+					});
+				}
+			}
+		}
+	}
+	const rebuilt = reversed.length === node.childCount && reversed.every((child, index) => child === node.child(index)) ? node : recreateProseNodeWithParagraphPropertySource(node, { content: reversed });
+	if (node.type.spec["tableRole"] !== "table") return rebuilt;
+	const tableResult = resolveAllTableChanges({
+		table: rebuilt,
+		mode: context.mode
+	});
+	context.structural ||= tableResult.structural;
+	context.failed ||= tableResult.failed;
+	const final = tableResult.node;
+	if (final) {
+		const inside = [...context.replacements.slice(structuralStart.replacements), ...context.deleted.slice(structuralStart.deleted).map(({ from, to }) => ({
+			from,
+			to,
+			slice: Slice.empty
+		}))].sort((a, b) => a.from - b.from);
+		const inputMap = structuralReplacementMap({
+			replacements: inside,
+			tables: context.tableRanges.slice(structuralStart.tableRanges),
+			bookmarkJoins: context.bookmarkJoins.slice(structuralStart.bookmarkJoins),
+			origin: position
+		});
+		const positionMap = composeRevisionResolutionMaps(inputMap, tableResult.positionMap);
+		context.tableRanges.push({
+			node: final,
+			inputNode: rebuilt,
+			sourceNodeSize: node.nodeSize,
+			position,
+			inputMap,
+			positionMap,
+			ranges: tableResult.changedParagraphRanges,
+			paragraphOffsets: tableResult.paragraphOffsets
+		});
+	}
+	context.steps.length = structuralStart.steps;
+	context.deleted.length = structuralStart.deleted;
+	context.replacements.length = structuralStart.replacements;
+	context.bookmarkJoins.length = structuralStart.bookmarkJoins;
+	if (final && !node.eq(final)) context.replacements.push({
+		from: position,
+		to: position + node.nodeSize,
+		slice: new Slice(Fragment.from(final), 0, 0)
+	});
+	return final;
+};
+const resolveWholeStory = ({ doc, mode, styleResolver, numbering }) => {
+	const steps = [];
+	const propertyRanges = [];
+	const propertyResult = resolveProperties({
+		doc,
+		mode,
+		styleResolver,
+		numbering,
+		steps,
+		changedRanges: propertyRanges
+	});
+	const properties = propertyResult.resolved;
+	const inline = resolveInlineRevisions({
+		doc: properties,
+		mode,
+		styleResolver,
+		keepType: doc.type.schema.marks[mode === "accept" ? "insertion" : "deletion"],
+		removeType: doc.type.schema.marks[mode === "accept" ? "deletion" : "insertion"]
+	});
+	const context = {
+		mode,
+		steps: [],
+		changedRanges: [],
+		deleted: [],
+		replacements: [],
+		transfers: [],
+		tableRanges: [],
+		bookmarkJoins: [],
+		structural: propertyResult.structural,
+		failed: false,
+		removedEndpointCount: 0,
+		removedReferences: [],
+		droppedTextBoxAnchors: inline ? droppedTextBoxAnchorIds(properties, inline.resolved) : /* @__PURE__ */ new Set()
+	};
+	const resolved = resolveStructure({
+		node: inline?.resolved ?? properties,
+		position: -1,
+		context
+	}) ?? doc;
+	if (inline) steps.push(...inline.steps);
+	steps.push(...context.steps);
+	const replacements = [...context.replacements, ...context.deleted.map(({ from, to }) => ({
+		from,
+		to,
+		slice: Slice.empty
+	}))].sort((a, b) => a.from - b.from);
+	const structuralMap = structuralReplacementMap({
+		replacements,
+		tables: context.tableRanges,
+		bookmarkJoins: context.bookmarkJoins,
+		origin: 0
+	});
+	for (const { from, to, slice } of replacements.toReversed()) steps.push(new ReplaceStep(from, to, slice));
+	const positionMap = composeRevisionResolutionMaps(inline?.positionMap ?? StepMap.empty, structuralMap);
+	return {
+		resolved,
+		mapping: new Mapping([positionMap]),
+		positionMap,
+		steps,
+		changedRanges: [...propertyRanges, ...inline?.ranges ?? []],
+		inlineMap: inline?.positionMap ?? StepMap.empty,
+		tableRanges: context.tableRanges,
+		transfers: context.transfers,
+		structuralRanges: context.changedRanges,
+		structuralMap,
+		structural: context.structural,
+		failed: context.failed,
+		removedEndpointCount: context.removedEndpointCount,
+		removedReferences: context.removedReferences
+	};
+};
+//#endregion
+export { resolveWholeStory };

package/dist/layout-bridge/convert/markupViewFlow.d.ts

@@ -0,0 +1,20 @@
+import { FlowBlock } from "../../layout-engine/types.js";
+import { StepMap } from "prosemirror-transform";
+//#region src/layout-bridge/convert/markupViewFlow.d.ts
+type PositionRange = {
+  from: number;
+  to: number;
+};
+type MarkupViewFlowOptions = {
+  /** Authored (editor) positions to the positions the blocks were built with. */
+  positionMap: StepMap;
+  /** Ranges, in the blocks' positions, whose paragraphs show a change bar. */
+  changeBarRanges: readonly PositionRange[];
+};
+/**
+ * Re-address blocks built from a view projection in editor positions, and mark
+ * the paragraphs the view flags with a change bar.
+ */
+declare function remapMarkupViewBlocks(blocks: readonly FlowBlock[], { positionMap, changeBarRanges }: MarkupViewFlowOptions): FlowBlock[];
+//#endregion
+export { MarkupViewFlowOptions, remapMarkupViewBlocks };

package/dist/layout-bridge/convert/markupViewFlow.js

@@ -0,0 +1,123 @@
+import { indexedPositionMap } from "../../internal/indexedPositionMap.js";
+//#region src/layout-bridge/convert/markupViewFlow.ts
+/**
+* Re-address blocks built from a view projection in editor positions, and mark
+* the paragraphs the view flags with a change bar.
+*/
+function remapMarkupViewBlocks(blocks, { positionMap, changeBarRanges }) {
+	const inverse = positionMap.invert();
+	const cutSet = /* @__PURE__ */ new Set();
+	inverse.forEach((oldStart, oldEnd) => {
+		cutSet.add(oldStart);
+		cutSet.add(oldEnd);
+	});
+	const context = {
+		toSource: indexedPositionMap(inverse),
+		cuts: [...cutSet].sort((left, right) => left - right),
+		changeBarRanges
+	};
+	return blocks.map((block) => remapBlock(block, context));
+}
+const touchesChangeBar = (block, ranges) => {
+	const { pmStart, pmEnd } = block;
+	if (pmStart === void 0 || pmEnd === void 0) return false;
+	return ranges.some((range) => range.from < pmEnd && range.to > pmStart);
+};
+/** A node's own positions: its start after any hidden content before it, its end before any after. */
+const remapNodeRange = (range, toSource) => {
+	if (range.pmStart === void 0 || range.pmEnd === void 0) return {};
+	const pmStart = toSource(range.pmStart, 1);
+	return {
+		pmStart,
+		pmEnd: Math.max(pmStart, toSource(range.pmEnd, -1))
+	};
+};
+const remapSdtGroups = (groups, toSource) => groups === void 0 ? {} : { sdtGroups: groups.map((group) => ({
+	...group,
+	pmPos: toSource(group.pmPos, 1)
+})) };
+function remapBlock(block, context) {
+	switch (block.kind) {
+		case "paragraph": return remapParagraph(block, context);
+		case "table": return remapTable(block, context);
+		case "image":
+		case "pageBreak":
+		case "columnBreak": return {
+			...block,
+			...remapNodeRange(block, context.toSource)
+		};
+		case "textBox": return {
+			...block,
+			...remapNodeRange(block, context.toSource),
+			content: block.content.map((contentBlock) => contentBlock.kind === "table" ? remapTable(contentBlock, context) : remapParagraph(contentBlock, context))
+		};
+		case "sectionBreak": return block;
+		default: return block;
+	}
+}
+function remapTable(block, context) {
+	return {
+		...block,
+		...remapNodeRange(block, context.toSource),
+		...remapSdtGroups(block.sdtGroups, context.toSource),
+		rows: block.rows.map((row) => ({
+			...row,
+			cells: row.cells.map((cell) => ({
+				...cell,
+				blocks: cell.blocks.map((cellBlock) => remapBlock(cellBlock, context))
+			}))
+		}))
+	};
+}
+function remapParagraph(block, context) {
+	const runs = [];
+	for (const run of block.runs) pushRemappedRun(run, context, runs);
+	return {
+		...block,
+		...remapNodeRange(block, context.toSource),
+		...remapSdtGroups(block.sdtGroups, context.toSource),
+		...touchesChangeBar(block, context.changeBarRanges) ? { reviewIndicator: "change-bar" } : {},
+		runs
+	};
+}
+/** Index of the first cut strictly after `position`. */
+const firstCutAfter = (cuts, position) => {
+	let low = 0;
+	let high = cuts.length;
+	while (low < high) {
+		const middle = Math.floor((low + high) / 2);
+		const cut = cuts.at(middle);
+		if (cut !== void 0 && cut <= position) low = middle + 1;
+		else high = middle;
+	}
+	return low;
+};
+/** Whether each character of the run occupies exactly one position. */
+const addressesPerCharacter = (run) => run.pmStart !== void 0 && run.pmEnd !== void 0 && run.templatePreview === void 0 && run.text.length === run.pmEnd - run.pmStart;
+function pushRemappedRun(run, context, out) {
+	if (run.kind !== "text" || !addressesPerCharacter(run)) {
+		out.push({
+			...run,
+			...remapNodeRange(run, context.toSource)
+		});
+		return;
+	}
+	const { pmStart, pmEnd } = run;
+	let pieceStart = pmStart;
+	for (let index = firstCutAfter(context.cuts, pmStart);; index++) {
+		const cut = context.cuts.at(index);
+		const pieceEnd = cut === void 0 || cut >= pmEnd ? pmEnd : cut;
+		out.push({
+			...run,
+			text: run.text.slice(pieceStart - pmStart, pieceEnd - pmStart),
+			...remapNodeRange({
+				pmStart: pieceStart,
+				pmEnd: pieceEnd
+			}, context.toSource)
+		});
+		if (pieceEnd === pmEnd) return;
+		pieceStart = pieceEnd;
+	}
+}
+//#endregion
+export { remapMarkupViewBlocks };

package/dist/layout-bridge/convert/tableConversion.js

@@ -65,7 +65,7 @@ function convertTableCell(node, startPos, options, tableCellMargins) {
 			blocks.push(block);
 		} else if (child.type.name === "table") blocks.push(convertTable(child, childStart, options));
 		else if (child.type.name === "textBox") blocks.push(convertTextBoxNode(child, childStart, options));
-		else if (child.type.name === "blockSdt") {
+		else if (child.type.name === "blockSdt" || child.type.name === "blockCustomXml") {
 			let sdtChildStart = childStart + 1;
 			child.forEach((sdtChild) => {
 				convertCellChild(sdtChild, sdtChildStart);