@matrixreq/htmldiff 1.6.0 → 2.0.0

package/js/tables/SequenceAligner.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SequenceAligner = void 0;
+const helpers_1 = require("./helpers");
+class SequenceAligner {
+    sequence;
+    constructor(sequence) {
+        this.sequence = sequence;
+    }
+    align() {
+        const sequence = this.sequence;
+        const exact = sequence.isExact ?? ((oldIndex, newIndex) => sequence.similarity(oldIndex, newIndex) === 1);
+        const similar = (oldIndex, newIndex) => sequence.similarity(oldIndex, newIndex) >= 0.5;
+        const whole = { oldStart: 0, oldEnd: sequence.oldCount, newStart: 0, newEnd: sequence.newCount };
+        let pairs = SequenceAligner.matchInOrder(whole, exact);
+        pairs = this.fillUnmatchedRanges(pairs, (unmatched) => SequenceAligner.matchInOrder(unmatched, similar));
+        pairs = this.fillUnmatchedRanges(pairs, (unmatched) => SequenceAligner.pairByPosition(sequence.byPosition, unmatched));
+        return SequenceAligner.toAlignments(pairs, sequence.oldCount, sequence.newCount);
+    }
+    fillUnmatchedRanges(pairs, pairUnmatched) {
+        const sequence = this.sequence;
+        const result = [];
+        let oldStart = 0;
+        let newStart = 0;
+        pairs.concat([{ oldIndex: sequence.oldCount, newIndex: sequence.newCount }]).forEach((pair) => {
+            if (pair.oldIndex > oldStart && pair.newIndex > newStart) {
+                pairUnmatched({ oldStart, oldEnd: pair.oldIndex, newStart, newEnd: pair.newIndex }).forEach((unmatchedPair) => result.push(unmatchedPair));
+            }
+            if (pair.oldIndex < sequence.oldCount) {
+                result.push(pair);
+            }
+            oldStart = pair.oldIndex + 1;
+            newStart = pair.newIndex + 1;
+        });
+        return result;
+    }
+    static pairByPosition(byPosition, unmatched) {
+        const oldIndexes = (0, helpers_1.range)(unmatched.oldStart, unmatched.oldEnd).filter((oldIndex) => !(byPosition.hasOldIdentity && byPosition.hasOldIdentity(oldIndex)));
+        const newIndexes = (0, helpers_1.range)(unmatched.newStart, unmatched.newEnd).filter((newIndex) => !(byPosition.hasNewIdentity && byPosition.hasNewIdentity(newIndex)));
+        const pairsInPlace = byPosition.pairsInPlace;
+        if (pairsInPlace && oldIndexes.length === newIndexes.length) {
+            return oldIndexes
+                .map((oldIndex, offset) => ({ oldIndex, newIndex: newIndexes[offset] }))
+                .filter((pair) => pairsInPlace(pair.oldIndex, pair.newIndex));
+        }
+        const blankOld = oldIndexes.filter(byPosition.isOldBlank);
+        const blankNew = newIndexes.filter(byPosition.isNewBlank);
+        const blankPairs = (0, helpers_1.range)(0, Math.min(blankOld.length, blankNew.length)).map((offset) => ({
+            oldIndex: blankOld[offset],
+            newIndex: blankNew[offset],
+        }));
+        const pairs = [];
+        let oldPosition = 0;
+        let newPosition = 0;
+        blankPairs.concat([null]).forEach((blankPair) => {
+            const oldEnd = blankPair ? oldIndexes.indexOf(blankPair.oldIndex) : oldIndexes.length;
+            const newEnd = blankPair ? newIndexes.indexOf(blankPair.newIndex) : newIndexes.length;
+            (0, helpers_1.range)(0, Math.min(oldEnd - oldPosition, newEnd - newPosition)).forEach((offset) => {
+                const oldIndex = oldIndexes[oldPosition + offset];
+                const newIndex = newIndexes[newPosition + offset];
+                if (byPosition.isOldBlank(oldIndex) || byPosition.isNewBlank(newIndex)) {
+                    pairs.push({ oldIndex, newIndex });
+                }
+            });
+            if (blankPair) {
+                pairs.push(blankPair);
+            }
+            oldPosition = oldEnd + 1;
+            newPosition = newEnd + 1;
+        });
+        return pairs;
+    }
+    static matchInOrder(unmatched, matches) {
+        const oldStart = unmatched.oldStart;
+        const newStart = unmatched.newStart;
+        const oldLength = unmatched.oldEnd - oldStart;
+        const newLength = unmatched.newEnd - newStart;
+        const width = newLength + 1;
+        const lengths = new Int32Array((oldLength + 1) * width);
+        for (let i = oldLength - 1; i >= 0; i--) {
+            for (let j = newLength - 1; j >= 0; j--) {
+                lengths[i * width + j] = matches(oldStart + i, newStart + j)
+                    ? lengths[(i + 1) * width + j + 1] + 1
+                    : Math.max(lengths[(i + 1) * width + j], lengths[i * width + j + 1]);
+            }
+        }
+        const pairs = [];
+        let oldOffset = 0;
+        let newOffset = 0;
+        while (oldOffset < oldLength && newOffset < newLength) {
+            if (matches(oldStart + oldOffset, newStart + newOffset)) {
+                pairs.push({ oldIndex: oldStart + oldOffset, newIndex: newStart + newOffset });
+                oldOffset++;
+                newOffset++;
+                continue;
+            }
+            if (lengths[(oldOffset + 1) * width + newOffset] >= lengths[oldOffset * width + newOffset + 1]) {
+                oldOffset++;
+                continue;
+            }
+            newOffset++;
+        }
+        return pairs;
+    }
+    static toAlignments(pairs, oldCount, newCount) {
+        const alignments = [];
+        let oldIndex = 0;
+        let newIndex = 0;
+        pairs.concat([{ oldIndex: oldCount, newIndex: newCount }]).forEach((pair) => {
+            for (; oldIndex < pair.oldIndex; oldIndex++) {
+                alignments.push({ kind: "deleted", oldIndex });
+            }
+            for (; newIndex < pair.newIndex; newIndex++) {
+                alignments.push({ kind: "added", newIndex });
+            }
+            if (pair.oldIndex < oldCount) {
+                alignments.push({ kind: "same", oldIndex: pair.oldIndex, newIndex: pair.newIndex });
+                oldIndex++;
+                newIndex++;
+            }
+        });
+        return alignments;
+    }
+}
+exports.SequenceAligner = SequenceAligner;

package/js/tables/Table.d.ts

@@ -0,0 +1,27 @@
+import { Element } from "./html";
+import { Row } from "./Row";
+export interface AppendChunk {
+    appended: Row[];
+    container: string | null;
+}
+export declare type Chunk = string | Row | AppendChunk;
+export declare class Table {
+    openTag: string;
+    readonly closeTag: string;
+    readonly start: number;
+    readonly end: number;
+    readonly inner: string;
+    readonly chunks: Chunk[];
+    readonly appendChunk: AppendChunk;
+    private constructor();
+    static read(element: Element): Table;
+    static findTopLevel(html: string): Table[];
+    ownId(): string | undefined;
+    wantsInnerDiff(): boolean;
+    ensureId(fallbackId: string): string;
+    documentRows(): Row[];
+    rows(): Row[];
+    nextSibling(row: Row): Row | null;
+    appendRow(row: Row): void;
+    renderInner(): string;
+}

package/js/tables/Table.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Table = void 0;
+const Cell_1 = require("./Cell");
+const constants_1 = require("../constants");
+const html_1 = require("./html");
+const Row_1 = require("./Row");
+class Table {
+    openTag;
+    closeTag;
+    start;
+    end;
+    inner;
+    chunks;
+    appendChunk;
+    constructor(element, chunks, appendChunk) {
+        this.openTag = element.openTag;
+        this.closeTag = element.closeTag;
+        this.start = element.start;
+        this.end = element.end;
+        this.inner = element.inner;
+        this.chunks = chunks;
+        this.appendChunk = appendChunk;
+    }
+    static read(element) {
+        const inner = element.inner;
+        const rowElements = (0, html_1.findElements)(inner, ["tr"]);
+        const containers = {};
+        let tableDepth = 0;
+        let container = null;
+        let appendAt = inner.length;
+        let firstTbodyEnd = -1;
+        (0, html_1.scanTags)(inner, (tag) => {
+            if (tag.name === "table") {
+                tableDepth += tag.isClosing ? -1 : 1;
+                return;
+            }
+            if (tableDepth !== 0) {
+                return;
+            }
+            if (tag.name === "thead" || tag.name === "tbody" || tag.name === "tfoot") {
+                if (tag.isClosing && tag.name === "tbody" && firstTbodyEnd === -1) {
+                    firstTbodyEnd = tag.start;
+                }
+                container = tag.isClosing ? null : tag.name;
+            }
+            if (tag.name === "tr" && !tag.isClosing) {
+                containers[tag.start] = container;
+            }
+        });
+        if (firstTbodyEnd !== -1) {
+            appendAt = firstTbodyEnd;
+        }
+        const chunks = [];
+        const appendChunk = { appended: [], container: firstTbodyEnd !== -1 ? "tbody" : null };
+        let position = 0;
+        let appendInserted = false;
+        const pushText = (textStart, textEnd) => {
+            if (!appendInserted && appendAt >= textStart && appendAt <= textEnd) {
+                if (textStart < appendAt) {
+                    chunks.push(inner.slice(textStart, appendAt));
+                }
+                chunks.push(appendChunk);
+                appendInserted = true;
+                if (appendAt < textEnd) {
+                    chunks.push(inner.slice(appendAt, textEnd));
+                }
+                return;
+            }
+            if (textStart < textEnd) {
+                chunks.push(inner.slice(textStart, textEnd));
+            }
+        };
+        rowElements.forEach((rowElement) => {
+            pushText(position, rowElement.start);
+            chunks.push(new Row_1.Row(rowElement.openTag, Cell_1.Cell.readRow(rowElement.inner), containers[rowElement.start] || null));
+            position = rowElement.end;
+        });
+        pushText(position, inner.length);
+        if (!appendInserted) {
+            chunks.push(appendChunk);
+        }
+        return new Table(element, chunks, appendChunk);
+    }
+    static findTopLevel(html) {
+        const elements = (0, html_1.findElements)(html, ["table"]);
+        const sealed = {};
+        const openTags = [];
+        let tableIndex = 0;
+        (0, html_1.scanTags)(html, (tag) => {
+            if (tag.isComment) {
+                return;
+            }
+            if (tag.isClosing) {
+                for (let depth = openTags.length - 1; depth >= 0; depth--) {
+                    if (openTags[depth].name === tag.name) {
+                        openTags.length = depth;
+                        break;
+                    }
+                }
+                return;
+            }
+            if (elements[tableIndex] && elements[tableIndex].start === tag.start) {
+                sealed[tag.start] = openTags.some((open) => open.sealed);
+                tableIndex++;
+            }
+            if (!tag.isSelfClosing) {
+                const id = (0, html_1.getTagAttribute)(tag.text, constants_1.HTMLDIFF_ID_ATTRIBUTE);
+                const flag = (0, html_1.getTagAttribute)(tag.text, constants_1.INNER_DIFF_ATTRIBUTE);
+                openTags.push({ name: tag.name, sealed: id !== null && (flag === null || flag === "false") });
+            }
+        });
+        return elements.filter((element) => !sealed[element.start]).map((element) => Table.read(element));
+    }
+    ownId() {
+        return (0, html_1.getTagAttribute)(this.openTag, constants_1.HTMLDIFF_ID_ATTRIBUTE) || undefined;
+    }
+    wantsInnerDiff() {
+        const flag = (0, html_1.getTagAttribute)(this.openTag, constants_1.INNER_DIFF_ATTRIBUTE);
+        return flag !== null && flag !== "false";
+    }
+    ensureId(fallbackId) {
+        const id = this.ownId() ?? fallbackId;
+        this.openTag = (0, html_1.setTagAttribute)(this.openTag, constants_1.HTMLDIFF_ID_ATTRIBUTE, id);
+        return id;
+    }
+    documentRows() {
+        const rows = [];
+        this.chunks.forEach((chunk) => {
+            if (chunk === this.appendChunk) {
+                chunk.appended.forEach((row) => row.collect(rows));
+            }
+            else if (chunk instanceof Row_1.Row && !chunk.detached) {
+                chunk.collect(rows);
+            }
+        });
+        return rows;
+    }
+    rows() {
+        const rows = this.documentRows();
+        return rows.filter((row) => row.container !== null).concat(rows.filter((row) => row.container === null));
+    }
+    nextSibling(row) {
+        const rows = this.documentRows();
+        const next = rows[rows.indexOf(row) + 1];
+        return next && next.container === row.container ? next : null;
+    }
+    appendRow(row) {
+        row.container = this.appendChunk.container;
+        this.appendChunk.appended.push(row);
+    }
+    renderInner() {
+        return this.chunks
+            .map((chunk) => {
+            if (typeof chunk === "string") {
+                return chunk;
+            }
+            if (chunk === this.appendChunk) {
+                return Row_1.Row.renderAll(chunk.appended);
+            }
+            return chunk.detached ? "" : chunk.render();
+        })
+            .join("");
+    }
+}
+exports.Table = Table;

package/js/tables/TableAligner.d.ts

@@ -0,0 +1,9 @@
+import { Alignment } from "./SequenceAligner";
+import { Table } from "./Table";
+export declare class TableAligner {
+    private readonly oldTables;
+    private readonly newTables;
+    constructor(oldTables: Table[], newTables: Table[]);
+    align(): Alignment[];
+    private static headerSignature;
+}

package/js/tables/TableAligner.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableAligner = void 0;
+const SequenceAligner_1 = require("./SequenceAligner");
+const similarity_1 = require("./similarity");
+const TableVersion_1 = require("./TableVersion");
+class TableAligner {
+    oldTables;
+    newTables;
+    constructor(oldTables, newTables) {
+        this.oldTables = oldTables;
+        this.newTables = newTables;
+    }
+    align() {
+        const oldTables = this.oldTables;
+        const newTables = this.newTables;
+        const oldIds = oldTables.map((table) => table.ownId());
+        const newIds = newTables.map((table) => table.ownId());
+        const oldVersions = oldTables.map((table) => TableVersion_1.TableVersion.read(table));
+        const newVersions = newTables.map((table) => TableVersion_1.TableVersion.read(table));
+        const oldValueCounts = oldVersions.map((version) => version.valueCounts());
+        const newValueCounts = newVersions.map((version) => version.valueCounts());
+        const oldHeaders = oldVersions.map((version) => TableAligner.headerSignature(version));
+        const newHeaders = newVersions.map((version) => TableAligner.headerSignature(version));
+        const keyed = (oldIndex, newIndex) => oldVersions[oldIndex].hasRowKeys && newVersions[newIndex].hasRowKeys;
+        const headersApart = (oldIndex, newIndex) => keyed(oldIndex, newIndex) &&
+            oldHeaders[oldIndex] !== null &&
+            newHeaders[newIndex] !== null &&
+            oldHeaders[oldIndex] !== newHeaders[newIndex];
+        const spansApart = (oldIndex, newIndex) => !keyed(oldIndex, newIndex) && !oldVersions[oldIndex].hasSameSpanLayoutAs(newVersions[newIndex]);
+        return new SequenceAligner_1.SequenceAligner({
+            oldCount: oldTables.length,
+            newCount: newTables.length,
+            similarity: (oldIndex, newIndex) => {
+                if (oldIds[oldIndex] !== undefined || newIds[newIndex] !== undefined) {
+                    return oldIds[oldIndex] === newIds[newIndex] ? 1 : 0;
+                }
+                if (headersApart(oldIndex, newIndex) || spansApart(oldIndex, newIndex)) {
+                    return 0;
+                }
+                return (0, similarity_1.valueOverlap)(oldValueCounts[oldIndex], newValueCounts[newIndex]);
+            },
+            byPosition: {
+                pairsInPlace: (oldIndex, newIndex) => {
+                    if (headersApart(oldIndex, newIndex) || spansApart(oldIndex, newIndex)) {
+                        return false;
+                    }
+                    return ((0, similarity_1.distinctSharedShare)(oldValueCounts[oldIndex], newValueCounts[newIndex]) >= 0.5 ||
+                        (keyed(oldIndex, newIndex) && oldVersions[oldIndex].columnCount === newVersions[newIndex].columnCount));
+                },
+                isOldBlank: (oldIndex) => (0, similarity_1.countsSize)(oldValueCounts[oldIndex]) === 0,
+                isNewBlank: (newIndex) => (0, similarity_1.countsSize)(newValueCounts[newIndex]) === 0,
+                hasOldIdentity: (oldIndex) => oldIds[oldIndex] !== undefined,
+                hasNewIdentity: (newIndex) => newIds[newIndex] !== undefined,
+            },
+        }).align();
+    }
+    static headerSignature(version) {
+        const headerRowCount = version.headerRowCount();
+        if (headerRowCount === 0) {
+            return null;
+        }
+        return version
+            .slice(0, headerRowCount)
+            .signatures.map((row) => row.join("|"))
+            .join("||");
+    }
+}
+exports.TableAligner = TableAligner;

package/js/tables/TableMerger.d.ts

@@ -0,0 +1,16 @@
+import { CellDiff } from "./constants";
+import { Table } from "./Table";
+export declare class TableMerger {
+    private readonly oldTable;
+    private readonly newTable;
+    private readonly diffContent;
+    constructor(oldTable: Table, newTable: Table, diffContent: CellDiff);
+    merge(): string;
+    private mergeUnderSameHeader;
+    private diffCellContent;
+    private diffCellsByPosition;
+    private static oldCellToCompare;
+    private buildKeptRowCell;
+    private static markChangedCells;
+    private emitRows;
+}

package/js/tables/TableMerger.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableMerger = void 0;
+const Cell_1 = require("./Cell");
+const ColumnAligner_1 = require("./ColumnAligner");
+const constants_1 = require("./constants");
+const helpers_1 = require("./helpers");
+const html_1 = require("./html");
+const MergedCells_1 = require("./MergedCells");
+const Row_1 = require("./Row");
+const RowAligner_1 = require("./RowAligner");
+const TableVersion_1 = require("./TableVersion");
+class TableMerger {
+    oldTable;
+    newTable;
+    diffContent;
+    constructor(oldTable, newTable, diffContent) {
+        this.oldTable = oldTable;
+        this.newTable = newTable;
+        this.diffContent = diffContent;
+    }
+    merge() {
+        let oldVersion = TableVersion_1.TableVersion.read(this.oldTable);
+        let newVersion = TableVersion_1.TableVersion.read(this.newTable);
+        if (oldVersion.hasSpans || newVersion.hasSpans) {
+            if (oldVersion.hasSameShapeAs(newVersion) && !(oldVersion.hasRowKeys && newVersion.hasRowKeys)) {
+                this.diffCellsByPosition(oldVersion, newVersion);
+                return this.newTable.renderInner();
+            }
+            if (this.mergeUnderSameHeader(oldVersion, newVersion)) {
+                return this.newTable.renderInner();
+            }
+            MergedCells_1.MergedCells.expand(this.oldTable, "old");
+            MergedCells_1.MergedCells.expand(this.newTable, "new");
+            oldVersion = TableVersion_1.TableVersion.read(this.oldTable);
+            newVersion = TableVersion_1.TableVersion.read(this.newTable);
+        }
+        const columnAligner = new ColumnAligner_1.ColumnAligner(oldVersion, newVersion);
+        let columns = columnAligner.align();
+        columns = columnAligner.splitReplaced(columns, new RowAligner_1.RowAligner(oldVersion, newVersion, columns).align());
+        const rowAligner = new RowAligner_1.RowAligner(oldVersion, newVersion, columns);
+        const rows = rowAligner.alternateReplaced(rowAligner.align());
+        const mergedCells = new MergedCells_1.MergedCells(oldVersion, newVersion);
+        this.emitRows(oldVersion, newVersion, columns, rows, mergedCells);
+        mergedCells.fold();
+        return columnAligner.rebuildColgroup(columns, this.newTable.renderInner());
+    }
+    mergeUnderSameHeader(oldVersion, newVersion) {
+        const headerRowCount = oldVersion.headerRowCount();
+        const oldHeader = oldVersion.slice(0, headerRowCount);
+        const newHeader = newVersion.slice(0, newVersion.headerRowCount());
+        const oldBody = oldVersion.slice(headerRowCount);
+        const newBody = newVersion.slice(newVersion.headerRowCount());
+        if (!oldHeader.hasSameShapeAs(newHeader) || oldBody.hasSpans || newBody.hasSpans) {
+            return false;
+        }
+        if (oldBody.columnCount !== newBody.columnCount) {
+            return false;
+        }
+        this.diffCellsByPosition(oldHeader, newHeader);
+        const columns = (0, helpers_1.range)(0, newBody.columnCount).map((index) => ({ kind: "same", oldIndex: index, newIndex: index }));
+        const rowAligner = new RowAligner_1.RowAligner(oldBody, newBody, columns);
+        this.emitRows(oldBody, newBody, columns, rowAligner.alternateReplaced(rowAligner.align()), new MergedCells_1.MergedCells(oldBody, newBody));
+        return true;
+    }
+    diffCellContent(oldCell, newCell) {
+        if (oldCell && oldCell.inner !== newCell.inner) {
+            newCell.inner = this.diffContent(oldCell.inner, newCell.inner);
+        }
+    }
+    diffCellsByPosition(oldVersion, newVersion) {
+        newVersion.cells.forEach((rowCells, rowIndex) => {
+            rowCells.forEach((newCell, cellIndex) => {
+                const oldCells = oldVersion.cells[rowIndex];
+                this.diffCellContent(oldCells && oldCells[cellIndex], newCell);
+            });
+        });
+    }
+    static oldCellToCompare(oldVersion, oldCell, newCell) {
+        if (!oldCell || oldCell.partOf === null) {
+            return oldCell;
+        }
+        const mergedCell = oldVersion.ownerOf(oldCell);
+        return mergedCell && mergedCell.signature() === newCell.signature() ? mergedCell : oldCell;
+    }
+    buildKeptRowCell(oldVersion, newVersion, row, column) {
+        const newCells = newVersion.cells[row.newIndex];
+        const oldCells = oldVersion.cells[row.oldIndex];
+        if (column.kind === "deleted") {
+            const cell = oldCells[column.oldIndex] ? oldCells[column.oldIndex].clone() : Cell_1.Cell.placeholder(newCells);
+            cell.addClass(constants_1.CELL_DELETED_CLASS);
+            return cell;
+        }
+        const newCell = newCells[column.newIndex] || Cell_1.Cell.placeholder(newCells);
+        if (column.kind === "added") {
+            newCell.addClass(constants_1.CELL_ADDED_CLASS);
+            return newCell;
+        }
+        if (newCell.partOf !== null) {
+            return newCell;
+        }
+        this.diffCellContent(TableMerger.oldCellToCompare(oldVersion, oldCells[column.oldIndex], newCell), newCell);
+        return newCell;
+    }
+    static markChangedCells(cells, className) {
+        cells.forEach((cell) => {
+            if (cell.partOf === null && !cell.hasChangeClass()) {
+                cell.addClass(className);
+            }
+        });
+    }
+    emitRows(oldVersion, newVersion, columns, rows, mergedCells) {
+        const table = newVersion.table;
+        mergedCells.moveOwnersToKeptRows(columns, rows);
+        const keptRows = rows.filter((row) => row.kind === "same");
+        const keptGroupSignatures = keptRows.map((row) => newVersion.groupSignatures(row.newIndex).concat(oldVersion.groupSignatures(row.oldIndex)));
+        const lastKeptRowOfGroup = (signatures) => {
+            if (signatures.length === 0) {
+                return null;
+            }
+            let found = null;
+            keptRows.forEach((row, index) => {
+                if (keptGroupSignatures[index].some((signature) => signatures.indexOf(signature) !== -1)) {
+                    found = newVersion.rows[row.newIndex];
+                }
+            });
+            return found;
+        };
+        const insertAfterGroup = (groupTail, tr) => {
+            let anchor = groupTail;
+            for (let sibling = table.nextSibling(anchor); sibling && sibling.changedInGroup; sibling = table.nextSibling(anchor)) {
+                anchor = sibling;
+            }
+            anchor.insertAfter(tr);
+        };
+        const placeDeletedRow = (tr, oldIndex, following) => {
+            const group = oldVersion.groupSignatures(oldIndex);
+            const next = following.find((row) => row.kind !== "deleted" &&
+                (!newVersion.isContinuationRow(row.newIndex) ||
+                    newVersion.groupSignatures(row.newIndex).some((signature) => group.indexOf(signature) !== -1)));
+            if (next) {
+                newVersion.rows[next.newIndex].insertBefore(tr);
+                return;
+            }
+            const tail = (0, helpers_1.last)(table.rows());
+            if (tail && tail.container !== "thead") {
+                tail.insertAfter(tr);
+                return;
+            }
+            table.appendRow(tr);
+        };
+        rows.forEach((row, index) => {
+            if (row.kind === "same") {
+                if (newVersion.cells[row.newIndex].length > 0) {
+                    newVersion.rows[row.newIndex].cells = columns.map((column) => this.buildKeptRowCell(oldVersion, newVersion, row, column));
+                }
+                return;
+            }
+            if (row.kind === "added") {
+                const addedRow = newVersion.rows[row.newIndex];
+                const addedCells = newVersion.cells[row.newIndex];
+                const addedGroupTail = lastKeptRowOfGroup(newVersion.groupSignatures(row.newIndex));
+                const addedInGroup = !!addedGroupTail && addedCells.length > 0;
+                addedRow.added = !addedInGroup;
+                if (!addedInGroup) {
+                    addedRow.openTag = (0, html_1.addTagClass)(addedRow.openTag, constants_1.ROW_ADDED_CLASS);
+                }
+                if (addedCells.length > 0) {
+                    addedRow.cells = columns.map((column) => {
+                        if (column.kind === "deleted") {
+                            return Cell_1.Cell.placeholder(addedCells, constants_1.CELL_DELETED_CLASS);
+                        }
+                        return addedCells[column.newIndex] || Cell_1.Cell.placeholder(addedCells);
+                    });
+                }
+                if (addedInGroup) {
+                    addedRow.changedInGroup = true;
+                    addedRow.changeClass = constants_1.CELL_ADDED_CLASS;
+                    TableMerger.markChangedCells(addedRow.cells, constants_1.CELL_ADDED_CLASS);
+                    if (addedGroupTail && newVersion.rows.indexOf(addedGroupTail) > row.newIndex) {
+                        addedRow.detach();
+                        insertAfterGroup(addedGroupTail, addedRow);
+                    }
+                }
+                return;
+            }
+            const oldRow = oldVersion.rows[row.oldIndex];
+            const oldCells = oldVersion.cells[row.oldIndex];
+            const deletedGroupTail = lastKeptRowOfGroup(oldVersion.groupSignatures(row.oldIndex));
+            const deletedInGroup = !!deletedGroupTail && oldCells.length > 0;
+            const tr = new Row_1.Row(deletedInGroup ? oldRow.openTag : (0, html_1.addTagClass)(oldRow.openTag, constants_1.ROW_DELETED_CLASS), oldCells.map((cell) => cell.clone()), null);
+            tr.deleted = !deletedInGroup;
+            if (oldCells.length > 0) {
+                tr.cells = columns.map((column) => {
+                    if (column.kind === "added") {
+                        return Cell_1.Cell.placeholder(oldCells, constants_1.CELL_ADDED_CLASS);
+                    }
+                    return oldCells[column.oldIndex] ? oldCells[column.oldIndex].clone() : Cell_1.Cell.placeholder(oldCells);
+                });
+            }
+            if (deletedInGroup) {
+                tr.changedInGroup = true;
+                tr.changeClass = constants_1.CELL_DELETED_CLASS;
+                TableMerger.markChangedCells(tr.cells, constants_1.CELL_DELETED_CLASS);
+                insertAfterGroup(deletedGroupTail, tr);
+                return;
+            }
+            if (deletedGroupTail) {
+                insertAfterGroup(deletedGroupTail, tr);
+                return;
+            }
+            placeDeletedRow(tr, row.oldIndex, rows.slice(index + 1));
+        });
+    }
+}
+exports.TableMerger = TableMerger;

package/js/tables/TableRedlining.d.ts

@@ -0,0 +1,10 @@
+import { CellDiff } from "./constants";
+export interface PreparedHtml {
+    before: string;
+    after: string;
+}
+export declare class TableRedlining {
+    private readonly diffContent;
+    constructor(diffContent: CellDiff);
+    redline(before: string, after: string): PreparedHtml;
+}