@createiq/htmldiff 1.1.0 → 1.2.0-beta.0

package/dist/HtmlDiff.cjs

@@ -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,
@@ -202,9 +215,423 @@ var Operation = class {
 	}
 };
 //#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);
@@ -397,102 +829,36 @@ function diffPositionalTable(oldHtml, newHtml, oldTable, newTable, diffCell) {
 		for (let c = 0; c < newRow.cells.length; c++) {
 			const oldCell = oldRow.cells[c];
 			const newCell = newRow.cells[c];
-			out.push(newHtml.slice(cursor, newCell.contentStart));
-			out.push(diffCell(oldHtml.slice(oldCell.contentStart, oldCell.contentEnd), newHtml.slice(newCell.contentStart, newCell.contentEnd)));
-			cursor = newCell.contentEnd;
-		}
-	}
-	out.push(newHtml.slice(cursor, newTable.tableEnd));
-	return out.join("");
-}
-/**
-* Mismatched-dimensions path: row-level LCS to identify added/deleted rows,
-* then per preserved row a cell-level LCS to identify added/deleted cells.
-* Reconstructs the table from scratch — there's no "single new structure"
-* to walk verbatim, since we're stitching together kept rows from both
-* sides.
-*/
-function diffStructurallyAlignedTable(oldHtml, newHtml, oldTable, newTable, diffCell) {
-	const alignment = orderAlignmentForEmission(pairSimilarUnmatchedRows(lcsAlign(oldTable.rows.map((row) => rowKey(oldHtml, row)), newTable.rows.map((row) => rowKey(newHtml, row))), oldTable, newTable, oldHtml, newHtml));
-	if (newTable.rows.length === 0) return rebuildStructurallyAlignedTable(oldHtml, newHtml, oldTable, newTable, alignment);
-	const out = [];
-	out.push(newHtml.slice(newTable.tableStart, newTable.rows[0].rowStart));
-	let cursor = newTable.rows[0].rowStart;
-	for (const align of alignment) if (align.newIdx !== null) {
-		const newRow = newTable.rows[align.newIdx];
-		out.push(newHtml.slice(cursor, newRow.rowStart));
-		if (align.oldIdx !== null) out.push(diffPreservedRow(oldHtml, newHtml, oldTable.rows[align.oldIdx], newRow, diffCell));
-		else out.push(emitFullRow(newHtml, newRow, "ins"));
-		cursor = newRow.rowEnd;
-	} else if (align.oldIdx !== null) out.push(emitFullRow(oldHtml, oldTable.rows[align.oldIdx], "del"));
-	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;
+			out.push(newHtml.slice(cursor, newCell.contentStart));
+			out.push(diffCell(oldHtml.slice(oldCell.contentStart, oldCell.contentEnd), newHtml.slice(newCell.contentStart, newCell.contentEnd)));
+			cursor = newCell.contentEnd;
 		}
-		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);
+	out.push(newHtml.slice(cursor, newTable.tableEnd));
+	return out.join("");
+}
+/**
+* Mismatched-dimensions path: row-level LCS to identify added/deleted rows,
+* then per preserved row a cell-level LCS to identify added/deleted cells.
+* Reconstructs the table from scratch — there's no "single new structure"
+* to walk verbatim, since we're stitching together kept rows from both
+* sides.
+*/
+function diffStructurallyAlignedTable(oldHtml, newHtml, oldTable, newTable, diffCell) {
+	const alignment = orderAlignmentForEmission(pairSimilarUnmatchedRows(lcsAlign(oldTable.rows.map((row) => rowKey(oldHtml, row)), newTable.rows.map((row) => rowKey(newHtml, row))), oldTable, newTable, oldHtml, newHtml));
+	if (newTable.rows.length === 0) return rebuildStructurallyAlignedTable(oldHtml, newHtml, oldTable, newTable, alignment);
+	const out = [];
+	out.push(newHtml.slice(newTable.tableStart, newTable.rows[0].rowStart));
+	let cursor = newTable.rows[0].rowStart;
+	for (const align of alignment) if (align.newIdx !== null) {
+		const newRow = newTable.rows[align.newIdx];
+		out.push(newHtml.slice(cursor, newRow.rowStart));
+		if (align.oldIdx !== null) out.push(diffPreservedRow(oldHtml, newHtml, oldTable.rows[align.oldIdx], newRow, diffCell));
+		else out.push(emitFullRow(newHtml, newRow, "ins"));
+		cursor = newRow.rowEnd;
+	} else if (align.oldIdx !== null) out.push(emitFullRow(oldHtml, oldTable.rows[align.oldIdx], "del"));
+	out.push(newHtml.slice(cursor, newTable.tableEnd));
+	return out.join("");
 }
 function rebuildStructurallyAlignedTable(oldHtml, newHtml, oldTable, newTable, alignment) {
 	const out = [];
@@ -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
@@ -800,262 +1117,53 @@ function wrapInlineTextRuns(content, kind) {
 	return out.join("");
 }
 function emitDiffedCell(oldHtml, newHtml, oldCell, newCell, diffCell) {
-	const tdOpening = parseOpeningTagAt(newHtml, newCell.cellStart);
-	if (!tdOpening) return newHtml.slice(newCell.cellStart, newCell.cellEnd);
-	const tdOpenTag = newHtml.slice(newCell.cellStart, tdOpening.end);
-	const content = diffCell(oldHtml.slice(oldCell.contentStart, oldCell.contentEnd), newHtml.slice(newCell.contentStart, newCell.contentEnd));
-	const closing = newHtml.slice(newCell.contentEnd, newCell.cellEnd);
-	return tdOpenTag + content + closing;
-}
-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)}`;
+	const tdOpening = parseOpeningTagAt(newHtml, newCell.cellStart);
+	if (!tdOpening) return newHtml.slice(newCell.cellStart, newCell.cellEnd);
+	const tdOpenTag = newHtml.slice(newCell.cellStart, tdOpening.end);
+	const content = diffCell(oldHtml.slice(oldCell.contentStart, oldCell.contentEnd), newHtml.slice(newCell.contentStart, newCell.contentEnd));
+	const closing = newHtml.slice(newCell.contentEnd, newCell.cellEnd);
+	return tdOpenTag + content + closing;
+}
+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;
 /**
-* 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,574 @@ 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
+function buildSegments(d1, d2) {
+	const v2DiffLen = d1.newDiffWords.length;
+	const fromV1 = buildOriginMap(d1.operations, v2DiffLen);
+	const toV3 = buildFateMap(d2.operations, v2DiffLen);
+	const cpDeletionsAt = collectDeletionsAtBoundary(d1);
+	const meInsertionsAt = collectInsertionsAtBoundary(d2);
+	const diffToOriginal = d1.newContentToOriginal ?? Array.from({ length: v2DiffLen }, (_, i) => i);
+	const v2OriginalLen = d1.newOriginalWords.length;
+	const segments = [];
+	let originalCursor = 0;
+	for (let i = 0; i < v2DiffLen; i++) {
+		const cpDel = cpDeletionsAt.get(i);
+		if (cpDel?.length) appendSegment(segments, {
+			kind: "del",
+			author: "cp"
+		}, cpDel);
+		const attr = combine(fromV1[i], toV3[i]);
+		const origIdx = diffToOriginal[i];
+		const slice = d1.newOriginalWords.slice(originalCursor, origIdx + 1);
+		originalCursor = origIdx + 1;
+		const meIns = meInsertionsAt.get(i);
+		const meInsAfterV2 = meIns?.length && isDeletion(attr);
+		if (meIns?.length && !meInsAfterV2) appendSegment(segments, {
+			kind: "ins",
+			author: "me"
+		}, meIns);
+		appendSegment(segments, attr, slice);
+		if (meInsAfterV2) appendSegment(segments, {
+			kind: "ins",
+			author: "me"
+		}, meIns);
+	}
+	const tailCpDel = cpDeletionsAt.get(v2DiffLen);
+	if (tailCpDel?.length) appendSegment(segments, {
+		kind: "del",
+		author: "cp"
+	}, tailCpDel);
+	const tailMeIns = meInsertionsAt.get(v2DiffLen);
+	if (tailMeIns?.length) appendSegment(segments, {
+		kind: "ins",
+		author: "me"
+	}, tailMeIns);
+	if (originalCursor < v2OriginalLen) appendSegment(segments, { kind: "equal" }, d1.newOriginalWords.slice(originalCursor));
+	return segments;
+}
+function buildOriginMap(ops, v2Len) {
+	const out = new Array(v2Len).fill("preserved-from-v1");
+	for (const op of ops) {
+		const origin = op.action === 2 ? "inserted-by-cp" : op.action === 4 ? "replaced-into-by-cp" : null;
+		if (origin === null) continue;
+		for (let i = op.startInNew; i < op.endInNew; i++) if (i >= 0 && i < v2Len) out[i] = origin;
+	}
+	return out;
+}
+function buildFateMap(ops, v2Len) {
+	const out = new Array(v2Len).fill("preserved-to-v3");
+	for (const op of ops) {
+		const fate = op.action === 1 ? "deleted-by-me" : op.action === 4 ? "replaced-out-by-me" : null;
+		if (fate === null) continue;
+		for (let i = op.startInOld; i < op.endInOld; i++) if (i >= 0 && i < v2Len) out[i] = fate;
+	}
+	return out;
+}
+function isDeletion(attr) {
+	return attr.kind === "del" || attr.kind === "reject";
+}
+function combine(origin, fate) {
+	const cpInserted = origin === "inserted-by-cp" || origin === "replaced-into-by-cp";
+	const meDeleted = fate === "deleted-by-me" || fate === "replaced-out-by-me";
+	if (!cpInserted && !meDeleted) return { kind: "equal" };
+	if (cpInserted && !meDeleted) return {
+		kind: "ins",
+		author: "cp"
+	};
+	if (!cpInserted && meDeleted) return {
+		kind: "del",
+		author: "me"
+	};
+	return {
+		kind: "reject",
+		by: "me",
+		rejected: "cp"
+	};
 }
-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";
+/**
+* Map V2-diff-boundary → CP-deleted V1 tokens at that boundary. Includes
+* both pure Delete ops and the V1-side of Replace ops (semantically a
+* Delete+Insert; the Insert half is picked up by the V2-token walk).
+*/
+function collectDeletionsAtBoundary(d) {
+	const out = /* @__PURE__ */ new Map();
+	for (const op of d.operations) {
+		if (op.action !== 1 && op.action !== 4) continue;
+		const words = d.oldDiffWords.slice(op.startInOld, op.endInOld);
+		if (words.length === 0) continue;
+		const existing = out.get(op.startInNew) ?? [];
+		existing.push(...words);
+		out.set(op.startInNew, existing);
+	}
+	return out;
+}
+function collectInsertionsAtBoundary(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 existing = out.get(op.startInOld) ?? [];
+		existing.push(...words);
+		out.set(op.startInOld, existing);
+	}
+	return out;
+}
+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;
+	}
+	segments.push({
+		attr,
+		words: [...words]
+	});
 }
-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 };
+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;
+	if (a.kind === "reject" && b.kind === "reject") return true;
+	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, rejects) {
+	const dataAttrs = { author };
+	if (rejects !== void 0) dataAttrs.rejects = rejects;
+	return {
+		extraClasses: rejects !== void 0 ? `${author} rejects-${rejects}` : author,
+		dataAttrs
+	};
+}
+/**
+* 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.
+*/
+function segmentEmissionShape(attr) {
+	switch (attr.kind) {
+		case "ins": return {
+			tag: "ins",
+			baseClass: "diffins",
+			metadata: authorAttribution(attr.author)
+		};
+		case "del": return {
+			tag: "del",
+			baseClass: "diffdel",
+			metadata: authorAttribution(attr.author)
+		};
+		case "reject": return {
+			tag: "del",
+			baseClass: "diffdel",
+			metadata: authorAttribution(attr.by, attr.rejected)
+		};
 	}
-	if (html.startsWith("<?", i)) {
-		const close = html.indexOf("?>", i + 2);
-		return close === -1 ? null : { end: close + 2 };
+}
+//#endregion
+//#region src/ThreeWayTable.ts
+function preprocessTablesThreeWay(v1, v2, v3, cellDiff) {
+	const t1s = findTopLevelTables(v1);
+	const t2s = findTopLevelTables(v2);
+	const t3s = findTopLevelTables(v3);
+	if (t1s.length === 0 && t2s.length === 0 && t3s.length === 0) return null;
+	for (const t of t1s) if (exceedsSizeLimit(t)) return null;
+	for (const t of t2s) if (exceedsSizeLimit(t)) return null;
+	for (const t of t3s) if (exceedsSizeLimit(t)) return null;
+	const placeholderPrefix = makePlaceholderPrefix(v1, v2, v3);
+	if (positionallyAligned(v1, v2, v3, t1s, t2s, t3s)) return preprocessAlignedByPosition(v1, v2, v3, t1s, t2s, t3s, cellDiff, placeholderPrefix);
+	return preprocessMisalignedByContent(v1, v2, v3, t1s, t2s, t3s, cellDiff, placeholderPrefix);
+}
+function preprocessAlignedByPosition(v1, v2, v3, t1s, t2s, t3s, cellDiff, placeholderPrefix) {
+	const pairs = [];
+	for (let i = 0; i < t1s.length; i++) pairs.push({
+		t1: t1s[i],
+		t2: t2s[i],
+		t3: t3s[i],
+		diffed: diffTableThreeWay(v1, v2, v3, t1s[i], t2s[i], t3s[i], cellDiff)
+	});
+	let modifiedV1 = v1;
+	let modifiedV2 = v2;
+	let modifiedV3 = v3;
+	const placeholderToDiff = /* @__PURE__ */ new Map();
+	for (let i = pairs.length - 1; i >= 0; i--) {
+		const placeholder = `${placeholderPrefix}${i}-->`;
+		placeholderToDiff.set(placeholder, pairs[i].diffed);
+		modifiedV1 = spliceString(modifiedV1, pairs[i].t1.tableStart, pairs[i].t1.tableEnd, placeholder);
+		modifiedV2 = spliceString(modifiedV2, pairs[i].t2.tableStart, pairs[i].t2.tableEnd, placeholder);
+		modifiedV3 = spliceString(modifiedV3, pairs[i].t3.tableStart, pairs[i].t3.tableEnd, placeholder);
 	}
-	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 {
+		modifiedV1,
+		modifiedV2,
+		modifiedV3,
+		placeholderToDiff
+	};
+}
+/**
+* Multi-table mismatch handler. Tables are paired across V1↔V2 and
+* V2↔V3 via content-LCS, then substituted as placeholders such that
+* each placeholder appears in exactly the inputs where its underlying
+* table exists. The word-level merger sees:
+*   - paired-everywhere placeholders → equal in both diffs → unwrapped
+*   - V2-only (CP-inserted + Me-rejected)  → inserted by CP, deleted by
+*     Me → reject wrapper around the table
+*   - V2+V3 (CP-inserted, Me-kept) → ins-cp wrapper
+*   - V1+V2 (Me-deleted) → del-me wrapper
+*   - V1-only (CP-deleted before V2) → del-cp wrapper
+*   - V3-only (Me-inserted) → ins-me wrapper
+*
+* Each placeholder's content is the diffed table for paired triples,
+* or the raw table HTML for unpaired tables (the word-level wrapper
+* provides the attribution).
+*/
+function preprocessMisalignedByContent(v1, v2, v3, t1s, t2s, t3s, cellDiff, placeholderPrefix) {
+	const k1 = t1s.map((t) => tableKey(v1, t));
+	const k2 = t2s.map((t) => tableKey(v2, t));
+	const k3 = t3s.map((t) => tableKey(v3, t));
+	const align12 = lcsAlign(k1, k2);
+	const align23 = lcsAlign(k2, k3);
+	const v1ToV2 = new Array(t1s.length).fill(-1);
+	const v2ToV1 = new Array(t2s.length).fill(-1);
+	for (const a of align12) if (a.oldIdx !== null && a.newIdx !== null) {
+		v1ToV2[a.oldIdx] = a.newIdx;
+		v2ToV1[a.newIdx] = a.oldIdx;
+	}
+	const v2ToV3 = new Array(t2s.length).fill(-1);
+	const v3ToV2 = new Array(t3s.length).fill(-1);
+	for (const a of align23) if (a.oldIdx !== null && a.newIdx !== null) {
+		v2ToV3[a.oldIdx] = a.newIdx;
+		v3ToV2[a.newIdx] = a.oldIdx;
+	}
+	let nextId = 0;
+	const placeholderToDiff = /* @__PURE__ */ new Map();
+	const placeholders = {
+		v1: new Array(t1s.length).fill(null),
+		v2: new Array(t2s.length).fill(null),
+		v3: new Array(t3s.length).fill(null)
+	};
+	const allocate = () => `${placeholderPrefix}${nextId++}-->`;
+	for (let v2Idx = 0; v2Idx < t2s.length; v2Idx++) {
+		const v1Idx = v2ToV1[v2Idx];
+		const v3Idx = v2ToV3[v2Idx];
+		if (v1Idx === -1 || v3Idx === -1) continue;
+		const placeholder = allocate();
+		placeholderToDiff.set(placeholder, diffTableThreeWay(v1, v2, v3, t1s[v1Idx], t2s[v2Idx], t3s[v3Idx], cellDiff));
+		placeholders.v1[v1Idx] = placeholder;
+		placeholders.v2[v2Idx] = placeholder;
+		placeholders.v3[v3Idx] = placeholder;
+	}
+	const wrapWhole = (tag, author, tableHtml, rejects) => Utils_default.wrapText(tableHtml, tag, `diff${tag}`, authorAttribution(author, rejects));
+	for (let v2Idx = 0; v2Idx < t2s.length; v2Idx++) {
+		if (placeholders.v2[v2Idx] !== null) continue;
+		const v3Idx = v2ToV3[v2Idx];
+		if (v3Idx === -1) continue;
+		const placeholder = allocate();
+		placeholderToDiff.set(placeholder, wrapWhole("ins", "cp", v2.slice(t2s[v2Idx].tableStart, t2s[v2Idx].tableEnd)));
+		placeholders.v2[v2Idx] = placeholder;
+		placeholders.v3[v3Idx] = placeholder;
+	}
+	for (let v2Idx = 0; v2Idx < t2s.length; v2Idx++) {
+		if (placeholders.v2[v2Idx] !== null) continue;
+		const v1Idx = v2ToV1[v2Idx];
+		if (v1Idx === -1) continue;
+		const placeholder = allocate();
+		placeholderToDiff.set(placeholder, wrapWhole("del", "me", v2.slice(t2s[v2Idx].tableStart, t2s[v2Idx].tableEnd)));
+		placeholders.v1[v1Idx] = placeholder;
+		placeholders.v2[v2Idx] = placeholder;
+	}
+	for (let v2Idx = 0; v2Idx < t2s.length; v2Idx++) {
+		if (placeholders.v2[v2Idx] !== null) continue;
+		const placeholder = allocate();
+		placeholderToDiff.set(placeholder, wrapWhole("del", "me", v2.slice(t2s[v2Idx].tableStart, t2s[v2Idx].tableEnd), "cp"));
+		placeholders.v2[v2Idx] = placeholder;
+	}
+	for (let v1Idx = 0; v1Idx < t1s.length; v1Idx++) {
+		if (placeholders.v1[v1Idx] !== null) continue;
+		const placeholder = allocate();
+		placeholderToDiff.set(placeholder, wrapWhole("del", "cp", v1.slice(t1s[v1Idx].tableStart, t1s[v1Idx].tableEnd)));
+		placeholders.v1[v1Idx] = placeholder;
+	}
+	for (let v3Idx = 0; v3Idx < t3s.length; v3Idx++) {
+		if (placeholders.v3[v3Idx] !== null) continue;
+		const placeholder = allocate();
+		placeholderToDiff.set(placeholder, wrapWhole("ins", "me", v3.slice(t3s[v3Idx].tableStart, t3s[v3Idx].tableEnd)));
+		placeholders.v3[v3Idx] = placeholder;
+	}
+	let modifiedV1 = v1;
+	for (let i = t1s.length - 1; i >= 0; i--) {
+		const p = placeholders.v1[i];
+		if (p === null) continue;
+		modifiedV1 = spliceString(modifiedV1, t1s[i].tableStart, t1s[i].tableEnd, p);
+	}
+	let modifiedV2 = v2;
+	for (let i = t2s.length - 1; i >= 0; i--) {
+		const p = placeholders.v2[i];
+		if (p === null) continue;
+		modifiedV2 = spliceString(modifiedV2, t2s[i].tableStart, t2s[i].tableEnd, p);
+	}
+	let modifiedV3 = v3;
+	for (let i = t3s.length - 1; i >= 0; i--) {
+		const p = placeholders.v3[i];
+		if (p === null) continue;
+		modifiedV3 = spliceString(modifiedV3, t3s[i].tableStart, t3s[i].tableEnd, p);
 	}
-	return null;
+	return {
+		modifiedV1,
+		modifiedV2,
+		modifiedV3,
+		placeholderToDiff
+	};
 }
 /**
-* Returns the index just past the matching `</tagName>`, accounting for
-* nested tags of the same name. Returns -1 if no match before `limit`.
+* Threshold at which positional pairing is considered sound. Below this
+* similarity, two positionally-aligned tables are probably different
+* tables (e.g. CP swapped them around) and content-LCS pairing should
+* be used instead. 0.5 is a deliberately loose bar — paired-but-content-
+* edited tables (the common case) sit well above it; genuinely different
+* tables sit well below.
 */
-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;
+const POSITIONAL_PAIR_SIMILARITY_THRESHOLD = .5;
+/**
+* Returns true when V1/V2/V3 tables can be 1:1 paired by position. The
+* three lists must have equal length AND each positional triple must
+* have content similar enough that positional pairing reflects the
+* authors' likely intent. The slow content-LCS path handles cases that
+* fail this gate (table reordering, additions, deletions).
+*/
+function positionallyAligned(v1, v2, v3, t1s, t2s, t3s) {
+	if (t1s.length !== t2s.length || t2s.length !== t3s.length) return false;
+	for (let i = 0; i < t1s.length; i++) {
+		const k1 = tableKey(v1, t1s[i]);
+		const k2 = tableKey(v2, t2s[i]);
+		const k3 = tableKey(v3, t3s[i]);
+		if (textSimilarity(k1, k2) < POSITIONAL_PAIR_SIMILARITY_THRESHOLD) return false;
+		if (textSimilarity(k2, k3) < POSITIONAL_PAIR_SIMILARITY_THRESHOLD) return false;
+	}
+	return true;
+}
+function tableKey(html, table) {
+	return html.slice(table.tableStart, table.tableEnd).replace(/\s+/g, " ").trim();
+}
+function diffTableThreeWay(v1, v2, v3, t1, t2, t3, cellDiff) {
+	if (sameDimensions(t1, t2) && sameDimensions(t2, t3)) return diffTablePositional(v1, v2, v3, t1, t2, t3, cellDiff);
+	return diffTableStructural(v1, v2, v3, t1, t2, t3, cellDiff);
+}
+function diffTablePositional(v1, v2, v3, t1, t2, t3, cellDiff) {
+	const out = [];
+	let cursor = t2.tableStart;
+	for (let r = 0; r < t2.rows.length; r++) {
+		const r1 = t1.rows[r];
+		const r2 = t2.rows[r];
+		const r3 = t3.rows[r];
+		for (let c = 0; c < r2.cells.length; c++) {
+			const c1 = r1.cells[c];
+			const c2 = r2.cells[c];
+			const c3 = r3.cells[c];
+			out.push(v2.slice(cursor, c2.contentStart));
+			out.push(cellDiff(v1.slice(c1.contentStart, c1.contentEnd), v2.slice(c2.contentStart, c2.contentEnd), v3.slice(c3.contentStart, c3.contentEnd)));
+			cursor = c2.contentEnd;
 		}
-		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;
+	}
+	out.push(v2.slice(cursor, t2.tableEnd));
+	return out.join("");
+}
+/**
+* Structural-change three-way table diff: rows or cells differ in count
+* across V1/V2/V3. Strategy:
+*   1. Run row-LCS for each pair (V1↔V2, V2↔V3) over rowKeys
+*   2. Build per-V2-row origin (from align1) and fate (from align2)
+*   3. Walk V2's row order, interleaving:
+*      - CP-deleted V1 rows (in align1 but not preserved into V2)
+*      - Me-inserted V3 rows (in align2 but not from V2)
+*   4. For each V2 row, combine origin+fate to decide:
+*      - equal: recurse cellDiff if cell counts match, else fall back
+*      - ins-cp: emit V2 row as fully-CP-inserted
+*      - del-me: emit V2 row as fully-Me-deleted
+*      - reject: emit V2 row as Me-rejects-CP
+*
+* Tie-break to Me on LCS disagreement (D2): each LCS is authoritative
+* for its own pair-wise view; we don't attempt to reconcile cases where
+* align1's idea of V2's V1 origin contradicts what align2 implies via
+* V3 history. In practice these cases manifest as the row being
+* attributed independently per pair, which is the conservative correct
+* thing to do.
+*/
+function diffTableStructural(v1, v2, v3, t1, t2, t3, cellDiff) {
+	const v1Keys = t1.rows.map((r) => rowKey(v1, r));
+	const v2Keys = t2.rows.map((r) => rowKey(v2, r));
+	const v3Keys = t3.rows.map((r) => rowKey(v3, r));
+	const align1 = lcsAlign(v1Keys, v2Keys);
+	const align2 = lcsAlign(v2Keys, v3Keys);
+	const v2Origin = new Array(t2.rows.length);
+	for (let i = 0; i < v2Origin.length; i++) v2Origin[i] = { kind: "cp-inserted" };
+	for (const a of align1) if (a.newIdx !== null && a.oldIdx !== null) v2Origin[a.newIdx] = {
+		kind: "preserved",
+		v1Idx: a.oldIdx
+	};
+	const v2Fate = new Array(t2.rows.length);
+	for (let i = 0; i < v2Fate.length; i++) v2Fate[i] = { kind: "me-deleted" };
+	for (const a of align2) if (a.oldIdx !== null && a.newIdx !== null) v2Fate[a.oldIdx] = {
+		kind: "preserved",
+		v3Idx: a.newIdx
+	};
+	const cpDelRowsAt = collectCpDelRowsAtBoundary(align1, t2.rows.length);
+	const meInsRowsAt = collectMeInsRowsAtBoundary(align2, t2.rows.length);
+	const out = [];
+	out.push(tableHeaderSlice(v2, t2));
+	const emitBoundary = (i) => {
+		const cpDel = cpDelRowsAt.get(i);
+		if (cpDel) for (const v1RowIdx of cpDel) out.push(emitFullRowAttributed(v1, t1.rows[v1RowIdx], "del", "cp"));
+		const meIns = meInsRowsAt.get(i);
+		if (meIns) for (const v3RowIdx of meIns) out.push(emitFullRowAttributed(v3, t3.rows[v3RowIdx], "ins", "me"));
+	};
+	for (let r = 0; r < t2.rows.length; r++) {
+		emitBoundary(r);
+		const v2Row = t2.rows[r];
+		const origin = v2Origin[r];
+		const fate = v2Fate[r];
+		out.push(emitV2Row(v1, v2, v3, v2Row, t1, t3, origin, fate, cellDiff));
+	}
+	emitBoundary(t2.rows.length);
+	out.push(tableFooterSlice(v2, t2));
+	return out.join("");
+}
+function emitV2Row(v1, v2, v3, v2Row, t1, t3, origin, fate, cellDiff) {
+	if (origin.kind === "cp-inserted" && fate.kind === "me-deleted") return emitFullRowAttributed(v2, v2Row, "del", "me", "cp");
+	if (origin.kind === "cp-inserted") return emitFullRowAttributed(v2, v2Row, "ins", "cp");
+	if (fate.kind === "me-deleted") return emitFullRowAttributed(v2, v2Row, "del", "me");
+	const v1Row = t1.rows[origin.v1Idx];
+	const v3Row = t3.rows[fate.v3Idx];
+	if (v1Row.cells.length === v2Row.cells.length && v2Row.cells.length === v3Row.cells.length) return diffRowPositional(v1, v2, v3, v1Row, v2Row, v3Row, cellDiff);
+	const out = [];
+	out.push(emitFullRowAttributed(v2, v2Row, "del", "me"));
+	out.push(emitFullRowAttributed(v3, v3Row, "ins", "me"));
+	return out.join("");
+}
+function diffRowPositional(v1, v2, v3, v1Row, v2Row, v3Row, cellDiff) {
+	const out = [];
+	let cursor = v2Row.rowStart;
+	for (let c = 0; c < v2Row.cells.length; c++) {
+		const c1 = v1Row.cells[c];
+		const c2 = v2Row.cells[c];
+		const c3 = v3Row.cells[c];
+		out.push(v2.slice(cursor, c2.contentStart));
+		out.push(cellDiff(v1.slice(c1.contentStart, c1.contentEnd), v2.slice(c2.contentStart, c2.contentEnd), v3.slice(c3.contentStart, c3.contentEnd)));
+		cursor = c2.contentEnd;
+	}
+	out.push(v2.slice(cursor, v2Row.rowEnd));
+	return out.join("");
+}
+function collectCpDelRowsAtBoundary(align, v2RowCount) {
+	const out = /* @__PURE__ */ new Map();
+	let nextV2Boundary = v2RowCount;
+	const pending = [];
+	for (let i = align.length - 1; i >= 0; i--) {
+		const a = align[i];
+		if (a.newIdx !== null) {
+			if (pending.length > 0) {
+				const existing = out.get(nextV2Boundary) ?? [];
+				existing.unshift(...pending.toReversed());
+				out.set(nextV2Boundary, existing);
+				pending.length = 0;
+			}
+			nextV2Boundary = a.newIdx;
+		} else if (a.oldIdx !== null) pending.push(a.oldIdx);
+	}
+	if (pending.length > 0) {
+		const existing = out.get(nextV2Boundary) ?? [];
+		existing.unshift(...pending.reverse());
+		out.set(nextV2Boundary, existing);
+	}
+	return out;
+}
+function collectMeInsRowsAtBoundary(align, v2RowCount) {
+	const out = /* @__PURE__ */ new Map();
+	let nextV2Boundary = v2RowCount;
+	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(nextV2Boundary) ?? [];
+				existing.unshift(...pending.toReversed());
+				out.set(nextV2Boundary, existing);
+				pending.length = 0;
+			}
+			nextV2Boundary = a.oldIdx;
+		} else if (a.newIdx !== null) pending.push(a.newIdx);
+	}
+	if (pending.length > 0) {
+		const existing = out.get(nextV2Boundary) ?? [];
+		existing.unshift(...pending.reverse());
+		out.set(nextV2Boundary, 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 that's fully attributed to one author, in an ins or del
+* role. `rejectsAuthor` is set when the row is a Me-deletion of a
+* CP-inserted row. Wraps `<tr>` in `class='diffins cp'` etc. and each
+* `<td>` content in the corresponding `<ins>`/`<del>` wrapper with the
+* author classes/attrs.
+*/
+function emitFullRowAttributed(html, row, kind, author, rejectsAuthor) {
+	const trOpening = parseOpeningTagAt(html, row.rowStart);
+	if (!trOpening) return html.slice(html.length, html.length);
+	const out = [injectAuthorAttribution(html.slice(row.rowStart, trOpening.end), kind, author, rejectsAuthor)];
+	let cursor = trOpening.end;
+	for (const cell of row.cells) {
+		out.push(html.slice(cursor, cell.cellStart));
+		out.push(emitFullCellAttributed(html, cell, kind, author, rejectsAuthor));
+		cursor = cell.cellEnd;
+	}
+	out.push(html.slice(cursor, row.rowEnd));
+	return out.join("");
+}
+function emitFullCellAttributed(html, cell, kind, author, rejectsAuthor) {
+	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, rejectsAuthor);
+	const innerContent = html.slice(cell.contentStart, cell.contentEnd);
+	const innerWrapped = innerContent.trim().length === 0 ? innerContent : Utils_default.wrapText(innerContent, kind, `diff${kind}`, authorAttribution(author, rejectsAuthor));
+	const closing = html.slice(cell.contentEnd, cell.cellEnd);
+	return tdWithAttrs + innerWrapped + closing;
+}
+/**
+* Inject author classes + data-attrs into an existing opening tag (e.g.
+* an `<tr>` or `<td>` already in the source HTML). Uses the same
+* attribution shape as `authorAttribution` + `Utils.wrapText` so the
+* inject-into-existing and wrap-around-text paths agree.
+*/
+function injectAuthorAttribution(openingTag, kind, author, rejectsAuthor) {
+	const meta = authorAttribution(author, rejectsAuthor);
+	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 +2075,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 +2151,153 @@ 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.
+	*/
+	static executeThreeWay(v1, v2, v3, options = {}) {
+		return HtmlDiff.executeThreeWayWithDepth(v1, v2, v3, options, 0);
+	}
+	static executeThreeWayWithDepth(v1, v2, v3, options, depth) {
+		const tablePreprocess = depth < HtmlDiff.MaxThreeWayDepth ? preprocessTablesThreeWay(v1, v2, v3, (c1, c2, c3) => HtmlDiff.executeThreeWayWithDepth(c1, c2, c3, options, depth + 1)) : null;
+		const inV1 = tablePreprocess?.modifiedV1 ?? v1;
+		const inV2 = tablePreprocess?.modifiedV2 ?? v2;
+		const inV3 = tablePreprocess?.modifiedV3 ?? v3;
+		const analyzeOpts = {
+			useProjections: options.useProjections ?? (HtmlDiff.evaluateProjectionApplicability(inV1, inV2) && HtmlDiff.evaluateProjectionApplicability(inV2, inV3)),
+			blockExpressions: options.blockExpressions,
+			repeatingWordsAccuracy: options.repeatingWordsAccuracy,
+			orphanMatchThreshold: options.orphanMatchThreshold,
+			ignoreWhitespaceDifferences: options.ignoreWhitespaceDifferences
+		};
+		const d1 = HtmlDiff.analyze(inV1, inV2, analyzeOpts);
+		const d2 = HtmlDiff.analyze(inV2, inV3, analyzeOpts);
+		if (d1.newDiffWords.length !== d2.oldDiffWords.length) throw new Error(`HtmlDiff.executeThreeWay: V2 tokenisation diverged across pair-wise analyses (${d1.newDiffWords.length} vs ${d2.oldDiffWords.length}). This indicates the symmetric-projection coordination has a bug.`);
+		const segments = buildSegments(d1, d2);
+		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 +2305,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 +2525,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 +2543,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 +2569,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;
 		}
 	}