@createiq/htmldiff 1.0.5-beta.3 → 1.0.5

package/dist/HtmlDiff.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"HtmlDiff.cjs","names":["Utils","Utils","Utils"],"sources":["../src/Match.ts","../src/Utils.ts","../src/MatchFinder.ts","../src/Operation.ts","../src/TableDiff.ts","../src/WordSplitter.ts","../src/HtmlDiff.ts"],"sourcesContent":["export default class Match {\n  private _startInOld: number\n  private _startInNew: number\n  private _size: number\n\n  constructor(startInOld: number, startInNew: number, size: number) {\n    this._startInOld = startInOld\n    this._startInNew = startInNew\n    this._size = size\n  }\n\n  get startInOld() {\n    return this._startInOld\n  }\n\n  get startInNew() {\n    return this._startInNew\n  }\n\n  get size() {\n    return this._size\n  }\n\n  get endInOld() {\n    return this._startInOld + this._size\n  }\n\n  get endInNew() {\n    return this._startInNew + this._size\n  }\n}\n","const openingTagRegex = /^\\s*<[^>]+>\\s*$/\nconst closingTagTexRegex = /^\\s*<\\/[^>]+>\\s*$/\nconst tagWordRegex = /<[^\\s>]+/\nconst whitespaceRegex = /^(\\s|&nbsp;)+$/\nconst wordRegex = /[\\w#@]+/\nconst tagRegex = /<\\/?(?<name>[^\\s/>]+)[^>]*>/\n\nconst SpecialCaseWordTags: readonly string[] = ['<img']\n\nexport function isTag(item: string): boolean {\n  if (SpecialCaseWordTags.some(re => item?.startsWith(re))) {\n    return false\n  }\n\n  return isOpeningTag(item) || isClosingTag(item)\n}\n\nfunction isOpeningTag(item: string): boolean {\n  return openingTagRegex.test(item)\n}\n\nfunction isClosingTag(item: string): boolean {\n  return closingTagTexRegex.test(item)\n}\n\nexport function stripTagAttributes(word: string): string {\n  const match = tagWordRegex.exec(word)\n  if (match) {\n    return `${match[0]}${word.endsWith('/>') ? '/>' : '>'}`\n  }\n\n  return word\n}\n\nexport function wrapText(text: string, tagName: string, cssClass: string): string {\n  return `<${tagName} class='${cssClass}'>${text}</${tagName}>`\n}\n\nexport function isStartOfTag(val: string): boolean {\n  return val === '<'\n}\n\nexport function isEndOfTag(val: string): boolean {\n  return val === '>'\n}\n\nexport function isStartOfEntity(val: string): boolean {\n  return val === '&'\n}\n\nexport function isEndOfEntity(val: string): boolean {\n  return val === ';'\n}\n\nexport function isWhiteSpace(value: string): boolean {\n  return whitespaceRegex.test(value)\n}\n\nexport function stripAnyAttributes(word: string): string {\n  if (isTag(word)) {\n    return stripTagAttributes(word)\n  }\n\n  return word\n}\n\nexport function isWord(text: string): boolean {\n  return wordRegex.test(text)\n}\n\nexport function getTagName(word: string | null): string {\n  if (word === null) {\n    return ''\n  }\n\n  const match = tagRegex.exec(word)\n  if (match) {\n    return match.groups?.name.toLowerCase() ?? match[1].toLowerCase()\n  }\n\n  return ''\n}\n\nexport default {\n  isTag,\n  stripTagAttributes,\n  wrapText,\n  isStartOfTag,\n  isEndOfTag,\n  isStartOfEntity,\n  isEndOfEntity,\n  isWhiteSpace,\n  stripAnyAttributes,\n  isWord,\n  getTagName,\n}\n","import Match from './Match'\nimport type MatchOptions from './MatchOptions'\nimport Utils from './Utils'\n\n/**\n * Finds the longest match in given texts. It uses indexing with fixed granularity that is used to compare blocks of text.\n */\nexport default class MatchFinder {\n  private oldWords: string[]\n  private newWords: string[]\n  private startInOld: number\n  private endInOld: number\n  private startInNew: number\n  private endInNew: number\n  private wordIndices: { [word: string]: number[] } = {}\n  private options: MatchOptions\n\n  constructor(\n    oldWords: string[],\n    newWords: string[],\n    startInOld: number,\n    endInOld: number,\n    startInNew: number,\n    endInNew: number,\n    options: MatchOptions\n  ) {\n    this.oldWords = oldWords\n    this.newWords = newWords\n    this.startInOld = startInOld\n    this.endInOld = endInOld\n    this.startInNew = startInNew\n    this.endInNew = endInNew\n    this.options = options\n  }\n\n  private indexNewWords() {\n    this.wordIndices = {}\n    const block: string[] = []\n    for (let i = this.startInNew; i < this.endInNew; i++) {\n      // if word is a tag, we should ignore attributes as attribute changes are not supported (yet)\n      const word = this.normalizeForIndex(this.newWords[i])\n      const key = MatchFinder.putNewWord(block, word, this.options.blockSize)\n\n      if (key === null) {\n        continue\n      }\n\n      if (!this.wordIndices[key]) {\n        this.wordIndices[key] = []\n      }\n      this.wordIndices[key].push(i)\n    }\n  }\n\n  private static putNewWord(block: string[], word: string, blockSize: number): string | null {\n    block.push(word)\n\n    if (block.length > blockSize) {\n      block.shift()\n    }\n\n    if (block.length !== blockSize) {\n      return null\n    }\n\n    return block.join('')\n  }\n\n  private normalizeForIndex(word: string): string {\n    const output = Utils.stripAnyAttributes(word)\n    if (this.options.ignoreWhitespaceDifferences && Utils.isWhiteSpace(output)) {\n      return ' '\n    }\n\n    return output\n  }\n\n  findMatch(): Match | null {\n    this.indexNewWords()\n    this.removeRepeatingWords()\n\n    let hasIndices = false\n    for (const _key in this.wordIndices) {\n      hasIndices = true\n      break\n    }\n    if (!hasIndices) {\n      return null\n    }\n\n    let bestMatchInOld = this.startInOld\n    let bestMatchInNew = this.startInNew\n    let bestMatchSize = 0\n\n    let matchLengthAt: Map<number, number> = new Map()\n    const block: string[] = []\n\n    for (let indexInOld = this.startInOld; indexInOld < this.endInOld; indexInOld++) {\n      const word = this.normalizeForIndex(this.oldWords[indexInOld])\n      const index = MatchFinder.putNewWord(block, word, this.options.blockSize)\n\n      if (index === null) {\n        continue\n      }\n\n      const newMatchLengthAt: Map<number, number> = new Map()\n\n      if (!this.wordIndices[index]) {\n        matchLengthAt = newMatchLengthAt\n        continue\n      }\n\n      for (const indexInNew of this.wordIndices[index]) {\n        // biome-ignore lint/style/noNonNullAssertion: This is safe as guarded by has()\n        const newMatchLength = (matchLengthAt.has(indexInNew - 1) ? matchLengthAt.get(indexInNew - 1)! : 0) + 1\n        newMatchLengthAt.set(indexInNew, newMatchLength)\n\n        if (newMatchLength > bestMatchSize) {\n          bestMatchInOld = indexInOld - newMatchLength - this.options.blockSize + 2\n          bestMatchInNew = indexInNew - newMatchLength - this.options.blockSize + 2\n          bestMatchSize = newMatchLength\n        }\n      }\n\n      matchLengthAt = newMatchLengthAt\n    }\n\n    return bestMatchSize !== 0\n      ? new Match(bestMatchInOld, bestMatchInNew, bestMatchSize + this.options.blockSize - 1)\n      : null\n  }\n\n  /**\n   * This method removes words that occur too many times. This way it reduces total count of comparison operations\n   * and as result the diff algorithm takes less time. But the side effect is that it may detect false differences of\n   * the repeating words.\n   * @private\n   */\n  private removeRepeatingWords() {\n    const threshold = this.newWords.length * this.options.repeatingWordsAccuracy\n    const repeatingWords = Object.entries(this.wordIndices)\n      .filter(([, indices]) => indices.length > threshold)\n      .map(([word]) => word)\n\n    for (const w of repeatingWords) {\n      delete this.wordIndices[w]\n    }\n  }\n}\n","import type Action from './Action'\n\nexport default class Operation {\n  action: Action\n  startInOld: number\n  endInOld: number\n  startInNew: number\n  endInNew: number\n\n  constructor(action: Action, startInOld: number, endInOld: number, startInNew: number, endInNew: number) {\n    this.action = action\n    this.startInOld = startInOld\n    this.endInOld = endInOld\n    this.startInNew = startInNew\n    this.endInNew = endInNew\n  }\n}\n","/**\n * Table-aware preprocessing for HtmlDiff.\n *\n * The word-level diff alone matches longest-common-subsequences across cell\n * boundaries and produces structurally wrong output for table edits — it\n * shuffles content between cells, introduces phantom `<td>`s, and provides\n * no signal that an entire row or column was added/deleted. We pre-process\n * the inputs to give Word-style results:\n *\n *   • When dimensions match (same row count, same cell count per row), we\n *     diff cell content positionally so cross-cell shifts produce one\n *     independent del/ins per cell.\n *   • When dimensions don't match (added/deleted row, added/deleted column),\n *     we run a row-level LCS to identify structurally added/deleted rows,\n *     then within preserved rows a cell-level LCS to identify added/deleted\n *     columns. Structurally added rows/cells get `class='diffins'` on the\n *     `<tr>`/`<td>`; deleted ones get `class='diffdel'`. Preserved cells\n *     fall back to a content diff via the recursive HtmlDiff callback.\n *\n * Tables are spliced out into placeholders before the main diff runs and\n * spliced back in after, so the surrounding (non-table) content is diffed\n * by the normal word-level pipeline.\n */\n\ninterface CellRange {\n  /** Start index of the cell's opening tag in the original html. */\n  cellStart: number\n  /** Index just past the cell's closing tag. */\n  cellEnd: number\n  /** Cell content range — the slice we feed into the cell-level diff. */\n  contentStart: number\n  contentEnd: number\n}\n\ninterface RowRange {\n  rowStart: number\n  rowEnd: number\n  cells: CellRange[]\n}\n\ninterface TableRange {\n  tableStart: number\n  tableEnd: number\n  rows: RowRange[]\n}\n\nexport interface PreprocessResult {\n  modifiedOld: string\n  modifiedNew: string\n  /** Maps placeholder marker → already-diffed table HTML to splice back in. */\n  placeholderToDiff: Map<string, string>\n}\n\n// HTML comments survive WordSplitter as a single atomic token and are\n// treated as equal on both sides, so they pass through the diff\n// untouched and are easy to substitute back later. The nonce is generated\n// per call so a previously-diffed document being re-diffed (or any input\n// that legitimately contains an `<!--HTMLDIFF_TABLE_*-->` comment) can't\n// collide with the placeholder we substitute. We additionally regenerate\n// the nonce if it appears in either input.\nconst PLACEHOLDER_PREFIX_BASE = '<!--HTMLDIFF_TABLE_'\nconst PLACEHOLDER_SUFFIX = '-->'\n\n/**\n * Hard cap on table dimensions handled by the structural-aware path.\n * The row-LCS is O(rows²), the per-row cell-LCS is O(cells²), and each\n * comparison string-equals row content (potentially many KB). Without a\n * cap, a several-thousand-row table can pin a CPU for seconds. Tables\n * larger than this fall through to the word-level diff, which scales\n * linearly. Tuned to comfortably cover real-world ISDA schedules\n * (which routinely have 1000+ rows).\n */\nconst MAX_TABLE_ROWS = 1500\nconst MAX_TABLE_CELLS_PER_ROW = 200\n\nfunction makePlaceholderPrefix(oldHtml: string, newHtml: string): string {\n  // 4 random bytes → 8 hex chars → 16^8 ≈ 4.3 billion combinations. We\n  // also retry if the generated nonce happens to occur in either input.\n  // Using `Math.random` here is fine: we're not defending against a\n  // malicious adversary, just avoiding accidental collisions.\n  for (let attempt = 0; attempt < 8; attempt++) {\n    const nonce = Math.floor(Math.random() * 0xffffffff)\n      .toString(16)\n      .padStart(8, '0')\n    const prefix = `${PLACEHOLDER_PREFIX_BASE}${nonce}_`\n    if (!oldHtml.includes(prefix) && !newHtml.includes(prefix)) {\n      return prefix\n    }\n  }\n  // Astronomically unlikely. Falling back to a counter ensures progress\n  // rather than an infinite loop, and any remaining collision will simply\n  // surface as a malformed diff that the caller can detect.\n  return `${PLACEHOLDER_PREFIX_BASE}fallback_${Date.now()}_`\n}\n\ntype DiffCellFn = (oldCellContent: string, newCellContent: string) => string\n\n/**\n * Diffs every paired-by-position table in the inputs and replaces each\n * source table with a placeholder, returning the modified inputs plus the\n * placeholder→diff mapping. Returns null when there are no tables to\n * preprocess or the table counts don't line up.\n */\nexport function preprocessTables(oldHtml: string, newHtml: string, diffCell: DiffCellFn): PreprocessResult | null {\n  const oldTables = findTopLevelTables(oldHtml)\n  const newTables = findTopLevelTables(newHtml)\n\n  if (oldTables.length === 0 && newTables.length === 0) return null\n  if (oldTables.length !== newTables.length) return null\n\n  // Bail out on pathologically large tables — see MAX_TABLE_ROWS comment.\n  for (let i = 0; i < oldTables.length; i++) {\n    if (exceedsSizeLimit(oldTables[i]) || exceedsSizeLimit(newTables[i])) return null\n  }\n\n  const pairs: Array<{ oldTable: TableRange; newTable: TableRange; diffed: string }> = []\n  for (let i = 0; i < oldTables.length; i++) {\n    pairs.push({\n      oldTable: oldTables[i],\n      newTable: newTables[i],\n      diffed: diffTable(oldHtml, newHtml, oldTables[i], newTables[i], diffCell),\n    })\n  }\n\n  // Splice from end → start so earlier offsets stay valid.\n  let modifiedOld = oldHtml\n  let modifiedNew = newHtml\n  const placeholderPrefix = makePlaceholderPrefix(oldHtml, newHtml)\n  const placeholderToDiff = new Map<string, string>()\n  for (let i = pairs.length - 1; i >= 0; i--) {\n    const placeholder = `${placeholderPrefix}${i}${PLACEHOLDER_SUFFIX}`\n    placeholderToDiff.set(placeholder, pairs[i].diffed)\n    modifiedOld = spliceString(modifiedOld, pairs[i].oldTable.tableStart, pairs[i].oldTable.tableEnd, placeholder)\n    modifiedNew = spliceString(modifiedNew, pairs[i].newTable.tableStart, pairs[i].newTable.tableEnd, placeholder)\n  }\n\n  return { modifiedOld, modifiedNew, placeholderToDiff }\n}\n\nexport function restoreTablePlaceholders(diffOutput: string, placeholderToDiff: Map<string, string>): string {\n  let result = diffOutput\n  for (const [placeholder, html] of placeholderToDiff) {\n    result = result.split(placeholder).join(html)\n  }\n  return result\n}\n\nfunction spliceString(s: string, start: number, end: number, replacement: string): string {\n  return s.slice(0, start) + replacement + s.slice(end)\n}\n\nfunction exceedsSizeLimit(table: TableRange): boolean {\n  if (table.rows.length > MAX_TABLE_ROWS) return true\n  for (const row of table.rows) {\n    if (row.cells.length > MAX_TABLE_CELLS_PER_ROW) return true\n  }\n  return false\n}\n\nfunction diffTable(\n  oldHtml: string,\n  newHtml: string,\n  oldTable: TableRange,\n  newTable: TableRange,\n  diffCell: DiffCellFn\n): string {\n  if (sameDimensions(oldTable, newTable)) {\n    return diffPositionalTable(oldHtml, newHtml, oldTable, newTable, diffCell)\n  }\n  if (oldTable.rows.length === newTable.rows.length) {\n    // Same row count, different cell counts: column add/delete only.\n    // Aligning rows positionally avoids the LCS row-key mismatch that\n    // happens when rows have different cell counts.\n    return diffSameRowCountTable(oldHtml, newHtml, oldTable, newTable, diffCell)\n  }\n  return diffStructurallyAlignedTable(oldHtml, newHtml, oldTable, newTable, diffCell)\n}\n\nfunction diffSameRowCountTable(\n  oldHtml: string,\n  newHtml: string,\n  oldTable: TableRange,\n  newTable: TableRange,\n  diffCell: DiffCellFn\n): string {\n  // Walk the new table verbatim (preserving `<thead>`/`<tbody>` wrappers,\n  // whitespace, etc.) and substitute each row's content with the diffed\n  // form. The cursor-based emission keeps everything between rows intact.\n  const out: string[] = []\n  let cursor = newTable.tableStart\n  let r = 0\n  while (r < newTable.rows.length) {\n    const merge = detectVerticalMerge(oldHtml, newHtml, oldTable, newTable, r)\n    if (merge) {\n      out.push(newHtml.slice(cursor, newTable.rows[r].rowStart))\n      out.push(merge.diff)\n      cursor = newTable.rows[r + merge.span - 1].rowEnd\n      r += merge.span\n      continue\n    }\n    const split = detectVerticalSplit(oldHtml, newHtml, oldTable, newTable, r)\n    if (split) {\n      out.push(newHtml.slice(cursor, newTable.rows[r].rowStart))\n      out.push(split.diff)\n      cursor = newTable.rows[r + split.span - 1].rowEnd\n      r += split.span\n      continue\n    }\n    const newRow = newTable.rows[r]\n    out.push(newHtml.slice(cursor, newRow.rowStart))\n    out.push(diffPreservedRow(oldHtml, newHtml, oldTable.rows[r], newRow, diffCell))\n    cursor = newRow.rowEnd\n    r++\n  }\n  out.push(newHtml.slice(cursor, newTable.tableEnd))\n  return out.join('')\n}\n\n/**\n * Detects a vertical merge starting at row `r`: new row R has a single\n * cell with rowspan=K (and any colspan ≥ 1), with rows R+1..R+K-1 empty\n * in new. Old rows R..R+K-1 must have a logical column width equal to\n * the new cell's colspan and contain no rowspan'd cells of their own.\n * This handles both single-column merges (old rows are 1-cell, new cell\n * rowspan=K) and rectangular merges (e.g. 2×2 merge into a single\n * colspan=2 rowspan=2 cell). Output: emit the merged cell with\n * `class='mod rowspan'` and the empty trailing rows unchanged.\n */\nfunction detectVerticalMerge(\n  oldHtml: string,\n  newHtml: string,\n  oldTable: TableRange,\n  newTable: TableRange,\n  r: number\n): { diff: string; span: number } | null {\n  const newRow = newTable.rows[r]\n  if (newRow.cells.length !== 1) return null\n  const cell = newRow.cells[0]\n  const span = getRowspan(newHtml, cell)\n  if (span <= 1) return null\n  if (r + span > newTable.rows.length) return null\n\n  const colspan = getColspan(newHtml, cell)\n\n  for (let k = 1; k < span; k++) {\n    if (newTable.rows[r + k].cells.length !== 0) return null\n  }\n  for (let k = 0; k < span; k++) {\n    const oldRow = oldTable.rows[r + k]\n    if (!oldRow) return null\n    // The absorbed region's logical width must match the merged cell's\n    // colspan; otherwise this isn't a clean rectangular merge and we let\n    // the caller fall through.\n    if (sumColspans(oldHtml, oldRow.cells) !== colspan) return null\n    for (const c of oldRow.cells) {\n      if (getRowspan(oldHtml, c) !== 1) return null\n    }\n  }\n\n  const out: string[] = []\n  out.push(rowHeaderSlice(newHtml, newRow))\n  out.push(emitSpanChangedCell(newHtml, cell, 'rowspan'))\n  out.push('</tr>')\n  for (let k = 1; k < span; k++) {\n    out.push(emitEmptyRow(newHtml, newTable.rows[r + k]))\n  }\n  return { diff: out.join(''), span }\n}\n\n/**\n * Detects a vertical split starting at row `r`: old row R has a single\n * cell with rowspan=K, old rows R+1..R+K-1 are empty. New rows R..R+K-1\n * each have a single cell. Output: emit each new row with the new cell\n * tagged `class='mod rowspan'`.\n */\nfunction detectVerticalSplit(\n  oldHtml: string,\n  newHtml: string,\n  oldTable: TableRange,\n  newTable: TableRange,\n  r: number\n): { diff: string; span: number } | null {\n  const oldRow = oldTable.rows[r]\n  if (oldRow.cells.length !== 1) return null\n  const oldCell = oldRow.cells[0]\n  const span = getRowspan(oldHtml, oldCell)\n  if (span <= 1) return null\n  if (r + span > oldTable.rows.length) return null\n\n  const colspan = getColspan(oldHtml, oldCell)\n\n  for (let k = 1; k < span; k++) {\n    if (oldTable.rows[r + k].cells.length !== 0) return null\n  }\n  for (let k = 0; k < span; k++) {\n    const newRow = newTable.rows[r + k]\n    if (!newRow) return null\n    // New rows must collectively cover the same logical width as the old\n    // merged cell's colspan, with no rowspan'd cells of their own.\n    if (sumColspans(newHtml, newRow.cells) !== colspan) return null\n    for (const c of newRow.cells) {\n      if (getRowspan(newHtml, c) !== 1) return null\n    }\n  }\n\n  const out: string[] = []\n  for (let k = 0; k < span; k++) {\n    const newRow = newTable.rows[r + k]\n    out.push(rowHeaderSlice(newHtml, newRow))\n    for (const c of newRow.cells) {\n      out.push(emitSpanChangedCell(newHtml, c, 'rowspan'))\n    }\n    out.push('</tr>')\n  }\n  return { diff: out.join(''), span }\n}\n\nfunction emitEmptyRow(html: string, row: RowRange): string {\n  // Re-emit the source row's `<tr ...></tr>` verbatim.\n  return html.slice(row.rowStart, row.rowEnd)\n}\n\nfunction sameDimensions(a: TableRange, b: TableRange): boolean {\n  if (a.rows.length !== b.rows.length) return false\n  for (let i = 0; i < a.rows.length; i++) {\n    if (a.rows[i].cells.length !== b.rows[i].cells.length) return false\n  }\n  return true\n}\n\n/**\n * Same-dimension path: walk the new table verbatim and substitute each\n * cell content range with the cell-level diff. The surrounding\n * `<thead>`/`<tbody>`/whitespace passes through untouched.\n */\nfunction diffPositionalTable(\n  oldHtml: string,\n  newHtml: string,\n  oldTable: TableRange,\n  newTable: TableRange,\n  diffCell: DiffCellFn\n): string {\n  const out: string[] = []\n  let cursor = newTable.tableStart\n  for (let r = 0; r < newTable.rows.length; r++) {\n    const oldRow = oldTable.rows[r]\n    const newRow = newTable.rows[r]\n    for (let c = 0; c < newRow.cells.length; c++) {\n      const oldCell = oldRow.cells[c]\n      const newCell = newRow.cells[c]\n      out.push(newHtml.slice(cursor, newCell.contentStart))\n      out.push(\n        diffCell(\n          oldHtml.slice(oldCell.contentStart, oldCell.contentEnd),\n          newHtml.slice(newCell.contentStart, newCell.contentEnd)\n        )\n      )\n      cursor = newCell.contentEnd\n    }\n  }\n  out.push(newHtml.slice(cursor, newTable.tableEnd))\n  return out.join('')\n}\n\n/**\n * Mismatched-dimensions path: row-level LCS to identify added/deleted rows,\n * then per preserved row a cell-level LCS to identify added/deleted cells.\n * Reconstructs the table from scratch — there's no \"single new structure\"\n * to walk verbatim, since we're stitching together kept rows from both\n * sides.\n */\nfunction diffStructurallyAlignedTable(\n  oldHtml: string,\n  newHtml: string,\n  oldTable: TableRange,\n  newTable: TableRange,\n  diffCell: DiffCellFn\n): string {\n  const oldKeys = oldTable.rows.map(row => rowKey(oldHtml, row))\n  const newKeys = newTable.rows.map(row => rowKey(newHtml, row))\n  const exactAlignment = lcsAlign(oldKeys, newKeys)\n  const alignment = pairSimilarUnmatchedRows(exactAlignment, oldTable, newTable, oldHtml, newHtml)\n\n  // Walk new's tableStart→tableEnd, substituting rows with their diffed\n  // form so `<thead>`/`<tbody>` wrappers and inter-row whitespace are\n  // preserved verbatim. Deleted rows (no position in new) are injected\n  // inline at their alignment position. If new has no rows at all, fall\n  // back to a from-scratch reconstruction so we still emit deleted rows.\n  if (newTable.rows.length === 0) {\n    return rebuildStructurallyAlignedTable(oldHtml, newHtml, oldTable, newTable, alignment, diffCell)\n  }\n\n  // Emit the table header (`<table>` + any `<thead>`/`<tbody>` opening\n  // text up to the first row) up-front so a leading run of deleted-only\n  // alignments doesn't slip in before the table opens.\n  const out: string[] = []\n  out.push(newHtml.slice(newTable.tableStart, newTable.rows[0].rowStart))\n  let cursor = newTable.rows[0].rowStart\n  for (const align of alignment) {\n    if (align.newIdx !== null) {\n      const newRow = newTable.rows[align.newIdx]\n      out.push(newHtml.slice(cursor, newRow.rowStart))\n      if (align.oldIdx !== null) {\n        out.push(diffPreservedRow(oldHtml, newHtml, oldTable.rows[align.oldIdx], newRow, diffCell))\n      } else {\n        out.push(emitFullRow(newHtml, newRow, 'ins', diffCell))\n      }\n      cursor = newRow.rowEnd\n    } else if (align.oldIdx !== null) {\n      // Deleted row: inject inline at the current cursor (between the\n      // previously emitted row and the next one in new).\n      out.push(emitFullRow(oldHtml, oldTable.rows[align.oldIdx], 'del', diffCell))\n    }\n  }\n  out.push(newHtml.slice(cursor, newTable.tableEnd))\n  return out.join('')\n}\n\nfunction rebuildStructurallyAlignedTable(\n  oldHtml: string,\n  newHtml: string,\n  oldTable: TableRange,\n  newTable: TableRange,\n  alignment: Alignment[],\n  diffCell: DiffCellFn\n): string {\n  // Used when new has no rows but old does — we lose the per-row\n  // wrappers from new (there are none), so reconstruct from old's frame.\n  const out: string[] = []\n  out.push(headerSlice(newHtml, newTable, oldHtml, oldTable))\n  for (const align of alignment) {\n    if (align.oldIdx !== null) {\n      out.push(emitFullRow(oldHtml, oldTable.rows[align.oldIdx], 'del', diffCell))\n    } else if (align.newIdx !== null) {\n      out.push(emitFullRow(newHtml, newTable.rows[align.newIdx], 'ins', diffCell))\n    }\n  }\n  out.push('</table>')\n  return out.join('')\n}\n\nfunction headerSlice(newHtml: string, newTable: TableRange, oldHtml: string, oldTable: TableRange): string {\n  // Slice from <table> to the start of the first <tr>. Prefer new since\n  // attribute changes on <table> itself should follow new.\n  const newFirstRow = newTable.rows[0]?.rowStart ?? newTable.tableEnd - '</table>'.length\n  if (newFirstRow > newTable.tableStart) {\n    return newHtml.slice(newTable.tableStart, newFirstRow)\n  }\n  const oldFirstRow = oldTable.rows[0]?.rowStart ?? oldTable.tableEnd - '</table>'.length\n  return oldHtml.slice(oldTable.tableStart, oldFirstRow)\n}\n\nfunction rowKey(html: string, row: RowRange): string {\n  // Include cell tag text in the key so column-add doesn't accidentally\n  // match a row to one with different cell counts. Whitespace-normalize to\n  // tolerate formatting differences.\n  return html.slice(row.rowStart, row.rowEnd).replace(/\\s+/g, ' ').trim()\n}\n\nfunction diffPreservedRow(\n  oldHtml: string,\n  newHtml: string,\n  oldRow: RowRange,\n  newRow: RowRange,\n  diffCell: DiffCellFn\n): string {\n  if (oldRow.cells.length === newRow.cells.length) {\n    return diffPositionalRow(oldHtml, newHtml, oldRow, newRow, diffCell)\n  }\n  // Cell counts differ. Try to interpret it as a horizontal merge/split via\n  // colspan first — preserving the new structure with `class='mod colspan'`\n  // on each affected cell.\n  const colspanAligned = diffColspanChangedRow(oldHtml, newHtml, oldRow, newRow, diffCell)\n  if (colspanAligned !== null) return colspanAligned\n  // For a single-column add/delete (cell count differs by exactly 1),\n  // detect the position via positional similarity scan and align the\n  // remaining cells positionally. This handles the case where a column\n  // was added AND a different cell got an unrelated content edit — the\n  // edited cell still aligns by position rather than getting orphaned by\n  // the cell-LCS exact-match.\n  const delta = newRow.cells.length - oldRow.cells.length\n  // For column add/delete (cell counts differ), find the best insertion\n  // or deletion positions via positional similarity scan and align the\n  // remaining cells positionally. This handles content-edit alongside\n  // column-add by keeping the edited cell in its column position rather\n  // than orphaning it via the cell-LCS exact match.\n  // Guardrail: combinatorial search is C(newCount, k); we cap to avoid\n  // explosion on very wide tables. The cap is generous for real legal\n  // schedules; anything above falls through to cell-LCS.\n  const absDelta = Math.abs(delta)\n  if (\n    absDelta > 0 &&\n    absDelta <= MAX_COLUMN_DELTA &&\n    Math.max(oldRow.cells.length, newRow.cells.length) <= MAX_COLUMN_SEARCH_WIDTH\n  ) {\n    if (delta > 0) return diffMultiColumnAddRow(oldHtml, newHtml, oldRow, newRow, delta, diffCell)\n    return diffMultiColumnDeleteRow(oldHtml, newHtml, oldRow, newRow, -delta, diffCell)\n  }\n  return diffStructurallyAlignedRow(oldHtml, newHtml, oldRow, newRow, diffCell)\n}\n\nconst MAX_COLUMN_DELTA = 6\nconst MAX_COLUMN_SEARCH_WIDTH = 40\n\n/**\n * For a row where new has K more cells than old, find the K column\n * positions in new where cells were inserted by scanning all C(newCount,\n * K) combinations and picking the one that maximises positional content\n * similarity with the remaining cells. The inserted cells are emitted\n * with diff markers; the rest are aligned positionally with content\n * diff for matched pairs.\n */\nfunction diffMultiColumnAddRow(\n  oldHtml: string,\n  newHtml: string,\n  oldRow: RowRange,\n  newRow: RowRange,\n  k: number,\n  diffCell: DiffCellFn\n): string {\n  const insertedPositions = findBestColumnInsertPositions(oldRow, newRow, k, oldHtml, newHtml)\n  const inserted = new Set(insertedPositions)\n  const out: string[] = [rowHeaderSlice(newHtml, newRow)]\n  let oldIdx = 0\n  for (let c = 0; c < newRow.cells.length; c++) {\n    if (inserted.has(c)) {\n      out.push(emitFullCell(newHtml, newRow.cells[c], 'ins', diffCell))\n    } else {\n      out.push(emitDiffedCell(oldHtml, newHtml, oldRow.cells[oldIdx], newRow.cells[c], diffCell))\n      oldIdx++\n    }\n  }\n  out.push('</tr>')\n  return out.join('')\n}\n\nfunction diffMultiColumnDeleteRow(\n  oldHtml: string,\n  newHtml: string,\n  oldRow: RowRange,\n  newRow: RowRange,\n  k: number,\n  diffCell: DiffCellFn\n): string {\n  const deletedPositions = findBestColumnDeletePositions(oldRow, newRow, k, oldHtml, newHtml)\n  const deleted = new Set(deletedPositions)\n  const out: string[] = [rowHeaderSlice(newHtml, newRow)]\n  let newIdx = 0\n  for (let oldIdx = 0; oldIdx < oldRow.cells.length; oldIdx++) {\n    if (deleted.has(oldIdx)) {\n      out.push(emitFullCell(oldHtml, oldRow.cells[oldIdx], 'del', diffCell))\n      continue\n    }\n    out.push(emitDiffedCell(oldHtml, newHtml, oldRow.cells[oldIdx], newRow.cells[newIdx], diffCell))\n    newIdx++\n  }\n  out.push('</tr>')\n  return out.join('')\n}\n\nfunction findBestColumnInsertPositions(\n  oldRow: RowRange,\n  newRow: RowRange,\n  k: number,\n  oldHtml: string,\n  newHtml: string\n): number[] {\n  let bestPositions: number[] = []\n  let bestScore = -1\n  for (const combo of combinationsOfRange(newRow.cells.length, k)) {\n    const inserted = new Set(combo)\n    let score = 0\n    let oldIdx = 0\n    for (let newIdx = 0; newIdx < newRow.cells.length; newIdx++) {\n      if (inserted.has(newIdx)) continue\n      score += cellSimilarity(oldRow.cells[oldIdx], newRow.cells[newIdx], oldHtml, newHtml)\n      oldIdx++\n    }\n    if (score > bestScore) {\n      bestScore = score\n      bestPositions = combo\n    }\n  }\n  return bestPositions\n}\n\nfunction findBestColumnDeletePositions(\n  oldRow: RowRange,\n  newRow: RowRange,\n  k: number,\n  oldHtml: string,\n  newHtml: string\n): number[] {\n  let bestPositions: number[] = []\n  let bestScore = -1\n  for (const combo of combinationsOfRange(oldRow.cells.length, k)) {\n    const deleted = new Set(combo)\n    let score = 0\n    let newIdx = 0\n    for (let oldIdx = 0; oldIdx < oldRow.cells.length; oldIdx++) {\n      if (deleted.has(oldIdx)) continue\n      score += cellSimilarity(oldRow.cells[oldIdx], newRow.cells[newIdx], oldHtml, newHtml)\n      newIdx++\n    }\n    if (score > bestScore) {\n      bestScore = score\n      bestPositions = combo\n    }\n  }\n  return bestPositions\n}\n\n/**\n * Yields all sorted-ascending combinations of `k` distinct integers\n * from [0, n). Iterative implementation avoids recursion overhead and\n * keeps memory at O(k).\n */\nfunction* combinationsOfRange(n: number, k: number): IterableIterator<number[]> {\n  if (k === 0 || k > n) return\n  const indices = Array.from({ length: k }, (_, i) => i)\n  while (true) {\n    yield indices.slice()\n    let i = k - 1\n    while (i >= 0 && indices[i] === n - k + i) i--\n    if (i < 0) return\n    indices[i]++\n    for (let j = i + 1; j < k; j++) indices[j] = indices[j - 1] + 1\n  }\n}\n\n/**\n * Try to align cells by logical column position (sum of colspans). When\n * one side has a colspan'd cell that absorbs multiple cells on the other\n * side, emit the new structure with `class='mod colspan'` on the\n * merged/split cells. Returns null if the rows don't align cleanly —\n * caller falls back to a generic cell-LCS.\n */\nfunction diffColspanChangedRow(\n  oldHtml: string,\n  newHtml: string,\n  oldRow: RowRange,\n  newRow: RowRange,\n  diffCell: DiffCellFn\n): string | null {\n  const oldWidth = sumColspans(oldHtml, oldRow.cells)\n  const newWidth = sumColspans(newHtml, newRow.cells)\n  if (oldWidth !== newWidth) return null\n\n  const out: string[] = []\n  out.push(rowHeaderSlice(newHtml, newRow))\n\n  let oi = 0\n  let ni = 0\n  while (oi < oldRow.cells.length && ni < newRow.cells.length) {\n    const oCell = oldRow.cells[oi]\n    const nCell = newRow.cells[ni]\n    const oSpan = getColspan(oldHtml, oCell)\n    const nSpan = getColspan(newHtml, nCell)\n\n    if (oSpan === nSpan) {\n      out.push(emitDiffedCell(oldHtml, newHtml, oCell, nCell, diffCell))\n      oi++\n      ni++\n    } else if (nSpan > oSpan) {\n      // New cell absorbs multiple old cells — horizontal merge.\n      let totalOldSpan = 0\n      let oj = oi\n      while (oj < oldRow.cells.length && totalOldSpan < nSpan) {\n        totalOldSpan += getColspan(oldHtml, oldRow.cells[oj])\n        oj++\n      }\n      if (totalOldSpan !== nSpan) return null\n      out.push(emitSpanChangedCell(newHtml, nCell, 'colspan'))\n      oi = oj\n      ni++\n    } else {\n      // One old cell becomes multiple new cells — horizontal split.\n      let totalNewSpan = 0\n      let nj = ni\n      while (nj < newRow.cells.length && totalNewSpan < oSpan) {\n        totalNewSpan += getColspan(newHtml, newRow.cells[nj])\n        nj++\n      }\n      if (totalNewSpan !== oSpan) return null\n      for (let k = ni; k < nj; k++) {\n        out.push(emitSpanChangedCell(newHtml, newRow.cells[k], 'colspan'))\n      }\n      oi++\n      ni = nj\n    }\n  }\n\n  // If we couldn't consume both sides cleanly, bail out.\n  if (oi !== oldRow.cells.length || ni !== newRow.cells.length) return null\n\n  out.push('</tr>')\n  return out.join('')\n}\n\nfunction sumColspans(html: string, cells: CellRange[]): number {\n  let total = 0\n  for (const cell of cells) total += getColspan(html, cell)\n  return total\n}\n\nfunction getColspan(html: string, cell: CellRange): number {\n  return parseSpanAttribute(html.slice(cell.cellStart, cell.contentStart), 'colspan')\n}\n\nfunction getRowspan(html: string, cell: CellRange): number {\n  return parseSpanAttribute(html.slice(cell.cellStart, cell.contentStart), 'rowspan')\n}\n\nfunction parseSpanAttribute(openingTag: string, name: 'colspan' | 'rowspan'): number {\n  const re = name === 'colspan' ? /\\bcolspan\\s*=\\s*[\"']?(\\d+)[\"']?/i : /\\browspan\\s*=\\s*[\"']?(\\d+)[\"']?/i\n  const m = re.exec(openingTag)\n  if (!m) return 1\n  const value = Number.parseInt(m[1], 10)\n  return Number.isFinite(value) && value > 0 ? value : 1\n}\n\n/**\n * Emits a cell that's the merged/split product of a structural change,\n * tagged with `class='mod colspan'` or `class='mod rowspan'`. Content is\n * carried through unmodified — Word doesn't track these changes, and\n * inserting del/ins around content that didn't really change would be\n * misleading.\n */\nfunction emitSpanChangedCell(html: string, cell: CellRange, kind: 'colspan' | 'rowspan'): string {\n  const tdOpening = parseOpeningTagAt(html, cell.cellStart)\n  if (!tdOpening) return html.slice(cell.cellStart, cell.cellEnd)\n  const tdOpenTag = injectClass(html.slice(cell.cellStart, tdOpening.end), `mod ${kind}`)\n  return tdOpenTag + html.slice(cell.contentStart, cell.cellEnd)\n}\n\nfunction diffPositionalRow(\n  oldHtml: string,\n  newHtml: string,\n  oldRow: RowRange,\n  newRow: RowRange,\n  diffCell: DiffCellFn\n): string {\n  const out: string[] = []\n  // Use new's <tr> opening tag (preserves attributes from new).\n  const trHeader = rowHeaderSlice(newHtml, newRow)\n  out.push(trHeader)\n\n  let cursor = newRow.cells[0]?.cellStart ?? newRow.rowEnd\n  for (let c = 0; c < newRow.cells.length; c++) {\n    const oldCell = oldRow.cells[c]\n    const newCell = newRow.cells[c]\n    out.push(newHtml.slice(cursor, newCell.contentStart))\n    out.push(\n      diffCell(\n        oldHtml.slice(oldCell.contentStart, oldCell.contentEnd),\n        newHtml.slice(newCell.contentStart, newCell.contentEnd)\n      )\n    )\n    cursor = newCell.contentEnd\n  }\n  out.push(newHtml.slice(cursor, newRow.rowEnd))\n  return out.join('')\n}\n\nfunction diffStructurallyAlignedRow(\n  oldHtml: string,\n  newHtml: string,\n  oldRow: RowRange,\n  newRow: RowRange,\n  diffCell: DiffCellFn\n): string {\n  const oldKeys = oldRow.cells.map(cell => cellKey(oldHtml, cell))\n  const newKeys = newRow.cells.map(cell => cellKey(newHtml, cell))\n  const exactAlignment = lcsAlign(oldKeys, newKeys)\n  // After exact LCS, fuzzy-pair adjacent unmatched old/new cells whose\n  // content is similar enough — so a content-edit cell alongside a\n  // column-add in the same row produces a content diff for the edited\n  // cell rather than a phantom delete + insert + extra cell.\n  const alignment = pairSimilarUnmatchedCells(exactAlignment, oldRow, newRow, oldHtml, newHtml)\n\n  const out: string[] = []\n  // Use new's <tr> if it exists; otherwise old's.\n  out.push(rowHeaderSlice(newHtml, newRow))\n\n  for (const align of alignment) {\n    if (align.oldIdx !== null && align.newIdx !== null) {\n      const oldCell = oldRow.cells[align.oldIdx]\n      const newCell = newRow.cells[align.newIdx]\n      out.push(emitDiffedCell(oldHtml, newHtml, oldCell, newCell, diffCell))\n    } else if (align.newIdx !== null) {\n      out.push(emitFullCell(newHtml, newRow.cells[align.newIdx], 'ins', diffCell))\n    } else if (align.oldIdx !== null) {\n      out.push(emitFullCell(oldHtml, oldRow.cells[align.oldIdx], 'del', diffCell))\n    }\n  }\n\n  out.push('</tr>')\n  return out.join('')\n}\n\nfunction cellKey(html: string, cell: CellRange): string {\n  // Use cell content (not tag attributes) for matching, since column-add\n  // typically changes content but not tag attributes — and matching purely\n  // on attributes would mis-pair cells with the same content but different\n  // styling.\n  return html.slice(cell.contentStart, cell.contentEnd).replace(/\\s+/g, ' ').trim()\n}\n\n/**\n * Emits a row with all cells either inserted (kind='ins') or deleted\n * (kind='del'). Adds `class='diffins'`/`'diffdel'` to the `<tr>` and to\n * each `<td>`, with an `<ins>`/`<del>` wrapper around any cell content\n * (empty cells get the class but no wrapper).\n */\nfunction emitFullRow(html: string, row: RowRange, kind: 'ins' | 'del', diffCell: DiffCellFn): string {\n  const cls = kind === 'ins' ? 'diffins' : 'diffdel'\n  const trOpening = parseOpeningTagAt(html, row.rowStart)\n  if (!trOpening) return html.slice(row.rowStart, row.rowEnd)\n  const trOpenTag = injectClass(html.slice(row.rowStart, trOpening.end), cls)\n\n  const out: string[] = [trOpenTag]\n  let cursor = trOpening.end\n  for (const cell of row.cells) {\n    out.push(html.slice(cursor, cell.cellStart))\n    out.push(emitFullCell(html, cell, kind, diffCell))\n    cursor = cell.cellEnd\n  }\n  out.push(html.slice(cursor, row.rowEnd))\n  return out.join('')\n}\n\n/**\n * Emits a fully-inserted or fully-deleted cell. Inner text runs are wrapped\n * with `<ins>`/`<del>` while formatting tags pass through unchanged, so\n * `<strong>B</strong>` renders as `<strong><ins>B</ins></strong>` —\n * matching htmldiff's general convention without the doubled-`<ins>` that\n * the full recursive diff would produce for newly-inserted formatting.\n * Empty cells get the class on the `<td>` but no inner wrapping.\n */\nfunction emitFullCell(html: string, cell: CellRange, kind: 'ins' | 'del', _diffCell: DiffCellFn): string {\n  const cls = kind === 'ins' ? 'diffins' : 'diffdel'\n  const tdOpening = parseOpeningTagAt(html, cell.cellStart)\n  if (!tdOpening) return html.slice(cell.cellStart, cell.cellEnd)\n  const tdOpenTag = injectClass(html.slice(cell.cellStart, tdOpening.end), cls)\n\n  const content = html.slice(cell.contentStart, cell.contentEnd)\n  const wrapped = content.trim().length === 0 ? content : wrapInlineTextRuns(content, kind)\n  const closing = html.slice(cell.contentEnd, cell.cellEnd)\n  return tdOpenTag + wrapped + closing\n}\n\n/**\n * Wraps every non-whitespace text run in the given content with an\n * `<ins>`/`<del>` tag, leaving HTML tags untouched. This produces output\n * like `<strong><ins>X</ins></strong>` for fully-inserted formatted\n * content — the same shape the rest of htmldiff emits for content\n * insertions inside existing formatting.\n */\nfunction wrapInlineTextRuns(content: string, kind: 'ins' | 'del'): string {\n  const tag = kind === 'ins' ? 'ins' : 'del'\n  const cls = kind === 'ins' ? 'diffins' : 'diffdel'\n\n  const out: string[] = []\n  let i = 0\n  while (i < content.length) {\n    if (content[i] === '<') {\n      const tagEnd = parseOpeningTagAt(content, i)\n      if (!tagEnd) {\n        // Malformed — pass the rest through verbatim.\n        out.push(content.slice(i))\n        break\n      }\n      out.push(content.slice(i, tagEnd.end))\n      i = tagEnd.end\n      continue\n    }\n    let j = i\n    while (j < content.length && content[j] !== '<') j++\n    const text = content.slice(i, j)\n    if (text.trim().length > 0) {\n      out.push(`<${tag} class='${cls}'>${text}</${tag}>`)\n    } else {\n      out.push(text)\n    }\n    i = j\n  }\n  return out.join('')\n}\n\nfunction emitDiffedCell(\n  oldHtml: string,\n  newHtml: string,\n  oldCell: CellRange,\n  newCell: CellRange,\n  diffCell: DiffCellFn\n): string {\n  const tdOpening = parseOpeningTagAt(newHtml, newCell.cellStart)\n  if (!tdOpening) return newHtml.slice(newCell.cellStart, newCell.cellEnd)\n  const tdOpenTag = newHtml.slice(newCell.cellStart, tdOpening.end)\n  const content = diffCell(\n    oldHtml.slice(oldCell.contentStart, oldCell.contentEnd),\n    newHtml.slice(newCell.contentStart, newCell.contentEnd)\n  )\n  const closing = newHtml.slice(newCell.contentEnd, newCell.cellEnd)\n  return tdOpenTag + content + closing\n}\n\nfunction rowHeaderSlice(html: string, row: RowRange): string {\n  // Slice from <tr> to just before the first <td> opening tag. Preserves\n  // the <tr ...> attributes plus any inter-tag whitespace. For a row with\n  // no cells, we only want the `<tr ...>` opening — the caller appends the\n  // closing `</tr>` explicitly, so taking the whole `<tr></tr>` here would\n  // double the close.\n  const opening = parseOpeningTagAt(html, row.rowStart)\n  if (!opening) return ''\n  if (row.cells.length === 0) return html.slice(row.rowStart, opening.end)\n  return html.slice(row.rowStart, row.cells[0].cellStart)\n}\n\ninterface Alignment {\n  oldIdx: number | null\n  newIdx: number | null\n}\n\n/** Character-level similarity threshold above which we treat two rows as \"the same row, edited\". */\nconst ROW_FUZZY_THRESHOLD = 0.5\n\n/**\n * Threshold for \"this cell is a content-edit of that cell.\" Tuned the same\n * as ROW_FUZZY_THRESHOLD; cells in legal docs that share most of their\n * content typically ARE the same logical cell with a body edit, so 0.5\n * works for both granularities in practice.\n */\nconst CELL_FUZZY_THRESHOLD = 0.5\n\n/**\n * After exact LCS, scan the alignment for runs of \"old deleted, then new\n * inserted\" (or vice versa) and pair entries whose content is similar\n * enough to be treated as an edit rather than a delete+insert. This keeps\n * row-level edits (a typo fix, a single word change) from being shown as\n * an entire row vanishing and a new one appearing — matching what users\n * expect from a typical track-changes view.\n */\nfunction pairSimilarUnmatchedRows(\n  alignment: Alignment[],\n  oldTable: TableRange,\n  newTable: TableRange,\n  oldHtml: string,\n  newHtml: string\n): Alignment[] {\n  return pairSimilarUnmatched(alignment, ROW_FUZZY_THRESHOLD, (oldIdx, newIdx) =>\n    rowSimilarity(oldTable.rows[oldIdx], newTable.rows[newIdx], oldHtml, newHtml)\n  )\n}\n\nfunction pairSimilarUnmatchedCells(\n  alignment: Alignment[],\n  oldRow: RowRange,\n  newRow: RowRange,\n  oldHtml: string,\n  newHtml: string\n): Alignment[] {\n  return pairSimilarUnmatched(alignment, CELL_FUZZY_THRESHOLD, (oldIdx, newIdx) =>\n    cellSimilarity(oldRow.cells[oldIdx], newRow.cells[newIdx], oldHtml, newHtml)\n  )\n}\n\n/**\n * Identify pairings inside each unmatched-only run, then build the output\n * alignment by walking the original and substituting paired entries at\n * the *ins position* (not the del position). This keeps the result\n * monotonic in newIdx — critical because the cursor-based emission\n * downstream walks new's html in order. Emitting at the del position\n * would be fine when del<ins in the alignment array (the typical case),\n * but can violate monotonicity when there are mixed unpaired entries in\n * between (column-add + row-add together, content-edit + column-add,\n * etc.).\n *\n * Generic over what's being paired — works for both rows (by full row\n * content similarity) and cells (by per-cell content similarity).\n */\nfunction pairSimilarUnmatched(\n  alignment: Alignment[],\n  threshold: number,\n  similarity: (oldIdx: number, newIdx: number) => number\n): Alignment[] {\n  const pairs = new Map<number, number>() // del-alignment-idx → ins-alignment-idx\n  let i = 0\n  while (i < alignment.length) {\n    if (alignment[i].oldIdx !== null && alignment[i].newIdx !== null) {\n      i++\n      continue\n    }\n    const runStart = i\n    while (i < alignment.length && (alignment[i].oldIdx === null) !== (alignment[i].newIdx === null)) i++\n    const runEnd = i\n\n    const delIndices: number[] = []\n    const insIndices: number[] = []\n    for (let k = runStart; k < runEnd; k++) {\n      if (alignment[k].oldIdx !== null) delIndices.push(k)\n      else insIndices.push(k)\n    }\n\n    const usedIns = new Set<number>()\n    for (const di of delIndices) {\n      let bestIi = -1\n      let bestSim = threshold\n      for (const ii of insIndices) {\n        if (usedIns.has(ii)) continue\n        const sim = similarity(alignment[di].oldIdx as number, alignment[ii].newIdx as number)\n        if (sim > bestSim) {\n          bestSim = sim\n          bestIi = ii\n        }\n      }\n      if (bestIi >= 0) {\n        pairs.set(di, bestIi)\n        usedIns.add(bestIi)\n      }\n    }\n  }\n\n  const insToDel = new Map<number, number>() // ins-alignment-idx → del-alignment-idx\n  for (const [delAi, insAi] of pairs) insToDel.set(insAi, delAi)\n  const pairedDels = new Set<number>(pairs.keys())\n\n  const result: Alignment[] = []\n  for (let k = 0; k < alignment.length; k++) {\n    if (pairedDels.has(k)) continue // paired del — emitted when we reach its ins\n    if (insToDel.has(k)) {\n      const delAi = insToDel.get(k) as number\n      result.push({ oldIdx: alignment[delAi].oldIdx, newIdx: alignment[k].newIdx })\n    } else {\n      result.push(alignment[k])\n    }\n  }\n  return result\n}\n\n/**\n * Combined similarity metric used for both row-level and cell-level\n * fuzzy pairing. Returns the MAX of two complementary metrics:\n *\n *   1. **Character prefix+suffix similarity** — fraction of the longer\n *      string covered by shared prefix + shared suffix. Catches small\n *      edits in the middle of a string (one word changed in a row).\n *      Misses cases where the bulk of common content is in the middle\n *      and the ends differ.\n *\n *   2. **Token Jaccard similarity** — intersection-over-union of the\n *      whitespace-split tokens. Catches \"most of the content is the\n *      same but bookended by different bits\" — e.g. a row whose only\n *      edit is a column added at the start and another at the end,\n *      where the ~50 chars in the middle that DO match would be\n *      invisible to prefix+suffix.\n *\n * Either metric exceeding the threshold means pair. Neither alone is\n * sufficient for the full range of legal-doc edits we see in\n * production tables.\n */\nfunction rowSimilarity(oldRow: RowRange, newRow: RowRange, oldHtml: string, newHtml: string): number {\n  return textSimilarity(rowText(oldHtml, oldRow), rowText(newHtml, newRow))\n}\n\nfunction cellSimilarity(oldCell: CellRange, newCell: CellRange, oldHtml: string, newHtml: string): number {\n  return textSimilarity(cellText(oldHtml, oldCell), cellText(newHtml, newCell))\n}\n\nfunction textSimilarity(a: string, b: string): number {\n  if (a === b) return 1\n  if (a.length === 0 || b.length === 0) return 0\n  return Math.max(charPrefixSuffixSimilarity(a, b), tokenJaccardSimilarity(a, b))\n}\n\nfunction charPrefixSuffixSimilarity(a: string, b: string): number {\n  let prefix = 0\n  const minLen = Math.min(a.length, b.length)\n  while (prefix < minLen && a[prefix] === b[prefix]) prefix++\n\n  let suffix = 0\n  while (\n    suffix < a.length - prefix &&\n    suffix < b.length - prefix &&\n    a[a.length - 1 - suffix] === b[b.length - 1 - suffix]\n  ) {\n    suffix++\n  }\n\n  return (prefix + suffix) / Math.max(a.length, b.length)\n}\n\nfunction tokenJaccardSimilarity(a: string, b: string): number {\n  const tokensA = new Set(a.split(/\\s+/).filter(Boolean))\n  const tokensB = new Set(b.split(/\\s+/).filter(Boolean))\n  if (tokensA.size === 0 && tokensB.size === 0) return 1\n  let intersection = 0\n  for (const t of tokensA) {\n    if (tokensB.has(t)) intersection++\n  }\n  const union = tokensA.size + tokensB.size - intersection\n  return union === 0 ? 0 : intersection / union\n}\n\nfunction rowText(html: string, row: RowRange): string {\n  const parts: string[] = []\n  for (const cell of row.cells) {\n    parts.push(html.slice(cell.contentStart, cell.contentEnd).replace(/<[^>]+>/g, ' '))\n  }\n  return parts.join(' ').replace(/\\s+/g, ' ').trim().toLowerCase()\n}\n\nfunction cellText(html: string, cell: CellRange): string {\n  return html\n    .slice(cell.contentStart, cell.contentEnd)\n    .replace(/<[^>]+>/g, ' ')\n    .replace(/\\s+/g, ' ')\n    .trim()\n    .toLowerCase()\n}\n\n/**\n * Standard LCS alignment: walks both sequences and emits a list of pairs\n * where `(oldIdx, newIdx)` are both set for matching positions, and one\n * side is null for an unmatched entry on the other side. Equality uses\n * strict ===.\n */\nfunction lcsAlign(oldKeys: string[], newKeys: string[]): Alignment[] {\n  const m = oldKeys.length\n  const n = newKeys.length\n  const dp: number[][] = Array.from({ length: m + 1 }, () => new Array<number>(n + 1).fill(0))\n  for (let i = 1; i <= m; i++) {\n    for (let j = 1; j <= n; j++) {\n      if (oldKeys[i - 1] === newKeys[j - 1]) {\n        dp[i][j] = dp[i - 1][j - 1] + 1\n      } else {\n        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1])\n      }\n    }\n  }\n\n  const result: Alignment[] = []\n  let i = m\n  let j = n\n  while (i > 0 || j > 0) {\n    if (i > 0 && j > 0 && oldKeys[i - 1] === newKeys[j - 1]) {\n      result.unshift({ oldIdx: i - 1, newIdx: j - 1 })\n      i--\n      j--\n    } else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {\n      result.unshift({ oldIdx: null, newIdx: j - 1 })\n      j--\n    } else {\n      result.unshift({ oldIdx: i - 1, newIdx: null })\n      i--\n    }\n  }\n  return result\n}\n\n/**\n * Returns the opening tag string with the given class injected. Existing\n * `class` attributes are preserved and the new class appended.\n */\n/**\n * Returns the opening tag with the given class injected. Locates the real\n * `class` attribute via attribute-aware walking (NOT a flat regex — that\n * would mis-match inside a foreign attribute value like\n * `title=\"see class='x'\"`). When the class already partially overlaps with\n * `cls` — e.g. existing `class=\"mod\"` and we're injecting `mod colspan` —\n * only the missing tokens get appended, so we never end up with\n * `class=\"mod mod colspan\"`.\n */\nfunction injectClass(openingTag: string, cls: string): string {\n  const clsTokens = cls.split(/\\s+/).filter(Boolean)\n  if (clsTokens.length === 0) return openingTag\n\n  const classAttr = findClassAttribute(openingTag)\n  if (classAttr) {\n    const existingTokens = classAttr.value.split(/\\s+/).filter(Boolean)\n    const missing = clsTokens.filter(t => !existingTokens.includes(t))\n    if (missing.length === 0) return openingTag\n    const updatedValue =\n      existingTokens.length === 0 ? missing.join(' ') : `${existingTokens.join(' ')} ${missing.join(' ')}`\n    return openingTag.slice(0, classAttr.valueStart) + updatedValue + openingTag.slice(classAttr.valueEnd)\n  }\n\n  const isSelfClosing = openingTag.endsWith('/>')\n  const insertAt = isSelfClosing ? openingTag.length - 2 : openingTag.length - 1\n  return `${openingTag.slice(0, insertAt).replace(/\\s*$/, '')} class='${cls}'${openingTag.slice(insertAt)}`\n}\n\n/**\n * Walks the opening tag's attributes (respecting quoted values) to find\n * the actual `class` attribute. Returns the value range (start/end of the\n * value content, *excluding* the surrounding quotes) and the value, or\n * null if no `class` attribute is present.\n */\nfunction findClassAttribute(openingTag: string): { valueStart: number; valueEnd: number; value: string } | null {\n  // Skip past the tag name. Tag starts with `<`; first run of [A-Za-z0-9-]\n  // is the tag name. Anything after is attribute territory.\n  let i = 1\n  while (i < openingTag.length && /[A-Za-z0-9_:-]/.test(openingTag[i])) i++\n\n  while (i < openingTag.length) {\n    // Skip whitespace\n    while (i < openingTag.length && /\\s/.test(openingTag[i])) i++\n    if (i >= openingTag.length) break\n    if (openingTag[i] === '>' || openingTag[i] === '/') break\n\n    // Read attribute name\n    const nameStart = i\n    while (i < openingTag.length && !/[\\s=>/]/.test(openingTag[i])) i++\n    const name = openingTag.slice(nameStart, i)\n\n    // Optional whitespace + '=' + optional whitespace + value\n    while (i < openingTag.length && /\\s/.test(openingTag[i])) i++\n    if (openingTag[i] !== '=') {\n      // Bare attribute (no value) — not class\n      continue\n    }\n    i++ // past '='\n    while (i < openingTag.length && /\\s/.test(openingTag[i])) i++\n\n    // Value: quoted or unquoted\n    let valueStart: number\n    let valueEnd: number\n    if (openingTag[i] === '\"' || openingTag[i] === \"'\") {\n      const quote = openingTag[i]\n      i++\n      valueStart = i\n      while (i < openingTag.length && openingTag[i] !== quote) i++\n      valueEnd = i\n      if (i < openingTag.length) i++ // past closing quote\n    } else {\n      valueStart = i\n      while (i < openingTag.length && !/[\\s>/]/.test(openingTag[i])) i++\n      valueEnd = i\n    }\n\n    if (name.toLowerCase() === 'class') {\n      return { valueStart, valueEnd, value: openingTag.slice(valueStart, valueEnd) }\n    }\n  }\n\n  return null\n}\n\n/**\n * Walks html and returns ranges for every top-level `<table>...</table>`\n * block. Nested tables aren't extracted as separate top-level entries —\n * they're captured inside the parent's content range and handled when the\n * cell-level diff recurses through them.\n */\nfunction findTopLevelTables(html: string): TableRange[] {\n  const tables: TableRange[] = []\n  let i = 0\n  while (i < html.length) {\n    if (matchesTagAt(html, i, 'table')) {\n      const opening = parseOpeningTagAt(html, i)\n      if (!opening) {\n        i++\n        continue\n      }\n      const tableContentStart = opening.end\n      const tableEnd = findMatchingClosingTag(html, tableContentStart, 'table')\n      if (tableEnd === -1) {\n        i = opening.end\n        continue\n      }\n      const closingTagStart = tableEnd - '</table>'.length\n      const rows = findTopLevelRows(html, tableContentStart, closingTagStart)\n      tables.push({ tableStart: i, tableEnd, rows })\n      i = tableEnd\n    } else {\n      i++\n    }\n  }\n  return tables\n}\n\nfunction findTopLevelRows(html: string, start: number, end: number): RowRange[] {\n  const rows: RowRange[] = []\n  let i = start\n  while (i < end) {\n    if (matchesTagAt(html, i, 'tr')) {\n      const opening = parseOpeningTagAt(html, i)\n      if (!opening) {\n        i++\n        continue\n      }\n      const rowContentStart = opening.end\n      const rowEnd = findMatchingClosingTag(html, rowContentStart, 'tr', end)\n      if (rowEnd === -1) {\n        i = opening.end\n        continue\n      }\n      const closingTagStart = rowEnd - '</tr>'.length\n      const cells = findTopLevelCells(html, rowContentStart, closingTagStart)\n      rows.push({ rowStart: i, rowEnd, cells })\n      i = rowEnd\n    } else if (matchesClosingTagAt(html, i, 'table')) {\n      // Defensive: bail out if we encounter a closing </table> while\n      // scanning rows (we should have stopped at `end` already).\n      break\n    } else {\n      i++\n    }\n  }\n  return rows\n}\n\nfunction findTopLevelCells(html: string, start: number, end: number): CellRange[] {\n  const cells: CellRange[] = []\n  let i = start\n  while (i < end) {\n    if (matchesTagAt(html, i, 'td') || matchesTagAt(html, i, 'th')) {\n      const tagName = matchesTagAt(html, i, 'td') ? 'td' : 'th'\n      const opening = parseOpeningTagAt(html, i)\n      if (!opening) {\n        i++\n        continue\n      }\n      const contentStart = opening.end\n      const cellEnd = findMatchingClosingTag(html, contentStart, tagName, end)\n      if (cellEnd === -1) {\n        i = opening.end\n        continue\n      }\n      const contentEnd = cellEnd - `</${tagName}>`.length\n      cells.push({ cellStart: i, cellEnd, contentStart, contentEnd })\n      i = cellEnd\n    } else if (matchesClosingTagAt(html, i, 'tr')) {\n      break\n    } else {\n      i++\n    }\n  }\n  return cells\n}\n\nfunction matchesTagAt(html: string, i: number, tagName: string): boolean {\n  if (html[i] !== '<') return false\n  const candidate = html.slice(i + 1, i + 1 + tagName.length).toLowerCase()\n  if (candidate !== tagName) return false\n  const after = html[i + 1 + tagName.length]\n  return after === '>' || after === ' ' || after === '\\t' || after === '\\n' || after === '\\r' || after === '/'\n}\n\nfunction matchesClosingTagAt(html: string, i: number, tagName: string): boolean {\n  if (html[i] !== '<' || html[i + 1] !== '/') return false\n  const candidate = html.slice(i + 2, i + 2 + tagName.length).toLowerCase()\n  if (candidate !== tagName) return false\n  const after = html[i + 2 + tagName.length]\n  return after === '>' || after === ' ' || after === '\\t' || after === '\\n' || after === '\\r'\n}\n\ninterface OpeningTag {\n  /** Index just past the closing `>` of the opening tag. */\n  end: number\n}\n\nfunction parseOpeningTagAt(html: string, i: number): OpeningTag | null {\n  // HTML comments, CDATA, processing instructions, and DOCTYPE need their\n  // own terminators — a plain `>`-walker would cut a comment like\n  // `<!-- a > b -->` at the first inner `>`, treating the rest as text\n  // and corrupting downstream offsets. Word-exported HTML routinely\n  // emits comments inside tables (conditional comments, OLE markers) so\n  // these have to be handled, not just be theoretical.\n  if (html.startsWith('<!--', i)) {\n    const close = html.indexOf('-->', i + 4)\n    return close === -1 ? null : { end: close + 3 }\n  }\n  if (html.startsWith('<![CDATA[', i)) {\n    const close = html.indexOf(']]>', i + 9)\n    return close === -1 ? null : { end: close + 3 }\n  }\n  if (html.startsWith('<?', i)) {\n    const close = html.indexOf('?>', i + 2)\n    return close === -1 ? null : { end: close + 2 }\n  }\n  // Walk to the next unquoted '>'. Handles attributes whose values contain\n  // a literal '>' inside quotes, which a plain indexOf would mishandle.\n  let j = i + 1\n  let quote: string | null = null\n  while (j < html.length) {\n    const ch = html[j]\n    if (quote) {\n      if (ch === quote) quote = null\n    } else if (ch === '\"' || ch === \"'\") {\n      quote = ch\n    } else if (ch === '>') {\n      return { end: j + 1 }\n    }\n    j++\n  }\n  return null\n}\n\n/**\n * Returns the index just past the matching `</tagName>`, accounting for\n * nested tags of the same name. Returns -1 if no match before `limit`.\n */\nfunction findMatchingClosingTag(html: string, from: number, tagName: string, limit: number = html.length): number {\n  let depth = 1\n  let i = from\n  while (i < limit) {\n    if (matchesTagAt(html, i, tagName)) {\n      const opening = parseOpeningTagAt(html, i)\n      if (!opening) {\n        i++\n        continue\n      }\n      const tagText = html.slice(i, opening.end)\n      if (!tagText.endsWith('/>')) depth++\n      i = opening.end\n    } else if (matchesClosingTagAt(html, i, tagName)) {\n      depth--\n      const closing = parseOpeningTagAt(html, i)\n      const closingEnd = closing?.end ?? i + `</${tagName}>`.length\n      if (depth === 0) return closingEnd\n      i = closingEnd\n    } else {\n      i++\n    }\n  }\n  return -1\n}\n","import Mode from './Mode'\nimport Utils from './Utils'\n\nexport default class WordSplitter {\n  private text: string\n  private isBlockCheckRequired: boolean\n  private blockLocations: BlockFinderResult\n  private mode: Mode\n  private isGrouping = false\n  private globbingUntil: number\n  private currentWord: string[]\n  private words: string[]\n  private static NotGlobbing = -1\n\n  private get currentWordHasChars() {\n    return this.currentWord.length > 0\n  }\n\n  constructor(text: string, blockExpressions: RegExp[]) {\n    this.text = text\n    this.blockLocations = new BlockFinder(text, blockExpressions).findBlocks()\n    this.isBlockCheckRequired = this.blockLocations.hasBlocks\n    this.mode = Mode.Character\n    this.globbingUntil = WordSplitter.NotGlobbing\n    this.currentWord = []\n    this.words = []\n  }\n\n  process(): string[] {\n    for (let index = 0; index < this.text.length; index++) {\n      const character = this.text.charAt(index)\n      this.processCharacter(index, character)\n    }\n\n    this.appendCurrentWordToWords()\n    return this.words\n  }\n\n  private processCharacter(index: number, character: string) {\n    if (this.isGlobbing(index, character)) {\n      return\n    }\n\n    switch (this.mode) {\n      case Mode.Character:\n        this.processTextCharacter(character)\n        break\n      case Mode.Tag:\n        this.processHtmlTagContinuation(character)\n        break\n      case Mode.Whitespace:\n        this.processWhiteSpaceContinuation(character)\n        break\n      case Mode.Entity:\n        this.processEntityContinuation(character)\n        break\n    }\n  }\n\n  private processEntityContinuation(character: string) {\n    if (Utils.isStartOfTag(character)) {\n      this.appendCurrentWordToWords()\n      this.currentWord.push(character)\n      this.mode = Mode.Tag\n    } else if (character.trim().length === 0) {\n      this.appendCurrentWordToWords()\n      this.currentWord.push(character)\n      this.mode = Mode.Whitespace\n    } else if (Utils.isEndOfEntity(character)) {\n      let switchToNextMode = true\n      if (this.currentWordHasChars) {\n        this.currentWord.push(character)\n        this.words.push(this.currentWord.join(''))\n\n        //join &nbsp; entity with last whitespace\n        if (\n          this.words.length > 2 &&\n          Utils.isWhiteSpace(this.words[this.words.length - 2]) &&\n          Utils.isWhiteSpace(this.words[this.words.length - 1])\n        ) {\n          const w1 = this.words[this.words.length - 2]\n          const w2 = this.words[this.words.length - 1]\n          this.words.splice(this.words.length - 2, 2)\n          this.currentWord = `${w1}${w2}`.split('')\n          this.mode = Mode.Whitespace\n          switchToNextMode = false\n        }\n      }\n\n      if (switchToNextMode) {\n        this.currentWord = []\n        this.mode = Mode.Character\n      }\n    } else if (Utils.isWord(character)) {\n      this.currentWord.push(character)\n    } else {\n      this.appendCurrentWordToWords()\n      this.currentWord.push(character)\n      this.mode = Mode.Character\n    }\n  }\n\n  private processWhiteSpaceContinuation(character: string) {\n    if (Utils.isStartOfTag(character)) {\n      this.appendCurrentWordToWords()\n      this.currentWord.push(character)\n      this.mode = Mode.Tag\n    } else if (Utils.isStartOfEntity(character)) {\n      this.appendCurrentWordToWords()\n      this.currentWord.push(character)\n      this.mode = Mode.Entity\n    } else if (Utils.isWhiteSpace(character)) {\n      this.currentWord.push(character)\n    } else {\n      this.appendCurrentWordToWords()\n      this.currentWord.push(character)\n      this.mode = Mode.Character\n    }\n  }\n\n  private processHtmlTagContinuation(character: string) {\n    if (Utils.isEndOfTag(character)) {\n      this.currentWord.push(character)\n      this.appendCurrentWordToWords()\n      this.mode = Utils.isWhiteSpace(character) ? Mode.Whitespace : Mode.Character\n    } else {\n      this.currentWord.push(character)\n    }\n  }\n\n  private processTextCharacter(character: string) {\n    if (Utils.isStartOfTag(character)) {\n      this.appendCurrentWordToWords()\n      this.currentWord.push('<')\n      this.mode = Mode.Tag\n    } else if (Utils.isStartOfEntity(character)) {\n      this.appendCurrentWordToWords()\n      this.currentWord.push(character)\n      this.mode = Mode.Entity\n    } else if (Utils.isWhiteSpace(character)) {\n      this.appendCurrentWordToWords()\n      this.currentWord.push(character)\n      this.mode = Mode.Whitespace\n    } else if (\n      Utils.isWord(character) &&\n      (this.currentWord.length === 0 || Utils.isWord(this.currentWord[this.currentWord.length - 1]))\n    ) {\n      this.currentWord.push(character)\n    } else {\n      this.appendCurrentWordToWords()\n      this.currentWord.push(character)\n    }\n  }\n\n  private appendCurrentWordToWords() {\n    if (this.currentWordHasChars) {\n      this.words.push(this.currentWord.join(''))\n      this.currentWord = []\n    }\n  }\n\n  private isGlobbing(index: number, character: string): boolean {\n    if (!this.isBlockCheckRequired) {\n      return false\n    }\n    const isCurrentBlockTerminating = index === this.globbingUntil\n    if (isCurrentBlockTerminating) {\n      this.globbingUntil = WordSplitter.NotGlobbing\n      this.isGrouping = false\n      this.appendCurrentWordToWords()\n    }\n\n    const until = this.blockLocations.isInBlock(index)\n    if (until) {\n      this.isGrouping = true\n      this.globbingUntil = until\n    }\n    if (this.isGrouping) {\n      this.currentWord.push(character)\n      this.mode = Mode.Character\n    }\n    return this.isGrouping\n  }\n\n  static convertHtmlToListOfWords(text: string, blockExpressions: RegExp[]): string[] {\n    return new WordSplitter(text, blockExpressions).process()\n  }\n}\n\nclass BlockFinderResult {\n  private blocks: Map<number, number> = new Map()\n\n  addBlock(from: number, to: number) {\n    if (this.blocks.has(from)) {\n      throw new ArgumentError('One or more block expressions result in a text sequence that overlaps.')\n    }\n\n    this.blocks.set(from, to)\n  }\n\n  isInBlock(location: number): number | null {\n    return this.blocks.get(location) ?? null\n  }\n\n  get hasBlocks() {\n    return this.blocks.size > 0\n  }\n}\n\nclass ArgumentError extends Error {}\n\nclass BlockFinder {\n  private text: string\n  private blockExpressions: RegExp[]\n\n  constructor(text: string, blockExpressions: RegExp[]) {\n    this.text = text\n    this.blockExpressions = blockExpressions\n  }\n\n  findBlocks(): BlockFinderResult {\n    const result = new BlockFinderResult()\n    for (const expression of this.blockExpressions) {\n      this.processBlockMatcher(expression, result)\n    }\n    return result\n  }\n\n  private processBlockMatcher(exp: RegExp, result: BlockFinderResult) {\n    let match: RegExpExecArray | null\n    // biome-ignore lint/suspicious/noAssignInExpressions: Couldn't think of a nicer way to do this\n    while ((match = exp.exec(this.text)) !== null) {\n      this.tryAddBlock(exp, match, result)\n    }\n  }\n\n  private tryAddBlock(exp: RegExp, match: RegExpExecArray, result: BlockFinderResult) {\n    try {\n      const from = match.index\n      const to = match.index + match[0].length\n      result.addBlock(from, to)\n    } catch {\n      throw new ArgumentError(\n        `One or more block expressions result in a text sequence that overlaps. Current expression: ${exp}`\n      )\n    }\n  }\n}\n","import Action from './Action'\nimport Match from './Match'\nimport MatchFinder from './MatchFinder'\nimport Operation from './Operation'\nimport { preprocessTables, restoreTablePlaceholders } from './TableDiff'\nimport Utils from './Utils'\nimport WordSplitter from './WordSplitter'\n\nexport default class HtmlDiff {\n  /**\n   * This value defines balance between speed and memory utilization. The higher it is the faster it works and more memory consumes.\n   * @private\n   */\n  private static MatchGranularityMaximum = 4\n\n  private static DelTag = 'del'\n  private static InsTag = 'ins'\n\n  // ignore case\n  private static SpecialCaseClosingTags = [\n    '</strong>',\n    '</em>',\n    '</b>',\n    '</i>',\n    '</big>',\n    '</small>',\n    '</u>',\n    '</sub>',\n    '</sup>',\n    '</strike>',\n    '</s>',\n    '</span>',\n  ]\n\n  private static SpecialCaseClosingTagsSet = new Set([\n    '</strong>',\n    '</em>',\n    '</b>',\n    '</i>',\n    '</big>',\n    '</small>',\n    '</u>',\n    '</sub>',\n    '</sup>',\n    '</strike>',\n    '</s>',\n    '</span>',\n  ])\n\n  private static SpecialCaseOpeningTagRegex =\n    /<((strong)|(b)|(i)|(em)|(big)|(small)|(u)|(sub)|(sup)|(strike)|(s)|(span))[>\\s]+/i\n\n  private static FormattingTags = new Set([\n    'strong',\n    'em',\n    'b',\n    'i',\n    'big',\n    'small',\n    'u',\n    'sub',\n    'sup',\n    'strike',\n    's',\n    'span',\n  ])\n\n  /**\n   * Hard cap on nested `HtmlDiff.execute` calls (table preprocessing\n   * recurses through `diffCell` for cell content). Each level allocates\n   * fresh DP matrices and word arrays; without a guard a maliciously\n   * nested table-in-cell-in-table-in-cell input could blow stack and\n   * memory. Set high enough to comfortably handle real legal documents\n   * (tables nested 2-3 deep at most), low enough to short-circuit\n   * pathological input.\n   */\n  private static MaxTablePreprocessDepth = 8\n\n  private content: string[] = []\n  private newText: string\n  private oldText: string\n  private readonly tablePreprocessDepth: number\n\n  private specialTagDiffStack: string[] = []\n  private newWords: string[] = []\n  private oldWords: string[] = []\n  /**\n   * Content-only projections of oldWords/newWords (structural tags and adjacent whitespace removed).\n   * When null, no structural normalization is applied (the word arrays are identical for diffing).\n   */\n  private oldContentWords: string[] | null = null\n  private newContentWords: string[] | null = null\n  /** Maps content-word index → original word index */\n  private oldContentToOriginal: number[] | null = null\n  private newContentToOriginal: number[] | null = null\n  /**\n   * Tracks the next unwritten word index in oldWords/newWords. Mutated only by\n   * {@link sliceOriginalWordsForOp} (each op reads a slice and advances its cursor).\n   * Advances monotonically. Used so:\n   *   - subsequent equal/delete ops know where in old to resume from\n   *   - subsequent insert ops know where in new to resume from\n   * The two cursors are independent: equal/delete output from old and advance the old\n   * cursor; insert outputs from new and advances the new cursor.\n   */\n  private lastOriginalOldOutputIndex = 0\n  private lastOriginalNewOutputIndex = 0\n  private matchGranularity = 0\n  private blockExpressions: RegExp[] = []\n\n  /**\n   * Defines how to compare repeating words. Valid values are from 0 to 1.\n   * This value allows to exclude some words from comparison that eventually\n   * reduces the total time of the diff algorithm.\n   * 0 means that all words are excluded so the diff will not find any matching words at all.\n   * 1 (default value) means that all words participate in comparison so this is the most accurate case.\n   * 0.5 means that any word that occurs more than 50% times may be excluded from comparison. This doesn't\n   * mean that such words will definitely be excluded but only gives a permission to exclude them if necessary.\n   */\n  repeatingWordsAccuracy = 1.0\n\n  /**\n   * If true all whitespaces are considered as equal\n   */\n  ignoreWhitespaceDifferences = false\n\n  /**\n   * If some match is too small and located far from its neighbors then it is considered as orphan\n   * and removed. For example:\n   * <code>\n   * aaaaa bb ccccccccc dddddd ee\n   * 11111 bb 222222222 dddddd ee\n   * </code>\n   * will find two matches <code>bb</code> and <code>dddddd ee</code> but the first will be considered\n   * as orphan and ignored, as result it will consider texts <code>aaaaa bb ccccccccc</code> and\n   * <code>11111 bb 222222222</code> as single replacement:\n   * <code>\n   * &lt;del&gt;aaaaa bb ccccccccc&lt;/del&gt;&lt;ins&gt;11111 bb 222222222&lt;/ins&gt; dddddd ee\n   * </code>\n   * This property defines relative size of the match to be considered as orphan, from 0 to 1.\n   * 1 means that all matches will be considered as orphans.\n   * 0 (default) means that no match will be considered as orphan.\n   * 0.2 means that if match length is less than 20% of distance between its neighbors it is considered as orphan.\n   */\n  orphanMatchThreshold = 0.0\n\n  /**\n   * Initializes a new instance of the class.\n   * @param oldText The old text.\n   * @param newText The new text.\n   * @param tablePreprocessDepth Internal: nested-call depth for table\n   *   preprocessing. Callers should leave at default (0); the recursive\n   *   `diffCell` callback in TableDiff bumps it.\n   */\n  constructor(oldText: string, newText: string, tablePreprocessDepth = 0) {\n    this.oldText = oldText\n    this.newText = newText\n    this.tablePreprocessDepth = tablePreprocessDepth\n  }\n\n  static execute(oldText: string, newText: string, tablePreprocessDepth = 0) {\n    return new HtmlDiff(oldText, newText, tablePreprocessDepth).build()\n  }\n\n  /**\n   * Builds the HTML diff output\n   * @return HTML diff markup\n   */\n  build(): string {\n    // If there is no difference, don't bother checking for differences\n    if (this.oldText === this.newText) {\n      return this.newText\n    }\n\n    // Table preprocessing: when both sides have matching `<table>` structures,\n    // diff cells positionally so cross-cell content shifts produce one\n    // independent del/ins per cell rather than cell-misaligned output.\n    // Recursion guarded by MaxTablePreprocessDepth to bound work on\n    // deeply-nested table-in-cell-in-table inputs. Caller-configured\n    // settings (block expressions, accuracy thresholds) are propagated to\n    // the recursive cell diff so cell-level output is consistent with the\n    // top-level configuration.\n    const blockExpressions = this.blockExpressions\n    const repeatingWordsAccuracy = this.repeatingWordsAccuracy\n    const orphanMatchThreshold = this.orphanMatchThreshold\n    const ignoreWhitespaceDifferences = this.ignoreWhitespaceDifferences\n    const tablePreprocess =\n      this.tablePreprocessDepth >= HtmlDiff.MaxTablePreprocessDepth\n        ? null\n        : preprocessTables(this.oldText, this.newText, (oldCell, newCell) => {\n            const inner = new HtmlDiff(oldCell, newCell, this.tablePreprocessDepth + 1)\n            for (const expr of blockExpressions) inner.addBlockExpression(expr)\n            inner.repeatingWordsAccuracy = repeatingWordsAccuracy\n            inner.orphanMatchThreshold = orphanMatchThreshold\n            inner.ignoreWhitespaceDifferences = ignoreWhitespaceDifferences\n            return inner.build()\n          })\n    if (tablePreprocess) {\n      this.oldText = tablePreprocess.modifiedOld\n      this.newText = tablePreprocess.modifiedNew\n    }\n\n    this.splitInputsToWords()\n    this.buildContentProjections()\n\n    const wordsForDiffOld = this.oldContentWords ?? this.oldWords\n    const wordsForDiffNew = this.newContentWords ?? this.newWords\n\n    this.matchGranularity = Math.min(\n      HtmlDiff.MatchGranularityMaximum,\n      Math.min(wordsForDiffOld.length, wordsForDiffNew.length)\n    )\n\n    const operations = this.operations()\n    for (const op of operations) {\n      this.performOperation(op)\n    }\n\n    const result = this.content.join('')\n    return tablePreprocess ? restoreTablePlaceholders(result, tablePreprocess.placeholderToDiff) : result\n  }\n\n  /**\n   * Uses {@link expression} to group text together so that any change detected within the group is treated as a single block\n   * @param expression\n   */\n  addBlockExpression(expression: RegExp) {\n    this.blockExpressions.push(expression)\n  }\n\n  private splitInputsToWords() {\n    this.oldWords = WordSplitter.convertHtmlToListOfWords(this.oldText, this.blockExpressions)\n\n    // free memory, allow it for GC\n    this.oldText = ''\n\n    this.newWords = WordSplitter.convertHtmlToListOfWords(this.newText, this.blockExpressions)\n\n    // free memory, allow it for GC\n    this.newText = ''\n  }\n\n  /**\n   * Builds \"content projections\" — word arrays with structural wrapper tags stripped — when\n   * structural normalization is appropriate for these inputs. The diff algorithm operates on\n   * the projections so wrapper-tag differences (e.g. `<p>` vs `<div>`) don't appear as content\n   * changes; structural tags are then folded back in at output time.\n   */\n  private buildContentProjections() {\n    if (!HtmlDiff.hasStructuralDifferences(this.oldWords, this.newWords)) return\n\n    const oldProjection = HtmlDiff.createContentProjection(this.oldWords)\n    const newProjection = HtmlDiff.createContentProjection(this.newWords)\n\n    if (!HtmlDiff.shouldUseContentProjections(this.oldWords, this.newWords, oldProjection, newProjection)) {\n      return\n    }\n\n    this.oldContentWords = oldProjection.contentWords\n    this.oldContentToOriginal = oldProjection.contentToOriginal\n    this.newContentWords = newProjection.contentWords\n    this.newContentToOriginal = newProjection.contentToOriginal\n  }\n\n  /**\n   * Decides whether structural normalization should be activated for this pair of inputs.\n   * Each clause is a distinct correctness or fitness check — extend by adding a named\n   * sub-predicate rather than chaining ad-hoc conditions.\n   */\n  private static shouldUseContentProjections(\n    oldWords: string[],\n    newWords: string[],\n    oldProjection: { contentWords: string[]; contentToOriginal: number[] },\n    newProjection: { contentWords: string[]; contentToOriginal: number[] }\n  ): boolean {\n    // One side has no content at all: that's a genuine addition/deletion, not a wrapper rename.\n    // Normalization would mis-attribute the wrappers as part of the diff.\n    if (oldProjection.contentWords.length === 0 || newProjection.contentWords.length === 0) return false\n\n    // Asymmetric structural state: one side has no structural wrappers at all (e.g. plain text\n    // vs. wrapped HTML). Normalization would force the equal output to use the unwrapped side's\n    // (missing) structure and emit dangling closing tags from the wrapped side. The plain\n    // word-level diff handles this correctly without normalization.\n    const oldHasStructuralTags = oldProjection.contentWords.length < oldWords.length\n    const newHasStructuralTags = newProjection.contentWords.length < newWords.length\n    if (oldHasStructuralTags !== newHasStructuralTags) return false\n\n    return true\n  }\n\n  /**\n   * Tags that commonly serve as content wrappers and may change structurally\n   * without affecting the actual content. Only these tags are stripped during\n   * structural normalization.\n   */\n  private static WrapperTags = new Set(['div', 'p', 'section', 'article', 'main', 'header', 'footer', 'aside', 'nav'])\n\n  private static isStructuralTag(word: string): boolean {\n    if (!Utils.isTag(word)) return false\n    const tagName = Utils.getTagName(word)\n    return HtmlDiff.WrapperTags.has(tagName)\n  }\n\n  /** True when the word is a structural opening tag (e.g. `<p>`, `<div>`). */\n  private static isOpeningStructuralTag(word: string): boolean {\n    return HtmlDiff.isStructuralTag(word) && !word.startsWith('</')\n  }\n\n  /**\n   * Returns true if words between structural tags are just whitespace (indentation).\n   */\n  private static isStructuralWhitespace(words: string[], index: number): boolean {\n    if (!Utils.isWhiteSpace(words[index])) return false\n\n    // Check if this whitespace is adjacent to a structural tag on either side\n    const prevIsStructural = index === 0 || HtmlDiff.isStructuralTag(words[index - 1])\n    const nextIsStructural = index === words.length - 1 || HtmlDiff.isStructuralTag(words[index + 1])\n    return prevIsStructural || nextIsStructural\n  }\n\n  private static createContentProjection(words: string[]): {\n    contentWords: string[]\n    contentToOriginal: number[]\n  } {\n    const contentWords: string[] = []\n    const contentToOriginal: number[] = []\n\n    for (let i = 0; i < words.length; i++) {\n      if (HtmlDiff.isStructuralTag(words[i])) continue\n      if (HtmlDiff.isStructuralWhitespace(words, i)) continue\n      contentWords.push(words[i])\n      contentToOriginal.push(i)\n    }\n\n    return { contentWords, contentToOriginal }\n  }\n\n  private static hasStructuralDifferences(oldWords: string[], newWords: string[]): boolean {\n    const oldStructural: string[] = []\n    const newStructural: string[] = []\n\n    // Compare only tag names (stripped of attributes) since structural normalization\n    // is about wrapper tag name changes (e.g. <p> vs <div>), not attribute differences.\n    // Attribute changes on the same tag name don't need projection-based normalization.\n    for (const w of oldWords) {\n      if (HtmlDiff.isStructuralTag(w)) {\n        oldStructural.push(Utils.stripTagAttributes(w))\n      }\n    }\n    for (const w of newWords) {\n      if (HtmlDiff.isStructuralTag(w)) {\n        newStructural.push(Utils.stripTagAttributes(w))\n      }\n    }\n\n    if (oldStructural.length !== newStructural.length) return true\n    for (let i = 0; i < oldStructural.length; i++) {\n      if (oldStructural[i] !== newStructural[i]) return true\n    }\n    return false\n  }\n\n  private performOperation(operation: Operation) {\n    switch (operation.action) {\n      case Action.Equal:\n        this.processEqualOperation(operation)\n        break\n      case Action.Delete:\n        this.processDeleteOperation(operation, 'diffdel')\n        break\n      case Action.Insert:\n        this.processInsertOperation(operation, 'diffins')\n        break\n      case Action.None:\n        break\n      case Action.Replace:\n        this.processReplaceOperation(operation)\n        break\n    }\n  }\n\n  private processReplaceOperation(operation: Operation) {\n    this.processDeleteOperation(operation, 'diffmod')\n    this.processInsertOperation(operation, 'diffmod')\n  }\n\n  private processInsertOperation(operation: Operation, cssClass: string) {\n    const words = this.usingContentProjections()\n      ? this.sliceOriginalWordsForOp('new', operation.startInNew, operation.endInNew)\n      : this.newWords.slice(operation.startInNew, operation.endInNew)\n    this.insertTag(HtmlDiff.InsTag, cssClass, words)\n  }\n\n  private processDeleteOperation(operation: Operation, cssClass: string) {\n    const words = this.usingContentProjections()\n      ? this.sliceOriginalWordsForOp('old', operation.startInOld, operation.endInOld)\n      : this.oldWords.slice(operation.startInOld, operation.endInOld)\n    this.insertTag(HtmlDiff.DelTag, cssClass, words)\n  }\n\n  private processEqualOperation(operation: Operation) {\n    if (this.usingContentProjections()) {\n      // Output from old to preserve old's HTML structure for the matched content.\n      const result = this.sliceOriginalWordsForOp('old', operation.startInOld, operation.endInOld)\n      this.content.push(result.join(''))\n\n      // Advance new-side tracking past the equivalent range in new so the next insert op\n      // resumes from the correct position. We compute new's range with the same rule used\n      // for old (rather than mirroring old's count) so the two sides are independently sound\n      // when their structural tags don't perfectly parallel each other.\n      this.sliceOriginalWordsForOp('new', operation.startInNew, operation.endInNew)\n    } else {\n      const result = this.newWords.slice(operation.startInNew, operation.endInNew)\n      this.content.push(result.join(''))\n    }\n  }\n\n  /** True when content projections are active for both sides — i.e. structural normalization is in effect. */\n  private usingContentProjections(): boolean {\n    return this.oldContentToOriginal !== null && this.newContentToOriginal !== null\n  }\n\n  /**\n   * Returns the slice of original (old or new) words covering a content-index range,\n   * including the structural tags that surround the content. Advances the side's cursor\n   * past the slice so the next op resumes correctly.\n   *\n   * The slice extends:\n   *   - LEADING: from the side's cursor (or the first content word's original index,\n   *     whichever is smaller) so structural tags that precede the first content word\n   *     are picked up by this op rather than left orphaned.\n   *   - TRAILING (non-last range): from just after the last content word, including\n   *     closing structural tags that close *this* op's paragraphs, but stopping at\n   *     the first opening structural tag — that opening tag belongs to the next\n   *     op's paragraph and would otherwise be emitted twice.\n   *   - TRAILING (last range): all the way to the end of words, since there is no next\n   *     op to claim the trailing tags.\n   */\n  private sliceOriginalWordsForOp(side: 'old' | 'new', contentStart: number, contentEnd: number): string[] {\n    const words = side === 'old' ? this.oldWords : this.newWords\n    const contentToOriginal = side === 'old' ? this.oldContentToOriginal : this.newContentToOriginal\n\n    if (!contentToOriginal) return words.slice(contentStart, contentEnd)\n    if (contentStart >= contentEnd) return []\n\n    const firstContentOrigIdx = contentToOriginal[contentStart]\n    const lastContentOrigIdx = contentToOriginal[contentEnd - 1]\n    const cursor = side === 'old' ? this.lastOriginalOldOutputIndex : this.lastOriginalNewOutputIndex\n    const origStart = Math.min(cursor, firstContentOrigIdx)\n\n    let origEnd: number\n    if (contentEnd < contentToOriginal.length) {\n      // Non-last range: walk trailing tags after the last content word, stopping at the\n      // first opening structural tag so it can be emitted by the next op.\n      const limit = contentToOriginal[contentEnd]\n      origEnd = lastContentOrigIdx + 1\n      while (origEnd < limit && !HtmlDiff.isOpeningStructuralTag(words[origEnd])) {\n        origEnd++\n      }\n    } else {\n      // Last range: include everything to the end.\n      origEnd = words.length\n    }\n\n    if (side === 'old') {\n      this.lastOriginalOldOutputIndex = origEnd\n    } else {\n      this.lastOriginalNewOutputIndex = origEnd\n    }\n\n    return words.slice(origStart, origEnd)\n  }\n\n  /**\n   * This method encloses words within a specified tag (ins or del), and adds this into \"content\",\n   * with a twist: if there are words contain tags, it actually creates multiple ins or del,\n   * so that they don't include any ins or del. This handles cases like\n   * old: '<p>a</p>'\n   * new: '<p>ab</p>\n   * <p>\n   *     c</b>'\n   *     diff result: '<p>a<ins>b</ins></p>\n   *     <p>\n   *         <ins>c</ins>\n   *     </p>\n   *     '\n   *     this still doesn't guarantee valid HTML (hint: think about diffing a text containing ins or\n   *     del tags), but handles correctly more cases than the earlier version.\n   *     P.S.: Spare a thought for people who write HTML browsers. They live in this ... every day.\n   * @param tag\n   * @param cssClass\n   * @param words\n   * @private\n   */\n  private insertTag(tag: string, cssClass: string, words: string[]) {\n    while (true) {\n      if (words.length === 0) {\n        break\n      }\n\n      const allWordsUntilFirstTag = this.extractConsecutiveWords(words, x => !Utils.isTag(x))\n      if (allWordsUntilFirstTag.length > 0) {\n        const text = Utils.wrapText(allWordsUntilFirstTag.join(''), tag, cssClass)\n        this.content.push(text)\n      }\n\n      const isInsertOpCompleted = words.length === 0\n      if (isInsertOpCompleted) {\n        break\n      }\n\n      // if there are still words left, they must start with a tag, but still can contain nonTag entries.\n      // e.g. </span></big>bar\n      // the remaining words need to be handled separately divided in a tagBlock, which definitely contains\n      // at least one word and a potentially existing second block which starts with a nonTag but may\n      // contain tags later on.\n      const indexOfFirstNonTag = words.findIndex(x => !Utils.isTag(x))\n\n      // if there are no nonTags, the whole block is a tagBlock and the index of the last tag is the last index of the block.\n      // if there are nonTags, the index of the last tag is the index before the first nonTag.\n      const indexLastTagInFirstTagBlock = indexOfFirstNonTag === -1 ? words.length - 1 : indexOfFirstNonTag - 1\n\n      let specialCaseTagInjection = ''\n      let specialCaseTagInjectionIsBefore = false\n\n      // handle opening tag\n      if (HtmlDiff.SpecialCaseOpeningTagRegex.test(words[0])) {\n        const tagNames = new Set<string>()\n        for (const word of words) {\n          if (Utils.isTag(word)) {\n            tagNames.add(Utils.getTagName(word))\n          }\n        }\n        const styledTagNames = Array.from(tagNames).join(' ')\n\n        this.specialTagDiffStack.push(words[0])\n        specialCaseTagInjection = `<ins class='mod ${styledTagNames}'>`\n        if (tag === HtmlDiff.DelTag) {\n          words.shift()\n\n          // following tags may be formatting tags as well, follow through\n          while (words.length > 0 && HtmlDiff.SpecialCaseOpeningTagRegex.test(words[0])) {\n            words.shift()\n          }\n        }\n      }\n      // handle closing tag\n      else if (HtmlDiff.SpecialCaseClosingTagsSet.has(words[0].toLowerCase())) {\n        const openingTag = this.specialTagDiffStack.length === 0 ? null : this.specialTagDiffStack.pop()\n        // For delete operations: when the tag block contains a mix of formatting and\n        // non-formatting closing tags (e.g. </strong></div>), compare against the first\n        // closing tag (the formatting one) rather than the last tag in the block.\n        // For purely formatting tag blocks (e.g. </i></strong>) or insert operations,\n        // use the last tag as before to match against the outermost opening tag.\n        let tagIndexToCompare = indexLastTagInFirstTagBlock\n        if (tag === HtmlDiff.DelTag && indexOfFirstNonTag === -1) {\n          const hasNonFormattingClosingTag = words\n            .slice(0, indexLastTagInFirstTagBlock + 1)\n            .some(w => !HtmlDiff.SpecialCaseClosingTagsSet.has(w.toLowerCase()))\n          if (hasNonFormattingClosingTag) {\n            tagIndexToCompare = 0\n          }\n        }\n        const openingAndClosingTagsMatch =\n          !!openingTag && Utils.getTagName(openingTag) === Utils.getTagName(words[tagIndexToCompare])\n\n        if (openingTag && openingAndClosingTagsMatch) {\n          specialCaseTagInjection = '</ins>'\n          specialCaseTagInjectionIsBefore = true\n        }\n\n        // if the tag has a corresponding opening tag, but they don't match,\n        // we need to push the opening tag back onto the stack\n        else if (openingTag) {\n          this.specialTagDiffStack.push(openingTag)\n        }\n\n        if (tag === HtmlDiff.DelTag) {\n          words.shift()\n          // following tags may be formatting tags as well, follow through\n          while (words.length > 0 && HtmlDiff.SpecialCaseClosingTagsSet.has(words[0].toLowerCase())) {\n            words.shift()\n          }\n        }\n      }\n\n      if (words.length === 0 && specialCaseTagInjection.length === 0) {\n        break\n      }\n\n      // For delete operations, only extract non-formatting tags. Formatting tags (special case\n      // opening/closing tags) need to be handled in the next loop iteration so they go through\n      // the proper specialTagDiffStack logic. Otherwise, opening formatting tags get output as\n      // plain tags and their corresponding closing tags are later discarded, producing invalid HTML.\n      const isTagForExtraction =\n        tag === HtmlDiff.DelTag\n          ? (x: string) =>\n              Utils.isTag(x) &&\n              !HtmlDiff.SpecialCaseOpeningTagRegex.test(x) &&\n              !HtmlDiff.SpecialCaseClosingTagsSet.has(x.toLowerCase())\n          : Utils.isTag\n\n      if (specialCaseTagInjectionIsBefore) {\n        this.content.push(specialCaseTagInjection + this.extractConsecutiveWords(words, isTagForExtraction).join(''))\n      } else {\n        this.content.push(this.extractConsecutiveWords(words, isTagForExtraction).join('') + specialCaseTagInjection)\n      }\n\n      if (words.length === 0) continue\n\n      // if there are still words left, they must start with a nonTag and need to be handled in the next iteration.\n      this.insertTag(tag, cssClass, words)\n      break\n    }\n  }\n\n  private extractConsecutiveWords(words: string[], condition: (character: string) => boolean): string[] {\n    let indexOfFirstTag: number | null = null\n    for (let i = 0; i < words.length; i++) {\n      const word = words[i]\n      if (i === 0 && word === ' ') {\n        words[i] = '&nbsp;'\n      }\n      if (!condition(word)) {\n        indexOfFirstTag = i\n        break\n      }\n    }\n\n    if (indexOfFirstTag !== null) {\n      const items = words.slice(0, indexOfFirstTag)\n      if (indexOfFirstTag > 0) {\n        words.splice(0, indexOfFirstTag)\n      }\n      return items\n    }\n\n    const items = words.slice(0)\n    words.splice(0, words.length)\n    return items\n  }\n\n  private operations(): Operation[] {\n    let positionInOld = 0\n    let positionInNew = 0\n    const operations: Operation[] = []\n\n    const wordsForDiffOld = this.oldContentWords ?? this.oldWords\n    const wordsForDiffNew = this.newContentWords ?? this.newWords\n\n    const matches = this.matchingBlocks()\n    matches.push(new Match(wordsForDiffOld.length, wordsForDiffNew.length, 0))\n\n    //Remove orphans from matches.\n    //If distance between left and right matches is 4 times longer than length of current match then it is considered as orphan\n    const matchesWithoutOrphans = this.removeOrphans(matches)\n\n    for (const match of matchesWithoutOrphans) {\n      const matchStartsAtCurrentPositionInOld = positionInOld === match.startInOld\n      const matchStartsAtCurrentPositionInNew = positionInNew === match.startInNew\n\n      let action: Action\n\n      if (!matchStartsAtCurrentPositionInOld && !matchStartsAtCurrentPositionInNew) {\n        action = Action.Replace\n      } else if (matchStartsAtCurrentPositionInOld && !matchStartsAtCurrentPositionInNew) {\n        action = Action.Insert\n      } else if (!matchStartsAtCurrentPositionInOld) {\n        action = Action.Delete\n      } // This occurs if the first few words are the same in both versions\n      else {\n        action = Action.None\n      }\n\n      if (action !== Action.None) {\n        operations.push(new Operation(action, positionInOld, match.startInOld, positionInNew, match.startInNew))\n      }\n\n      if (match.size !== 0) {\n        operations.push(new Operation(Action.Equal, match.startInOld, match.endInOld, match.startInNew, match.endInNew))\n      }\n\n      positionInOld = match.endInOld\n      positionInNew = match.endInNew\n    }\n\n    return operations\n  }\n\n  private *removeOrphans(matches: Match[]) {\n    const wordsForDiffOld = this.oldContentWords ?? this.oldWords\n    const wordsForDiffNew = this.newContentWords ?? this.newWords\n\n    let prev: Match = new Match(0, 0, 0)\n    let curr: Match | null = null\n\n    for (const next of matches) {\n      if (curr === null) {\n        curr = next\n        continue\n      }\n\n      if (\n        (prev.endInOld === curr.startInOld && prev.endInNew === curr.startInNew) ||\n        (curr.endInOld === next.startInOld && curr.endInNew === next.startInNew)\n      ) {\n        //if match has no diff on the left or on the right\n        yield curr\n        prev = curr\n        curr = next\n        continue\n      }\n\n      let oldDistanceInChars = 0\n      for (let i = prev.endInOld; i < next.startInOld; i++) {\n        oldDistanceInChars += wordsForDiffOld[i].length\n      }\n      let newDistanceInChars = 0\n      for (let i = prev.endInNew; i < next.startInNew; i++) {\n        newDistanceInChars += wordsForDiffNew[i].length\n      }\n      let currMatchLengthInChars = 0\n      for (let i = curr.startInNew; i < curr.endInNew; i++) {\n        currMatchLengthInChars += wordsForDiffNew[i].length\n      }\n\n      if (currMatchLengthInChars > Math.max(oldDistanceInChars, newDistanceInChars) * this.orphanMatchThreshold) {\n        yield curr\n      }\n\n      prev = curr\n      curr = next\n    }\n\n    if (curr !== null) {\n      yield curr //assume that the last match is always vital\n    }\n  }\n\n  private matchingBlocks(): Match[] {\n    const wordsForDiffOld = this.oldContentWords ?? this.oldWords\n    const wordsForDiffNew = this.newContentWords ?? this.newWords\n    const matchingBlocks: Match[] = []\n    this.findMatchingBlocks(0, wordsForDiffOld.length, 0, wordsForDiffNew.length, matchingBlocks)\n    return matchingBlocks\n  }\n\n  private findMatchingBlocks(\n    startInOld: number,\n    endInOld: number,\n    startInNew: number,\n    endInNew: number,\n    matchingBlocks: Match[]\n  ) {\n    const match = this.findMatch(startInOld, endInOld, startInNew, endInNew)\n\n    if (match !== null) {\n      if (startInOld < match.startInOld && startInNew < match.startInNew) {\n        this.findMatchingBlocks(startInOld, match.startInOld, startInNew, match.startInNew, matchingBlocks)\n      }\n\n      matchingBlocks.push(match)\n\n      if (match.endInOld < endInOld && match.endInNew < endInNew) {\n        this.findMatchingBlocks(match.endInOld, endInOld, match.endInNew, endInNew, matchingBlocks)\n      }\n    }\n  }\n\n  private findMatch(startInOld: number, endInOld: number, startInNew: number, endInNew: number): Match | null {\n    const wordsForDiffOld = this.oldContentWords ?? this.oldWords\n    const wordsForDiffNew = this.newContentWords ?? this.newWords\n\n    // For large texts it is more likely that there is a Match of size bigger than maximum granularity.\n    // If not then go down and try to find it with smaller granularity.\n    for (let i = this.matchGranularity; i > 0; i--) {\n      const options = {\n        blockSize: i,\n        repeatingWordsAccuracy: this.repeatingWordsAccuracy,\n        ignoreWhitespaceDifferences: this.ignoreWhitespaceDifferences,\n      }\n      const finder = new MatchFinder(\n        wordsForDiffOld,\n        wordsForDiffNew,\n        startInOld,\n        endInOld,\n        startInNew,\n        endInNew,\n        options\n      )\n      const match = finder.findMatch()\n      if (match !== null) return match\n    }\n    return null\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"HtmlDiff.cjs","names":["Utils","Utils","Utils"],"sources":["../src/Match.ts","../src/Utils.ts","../src/MatchFinder.ts","../src/Operation.ts","../src/WordSplitter.ts","../src/HtmlDiff.ts"],"sourcesContent":["export default class Match {\n  private _startInOld: number\n  private _startInNew: number\n  private _size: number\n\n  constructor(startInOld: number, startInNew: number, size: number) {\n    this._startInOld = startInOld\n    this._startInNew = startInNew\n    this._size = size\n  }\n\n  get startInOld() {\n    return this._startInOld\n  }\n\n  get startInNew() {\n    return this._startInNew\n  }\n\n  get size() {\n    return this._size\n  }\n\n  get endInOld() {\n    return this._startInOld + this._size\n  }\n\n  get endInNew() {\n    return this._startInNew + this._size\n  }\n}\n","const openingTagRegex = /^\\s*<[^>]+>\\s*$/\nconst closingTagTexRegex = /^\\s*<\\/[^>]+>\\s*$/\nconst tagWordRegex = /<[^\\s>]+/\nconst whitespaceRegex = /^(\\s|&nbsp;)+$/\nconst wordRegex = /[\\w#@]+/\nconst tagRegex = /<\\/?(?<name>[^\\s/>]+)[^>]*>/\n\nconst SpecialCaseWordTags: readonly string[] = ['<img']\n\nexport function isTag(item: string): boolean {\n  if (SpecialCaseWordTags.some(re => item?.startsWith(re))) {\n    return false\n  }\n\n  return isOpeningTag(item) || isClosingTag(item)\n}\n\nfunction isOpeningTag(item: string): boolean {\n  return openingTagRegex.test(item)\n}\n\nfunction isClosingTag(item: string): boolean {\n  return closingTagTexRegex.test(item)\n}\n\nexport function stripTagAttributes(word: string): string {\n  const match = tagWordRegex.exec(word)\n  if (match) {\n    return `${match[0]}${word.endsWith('/>') ? '/>' : '>'}`\n  }\n\n  return word\n}\n\nexport function wrapText(text: string, tagName: string, cssClass: string): string {\n  return `<${tagName} class='${cssClass}'>${text}</${tagName}>`\n}\n\nexport function isStartOfTag(val: string): boolean {\n  return val === '<'\n}\n\nexport function isEndOfTag(val: string): boolean {\n  return val === '>'\n}\n\nexport function isStartOfEntity(val: string): boolean {\n  return val === '&'\n}\n\nexport function isEndOfEntity(val: string): boolean {\n  return val === ';'\n}\n\nexport function isWhiteSpace(value: string): boolean {\n  return whitespaceRegex.test(value)\n}\n\nexport function stripAnyAttributes(word: string): string {\n  if (isTag(word)) {\n    return stripTagAttributes(word)\n  }\n\n  return word\n}\n\nexport function isWord(text: string): boolean {\n  return wordRegex.test(text)\n}\n\nexport function getTagName(word: string | null): string {\n  if (word === null) {\n    return ''\n  }\n\n  const match = tagRegex.exec(word)\n  if (match) {\n    return match.groups?.name.toLowerCase() ?? match[1].toLowerCase()\n  }\n\n  return ''\n}\n\nexport default {\n  isTag,\n  stripTagAttributes,\n  wrapText,\n  isStartOfTag,\n  isEndOfTag,\n  isStartOfEntity,\n  isEndOfEntity,\n  isWhiteSpace,\n  stripAnyAttributes,\n  isWord,\n  getTagName,\n}\n","import Match from './Match'\nimport type MatchOptions from './MatchOptions'\nimport Utils from './Utils'\n\n/**\n * Finds the longest match in given texts. It uses indexing with fixed granularity that is used to compare blocks of text.\n */\nexport default class MatchFinder {\n  private oldWords: string[]\n  private newWords: string[]\n  private startInOld: number\n  private endInOld: number\n  private startInNew: number\n  private endInNew: number\n  private wordIndices: { [word: string]: number[] } = {}\n  private options: MatchOptions\n\n  constructor(\n    oldWords: string[],\n    newWords: string[],\n    startInOld: number,\n    endInOld: number,\n    startInNew: number,\n    endInNew: number,\n    options: MatchOptions\n  ) {\n    this.oldWords = oldWords\n    this.newWords = newWords\n    this.startInOld = startInOld\n    this.endInOld = endInOld\n    this.startInNew = startInNew\n    this.endInNew = endInNew\n    this.options = options\n  }\n\n  private indexNewWords() {\n    this.wordIndices = {}\n    const block: string[] = []\n    for (let i = this.startInNew; i < this.endInNew; i++) {\n      // if word is a tag, we should ignore attributes as attribute changes are not supported (yet)\n      const word = this.normalizeForIndex(this.newWords[i])\n      const key = MatchFinder.putNewWord(block, word, this.options.blockSize)\n\n      if (key === null) {\n        continue\n      }\n\n      if (!this.wordIndices[key]) {\n        this.wordIndices[key] = []\n      }\n      this.wordIndices[key].push(i)\n    }\n  }\n\n  private static putNewWord(block: string[], word: string, blockSize: number): string | null {\n    block.push(word)\n\n    if (block.length > blockSize) {\n      block.shift()\n    }\n\n    if (block.length !== blockSize) {\n      return null\n    }\n\n    return block.join('')\n  }\n\n  private normalizeForIndex(word: string): string {\n    const output = Utils.stripAnyAttributes(word)\n    if (this.options.ignoreWhitespaceDifferences && Utils.isWhiteSpace(output)) {\n      return ' '\n    }\n\n    return output\n  }\n\n  findMatch(): Match | null {\n    this.indexNewWords()\n    this.removeRepeatingWords()\n\n    let hasIndices = false\n    for (const _key in this.wordIndices) {\n      hasIndices = true\n      break\n    }\n    if (!hasIndices) {\n      return null\n    }\n\n    let bestMatchInOld = this.startInOld\n    let bestMatchInNew = this.startInNew\n    let bestMatchSize = 0\n\n    let matchLengthAt: Map<number, number> = new Map()\n    const block: string[] = []\n\n    for (let indexInOld = this.startInOld; indexInOld < this.endInOld; indexInOld++) {\n      const word = this.normalizeForIndex(this.oldWords[indexInOld])\n      const index = MatchFinder.putNewWord(block, word, this.options.blockSize)\n\n      if (index === null) {\n        continue\n      }\n\n      const newMatchLengthAt: Map<number, number> = new Map()\n\n      if (!this.wordIndices[index]) {\n        matchLengthAt = newMatchLengthAt\n        continue\n      }\n\n      for (const indexInNew of this.wordIndices[index]) {\n        // biome-ignore lint/style/noNonNullAssertion: This is safe as guarded by has()\n        const newMatchLength = (matchLengthAt.has(indexInNew - 1) ? matchLengthAt.get(indexInNew - 1)! : 0) + 1\n        newMatchLengthAt.set(indexInNew, newMatchLength)\n\n        if (newMatchLength > bestMatchSize) {\n          bestMatchInOld = indexInOld - newMatchLength - this.options.blockSize + 2\n          bestMatchInNew = indexInNew - newMatchLength - this.options.blockSize + 2\n          bestMatchSize = newMatchLength\n        }\n      }\n\n      matchLengthAt = newMatchLengthAt\n    }\n\n    return bestMatchSize !== 0\n      ? new Match(bestMatchInOld, bestMatchInNew, bestMatchSize + this.options.blockSize - 1)\n      : null\n  }\n\n  /**\n   * This method removes words that occur too many times. This way it reduces total count of comparison operations\n   * and as result the diff algorithm takes less time. But the side effect is that it may detect false differences of\n   * the repeating words.\n   * @private\n   */\n  private removeRepeatingWords() {\n    const threshold = this.newWords.length * this.options.repeatingWordsAccuracy\n    const repeatingWords = Object.entries(this.wordIndices)\n      .filter(([, indices]) => indices.length > threshold)\n      .map(([word]) => word)\n\n    for (const w of repeatingWords) {\n      delete this.wordIndices[w]\n    }\n  }\n}\n","import type Action from './Action'\n\nexport default class Operation {\n  action: Action\n  startInOld: number\n  endInOld: number\n  startInNew: number\n  endInNew: number\n\n  constructor(action: Action, startInOld: number, endInOld: number, startInNew: number, endInNew: number) {\n    this.action = action\n    this.startInOld = startInOld\n    this.endInOld = endInOld\n    this.startInNew = startInNew\n    this.endInNew = endInNew\n  }\n}\n","import Mode from './Mode'\nimport Utils from './Utils'\n\nexport default class WordSplitter {\n  private text: string\n  private isBlockCheckRequired: boolean\n  private blockLocations: BlockFinderResult\n  private mode: Mode\n  private isGrouping = false\n  private globbingUntil: number\n  private currentWord: string[]\n  private words: string[]\n  private static NotGlobbing = -1\n\n  private get currentWordHasChars() {\n    return this.currentWord.length > 0\n  }\n\n  constructor(text: string, blockExpressions: RegExp[]) {\n    this.text = text\n    this.blockLocations = new BlockFinder(text, blockExpressions).findBlocks()\n    this.isBlockCheckRequired = this.blockLocations.hasBlocks\n    this.mode = Mode.Character\n    this.globbingUntil = WordSplitter.NotGlobbing\n    this.currentWord = []\n    this.words = []\n  }\n\n  process(): string[] {\n    for (let index = 0; index < this.text.length; index++) {\n      const character = this.text.charAt(index)\n      this.processCharacter(index, character)\n    }\n\n    this.appendCurrentWordToWords()\n    return this.words\n  }\n\n  private processCharacter(index: number, character: string) {\n    if (this.isGlobbing(index, character)) {\n      return\n    }\n\n    switch (this.mode) {\n      case Mode.Character:\n        this.processTextCharacter(character)\n        break\n      case Mode.Tag:\n        this.processHtmlTagContinuation(character)\n        break\n      case Mode.Whitespace:\n        this.processWhiteSpaceContinuation(character)\n        break\n      case Mode.Entity:\n        this.processEntityContinuation(character)\n        break\n    }\n  }\n\n  private processEntityContinuation(character: string) {\n    if (Utils.isStartOfTag(character)) {\n      this.appendCurrentWordToWords()\n      this.currentWord.push(character)\n      this.mode = Mode.Tag\n    } else if (character.trim().length === 0) {\n      this.appendCurrentWordToWords()\n      this.currentWord.push(character)\n      this.mode = Mode.Whitespace\n    } else if (Utils.isEndOfEntity(character)) {\n      let switchToNextMode = true\n      if (this.currentWordHasChars) {\n        this.currentWord.push(character)\n        this.words.push(this.currentWord.join(''))\n\n        //join &nbsp; entity with last whitespace\n        if (\n          this.words.length > 2 &&\n          Utils.isWhiteSpace(this.words[this.words.length - 2]) &&\n          Utils.isWhiteSpace(this.words[this.words.length - 1])\n        ) {\n          const w1 = this.words[this.words.length - 2]\n          const w2 = this.words[this.words.length - 1]\n          this.words.splice(this.words.length - 2, 2)\n          this.currentWord = `${w1}${w2}`.split('')\n          this.mode = Mode.Whitespace\n          switchToNextMode = false\n        }\n      }\n\n      if (switchToNextMode) {\n        this.currentWord = []\n        this.mode = Mode.Character\n      }\n    } else if (Utils.isWord(character)) {\n      this.currentWord.push(character)\n    } else {\n      this.appendCurrentWordToWords()\n      this.currentWord.push(character)\n      this.mode = Mode.Character\n    }\n  }\n\n  private processWhiteSpaceContinuation(character: string) {\n    if (Utils.isStartOfTag(character)) {\n      this.appendCurrentWordToWords()\n      this.currentWord.push(character)\n      this.mode = Mode.Tag\n    } else if (Utils.isStartOfEntity(character)) {\n      this.appendCurrentWordToWords()\n      this.currentWord.push(character)\n      this.mode = Mode.Entity\n    } else if (Utils.isWhiteSpace(character)) {\n      this.currentWord.push(character)\n    } else {\n      this.appendCurrentWordToWords()\n      this.currentWord.push(character)\n      this.mode = Mode.Character\n    }\n  }\n\n  private processHtmlTagContinuation(character: string) {\n    if (Utils.isEndOfTag(character)) {\n      this.currentWord.push(character)\n      this.appendCurrentWordToWords()\n      this.mode = Utils.isWhiteSpace(character) ? Mode.Whitespace : Mode.Character\n    } else {\n      this.currentWord.push(character)\n    }\n  }\n\n  private processTextCharacter(character: string) {\n    if (Utils.isStartOfTag(character)) {\n      this.appendCurrentWordToWords()\n      this.currentWord.push('<')\n      this.mode = Mode.Tag\n    } else if (Utils.isStartOfEntity(character)) {\n      this.appendCurrentWordToWords()\n      this.currentWord.push(character)\n      this.mode = Mode.Entity\n    } else if (Utils.isWhiteSpace(character)) {\n      this.appendCurrentWordToWords()\n      this.currentWord.push(character)\n      this.mode = Mode.Whitespace\n    } else if (\n      Utils.isWord(character) &&\n      (this.currentWord.length === 0 || Utils.isWord(this.currentWord[this.currentWord.length - 1]))\n    ) {\n      this.currentWord.push(character)\n    } else {\n      this.appendCurrentWordToWords()\n      this.currentWord.push(character)\n    }\n  }\n\n  private appendCurrentWordToWords() {\n    if (this.currentWordHasChars) {\n      this.words.push(this.currentWord.join(''))\n      this.currentWord = []\n    }\n  }\n\n  private isGlobbing(index: number, character: string): boolean {\n    if (!this.isBlockCheckRequired) {\n      return false\n    }\n    const isCurrentBlockTerminating = index === this.globbingUntil\n    if (isCurrentBlockTerminating) {\n      this.globbingUntil = WordSplitter.NotGlobbing\n      this.isGrouping = false\n      this.appendCurrentWordToWords()\n    }\n\n    const until = this.blockLocations.isInBlock(index)\n    if (until) {\n      this.isGrouping = true\n      this.globbingUntil = until\n    }\n    if (this.isGrouping) {\n      this.currentWord.push(character)\n      this.mode = Mode.Character\n    }\n    return this.isGrouping\n  }\n\n  static convertHtmlToListOfWords(text: string, blockExpressions: RegExp[]): string[] {\n    return new WordSplitter(text, blockExpressions).process()\n  }\n}\n\nclass BlockFinderResult {\n  private blocks: Map<number, number> = new Map()\n\n  addBlock(from: number, to: number) {\n    if (this.blocks.has(from)) {\n      throw new ArgumentError('One or more block expressions result in a text sequence that overlaps.')\n    }\n\n    this.blocks.set(from, to)\n  }\n\n  isInBlock(location: number): number | null {\n    return this.blocks.get(location) ?? null\n  }\n\n  get hasBlocks() {\n    return this.blocks.size > 0\n  }\n}\n\nclass ArgumentError extends Error {}\n\nclass BlockFinder {\n  private text: string\n  private blockExpressions: RegExp[]\n\n  constructor(text: string, blockExpressions: RegExp[]) {\n    this.text = text\n    this.blockExpressions = blockExpressions\n  }\n\n  findBlocks(): BlockFinderResult {\n    const result = new BlockFinderResult()\n    for (const expression of this.blockExpressions) {\n      this.processBlockMatcher(expression, result)\n    }\n    return result\n  }\n\n  private processBlockMatcher(exp: RegExp, result: BlockFinderResult) {\n    let match: RegExpExecArray | null\n    // biome-ignore lint/suspicious/noAssignInExpressions: Couldn't think of a nicer way to do this\n    while ((match = exp.exec(this.text)) !== null) {\n      this.tryAddBlock(exp, match, result)\n    }\n  }\n\n  private tryAddBlock(exp: RegExp, match: RegExpExecArray, result: BlockFinderResult) {\n    try {\n      const from = match.index\n      const to = match.index + match[0].length\n      result.addBlock(from, to)\n    } catch {\n      throw new ArgumentError(\n        `One or more block expressions result in a text sequence that overlaps. Current expression: ${exp}`\n      )\n    }\n  }\n}\n","import Action from './Action'\nimport Match from './Match'\nimport MatchFinder from './MatchFinder'\nimport Operation from './Operation'\nimport Utils from './Utils'\nimport WordSplitter from './WordSplitter'\n\nexport default class HtmlDiff {\n  /**\n   * This value defines balance between speed and memory utilization. The higher it is the faster it works and more memory consumes.\n   * @private\n   */\n  private static MatchGranularityMaximum = 4\n\n  private static DelTag = 'del'\n  private static InsTag = 'ins'\n\n  // ignore case\n  private static SpecialCaseClosingTags = [\n    '</strong>',\n    '</em>',\n    '</b>',\n    '</i>',\n    '</big>',\n    '</small>',\n    '</u>',\n    '</sub>',\n    '</sup>',\n    '</strike>',\n    '</s>',\n    '</span>',\n  ]\n\n  private static SpecialCaseClosingTagsSet = new Set([\n    '</strong>',\n    '</em>',\n    '</b>',\n    '</i>',\n    '</big>',\n    '</small>',\n    '</u>',\n    '</sub>',\n    '</sup>',\n    '</strike>',\n    '</s>',\n    '</span>',\n  ])\n\n  private static SpecialCaseOpeningTagRegex =\n    /<((strong)|(b)|(i)|(em)|(big)|(small)|(u)|(sub)|(sup)|(strike)|(s)|(span))[>\\s]+/i\n\n  private static FormattingTags = new Set([\n    'strong',\n    'em',\n    'b',\n    'i',\n    'big',\n    'small',\n    'u',\n    'sub',\n    'sup',\n    'strike',\n    's',\n    'span',\n  ])\n\n  private content: string[] = []\n  private newText: string\n  private oldText: string\n\n  private specialTagDiffStack: string[] = []\n  private newWords: string[] = []\n  private oldWords: string[] = []\n  /**\n   * Content-only projections of oldWords/newWords (structural tags and adjacent whitespace removed).\n   * When null, no structural normalization is applied (the word arrays are identical for diffing).\n   */\n  private oldContentWords: string[] | null = null\n  private newContentWords: string[] | null = null\n  /** Maps content-word index → original word index */\n  private oldContentToOriginal: number[] | null = null\n  private newContentToOriginal: number[] | null = null\n  /**\n   * Tracks the next unwritten word index in oldWords/newWords. Mutated only by\n   * {@link sliceOriginalWordsForOp} (each op reads a slice and advances its cursor).\n   * Advances monotonically. Used so:\n   *   - subsequent equal/delete ops know where in old to resume from\n   *   - subsequent insert ops know where in new to resume from\n   * The two cursors are independent: equal/delete output from old and advance the old\n   * cursor; insert outputs from new and advances the new cursor.\n   */\n  private lastOriginalOldOutputIndex = 0\n  private lastOriginalNewOutputIndex = 0\n  private matchGranularity = 0\n  private blockExpressions: RegExp[] = []\n\n  /**\n   * Defines how to compare repeating words. Valid values are from 0 to 1.\n   * This value allows to exclude some words from comparison that eventually\n   * reduces the total time of the diff algorithm.\n   * 0 means that all words are excluded so the diff will not find any matching words at all.\n   * 1 (default value) means that all words participate in comparison so this is the most accurate case.\n   * 0.5 means that any word that occurs more than 50% times may be excluded from comparison. This doesn't\n   * mean that such words will definitely be excluded but only gives a permission to exclude them if necessary.\n   */\n  repeatingWordsAccuracy = 1.0\n\n  /**\n   * If true all whitespaces are considered as equal\n   */\n  ignoreWhitespaceDifferences = false\n\n  /**\n   * If some match is too small and located far from its neighbors then it is considered as orphan\n   * and removed. For example:\n   * <code>\n   * aaaaa bb ccccccccc dddddd ee\n   * 11111 bb 222222222 dddddd ee\n   * </code>\n   * will find two matches <code>bb</code> and <code>dddddd ee</code> but the first will be considered\n   * as orphan and ignored, as result it will consider texts <code>aaaaa bb ccccccccc</code> and\n   * <code>11111 bb 222222222</code> as single replacement:\n   * <code>\n   * &lt;del&gt;aaaaa bb ccccccccc&lt;/del&gt;&lt;ins&gt;11111 bb 222222222&lt;/ins&gt; dddddd ee\n   * </code>\n   * This property defines relative size of the match to be considered as orphan, from 0 to 1.\n   * 1 means that all matches will be considered as orphans.\n   * 0 (default) means that no match will be considered as orphan.\n   * 0.2 means that if match length is less than 20% of distance between its neighbors it is considered as orphan.\n   */\n  orphanMatchThreshold = 0.0\n\n  /**\n   * Initializes a new instance of the class.\n   * @param oldText The old text.\n   * @param newText The new text.\n   */\n  constructor(oldText: string, newText: string) {\n    this.oldText = oldText\n    this.newText = newText\n  }\n\n  static execute(oldText: string, newText: string) {\n    return new HtmlDiff(oldText, newText).build()\n  }\n\n  /**\n   * Builds the HTML diff output\n   * @return HTML diff markup\n   */\n  build(): string {\n    // If there is no difference, don't bother checking for differences\n    if (this.oldText === this.newText) {\n      return this.newText\n    }\n\n    this.splitInputsToWords()\n    this.buildContentProjections()\n\n    const wordsForDiffOld = this.oldContentWords ?? this.oldWords\n    const wordsForDiffNew = this.newContentWords ?? this.newWords\n\n    this.matchGranularity = Math.min(\n      HtmlDiff.MatchGranularityMaximum,\n      Math.min(wordsForDiffOld.length, wordsForDiffNew.length)\n    )\n\n    const operations = this.operations()\n    for (const op of operations) {\n      this.performOperation(op)\n    }\n\n    return this.content.join('')\n  }\n\n  /**\n   * Uses {@link expression} to group text together so that any change detected within the group is treated as a single block\n   * @param expression\n   */\n  addBlockExpression(expression: RegExp) {\n    this.blockExpressions.push(expression)\n  }\n\n  private splitInputsToWords() {\n    this.oldWords = WordSplitter.convertHtmlToListOfWords(this.oldText, this.blockExpressions)\n\n    // free memory, allow it for GC\n    this.oldText = ''\n\n    this.newWords = WordSplitter.convertHtmlToListOfWords(this.newText, this.blockExpressions)\n\n    // free memory, allow it for GC\n    this.newText = ''\n  }\n\n  /**\n   * Builds \"content projections\" — word arrays with structural wrapper tags stripped — when\n   * structural normalization is appropriate for these inputs. The diff algorithm operates on\n   * the projections so wrapper-tag differences (e.g. `<p>` vs `<div>`) don't appear as content\n   * changes; structural tags are then folded back in at output time.\n   */\n  private buildContentProjections() {\n    if (!HtmlDiff.hasStructuralDifferences(this.oldWords, this.newWords)) return\n\n    const oldProjection = HtmlDiff.createContentProjection(this.oldWords)\n    const newProjection = HtmlDiff.createContentProjection(this.newWords)\n\n    if (!HtmlDiff.shouldUseContentProjections(this.oldWords, this.newWords, oldProjection, newProjection)) {\n      return\n    }\n\n    this.oldContentWords = oldProjection.contentWords\n    this.oldContentToOriginal = oldProjection.contentToOriginal\n    this.newContentWords = newProjection.contentWords\n    this.newContentToOriginal = newProjection.contentToOriginal\n  }\n\n  /**\n   * Decides whether structural normalization should be activated for this pair of inputs.\n   * Each clause is a distinct correctness or fitness check — extend by adding a named\n   * sub-predicate rather than chaining ad-hoc conditions.\n   */\n  private static shouldUseContentProjections(\n    oldWords: string[],\n    newWords: string[],\n    oldProjection: { contentWords: string[]; contentToOriginal: number[] },\n    newProjection: { contentWords: string[]; contentToOriginal: number[] }\n  ): boolean {\n    // One side has no content at all: that's a genuine addition/deletion, not a wrapper rename.\n    // Normalization would mis-attribute the wrappers as part of the diff.\n    if (oldProjection.contentWords.length === 0 || newProjection.contentWords.length === 0) return false\n\n    // Asymmetric structural state: one side has no structural wrappers at all (e.g. plain text\n    // vs. wrapped HTML). Normalization would force the equal output to use the unwrapped side's\n    // (missing) structure and emit dangling closing tags from the wrapped side. The plain\n    // word-level diff handles this correctly without normalization.\n    const oldHasStructuralTags = oldProjection.contentWords.length < oldWords.length\n    const newHasStructuralTags = newProjection.contentWords.length < newWords.length\n    if (oldHasStructuralTags !== newHasStructuralTags) return false\n\n    return true\n  }\n\n  /**\n   * Tags that commonly serve as content wrappers and may change structurally\n   * without affecting the actual content. Only these tags are stripped during\n   * structural normalization.\n   */\n  private static WrapperTags = new Set(['div', 'p', 'section', 'article', 'main', 'header', 'footer', 'aside', 'nav'])\n\n  private static isStructuralTag(word: string): boolean {\n    if (!Utils.isTag(word)) return false\n    const tagName = Utils.getTagName(word)\n    return HtmlDiff.WrapperTags.has(tagName)\n  }\n\n  /** True when the word is a structural opening tag (e.g. `<p>`, `<div>`). */\n  private static isOpeningStructuralTag(word: string): boolean {\n    return HtmlDiff.isStructuralTag(word) && !word.startsWith('</')\n  }\n\n  /**\n   * Returns true if words between structural tags are just whitespace (indentation).\n   */\n  private static isStructuralWhitespace(words: string[], index: number): boolean {\n    if (!Utils.isWhiteSpace(words[index])) return false\n\n    // Check if this whitespace is adjacent to a structural tag on either side\n    const prevIsStructural = index === 0 || HtmlDiff.isStructuralTag(words[index - 1])\n    const nextIsStructural = index === words.length - 1 || HtmlDiff.isStructuralTag(words[index + 1])\n    return prevIsStructural || nextIsStructural\n  }\n\n  private static createContentProjection(words: string[]): {\n    contentWords: string[]\n    contentToOriginal: number[]\n  } {\n    const contentWords: string[] = []\n    const contentToOriginal: number[] = []\n\n    for (let i = 0; i < words.length; i++) {\n      if (HtmlDiff.isStructuralTag(words[i])) continue\n      if (HtmlDiff.isStructuralWhitespace(words, i)) continue\n      contentWords.push(words[i])\n      contentToOriginal.push(i)\n    }\n\n    return { contentWords, contentToOriginal }\n  }\n\n  private static hasStructuralDifferences(oldWords: string[], newWords: string[]): boolean {\n    const oldStructural: string[] = []\n    const newStructural: string[] = []\n\n    // Compare only tag names (stripped of attributes) since structural normalization\n    // is about wrapper tag name changes (e.g. <p> vs <div>), not attribute differences.\n    // Attribute changes on the same tag name don't need projection-based normalization.\n    for (const w of oldWords) {\n      if (HtmlDiff.isStructuralTag(w)) {\n        oldStructural.push(Utils.stripTagAttributes(w))\n      }\n    }\n    for (const w of newWords) {\n      if (HtmlDiff.isStructuralTag(w)) {\n        newStructural.push(Utils.stripTagAttributes(w))\n      }\n    }\n\n    if (oldStructural.length !== newStructural.length) return true\n    for (let i = 0; i < oldStructural.length; i++) {\n      if (oldStructural[i] !== newStructural[i]) return true\n    }\n    return false\n  }\n\n  private performOperation(operation: Operation) {\n    switch (operation.action) {\n      case Action.Equal:\n        this.processEqualOperation(operation)\n        break\n      case Action.Delete:\n        this.processDeleteOperation(operation, 'diffdel')\n        break\n      case Action.Insert:\n        this.processInsertOperation(operation, 'diffins')\n        break\n      case Action.None:\n        break\n      case Action.Replace:\n        this.processReplaceOperation(operation)\n        break\n    }\n  }\n\n  private processReplaceOperation(operation: Operation) {\n    this.processDeleteOperation(operation, 'diffmod')\n    this.processInsertOperation(operation, 'diffmod')\n  }\n\n  private processInsertOperation(operation: Operation, cssClass: string) {\n    const words = this.usingContentProjections()\n      ? this.sliceOriginalWordsForOp('new', operation.startInNew, operation.endInNew)\n      : this.newWords.slice(operation.startInNew, operation.endInNew)\n    this.insertTag(HtmlDiff.InsTag, cssClass, words)\n  }\n\n  private processDeleteOperation(operation: Operation, cssClass: string) {\n    const words = this.usingContentProjections()\n      ? this.sliceOriginalWordsForOp('old', operation.startInOld, operation.endInOld)\n      : this.oldWords.slice(operation.startInOld, operation.endInOld)\n    this.insertTag(HtmlDiff.DelTag, cssClass, words)\n  }\n\n  private processEqualOperation(operation: Operation) {\n    if (this.usingContentProjections()) {\n      // Output from old to preserve old's HTML structure for the matched content.\n      const result = this.sliceOriginalWordsForOp('old', operation.startInOld, operation.endInOld)\n      this.content.push(result.join(''))\n\n      // Advance new-side tracking past the equivalent range in new so the next insert op\n      // resumes from the correct position. We compute new's range with the same rule used\n      // for old (rather than mirroring old's count) so the two sides are independently sound\n      // when their structural tags don't perfectly parallel each other.\n      this.sliceOriginalWordsForOp('new', operation.startInNew, operation.endInNew)\n    } else {\n      const result = this.newWords.slice(operation.startInNew, operation.endInNew)\n      this.content.push(result.join(''))\n    }\n  }\n\n  /** True when content projections are active for both sides — i.e. structural normalization is in effect. */\n  private usingContentProjections(): boolean {\n    return this.oldContentToOriginal !== null && this.newContentToOriginal !== null\n  }\n\n  /**\n   * Returns the slice of original (old or new) words covering a content-index range,\n   * including the structural tags that surround the content. Advances the side's cursor\n   * past the slice so the next op resumes correctly.\n   *\n   * The slice extends:\n   *   - LEADING: from the side's cursor (or the first content word's original index,\n   *     whichever is smaller) so structural tags that precede the first content word\n   *     are picked up by this op rather than left orphaned.\n   *   - TRAILING (non-last range): from just after the last content word, including\n   *     closing structural tags that close *this* op's paragraphs, but stopping at\n   *     the first opening structural tag — that opening tag belongs to the next\n   *     op's paragraph and would otherwise be emitted twice.\n   *   - TRAILING (last range): all the way to the end of words, since there is no next\n   *     op to claim the trailing tags.\n   */\n  private sliceOriginalWordsForOp(side: 'old' | 'new', contentStart: number, contentEnd: number): string[] {\n    const words = side === 'old' ? this.oldWords : this.newWords\n    const contentToOriginal = side === 'old' ? this.oldContentToOriginal : this.newContentToOriginal\n\n    if (!contentToOriginal) return words.slice(contentStart, contentEnd)\n    if (contentStart >= contentEnd) return []\n\n    const firstContentOrigIdx = contentToOriginal[contentStart]\n    const lastContentOrigIdx = contentToOriginal[contentEnd - 1]\n    const cursor = side === 'old' ? this.lastOriginalOldOutputIndex : this.lastOriginalNewOutputIndex\n    const origStart = Math.min(cursor, firstContentOrigIdx)\n\n    let origEnd: number\n    if (contentEnd < contentToOriginal.length) {\n      // Non-last range: walk trailing tags after the last content word, stopping at the\n      // first opening structural tag so it can be emitted by the next op.\n      const limit = contentToOriginal[contentEnd]\n      origEnd = lastContentOrigIdx + 1\n      while (origEnd < limit && !HtmlDiff.isOpeningStructuralTag(words[origEnd])) {\n        origEnd++\n      }\n    } else {\n      // Last range: include everything to the end.\n      origEnd = words.length\n    }\n\n    if (side === 'old') {\n      this.lastOriginalOldOutputIndex = origEnd\n    } else {\n      this.lastOriginalNewOutputIndex = origEnd\n    }\n\n    return words.slice(origStart, origEnd)\n  }\n\n  /**\n   * This method encloses words within a specified tag (ins or del), and adds this into \"content\",\n   * with a twist: if there are words contain tags, it actually creates multiple ins or del,\n   * so that they don't include any ins or del. This handles cases like\n   * old: '<p>a</p>'\n   * new: '<p>ab</p>\n   * <p>\n   *     c</b>'\n   *     diff result: '<p>a<ins>b</ins></p>\n   *     <p>\n   *         <ins>c</ins>\n   *     </p>\n   *     '\n   *     this still doesn't guarantee valid HTML (hint: think about diffing a text containing ins or\n   *     del tags), but handles correctly more cases than the earlier version.\n   *     P.S.: Spare a thought for people who write HTML browsers. They live in this ... every day.\n   * @param tag\n   * @param cssClass\n   * @param words\n   * @private\n   */\n  private insertTag(tag: string, cssClass: string, words: string[]) {\n    while (true) {\n      if (words.length === 0) {\n        break\n      }\n\n      const allWordsUntilFirstTag = this.extractConsecutiveWords(words, x => !Utils.isTag(x))\n      if (allWordsUntilFirstTag.length > 0) {\n        const text = Utils.wrapText(allWordsUntilFirstTag.join(''), tag, cssClass)\n        this.content.push(text)\n      }\n\n      const isInsertOpCompleted = words.length === 0\n      if (isInsertOpCompleted) {\n        break\n      }\n\n      // if there are still words left, they must start with a tag, but still can contain nonTag entries.\n      // e.g. </span></big>bar\n      // the remaining words need to be handled separately divided in a tagBlock, which definitely contains\n      // at least one word and a potentially existing second block which starts with a nonTag but may\n      // contain tags later on.\n      const indexOfFirstNonTag = words.findIndex(x => !Utils.isTag(x))\n\n      // if there are no nonTags, the whole block is a tagBlock and the index of the last tag is the last index of the block.\n      // if there are nonTags, the index of the last tag is the index before the first nonTag.\n      const indexLastTagInFirstTagBlock = indexOfFirstNonTag === -1 ? words.length - 1 : indexOfFirstNonTag - 1\n\n      let specialCaseTagInjection = ''\n      let specialCaseTagInjectionIsBefore = false\n\n      // handle opening tag\n      if (HtmlDiff.SpecialCaseOpeningTagRegex.test(words[0])) {\n        const tagNames = new Set<string>()\n        for (const word of words) {\n          if (Utils.isTag(word)) {\n            tagNames.add(Utils.getTagName(word))\n          }\n        }\n        const styledTagNames = Array.from(tagNames).join(' ')\n\n        this.specialTagDiffStack.push(words[0])\n        specialCaseTagInjection = `<ins class='mod ${styledTagNames}'>`\n        if (tag === HtmlDiff.DelTag) {\n          words.shift()\n\n          // following tags may be formatting tags as well, follow through\n          while (words.length > 0 && HtmlDiff.SpecialCaseOpeningTagRegex.test(words[0])) {\n            words.shift()\n          }\n        }\n      }\n      // handle closing tag\n      else if (HtmlDiff.SpecialCaseClosingTagsSet.has(words[0].toLowerCase())) {\n        const openingTag = this.specialTagDiffStack.length === 0 ? null : this.specialTagDiffStack.pop()\n        // For delete operations: when the tag block contains a mix of formatting and\n        // non-formatting closing tags (e.g. </strong></div>), compare against the first\n        // closing tag (the formatting one) rather than the last tag in the block.\n        // For purely formatting tag blocks (e.g. </i></strong>) or insert operations,\n        // use the last tag as before to match against the outermost opening tag.\n        let tagIndexToCompare = indexLastTagInFirstTagBlock\n        if (tag === HtmlDiff.DelTag && indexOfFirstNonTag === -1) {\n          const hasNonFormattingClosingTag = words\n            .slice(0, indexLastTagInFirstTagBlock + 1)\n            .some(w => !HtmlDiff.SpecialCaseClosingTagsSet.has(w.toLowerCase()))\n          if (hasNonFormattingClosingTag) {\n            tagIndexToCompare = 0\n          }\n        }\n        const openingAndClosingTagsMatch =\n          !!openingTag && Utils.getTagName(openingTag) === Utils.getTagName(words[tagIndexToCompare])\n\n        if (!!openingTag && openingAndClosingTagsMatch) {\n          specialCaseTagInjection = '</ins>'\n          specialCaseTagInjectionIsBefore = true\n        }\n\n        // if the tag has a corresponding opening tag, but they don't match,\n        // we need to push the opening tag back onto the stack\n        else if (openingTag) {\n          this.specialTagDiffStack.push(openingTag)\n        }\n\n        if (tag === HtmlDiff.DelTag) {\n          words.shift()\n          // following tags may be formatting tags as well, follow through\n          while (words.length > 0 && HtmlDiff.SpecialCaseClosingTagsSet.has(words[0].toLowerCase())) {\n            words.shift()\n          }\n        }\n      }\n\n      if (words.length === 0 && specialCaseTagInjection.length === 0) {\n        break\n      }\n\n      // For delete operations, only extract non-formatting tags. Formatting tags (special case\n      // opening/closing tags) need to be handled in the next loop iteration so they go through\n      // the proper specialTagDiffStack logic. Otherwise, opening formatting tags get output as\n      // plain tags and their corresponding closing tags are later discarded, producing invalid HTML.\n      const isTagForExtraction =\n        tag === HtmlDiff.DelTag\n          ? (x: string) =>\n              Utils.isTag(x) &&\n              !HtmlDiff.SpecialCaseOpeningTagRegex.test(x) &&\n              !HtmlDiff.SpecialCaseClosingTagsSet.has(x.toLowerCase())\n          : Utils.isTag\n\n      if (specialCaseTagInjectionIsBefore) {\n        this.content.push(specialCaseTagInjection + this.extractConsecutiveWords(words, isTagForExtraction).join(''))\n      } else {\n        this.content.push(this.extractConsecutiveWords(words, isTagForExtraction).join('') + specialCaseTagInjection)\n      }\n\n      if (words.length === 0) continue\n\n      // if there are still words left, they must start with a nonTag and need to be handled in the next iteration.\n      this.insertTag(tag, cssClass, words)\n      break\n    }\n  }\n\n  private extractConsecutiveWords(words: string[], condition: (character: string) => boolean): string[] {\n    let indexOfFirstTag: number | null = null\n    for (let i = 0; i < words.length; i++) {\n      const word = words[i]\n      if (i === 0 && word === ' ') {\n        words[i] = '&nbsp;'\n      }\n      if (!condition(word)) {\n        indexOfFirstTag = i\n        break\n      }\n    }\n\n    if (indexOfFirstTag !== null) {\n      const items = words.slice(0, indexOfFirstTag)\n      if (indexOfFirstTag > 0) {\n        words.splice(0, indexOfFirstTag)\n      }\n      return items\n    }\n\n    const items = words.slice(0)\n    words.splice(0, words.length)\n    return items\n  }\n\n  private operations(): Operation[] {\n    let positionInOld = 0\n    let positionInNew = 0\n    const operations: Operation[] = []\n\n    const wordsForDiffOld = this.oldContentWords ?? this.oldWords\n    const wordsForDiffNew = this.newContentWords ?? this.newWords\n\n    const matches = this.matchingBlocks()\n    matches.push(new Match(wordsForDiffOld.length, wordsForDiffNew.length, 0))\n\n    //Remove orphans from matches.\n    //If distance between left and right matches is 4 times longer than length of current match then it is considered as orphan\n    const matchesWithoutOrphans = this.removeOrphans(matches)\n\n    for (const match of matchesWithoutOrphans) {\n      const matchStartsAtCurrentPositionInOld = positionInOld === match.startInOld\n      const matchStartsAtCurrentPositionInNew = positionInNew === match.startInNew\n\n      let action: Action\n\n      if (!matchStartsAtCurrentPositionInOld && !matchStartsAtCurrentPositionInNew) {\n        action = Action.Replace\n      } else if (matchStartsAtCurrentPositionInOld && !matchStartsAtCurrentPositionInNew) {\n        action = Action.Insert\n      } else if (!matchStartsAtCurrentPositionInOld) {\n        action = Action.Delete\n      } // This occurs if the first few words are the same in both versions\n      else {\n        action = Action.None\n      }\n\n      if (action !== Action.None) {\n        operations.push(new Operation(action, positionInOld, match.startInOld, positionInNew, match.startInNew))\n      }\n\n      if (match.size !== 0) {\n        operations.push(new Operation(Action.Equal, match.startInOld, match.endInOld, match.startInNew, match.endInNew))\n      }\n\n      positionInOld = match.endInOld\n      positionInNew = match.endInNew\n    }\n\n    return operations\n  }\n\n  private *removeOrphans(matches: Match[]) {\n    const wordsForDiffOld = this.oldContentWords ?? this.oldWords\n    const wordsForDiffNew = this.newContentWords ?? this.newWords\n\n    let prev: Match = new Match(0, 0, 0)\n    let curr: Match | null = null\n\n    for (const next of matches) {\n      if (curr === null) {\n        curr = next\n        continue\n      }\n\n      if (\n        (prev.endInOld === curr.startInOld && prev.endInNew === curr.startInNew) ||\n        (curr.endInOld === next.startInOld && curr.endInNew === next.startInNew)\n      ) {\n        //if match has no diff on the left or on the right\n        yield curr\n        prev = curr\n        curr = next\n        continue\n      }\n\n      let oldDistanceInChars = 0\n      for (let i = prev.endInOld; i < next.startInOld; i++) {\n        oldDistanceInChars += wordsForDiffOld[i].length\n      }\n      let newDistanceInChars = 0\n      for (let i = prev.endInNew; i < next.startInNew; i++) {\n        newDistanceInChars += wordsForDiffNew[i].length\n      }\n      let currMatchLengthInChars = 0\n      for (let i = curr.startInNew; i < curr.endInNew; i++) {\n        currMatchLengthInChars += wordsForDiffNew[i].length\n      }\n\n      if (currMatchLengthInChars > Math.max(oldDistanceInChars, newDistanceInChars) * this.orphanMatchThreshold) {\n        yield curr\n      }\n\n      prev = curr\n      curr = next\n    }\n\n    if (curr !== null) {\n      yield curr //assume that the last match is always vital\n    }\n  }\n\n  private matchingBlocks(): Match[] {\n    const wordsForDiffOld = this.oldContentWords ?? this.oldWords\n    const wordsForDiffNew = this.newContentWords ?? this.newWords\n    const matchingBlocks: Match[] = []\n    this.findMatchingBlocks(0, wordsForDiffOld.length, 0, wordsForDiffNew.length, matchingBlocks)\n    return matchingBlocks\n  }\n\n  private findMatchingBlocks(\n    startInOld: number,\n    endInOld: number,\n    startInNew: number,\n    endInNew: number,\n    matchingBlocks: Match[]\n  ) {\n    const match = this.findMatch(startInOld, endInOld, startInNew, endInNew)\n\n    if (match !== null) {\n      if (startInOld < match.startInOld && startInNew < match.startInNew) {\n        this.findMatchingBlocks(startInOld, match.startInOld, startInNew, match.startInNew, matchingBlocks)\n      }\n\n      matchingBlocks.push(match)\n\n      if (match.endInOld < endInOld && match.endInNew < endInNew) {\n        this.findMatchingBlocks(match.endInOld, endInOld, match.endInNew, endInNew, matchingBlocks)\n      }\n    }\n  }\n\n  private findMatch(startInOld: number, endInOld: number, startInNew: number, endInNew: number): Match | null {\n    const wordsForDiffOld = this.oldContentWords ?? this.oldWords\n    const wordsForDiffNew = this.newContentWords ?? this.newWords\n\n    // For large texts it is more likely that there is a Match of size bigger than maximum granularity.\n    // If not then go down and try to find it with smaller granularity.\n    for (let i = this.matchGranularity; i > 0; i--) {\n      const options = {\n        blockSize: i,\n        repeatingWordsAccuracy: this.repeatingWordsAccuracy,\n        ignoreWhitespaceDifferences: this.ignoreWhitespaceDifferences,\n      }\n      const finder = new MatchFinder(\n        wordsForDiffOld,\n        wordsForDiffNew,\n        startInOld,\n        endInOld,\n        startInNew,\n        endInNew,\n        options\n      )\n      const match = finder.findMatch()\n      if (match !== null) return match\n    }\n    return null\n  }\n}\n"],"mappings":"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"}

package/dist/HtmlDiff.d.cts

@@ -11,20 +11,9 @@ declare class HtmlDiff {
   private static SpecialCaseClosingTagsSet;
   private static SpecialCaseOpeningTagRegex;
   private static FormattingTags;
-  /**
-   * Hard cap on nested `HtmlDiff.execute` calls (table preprocessing
-   * recurses through `diffCell` for cell content). Each level allocates
-   * fresh DP matrices and word arrays; without a guard a maliciously
-   * nested table-in-cell-in-table-in-cell input could blow stack and
-   * memory. Set high enough to comfortably handle real legal documents
-   * (tables nested 2-3 deep at most), low enough to short-circuit
-   * pathological input.
-   */
-  private static MaxTablePreprocessDepth;
   private content;
   private newText;
   private oldText;
-  private readonly tablePreprocessDepth;
   private specialTagDiffStack;
   private newWords;
   private oldWords;
@@ -87,12 +76,9 @@ declare 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: string, newText: string, tablePreprocessDepth?: number);
-  static execute(oldText: string, newText: string, tablePreprocessDepth?: number): string;
+  constructor(oldText: string, newText: string);
+  static execute(oldText: string, newText: string): string;
   /**
    * Builds the HTML diff output
    * @return HTML diff markup

package/dist/HtmlDiff.d.mts

@@ -11,20 +11,9 @@ declare class HtmlDiff {
   private static SpecialCaseClosingTagsSet;
   private static SpecialCaseOpeningTagRegex;
   private static FormattingTags;
-  /**
-   * Hard cap on nested `HtmlDiff.execute` calls (table preprocessing
-   * recurses through `diffCell` for cell content). Each level allocates
-   * fresh DP matrices and word arrays; without a guard a maliciously
-   * nested table-in-cell-in-table-in-cell input could blow stack and
-   * memory. Set high enough to comfortably handle real legal documents
-   * (tables nested 2-3 deep at most), low enough to short-circuit
-   * pathological input.
-   */
-  private static MaxTablePreprocessDepth;
   private content;
   private newText;
   private oldText;
-  private readonly tablePreprocessDepth;
   private specialTagDiffStack;
   private newWords;
   private oldWords;
@@ -87,12 +76,9 @@ declare 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: string, newText: string, tablePreprocessDepth?: number);
-  static execute(oldText: string, newText: string, tablePreprocessDepth?: number): string;
+  constructor(oldText: string, newText: string);
+  static execute(oldText: string, newText: string): string;
   /**
    * Builds the HTML diff output
    * @return HTML diff markup