@stll/folio-core 0.53.0 → 0.54.0

package/dist/layout-engine/measure/paragraphMeasureShared.js

@@ -4,6 +4,19 @@ import { DEFAULT_FONT_FAMILY, buildRunFontStyle } from "./measureHelpers.js";
 const DEFAULT_FONT_SIZE = 11;
 const DEFAULT_LINE_HEIGHT_MULTIPLIER = 1;
 const WIDTH_TOLERANCE = .5;
+/** Grid a finished line's width snaps to: 1/1024 px, exact in binary floating point. */
+const LINE_WIDTH_GRID = 1024;
+/**
+* The width a finished line reports. A line's width is a floating-point sum
+* of per-token measurements, and the same text can reach it through different
+* token groupings, e.g. a run split where a hidden revision sat measures
+* "confirm" + "ation" where the resolved text measures "confirmation". Those
+* sums agree only up to the last few bits, so the result snaps to a
+* binary-exact 1/1024 px grid (under 0.0005 px, far below a device pixel):
+* the same text yields the same width whichever grouping summed it, and the
+* alignment offsets derived from it agree too.
+*/
+const canonicalLineWidth = (width) => Math.round(Math.max(0, width) * LINE_WIDTH_GRID) / LINE_WIDTH_GRID;
 /**
 * Extract FontStyle from a run that carries RunFormatting (text, tab, or
 * field). All three share the same formatting shape, so they measure the
@@ -79,4 +92,4 @@ function isSpaceOrTab(char) {
 	return char === " " || char === "	";
 }
 //#endregion
-export { DEFAULT_FONT_SIZE, DEFAULT_LINE_HEIGHT_MULTIPLIER, WIDTH_TOLERANCE, fieldMeasureText, isBlockLayoutImageRun, isEmptyTextRun, isFieldRun, isImageRun, isLineBreakRun, isMathRun, isSpaceOrTab, isTabRun, isTextRun, runToFontStyle };
+export { DEFAULT_FONT_SIZE, DEFAULT_LINE_HEIGHT_MULTIPLIER, WIDTH_TOLERANCE, canonicalLineWidth, fieldMeasureText, isBlockLayoutImageRun, isEmptyTextRun, isFieldRun, isImageRun, isLineBreakRun, isMathRun, isSpaceOrTab, isTabRun, isTextRun, runToFontStyle };

package/dist/markdown/escape.d.ts

@@ -7,8 +7,8 @@
  */
 /**
  * Escape only characters that would change markdown structure mid-text:
- *   - backslash, backtick, asterisk, brackets (always)
- *   - underscore: only at word boundaries (emphasis trigger)
+ *   - backslash, backtick, asterisk, brackets, tilde (always)
+ *   - underscore: unless between two letters or digits (emphasis trigger)
  *   - angle brackets: only when they look like a tag/autolink
  *
  * Characters like `.` `-` `+` `#` `(` `)` `!` are only meaningful at line

package/dist/markdown/escape.js

@@ -7,8 +7,8 @@
 */
 /**
 * Escape only characters that would change markdown structure mid-text:
-*   - backslash, backtick, asterisk, brackets (always)
-*   - underscore: only at word boundaries (emphasis trigger)
+*   - backslash, backtick, asterisk, brackets, tilde (always)
+*   - underscore: unless between two letters or digits (emphasis trigger)
 *   - angle brackets: only when they look like a tag/autolink
 *
 * Characters like `.` `-` `+` `#` `(` `)` `!` are only meaningful at line
@@ -16,9 +16,8 @@
 * when to escape those.
 */
 function escapeInline(text) {
-	let out = text.replace(/(?<ch>[\\`*[\]])/gu, "\\$<ch>");
-	out = out.replace(/(?<pre>^|\s)_/gu, "$<pre>\\_");
-	out = out.replace(/_(?<post>\s|$)/gu, "\\_$<post>");
+	let out = text.replace(/(?<ch>[\\`*[\]~])/gu, "\\$<ch>");
+	out = out.replace(/(?<![\p{L}\p{N}])_|_(?![\p{L}\p{N}])/gu, "\\_");
 	out = out.replace(/<(?<tag>\/?[A-Za-z][\w-]*)(?=[\s/>])/gu, "\\<$<tag>");
 	return out;
 }

package/dist/markdown/renderBlock.js

@@ -11,37 +11,103 @@ import { panic } from "better-result";
 * of the same list. Ported from eigenpal/docx-editor PR #595.
 */
 /**
-* In `trackedChanges: "clean"` mode every change is accepted. A paragraph whose
-* end-of-paragraph mark is a pending deletion (`pPrMark.kind === "del"`) loses
-* its break on accept and merges with the following paragraph. Word's join
-* keeps the FIRST paragraph's properties (style, list) and drops the resolved
-* mark; the surviving break is the next paragraph's, so a run of consecutive
-* deletions collapses into one paragraph. A first paragraph with nothing left
-* once its deletions are accepted (a whole deleted paragraph) contributes only
-* the join, so the NEXT paragraph keeps its own properties, as the editor's
-* accept does. A non-paragraph next block (table, SDT) is structurally
-* incompatible and stays unmerged, matching the editor's accept-change join
-* guard (`commands/comments.ts`).
+* In `trackedChanges: "clean"` mode every change is accepted, as the editor's
+* accept-all resolves the story (`internal/wholeStoryRevisionResolution.ts`).
+*
+* A paragraph whose mark is pending deletion loses its break on accept and
+* runs on into the paragraph after it, which is the paragraph left: its mark
+* ends the joined text, and a paragraph's properties (style, list) live on its
+* mark. A run of consecutive deletions collapses into that last paragraph.
+*
+* With a table right after it, its words run on into the table's first cell
+* and lead that cell's first paragraph (`prosemirror/tableRunIn.ts`), unless
+* it ends a section, keeps nothing once accepted, or that cell is pending.
+* Otherwise a paragraph that cannot join keeps its place, or goes when it
+* keeps nothing and something follows it.
 */
 function mergeAcceptedParagraphBreaks(blocks) {
-	const merged = [];
-	for (const block of blocks) {
-		const prev = merged.at(-1);
-		if (prev?.type === "paragraph" && prev.pPrMark?.kind === "del" && block.type === "paragraph") {
-			const next = block.pPrMark;
-			const content = [...prev.content, ...block.content];
-			const joined = cloneParagraphWithoutPropertySource(holdsNothingOnAccept(prev) ? block : prev, {
-				content,
-				...next ? { pPrMark: next } : {}
-			});
-			if (!next) Reflect.deleteProperty(joined, "pPrMark");
-			merged[merged.length - 1] = joined;
+	const reversed = [];
+	let survivor = null;
+	let tableFollows = false;
+	let followed = false;
+	const flush = () => {
+		if (survivor) reversed.push(survivor);
+		survivor = null;
+	};
+	for (let index = blocks.length - 1; index >= 0; index--) {
+		const block = blocks[index];
+		if (!block) continue;
+		if (block.type !== "paragraph") {
+			flush();
+			reversed.push(block);
+			tableFollows = block.type === "table";
+			followed ||= tableFollows;
 			continue;
 		}
-		merged.push(block);
+		const goes = block.pPrMark?.kind === "del" || block.pPrMark?.kind === "moveFrom";
+		if (goes && survivor) {
+			survivor = cloneParagraphWithoutPropertySource(survivor, { content: [...block.content, ...survivor.content] });
+			continue;
+		}
+		const table = reversed.at(-1);
+		if (goes && tableFollows && table?.type === "table") {
+			const ranIn = tableWithParagraphRunIn(table, block);
+			if (ranIn) {
+				reversed[reversed.length - 1] = ranIn;
+				continue;
+			}
+		}
+		flush();
+		tableFollows = false;
+		if (goes && holdsNothingOnAccept(block) && followed && index + reversed.length > 0) continue;
+		survivor = block;
+		followed = true;
 	}
-	return merged;
+	flush();
+	return reversed.reverse();
 }
+/**
+* Whether the cell a paragraph's words would run into is itself pending (its
+* row or the cell, through nested tables' first cells), as
+* `prosemirror/tableRunIn.ts` reads it.
+*/
+const runInCellPending = (table) => {
+	const row = table.rows[0];
+	const cell = row?.cells[0];
+	if (!row || !cell) return false;
+	if (row.structuralChange !== void 0 || cell.structuralChange !== void 0) return true;
+	const first = cell.content[0];
+	return first?.type === "table" && runInCellPending(first);
+};
+/**
+* `table` with `paragraph`'s words leading its first cell's first paragraph,
+* descending into nested tables, or null when the paragraph keeps its place.
+*/
+const tableWithParagraphRunIn = (table, paragraph) => {
+	if (paragraph.sectionProperties !== void 0 || holdsNothingOnAccept(paragraph)) return null;
+	if (runInCellPending(table)) return null;
+	const runIn = (current) => {
+		const [row, ...rows] = current.rows;
+		const [cell, ...cells] = row?.cells ?? [];
+		const [first, ...rest] = cell?.content ?? [];
+		if (!row || !cell || !first) return null;
+		let led = null;
+		if (first.type === "paragraph") led = cloneParagraphWithoutPropertySource(first, { content: [...paragraph.content, ...first.content] });
+		else if (first.type === "table") led = runIn(first);
+		if (!led) return null;
+		return {
+			...current,
+			rows: [{
+				...row,
+				cells: [{
+					...cell,
+					content: [led, ...rest]
+				}, ...cells]
+			}, ...rows]
+		};
+	};
+	return runIn(table);
+};
 /** Paragraph content that shows nothing: range boundaries and anchors. */
 const ZERO_WIDTH_CONTENT = /* @__PURE__ */ new Set([
 	"bookmarkStart",

package/dist/markdown/renderRuns.d.ts

@@ -1,10 +1,19 @@
 import { document_d_exports } from "../types/document.js";
 import { RenderContext } from "./types.js";
 //#region src/markdown/renderRuns.d.ts
+/**
+ * The character beside a run's delimiters: `""` at the paragraph's edge,
+ * `undefined` when it cannot be told (read as a letter, the strictest case).
+ */
+type Neighbor = string | undefined;
+type RunNeighbors = {
+  before: Neighbor;
+  after: Neighbor;
+};
 /**
  * Render the full inline content of a paragraph, tracking comment-range
  * boundaries to apply the configured wrapper.
  */
-declare function renderParagraphInline(ctx: RenderContext, pkg: document_d_exports.DocxPackage | undefined, content: readonly document_d_exports.ParagraphContent[], paraId: string | undefined): string;
+declare function renderParagraphInline(ctx: RenderContext, pkg: document_d_exports.DocxPackage | undefined, content: readonly document_d_exports.ParagraphContent[], paraId: string | undefined, edges?: RunNeighbors): string;
 //#endregion
 export { renderParagraphInline };

package/dist/markdown/renderRuns.js

@@ -5,6 +5,7 @@ import { wrapComment, wrapDeletion, wrapInsertion, wrapMoveFrom, wrapMoveTo } fr
 import { escapeAltText, escapeInline, escapeLinkUrl } from "./escape.js";
 import { registerImage } from "./images.js";
 import { numberNoteReference, pushWarning } from "./internals.js";
+import { compileMarkdownToContent } from "@stll/docx-core";
 //#region src/markdown/renderRuns.ts
 const MARK_DELIMS = {
 	bold: "**",
@@ -32,9 +33,9 @@ function marksFor(run) {
 	const f = run.formatting;
 	if (!f) return [];
 	const out = [];
+	if (f.strike) out.push("strike");
 	if (f.bold) out.push("bold");
 	if (f.italic) out.push("italic");
-	if (f.strike) out.push("strike");
 	const ascii = f.fontFamily?.ascii?.toLowerCase();
 	if (ascii && MONOSPACE_FONTS.has(ascii)) out.push("code");
 	return out;
@@ -42,7 +43,7 @@ function marksFor(run) {
 function applyMarks(text, marks) {
 	if (!text) return text;
 	if (marks.includes("code")) {
-		const literal = text.replace(/\\(?<char>[\\`*[\]_<])/gu, "$<char>");
+		const literal = text.replace(/\\(?<char>[\\`*[\]_<~])/gu, "$<char>");
 		let longestRun = 0;
 		for (const m of literal.matchAll(/`+/gu)) longestRun = Math.max(longestRun, m[0].length);
 		const fence = "`".repeat(longestRun + 1);
@@ -56,6 +57,133 @@ function applyMarks(text, marks) {
 	}
 	return out;
 }
+const UNKNOWN_NEIGHBORS = {
+	before: void 0,
+	after: void 0
+};
+const isBlank = (ch) => ch === "" || ch !== void 0 && /\s/u.test(ch);
+/**
+* Which mark wraps a stretch of runs first, outermost first. Strikethrough
+* goes inside emphasis: an emphasis delimiter beside a tilde opens and closes
+* wherever it stands, where the other way round (`~~*`) needs a blank or
+* punctuation outside.
+*/
+const GROUPING_ORDER = [
+	"italic",
+	"bold",
+	"strike"
+];
+/** The stackings tried, in turn, where the reader misreads one. */
+const GROUPING_ORDERS = [GROUPING_ORDER, [
+	"bold",
+	"italic",
+	"strike"
+]];
+/**
+* CommonMark punctuation (Unicode P and S categories) as a delimiter of
+* `mark` meets it. Beside an emphasis delimiter, an asterisk is another
+* delimiter that runs together with it, and a tilde does not let it close
+* (the GFM reader's rule): both count as letters. (Words carry them escaped,
+* as a two-character unit.)
+*/
+const punctuationFor = (mark) => (ch) => {
+	if (ch === void 0 || ch === "" || ch === "~") return false;
+	if (mark !== "strike" && ch === "*") return false;
+	return /[\p{P}\p{S}]/u.test(ch);
+};
+/** One escape pair (`\*`) or one code point of escaped inline text. */
+const INLINE_UNIT = /\\[\s\S]|[\s\S]/gu;
+/**
+* Wrap `inner` in `mark` so a CommonMark reader reads it back. A delimiter
+* opens only before a character that is not blank, and before punctuation
+* only where blank or punctuation precedes it; closing mirrors that. Where
+* the words at an edge would stop a delimiter from opening or closing (a
+* space at the edge, emphasis ending in a full stop right before a letter),
+* those characters are left outside the emphasis rather than written as
+* literal asterisks.
+*/
+function wrapFlanking(inner, mark, { before, after }) {
+	const isPunctuation = punctuationFor(mark);
+	const opensAfter = (ch) => isBlank(ch) || isPunctuation(ch);
+	const units = Array.from(inner.matchAll(INLINE_UNIT), ([unit]) => unit);
+	const isPunctuationUnit = (unit) => unit.length === 2 && unit.startsWith("\\") || isPunctuation(unit);
+	let start = 0;
+	let end = units.length;
+	let outside = before;
+	for (;;) {
+		const unit = units[start];
+		if (unit === void 0 || start >= end) break;
+		if (!isBlank(unit) && (!isPunctuationUnit(unit) || opensAfter(outside))) break;
+		outside = unit.at(-1);
+		start++;
+	}
+	outside = after;
+	for (;;) {
+		const unit = units[end - 1];
+		if (unit === void 0 || end <= start) break;
+		if (!isBlank(unit) && (!isPunctuationUnit(unit) || opensAfter(outside))) break;
+		outside = unit.at(0);
+		end--;
+	}
+	return units.slice(0, start).join("") + applyMarks(units.slice(start, end).join(""), start < end ? [mark] : []) + units.slice(end).join("");
+}
+/** Paragraph content that writes nothing to the line. */
+const SILENT_MARKERS = /* @__PURE__ */ new Set([
+	"bookmarkStart",
+	"bookmarkEnd",
+	"moveFromRangeStart",
+	"moveFromRangeEnd",
+	"moveToRangeStart",
+	"moveToRangeEnd"
+]);
+/** Comment range markers, which write nothing when comments are stripped. */
+const COMMENT_MARKERS = /* @__PURE__ */ new Set(["commentRangeStart", "commentRangeEnd"]);
+/** The first character `piece` puts on the line, inside the marks `outer` already opened. */
+const pieceStart = (piece, outer, order) => {
+	const first = piece.text.match(INLINE_UNIT)?.[0];
+	if (first === void 0 || isBlank(first)) return first;
+	const opens = order.find((mark) => piece.marks.has(mark) && !outer.has(mark));
+	if (opens === void 0) return first;
+	return opens === "strike" ? "~" : "*";
+};
+/**
+* Wrap consecutive pieces in their emphasis, one mark at a time: the pieces
+* sharing the outermost mark are wrapped once, around the rest of their
+* emphasis. Written run by run, the closing delimiter of one would meet the
+* opening one of the next (`*a**b*`), which no reader takes for two
+* emphases.
+*/
+function renderPieces(pieces, outer, edges, order = GROUPING_ORDER) {
+	let out = "";
+	let index = 0;
+	while (index < pieces.length) {
+		const piece = pieces[index];
+		if (!piece) break;
+		const mark = order.find((key) => piece.marks.has(key) && !outer.has(key));
+		if (mark === void 0) {
+			out += piece.text;
+			index++;
+			continue;
+		}
+		let last = index;
+		while (pieces[last + 1]?.marks.has(mark)) last++;
+		const next = pieces[last + 1];
+		const around = {
+			before: out.length > 0 ? out.at(-1) : edges.before,
+			after: next === void 0 ? edges.after : pieceStart(next, outer, order)
+		};
+		const inner = renderPieces(pieces.slice(index, last + 1), /* @__PURE__ */ new Set([...outer, mark]), around, order);
+		out += wrapFlanking(inner, mark, around);
+		index = last + 1;
+	}
+	return out;
+}
+/** The first character an item that is not a run puts on the line, where it is fixed. */
+function renderedStart(item) {
+	if (item?.type !== "hyperlink") return void 0;
+	const link = item;
+	return link.href || link.anchor ? "[" : void 0;
+}
 /** Render a single run's RunContent array into the inline text fragment. */
 function renderRunContent(ctx, pkg, content, paraId) {
 	let out = "";
@@ -111,21 +239,111 @@ function renderRunContent(ctx, pkg, content, paraId) {
 	}
 	return out;
 }
-/** Render a single Run with its formatting applied. */
-function renderRun(ctx, pkg, run, paraId) {
-	if (run.formatting?.hidden) return "";
+/** A run's rendered text and the emphasis it still takes; `null` when it writes nothing. */
+function pieceOf(ctx, pkg, run, paraId) {
+	if (run.formatting?.hidden) return null;
 	const inner = renderRunContent(ctx, pkg, run.content, paraId);
-	if (!inner) return "";
+	if (!inner) return null;
+	const marks = marksFor(run);
+	if (!marks.includes("code")) return {
+		text: inner,
+		marks: new Set(marks)
+	};
 	const leadLen = inner.length - inner.trimStart().length;
 	const trailLen = inner.length - inner.trimEnd().length;
 	const core = inner.slice(leadLen, inner.length - trailLen);
-	if (!core) return inner;
-	const lead = inner.slice(0, leadLen);
-	const trail = inner.slice(inner.length - trailLen);
-	return `${lead}${applyMarks(core, marksFor(run))}${trail}`;
+	return {
+		text: core ? `${inner.slice(0, leadLen)}${applyMarks(core, marks)}${inner.slice(inner.length - trailLen)}` : inner,
+		marks: /* @__PURE__ */ new Set()
+	};
 }
+/** What a markdown reader reads from one line: each character with its emphasis. */
+const readLine = (line) => compileMarkdownToContent(line).content.flatMap((block) => block.type === "paragraph" ? block.content : []).flatMap((item) => item.type === "hyperlink" ? item.children : [item]).flatMap((item) => {
+	if (item.type !== "run") return [{
+		char: "\0",
+		marks: /* @__PURE__ */ new Set()
+	}];
+	const marks = new Set(GROUPING_ORDER.filter((key) => item.formatting?.[key] === true));
+	return item.content.flatMap((content) => content.type === "text" ? Array.from(content.text, (char) => ({
+		char,
+		marks
+	})) : [{
+		char: "\0",
+		marks
+	}]);
+});
+const sameMarks = (left, right) => left.size === right.size && [...left].every((key) => right.has(key));
+/**
+* How `rendered`, between `edges`, reads back: `"exact"` with the pieces'
+* text and each letter's emphasis, `"text"` with their text alone (emphasis
+* lost somewhere, none of it read as literal asterisks), or `null`.
+*/
+const readBack = (rendered, pieces, edges) => {
+	const side = (ch) => {
+		if (ch === void 0) return "x";
+		return ch === "" ? " " : ch;
+	};
+	const line = (inner) => `x ${side(edges.before)}${inner}${side(edges.after)} x`;
+	const read = readLine(line(rendered));
+	const plain = readLine(line(pieces.map(({ text }) => text).join("")));
+	if (read.map(({ char }) => char).join("") !== plain.map(({ char }) => char).join("")) return null;
+	const expected = pieces.flatMap(({ text, marks }) => readLine(`x${text}x`).slice(1, -1).map(({ char }) => ({
+		char,
+		marks
+	})));
+	const start = Array.from(`x ${side(edges.before)}`).length;
+	const end = Array.from(`${side(edges.after)} x`).length;
+	if (read.length !== start + expected.length + end) return read.every(({ marks }) => marks.size === 0) ? "text" : null;
+	let exact = true;
+	for (const [index, { char, marks }] of expected.entries()) {
+		const at = read[start + index];
+		if (at?.char !== char) return null;
+		if ([...at.marks].some((mark) => !marks.has(mark))) return null;
+		if (/[\p{L}\p{N}]/u.test(char) && !sameMarks(at.marks, marks)) exact = false;
+	}
+	return exact ? "exact" : "text";
+};
+/**
+* Render consecutive runs with their formatting applied. The delimiters are
+* placed by the flanking rules the reader applies, and the result is checked
+* against the reader: a stacking it misreads is tried the other way round,
+* or with more punctuation left outside, and failing all of those, the runs
+* go out without emphasis rather than with stray asterisks.
+*/
+function renderRuns(ctx, pkg, runs, paraId, edges = UNKNOWN_NEIGHBORS) {
+	const pieces = runs.flatMap((run) => pieceOf(ctx, pkg, run, paraId) ?? []);
+	const plain = pieces.map(({ text }) => text).join("");
+	if (!pieces.some(({ marks }) => marks.size > 0)) return plain;
+	let fallback;
+	for (const split of [pieces, splitAtBlanks(pieces)]) for (const order of GROUPING_ORDERS) for (const neighbors of [edges, UNKNOWN_NEIGHBORS]) {
+		const rendered = renderPieces(split, /* @__PURE__ */ new Set(), neighbors, order);
+		const read = readBack(rendered, pieces, edges);
+		if (read === "exact") return rendered;
+		if (read === "text") fallback ??= rendered;
+	}
+	return fallback ?? plain;
+}
+/** The pieces with every blank a piece of its own, without emphasis. */
+const splitAtBlanks = (pieces) => pieces.flatMap((piece) => {
+	if (piece.marks.size === 0) return [piece];
+	const parts = [];
+	for (const [unit] of piece.text.matchAll(INLINE_UNIT)) {
+		const marks = isBlank(unit) ? /* @__PURE__ */ new Set() : piece.marks;
+		const last = parts.at(-1);
+		if (last && last.marks === marks) last.text += unit;
+		else parts.push({
+			text: unit,
+			marks
+		});
+	}
+	return parts;
+});
 function renderHyperlink(ctx, pkg, link, paraId) {
-	const inner = getHyperlinkRuns(link).map((run) => renderRun(ctx, pkg, run, paraId)).join("");
+	const bracketed = Boolean(link.href ?? link.anchor);
+	const inner = renderRuns(ctx, pkg, getHyperlinkRuns(link), paraId, bracketed ? {
+		before: "[",
+		after: "]"
+	} : UNKNOWN_NEIGHBORS);
 	if (!inner) return "";
 	const href = link.href ?? (link.anchor ? `#${link.anchor}` : "");
 	if (!href) {
@@ -145,17 +363,17 @@ function renderHyperlink(ctx, pkg, link, paraId) {
 function renderTrackedWrapper(ctx, pkg, wrapper, paraId) {
 	const renderChild = (child) => {
 		switch (child.type) {
-			case "run": return renderRun(ctx, pkg, child, paraId);
+			case "run": return renderRuns(ctx, pkg, [child], paraId);
 			case "hyperlink": return renderHyperlink(ctx, pkg, child, paraId);
 			case "mathEquation": return child.plainText ? escapeInline(child.plainText) : "";
 			case "inlineWrapper":
-			case "inlineSdt": return renderParagraphInline(ctx, pkg, child.content, paraId);
+			case "inlineSdt": return renderParagraphInline(ctx, pkg, child.content, paraId, UNKNOWN_NEIGHBORS);
 			case "insertion":
 			case "deletion":
 			case "moveFrom":
 			case "moveTo": return renderTrackedWrapper(ctx, pkg, child, paraId);
 			case "simpleField":
-			case "complexField": return renderParagraphInline(ctx, pkg, [child], paraId);
+			case "complexField": return renderParagraphInline(ctx, pkg, [child], paraId, UNKNOWN_NEIGHBORS);
 			case "bookmarkStart":
 			case "bookmarkEnd":
 			case "moveFromRangeStart":
@@ -166,11 +384,33 @@ function renderTrackedWrapper(ctx, pkg, wrapper, paraId) {
 			default: return child;
 		}
 	};
+	const renderChildren = () => {
+		let rendered = "";
+		let runs = [];
+		const flush = (after) => {
+			if (runs.length === 0) return;
+			rendered += renderRuns(ctx, pkg, runs, paraId, {
+				before: rendered.length > 0 ? rendered.at(-1) : void 0,
+				after
+			});
+			runs = [];
+		};
+		for (const child of wrapper.content) {
+			if (child.type === "run") {
+				runs.push(child);
+				continue;
+			}
+			flush(renderedStart(child));
+			rendered += renderChild(child);
+		}
+		flush(void 0);
+		return rendered;
+	};
 	if (ctx.opts.trackedChanges === "clean") {
-		if (wrapper.type === "insertion" || wrapper.type === "moveTo") return wrapper.content.map(renderChild).join("");
+		if (wrapper.type === "insertion" || wrapper.type === "moveTo") return renderChildren();
 		return "";
 	}
-	const inner = wrapper.content.map(renderChild).join("");
+	const inner = renderChildren();
 	switch (wrapper.type) {
 		case "insertion": return wrapInsertion(ctx, wrapper.info, inner);
 		case "deletion": return wrapDeletion(ctx, wrapper.info, inner);
@@ -182,55 +422,76 @@ function renderTrackedWrapper(ctx, pkg, wrapper, paraId) {
 * Render the full inline content of a paragraph, tracking comment-range
 * boundaries to apply the configured wrapper.
 */
-function renderParagraphInline(ctx, pkg, content, paraId) {
+function renderParagraphInline(ctx, pkg, content, paraId, edges = {
+	before: "",
+	after: ""
+}) {
 	let out = "";
 	const openComments = [];
-	for (const item of content) switch (item.type) {
-		case "run":
-			out += renderRun(ctx, pkg, item, paraId);
-			break;
-		case "hyperlink":
-			out += renderHyperlink(ctx, pkg, item, paraId);
-			break;
-		case "insertion":
-		case "deletion":
-		case "moveFrom":
-		case "moveTo":
-			out += renderTrackedWrapper(ctx, pkg, item, paraId);
-			break;
-		case "commentRangeStart":
-			out += handleCommentStart(ctx, pkg, item, openComments, out.length);
-			break;
-		case "commentRangeEnd":
-			out = handleCommentEnd(ctx, item, openComments, out);
-			break;
-		case "commentReference":
-			out += renderPointComment(ctx, pkg, item.id);
-			break;
-		case "simpleField":
-		case "complexField": {
-			const runs = item.type === "simpleField" ? item.content : item.fieldResult;
-			for (const child of runs) {
-				if (child.type === "run") {
-					out += renderRun(ctx, pkg, child, paraId);
-					continue;
+	const items = content.filter((item) => !SILENT_MARKERS.has(item.type) && !(ctx.opts.comments === "strip" && COMMENT_MARKERS.has(item.type)));
+	const around = (index) => {
+		const next = items[index + 1];
+		return {
+			before: out.length > 0 ? out.at(-1) : edges.before,
+			after: next === void 0 ? edges.after : renderedStart(next)
+		};
+	};
+	for (let index = 0; index < items.length; index++) {
+		const item = items[index];
+		if (item === void 0) break;
+		switch (item.type) {
+			case "run": {
+				const runs = [item];
+				while (items[index + 1]?.type === "run") {
+					runs.push(items[index + 1]);
+					index++;
 				}
-				if (child.type === "hyperlink") {
-					out += renderHyperlink(ctx, pkg, child, paraId);
-					continue;
+				out += renderRuns(ctx, pkg, runs, paraId, around(index));
+				break;
+			}
+			case "hyperlink":
+				out += renderHyperlink(ctx, pkg, item, paraId);
+				break;
+			case "insertion":
+			case "deletion":
+			case "moveFrom":
+			case "moveTo":
+				out += renderTrackedWrapper(ctx, pkg, item, paraId);
+				break;
+			case "commentRangeStart":
+				out += handleCommentStart(ctx, pkg, item, openComments, out.length);
+				break;
+			case "commentRangeEnd":
+				out = handleCommentEnd(ctx, item, openComments, out);
+				break;
+			case "commentReference":
+				out += renderPointComment(ctx, pkg, item.id);
+				break;
+			case "simpleField":
+			case "complexField": {
+				const runs = item.type === "simpleField" ? item.content : item.fieldResult;
+				for (const child of runs) {
+					if (child.type === "run") {
+						out += renderRuns(ctx, pkg, [child], paraId);
+						continue;
+					}
+					if (child.type === "hyperlink") {
+						out += renderHyperlink(ctx, pkg, child, paraId);
+						continue;
+					}
+					out += child.type === "inlineWrapper" ? renderParagraphInline(ctx, pkg, child.content, paraId, UNKNOWN_NEIGHBORS) : child.text;
 				}
-				out += child.type === "inlineWrapper" ? renderParagraphInline(ctx, pkg, child.content, paraId) : child.text;
+				break;
 			}
-			break;
+			case "inlineSdt":
+			case "inlineWrapper":
+				out += renderParagraphInline(ctx, pkg, item.content, paraId, around(index));
+				break;
+			case "mathEquation":
+				if (item.plainText) out += escapeInline(item.plainText);
+				break;
+			default: break;
 		}
-		case "inlineSdt":
-		case "inlineWrapper":
-			out += renderParagraphInline(ctx, pkg, item.content, paraId);
-			break;
-		case "mathEquation":
-			if (item.plainText) out += escapeInline(item.plainText);
-			break;
-		default: break;
 	}
 	while (openComments.length) {
 		const slot = openComments.pop();