@matrixreq/htmldiff 1.6.0 → 2.0.1

package/js/tables/Cell.d.ts

@@ -0,0 +1,24 @@
+import { Element } from "./html";
+export declare class Cell {
+    tag: string;
+    openTag: string;
+    inner: string;
+    closeTag: string;
+    mergedKey: string | null;
+    partOf: string | null;
+    removed: boolean;
+    constructor(tag: string, openTag: string, inner: string, closeTag: string);
+    static read(element: Element): Cell;
+    static readRow(rowInner: string): Cell[];
+    static placeholder(siblingCells: Cell[], className?: string): Cell;
+    static part(mergedCellKey: string, siblingCells: Cell[]): Cell;
+    clone(): Cell;
+    addClass(className: string): void;
+    hasChangeClass(): boolean;
+    render(): string;
+    signature(): string;
+    ownId(): string | null;
+    span(attribute: "colspan" | "rowspan"): number;
+    shape(): string;
+    private scanContent;
+}

package/js/tables/Cell.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cell = void 0;
+const constants_1 = require("../constants");
+const constants_2 = require("./constants");
+const html_1 = require("./html");
+class Cell {
+    tag;
+    openTag;
+    inner;
+    closeTag;
+    mergedKey = null;
+    partOf = null;
+    removed = false;
+    constructor(tag, openTag, inner, closeTag) {
+        this.tag = tag;
+        this.openTag = openTag;
+        this.inner = inner;
+        this.closeTag = closeTag;
+    }
+    static read(element) {
+        return new Cell(element.name, element.openTag, element.inner, element.closeTag);
+    }
+    static readRow(rowInner) {
+        return (0, html_1.findElements)(rowInner, ["td", "th"]).map((element) => Cell.read(element));
+    }
+    static placeholder(siblingCells, className) {
+        const tag = siblingCells[0] ? siblingCells[0].tag : "td";
+        return new Cell(tag, `<${tag}${className ? ` class="${className}"` : ""}>`, "", `</${tag}>`);
+    }
+    static part(mergedCellKey, siblingCells) {
+        const part = Cell.placeholder(siblingCells);
+        part.partOf = mergedCellKey;
+        return part;
+    }
+    clone() {
+        const copy = new Cell(this.tag, this.openTag, this.inner, this.closeTag);
+        copy.mergedKey = this.mergedKey;
+        copy.partOf = this.partOf;
+        return copy;
+    }
+    addClass(className) {
+        this.openTag = (0, html_1.addTagClass)(this.openTag, className);
+    }
+    hasChangeClass() {
+        const classes = ((0, html_1.getTagAttribute)(this.openTag, "class") || "").split(/\s+/);
+        return classes.indexOf(constants_2.CELL_ADDED_CLASS) !== -1 || classes.indexOf(constants_2.CELL_DELETED_CLASS) !== -1;
+    }
+    render() {
+        return this.removed ? "" : this.openTag + this.inner + this.closeTag;
+    }
+    signature() {
+        const content = this.scanContent();
+        const text = content.text.replace(/\s+/g, " ").trim();
+        return [text]
+            .concat(content.ids, content.images)
+            .filter((part) => part !== "")
+            .join("|");
+    }
+    ownId() {
+        return (0, html_1.getTagAttribute)(this.openTag, constants_1.HTMLDIFF_ID_ATTRIBUTE);
+    }
+    span(attribute) {
+        const span = parseInt((0, html_1.getTagAttribute)(this.openTag, attribute) || "", 10);
+        return isNaN(span) || span < 1 ? 1 : span;
+    }
+    shape() {
+        return `${this.tag}:${this.span("colspan")}x${this.span("rowspan")}`;
+    }
+    scanContent() {
+        const inner = this.inner;
+        const openTags = [];
+        let text = "";
+        const ids = [];
+        const images = [];
+        let position = 0;
+        const isHidden = () => openTags.some((tag) => tag.hidden);
+        (0, html_1.scanTags)(inner, (tag) => {
+            if (!isHidden()) {
+                text += inner.slice(position, tag.start);
+            }
+            position = tag.end;
+            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;
+            }
+            const hidden = (0, html_1.getTagAttribute)(tag.text, "aria-hidden") === "true";
+            if (!hidden && !isHidden()) {
+                const id = (0, html_1.getTagAttribute)(tag.text, constants_1.HTMLDIFF_ID_ATTRIBUTE);
+                if (id !== null) {
+                    ids.push(id);
+                }
+                if (tag.name === "img") {
+                    images.push((0, html_1.getTagAttribute)(tag.text, "src") || "");
+                }
+            }
+            if (!tag.isSelfClosing) {
+                openTags.push({ name: tag.name, hidden });
+            }
+        });
+        if (!isHidden()) {
+            text += inner.slice(position);
+        }
+        return { text: (0, html_1.decodeEntities)(text), ids, images };
+    }
+}
+exports.Cell = Cell;

package/js/tables/ColumnAligner.d.ts

@@ -0,0 +1,11 @@
+import { Alignment } from "./SequenceAligner";
+import { TableVersion } from "./TableVersion";
+export declare class ColumnAligner {
+    private readonly oldVersion;
+    private readonly newVersion;
+    constructor(oldVersion: TableVersion, newVersion: TableVersion);
+    align(): Alignment[];
+    splitReplaced(columns: Alignment[], rows: Alignment[]): Alignment[];
+    rebuildColgroup(columns: Alignment[], mergedInner: string): string;
+    private static colTags;
+}

package/js/tables/ColumnAligner.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColumnAligner = void 0;
+const constants_1 = require("./constants");
+const helpers_1 = require("./helpers");
+const html_1 = require("./html");
+const SequenceAligner_1 = require("./SequenceAligner");
+const similarity_1 = require("./similarity");
+class ColumnAligner {
+    oldVersion;
+    newVersion;
+    constructor(oldVersion, newVersion) {
+        this.oldVersion = oldVersion;
+        this.newVersion = newVersion;
+    }
+    align() {
+        const oldValueCounts = this.oldVersion.columnValueCounts();
+        const newValueCounts = this.newVersion.columnValueCounts();
+        return new SequenceAligner_1.SequenceAligner({
+            oldCount: this.oldVersion.columnCount,
+            newCount: this.newVersion.columnCount,
+            similarity: (oldIndex, newIndex) => (0, similarity_1.sharedShare)(oldValueCounts[oldIndex], newValueCounts[newIndex]),
+            byPosition: {
+                pairsInPlace: () => true,
+                isOldBlank: (oldIndex) => (0, similarity_1.countsSize)(oldValueCounts[oldIndex]) === 0,
+                isNewBlank: (newIndex) => (0, similarity_1.countsSize)(newValueCounts[newIndex]) === 0,
+            },
+        }).align();
+    }
+    splitReplaced(columns, rows) {
+        const keptRows = rows.filter((row) => row.kind === "same");
+        return (0, helpers_1.flatten)(columns.map((column) => {
+            if (column.kind !== "same" ||
+                (this.oldVersion.isSequenceColumn(column.oldIndex) && this.newVersion.isSequenceColumn(column.newIndex))) {
+                return [column];
+            }
+            const compared = keptRows
+                .map((row) => [this.oldVersion.signatureAt(row.oldIndex, column.oldIndex), this.newVersion.signatureAt(row.newIndex, column.newIndex)])
+                .filter((pair) => pair[0] !== "" && pair[1] !== "");
+            const isReplaced = compared.length >= 2 && compared.every((pair) => (0, similarity_1.cellSimilarity)(pair[0], pair[1]) < 0.5);
+            return isReplaced
+                ? [
+                    { kind: "deleted", oldIndex: column.oldIndex },
+                    { kind: "added", newIndex: column.newIndex },
+                ]
+                : [column];
+        }));
+    }
+    rebuildColgroup(columns, mergedInner) {
+        const oldCols = ColumnAligner.colTags(this.oldVersion.table.inner);
+        const newCols = ColumnAligner.colTags(this.newVersion.table.inner);
+        if (oldCols.length === 0 && newCols.length === 0) {
+            return mergedInner;
+        }
+        const inner = (0, html_1.replaceRanges)(mergedInner, (0, html_1.findElements)(mergedInner, ["colgroup"]).map((colgroup) => ({ start: colgroup.start, end: colgroup.end, html: "" })));
+        const colgroup = "<colgroup>" +
+            columns
+                .map((column) => {
+                let col = column.kind === "deleted" ? oldCols[column.oldIndex] || "<col />" : newCols[column.newIndex] || "<col />";
+                if (column.kind !== "same") {
+                    col = (0, html_1.addTagClass)(col, column.kind === "added" ? constants_1.CELL_ADDED_CLASS : constants_1.CELL_DELETED_CLASS);
+                }
+                return col;
+            })
+                .join("") +
+            "</colgroup>";
+        const caption = (0, html_1.findElements)(inner, ["caption"])[0];
+        const at = caption ? caption.end : 0;
+        return inner.slice(0, at) + colgroup + inner.slice(at);
+    }
+    static colTags(tableInner) {
+        const cols = [];
+        (0, html_1.findElements)(tableInner, ["colgroup"]).forEach((colgroup) => {
+            (0, html_1.scanTags)(colgroup.inner, (tag) => {
+                if (tag.name === "col" && !tag.isClosing) {
+                    cols.push(tag.text);
+                }
+            });
+        });
+        return cols;
+    }
+}
+exports.ColumnAligner = ColumnAligner;

package/js/tables/MergedCells.d.ts

@@ -0,0 +1,11 @@
+import { Alignment } from "./SequenceAligner";
+import { Table } from "./Table";
+import { TableVersion } from "./TableVersion";
+export declare class MergedCells {
+    private readonly oldVersion;
+    private readonly newVersion;
+    constructor(oldVersion: TableVersion, newVersion: TableVersion);
+    static expand(table: Table, versionKey: string): void;
+    fold(): void;
+    moveOwnersToKeptRows(columns: Alignment[], rows: Alignment[]): void;
+}

package/js/tables/MergedCells.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MergedCells = void 0;
+const Cell_1 = require("./Cell");
+const helpers_1 = require("./helpers");
+const html_1 = require("./html");
+class MergedCells {
+    oldVersion;
+    newVersion;
+    constructor(oldVersion, newVersion) {
+        this.oldVersion = oldVersion;
+        this.newVersion = newVersion;
+    }
+    static expand(table, versionKey) {
+        const coveredByRow = {};
+        const coveredIn = (rowIndex) => {
+            coveredByRow[rowIndex] = coveredByRow[rowIndex] || {};
+            return coveredByRow[rowIndex];
+        };
+        table.rows().forEach((row, rowIndex) => {
+            const covered = coveredIn(rowIndex);
+            const cells = row.cells;
+            const expanded = [];
+            let column = 0;
+            cells.forEach((cell, cellIndex) => {
+                while (covered[column] !== undefined) {
+                    expanded.push(Cell_1.Cell.part(covered[column], [cell]));
+                    column++;
+                }
+                const columnSpan = cell.span("colspan");
+                const rowSpan = cell.span("rowspan");
+                expanded.push(cell);
+                if (columnSpan === 1 && rowSpan === 1) {
+                    column++;
+                    return;
+                }
+                const mergedCellKey = `${versionKey}-${rowIndex}-${cellIndex}`;
+                cell.mergedKey = mergedCellKey;
+                cell.openTag = (0, html_1.removeTagAttribute)((0, html_1.removeTagAttribute)(cell.openTag, "colspan"), "rowspan");
+                for (let offset = 1; offset < columnSpan; offset++) {
+                    expanded.push(Cell_1.Cell.part(mergedCellKey, [cell]));
+                }
+                for (let rowOffset = 1; rowOffset < rowSpan; rowOffset++) {
+                    (0, helpers_1.range)(column, column + columnSpan).forEach((index) => {
+                        coveredIn(rowIndex + rowOffset)[index] = mergedCellKey;
+                    });
+                }
+                column += columnSpan;
+            });
+            while (covered[column] !== undefined) {
+                expanded.push(Cell_1.Cell.part(covered[column], cells));
+                column++;
+            }
+            row.cells = expanded;
+        });
+    }
+    fold() {
+        const rows = this.newVersion.table.rows();
+        const cells = rows.map((row) => row.cells);
+        const mergedCells = Object.create(null);
+        Object.keys(this.oldVersion.mergedCells).forEach((key) => {
+            mergedCells[key] = this.oldVersion.mergedCells[key];
+        });
+        Object.keys(this.newVersion.mergedCells).forEach((key) => {
+            mergedCells[key] = this.newVersion.mergedCells[key];
+        });
+        const isSameMergedCell = (key, otherKey) => key === otherKey || (mergedCells[key] !== "" && mergedCells[key] === mergedCells[otherKey]);
+        const isEmptyPartOf = (mergedCellKey, rowIndex, columnIndex, rowKind) => {
+            const cell = cells[rowIndex] && cells[rowIndex][columnIndex];
+            return (!!cell &&
+                cell.partOf !== null &&
+                cell.inner === "" &&
+                isSameMergedCell(mergedCellKey, cell.partOf) &&
+                rows[rowIndex].kind() === rowKind);
+        };
+        cells.forEach((rowCells, rowIndex) => {
+            rowCells.forEach((cell, columnIndex) => {
+                const mergedCellKey = cell.mergedKey;
+                if (mergedCellKey === null) {
+                    return;
+                }
+                const rowKind = rows[rowIndex].kind();
+                const spansRows = !(rows[rowIndex].changedInGroup && cell.hasChangeClass());
+                let columnSpan = 1;
+                while (isEmptyPartOf(mergedCellKey, rowIndex, columnIndex + columnSpan, rowKind)) {
+                    columnSpan++;
+                }
+                let rowSpan = 1;
+                while (spansRows &&
+                    (0, helpers_1.range)(columnIndex, columnIndex + columnSpan).every((index) => isEmptyPartOf(mergedCellKey, rowIndex + rowSpan, index, rowKind))) {
+                    rowSpan++;
+                }
+                (0, helpers_1.range)(rowIndex, rowIndex + rowSpan).forEach((spannedRow) => {
+                    (0, helpers_1.range)(columnIndex, columnIndex + columnSpan).forEach((spannedColumn) => {
+                        if (spannedRow !== rowIndex || spannedColumn !== columnIndex) {
+                            cells[spannedRow][spannedColumn].removed = true;
+                        }
+                    });
+                });
+                if (columnSpan > 1) {
+                    cell.openTag = (0, html_1.setTagAttribute)(cell.openTag, "colspan", columnSpan);
+                }
+                if (rowSpan > 1) {
+                    cell.openTag = (0, html_1.setTagAttribute)(cell.openTag, "rowspan", rowSpan);
+                }
+            });
+        });
+        rows.forEach((row) => {
+            if (!row.changedInGroup || !row.changeClass) {
+                return;
+            }
+            const changeClass = row.changeClass;
+            row.cells.forEach((cell) => {
+                if (!cell.removed && cell.partOf !== null && !cell.hasChangeClass()) {
+                    cell.addClass(changeClass);
+                }
+            });
+        });
+    }
+    moveOwnersToKeptRows(columns, rows) {
+        const moveOwners = (version, keptIndexes) => {
+            version.cells.forEach((rowCells, rowIndex) => {
+                if (keptIndexes.indexOf(rowIndex) !== -1) {
+                    return;
+                }
+                rowCells.forEach((cell, columnIndex) => {
+                    if (cell.mergedKey === null) {
+                        return;
+                    }
+                    const target = keptIndexes
+                        .filter((keptIndex) => {
+                        const keptCell = version.cells[keptIndex][columnIndex];
+                        return keptIndex > rowIndex && !!keptCell && keptCell.partOf === cell.mergedKey;
+                    })
+                        .sort((first, second) => first - second)[0];
+                    if (target === undefined) {
+                        return;
+                    }
+                    rowCells[columnIndex] = version.cells[target][columnIndex];
+                    version.cells[target][columnIndex] = cell;
+                    const signature = version.signatures[rowIndex][columnIndex];
+                    version.signatures[rowIndex][columnIndex] = version.signatures[target][columnIndex];
+                    version.signatures[target][columnIndex] = signature;
+                });
+            });
+        };
+        const keptRows = rows.filter((row) => row.kind === "same");
+        moveOwners(this.oldVersion, keptRows.map((row) => row.oldIndex));
+        moveOwners(this.newVersion, keptRows.map((row) => row.newIndex));
+        keptRows.forEach((row) => {
+            columns.forEach((column) => {
+                if (column.kind !== "same") {
+                    return;
+                }
+                const oldCell = this.oldVersion.cells[row.oldIndex][column.oldIndex];
+                const newCell = this.newVersion.cells[row.newIndex][column.newIndex];
+                if (!oldCell ||
+                    !newCell ||
+                    oldCell.mergedKey === null ||
+                    newCell.mergedKey !== null ||
+                    newCell.partOf !== null ||
+                    oldCell.signature() !== newCell.signature()) {
+                    return;
+                }
+                newCell.mergedKey = oldCell.mergedKey;
+                this.newVersion.mergedCells[oldCell.mergedKey] = this.oldVersion.mergedCells[oldCell.mergedKey];
+            });
+        });
+    }
+}
+exports.MergedCells = MergedCells;

package/js/tables/Row.d.ts

@@ -0,0 +1,22 @@
+import { Cell } from "./Cell";
+export declare type RowKind = "kept" | "added" | "deleted";
+export declare class Row {
+    openTag: string;
+    cells: Cell[];
+    container: string | null;
+    before: Row[];
+    after: Row[];
+    added: boolean;
+    deleted: boolean;
+    detached: boolean;
+    changedInGroup: boolean;
+    changeClass: string | null;
+    constructor(openTag: string, cells: Cell[], container: string | null);
+    kind(): RowKind;
+    render(): string;
+    static renderAll(rows: Row[]): string;
+    insertBefore(row: Row): void;
+    insertAfter(row: Row): void;
+    detach(): void;
+    collect(rows: Row[]): void;
+}

package/js/tables/Row.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Row = void 0;
+class Row {
+    openTag;
+    cells;
+    container;
+    before = [];
+    after = [];
+    added = false;
+    deleted = false;
+    detached = false;
+    changedInGroup = false;
+    changeClass = null;
+    constructor(openTag, cells, container) {
+        this.openTag = openTag;
+        this.cells = cells;
+        this.container = container;
+    }
+    kind() {
+        if (this.deleted) {
+            return "deleted";
+        }
+        return this.added ? "added" : "kept";
+    }
+    render() {
+        return Row.renderAll(this.before) + this.openTag + this.cells.map((cell) => cell.render()).join("") + "</tr>" + Row.renderAll(this.after);
+    }
+    static renderAll(rows) {
+        return rows.map((row) => row.render()).join("");
+    }
+    insertBefore(row) {
+        row.container = this.container;
+        this.before.push(row);
+    }
+    insertAfter(row) {
+        row.container = this.container;
+        this.after.unshift(row);
+    }
+    detach() {
+        this.detached = true;
+    }
+    collect(rows) {
+        this.before.forEach((row) => row.collect(rows));
+        rows.push(this);
+        this.after.forEach((row) => row.collect(rows));
+    }
+}
+exports.Row = Row;

package/js/tables/RowAligner.d.ts

@@ -0,0 +1,12 @@
+import { Alignment } from "./SequenceAligner";
+import { TableVersion } from "./TableVersion";
+export declare class RowAligner {
+    private readonly oldVersion;
+    private readonly newVersion;
+    private readonly comparedColumns;
+    constructor(oldVersion: TableVersion, newVersion: TableVersion, columns: Alignment[]);
+    align(): Alignment[];
+    private static readRows;
+    alternateReplaced(rows: Alignment[]): Alignment[];
+    private static groupIntoUnits;
+}

package/js/tables/RowAligner.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RowAligner = void 0;
+const helpers_1 = require("./helpers");
+const SequenceAligner_1 = require("./SequenceAligner");
+const similarity_1 = require("./similarity");
+class RowAligner {
+    oldVersion;
+    newVersion;
+    comparedColumns;
+    constructor(oldVersion, newVersion, columns) {
+        this.oldVersion = oldVersion;
+        this.newVersion = newVersion;
+        this.comparedColumns = columns.filter((column) => column.kind === "same" && (!oldVersion.isSequenceColumn(column.oldIndex) || !newVersion.isSequenceColumn(column.newIndex)));
+    }
+    align() {
+        const keyed = this.oldVersion.hasRowKeys && this.newVersion.hasRowKeys;
+        const exactKeys = new Map();
+        const oldRows = RowAligner.readRows(this.oldVersion, this.comparedColumns.map((column) => column.oldIndex), keyed, exactKeys);
+        const newRows = RowAligner.readRows(this.newVersion, this.comparedColumns.map((column) => column.newIndex), keyed, exactKeys);
+        const similarity = (oldIndex, newIndex) => {
+            const oldRow = oldRows[oldIndex];
+            const newRow = newRows[newIndex];
+            if (keyed) {
+                return oldRow.exactKey === newRow.exactKey ? 1 : 0;
+            }
+            let compared = 0;
+            let kept = 0;
+            oldRow.signatures.forEach((oldSignature, column) => {
+                const newSignature = newRow.signatures[column];
+                if (oldSignature === "" && newSignature === "") {
+                    return;
+                }
+                compared++;
+                kept += oldSignature === newSignature ? 1 : (0, similarity_1.wordSimilarity)(oldRow.words[column], newRow.words[column]);
+            });
+            return compared === 0 ? NaN : kept / compared;
+        };
+        const isExact = (oldIndex, newIndex) => {
+            const oldRow = oldRows[oldIndex];
+            const newRow = newRows[newIndex];
+            return oldRow.exactKey === newRow.exactKey && (keyed || !(oldRow.blank && newRow.blank));
+        };
+        return new SequenceAligner_1.SequenceAligner({
+            oldCount: oldRows.length,
+            newCount: newRows.length,
+            similarity,
+            isExact,
+            byPosition: {
+                isOldBlank: (oldIndex) => oldRows[oldIndex].blank,
+                isNewBlank: (newIndex) => newRows[newIndex].blank,
+                hasOldIdentity: (oldIndex) => keyed && oldRows[oldIndex].keys.length > 0,
+                hasNewIdentity: (newIndex) => keyed && newRows[newIndex].keys.length > 0,
+            },
+        }).align();
+    }
+    static readRows(version, columnIndexes, keyed, exactKeys) {
+        const keysByRow = keyed ? version.rowKeysByRow() : [];
+        return (0, helpers_1.range)(0, version.rows.length).map((rowIndex) => {
+            const signatures = columnIndexes.map((columnIndex) => version.signatureAt(rowIndex, columnIndex));
+            const words = signatures.map((signature) => (0, similarity_1.signatureWords)(signature));
+            const keys = keyed ? keysByRow[rowIndex] : [];
+            const exactKey = keyed ? JSON.stringify(keys) : words.map((cellWords) => cellWords.slice().sort().join(" ")).join("|");
+            let interned = exactKeys.get(exactKey);
+            if (interned === undefined) {
+                interned = exactKeys.size;
+                exactKeys.set(exactKey, interned);
+            }
+            return { signatures, words, blank: signatures.every((signature) => signature === ""), keys, exactKey: interned };
+        });
+    }
+    alternateReplaced(rows) {
+        let result = [];
+        let run = [];
+        const flushRun = () => {
+            const deletedUnits = RowAligner.groupIntoUnits(run.filter((row) => row.kind === "deleted"), (row) => row.kind === "deleted" && this.oldVersion.isContinuationRow(row.oldIndex));
+            const addedUnits = RowAligner.groupIntoUnits(run.filter((row) => row.kind === "added"), (row) => row.kind === "added" && this.newVersion.isContinuationRow(row.newIndex));
+            (0, helpers_1.range)(0, Math.max(deletedUnits.length, addedUnits.length)).forEach((index) => {
+                result = result.concat(deletedUnits[index] || [], addedUnits[index] || []);
+            });
+            run = [];
+        };
+        rows.forEach((row) => {
+            if (row.kind === "same") {
+                flushRun();
+                result.push(row);
+                return;
+            }
+            run.push(row);
+        });
+        flushRun();
+        return result;
+    }
+    static groupIntoUnits(rows, continuesUnit) {
+        const units = [];
+        rows.forEach((row) => {
+            const unit = (0, helpers_1.last)(units);
+            if (unit && continuesUnit(row)) {
+                unit.push(row);
+                return;
+            }
+            units.push([row]);
+        });
+        return units;
+    }
+}
+exports.RowAligner = RowAligner;

package/js/tables/SequenceAligner.d.ts

@@ -0,0 +1,47 @@
+export declare type Alignment = {
+    kind: "same";
+    oldIndex: number;
+    newIndex: number;
+} | {
+    kind: "added";
+    newIndex: number;
+} | {
+    kind: "deleted";
+    oldIndex: number;
+};
+export declare type SameAlignment = Extract<Alignment, {
+    kind: "same";
+}>;
+export interface IndexPair {
+    oldIndex: number;
+    newIndex: number;
+}
+export interface UnmatchedRange {
+    oldStart: number;
+    oldEnd: number;
+    newStart: number;
+    newEnd: number;
+}
+export interface PositionalPairing {
+    pairsInPlace?: (oldIndex: number, newIndex: number) => boolean;
+    isOldBlank: (oldIndex: number) => boolean;
+    isNewBlank: (newIndex: number) => boolean;
+    hasOldIdentity?: (oldIndex: number) => boolean;
+    hasNewIdentity?: (newIndex: number) => boolean;
+}
+export interface Sequence {
+    oldCount: number;
+    newCount: number;
+    similarity: (oldIndex: number, newIndex: number) => number;
+    isExact?: (oldIndex: number, newIndex: number) => boolean;
+    byPosition: PositionalPairing;
+}
+export declare class SequenceAligner {
+    private readonly sequence;
+    constructor(sequence: Sequence);
+    align(): Alignment[];
+    private fillUnmatchedRanges;
+    static pairByPosition(byPosition: PositionalPairing, unmatched: UnmatchedRange): IndexPair[];
+    static matchInOrder(unmatched: UnmatchedRange, matches: (oldIndex: number, newIndex: number) => boolean): IndexPair[];
+    static toAlignments(pairs: IndexPair[], oldCount: number, newCount: number): Alignment[];
+}