@createiq/htmldiff 1.1.0-beta.0 → 1.2.0-beta.0

package/src/TableDiff.ts

@@ -1,3 +1,20 @@
+import {
+  type Alignment,
+  findOptimalAlignmentSkips,
+  lcsAlign,
+  orderAlignmentForEmission,
+  pairSimilarUnmatched,
+  textSimilarity,
+} from './Alignment'
+import {
+  findMatchingClosingTag,
+  injectClass,
+  matchesClosingTagAt,
+  matchesTagAt,
+  parseOpeningTagAt,
+} from './HtmlScanner'
+import { wrapText } from './Utils'
+
 /**
  * Table-aware preprocessing for HtmlDiff.
  *
@@ -22,7 +39,7 @@
  * by the normal word-level pipeline.
  */
 
-interface CellRange {
+export interface CellRange {
   /** Start index of the cell's opening tag in the original html. */
   cellStart: number
   /** Index just past the cell's closing tag. */
@@ -32,13 +49,13 @@ interface CellRange {
   contentEnd: number
 }
 
-interface RowRange {
+export interface RowRange {
   rowStart: number
   rowEnd: number
   cells: CellRange[]
 }
 
-interface TableRange {
+export interface TableRange {
   tableStart: number
   tableEnd: number
   rows: RowRange[]
@@ -73,9 +90,26 @@ const PLACEHOLDER_SUFFIX = '-->'
 const MAX_TABLE_ROWS = 1500
 const MAX_TABLE_CELLS_PER_ROW = 200
 
-function makePlaceholderPrefix(oldHtml: string, newHtml: string): string {
+// Caps for the per-row column-position DP in
+// findBestColumnInsertPositions / findBestColumnDeletePositions.
+// MAX_COLUMN_DELTA is the *semantic* guard: a row with more than 6
+// columns added or deleted is almost always a row rewrite rather than
+// a structural column change, and is better handled by cell-LCS with
+// fuzzy pairing. MAX_COLUMN_SEARCH_WIDTH bounds the per-row DP at
+// O(MAX_COLUMN_SEARCH_WIDTH²) ≈ 40K ops; aligned with
+// MAX_TABLE_CELLS_PER_ROW so any row that survives the table-size cap
+// can still use the DP path.
+const MAX_COLUMN_DELTA = 6
+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.
+ */
+export function makePlaceholderPrefix(...inputs: string[]): string {
   // 4 random bytes → 8 hex chars → 16^8 ≈ 4.3 billion combinations. We
-  // also retry if the generated nonce happens to occur in either input.
+  // also retry if the generated nonce happens to occur in any input.
   // Using `Math.random` here is fine: we're not defending against a
   // malicious adversary, just avoiding accidental collisions.
   for (let attempt = 0; attempt < 8; attempt++) {
@@ -83,7 +117,7 @@ function makePlaceholderPrefix(oldHtml: string, newHtml: string): string {
       .toString(16)
       .padStart(8, '0')
     const prefix = `${PLACEHOLDER_PREFIX_BASE}${nonce}_`
-    if (!oldHtml.includes(prefix) && !newHtml.includes(prefix)) {
+    if (inputs.every(input => !input.includes(prefix))) {
       return prefix
     }
   }
@@ -93,6 +127,8 @@ function makePlaceholderPrefix(oldHtml: string, newHtml: string): string {
   return `${PLACEHOLDER_PREFIX_BASE}fallback_${Date.now()}_`
 }
 
+export { PLACEHOLDER_SUFFIX }
+
 type DiffCellFn = (oldCellContent: string, newCellContent: string) => string
 
 /**
@@ -145,11 +181,11 @@ export function restoreTablePlaceholders(diffOutput: string, placeholderToDiff:
   return result
 }
 
-function spliceString(s: string, start: number, end: number, replacement: string): string {
+export function spliceString(s: string, start: number, end: number, replacement: string): string {
   return s.slice(0, start) + replacement + s.slice(end)
 }
 
-function exceedsSizeLimit(table: TableRange): boolean {
+export function exceedsSizeLimit(table: TableRange): boolean {
   if (table.rows.length > MAX_TABLE_ROWS) return true
   for (const row of table.rows) {
     if (row.cells.length > MAX_TABLE_CELLS_PER_ROW) return true
@@ -320,7 +356,7 @@ function emitEmptyRow(html: string, row: RowRange): string {
   return html.slice(row.rowStart, row.rowEnd)
 }
 
-function sameDimensions(a: TableRange, b: TableRange): boolean {
+export function sameDimensions(a: TableRange, b: TableRange): boolean {
   if (a.rows.length !== b.rows.length) return false
   for (let i = 0; i < a.rows.length; i++) {
     if (a.rows[i].cells.length !== b.rows[i].cells.length) return false
@@ -395,7 +431,7 @@ function diffStructurallyAlignedTable(
   // has no rows at all, fall back to a from-scratch reconstruction so
   // we still emit deleted rows.
   if (newTable.rows.length === 0) {
-    return rebuildStructurallyAlignedTable(oldHtml, newHtml, oldTable, newTable, alignment, diffCell)
+    return rebuildStructurallyAlignedTable(oldHtml, newHtml, oldTable, newTable, alignment)
   }
 
   const out: string[] = []
@@ -408,97 +444,23 @@ function diffStructurallyAlignedTable(
       if (align.oldIdx !== null) {
         out.push(diffPreservedRow(oldHtml, newHtml, oldTable.rows[align.oldIdx], newRow, diffCell))
       } else {
-        out.push(emitFullRow(newHtml, newRow, 'ins', diffCell))
+        out.push(emitFullRow(newHtml, newRow, 'ins'))
       }
       cursor = newRow.rowEnd
     } else if (align.oldIdx !== null) {
-      out.push(emitFullRow(oldHtml, oldTable.rows[align.oldIdx], 'del', diffCell))
+      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: Alignment[]): Alignment[] {
-  const preserved: Array<{ oldIdx: number; newIdx: number }> = []
-  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)
-
-  // For a deleted row with oldIdx K, return the newIdx of the preserved
-  // entry with the largest oldIdx less than K, or -1 if none.
-  function newIdxOfPreservedBefore(oldIdx: number): number {
-    let result = -1
-    for (const p of preserved) {
-      if (p.oldIdx >= oldIdx) break
-      result = p.newIdx
-    }
-    return result
-  }
-
-  // Decorate each alignment with a fractional position. We use
-  // (primary, secondary) tuples so dels at the same gap sort by oldIdx
-  // (in old's row order) and inserts at the same newIdx stay stable.
-  const decorated = alignment.map((a, i) => {
-    let primary: number
-    let secondary: number
-    if (a.newIdx !== null) {
-      primary = a.newIdx
-      secondary = a.oldIdx === null ? 1 : 0 // preserved before pure-insert at same newIdx (rare)
-    } else {
-      // Pure delete
-      primary = newIdxOfPreservedBefore(a.oldIdx as number) + 0.5
-      secondary = a.oldIdx as number
-    }
-    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 // stable
-  })
-
-  return decorated.map(d => d.entry)
-}
-
 function rebuildStructurallyAlignedTable(
   oldHtml: string,
   newHtml: string,
   oldTable: TableRange,
   newTable: TableRange,
-  alignment: Alignment[],
-  diffCell: DiffCellFn
+  alignment: Alignment[]
 ): string {
   // Used when new has no rows but old does — we lose the per-row
   // wrappers from new (there are none), so reconstruct from old's frame.
@@ -506,9 +468,9 @@ function rebuildStructurallyAlignedTable(
   out.push(headerSlice(newHtml, newTable, oldHtml, oldTable))
   for (const align of alignment) {
     if (align.oldIdx !== null) {
-      out.push(emitFullRow(oldHtml, oldTable.rows[align.oldIdx], 'del', diffCell))
+      out.push(emitFullRow(oldHtml, oldTable.rows[align.oldIdx], 'del'))
     } else if (align.newIdx !== null) {
-      out.push(emitFullRow(newHtml, newTable.rows[align.newIdx], 'ins', diffCell))
+      out.push(emitFullRow(newHtml, newTable.rows[align.newIdx], 'ins'))
     }
   }
   out.push('</table>')
@@ -526,7 +488,7 @@ function headerSlice(newHtml: string, newTable: TableRange, oldHtml: string, old
   return oldHtml.slice(oldTable.tableStart, oldFirstRow)
 }
 
-function rowKey(html: string, row: RowRange): string {
+export function rowKey(html: string, row: RowRange): string {
   // Include cell tag text in the key so column-add doesn't accidentally
   // match a row to one with different cell counts. Whitespace-normalize to
   // tolerate formatting differences.
@@ -548,59 +510,51 @@ function diffPreservedRow(
   // on each affected cell.
   const colspanAligned = diffColspanChangedRow(oldHtml, newHtml, oldRow, newRow, diffCell)
   if (colspanAligned !== null) return colspanAligned
-  // For a single-column add/delete (cell count differs by exactly 1),
-  // detect the position via positional similarity scan and align the
-  // remaining cells positionally. This handles the case where a column
-  // was added AND a different cell got an unrelated content edit — the
-  // edited cell still aligns by position rather than getting orphaned by
-  // the cell-LCS exact-match.
-  const delta = newRow.cells.length - oldRow.cells.length
   // For column add/delete (cell counts differ), find the best insertion
   // or deletion positions via positional similarity scan and align the
   // remaining cells positionally. This handles content-edit alongside
   // column-add by keeping the edited cell in its column position rather
   // than orphaning it via the cell-LCS exact match.
-  // Guardrail: combinatorial search is C(newCount, k); we cap to avoid
-  // explosion on very wide tables. The cap is generous for real legal
-  // schedules; anything above falls through to cell-LCS.
+  // Guardrail: O(M × N) DP scales fine within MAX_COLUMN_SEARCH_WIDTH;
+  // wider rows fall through to cell-LCS so we don't run the per-row DP
+  // on multi-thousand-cell exotica. MAX_COLUMN_DELTA stays as a
+  // semantic guard — a delta > 6 usually means "row rewrite", not
+  // "column added", and is better handled by cell-LCS.
+  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)
 }
 
-const MAX_COLUMN_DELTA = 6
-const MAX_COLUMN_SEARCH_WIDTH = 40
-
 /**
- * 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: string,
   newHtml: string,
   oldRow: RowRange,
   newRow: RowRange,
-  k: number,
   diffCell: DiffCellFn
 ): string {
-  const insertedPositions = findBestColumnInsertPositions(oldRow, newRow, k, oldHtml, newHtml)
+  const insertedPositions = findBestColumnInsertPositions(oldRow, newRow, oldHtml, newHtml)
   const inserted = new Set(insertedPositions)
   const out: string[] = [rowHeaderSlice(newHtml, newRow)]
   let oldIdx = 0
   for (let c = 0; c < newRow.cells.length; c++) {
     if (inserted.has(c)) {
-      out.push(emitFullCell(newHtml, newRow.cells[c], 'ins', diffCell))
+      out.push(emitFullCell(newHtml, newRow.cells[c], 'ins'))
     } else {
       out.push(emitDiffedCell(oldHtml, newHtml, oldRow.cells[oldIdx], newRow.cells[c], diffCell))
       oldIdx++
@@ -615,16 +569,15 @@ function diffMultiColumnDeleteRow(
   newHtml: string,
   oldRow: RowRange,
   newRow: RowRange,
-  k: number,
   diffCell: DiffCellFn
 ): string {
-  const deletedPositions = findBestColumnDeletePositions(oldRow, newRow, k, oldHtml, newHtml)
+  const deletedPositions = findBestColumnDeletePositions(oldRow, newRow, oldHtml, newHtml)
   const deleted = new Set(deletedPositions)
   const out: string[] = [rowHeaderSlice(newHtml, newRow)]
   let newIdx = 0
   for (let oldIdx = 0; oldIdx < oldRow.cells.length; oldIdx++) {
     if (deleted.has(oldIdx)) {
-      out.push(emitFullCell(oldHtml, oldRow.cells[oldIdx], 'del', diffCell))
+      out.push(emitFullCell(oldHtml, oldRow.cells[oldIdx], 'del'))
       continue
     }
     out.push(emitDiffedCell(oldHtml, newHtml, oldRow.cells[oldIdx], newRow.cells[newIdx], diffCell))
@@ -634,74 +587,20 @@ function diffMultiColumnDeleteRow(
   return out.join('')
 }
 
-function findBestColumnInsertPositions(
-  oldRow: RowRange,
-  newRow: RowRange,
-  k: number,
-  oldHtml: string,
-  newHtml: string
-): number[] {
-  let bestPositions: number[] = []
-  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 += cellSimilarity(oldRow.cells[oldIdx], newRow.cells[newIdx], oldHtml, newHtml)
-      oldIdx++
-    }
-    if (score > bestScore) {
-      bestScore = score
-      bestPositions = combo
-    }
-  }
-  return bestPositions
-}
-
-function findBestColumnDeletePositions(
-  oldRow: RowRange,
-  newRow: RowRange,
-  k: number,
-  oldHtml: string,
-  newHtml: string
-): number[] {
-  let bestPositions: number[] = []
-  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 += cellSimilarity(oldRow.cells[oldIdx], newRow.cells[newIdx], oldHtml, newHtml)
-      newIdx++
-    }
-    if (score > bestScore) {
-      bestScore = score
-      bestPositions = combo
-    }
-  }
-  return bestPositions
+function findBestColumnInsertPositions(oldRow: RowRange, newRow: RowRange, oldHtml: string, newHtml: string): number[] {
+  const oldTexts = oldRow.cells.map(c => cellText(oldHtml, c))
+  const newTexts = newRow.cells.map(c => cellText(newHtml, c))
+  return findOptimalAlignmentSkips(oldTexts, newTexts, (oldIdx, newIdx) =>
+    textSimilarity(oldTexts[oldIdx], newTexts[newIdx])
+  )
 }
 
-/**
- * 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: number, k: number): IterableIterator<number[]> {
-  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
-  }
+function findBestColumnDeletePositions(oldRow: RowRange, newRow: RowRange, oldHtml: string, newHtml: string): number[] {
+  const oldTexts = oldRow.cells.map(c => cellText(oldHtml, c))
+  const newTexts = newRow.cells.map(c => cellText(newHtml, c))
+  return findOptimalAlignmentSkips(newTexts, oldTexts, (newIdx, oldIdx) =>
+    textSimilarity(oldTexts[oldIdx], newTexts[newIdx])
+  )
 }
 
 /**
@@ -864,9 +763,9 @@ function diffStructurallyAlignedRow(
       const newCell = newRow.cells[align.newIdx]
       out.push(emitDiffedCell(oldHtml, newHtml, oldCell, newCell, diffCell))
     } else if (align.newIdx !== null) {
-      out.push(emitFullCell(newHtml, newRow.cells[align.newIdx], 'ins', diffCell))
+      out.push(emitFullCell(newHtml, newRow.cells[align.newIdx], 'ins'))
     } else if (align.oldIdx !== null) {
-      out.push(emitFullCell(oldHtml, oldRow.cells[align.oldIdx], 'del', diffCell))
+      out.push(emitFullCell(oldHtml, oldRow.cells[align.oldIdx], 'del'))
     }
   }
 
@@ -888,7 +787,7 @@ function cellKey(html: string, cell: CellRange): string {
  * each `<td>`, with an `<ins>`/`<del>` wrapper around any cell content
  * (empty cells get the class but no wrapper).
  */
-function emitFullRow(html: string, row: RowRange, kind: 'ins' | 'del', diffCell: DiffCellFn): string {
+function emitFullRow(html: string, row: RowRange, kind: 'ins' | 'del'): string {
   const cls = kind === 'ins' ? 'diffins' : 'diffdel'
   const trOpening = parseOpeningTagAt(html, row.rowStart)
   if (!trOpening) return html.slice(row.rowStart, row.rowEnd)
@@ -898,7 +797,7 @@ function emitFullRow(html: string, row: RowRange, kind: 'ins' | 'del', diffCell:
   let cursor = trOpening.end
   for (const cell of row.cells) {
     out.push(html.slice(cursor, cell.cellStart))
-    out.push(emitFullCell(html, cell, kind, diffCell))
+    out.push(emitFullCell(html, cell, kind))
     cursor = cell.cellEnd
   }
   out.push(html.slice(cursor, row.rowEnd))
@@ -913,7 +812,7 @@ function emitFullRow(html: string, row: RowRange, kind: 'ins' | 'del', diffCell:
  * the full recursive diff would produce for newly-inserted formatting.
  * Empty cells get the class on the `<td>` but no inner wrapping.
  */
-function emitFullCell(html: string, cell: CellRange, kind: 'ins' | 'del', _diffCell: DiffCellFn): string {
+function emitFullCell(html: string, cell: CellRange, kind: 'ins' | 'del'): string {
   const cls = kind === 'ins' ? 'diffins' : 'diffdel'
   const tdOpening = parseOpeningTagAt(html, cell.cellStart)
   if (!tdOpening) return html.slice(cell.cellStart, cell.cellEnd)
@@ -954,7 +853,7 @@ function wrapInlineTextRuns(content: string, kind: 'ins' | 'del'): string {
     while (j < content.length && content[j] !== '<') j++
     const text = content.slice(i, j)
     if (text.trim().length > 0) {
-      out.push(`<${tag} class='${cls}'>${text}</${tag}>`)
+      out.push(wrapText(text, tag, cls))
     } else {
       out.push(text)
     }
@@ -993,11 +892,6 @@ function rowHeaderSlice(html: string, row: RowRange): string {
   return html.slice(row.rowStart, row.cells[0].cellStart)
 }
 
-interface Alignment {
-  oldIdx: number | null
-  newIdx: number | null
-}
-
 /** Character-level similarity threshold above which we treat two rows as "the same row, edited". */
 const ROW_FUZZY_THRESHOLD = 0.5
 
@@ -1024,8 +918,13 @@ function pairSimilarUnmatchedRows(
   oldHtml: string,
   newHtml: string
 ): Alignment[] {
+  // Pre-compute row texts once; the similarity callback is invoked
+  // O(D × I) times per unmatched run (every del × every ins), and
+  // rowText walks every cell.
+  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) =>
-    rowSimilarity(oldTable.rows[oldIdx], newTable.rows[newIdx], oldHtml, newHtml)
+    textSimilarity(oldTexts[oldIdx], newTexts[newIdx])
   )
 }
 
@@ -1036,149 +935,14 @@ function pairSimilarUnmatchedCells(
   oldHtml: string,
   newHtml: string
 ): Alignment[] {
+  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) =>
-    cellSimilarity(oldRow.cells[oldIdx], newRow.cells[newIdx], oldHtml, newHtml)
+    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: Alignment[],
-  threshold: number,
-  similarity: (oldIdx: number, newIdx: number) => number
-): Alignment[] {
-  const pairs = new Map<number, number>() // del-alignment-idx → ins-alignment-idx
-  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: number[] = []
-    const insIndices: number[] = []
-    for (let k = runStart; k < runEnd; k++) {
-      if (alignment[k].oldIdx !== null) delIndices.push(k)
-      else insIndices.push(k)
-    }
-
-    const usedIns = new Set<number>()
-    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 as number, alignment[ii].newIdx as number)
-        if (sim > bestSim) {
-          bestSim = sim
-          bestIi = ii
-        }
-      }
-      if (bestIi >= 0) {
-        pairs.set(di, bestIi)
-        usedIns.add(bestIi)
-      }
-    }
-  }
-
-  const insToDel = new Map<number, number>() // ins-alignment-idx → del-alignment-idx
-  for (const [delAi, insAi] of pairs) insToDel.set(insAi, delAi)
-  const pairedDels = new Set<number>(pairs.keys())
-
-  const result: Alignment[] = []
-  for (let k = 0; k < alignment.length; k++) {
-    if (pairedDels.has(k)) continue // paired del — emitted when we reach its ins
-    if (insToDel.has(k)) {
-      const delAi = insToDel.get(k) as number
-      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 rowSimilarity(oldRow: RowRange, newRow: RowRange, oldHtml: string, newHtml: string): number {
-  return textSimilarity(rowText(oldHtml, oldRow), rowText(newHtml, newRow))
-}
-
-function cellSimilarity(oldCell: CellRange, newCell: CellRange, oldHtml: string, newHtml: string): number {
-  return textSimilarity(cellText(oldHtml, oldCell), cellText(newHtml, newCell))
-}
-
-function textSimilarity(a: string, b: string): number {
-  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: string, b: string): number {
-  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: string, b: string): number {
-  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: string, row: RowRange): string {
+export function rowText(html: string, row: RowRange): string {
   const parts: string[] = []
   for (const cell of row.cells) {
     parts.push(html.slice(cell.contentStart, cell.contentEnd).replace(/<[^>]+>/g, ' '))
@@ -1195,140 +959,13 @@ function cellText(html: string, cell: CellRange): string {
     .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: string[], newKeys: string[]): Alignment[] {
-  const m = oldKeys.length
-  const n = newKeys.length
-  const dp: number[][] = Array.from({ length: m + 1 }, () => new Array<number>(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: Alignment[] = []
-  let i = m
-  let j = n
-  while (i > 0 || j > 0) {
-    if (i > 0 && j > 0 && oldKeys[i - 1] === newKeys[j - 1]) {
-      result.unshift({ oldIdx: i - 1, newIdx: j - 1 })
-      i--
-      j--
-    } else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
-      result.unshift({ oldIdx: null, newIdx: j - 1 })
-      j--
-    } else {
-      result.unshift({ oldIdx: i - 1, newIdx: null })
-      i--
-    }
-  }
-  return result
-}
-
-/**
- * Returns the opening tag string with the given class injected. Existing
- * `class` attributes are preserved and the new class appended.
- */
-/**
- * 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: string, cls: string): string {
-  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 isSelfClosing = openingTag.endsWith('/>')
-  const insertAt = isSelfClosing ? 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: string): { valueStart: number; valueEnd: number; value: string } | null {
-  // Skip past the tag name. Tag starts with `<`; first run of [A-Za-z0-9-]
-  // is the tag name. Anything after is attribute territory.
-  let i = 1
-  while (i < openingTag.length && /[A-Za-z0-9_:-]/.test(openingTag[i])) i++
-
-  while (i < openingTag.length) {
-    // Skip whitespace
-    while (i < openingTag.length && /\s/.test(openingTag[i])) i++
-    if (i >= openingTag.length) break
-    if (openingTag[i] === '>' || openingTag[i] === '/') break
-
-    // Read attribute name
-    const nameStart = i
-    while (i < openingTag.length && !/[\s=>/]/.test(openingTag[i])) i++
-    const name = openingTag.slice(nameStart, i)
-
-    // Optional whitespace + '=' + optional whitespace + value
-    while (i < openingTag.length && /\s/.test(openingTag[i])) i++
-    if (openingTag[i] !== '=') {
-      // Bare attribute (no value) — not class
-      continue
-    }
-    i++ // past '='
-    while (i < openingTag.length && /\s/.test(openingTag[i])) i++
-
-    // Value: quoted or unquoted
-    let valueStart: number
-    let valueEnd: number
-    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++ // past closing quote
-    } 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
-}
-
 /**
  * Walks html and returns ranges for every top-level `<table>...</table>`
  * block. Nested tables aren't extracted as separate top-level entries —
  * they're captured inside the parent's content range and handled when the
  * cell-level diff recurses through them.
  */
-function findTopLevelTables(html: string): TableRange[] {
+export function findTopLevelTables(html: string): TableRange[] {
   const tables: TableRange[] = []
   let i = 0
   while (i < html.length) {
@@ -1414,91 +1051,3 @@ function findTopLevelCells(html: string, start: number, end: number): CellRange[
   }
   return cells
 }
-
-function matchesTagAt(html: string, i: number, tagName: string): boolean {
-  if (html[i] !== '<') return false
-  const candidate = html.slice(i + 1, i + 1 + tagName.length).toLowerCase()
-  if (candidate !== tagName) return false
-  const after = html[i + 1 + tagName.length]
-  return after === '>' || after === ' ' || after === '\t' || after === '\n' || after === '\r' || after === '/'
-}
-
-function matchesClosingTagAt(html: string, i: number, tagName: string): boolean {
-  if (html[i] !== '<' || html[i + 1] !== '/') return false
-  const candidate = html.slice(i + 2, i + 2 + tagName.length).toLowerCase()
-  if (candidate !== tagName) return false
-  const after = html[i + 2 + tagName.length]
-  return after === '>' || after === ' ' || after === '\t' || after === '\n' || after === '\r'
-}
-
-interface OpeningTag {
-  /** Index just past the closing `>` of the opening tag. */
-  end: number
-}
-
-function parseOpeningTagAt(html: string, i: number): OpeningTag | null {
-  // 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, not just be theoretical.
-  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 }
-  }
-  // Walk to the next unquoted '>'. Handles attributes whose values contain
-  // a literal '>' inside quotes, which a plain indexOf would mishandle.
-  let j = i + 1
-  let quote: string | null = 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
-}
-
-/**
- * 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: string, from: number, tagName: string, limit: number = html.length): number {
-  let depth = 1
-  let i = from
-  while (i < limit) {
-    if (matchesTagAt(html, i, tagName)) {
-      const opening = parseOpeningTagAt(html, i)
-      if (!opening) {
-        i++
-        continue
-      }
-      const tagText = html.slice(i, opening.end)
-      if (!tagText.endsWith('/>')) depth++
-      i = opening.end
-    } else if (matchesClosingTagAt(html, i, tagName)) {
-      depth--
-      const closing = parseOpeningTagAt(html, i)
-      const closingEnd = closing?.end ?? i + `</${tagName}>`.length
-      if (depth === 0) return closingEnd
-      i = closingEnd
-    } else {
-      i++
-    }
-  }
-  return -1
-}