@createiq/htmldiff 1.1.0 → 1.2.0-beta.1

package/dist/HtmlDiff.mjs

@@ -48,8 +48,20 @@ function stripTagAttributes(word) {
 	if (match) return `${match[0]}${word.endsWith("/>") ? "/>" : ">"}`;
 	return word;
 }
-function wrapText(text, tagName, cssClass) {
-	return `<${tagName} class='${cssClass}'>${text}</${tagName}>`;
+function wrapText(text, tagName, cssClass, metadata) {
+	if (!metadata) return `<${tagName} class='${cssClass}'>${text}</${tagName}>`;
+	return `<${tagName}${composeTagAttributes(cssClass, metadata)}>${text}</${tagName}>`;
+}
+/**
+* Build the attribute portion of an opening tag from a base class plus
+* optional metadata. Exposed so emission paths that build opening-tag
+* fragments by hand (e.g. the formatting-tag special-case in
+* `HtmlDiff.insertTag`) can stay consistent with `wrapText`.
+*/
+function composeTagAttributes(cssClass, metadata) {
+	let out = ` class='${metadata.extraClasses ? `${cssClass} ${metadata.extraClasses}` : cssClass}'`;
+	if (metadata.dataAttrs) for (const key of Object.keys(metadata.dataAttrs)) out += ` data-${key}='${metadata.dataAttrs[key]}'`;
+	return out;
 }
 function isStartOfTag(val) {
 	return val === "<";
@@ -83,6 +95,7 @@ var Utils_default = {
 	isTag,
 	stripTagAttributes,
 	wrapText,
+	composeTagAttributes,
 	isStartOfTag,
 	isEndOfTag,
 	isStartOfEntity,
@@ -200,11 +213,425 @@ var Operation = class {
 		this.startInNew = startInNew;
 		this.endInNew = endInNew;
 	}
-};
+};
+//#endregion
+//#region src/Alignment.ts
+/**
+* Standard LCS alignment: walks both sequences and emits a list of pairs
+* where `(oldIdx, newIdx)` are both set for matching positions, and one
+* side is null for an unmatched entry on the other side. Equality uses
+* strict ===.
+*/
+function lcsAlign(oldKeys, newKeys) {
+	const m = oldKeys.length;
+	const n = newKeys.length;
+	const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+	for (let i = 1; i <= m; i++) for (let j = 1; j <= n; j++) if (oldKeys[i - 1] === newKeys[j - 1]) dp[i][j] = dp[i - 1][j - 1] + 1;
+	else dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+	const result = [];
+	let i = m;
+	let j = n;
+	while (i > 0 || j > 0) if (i > 0 && j > 0 && oldKeys[i - 1] === newKeys[j - 1]) {
+		result.push({
+			oldIdx: i - 1,
+			newIdx: j - 1
+		});
+		i--;
+		j--;
+	} else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+		result.push({
+			oldIdx: null,
+			newIdx: j - 1
+		});
+		j--;
+	} else {
+		result.push({
+			oldIdx: i - 1,
+			newIdx: null
+		});
+		i--;
+	}
+	result.reverse();
+	return result;
+}
+/**
+* Given a shorter sequence (M items) and a longer sequence (N items, with
+* N > M), find the K = N - M positions in the longer sequence that should
+* be "skipped" so the unskipped longer items, aligned positionally with
+* the shorter items, maximise the sum of pairwise similarity.
+*
+* Solves the same problem as enumerating C(N, K) skip combinations and
+* picking the highest-scoring one, but in O(M × N) time via DP:
+*
+*   f(i, j) = max similarity from consuming i shorter and j longer items
+*             (defined for j >= i; entries below the diagonal are never
+*              written or read).
+*   f(0, j) = 0
+*   f(i, j) = max(
+*     f(i-1, j-1) + similarity(i-1, j-1),  // pair
+*     f(i,   j-1)                          // skip longer[j-1]
+*   )
+*
+* Tie-breaking prefers pairing over skipping, so ties resolve to skipping
+* EARLIER positions — matching the lex-first-combo behaviour of a full
+* combinatorial enumeration over which K positions to skip. Backtrack
+* re-asks the fill's pair-vs-skip question to preserve this direction
+* (the alternative — a `dp[i][j] > dp[i][j-1]` shortcut — would invert
+* the tie-breaking).
+*
+* Caller responsibility: ensure `longerTexts.length >= shorterTexts.length`.
+*/
+function findOptimalAlignmentSkips(shorterTexts, longerTexts, similarity) {
+	const m = shorterTexts.length;
+	const n = longerTexts.length;
+	const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+	for (let i = 1; i <= m; i++) for (let j = i; j <= n; j++) {
+		const pair = dp[i - 1][j - 1] + similarity(i - 1, j - 1);
+		const skip = j > i ? dp[i][j - 1] : Number.NEGATIVE_INFINITY;
+		dp[i][j] = pair >= skip ? pair : skip;
+	}
+	const skipped = [];
+	let i = m;
+	let j = n;
+	while (j > 0) {
+		if (i === 0) {
+			skipped.push(j - 1);
+			j--;
+			continue;
+		}
+		if (j === i) {
+			i--;
+			j--;
+			continue;
+		}
+		if (dp[i - 1][j - 1] + similarity(i - 1, j - 1) >= dp[i][j - 1]) {
+			i--;
+			j--;
+		} else {
+			skipped.push(j - 1);
+			j--;
+		}
+	}
+	skipped.reverse();
+	return skipped;
+}
+/**
+* Identifies pairings inside each unmatched-only run, then builds the
+* output alignment by walking the original and substituting paired
+* entries at the *ins position* (not the del position). This keeps the
+* result monotonically non-decreasing in newIdx — required by any
+* downstream emission that walks the new sequence in order. Emitting at
+* the del position would be safe when del<ins in the alignment array
+* (the typical case), but can violate monotonicity when unpaired
+* entries interleave with paired ones in the same run.
+*
+* Greedy assignment: the first del in document order wins its best ins.
+* Suboptimal vs Hungarian on edge cases (two dels above threshold for
+* the same ins), but bounded — a losing del just emits as a full delete
+* rather than a content edit.
+*/
+function pairSimilarUnmatched(alignment, threshold, similarity) {
+	const pairs = /* @__PURE__ */ new Map();
+	let i = 0;
+	while (i < alignment.length) {
+		if (alignment[i].oldIdx !== null && alignment[i].newIdx !== null) {
+			i++;
+			continue;
+		}
+		const runStart = i;
+		while (i < alignment.length && alignment[i].oldIdx === null !== (alignment[i].newIdx === null)) i++;
+		const runEnd = i;
+		const delIndices = [];
+		const insIndices = [];
+		for (let k = runStart; k < runEnd; k++) if (alignment[k].oldIdx !== null) delIndices.push(k);
+		else insIndices.push(k);
+		const usedIns = /* @__PURE__ */ new Set();
+		for (const di of delIndices) {
+			let bestIi = -1;
+			let bestSim = threshold;
+			for (const ii of insIndices) {
+				if (usedIns.has(ii)) continue;
+				const sim = similarity(alignment[di].oldIdx, alignment[ii].newIdx);
+				if (sim > bestSim) {
+					bestSim = sim;
+					bestIi = ii;
+				}
+			}
+			if (bestIi >= 0) {
+				pairs.set(di, bestIi);
+				usedIns.add(bestIi);
+			}
+		}
+	}
+	const insToDel = /* @__PURE__ */ new Map();
+	for (const [delAi, insAi] of pairs) insToDel.set(insAi, delAi);
+	const pairedDels = new Set(pairs.keys());
+	const result = [];
+	for (let k = 0; k < alignment.length; k++) {
+		if (pairedDels.has(k)) continue;
+		if (insToDel.has(k)) {
+			const delAi = insToDel.get(k);
+			result.push({
+				oldIdx: alignment[delAi].oldIdx,
+				newIdx: alignment[k].newIdx
+			});
+		} else result.push(alignment[k]);
+	}
+	return result;
+}
+/**
+* Reorders the alignment so a cursor-based emission walking the new
+* sequence in order produces entries in their visually-correct
+* position. Each entry is assigned a fractional "position" in new's
+* flow:
+*
+*   • Preserved/paired (oldIdx, newIdx): position = newIdx.
+*   • Pure insert (null, newIdx): position = newIdx.
+*   • Pure delete (oldIdx, null): position = newIdx-of-preserved-just-
+*     before-this-oldIdx + 0.5. Dels at the same gap sort by oldIdx so
+*     they appear in old's source order. The +0.5 places dels BEFORE
+*     any insert at the same gap (insert at newIdx N1+1 has position
+*     N1+1 which is > N1+0.5), giving the natural "delete first, insert
+*     second" reading order at a replaced position.
+*
+* Handles the full range:
+*   • Run of unpaired dels at the start (no preserved predecessor):
+*     position -0.5, sorted by oldIdx.
+*   • Dels in the middle: positioned right after their preceding
+*     preserved entry.
+*   • Dels at the end (no preserved successor): positioned after the
+*     last preserved entry.
+*
+* Without this reordering, a run of unpaired deletes ahead of any
+* preserved entry would be emitted before the first preserved entry,
+* regardless of where they originated in old.
+*
+* NB: `0.5` is the ONLY fractional offset used. If another decoration
+* kind ever needs a fractional position too, redesign this scheme
+* (e.g. a discrete `(integerSlot, kind, secondary)` triple) rather than
+* picking another magic offset and hoping it doesn't collide.
+*/
+function orderAlignmentForEmission(alignment) {
+	const preserved = [];
+	for (const a of alignment) if (a.oldIdx !== null && a.newIdx !== null) preserved.push({
+		oldIdx: a.oldIdx,
+		newIdx: a.newIdx
+	});
+	preserved.sort((a, b) => a.oldIdx - b.oldIdx);
+	function newIdxOfPreservedBefore(oldIdx) {
+		let result = -1;
+		for (const p of preserved) {
+			if (p.oldIdx >= oldIdx) break;
+			result = p.newIdx;
+		}
+		return result;
+	}
+	const decorated = alignment.map((a, i) => {
+		let primary;
+		let secondary;
+		if (a.newIdx !== null) {
+			primary = a.newIdx;
+			secondary = a.oldIdx === null ? 1 : 0;
+		} else {
+			primary = newIdxOfPreservedBefore(a.oldIdx) + .5;
+			secondary = a.oldIdx;
+		}
+		return {
+			entry: a,
+			primary,
+			secondary,
+			originalIdx: i
+		};
+	});
+	decorated.sort((a, b) => {
+		if (a.primary !== b.primary) return a.primary - b.primary;
+		if (a.secondary !== b.secondary) return a.secondary - b.secondary;
+		return a.originalIdx - b.originalIdx;
+	});
+	return decorated.map((d) => d.entry);
+}
+/**
+* Combined similarity metric used for fuzzy pairing. Returns the MAX of
+* two complementary metrics:
+*
+*   1. **Character prefix+suffix similarity** — fraction of the longer
+*      string covered by shared prefix + shared suffix. Catches small
+*      edits in the middle of a string (one word changed). Misses cases
+*      where the bulk of common content is in the middle and the ends
+*      differ.
+*
+*   2. **Token Jaccard similarity** — intersection-over-union of the
+*      whitespace-split tokens. Catches "most of the content is the
+*      same but bookended by different bits" — e.g. an edit where the
+*      ~50 chars in the middle that DO match would be invisible to
+*      prefix+suffix.
+*
+* Either metric exceeding the threshold means pair. Neither alone is
+* sufficient for the full range of legal-doc edits we see in
+* production tables.
+*/
+function textSimilarity(a, b) {
+	if (a === b) return 1;
+	if (a.length === 0 || b.length === 0) return 0;
+	return Math.max(charPrefixSuffixSimilarity(a, b), tokenJaccardSimilarity(a, b));
+}
+function charPrefixSuffixSimilarity(a, b) {
+	let prefix = 0;
+	const minLen = Math.min(a.length, b.length);
+	while (prefix < minLen && a[prefix] === b[prefix]) prefix++;
+	let suffix = 0;
+	while (suffix < a.length - prefix && suffix < b.length - prefix && a[a.length - 1 - suffix] === b[b.length - 1 - suffix]) suffix++;
+	return (prefix + suffix) / Math.max(a.length, b.length);
+}
+function tokenJaccardSimilarity(a, b) {
+	const tokensA = new Set(a.split(/\s+/).filter(Boolean));
+	const tokensB = new Set(b.split(/\s+/).filter(Boolean));
+	if (tokensA.size === 0 && tokensB.size === 0) return 1;
+	let intersection = 0;
+	for (const t of tokensA) if (tokensB.has(t)) intersection++;
+	const union = tokensA.size + tokensB.size - intersection;
+	return union === 0 ? 0 : intersection / union;
+}
+//#endregion
+//#region src/HtmlScanner.ts
+/**
+* Parses the opening tag (or comment/CDATA/PI) starting at `i`. Returns
+* the index just past the closing delimiter, or null if the tag is
+* malformed (unterminated). HTML comments, CDATA, processing
+* instructions, and DOCTYPE need their own terminators — a plain
+* `>`-walker would cut a comment like `<!-- a > b -->` at the first
+* inner `>`, treating the rest as text and corrupting downstream
+* offsets. Word-exported HTML routinely emits comments inside tables
+* (conditional comments, OLE markers) so these have to be handled.
+*/
+function parseOpeningTagAt(html, i) {
+	if (html.startsWith("<!--", i)) {
+		const close = html.indexOf("-->", i + 4);
+		return close === -1 ? null : { end: close + 3 };
+	}
+	if (html.startsWith("<![CDATA[", i)) {
+		const close = html.indexOf("]]>", i + 9);
+		return close === -1 ? null : { end: close + 3 };
+	}
+	if (html.startsWith("<?", i)) {
+		const close = html.indexOf("?>", i + 2);
+		return close === -1 ? null : { end: close + 2 };
+	}
+	let j = i + 1;
+	let quote = null;
+	while (j < html.length) {
+		const ch = html[j];
+		if (quote) {
+			if (ch === quote) quote = null;
+		} else if (ch === "\"" || ch === "'") quote = ch;
+		else if (ch === ">") return { end: j + 1 };
+		j++;
+	}
+	return null;
+}
+function matchesTagAt(html, i, tagName) {
+	if (html[i] !== "<") return false;
+	if (html.slice(i + 1, i + 1 + tagName.length).toLowerCase() !== tagName) return false;
+	const after = html[i + 1 + tagName.length];
+	return after === ">" || after === " " || after === "	" || after === "\n" || after === "\r" || after === "/";
+}
+function matchesClosingTagAt(html, i, tagName) {
+	if (html[i] !== "<" || html[i + 1] !== "/") return false;
+	if (html.slice(i + 2, i + 2 + tagName.length).toLowerCase() !== tagName) return false;
+	const after = html[i + 2 + tagName.length];
+	return after === ">" || after === " " || after === "	" || after === "\n" || after === "\r";
+}
+/**
+* Returns the index just past the matching `</tagName>`, accounting for
+* nested tags of the same name. Returns -1 if no match before `limit`.
+*/
+function findMatchingClosingTag(html, from, tagName, limit = html.length) {
+	let depth = 1;
+	let i = from;
+	while (i < limit) if (matchesTagAt(html, i, tagName)) {
+		const opening = parseOpeningTagAt(html, i);
+		if (!opening) {
+			i++;
+			continue;
+		}
+		if (!html.slice(i, opening.end).endsWith("/>")) depth++;
+		i = opening.end;
+	} else if (matchesClosingTagAt(html, i, tagName)) {
+		depth--;
+		const closingEnd = parseOpeningTagAt(html, i)?.end ?? i + `</${tagName}>`.length;
+		if (depth === 0) return closingEnd;
+		i = closingEnd;
+	} else i++;
+	return -1;
+}
+/**
+* Returns the opening tag with the given class injected. Locates the real
+* `class` attribute via attribute-aware walking (NOT a flat regex — that
+* would mis-match inside a foreign attribute value like
+* `title="see class='x'"`). When the class already partially overlaps with
+* `cls` — e.g. existing `class="mod"` and we're injecting `mod colspan` —
+* only the missing tokens get appended, so we never end up with
+* `class="mod mod colspan"`.
+*/
+function injectClass(openingTag, cls) {
+	const clsTokens = cls.split(/\s+/).filter(Boolean);
+	if (clsTokens.length === 0) return openingTag;
+	const classAttr = findClassAttribute(openingTag);
+	if (classAttr) {
+		const existingTokens = classAttr.value.split(/\s+/).filter(Boolean);
+		const missing = clsTokens.filter((t) => !existingTokens.includes(t));
+		if (missing.length === 0) return openingTag;
+		const updatedValue = existingTokens.length === 0 ? missing.join(" ") : `${existingTokens.join(" ")} ${missing.join(" ")}`;
+		return openingTag.slice(0, classAttr.valueStart) + updatedValue + openingTag.slice(classAttr.valueEnd);
+	}
+	const insertAt = openingTag.endsWith("/>") ? openingTag.length - 2 : openingTag.length - 1;
+	return `${openingTag.slice(0, insertAt).replace(/\s*$/, "")} class='${cls}'${openingTag.slice(insertAt)}`;
+}
+/**
+* Walks the opening tag's attributes (respecting quoted values) to find
+* the actual `class` attribute. Returns the value range (start/end of the
+* value content, *excluding* the surrounding quotes) and the value, or
+* null if no `class` attribute is present.
+*/
+function findClassAttribute(openingTag) {
+	let i = 1;
+	while (i < openingTag.length && /[A-Za-z0-9_:-]/.test(openingTag[i])) i++;
+	while (i < openingTag.length) {
+		while (i < openingTag.length && /\s/.test(openingTag[i])) i++;
+		if (i >= openingTag.length) break;
+		if (openingTag[i] === ">" || openingTag[i] === "/") break;
+		const nameStart = i;
+		while (i < openingTag.length && !/[\s=>/]/.test(openingTag[i])) i++;
+		const name = openingTag.slice(nameStart, i);
+		while (i < openingTag.length && /\s/.test(openingTag[i])) i++;
+		if (openingTag[i] !== "=") continue;
+		i++;
+		while (i < openingTag.length && /\s/.test(openingTag[i])) i++;
+		let valueStart;
+		let valueEnd;
+		if (openingTag[i] === "\"" || openingTag[i] === "'") {
+			const quote = openingTag[i];
+			i++;
+			valueStart = i;
+			while (i < openingTag.length && openingTag[i] !== quote) i++;
+			valueEnd = i;
+			if (i < openingTag.length) i++;
+		} else {
+			valueStart = i;
+			while (i < openingTag.length && !/[\s>/]/.test(openingTag[i])) i++;
+			valueEnd = i;
+		}
+		if (name.toLowerCase() === "class") return {
+			valueStart,
+			valueEnd,
+			value: openingTag.slice(valueStart, valueEnd)
+		};
+	}
+	return null;
+}
 //#endregion
 //#region src/TableDiff.ts
 const PLACEHOLDER_PREFIX_BASE = "<!--HTMLDIFF_TABLE_";
-const PLACEHOLDER_SUFFIX = "-->";
 /**
 * Hard cap on table dimensions handled by the structural-aware path.
 * The row-LCS is O(rows²), the per-row cell-LCS is O(cells²), and each
@@ -217,11 +644,16 @@ const PLACEHOLDER_SUFFIX = "-->";
 const MAX_TABLE_ROWS = 1500;
 const MAX_TABLE_CELLS_PER_ROW = 200;
 const MAX_COLUMN_DELTA = 6;
-const MAX_COLUMN_SEARCH_WIDTH = 40;
-function makePlaceholderPrefix(oldHtml, newHtml) {
+const MAX_COLUMN_SEARCH_WIDTH = 200;
+/**
+* Generate a placeholder-prefix nonce that doesn't collide with any
+* existing content in the inputs. Variadic so callers with N inputs
+* (e.g. three-way diff with V1/V2/V3) check across all of them.
+*/
+function makePlaceholderPrefix(...inputs) {
 	for (let attempt = 0; attempt < 8; attempt++) {
 		const prefix = `${PLACEHOLDER_PREFIX_BASE}${Math.floor(Math.random() * 4294967295).toString(16).padStart(8, "0")}_`;
-		if (!oldHtml.includes(prefix) && !newHtml.includes(prefix)) return prefix;
+		if (inputs.every((input) => !input.includes(prefix))) return prefix;
 	}
 	return `${PLACEHOLDER_PREFIX_BASE}fallback_${Date.now()}_`;
 }
@@ -248,7 +680,7 @@ function preprocessTables(oldHtml, newHtml, diffCell) {
 	const placeholderPrefix = makePlaceholderPrefix(oldHtml, newHtml);
 	const placeholderToDiff = /* @__PURE__ */ new Map();
 	for (let i = pairs.length - 1; i >= 0; i--) {
-		const placeholder = `${placeholderPrefix}${i}${PLACEHOLDER_SUFFIX}`;
+		const placeholder = `${placeholderPrefix}${i}-->`;
 		placeholderToDiff.set(placeholder, pairs[i].diffed);
 		modifiedOld = spliceString(modifiedOld, pairs[i].oldTable.tableStart, pairs[i].oldTable.tableEnd, placeholder);
 		modifiedNew = spliceString(modifiedNew, pairs[i].newTable.tableStart, pairs[i].newTable.tableEnd, placeholder);
@@ -428,72 +860,6 @@ function diffStructurallyAlignedTable(oldHtml, newHtml, oldTable, newTable, diff
 	out.push(newHtml.slice(cursor, newTable.tableEnd));
 	return out.join("");
 }
-/**
-* Reorders the alignment so emission produces rows in the visually-
-* correct order. Each entry is assigned a fractional "position" in
-* new's flow:
-*
-*   • Preserved/paired (oldIdx, newIdx): position = newIdx.
-*   • Pure insert (null, newIdx): position = newIdx.
-*   • Pure delete (oldIdx, null): position = newIdx-of-preserved-just-
-*     before-this-oldIdx + 0.5. Dels at the same gap sort by oldIdx so
-*     they appear in old's row order. The +0.5 places dels BEFORE any
-*     insert at the same gap (insert at newIdx N1+1 has position N1+1
-*     which is > N1+0.5), giving the natural "delete first, insert
-*     second" reading order at a replaced position.
-*
-* This handles the full range:
-*   • Run of unpaired dels at the start (no preserved predecessor):
-*     position -0.5, sorted by oldIdx.
-*   • Dels in the middle: positioned right after their preceding
-*     preserved row.
-*   • Dels at the end (no preserved successor): positioned after the
-*     last preserved row.
-*
-* Without this reordering, a run of unpaired deletes at low alignment
-* indices got emitted at cursor = first-new-row position — putting
-* all deletes before any preserved row in the output, regardless of
-* where they came from in old.
-*/
-function orderAlignmentForEmission(alignment) {
-	const preserved = [];
-	for (const a of alignment) if (a.oldIdx !== null && a.newIdx !== null) preserved.push({
-		oldIdx: a.oldIdx,
-		newIdx: a.newIdx
-	});
-	preserved.sort((a, b) => a.oldIdx - b.oldIdx);
-	function newIdxOfPreservedBefore(oldIdx) {
-		let result = -1;
-		for (const p of preserved) {
-			if (p.oldIdx >= oldIdx) break;
-			result = p.newIdx;
-		}
-		return result;
-	}
-	const decorated = alignment.map((a, i) => {
-		let primary;
-		let secondary;
-		if (a.newIdx !== null) {
-			primary = a.newIdx;
-			secondary = a.oldIdx === null ? 1 : 0;
-		} else {
-			primary = newIdxOfPreservedBefore(a.oldIdx) + .5;
-			secondary = a.oldIdx;
-		}
-		return {
-			entry: a,
-			primary,
-			secondary,
-			originalIdx: i
-		};
-	});
-	decorated.sort((a, b) => {
-		if (a.primary !== b.primary) return a.primary - b.primary;
-		if (a.secondary !== b.secondary) return a.secondary - b.secondary;
-		return a.originalIdx - b.originalIdx;
-	});
-	return decorated.map((d) => d.entry);
-}
 function rebuildStructurallyAlignedTable(oldHtml, newHtml, oldTable, newTable, alignment) {
 	const out = [];
 	out.push(headerSlice(newHtml, newTable, oldHtml, oldTable));
@@ -518,21 +884,21 @@ function diffPreservedRow(oldHtml, newHtml, oldRow, newRow, diffCell) {
 	const delta = newRow.cells.length - oldRow.cells.length;
 	const absDelta = Math.abs(delta);
 	if (absDelta > 0 && absDelta <= MAX_COLUMN_DELTA && Math.max(oldRow.cells.length, newRow.cells.length) <= MAX_COLUMN_SEARCH_WIDTH) {
-		if (delta > 0) return diffMultiColumnAddRow(oldHtml, newHtml, oldRow, newRow, delta, diffCell);
-		return diffMultiColumnDeleteRow(oldHtml, newHtml, oldRow, newRow, -delta, diffCell);
+		if (delta > 0) return diffMultiColumnAddRow(oldHtml, newHtml, oldRow, newRow, diffCell);
+		return diffMultiColumnDeleteRow(oldHtml, newHtml, oldRow, newRow, diffCell);
 	}
 	return diffStructurallyAlignedRow(oldHtml, newHtml, oldRow, newRow, diffCell);
 }
 /**
-* For a row where new has K more cells than old, find the K column
-* positions in new where cells were inserted by scanning all C(newCount,
-* K) combinations and picking the one that maximises positional content
-* similarity with the remaining cells. The inserted cells are emitted
-* with diff markers; the rest are aligned positionally with content
-* diff for matched pairs.
+* For a row where new has more cells than old, find the column positions
+* in new where cells were inserted by running a monotonic-alignment DP
+* over the cell texts: pick the skip positions that maximise the sum-of-
+* similarities of the unskipped new cells aligned positionally against
+* the old cells. The inserted cells are emitted with diff markers; the
+* rest are aligned positionally with content diff for matched pairs.
 */
-function diffMultiColumnAddRow(oldHtml, newHtml, oldRow, newRow, k, diffCell) {
-	const insertedPositions = findBestColumnInsertPositions(oldRow, newRow, k, oldHtml, newHtml);
+function diffMultiColumnAddRow(oldHtml, newHtml, oldRow, newRow, diffCell) {
+	const insertedPositions = findBestColumnInsertPositions(oldRow, newRow, oldHtml, newHtml);
 	const inserted = new Set(insertedPositions);
 	const out = [rowHeaderSlice(newHtml, newRow)];
 	let oldIdx = 0;
@@ -544,8 +910,8 @@ function diffMultiColumnAddRow(oldHtml, newHtml, oldRow, newRow, k, diffCell) {
 	out.push("</tr>");
 	return out.join("");
 }
-function diffMultiColumnDeleteRow(oldHtml, newHtml, oldRow, newRow, k, diffCell) {
-	const deletedPositions = findBestColumnDeletePositions(oldRow, newRow, k, oldHtml, newHtml);
+function diffMultiColumnDeleteRow(oldHtml, newHtml, oldRow, newRow, diffCell) {
+	const deletedPositions = findBestColumnDeletePositions(oldRow, newRow, oldHtml, newHtml);
 	const deleted = new Set(deletedPositions);
 	const out = [rowHeaderSlice(newHtml, newRow)];
 	let newIdx = 0;
@@ -560,64 +926,15 @@ function diffMultiColumnDeleteRow(oldHtml, newHtml, oldRow, newRow, k, diffCell)
 	out.push("</tr>");
 	return out.join("");
 }
-function findBestColumnInsertPositions(oldRow, newRow, k, oldHtml, newHtml) {
+function findBestColumnInsertPositions(oldRow, newRow, oldHtml, newHtml) {
 	const oldTexts = oldRow.cells.map((c) => cellText(oldHtml, c));
 	const newTexts = newRow.cells.map((c) => cellText(newHtml, c));
-	let bestPositions = [];
-	let bestScore = -1;
-	for (const combo of combinationsOfRange(newRow.cells.length, k)) {
-		const inserted = new Set(combo);
-		let score = 0;
-		let oldIdx = 0;
-		for (let newIdx = 0; newIdx < newRow.cells.length; newIdx++) {
-			if (inserted.has(newIdx)) continue;
-			score += textSimilarity(oldTexts[oldIdx], newTexts[newIdx]);
-			oldIdx++;
-		}
-		if (score > bestScore) {
-			bestScore = score;
-			bestPositions = combo;
-		}
-	}
-	return bestPositions;
+	return findOptimalAlignmentSkips(oldTexts, newTexts, (oldIdx, newIdx) => textSimilarity(oldTexts[oldIdx], newTexts[newIdx]));
 }
-function findBestColumnDeletePositions(oldRow, newRow, k, oldHtml, newHtml) {
+function findBestColumnDeletePositions(oldRow, newRow, oldHtml, newHtml) {
 	const oldTexts = oldRow.cells.map((c) => cellText(oldHtml, c));
 	const newTexts = newRow.cells.map((c) => cellText(newHtml, c));
-	let bestPositions = [];
-	let bestScore = -1;
-	for (const combo of combinationsOfRange(oldRow.cells.length, k)) {
-		const deleted = new Set(combo);
-		let score = 0;
-		let newIdx = 0;
-		for (let oldIdx = 0; oldIdx < oldRow.cells.length; oldIdx++) {
-			if (deleted.has(oldIdx)) continue;
-			score += textSimilarity(oldTexts[oldIdx], newTexts[newIdx]);
-			newIdx++;
-		}
-		if (score > bestScore) {
-			bestScore = score;
-			bestPositions = combo;
-		}
-	}
-	return bestPositions;
-}
-/**
-* Yields all sorted-ascending combinations of `k` distinct integers
-* from [0, n). Iterative implementation avoids recursion overhead and
-* keeps memory at O(k).
-*/
-function* combinationsOfRange(n, k) {
-	if (k === 0 || k > n) return;
-	const indices = Array.from({ length: k }, (_, i) => i);
-	while (true) {
-		yield indices.slice();
-		let i = k - 1;
-		while (i >= 0 && indices[i] === n - k + i) i--;
-		if (i < 0) return;
-		indices[i]++;
-		for (let j = i + 1; j < k; j++) indices[j] = indices[j - 1] + 1;
-	}
+	return findOptimalAlignmentSkips(newTexts, oldTexts, (newIdx, oldIdx) => textSimilarity(oldTexts[oldIdx], newTexts[newIdx]));
 }
 /**
 * Try to align cells by logical column position (sum of colspans). When
@@ -809,253 +1126,44 @@ function emitDiffedCell(oldHtml, newHtml, oldCell, newCell, diffCell) {
 }
 function rowHeaderSlice(html, row) {
 	const opening = parseOpeningTagAt(html, row.rowStart);
-	if (!opening) return "";
-	if (row.cells.length === 0) return html.slice(row.rowStart, opening.end);
-	return html.slice(row.rowStart, row.cells[0].cellStart);
-}
-/** Character-level similarity threshold above which we treat two rows as "the same row, edited". */
-const ROW_FUZZY_THRESHOLD = .5;
-/**
-* Threshold for "this cell is a content-edit of that cell." Tuned the same
-* as ROW_FUZZY_THRESHOLD; cells in legal docs that share most of their
-* content typically ARE the same logical cell with a body edit, so 0.5
-* works for both granularities in practice.
-*/
-const CELL_FUZZY_THRESHOLD = .5;
-/**
-* After exact LCS, scan the alignment for runs of "old deleted, then new
-* inserted" (or vice versa) and pair entries whose content is similar
-* enough to be treated as an edit rather than a delete+insert. This keeps
-* row-level edits (a typo fix, a single word change) from being shown as
-* an entire row vanishing and a new one appearing — matching what users
-* expect from a typical track-changes view.
-*/
-function pairSimilarUnmatchedRows(alignment, oldTable, newTable, oldHtml, newHtml) {
-	const oldTexts = oldTable.rows.map((r) => rowText(oldHtml, r));
-	const newTexts = newTable.rows.map((r) => rowText(newHtml, r));
-	return pairSimilarUnmatched(alignment, ROW_FUZZY_THRESHOLD, (oldIdx, newIdx) => textSimilarity(oldTexts[oldIdx], newTexts[newIdx]));
-}
-function pairSimilarUnmatchedCells(alignment, oldRow, newRow, oldHtml, newHtml) {
-	const oldTexts = oldRow.cells.map((c) => cellText(oldHtml, c));
-	const newTexts = newRow.cells.map((c) => cellText(newHtml, c));
-	return pairSimilarUnmatched(alignment, CELL_FUZZY_THRESHOLD, (oldIdx, newIdx) => textSimilarity(oldTexts[oldIdx], newTexts[newIdx]));
-}
-/**
-* Identify pairings inside each unmatched-only run, then build the output
-* alignment by walking the original and substituting paired entries at
-* the *ins position* (not the del position). This keeps the result
-* monotonic in newIdx — critical because the cursor-based emission
-* downstream walks new's html in order. Emitting at the del position
-* would be fine when del<ins in the alignment array (the typical case),
-* but can violate monotonicity when there are mixed unpaired entries in
-* between (column-add + row-add together, content-edit + column-add,
-* etc.).
-*
-* Generic over what's being paired — works for both rows (by full row
-* content similarity) and cells (by per-cell content similarity).
-*/
-function pairSimilarUnmatched(alignment, threshold, similarity) {
-	const pairs = /* @__PURE__ */ new Map();
-	let i = 0;
-	while (i < alignment.length) {
-		if (alignment[i].oldIdx !== null && alignment[i].newIdx !== null) {
-			i++;
-			continue;
-		}
-		const runStart = i;
-		while (i < alignment.length && alignment[i].oldIdx === null !== (alignment[i].newIdx === null)) i++;
-		const runEnd = i;
-		const delIndices = [];
-		const insIndices = [];
-		for (let k = runStart; k < runEnd; k++) if (alignment[k].oldIdx !== null) delIndices.push(k);
-		else insIndices.push(k);
-		const usedIns = /* @__PURE__ */ new Set();
-		for (const di of delIndices) {
-			let bestIi = -1;
-			let bestSim = threshold;
-			for (const ii of insIndices) {
-				if (usedIns.has(ii)) continue;
-				const sim = similarity(alignment[di].oldIdx, alignment[ii].newIdx);
-				if (sim > bestSim) {
-					bestSim = sim;
-					bestIi = ii;
-				}
-			}
-			if (bestIi >= 0) {
-				pairs.set(di, bestIi);
-				usedIns.add(bestIi);
-			}
-		}
-	}
-	const insToDel = /* @__PURE__ */ new Map();
-	for (const [delAi, insAi] of pairs) insToDel.set(insAi, delAi);
-	const pairedDels = new Set(pairs.keys());
-	const result = [];
-	for (let k = 0; k < alignment.length; k++) {
-		if (pairedDels.has(k)) continue;
-		if (insToDel.has(k)) {
-			const delAi = insToDel.get(k);
-			result.push({
-				oldIdx: alignment[delAi].oldIdx,
-				newIdx: alignment[k].newIdx
-			});
-		} else result.push(alignment[k]);
-	}
-	return result;
-}
-/**
-* Combined similarity metric used for both row-level and cell-level
-* fuzzy pairing. Returns the MAX of two complementary metrics:
-*
-*   1. **Character prefix+suffix similarity** — fraction of the longer
-*      string covered by shared prefix + shared suffix. Catches small
-*      edits in the middle of a string (one word changed in a row).
-*      Misses cases where the bulk of common content is in the middle
-*      and the ends differ.
-*
-*   2. **Token Jaccard similarity** — intersection-over-union of the
-*      whitespace-split tokens. Catches "most of the content is the
-*      same but bookended by different bits" — e.g. a row whose only
-*      edit is a column added at the start and another at the end,
-*      where the ~50 chars in the middle that DO match would be
-*      invisible to prefix+suffix.
-*
-* Either metric exceeding the threshold means pair. Neither alone is
-* sufficient for the full range of legal-doc edits we see in
-* production tables.
-*/
-function textSimilarity(a, b) {
-	if (a === b) return 1;
-	if (a.length === 0 || b.length === 0) return 0;
-	return Math.max(charPrefixSuffixSimilarity(a, b), tokenJaccardSimilarity(a, b));
-}
-function charPrefixSuffixSimilarity(a, b) {
-	let prefix = 0;
-	const minLen = Math.min(a.length, b.length);
-	while (prefix < minLen && a[prefix] === b[prefix]) prefix++;
-	let suffix = 0;
-	while (suffix < a.length - prefix && suffix < b.length - prefix && a[a.length - 1 - suffix] === b[b.length - 1 - suffix]) suffix++;
-	return (prefix + suffix) / Math.max(a.length, b.length);
-}
-function tokenJaccardSimilarity(a, b) {
-	const tokensA = new Set(a.split(/\s+/).filter(Boolean));
-	const tokensB = new Set(b.split(/\s+/).filter(Boolean));
-	if (tokensA.size === 0 && tokensB.size === 0) return 1;
-	let intersection = 0;
-	for (const t of tokensA) if (tokensB.has(t)) intersection++;
-	const union = tokensA.size + tokensB.size - intersection;
-	return union === 0 ? 0 : intersection / union;
-}
-function rowText(html, row) {
-	const parts = [];
-	for (const cell of row.cells) parts.push(html.slice(cell.contentStart, cell.contentEnd).replace(/<[^>]+>/g, " "));
-	return parts.join(" ").replace(/\s+/g, " ").trim().toLowerCase();
-}
-function cellText(html, cell) {
-	return html.slice(cell.contentStart, cell.contentEnd).replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim().toLowerCase();
-}
-/**
-* Standard LCS alignment: walks both sequences and emits a list of pairs
-* where `(oldIdx, newIdx)` are both set for matching positions, and one
-* side is null for an unmatched entry on the other side. Equality uses
-* strict ===.
-*/
-function lcsAlign(oldKeys, newKeys) {
-	const m = oldKeys.length;
-	const n = newKeys.length;
-	const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
-	for (let i = 1; i <= m; i++) for (let j = 1; j <= n; j++) if (oldKeys[i - 1] === newKeys[j - 1]) dp[i][j] = dp[i - 1][j - 1] + 1;
-	else dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
-	const result = [];
-	let i = m;
-	let j = n;
-	while (i > 0 || j > 0) if (i > 0 && j > 0 && oldKeys[i - 1] === newKeys[j - 1]) {
-		result.push({
-			oldIdx: i - 1,
-			newIdx: j - 1
-		});
-		i--;
-		j--;
-	} else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
-		result.push({
-			oldIdx: null,
-			newIdx: j - 1
-		});
-		j--;
-	} else {
-		result.push({
-			oldIdx: i - 1,
-			newIdx: null
-		});
-		i--;
-	}
-	result.reverse();
-	return result;
-}
-/**
-* Returns the opening tag with the given class injected. Locates the real
-* `class` attribute via attribute-aware walking (NOT a flat regex — that
-* would mis-match inside a foreign attribute value like
-* `title="see class='x'"`). When the class already partially overlaps with
-* `cls` — e.g. existing `class="mod"` and we're injecting `mod colspan` —
-* only the missing tokens get appended, so we never end up with
-* `class="mod mod colspan"`.
-*/
-function injectClass(openingTag, cls) {
-	const clsTokens = cls.split(/\s+/).filter(Boolean);
-	if (clsTokens.length === 0) return openingTag;
-	const classAttr = findClassAttribute(openingTag);
-	if (classAttr) {
-		const existingTokens = classAttr.value.split(/\s+/).filter(Boolean);
-		const missing = clsTokens.filter((t) => !existingTokens.includes(t));
-		if (missing.length === 0) return openingTag;
-		const updatedValue = existingTokens.length === 0 ? missing.join(" ") : `${existingTokens.join(" ")} ${missing.join(" ")}`;
-		return openingTag.slice(0, classAttr.valueStart) + updatedValue + openingTag.slice(classAttr.valueEnd);
-	}
-	const insertAt = openingTag.endsWith("/>") ? openingTag.length - 2 : openingTag.length - 1;
-	return `${openingTag.slice(0, insertAt).replace(/\s*$/, "")} class='${cls}'${openingTag.slice(insertAt)}`;
+	if (!opening) return "";
+	if (row.cells.length === 0) return html.slice(row.rowStart, opening.end);
+	return html.slice(row.rowStart, row.cells[0].cellStart);
 }
+/** Character-level similarity threshold above which we treat two rows as "the same row, edited". */
+const ROW_FUZZY_THRESHOLD = .5;
 /**
-* Walks the opening tag's attributes (respecting quoted values) to find
-* the actual `class` attribute. Returns the value range (start/end of the
-* value content, *excluding* the surrounding quotes) and the value, or
-* null if no `class` attribute is present.
+* Threshold for "this cell is a content-edit of that cell." Tuned the same
+* as ROW_FUZZY_THRESHOLD; cells in legal docs that share most of their
+* content typically ARE the same logical cell with a body edit, so 0.5
+* works for both granularities in practice.
 */
-function findClassAttribute(openingTag) {
-	let i = 1;
-	while (i < openingTag.length && /[A-Za-z0-9_:-]/.test(openingTag[i])) i++;
-	while (i < openingTag.length) {
-		while (i < openingTag.length && /\s/.test(openingTag[i])) i++;
-		if (i >= openingTag.length) break;
-		if (openingTag[i] === ">" || openingTag[i] === "/") break;
-		const nameStart = i;
-		while (i < openingTag.length && !/[\s=>/]/.test(openingTag[i])) i++;
-		const name = openingTag.slice(nameStart, i);
-		while (i < openingTag.length && /\s/.test(openingTag[i])) i++;
-		if (openingTag[i] !== "=") continue;
-		i++;
-		while (i < openingTag.length && /\s/.test(openingTag[i])) i++;
-		let valueStart;
-		let valueEnd;
-		if (openingTag[i] === "\"" || openingTag[i] === "'") {
-			const quote = openingTag[i];
-			i++;
-			valueStart = i;
-			while (i < openingTag.length && openingTag[i] !== quote) i++;
-			valueEnd = i;
-			if (i < openingTag.length) i++;
-		} else {
-			valueStart = i;
-			while (i < openingTag.length && !/[\s>/]/.test(openingTag[i])) i++;
-			valueEnd = i;
-		}
-		if (name.toLowerCase() === "class") return {
-			valueStart,
-			valueEnd,
-			value: openingTag.slice(valueStart, valueEnd)
-		};
-	}
-	return null;
+const CELL_FUZZY_THRESHOLD = .5;
+/**
+* After exact LCS, scan the alignment for runs of "old deleted, then new
+* inserted" (or vice versa) and pair entries whose content is similar
+* enough to be treated as an edit rather than a delete+insert. This keeps
+* row-level edits (a typo fix, a single word change) from being shown as
+* an entire row vanishing and a new one appearing — matching what users
+* expect from a typical track-changes view.
+*/
+function pairSimilarUnmatchedRows(alignment, oldTable, newTable, oldHtml, newHtml) {
+	const oldTexts = oldTable.rows.map((r) => rowText(oldHtml, r));
+	const newTexts = newTable.rows.map((r) => rowText(newHtml, r));
+	return pairSimilarUnmatched(alignment, ROW_FUZZY_THRESHOLD, (oldIdx, newIdx) => textSimilarity(oldTexts[oldIdx], newTexts[newIdx]));
+}
+function pairSimilarUnmatchedCells(alignment, oldRow, newRow, oldHtml, newHtml) {
+	const oldTexts = oldRow.cells.map((c) => cellText(oldHtml, c));
+	const newTexts = newRow.cells.map((c) => cellText(newHtml, c));
+	return pairSimilarUnmatched(alignment, CELL_FUZZY_THRESHOLD, (oldIdx, newIdx) => textSimilarity(oldTexts[oldIdx], newTexts[newIdx]));
+}
+function rowText(html, row) {
+	const parts = [];
+	for (const cell of row.cells) parts.push(html.slice(cell.contentStart, cell.contentEnd).replace(/<[^>]+>/g, " "));
+	return parts.join(" ").replace(/\s+/g, " ").trim().toLowerCase();
+}
+function cellText(html, cell) {
+	return html.slice(cell.contentStart, cell.contentEnd).replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim().toLowerCase();
 }
 /**
 * Walks html and returns ranges for every top-level `<table>...</table>`
@@ -1142,65 +1250,529 @@ function findTopLevelCells(html, start, end) {
 	else i++;
 	return cells;
 }
-function matchesTagAt(html, i, tagName) {
-	if (html[i] !== "<") return false;
-	if (html.slice(i + 1, i + 1 + tagName.length).toLowerCase() !== tagName) return false;
-	const after = html[i + 1 + tagName.length];
-	return after === ">" || after === " " || after === "	" || after === "\n" || after === "\r" || after === "/";
+//#endregion
+//#region src/ThreeWayDiff.ts
+/**
+* Builds the attributed segment stream for a three-way diff.
+*
+* @param dCp  analysis of diff(genesis → cp-latest)
+* @param dMe  analysis of diff(genesis → me-current)
+*
+* Both analyses must share the same `oldDiffWords` (the genesis tokens)
+* — the caller guarantees this by passing the same genesis input and
+* the same `useProjections` decision to both `HtmlDiff.analyze` calls.
+*/
+function buildSegments(dCp, dMe) {
+	const genesisLen = dCp.oldDiffWords.length;
+	const cpFate = buildFateFromGenesis(dCp.operations, genesisLen);
+	const meFate = buildFateFromGenesis(dMe.operations, genesisLen);
+	const cpInsAt = collectInsertionsKeyedByEnd(dCp);
+	const meInsAt = collectInsertionsKeyedByEnd(dMe);
+	const diffToOriginal = dCp.oldContentToOriginal ?? Array.from({ length: genesisLen }, (_, i) => i);
+	const genesisOriginalLen = dCp.oldOriginalWords.length;
+	const segments = [];
+	let originalCursor = 0;
+	emitBoundary(0, cpInsAt, meInsAt, dCp.newDiffWords, dMe.newDiffWords, segments);
+	for (let i = 0; i < genesisLen; i++) {
+		const cpDel = cpFate[i] === "deleted";
+		const meDel = meFate[i] === "deleted";
+		const origIdx = diffToOriginal[i];
+		const slice = dCp.oldOriginalWords.slice(originalCursor, origIdx + 1);
+		originalCursor = origIdx + 1;
+		if (!cpDel && !meDel) appendSegment(segments, { kind: "equal" }, slice);
+		else if (cpDel && meDel) {
+			if (slice.length > 1) appendSegment(segments, { kind: "equal" }, slice.slice(0, slice.length - 1));
+		} else if (cpDel) appendSegment(segments, {
+			kind: "del",
+			author: "cp"
+		}, slice);
+		else appendSegment(segments, {
+			kind: "del",
+			author: "me"
+		}, slice);
+		emitBoundary(i + 1, cpInsAt, meInsAt, dCp.newDiffWords, dMe.newDiffWords, segments);
+	}
+	if (originalCursor < genesisOriginalLen) appendSegment(segments, { kind: "equal" }, dCp.oldOriginalWords.slice(originalCursor));
+	return segments;
 }
-function matchesClosingTagAt(html, i, tagName) {
-	if (html[i] !== "<" || html[i + 1] !== "/") return false;
-	if (html.slice(i + 2, i + 2 + tagName.length).toLowerCase() !== tagName) return false;
-	const after = html[i + 2 + tagName.length];
-	return after === ">" || after === " " || after === "	" || after === "\n" || after === "\r";
+/**
+* Per genesis-diff-index, what did this side do to that token? Both
+* Delete and Replace ops remove the token from the side's output, so
+* both contribute `'deleted'`. Equal ops contribute `'kept'`. Insert
+* ops have an empty old range, so they don't touch the genesis fate
+* map.
+*/
+function buildFateFromGenesis(ops, genesisLen) {
+	const out = new Array(genesisLen).fill("kept");
+	for (const op of ops) {
+		if (op.action !== 1 && op.action !== 4) continue;
+		for (let i = op.startInOld; i < op.endInOld; i++) if (i >= 0 && i < genesisLen) out[i] = "deleted";
+	}
+	return out;
 }
-function parseOpeningTagAt(html, i) {
-	if (html.startsWith("<!--", i)) {
-		const close = html.indexOf("-->", i + 4);
-		return close === -1 ? null : { end: close + 3 };
+/**
+* Per genesis boundary `b`, collect tokens this side inserted at that
+* boundary. Keyed by `endInOld` so a Replace at genesis[k..k+1] has its
+* insertion at boundary k+1 (after the deleted token) rather than k
+* (before) — that produces the del-then-ins visual order.
+*
+* For pure Insert ops the old range is empty (endInOld == startInOld),
+* so the key is the same as the semantic between-tokens position.
+*/
+function collectInsertionsKeyedByEnd(d) {
+	const out = /* @__PURE__ */ new Map();
+	for (const op of d.operations) {
+		if (op.action !== 2 && op.action !== 4) continue;
+		const words = d.newDiffWords.slice(op.startInNew, op.endInNew);
+		if (words.length === 0) continue;
+		const key = op.endInOld;
+		const existing = out.get(key) ?? [];
+		existing.push(...words);
+		out.set(key, existing);
+	}
+	return out;
+}
+/**
+* Emit any insertions at boundary `b`. When both authors inserted at
+* the same boundary AND the inserted token sequences are textually
+* identical, the insertion is treated as agreed and emitted unmarked.
+* Otherwise each side's insertion is emitted with author attribution.
+*
+* The CP-then-Me ordering for disagreement is arbitrary but consistent;
+* callers don't depend on it.
+*/
+function emitBoundary(b, cpInsAt, meInsAt, _cpDiffWords, _meDiffWords, segments) {
+	const cpIns = cpInsAt.get(b);
+	const meIns = meInsAt.get(b);
+	const hasCp = !!cpIns && cpIns.length > 0;
+	const hasMe = !!meIns && meIns.length > 0;
+	if (!hasCp && !hasMe) return;
+	if (hasCp && hasMe && tokenArraysEqual(cpIns, meIns)) {
+		appendSegment(segments, { kind: "equal" }, cpIns);
+		return;
+	}
+	if (hasCp) appendSegment(segments, {
+		kind: "ins",
+		author: "cp"
+	}, cpIns);
+	if (hasMe) appendSegment(segments, {
+		kind: "ins",
+		author: "me"
+	}, meIns);
+}
+function tokenArraysEqual(a, b) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+function appendSegment(segments, attr, words) {
+	if (words.length === 0) return;
+	const last = segments[segments.length - 1];
+	if (last && sameAttribution(last.attr, attr)) {
+		last.words.push(...words);
+		return;
 	}
-	if (html.startsWith("<![CDATA[", i)) {
-		const close = html.indexOf("]]>", i + 9);
-		return close === -1 ? null : { end: close + 3 };
+	segments.push({
+		attr,
+		words: [...words]
+	});
+}
+function sameAttribution(a, b) {
+	if (a.kind === "equal" && b.kind === "equal") return true;
+	if (a.kind === "ins" && b.kind === "ins") return a.author === b.author;
+	if (a.kind === "del" && b.kind === "del") return a.author === b.author;
+	return false;
+}
+/**
+* Build the `WrapMetadata` for an attribution. Single source of truth
+* for author-class / data-attr shape so the three emission paths
+* (word-level, table-level full-row/cell, multi-table whole-table
+* pre-wrap) stay consistent. A change here propagates to every author
+* marker in the output.
+*/
+function authorAttribution(author) {
+	return {
+		extraClasses: author,
+		dataAttrs: { author }
+	};
+}
+/**
+* Resolve a segment's attribution into the wrapper-tag, base CSS class,
+* and `WrapMetadata` consumed by `Utils.wrapText` / `insertTag`. The
+* caller is `HtmlDiff.executeThreeWay`'s emission loop.
+*
+* `equal` segments don't go through this — they're emitted unmarked.
+*/
+function segmentEmissionShape(attr) {
+	return {
+		tag: attr.kind,
+		baseClass: attr.kind === "ins" ? "diffins" : "diffdel",
+		metadata: authorAttribution(attr.author)
+	};
+}
+//#endregion
+//#region src/ThreeWayTable.ts
+function preprocessTablesThreeWay(genesis, cpLatest, meCurrent, cellDiff) {
+	const gTables = findTopLevelTables(genesis);
+	const cTables = findTopLevelTables(cpLatest);
+	const mTables = findTopLevelTables(meCurrent);
+	if (gTables.length === 0 && cTables.length === 0 && mTables.length === 0) return null;
+	for (const t of gTables) if (exceedsSizeLimit(t)) return null;
+	for (const t of cTables) if (exceedsSizeLimit(t)) return null;
+	for (const t of mTables) if (exceedsSizeLimit(t)) return null;
+	const placeholderPrefix = makePlaceholderPrefix(genesis, cpLatest, meCurrent);
+	if (positionallyAligned(genesis, cpLatest, meCurrent, gTables, cTables, mTables)) return preprocessAlignedByPosition(genesis, cpLatest, meCurrent, gTables, cTables, mTables, cellDiff, placeholderPrefix);
+	return preprocessByContent(genesis, cpLatest, meCurrent, gTables, cTables, mTables, cellDiff, placeholderPrefix);
+}
+function preprocessAlignedByPosition(genesis, cpLatest, meCurrent, gTables, cTables, mTables, cellDiff, placeholderPrefix) {
+	const pairs = [];
+	for (let i = 0; i < gTables.length; i++) pairs.push({
+		g: gTables[i],
+		c: cTables[i],
+		m: mTables[i],
+		diffed: diffTableThreeWay(genesis, cpLatest, meCurrent, gTables[i], cTables[i], mTables[i], cellDiff)
+	});
+	let modifiedGenesis = genesis;
+	let modifiedCp = cpLatest;
+	let modifiedMe = meCurrent;
+	const placeholderToDiff = /* @__PURE__ */ new Map();
+	for (let i = pairs.length - 1; i >= 0; i--) {
+		const placeholder = `${placeholderPrefix}${i}-->`;
+		placeholderToDiff.set(placeholder, pairs[i].diffed);
+		modifiedGenesis = spliceString(modifiedGenesis, pairs[i].g.tableStart, pairs[i].g.tableEnd, placeholder);
+		modifiedCp = spliceString(modifiedCp, pairs[i].c.tableStart, pairs[i].c.tableEnd, placeholder);
+		modifiedMe = spliceString(modifiedMe, pairs[i].m.tableStart, pairs[i].m.tableEnd, placeholder);
 	}
-	if (html.startsWith("<?", i)) {
-		const close = html.indexOf("?>", i + 2);
-		return close === -1 ? null : { end: close + 2 };
+	return {
+		modifiedGenesis,
+		modifiedCp,
+		modifiedMe,
+		placeholderToDiff
+	};
+}
+/**
+* Multi-table handler. Tables are paired against `genesis` (the spine)
+* via content-LCS on each of cp and me. Placeholders are assigned so
+* each appears only in the inputs that actually contain the underlying
+* table. The word-level merger then attributes them naturally:
+*
+*   - paired in genesis+cp+me   → equal in both diffs → emit recursive 3-way diff
+*   - in cp+me, not in genesis  → both-agree insertion → emit plain
+*   - in cp only                → cp insertion → ins-cp wrapper (Me didn't take it)
+*   - in me only                → me insertion → ins-me wrapper
+*   - in genesis+cp, not me     → me deletion → del-me wrapper
+*   - in genesis+me, not cp     → cp deletion → del-cp wrapper
+*   - in genesis only           → both deleted, settled → silent (placeholder content empty)
+*/
+function preprocessByContent(genesis, cpLatest, meCurrent, gTables, cTables, mTables, cellDiff, placeholderPrefix) {
+	const gKeys = gTables.map((t) => tableKey(genesis, t));
+	const cKeys = cTables.map((t) => tableKey(cpLatest, t));
+	const mKeys = mTables.map((t) => tableKey(meCurrent, t));
+	const alignCp = lcsAlign(gKeys, cKeys);
+	const alignMe = lcsAlign(gKeys, mKeys);
+	const gToCp = new Array(gTables.length).fill(-1);
+	const cpToG = new Array(cTables.length).fill(-1);
+	for (const a of alignCp) if (a.oldIdx !== null && a.newIdx !== null) {
+		gToCp[a.oldIdx] = a.newIdx;
+		cpToG[a.newIdx] = a.oldIdx;
+	}
+	const gToMe = new Array(gTables.length).fill(-1);
+	const meToG = new Array(mTables.length).fill(-1);
+	for (const a of alignMe) if (a.oldIdx !== null && a.newIdx !== null) {
+		gToMe[a.oldIdx] = a.newIdx;
+		meToG[a.newIdx] = a.oldIdx;
+	}
+	let nextId = 0;
+	const placeholderToDiff = /* @__PURE__ */ new Map();
+	const placeholders = {
+		g: new Array(gTables.length).fill(null),
+		c: new Array(cTables.length).fill(null),
+		m: new Array(mTables.length).fill(null)
+	};
+	const allocate = () => `${placeholderPrefix}${nextId++}-->`;
+	const wrapWhole = (tag, author, tableHtml) => Utils_default.wrapText(tableHtml, tag, `diff${tag}`, authorAttribution(author));
+	for (let gIdx = 0; gIdx < gTables.length; gIdx++) {
+		const cIdx = gToCp[gIdx];
+		const mIdx = gToMe[gIdx];
+		if (cIdx === -1 || mIdx === -1) continue;
+		const placeholder = allocate();
+		placeholderToDiff.set(placeholder, diffTableThreeWay(genesis, cpLatest, meCurrent, gTables[gIdx], cTables[cIdx], mTables[mIdx], cellDiff));
+		placeholders.g[gIdx] = placeholder;
+		placeholders.c[cIdx] = placeholder;
+		placeholders.m[mIdx] = placeholder;
+	}
+	for (let gIdx = 0; gIdx < gTables.length; gIdx++) {
+		if (placeholders.g[gIdx] !== null) continue;
+		const cIdx = gToCp[gIdx];
+		if (cIdx === -1) continue;
+		const placeholder = allocate();
+		placeholderToDiff.set(placeholder, wrapWhole("del", "me", genesis.slice(gTables[gIdx].tableStart, gTables[gIdx].tableEnd)));
+		placeholders.g[gIdx] = placeholder;
+		placeholders.c[cIdx] = placeholder;
+	}
+	for (let gIdx = 0; gIdx < gTables.length; gIdx++) {
+		if (placeholders.g[gIdx] !== null) continue;
+		const mIdx = gToMe[gIdx];
+		if (mIdx === -1) continue;
+		const placeholder = allocate();
+		placeholderToDiff.set(placeholder, wrapWhole("del", "cp", genesis.slice(gTables[gIdx].tableStart, gTables[gIdx].tableEnd)));
+		placeholders.g[gIdx] = placeholder;
+		placeholders.m[mIdx] = placeholder;
+	}
+	for (let gIdx = 0; gIdx < gTables.length; gIdx++) {
+		if (placeholders.g[gIdx] !== null) continue;
+		const placeholder = allocate();
+		placeholderToDiff.set(placeholder, "");
+		placeholders.g[gIdx] = placeholder;
+	}
+	for (let cIdx = 0; cIdx < cTables.length; cIdx++) {
+		if (placeholders.c[cIdx] !== null) continue;
+		const cText = cKeys[cIdx];
+		let mIdx = -1;
+		for (let candidate = 0; candidate < mTables.length; candidate++) {
+			if (placeholders.m[candidate] !== null) continue;
+			if (meToG[candidate] !== -1) continue;
+			if (mKeys[candidate] === cText) {
+				mIdx = candidate;
+				break;
+			}
+		}
+		if (mIdx === -1) continue;
+		const placeholder = allocate();
+		placeholderToDiff.set(placeholder, cpLatest.slice(cTables[cIdx].tableStart, cTables[cIdx].tableEnd));
+		placeholders.c[cIdx] = placeholder;
+		placeholders.m[mIdx] = placeholder;
+	}
+	for (let cIdx = 0; cIdx < cTables.length; cIdx++) {
+		if (placeholders.c[cIdx] !== null) continue;
+		const placeholder = allocate();
+		placeholderToDiff.set(placeholder, wrapWhole("ins", "cp", cpLatest.slice(cTables[cIdx].tableStart, cTables[cIdx].tableEnd)));
+		placeholders.c[cIdx] = placeholder;
+	}
+	for (let mIdx = 0; mIdx < mTables.length; mIdx++) {
+		if (placeholders.m[mIdx] !== null) continue;
+		const placeholder = allocate();
+		placeholderToDiff.set(placeholder, wrapWhole("ins", "me", meCurrent.slice(mTables[mIdx].tableStart, mTables[mIdx].tableEnd)));
+		placeholders.m[mIdx] = placeholder;
+	}
+	let modifiedGenesis = genesis;
+	for (let i = gTables.length - 1; i >= 0; i--) {
+		const p = placeholders.g[i];
+		if (p === null) continue;
+		modifiedGenesis = spliceString(modifiedGenesis, gTables[i].tableStart, gTables[i].tableEnd, p);
+	}
+	let modifiedCp = cpLatest;
+	for (let i = cTables.length - 1; i >= 0; i--) {
+		const p = placeholders.c[i];
+		if (p === null) continue;
+		modifiedCp = spliceString(modifiedCp, cTables[i].tableStart, cTables[i].tableEnd, p);
+	}
+	let modifiedMe = meCurrent;
+	for (let i = mTables.length - 1; i >= 0; i--) {
+		const p = placeholders.m[i];
+		if (p === null) continue;
+		modifiedMe = spliceString(modifiedMe, mTables[i].tableStart, mTables[i].tableEnd, p);
 	}
-	let j = i + 1;
-	let quote = null;
-	while (j < html.length) {
-		const ch = html[j];
-		if (quote) {
-			if (ch === quote) quote = null;
-		} else if (ch === "\"" || ch === "'") quote = ch;
-		else if (ch === ">") return { end: j + 1 };
-		j++;
+	return {
+		modifiedGenesis,
+		modifiedCp,
+		modifiedMe,
+		placeholderToDiff
+	};
+}
+const POSITIONAL_PAIR_SIMILARITY_THRESHOLD = .5;
+function positionallyAligned(genesis, cpLatest, meCurrent, gTables, cTables, mTables) {
+	if (gTables.length !== cTables.length || cTables.length !== mTables.length) return false;
+	for (let i = 0; i < gTables.length; i++) {
+		const kG = tableKey(genesis, gTables[i]);
+		const kC = tableKey(cpLatest, cTables[i]);
+		const kM = tableKey(meCurrent, mTables[i]);
+		if (textSimilarity(kG, kC) < POSITIONAL_PAIR_SIMILARITY_THRESHOLD) return false;
+		if (textSimilarity(kG, kM) < POSITIONAL_PAIR_SIMILARITY_THRESHOLD) return false;
 	}
-	return null;
+	return true;
+}
+function tableKey(html, table) {
+	return html.slice(table.tableStart, table.tableEnd).replace(/\s+/g, " ").trim();
+}
+function diffTableThreeWay(genesis, cpLatest, meCurrent, tG, tC, tM, cellDiff) {
+	if (sameDimensions(tG, tC) && sameDimensions(tC, tM)) return diffTablePositional(genesis, cpLatest, meCurrent, tG, tC, tM, cellDiff);
+	return diffTableStructural(genesis, cpLatest, meCurrent, tG, tC, tM, cellDiff);
+}
+function diffTablePositional(genesis, cpLatest, meCurrent, tG, tC, tM, cellDiff) {
+	const out = [];
+	let cursor = tG.tableStart;
+	for (let r = 0; r < tG.rows.length; r++) {
+		const rG = tG.rows[r];
+		const rC = tC.rows[r];
+		const rM = tM.rows[r];
+		for (let c = 0; c < rG.cells.length; c++) {
+			const cG = rG.cells[c];
+			const cC = rC.cells[c];
+			const cM = rM.cells[c];
+			out.push(genesis.slice(cursor, cG.contentStart));
+			out.push(cellDiff(genesis.slice(cG.contentStart, cG.contentEnd), cpLatest.slice(cC.contentStart, cC.contentEnd), meCurrent.slice(cM.contentStart, cM.contentEnd)));
+			cursor = cG.contentEnd;
+		}
+	}
+	out.push(genesis.slice(cursor, tG.tableEnd));
+	return out.join("");
 }
 /**
-* Returns the index just past the matching `</tagName>`, accounting for
-* nested tags of the same name. Returns -1 if no match before `limit`.
+* Row-level genesis-spine merge for tables with diverging row/cell
+* counts.
+*
+* 1. Align cp rows to genesis rows (alignCp), me rows to genesis rows
+*    (alignMe), each via row-LCS over rowKeys.
+* 2. Per genesis row: cpFate (kept / deleted), meFate (kept / deleted).
+*    Both kept → recurse cell diff (with structural-change cell handling
+*    falling back to me-attribution Replace per the documented
+*    limitation). One kept, other deleted → emit author-attributed full
+*    row. Both deleted → silent.
+* 3. Off-spine rows: cp-only inserted rows + me-only inserted rows.
+*    Check for content agreement at the same boundary; agreed
+*    insertions emit plain.
 */
-function findMatchingClosingTag(html, from, tagName, limit = html.length) {
-	let depth = 1;
-	let i = from;
-	while (i < limit) if (matchesTagAt(html, i, tagName)) {
-		const opening = parseOpeningTagAt(html, i);
-		if (!opening) {
-			i++;
-			continue;
+function diffTableStructural(genesis, cpLatest, meCurrent, tG, tC, tM, cellDiff) {
+	const gKeys = tG.rows.map((r) => rowKey(genesis, r));
+	const cKeys = tC.rows.map((r) => rowKey(cpLatest, r));
+	const mKeys = tM.rows.map((r) => rowKey(meCurrent, r));
+	const alignCp = lcsAlign(gKeys, cKeys);
+	const alignMe = lcsAlign(gKeys, mKeys);
+	const gToCp = new Array(tG.rows.length).fill(-1);
+	for (const a of alignCp) if (a.oldIdx !== null && a.newIdx !== null) gToCp[a.oldIdx] = a.newIdx;
+	const gToMe = new Array(tG.rows.length).fill(-1);
+	for (const a of alignMe) if (a.oldIdx !== null && a.newIdx !== null) gToMe[a.oldIdx] = a.newIdx;
+	const cpInsAt = collectInsertedRowsAtBoundary(alignCp, tG.rows.length);
+	const meInsAt = collectInsertedRowsAtBoundary(alignMe, tG.rows.length);
+	const out = [];
+	out.push(tableHeaderSlice(genesis, tG));
+	const emitBoundaryInsertions = (b) => {
+		const cIdxs = cpInsAt.get(b) ?? [];
+		const mIdxs = meInsAt.get(b) ?? [];
+		if (cIdxs.length === 0 && mIdxs.length === 0) return;
+		const remainingMe = new Set(mIdxs);
+		for (const cIdx of cIdxs) {
+			const cText = cKeys[cIdx];
+			let agreedMeIdx;
+			for (const mIdx of remainingMe) if (mKeys[mIdx] === cText) {
+				agreedMeIdx = mIdx;
+				break;
+			}
+			if (agreedMeIdx !== void 0) {
+				remainingMe.delete(agreedMeIdx);
+				out.push(cpLatest.slice(tC.rows[cIdx].rowStart, tC.rows[cIdx].rowEnd));
+			} else out.push(emitFullRowAttributed(cpLatest, tC.rows[cIdx], "ins", "cp"));
 		}
-		if (!html.slice(i, opening.end).endsWith("/>")) depth++;
-		i = opening.end;
-	} else if (matchesClosingTagAt(html, i, tagName)) {
-		depth--;
-		const closingEnd = parseOpeningTagAt(html, i)?.end ?? i + `</${tagName}>`.length;
-		if (depth === 0) return closingEnd;
-		i = closingEnd;
-	} else i++;
-	return -1;
+		for (const mIdx of remainingMe) out.push(emitFullRowAttributed(meCurrent, tM.rows[mIdx], "ins", "me"));
+	};
+	for (let g = 0; g < tG.rows.length; g++) {
+		emitBoundaryInsertions(g);
+		const cIdx = gToCp[g];
+		const mIdx = gToMe[g];
+		const cpDel = cIdx === -1;
+		const meDel = mIdx === -1;
+		if (!cpDel && !meDel) out.push(emitPreservedRow(genesis, cpLatest, meCurrent, tG.rows[g], tC.rows[cIdx], tM.rows[mIdx], cellDiff));
+		else if (cpDel && meDel) {} else if (cpDel) out.push(emitFullRowAttributed(meCurrent, tM.rows[mIdx], "del", "cp"));
+		else out.push(emitFullRowAttributed(cpLatest, tC.rows[cIdx], "del", "me"));
+	}
+	emitBoundaryInsertions(tG.rows.length);
+	out.push(tableFooterSlice(genesis, tG));
+	return out.join("");
+}
+function emitPreservedRow(genesis, cpLatest, meCurrent, rG, rC, rM, cellDiff) {
+	if (rG.cells.length === rC.cells.length && rC.cells.length === rM.cells.length) {
+		const out = [];
+		let cursor = rG.rowStart;
+		for (let c = 0; c < rG.cells.length; c++) {
+			const cG = rG.cells[c];
+			const cC = rC.cells[c];
+			const cM = rM.cells[c];
+			out.push(genesis.slice(cursor, cG.contentStart));
+			out.push(cellDiff(genesis.slice(cG.contentStart, cG.contentEnd), cpLatest.slice(cC.contentStart, cC.contentEnd), meCurrent.slice(cM.contentStart, cM.contentEnd)));
+			cursor = cG.contentEnd;
+		}
+		out.push(genesis.slice(cursor, rG.rowEnd));
+		return out.join("");
+	}
+	return emitFullRowAttributed(genesis, rG, "del", "me") + emitFullRowAttributed(meCurrent, rM, "ins", "me");
+}
+/**
+* Returns map "genesis-row-boundary → list of new-side row indices
+* inserted at that boundary". Mirrors the word-level boundary collection
+* but at the row scale.
+*/
+function collectInsertedRowsAtBoundary(align, genesisRowCount) {
+	const out = /* @__PURE__ */ new Map();
+	let nextGenesisBoundary = genesisRowCount;
+	const pending = [];
+	for (let i = align.length - 1; i >= 0; i--) {
+		const a = align[i];
+		if (a.oldIdx !== null) {
+			if (pending.length > 0) {
+				const existing = out.get(nextGenesisBoundary) ?? [];
+				existing.unshift(...pending.toReversed());
+				out.set(nextGenesisBoundary, existing);
+				pending.length = 0;
+			}
+			nextGenesisBoundary = a.oldIdx;
+		} else if (a.newIdx !== null) pending.push(a.newIdx);
+	}
+	if (pending.length > 0) {
+		const existing = out.get(nextGenesisBoundary) ?? [];
+		existing.unshift(...pending.toReversed());
+		out.set(nextGenesisBoundary, existing);
+	}
+	return out;
+}
+function tableHeaderSlice(html, table) {
+	const firstRow = table.rows[0];
+	if (!firstRow) return html.slice(table.tableStart, table.tableEnd - 8);
+	return html.slice(table.tableStart, firstRow.rowStart);
+}
+function tableFooterSlice(html, table) {
+	const lastRow = table.rows[table.rows.length - 1];
+	if (!lastRow) return "</table>";
+	return html.slice(lastRow.rowEnd, table.tableEnd);
+}
+/**
+* Emit a row fully attributed to one author. Wraps `<tr>` and each
+* `<td>` with the author's diffins/diffdel class and `data-author`
+* attribute; wraps cell content with an inner `<ins>`/`<del>` matching
+* the word-level emission shape.
+*/
+function emitFullRowAttributed(html, row, kind, author) {
+	const trOpening = parseOpeningTagAt(html, row.rowStart);
+	if (!trOpening) return html.slice(row.rowStart, row.rowEnd);
+	const out = [injectAuthorAttribution(html.slice(row.rowStart, trOpening.end), kind, author)];
+	let cursor = trOpening.end;
+	for (const cell of row.cells) {
+		out.push(html.slice(cursor, cell.cellStart));
+		out.push(emitFullCellAttributed(html, cell, kind, author));
+		cursor = cell.cellEnd;
+	}
+	out.push(html.slice(cursor, row.rowEnd));
+	return out.join("");
+}
+function emitFullCellAttributed(html, cell, kind, author) {
+	const tdOpening = parseOpeningTagAt(html, cell.cellStart);
+	if (!tdOpening) return html.slice(cell.cellStart, cell.cellEnd);
+	const tdWithAttrs = injectAuthorAttribution(html.slice(cell.cellStart, tdOpening.end), kind, author);
+	const innerContent = html.slice(cell.contentStart, cell.contentEnd);
+	const innerWrapped = innerContent.trim().length === 0 ? innerContent : Utils_default.wrapText(innerContent, kind, `diff${kind}`, authorAttribution(author));
+	const closing = html.slice(cell.contentEnd, cell.cellEnd);
+	return tdWithAttrs + innerWrapped + closing;
+}
+function injectAuthorAttribution(openingTag, kind, author) {
+	const meta = authorAttribution(author);
+	return injectDataAttrs(injectClass(openingTag, `diff${kind} ${meta.extraClasses}`), meta.dataAttrs ?? {});
+}
+function injectDataAttrs(openingTag, dataAttrs) {
+	const keys = Object.keys(dataAttrs);
+	if (keys.length === 0) return openingTag;
+	const attrs = keys.map((k) => ` data-${k}='${dataAttrs[k]}'`).join("");
+	if (openingTag.endsWith("/>")) return `${openingTag.slice(0, -2)}${attrs}/>`;
+	return `${openingTag.slice(0, -1)}${attrs}>`;
 }
 //#endregion
 //#region src/WordSplitter.ts
@@ -1458,10 +2030,20 @@ var HtmlDiff = class HtmlDiff {
 	* pathological input.
 	*/
 	static MaxTablePreprocessDepth = 8;
+	/**
+	* Mirror cap for the three-way path. The 2-way `MaxTablePreprocessDepth`
+	* guards the recursion inside `executeWithContext`; the 3-way path has
+	* its own recursion (`executeThreeWay` → `preprocessTablesThreeWay` →
+	* `cellDiff` → `executeThreeWay`) which needs its own guard. Once the
+	* cap is reached, `executeThreeWay` skips table preprocessing and
+	* falls back to the word-level merge — same bail-out semantics as the
+	* 2-way path.
+	*/
+	static MaxThreeWayDepth = 8;
 	content = [];
 	newText;
 	oldText;
-	tablePreprocessDepth;
+	tablePreprocessDepth = 0;
 	specialTagDiffStack = [];
 	newWords = [];
 	oldWords = [];
@@ -1524,17 +2106,172 @@ var HtmlDiff = class HtmlDiff {
 	* Initializes a new instance of the class.
 	* @param oldText The old text.
 	* @param newText The new text.
-	* @param tablePreprocessDepth Internal: nested-call depth for table
-	*   preprocessing. Callers should leave at default (0); the recursive
-	*   `diffCell` callback in TableDiff bumps it.
 	*/
-	constructor(oldText, newText, tablePreprocessDepth = 0) {
+	constructor(oldText, newText) {
 		this.oldText = oldText;
 		this.newText = newText;
-		this.tablePreprocessDepth = tablePreprocessDepth;
 	}
-	static execute(oldText, newText, tablePreprocessDepth = 0) {
-		return new HtmlDiff(oldText, newText, tablePreprocessDepth).build();
+	static execute(oldText, newText) {
+		return new HtmlDiff(oldText, newText).build();
+	}
+	/**
+	* Analyse a two-way diff and return its raw building blocks: the word
+	* arrays the diff ran against, the operations produced, the original
+	* (pre-projection) word arrays, and the mappings from diff-index back
+	* to original-word index when structural projection is active.
+	* Consumed by `executeThreeWay` so it can compose two diffs by walking
+	* their Operation streams.
+	*
+	* The caller is expected to coordinate `useProjections` symmetrically
+	* across composed analyses — if V1↔V2 projects but V2↔V3 doesn't,
+	* V2's "new" array in the first analysis won't equal V2's "old" array
+	* in the second. `evaluateProjectionApplicability` exposes the same
+	* heuristic `build()` uses internally, so the orchestrator can compute
+	* a single decision and pass it into every `analyze` call.
+	*
+	* Table preprocessing is skipped here. Placeholders mutate the input
+	* in ways that don't compose across two independent analyses; the
+	* 3-way orchestrator handles tables explicitly before calling analyze.
+	*/
+	static analyze(oldText, newText, options = {}) {
+		const inner = new HtmlDiff(oldText, newText);
+		inner.tablePreprocessDepth = HtmlDiff.MaxTablePreprocessDepth;
+		if (options.blockExpressions) for (const expr of options.blockExpressions) inner.addBlockExpression(expr);
+		if (options.repeatingWordsAccuracy !== void 0) inner.repeatingWordsAccuracy = options.repeatingWordsAccuracy;
+		if (options.orphanMatchThreshold !== void 0) inner.orphanMatchThreshold = options.orphanMatchThreshold;
+		if (options.ignoreWhitespaceDifferences !== void 0) inner.ignoreWhitespaceDifferences = options.ignoreWhitespaceDifferences;
+		inner.splitInputsToWords();
+		if (options.useProjections === void 0) inner.buildContentProjections();
+		else if (options.useProjections) {
+			const oldProj = HtmlDiff.createContentProjection(inner.oldWords);
+			const newProj = HtmlDiff.createContentProjection(inner.newWords);
+			if (oldProj.contentWords.length > 0 && newProj.contentWords.length > 0) {
+				inner.oldContentWords = oldProj.contentWords;
+				inner.oldContentToOriginal = oldProj.contentToOriginal;
+				inner.newContentWords = newProj.contentWords;
+				inner.newContentToOriginal = newProj.contentToOriginal;
+			}
+		}
+		const wordsForDiffOld = inner.oldContentWords ?? inner.oldWords;
+		const wordsForDiffNew = inner.newContentWords ?? inner.newWords;
+		inner.matchGranularity = Math.min(HtmlDiff.MatchGranularityMaximum, Math.min(wordsForDiffOld.length, wordsForDiffNew.length));
+		return {
+			oldDiffWords: wordsForDiffOld,
+			newDiffWords: wordsForDiffNew,
+			operations: inner.operations(),
+			oldOriginalWords: inner.oldWords,
+			newOriginalWords: inner.newWords,
+			oldContentToOriginal: inner.oldContentToOriginal,
+			newContentToOriginal: inner.newContentToOriginal
+		};
+	}
+	/**
+	* Whether content-projection (structural-tag normalisation) would
+	* apply to this pair of inputs under `build()`'s default heuristic.
+	* Exposed so composers of multiple analyses can compute a symmetric
+	* decision before calling `analyze` — see `analyze`'s docstring for
+	* why symmetry matters.
+	*/
+	static evaluateProjectionApplicability(oldText, newText) {
+		const oldWords = WordSplitter.convertHtmlToListOfWords(oldText, []);
+		const newWords = WordSplitter.convertHtmlToListOfWords(newText, []);
+		if (!HtmlDiff.hasStructuralDifferences(oldWords, newWords)) return false;
+		const oldProj = HtmlDiff.createContentProjection(oldWords);
+		const newProj = HtmlDiff.createContentProjection(newWords);
+		return HtmlDiff.shouldUseContentProjections(oldWords, newWords, oldProj, newProj);
+	}
+	/**
+	* Three-way HTML diff. Given V1 (the version Me last sent), V2 (the
+	* version CP sent back), and V3 (Me's current draft), produces a
+	* single attributed HTML output where CP's and Me's changes are
+	* distinguished by `data-author` ('cp' or 'me') and matching
+	* `class='diffins cp'` / `class='diffdel me'` etc. The "Me rejected
+	* CP's proposal" case (Me deleted text CP had inserted) gets a
+	* dedicated marker: `data-rejects='cp'` plus `class='... rejects-cp'`.
+	*
+	* Coordinates the symmetric-projection decision (D1) across both
+	* internal `analyze` calls so V2 tokenises identically on each side
+	* of the spine. When `useProjections` is left undefined, the decision
+	* is the conjunction of both pair-wise heuristics — project iff both
+	* pairs would project on their own. Pass an explicit boolean to
+	* override.
+	*/
+	/**
+	* Three-way HTML diff against a shared genesis. Produces attributed
+	* HTML that distinguishes CP's accumulated changes (genesis → cpLatest)
+	* from Me's accumulated changes (genesis → meCurrent). Use this for
+	* blackline UX where the negotiation has gone through multiple turns
+	* and the reader wants to see "who proposed what" across the whole
+	* history, not just the most recent round.
+	*
+	* When both parties happen to have made the same change (e.g. CP
+	* proposed a wording change in turn N, Me adopted it in turn N+1),
+	* the change reads as "settled" and is emitted unmarked — only
+	* disagreements and pending proposals carry author attribution.
+	*
+	* @param genesis    the shared common ancestor (per-user — the FE
+	*                   picks between V1.0 and /preview/initialAnswers
+	*                   based on `prefillReceiverAnswers`)
+	* @param cpLatest   the counterparty's current published version
+	* @param meCurrent  Me's current draft (the document on screen)
+	*/
+	static executeThreeWay(genesis, cpLatest, meCurrent, options = {}) {
+		return HtmlDiff.executeThreeWayWithDepth(genesis, cpLatest, meCurrent, options, 0);
+	}
+	static executeThreeWayWithDepth(genesis, cpLatest, meCurrent, options, depth) {
+		const tablePreprocess = depth < HtmlDiff.MaxThreeWayDepth ? preprocessTablesThreeWay(genesis, cpLatest, meCurrent, (g, c, m) => HtmlDiff.executeThreeWayWithDepth(g, c, m, options, depth + 1)) : null;
+		const inGenesis = tablePreprocess?.modifiedGenesis ?? genesis;
+		const inCp = tablePreprocess?.modifiedCp ?? cpLatest;
+		const inMe = tablePreprocess?.modifiedMe ?? meCurrent;
+		const analyzeOpts = {
+			useProjections: options.useProjections ?? (HtmlDiff.evaluateProjectionApplicability(inGenesis, inCp) && HtmlDiff.evaluateProjectionApplicability(inGenesis, inMe)),
+			blockExpressions: options.blockExpressions,
+			repeatingWordsAccuracy: options.repeatingWordsAccuracy,
+			orphanMatchThreshold: options.orphanMatchThreshold,
+			ignoreWhitespaceDifferences: options.ignoreWhitespaceDifferences
+		};
+		const dCp = HtmlDiff.analyze(inGenesis, inCp, analyzeOpts);
+		const dMe = HtmlDiff.analyze(inGenesis, inMe, analyzeOpts);
+		if (dCp.oldDiffWords.length !== dMe.oldDiffWords.length) throw new Error(`HtmlDiff.executeThreeWay: genesis tokenisation diverged across pair-wise analyses (${dCp.oldDiffWords.length} vs ${dMe.oldDiffWords.length}). This indicates the symmetric-projection coordination has a bug.`);
+		const segments = buildSegments(dCp, dMe);
+		const merged = HtmlDiff.emitSegments(segments);
+		return tablePreprocess ? restoreTablePlaceholders(merged, tablePreprocess.placeholderToDiff) : merged;
+	}
+	/**
+	* Drives a fresh `HtmlDiff` instance through `insertTag` for ins/del
+	* segments and pushes equal segments straight to its `content`
+	* buffer. Reusing the instance keeps the formatting-tag stack
+	* (`specialTagDiffStack`) coherent across segments — a `<strong>`
+	* opened in one segment and closed in another stays balanced.
+	*/
+	static emitSegments(segments) {
+		const emitter = new HtmlDiff("", "");
+		for (const seg of segments) {
+			if (seg.attr.kind === "equal") {
+				emitter.content.push(seg.words.join(""));
+				continue;
+			}
+			const { tag, baseClass, metadata } = segmentEmissionShape(seg.attr);
+			emitter.insertTag(tag, baseClass, [...seg.words], metadata);
+		}
+		if (emitter.specialTagDiffStack.length > 0) throw new Error(`HtmlDiff.executeThreeWay: emission left ${emitter.specialTagDiffStack.length} unclosed formatting tag(s) on the stack — input may have unbalanced <strong>/<em>/etc. or there is a bug in segment emission.`);
+		return emitter.content.join("");
+	}
+	/**
+	* Internal entry point used by the table-cell recursion. Constructs an
+	* inner `HtmlDiff`, applies the caller's settings, and bumps the
+	* recursion depth — keeping the public constructor signature clean
+	* while still threading the configuration that's required for cell-
+	* level output to match the top-level call's behaviour.
+	*/
+	static executeWithContext(oldText, newText, ctx) {
+		const inner = new HtmlDiff(oldText, newText);
+		inner.tablePreprocessDepth = ctx.depth;
+		for (const expr of ctx.blockExpressions) inner.addBlockExpression(expr);
+		inner.repeatingWordsAccuracy = ctx.repeatingWordsAccuracy;
+		inner.orphanMatchThreshold = ctx.orphanMatchThreshold;
+		inner.ignoreWhitespaceDifferences = ctx.ignoreWhitespaceDifferences;
+		return inner.build();
 	}
 	/**
 	* Builds the HTML diff output
@@ -1542,18 +2279,17 @@ var HtmlDiff = class HtmlDiff {
 	*/
 	build() {
 		if (this.oldText === this.newText) return this.newText;
-		const blockExpressions = this.blockExpressions;
-		const repeatingWordsAccuracy = this.repeatingWordsAccuracy;
-		const orphanMatchThreshold = this.orphanMatchThreshold;
-		const ignoreWhitespaceDifferences = this.ignoreWhitespaceDifferences;
-		const tablePreprocess = this.tablePreprocessDepth >= HtmlDiff.MaxTablePreprocessDepth ? null : preprocessTables(this.oldText, this.newText, (oldCell, newCell) => {
-			const inner = new HtmlDiff(oldCell, newCell, this.tablePreprocessDepth + 1);
-			for (const expr of blockExpressions) inner.addBlockExpression(expr);
-			inner.repeatingWordsAccuracy = repeatingWordsAccuracy;
-			inner.orphanMatchThreshold = orphanMatchThreshold;
-			inner.ignoreWhitespaceDifferences = ignoreWhitespaceDifferences;
-			return inner.build();
-		});
+		let tablePreprocess = null;
+		if (this.tablePreprocessDepth < HtmlDiff.MaxTablePreprocessDepth) {
+			const ctx = {
+				depth: this.tablePreprocessDepth + 1,
+				blockExpressions: this.blockExpressions,
+				repeatingWordsAccuracy: this.repeatingWordsAccuracy,
+				orphanMatchThreshold: this.orphanMatchThreshold,
+				ignoreWhitespaceDifferences: this.ignoreWhitespaceDifferences
+			};
+			tablePreprocess = preprocessTables(this.oldText, this.newText, (oldCell, newCell) => HtmlDiff.executeWithContext(oldCell, newCell, ctx));
+		}
 		if (tablePreprocess) {
 			this.oldText = tablePreprocess.modifiedOld;
 			this.newText = tablePreprocess.modifiedNew;
@@ -1763,12 +2499,12 @@ var HtmlDiff = class HtmlDiff {
 	* @param words
 	* @private
 	*/
-	insertTag(tag, cssClass, words) {
+	insertTag(tag, cssClass, words, metadata) {
 		while (true) {
 			if (words.length === 0) break;
 			const allWordsUntilFirstTag = this.extractConsecutiveWords(words, (x) => !Utils_default.isTag(x));
 			if (allWordsUntilFirstTag.length > 0) {
-				const text = Utils_default.wrapText(allWordsUntilFirstTag.join(""), tag, cssClass);
+				const text = Utils_default.wrapText(allWordsUntilFirstTag.join(""), tag, cssClass, metadata);
 				this.content.push(text);
 			}
 			if (words.length === 0) break;
@@ -1781,7 +2517,7 @@ var HtmlDiff = class HtmlDiff {
 				for (const word of words) if (Utils_default.isTag(word)) tagNames.add(Utils_default.getTagName(word));
 				const styledTagNames = Array.from(tagNames).join(" ");
 				this.specialTagDiffStack.push(words[0]);
-				specialCaseTagInjection = `<ins class='mod ${styledTagNames}'>`;
+				specialCaseTagInjection = `<ins${Utils_default.composeTagAttributes(`mod ${styledTagNames}`, metadata ?? {})}>`;
 				if (tag === HtmlDiff.DelTag) {
 					words.shift();
 					while (words.length > 0 && HtmlDiff.SpecialCaseOpeningTagRegex.test(words[0])) words.shift();
@@ -1807,7 +2543,7 @@ var HtmlDiff = class HtmlDiff {
 			if (specialCaseTagInjectionIsBefore) this.content.push(specialCaseTagInjection + this.extractConsecutiveWords(words, isTagForExtraction).join(""));
 			else this.content.push(this.extractConsecutiveWords(words, isTagForExtraction).join("") + specialCaseTagInjection);
 			if (words.length === 0) continue;
-			this.insertTag(tag, cssClass, words);
+			this.insertTag(tag, cssClass, words, metadata);
 			break;
 		}
 	}