@createiq/htmldiff 1.1.0 → 1.2.0-beta.1

package/src/ThreeWayTable.ts

@@ -0,0 +1,625 @@
+import { lcsAlign, textSimilarity } from './Alignment'
+import { injectClass, parseOpeningTagAt } from './HtmlScanner'
+import {
+  type CellRange,
+  exceedsSizeLimit,
+  findTopLevelTables,
+  makePlaceholderPrefix,
+  PLACEHOLDER_SUFFIX,
+  type RowRange,
+  rowKey,
+  sameDimensions,
+  spliceString,
+  type TableRange,
+} from './TableDiff'
+import { type Author, authorAttribution } from './ThreeWayDiff'
+import Utils from './Utils'
+
+/**
+ * Three-way table preprocessing for the genesis-spine merge.
+ *
+ * Inputs: `genesis` (common ancestor), `cpLatest` (counterparty's
+ * accumulated position), `meCurrent` (Me's accumulated position). All
+ * three share a single placeholder nonce so genesis tokenises
+ * identically across both pair-wise word-level analyses.
+ *
+ * Three paths:
+ * 1. **Positional** — all three have the same table count AND each
+ *    positional triple's tableKey is similar enough that 1:1 pairing
+ *    by position is sound. Recurses cellDiff per cell, structural
+ *    layout from genesis.
+ * 2. **Row-structural** — paired triples whose row/cell counts differ.
+ *    Per-table row-level LCS against genesis; recurse on preserved
+ *    rows, emit author-attributed full rows for the rest.
+ * 3. **Multi-table by content** — table counts diverge across inputs.
+ *    Pair tables to genesis via content-LCS, then assign placeholders
+ *    such that each placeholder appears in exactly the inputs that
+ *    contain the underlying table. The word-level merger walks the
+ *    genesis spine and attributes unpaired tables naturally
+ *    (cp-only/me-only/both-agree).
+ */
+
+export interface ThreeWayPreprocessResult {
+  modifiedGenesis: string
+  modifiedCp: string
+  modifiedMe: string
+  placeholderToDiff: Map<string, string>
+}
+
+export type ThreeWayDiffCellFn = (genesisCell: string, cpCell: string, meCell: string) => string
+
+export function preprocessTablesThreeWay(
+  genesis: string,
+  cpLatest: string,
+  meCurrent: string,
+  cellDiff: ThreeWayDiffCellFn
+): ThreeWayPreprocessResult | null {
+  const gTables = findTopLevelTables(genesis)
+  const cTables = findTopLevelTables(cpLatest)
+  const mTables = findTopLevelTables(meCurrent)
+
+  if (gTables.length === 0 && cTables.length === 0 && mTables.length === 0) return null
+
+  for (const t of gTables) if (exceedsSizeLimit(t)) return null
+  for (const t of cTables) if (exceedsSizeLimit(t)) return null
+  for (const t of mTables) if (exceedsSizeLimit(t)) return null
+
+  const placeholderPrefix = makePlaceholderPrefix(genesis, cpLatest, meCurrent)
+
+  if (positionallyAligned(genesis, cpLatest, meCurrent, gTables, cTables, mTables)) {
+    return preprocessAlignedByPosition(
+      genesis,
+      cpLatest,
+      meCurrent,
+      gTables,
+      cTables,
+      mTables,
+      cellDiff,
+      placeholderPrefix
+    )
+  }
+
+  return preprocessByContent(genesis, cpLatest, meCurrent, gTables, cTables, mTables, cellDiff, placeholderPrefix)
+}
+
+function preprocessAlignedByPosition(
+  genesis: string,
+  cpLatest: string,
+  meCurrent: string,
+  gTables: TableRange[],
+  cTables: TableRange[],
+  mTables: TableRange[],
+  cellDiff: ThreeWayDiffCellFn,
+  placeholderPrefix: string
+): ThreeWayPreprocessResult {
+  const pairs: Array<{ g: TableRange; c: TableRange; m: TableRange; diffed: string }> = []
+  for (let i = 0; i < gTables.length; i++) {
+    pairs.push({
+      g: gTables[i],
+      c: cTables[i],
+      m: mTables[i],
+      diffed: diffTableThreeWay(genesis, cpLatest, meCurrent, gTables[i], cTables[i], mTables[i], cellDiff),
+    })
+  }
+  let modifiedGenesis = genesis
+  let modifiedCp = cpLatest
+  let modifiedMe = meCurrent
+  const placeholderToDiff = new Map<string, string>()
+  for (let i = pairs.length - 1; i >= 0; i--) {
+    const placeholder = `${placeholderPrefix}${i}${PLACEHOLDER_SUFFIX}`
+    placeholderToDiff.set(placeholder, pairs[i].diffed)
+    modifiedGenesis = spliceString(modifiedGenesis, pairs[i].g.tableStart, pairs[i].g.tableEnd, placeholder)
+    modifiedCp = spliceString(modifiedCp, pairs[i].c.tableStart, pairs[i].c.tableEnd, placeholder)
+    modifiedMe = spliceString(modifiedMe, pairs[i].m.tableStart, pairs[i].m.tableEnd, placeholder)
+  }
+  return { modifiedGenesis, modifiedCp, modifiedMe, placeholderToDiff }
+}
+
+/**
+ * Multi-table handler. Tables are paired against `genesis` (the spine)
+ * via content-LCS on each of cp and me. Placeholders are assigned so
+ * each appears only in the inputs that actually contain the underlying
+ * table. The word-level merger then attributes them naturally:
+ *
+ *   - paired in genesis+cp+me   → equal in both diffs → emit recursive 3-way diff
+ *   - in cp+me, not in genesis  → both-agree insertion → emit plain
+ *   - in cp only                → cp insertion → ins-cp wrapper (Me didn't take it)
+ *   - in me only                → me insertion → ins-me wrapper
+ *   - in genesis+cp, not me     → me deletion → del-me wrapper
+ *   - in genesis+me, not cp     → cp deletion → del-cp wrapper
+ *   - in genesis only           → both deleted, settled → silent (placeholder content empty)
+ */
+function preprocessByContent(
+  genesis: string,
+  cpLatest: string,
+  meCurrent: string,
+  gTables: TableRange[],
+  cTables: TableRange[],
+  mTables: TableRange[],
+  cellDiff: ThreeWayDiffCellFn,
+  placeholderPrefix: string
+): ThreeWayPreprocessResult {
+  const gKeys = gTables.map(t => tableKey(genesis, t))
+  const cKeys = cTables.map(t => tableKey(cpLatest, t))
+  const mKeys = mTables.map(t => tableKey(meCurrent, t))
+
+  const alignCp = lcsAlign(gKeys, cKeys)
+  const alignMe = lcsAlign(gKeys, mKeys)
+
+  // Maps: genesisIdx → matching cpIdx (-1 if none); cpIdx → matching genesisIdx; etc.
+  const gToCp = new Array<number>(gTables.length).fill(-1)
+  const cpToG = new Array<number>(cTables.length).fill(-1)
+  for (const a of alignCp) {
+    if (a.oldIdx !== null && a.newIdx !== null) {
+      gToCp[a.oldIdx] = a.newIdx
+      cpToG[a.newIdx] = a.oldIdx
+    }
+  }
+  const gToMe = new Array<number>(gTables.length).fill(-1)
+  const meToG = new Array<number>(mTables.length).fill(-1)
+  for (const a of alignMe) {
+    if (a.oldIdx !== null && a.newIdx !== null) {
+      gToMe[a.oldIdx] = a.newIdx
+      meToG[a.newIdx] = a.oldIdx
+    }
+  }
+
+  let nextId = 0
+  const placeholderToDiff = new Map<string, string>()
+  const placeholders = {
+    g: new Array<string | null>(gTables.length).fill(null),
+    c: new Array<string | null>(cTables.length).fill(null),
+    m: new Array<string | null>(mTables.length).fill(null),
+  }
+  const allocate = (): string => `${placeholderPrefix}${nextId++}${PLACEHOLDER_SUFFIX}`
+
+  // For unpaired-in-one-side placeholders, bake author attribution
+  // into the placeholder content — the word-level merger emits tag
+  // tokens (HTML comments) verbatim, so it can't wrap them itself.
+  const wrapWhole = (tag: 'ins' | 'del', author: Author, tableHtml: string): string =>
+    Utils.wrapText(tableHtml, tag, `diff${tag}`, authorAttribution(author))
+
+  // 1. Triples paired in all three (genesis + cp + me) → recursive 3-way diff.
+  for (let gIdx = 0; gIdx < gTables.length; gIdx++) {
+    const cIdx = gToCp[gIdx]
+    const mIdx = gToMe[gIdx]
+    if (cIdx === -1 || mIdx === -1) continue
+    const placeholder = allocate()
+    placeholderToDiff.set(
+      placeholder,
+      diffTableThreeWay(genesis, cpLatest, meCurrent, gTables[gIdx], cTables[cIdx], mTables[mIdx], cellDiff)
+    )
+    placeholders.g[gIdx] = placeholder
+    placeholders.c[cIdx] = placeholder
+    placeholders.m[mIdx] = placeholder
+  }
+
+  // 2. Genesis + CP only (not in Me) → me deletion.
+  for (let gIdx = 0; gIdx < gTables.length; gIdx++) {
+    if (placeholders.g[gIdx] !== null) continue
+    const cIdx = gToCp[gIdx]
+    if (cIdx === -1) continue
+    const placeholder = allocate()
+    placeholderToDiff.set(
+      placeholder,
+      wrapWhole('del', 'me', genesis.slice(gTables[gIdx].tableStart, gTables[gIdx].tableEnd))
+    )
+    placeholders.g[gIdx] = placeholder
+    placeholders.c[cIdx] = placeholder
+  }
+
+  // 3. Genesis + Me only (not in CP) → cp deletion.
+  for (let gIdx = 0; gIdx < gTables.length; gIdx++) {
+    if (placeholders.g[gIdx] !== null) continue
+    const mIdx = gToMe[gIdx]
+    if (mIdx === -1) continue
+    const placeholder = allocate()
+    placeholderToDiff.set(
+      placeholder,
+      wrapWhole('del', 'cp', genesis.slice(gTables[gIdx].tableStart, gTables[gIdx].tableEnd))
+    )
+    placeholders.g[gIdx] = placeholder
+    placeholders.m[mIdx] = placeholder
+  }
+
+  // 4. Genesis only (not in CP, not in Me) → both deleted, settled, silent.
+  //    Placeholder ONLY in genesis; cp and me lack it. The word-level merger
+  //    sees it as "deleted by both" via the genesis-spine fate maps and
+  //    silences it via the settled-deletion rule (empty placeholder content).
+  for (let gIdx = 0; gIdx < gTables.length; gIdx++) {
+    if (placeholders.g[gIdx] !== null) continue
+    const placeholder = allocate()
+    placeholderToDiff.set(placeholder, '')
+    placeholders.g[gIdx] = placeholder
+  }
+
+  // 5. CP + Me both inserted (no genesis) — agreement check. If their
+  //    table content is textually identical, emit plain (settled). Otherwise
+  //    each side gets its own placeholder (cp-only / me-only treatment).
+  for (let cIdx = 0; cIdx < cTables.length; cIdx++) {
+    if (placeholders.c[cIdx] !== null) continue
+    // CP table not paired to genesis. Is there an unpaired Me table with
+    // matching content?
+    const cText = cKeys[cIdx]
+    let mIdx = -1
+    for (let candidate = 0; candidate < mTables.length; candidate++) {
+      if (placeholders.m[candidate] !== null) continue
+      if (meToG[candidate] !== -1) continue
+      if (mKeys[candidate] === cText) {
+        mIdx = candidate
+        break
+      }
+    }
+    if (mIdx === -1) continue
+    // Both inserted the same table content → settled insertion.
+    const placeholder = allocate()
+    placeholderToDiff.set(placeholder, cpLatest.slice(cTables[cIdx].tableStart, cTables[cIdx].tableEnd))
+    placeholders.c[cIdx] = placeholder
+    placeholders.m[mIdx] = placeholder
+  }
+
+  // 6. Remaining CP-only tables (inserted by CP, Me didn't take).
+  for (let cIdx = 0; cIdx < cTables.length; cIdx++) {
+    if (placeholders.c[cIdx] !== null) continue
+    const placeholder = allocate()
+    placeholderToDiff.set(
+      placeholder,
+      wrapWhole('ins', 'cp', cpLatest.slice(cTables[cIdx].tableStart, cTables[cIdx].tableEnd))
+    )
+    placeholders.c[cIdx] = placeholder
+  }
+
+  // 7. Remaining Me-only tables (Me inserted, CP didn't).
+  for (let mIdx = 0; mIdx < mTables.length; mIdx++) {
+    if (placeholders.m[mIdx] !== null) continue
+    const placeholder = allocate()
+    placeholderToDiff.set(
+      placeholder,
+      wrapWhole('ins', 'me', meCurrent.slice(mTables[mIdx].tableStart, mTables[mIdx].tableEnd))
+    )
+    placeholders.m[mIdx] = placeholder
+  }
+
+  // Splice end → start per input.
+  let modifiedGenesis = genesis
+  for (let i = gTables.length - 1; i >= 0; i--) {
+    const p = placeholders.g[i]
+    if (p === null) continue
+    modifiedGenesis = spliceString(modifiedGenesis, gTables[i].tableStart, gTables[i].tableEnd, p)
+  }
+  let modifiedCp = cpLatest
+  for (let i = cTables.length - 1; i >= 0; i--) {
+    const p = placeholders.c[i]
+    if (p === null) continue
+    modifiedCp = spliceString(modifiedCp, cTables[i].tableStart, cTables[i].tableEnd, p)
+  }
+  let modifiedMe = meCurrent
+  for (let i = mTables.length - 1; i >= 0; i--) {
+    const p = placeholders.m[i]
+    if (p === null) continue
+    modifiedMe = spliceString(modifiedMe, mTables[i].tableStart, mTables[i].tableEnd, p)
+  }
+
+  return { modifiedGenesis, modifiedCp, modifiedMe, placeholderToDiff }
+}
+
+const POSITIONAL_PAIR_SIMILARITY_THRESHOLD = 0.5
+
+function positionallyAligned(
+  genesis: string,
+  cpLatest: string,
+  meCurrent: string,
+  gTables: TableRange[],
+  cTables: TableRange[],
+  mTables: TableRange[]
+): boolean {
+  if (gTables.length !== cTables.length || cTables.length !== mTables.length) return false
+  for (let i = 0; i < gTables.length; i++) {
+    const kG = tableKey(genesis, gTables[i])
+    const kC = tableKey(cpLatest, cTables[i])
+    const kM = tableKey(meCurrent, mTables[i])
+    if (textSimilarity(kG, kC) < POSITIONAL_PAIR_SIMILARITY_THRESHOLD) return false
+    if (textSimilarity(kG, kM) < POSITIONAL_PAIR_SIMILARITY_THRESHOLD) return false
+  }
+  return true
+}
+
+function tableKey(html: string, table: TableRange): string {
+  return html.slice(table.tableStart, table.tableEnd).replace(/\s+/g, ' ').trim()
+}
+
+// ────────────────────────────────────────────────────────────────────────────
+// Per-table diff: positional cells or row-level structural change.
+
+function diffTableThreeWay(
+  genesis: string,
+  cpLatest: string,
+  meCurrent: string,
+  tG: TableRange,
+  tC: TableRange,
+  tM: TableRange,
+  cellDiff: ThreeWayDiffCellFn
+): string {
+  if (sameDimensions(tG, tC) && sameDimensions(tC, tM)) {
+    return diffTablePositional(genesis, cpLatest, meCurrent, tG, tC, tM, cellDiff)
+  }
+  return diffTableStructural(genesis, cpLatest, meCurrent, tG, tC, tM, cellDiff)
+}
+
+function diffTablePositional(
+  genesis: string,
+  cpLatest: string,
+  meCurrent: string,
+  tG: TableRange,
+  tC: TableRange,
+  tM: TableRange,
+  cellDiff: ThreeWayDiffCellFn
+): string {
+  // Walk genesis's table scaffolding verbatim — it's the common
+  // ancestor. Cells are merged 3-way via cellDiff. Choosing genesis as
+  // the spine keeps the table structure stable across both pair-wise
+  // diffs that the word-level merger will see.
+  const out: string[] = []
+  let cursor = tG.tableStart
+  for (let r = 0; r < tG.rows.length; r++) {
+    const rG = tG.rows[r]
+    const rC = tC.rows[r]
+    const rM = tM.rows[r]
+    for (let c = 0; c < rG.cells.length; c++) {
+      const cG = rG.cells[c]
+      const cC = rC.cells[c]
+      const cM = rM.cells[c]
+      out.push(genesis.slice(cursor, cG.contentStart))
+      out.push(
+        cellDiff(
+          genesis.slice(cG.contentStart, cG.contentEnd),
+          cpLatest.slice(cC.contentStart, cC.contentEnd),
+          meCurrent.slice(cM.contentStart, cM.contentEnd)
+        )
+      )
+      cursor = cG.contentEnd
+    }
+  }
+  out.push(genesis.slice(cursor, tG.tableEnd))
+  return out.join('')
+}
+
+/**
+ * Row-level genesis-spine merge for tables with diverging row/cell
+ * counts.
+ *
+ * 1. Align cp rows to genesis rows (alignCp), me rows to genesis rows
+ *    (alignMe), each via row-LCS over rowKeys.
+ * 2. Per genesis row: cpFate (kept / deleted), meFate (kept / deleted).
+ *    Both kept → recurse cell diff (with structural-change cell handling
+ *    falling back to me-attribution Replace per the documented
+ *    limitation). One kept, other deleted → emit author-attributed full
+ *    row. Both deleted → silent.
+ * 3. Off-spine rows: cp-only inserted rows + me-only inserted rows.
+ *    Check for content agreement at the same boundary; agreed
+ *    insertions emit plain.
+ */
+function diffTableStructural(
+  genesis: string,
+  cpLatest: string,
+  meCurrent: string,
+  tG: TableRange,
+  tC: TableRange,
+  tM: TableRange,
+  cellDiff: ThreeWayDiffCellFn
+): string {
+  const gKeys = tG.rows.map(r => rowKey(genesis, r))
+  const cKeys = tC.rows.map(r => rowKey(cpLatest, r))
+  const mKeys = tM.rows.map(r => rowKey(meCurrent, r))
+
+  const alignCp = lcsAlign(gKeys, cKeys)
+  const alignMe = lcsAlign(gKeys, mKeys)
+
+  // genesisIdx → matching cpIdx (-1 if cp deleted this row)
+  const gToCp = new Array<number>(tG.rows.length).fill(-1)
+  for (const a of alignCp) {
+    if (a.oldIdx !== null && a.newIdx !== null) gToCp[a.oldIdx] = a.newIdx
+  }
+  const gToMe = new Array<number>(tG.rows.length).fill(-1)
+  for (const a of alignMe) {
+    if (a.oldIdx !== null && a.newIdx !== null) gToMe[a.oldIdx] = a.newIdx
+  }
+
+  // Off-spine row collections: cp rows with no genesis counterpart, me rows with no genesis counterpart.
+  // Keyed by "the genesis row index they should appear before" so emission interleaves correctly.
+  const cpInsAt = collectInsertedRowsAtBoundary(alignCp, tG.rows.length)
+  const meInsAt = collectInsertedRowsAtBoundary(alignMe, tG.rows.length)
+
+  const out: string[] = []
+  out.push(tableHeaderSlice(genesis, tG))
+
+  const emitBoundaryInsertions = (b: number) => {
+    const cIdxs = cpInsAt.get(b) ?? []
+    const mIdxs = meInsAt.get(b) ?? []
+    if (cIdxs.length === 0 && mIdxs.length === 0) return
+    // Detect settled insertions (cp and me both inserted the same row content).
+    // Pair by content key, in order of appearance.
+    const remainingMe = new Set(mIdxs)
+    for (const cIdx of cIdxs) {
+      const cText = cKeys[cIdx]
+      let agreedMeIdx: number | undefined
+      for (const mIdx of remainingMe) {
+        if (mKeys[mIdx] === cText) {
+          agreedMeIdx = mIdx
+          break
+        }
+      }
+      if (agreedMeIdx !== undefined) {
+        remainingMe.delete(agreedMeIdx)
+        // Settled insertion — emit cp's row verbatim, unmarked.
+        out.push(cpLatest.slice(tC.rows[cIdx].rowStart, tC.rows[cIdx].rowEnd))
+      } else {
+        out.push(emitFullRowAttributed(cpLatest, tC.rows[cIdx], 'ins', 'cp'))
+      }
+    }
+    for (const mIdx of remainingMe) {
+      out.push(emitFullRowAttributed(meCurrent, tM.rows[mIdx], 'ins', 'me'))
+    }
+  }
+
+  for (let g = 0; g < tG.rows.length; g++) {
+    emitBoundaryInsertions(g)
+
+    const cIdx = gToCp[g]
+    const mIdx = gToMe[g]
+    const cpDel = cIdx === -1
+    const meDel = mIdx === -1
+
+    if (!cpDel && !meDel) {
+      // Both kept — recurse cell-level diff against this row triple.
+      out.push(emitPreservedRow(genesis, cpLatest, meCurrent, tG.rows[g], tC.rows[cIdx], tM.rows[mIdx], cellDiff))
+    } else if (cpDel && meDel) {
+      // Both deleted — silent (settled).
+    } else if (cpDel) {
+      // CP dropped, Me kept → emit Me's row attributed as cp-deletion. The
+      // content shown is what Me has; the styling tells the reader CP
+      // wanted it gone.
+      out.push(emitFullRowAttributed(meCurrent, tM.rows[mIdx], 'del', 'cp'))
+    } else {
+      // Me dropped, CP kept → emit CP's row attributed as me-deletion.
+      out.push(emitFullRowAttributed(cpLatest, tC.rows[cIdx], 'del', 'me'))
+    }
+  }
+  emitBoundaryInsertions(tG.rows.length)
+  out.push(tableFooterSlice(genesis, tG))
+  return out.join('')
+}
+
+function emitPreservedRow(
+  genesis: string,
+  cpLatest: string,
+  meCurrent: string,
+  rG: RowRange,
+  rC: RowRange,
+  rM: RowRange,
+  cellDiff: ThreeWayDiffCellFn
+): string {
+  if (rG.cells.length === rC.cells.length && rC.cells.length === rM.cells.length) {
+    // Same cell counts — positional cell diff.
+    const out: string[] = []
+    let cursor = rG.rowStart
+    for (let c = 0; c < rG.cells.length; c++) {
+      const cG = rG.cells[c]
+      const cC = rC.cells[c]
+      const cM = rM.cells[c]
+      out.push(genesis.slice(cursor, cG.contentStart))
+      out.push(
+        cellDiff(
+          genesis.slice(cG.contentStart, cG.contentEnd),
+          cpLatest.slice(cC.contentStart, cC.contentEnd),
+          meCurrent.slice(cM.contentStart, cM.contentEnd)
+        )
+      )
+      cursor = cG.contentEnd
+    }
+    out.push(genesis.slice(cursor, rG.rowEnd))
+    return out.join('')
+  }
+  // Cell-count mismatch within a preserved row — cell-level structural
+  // change deferred. Fall back to me-attributed Replace (genesis row
+  // removed, me row inserted). Lossy for CP within that row.
+  return emitFullRowAttributed(genesis, rG, 'del', 'me') + emitFullRowAttributed(meCurrent, rM, 'ins', 'me')
+}
+
+/**
+ * Returns map "genesis-row-boundary → list of new-side row indices
+ * inserted at that boundary". Mirrors the word-level boundary collection
+ * but at the row scale.
+ */
+function collectInsertedRowsAtBoundary(
+  align: ReturnType<typeof lcsAlign>,
+  genesisRowCount: number
+): Map<number, number[]> {
+  const out = new Map<number, number[]>()
+  let nextGenesisBoundary = genesisRowCount
+  const pending: number[] = []
+  // Walk in reverse so nextGenesisBoundary tracks the next preserved row
+  // we'll encounter; flush pending unpaired new rows at the appropriate
+  // genesis boundary.
+  for (let i = align.length - 1; i >= 0; i--) {
+    const a = align[i]
+    if (a.oldIdx !== null) {
+      if (pending.length > 0) {
+        const existing = out.get(nextGenesisBoundary) ?? []
+        existing.unshift(...pending.toReversed())
+        out.set(nextGenesisBoundary, existing)
+        pending.length = 0
+      }
+      nextGenesisBoundary = a.oldIdx
+    } else if (a.newIdx !== null) {
+      pending.push(a.newIdx)
+    }
+  }
+  if (pending.length > 0) {
+    const existing = out.get(nextGenesisBoundary) ?? []
+    existing.unshift(...pending.toReversed())
+    out.set(nextGenesisBoundary, existing)
+  }
+  return out
+}
+
+function tableHeaderSlice(html: string, table: TableRange): string {
+  const firstRow = table.rows[0]
+  if (!firstRow) return html.slice(table.tableStart, table.tableEnd - '</table>'.length)
+  return html.slice(table.tableStart, firstRow.rowStart)
+}
+
+function tableFooterSlice(html: string, table: TableRange): string {
+  const lastRow = table.rows[table.rows.length - 1]
+  if (!lastRow) return '</table>'
+  return html.slice(lastRow.rowEnd, table.tableEnd)
+}
+
+/**
+ * Emit a row fully attributed to one author. Wraps `<tr>` and each
+ * `<td>` with the author's diffins/diffdel class and `data-author`
+ * attribute; wraps cell content with an inner `<ins>`/`<del>` matching
+ * the word-level emission shape.
+ */
+function emitFullRowAttributed(html: string, row: RowRange, kind: 'ins' | 'del', author: Author): string {
+  const trOpening = parseOpeningTagAt(html, row.rowStart)
+  if (!trOpening) return html.slice(row.rowStart, row.rowEnd)
+  const trWithAttrs = injectAuthorAttribution(html.slice(row.rowStart, trOpening.end), kind, author)
+
+  const out: string[] = [trWithAttrs]
+  let cursor = trOpening.end
+  for (const cell of row.cells) {
+    out.push(html.slice(cursor, cell.cellStart))
+    out.push(emitFullCellAttributed(html, cell, kind, author))
+    cursor = cell.cellEnd
+  }
+  out.push(html.slice(cursor, row.rowEnd))
+  return out.join('')
+}
+
+function emitFullCellAttributed(html: string, cell: CellRange, kind: 'ins' | 'del', author: Author): string {
+  const tdOpening = parseOpeningTagAt(html, cell.cellStart)
+  if (!tdOpening) return html.slice(cell.cellStart, cell.cellEnd)
+  const tdWithAttrs = injectAuthorAttribution(html.slice(cell.cellStart, tdOpening.end), kind, author)
+  const innerContent = html.slice(cell.contentStart, cell.contentEnd)
+  const innerWrapped =
+    innerContent.trim().length === 0
+      ? innerContent
+      : Utils.wrapText(innerContent, kind, `diff${kind}`, authorAttribution(author))
+  const closing = html.slice(cell.contentEnd, cell.cellEnd)
+  return tdWithAttrs + innerWrapped + closing
+}
+
+function injectAuthorAttribution(openingTag: string, kind: 'ins' | 'del', author: Author): string {
+  const meta = authorAttribution(author)
+  const tagWithClass = injectClass(openingTag, `diff${kind} ${meta.extraClasses}`)
+  return injectDataAttrs(tagWithClass, meta.dataAttrs ?? {})
+}
+
+function injectDataAttrs(openingTag: string, dataAttrs: Readonly<Record<string, string>>): string {
+  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}>`
+}

package/src/Utils.ts

@@ -32,8 +32,39 @@ export function stripTagAttributes(word: string): string {
   return word
 }
 
-export function wrapText(text: string, tagName: string, cssClass: string): string {
-  return `<${tagName} class='${cssClass}'>${text}</${tagName}>`
+/**
+ * Optional metadata attached to a wrapped tag. Used by `executeThreeWay`
+ * to colour diff segments with their author (CP vs Me) via extra classes
+ * and `data-*` attributes; the two-way path passes nothing and gets the
+ * unchanged historical output.
+ */
+export interface WrapMetadata {
+  /** Space-separated classes appended after `cssClass`. */
+  extraClasses?: string
+  /** `data-*` attribute map, keyed by the attribute name *without* the `data-` prefix. */
+  dataAttrs?: Readonly<Record<string, string>>
+}
+
+export function wrapText(text: string, tagName: string, cssClass: string, metadata?: WrapMetadata): string {
+  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`.
+ */
+export function composeTagAttributes(cssClass: string, metadata: WrapMetadata): string {
+  const classes = metadata.extraClasses ? `${cssClass} ${metadata.extraClasses}` : cssClass
+  let out = ` class='${classes}'`
+  if (metadata.dataAttrs) {
+    for (const key of Object.keys(metadata.dataAttrs)) {
+      out += ` data-${key}='${metadata.dataAttrs[key]}'`
+    }
+  }
+  return out
 }
 
 export function isStartOfTag(val: string): boolean {
@@ -85,6 +116,7 @@ export default {
   isTag,
   stripTagAttributes,
   wrapText,
+  composeTagAttributes,
   isStartOfTag,
   isEndOfTag,
   isStartOfEntity,