@adecore/merge 0.22.1 → 0.23.1

package/dist/patch-parser.js

@@ -0,0 +1,112 @@
+const HEADER = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(?: ?(.*))?$/;
+/* Reads one `@@ -a,b +c,d @@ section` line without its line ending; undefined when it is not a hunk header. */
+export function parseHunkHeader(line) {
+    const match = HEADER.exec(line);
+    if (match === null) {
+        return undefined;
+    }
+    return {
+        oldStart: Number(match[1]),
+        oldCount: Number(match[2] ?? 1),
+        newStart: Number(match[3]),
+        newCount: Number(match[4] ?? 1),
+        section: match[5] ?? ''
+    };
+}
+export function parsePatch(patch) {
+    const hunks = [];
+    const lines = patch.split('\n');
+    let current;
+    let oldCount = 0;
+    let newCount = 0;
+    let partial = false;
+    let oldEnded = false;
+    let newEnded = false;
+    const header = [];
+    const finish = () => {
+        if (current !== undefined && (oldCount !== current.oldCount || newCount !== current.newCount)) {
+            partial = true;
+        }
+        current = undefined;
+    };
+    for (let index = 0; index < lines.length; index++) {
+        const line = lines[index];
+        const metadata = line.replace(/\r$/, '');
+        if (metadata.startsWith('@@')) {
+            finish();
+            const match = parseHunkHeader(metadata);
+            if (match === undefined) {
+                partial = true;
+                continue;
+            }
+            const oldLength = match.oldCount;
+            const newLength = match.newCount;
+            const oldStart = match.oldStart - (oldLength === 0 ? 0 : 1);
+            const newStart = match.newStart - (newLength === 0 ? 0 : 1);
+            if (![oldStart, newStart, oldLength, newLength, oldStart + oldLength, newStart + newLength].every((value) => Number.isSafeInteger(value) && value >= 0)) {
+                partial = true;
+                continue;
+            }
+            const previous = hunks.at(-1);
+            if (previous !== undefined && (oldStart < previous.oldStart + previous.oldCount || newStart < previous.newStart + previous.newCount)) {
+                partial = true;
+            }
+            current = { oldStart, oldCount: oldLength, newStart, newCount: newLength, section: match.section, lines: [] };
+            hunks.push(current);
+            oldCount = 0;
+            newCount = 0;
+            continue;
+        }
+        if (metadata.startsWith('diff --git ') && hunks.length > 0) {
+            finish();
+            partial = true;
+            break;
+        }
+        if (current === undefined) {
+            if (hunks.length === 0) {
+                header.push(metadata);
+            }
+            else if (line !== '') {
+                partial = true;
+            }
+            continue;
+        }
+        if (metadata === '\') {
+            const previous = current.lines.at(-1);
+            if (previous === undefined || previous.noNewline) {
+                partial = true;
+            }
+            else {
+                current.lines[current.lines.length - 1] = { ...previous, noNewline: true };
+                oldEnded ||= previous.kind !== 'insert';
+                newEnded ||= previous.kind !== 'delete';
+            }
+            continue;
+        }
+        // The last empty split field is the patch's terminator, not a source line.
+        if (line === '' && index === lines.length - 1) {
+            continue;
+        }
+        const kind = line.startsWith('-') ? 'delete' : line.startsWith('+') ? 'insert' : line.startsWith(' ') || line === '' ? 'context' : undefined;
+        if (kind === undefined) {
+            partial = true;
+            continue;
+        }
+        if (kind !== 'insert') {
+            partial ||= oldEnded;
+            oldCount += 1;
+        }
+        if (kind !== 'delete') {
+            partial ||= newEnded;
+            newCount += 1;
+        }
+        current.lines.push({ kind, text: line === '' ? '' : line.slice(1) });
+    }
+    finish();
+    return {
+        text: patch,
+        hunks,
+        missing: { old: header.some((line) => /^--- \/dev\/null(?:\t|$)/.test(line)), new: header.some((line) => /^\+\+\+ \/dev\/null(?:\t|$)/.test(line)) },
+        partial
+    };
+}

package/dist/patch.d.ts

@@ -0,0 +1,5 @@
+export declare function missingSides(patch: string): {
+    old: boolean;
+    new: boolean;
+};
+export declare function patchFits(patch: string, oldText: string, newText: string, ignoreWhitespace: boolean): boolean;

package/dist/patch.js

@@ -0,0 +1,51 @@
+/* Which side a patch says the file is missing on, read from its header so no line of the file can pass for it. */
+export function missingSides(patch) {
+    const start = patch.search(/^@@/m);
+    const header = start === -1 ? patch : patch.slice(0, start);
+    return { old: /^--- \/dev\/null$/m.test(header), new: /^\+\+\+ \/dev\/null$/m.test(header) };
+}
+const HUNK_HEADER = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+/* Git's --ignore-all-space may show either side's spacing on a context line. */
+export function patchFits(patch, oldText, newText, ignoreWhitespace) {
+    const oldLines = oldText.split('\n');
+    const newLines = newText.split('\n');
+    const same = ignoreWhitespace
+        ? (shown, actual) => actual !== undefined && shown.replace(/\s+/g, '') === actual.replace(/\s+/g, '')
+        : (shown, actual) => shown === actual;
+    let oldAt = -1;
+    let newAt = -1;
+    let hunks = 0;
+    for (const line of patch.split('\n')) {
+        const header = HUNK_HEADER.exec(line);
+        if (header) {
+            hunks += 1;
+            oldAt = Number(header[1]) - (header[2] === '0' ? 0 : 1);
+            newAt = Number(header[3]) - (header[4] === '0' ? 0 : 1);
+            continue;
+        }
+        if (oldAt === -1) {
+            continue;
+        }
+        const body = line.slice(1);
+        if (line.startsWith(' ')) {
+            if (!same(body, oldLines[oldAt]) || !same(body, newLines[newAt])) {
+                return false;
+            }
+            oldAt += 1;
+            newAt += 1;
+        }
+        else if (line.startsWith('-')) {
+            if (!same(body, oldLines[oldAt])) {
+                return false;
+            }
+            oldAt += 1;
+        }
+        else if (line.startsWith('+')) {
+            if (!same(body, newLines[newAt])) {
+                return false;
+            }
+            newAt += 1;
+        }
+    }
+    return hunks > 0;
+}

package/dist/word-changes.d.ts

@@ -0,0 +1,8 @@
+export interface DiffWordRange {
+    readonly from: number;
+    readonly to: number;
+}
+export declare function wordChanges(oldLine: string, newLine: string): {
+    old: DiffWordRange[];
+    new: DiffWordRange[];
+} | null;

package/dist/word-changes.js

@@ -0,0 +1,21 @@
+import { diffLines } from './diff.js';
+let segmenter;
+export function wordChanges(oldLine, newLine) {
+    if (oldLine.length + newLine.length > 20000) {
+        return null;
+    }
+    segmenter ??= new Intl.Segmenter('en', { granularity: 'word' });
+    const before = [...segmenter.segment(oldLine)];
+    const after = [...segmenter.segment(newLine)];
+    if (before.length + after.length > 2000) {
+        return null;
+    }
+    const range = (segments, text, from, to) => from === to ? [] : [{ from: segments[from].index, to: segments[to]?.index ?? text.length }];
+    const old = [];
+    const fresh = [];
+    for (const change of diffLines(before.map((part) => part.segment), after.map((part) => part.segment))) {
+        old.push(...range(before, oldLine, change.baseStart, change.baseEnd));
+        fresh.push(...range(after, newLine, change.otherStart, change.otherEnd));
+    }
+    return { old, new: fresh };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/merge",
-  "version": "0.22.1",
+  "version": "0.23.1",
   "description": "Pure line diffs, three-way merge blocks and conflict resolution.",
   "license": "FSL-1.1-MIT",
   "author": "Bas Milius",

package/src/diff-display.ts

@@ -0,0 +1,31 @@
+import { diffRows, type DiffDocument, type DiffGapRow, type DiffLineRow } from './diff-document.ts';
+
+export interface DiffDisplayGap {
+    /* The gap precedes this display line; a value equal to the line count puts it after the text. */
+    readonly before: number;
+    readonly row: DiffGapRow;
+}
+
+export interface DiffDisplay {
+    readonly text: string;
+    readonly lines: readonly string[];
+    /* One source mapping per display line, including removed lines as real text. */
+    readonly rows: readonly DiffLineRow[];
+    readonly gaps: readonly DiffDisplayGap[];
+}
+
+export function diffDisplay(document: DiffDocument, unfolded?: ReadonlyMap<number, number>): DiffDisplay {
+    const lines: string[] = [];
+    const rows: DiffLineRow[] = [];
+    const gaps: DiffDisplayGap[] = [];
+    for (const row of diffRows(document, 'unified', unfolded)) {
+        if (row.kind === 'gap') {
+            gaps.push({ before: lines.length, row });
+        } else {
+            const ref = row.new ?? row.old!;
+            lines.push((row.new === undefined ? document.sides.old : document.sides.new)[ref.index]!);
+            rows.push(row);
+        }
+    }
+    return { text: lines.join('\n'), lines, rows, gaps };
+}

package/src/diff-document.ts

@@ -0,0 +1,243 @@
+import type { Hunk, ParsedPatch, PatchLine } from './patch-parser.ts';
+import { shapeOf, splitLines, type TextShape } from './text.ts';
+
+export interface DiffLineRef {
+    readonly index: number;
+    readonly number: number;
+}
+
+export interface DiffLineRow {
+    readonly kind: 'line';
+    readonly change: 'context' | 'delete' | 'insert' | 'pair';
+    readonly old?: DiffLineRef;
+    readonly new?: DiffLineRef;
+    readonly noNewline?: 'old' | 'new' | 'both';
+    readonly hunk?: number;
+}
+
+export interface DiffGapRow {
+    readonly kind: 'gap';
+    readonly id: number;
+    readonly oldStart: number;
+    readonly newStart: number;
+    readonly oldCount: number;
+    readonly newCount: number;
+    readonly unfoldable: boolean;
+}
+
+export type DiffRow = DiffLineRow | DiffGapRow;
+
+export interface DiffDocument {
+    readonly hunks: readonly Hunk[];
+    readonly sides: { readonly old: readonly string[]; readonly new: readonly string[] };
+    readonly shapes?: { readonly old: TextShape; readonly new: TextShape };
+    readonly offsets: readonly { readonly old: number; readonly new: number }[];
+    readonly snapshots: boolean;
+    readonly ignoreWhitespace: boolean;
+    readonly partial: boolean;
+}
+
+function sourceText(line: PatchLine): string {
+    return line.noNewline ? line.text : line.text.replace(/\r$/, '');
+}
+
+function snapshotsFit(parsed: ParsedPatch, contents: { old: string; new: string }, ignoreWhitespace: boolean): boolean {
+    if (parsed.partial || parsed.hunks.length === 0) {
+        return false;
+    }
+    const rawLines = (text: string): string[] => {
+        if (text === '') {
+            return [];
+        }
+        const lines = text.split('\n');
+        if (text.endsWith('\n')) {
+            lines.pop();
+        }
+        return lines;
+    };
+    const oldLines = rawLines(contents.old);
+    const newLines = rawLines(contents.new);
+    const oldShape = shapeOf(contents.old);
+    const newShape = shapeOf(contents.new);
+    const same = (left: string, right: string): boolean => (ignoreWhitespace ? left.replace(/\s+/g, '') === right.replace(/\s+/g, '') : left === right);
+    let oldAt = 0;
+    let newAt = 0;
+    const gapFits = (oldEnd: number, newEnd: number): boolean => {
+        if (oldEnd - oldAt !== newEnd - newAt) {
+            return false;
+        }
+        while (oldAt < oldEnd && newAt < newEnd) {
+            if (!same(oldLines[oldAt]!, newLines[newAt]!)) {
+                return false;
+            }
+            oldAt += 1;
+            newAt += 1;
+        }
+        return true;
+    };
+    for (const hunk of parsed.hunks) {
+        if (hunk.oldStart + hunk.oldCount > oldLines.length || hunk.newStart + hunk.newCount > newLines.length || !gapFits(hunk.oldStart, hunk.newStart)) {
+            return false;
+        }
+        for (const line of hunk.lines) {
+            if (line.kind !== 'insert') {
+                if (!same(line.text, oldLines[oldAt]!) || Boolean(line.noNewline) !== (oldAt === oldLines.length - 1 && !oldShape.finalNewline)) {
+                    return false;
+                }
+                oldAt += 1;
+            }
+            if (line.kind !== 'delete') {
+                if (!same(line.text, newLines[newAt]!) || Boolean(line.noNewline) !== (newAt === newLines.length - 1 && !newShape.finalNewline)) {
+                    return false;
+                }
+                newAt += 1;
+            }
+        }
+    }
+    const endShown = oldAt === oldLines.length && newAt === newLines.length;
+    return gapFits(oldLines.length, newLines.length) && (oldShape.finalNewline === newShape.finalNewline || endShown);
+}
+
+export function diffDocument(parsed: ParsedPatch, contents: { old: string; new: string } | undefined, ignoreWhitespace = false): DiffDocument {
+    if (contents !== undefined && snapshotsFit(parsed, contents, ignoreWhitespace)) {
+        return {
+            hunks: parsed.hunks,
+            sides: { old: splitLines(contents.old), new: splitLines(contents.new) },
+            shapes: { old: shapeOf(contents.old), new: shapeOf(contents.new) },
+            offsets: parsed.hunks.map((hunk) => ({ old: hunk.oldStart, new: hunk.newStart })),
+            snapshots: true,
+            ignoreWhitespace,
+            partial: false
+        };
+    }
+    const old: string[] = [];
+    const fresh: string[] = [];
+    const offsets = parsed.hunks.map((hunk) => {
+        const offset = { old: old.length, new: fresh.length };
+        for (const line of hunk.lines) {
+            if (line.kind !== 'insert') {
+                old.push(sourceText(line));
+            }
+            if (line.kind !== 'delete') {
+                fresh.push(sourceText(line));
+            }
+        }
+        return offset;
+    });
+    return { hunks: parsed.hunks, sides: { old, new: fresh }, offsets, snapshots: false, ignoreWhitespace, partial: true };
+}
+
+function newline(old: boolean, fresh: boolean): Pick<DiffLineRow, 'noNewline'> {
+    return old || fresh ? { noNewline: old && fresh ? 'both' : old ? 'old' : 'new' } : {};
+}
+
+function hunkRows(document: DiffDocument, index: number, layout: 'unified' | 'split'): DiffLineRow[] {
+    const hunk = document.hunks[index]!;
+    const offset = document.offsets[index]!;
+    let oldAt = 0;
+    let newAt = 0;
+    const rows: DiffLineRow[] = [];
+    const deletes: DiffLineRow[] = [];
+    const inserts: DiffLineRow[] = [];
+    const flush = (): void => {
+        for (let pair = 0; pair < Math.max(deletes.length, inserts.length); pair++) {
+            const old = deletes[pair];
+            const fresh = inserts[pair];
+            rows.push({
+                kind: 'line',
+                change: old && fresh ? 'pair' : old ? 'delete' : 'insert',
+                hunk: index,
+                ...(old ? { old: old.old } : {}),
+                ...(fresh ? { new: fresh.new } : {}),
+                ...newline(old?.noNewline === 'old', fresh?.noNewline === 'new')
+            });
+        }
+        deletes.length = 0;
+        inserts.length = 0;
+    };
+    for (const line of hunk.lines) {
+        const old = line.kind === 'insert' ? undefined : { index: offset.old + oldAt, number: hunk.oldStart + oldAt + 1 };
+        const fresh = line.kind === 'delete' ? undefined : { index: offset.new + newAt, number: hunk.newStart + newAt + 1 };
+        const row: DiffLineRow = {
+            kind: 'line',
+            change: line.kind,
+            hunk: index,
+            ...(old ? { old } : {}),
+            ...(fresh ? { new: fresh } : {}),
+            ...newline(Boolean(old && line.noNewline), Boolean(fresh && line.noNewline))
+        };
+        oldAt += old ? 1 : 0;
+        newAt += fresh ? 1 : 0;
+        if (layout === 'unified') {
+            rows.push(row);
+        } else if (line.kind === 'context') {
+            flush();
+            rows.push(row);
+        } else {
+            (line.kind === 'delete' ? deletes : inserts).push(row);
+        }
+    }
+    flush();
+    return rows;
+}
+
+export function diffRows(document: DiffDocument, layout: 'unified' | 'split', unfolded: ReadonlyMap<number, number> = new Map()): DiffRow[] {
+    const rows: DiffRow[] = [];
+    const gap = (id: number, oldStart: number, newStart: number, oldCount: number, newCount: number, position: 'before' | 'between' | 'after'): void => {
+        if (oldCount <= 0 && newCount <= 0) {
+            return;
+        }
+        oldCount = Math.max(0, oldCount);
+        newCount = Math.max(0, newCount);
+        const unfoldable = document.snapshots && oldCount === newCount;
+        const amount = unfolded.get(id) ?? 0;
+        const count = unfoldable
+            ? Math.min(oldCount, amount === Number.POSITIVE_INFINITY ? oldCount : Number.isFinite(amount) ? Math.max(0, Math.floor(amount)) : 0)
+            : 0;
+        const leading = position === 'before' ? 0 : count;
+        const trailing = position === 'after' ? 0 : Math.min(count, oldCount - leading);
+        const context = (from: number, to: number): void => {
+            for (let line = from; line < to; line++) {
+                const old = oldStart + line;
+                const fresh = newStart + line;
+                rows.push({
+                    kind: 'line',
+                    change: 'context',
+                    old: { index: old, number: old + 1 },
+                    new: { index: fresh, number: fresh + 1 },
+                    ...newline(
+                        old === document.sides.old.length - 1 && document.shapes?.old.finalNewline === false,
+                        fresh === document.sides.new.length - 1 && document.shapes?.new.finalNewline === false
+                    )
+                });
+            }
+        };
+        context(0, leading);
+        if (oldCount - leading - trailing > 0 || newCount - leading - trailing > 0) {
+            rows.push({
+                kind: 'gap',
+                id,
+                oldStart: oldStart + leading,
+                newStart: newStart + leading,
+                oldCount: Math.max(0, oldCount - leading - trailing),
+                newCount: Math.max(0, newCount - leading - trailing),
+                unfoldable
+            });
+        }
+        context(oldCount - trailing, oldCount);
+    };
+    let oldAt = 0;
+    let newAt = 0;
+    document.hunks.forEach((hunk, index) => {
+        gap(index, oldAt, newAt, hunk.oldStart - oldAt, hunk.newStart - newAt, index === 0 ? 'before' : 'between');
+        for (const row of hunkRows(document, index, layout)) {
+            rows.push(row);
+        }
+        oldAt = hunk.oldStart + hunk.oldCount;
+        newAt = hunk.newStart + hunk.newCount;
+    });
+    if (document.snapshots) {
+        gap(document.hunks.length, oldAt, newAt, document.sides.old.length - oldAt, document.sides.new.length - newAt, 'after');
+    }
+    return rows;
+}

package/src/diff-split.ts

@@ -0,0 +1,43 @@
+import { diffRows, type DiffDocument, type DiffGapRow, type DiffLineRow } from './diff-document.ts';
+import type { DiffDisplay } from './diff-display.ts';
+
+export type DiffSplitRow =
+    | { readonly kind: 'line'; readonly row: DiffLineRow; readonly old?: number; readonly new?: number }
+    | { readonly kind: 'gap'; readonly row: DiffGapRow };
+
+export interface DiffSplit {
+    readonly old: DiffDisplay;
+    readonly new: DiffDisplay;
+    readonly aligned: readonly DiffSplitRow[];
+}
+
+/* Each side contains only source text; alignment rows never enter selection, copy or Find. */
+export function diffSplit(document: DiffDocument, unfolded?: ReadonlyMap<number, number>): DiffSplit {
+    const old = { lines: [] as string[], rows: [] as DiffLineRow[], gaps: [] as DiffDisplay['gaps'][number][] };
+    const fresh = { lines: [] as string[], rows: [] as DiffLineRow[], gaps: [] as DiffDisplay['gaps'][number][] };
+    const aligned: DiffSplitRow[] = [];
+    for (const row of diffRows(document, 'split', unfolded)) {
+        if (row.kind === 'gap') {
+            old.gaps.push({ before: old.lines.length, row });
+            fresh.gaps.push({ before: fresh.lines.length, row });
+            aligned.push({ kind: 'gap', row });
+            continue;
+        }
+        const entry = {
+            kind: 'line' as const,
+            row,
+            old: row.old === undefined ? undefined : old.lines.length,
+            new: row.new === undefined ? undefined : fresh.lines.length
+        };
+        if (row.old !== undefined) {
+            old.lines.push(document.sides.old[row.old.index]!);
+            old.rows.push({ ...row, new: undefined, noNewline: row.noNewline === 'new' ? undefined : row.noNewline });
+        }
+        if (row.new !== undefined) {
+            fresh.lines.push(document.sides.new[row.new.index]!);
+            fresh.rows.push({ ...row, old: undefined, noNewline: row.noNewline === 'old' ? undefined : row.noNewline });
+        }
+        aligned.push(entry);
+    }
+    return { old: { ...old, text: old.lines.join('\n') }, new: { ...fresh, text: fresh.lines.join('\n') }, aligned };
+}

package/src/diff.ts

@@ -16,6 +16,10 @@ const MAX_DISTANCE = 4000;
    state per round came to over a hundred megabytes at MAX_DISTANCE. */
 const STRIDE = 64;
 
+interface WorkBudget {
+    remaining: number;
+}
+
 /* One edit and the run of equal lines behind it, as the walk found them. */
 interface Move {
     prevX: number;
@@ -30,12 +34,21 @@ function cameDown(reach: Int32Array, offset: number, diagonal: number, distance:
 }
 
 /* One round of the walk: every diagonal of this distance taken as far as its lines match. True once the far corner is reached. */
-function extend(left: readonly string[], right: readonly string[], reach: Int32Array, offset: number, distance: number): boolean {
+function extend(left: readonly string[], right: readonly string[], reach: Int32Array, offset: number, distance: number, work?: WorkBudget): boolean | null {
     for (let diagonal = -distance; diagonal <= distance; diagonal += 2) {
+        if (work !== undefined && work.remaining-- <= 0) {
+            return null;
+        }
         const down = cameDown(reach, offset, diagonal, distance);
         let x = down ? reach[offset + diagonal + 1]! : reach[offset + diagonal - 1]! + 1;
         let y = x - diagonal;
-        while (x < left.length && y < right.length && left[x] === right[y]) {
+        while (x < left.length && y < right.length) {
+            if (work !== undefined && work.remaining-- <= 0) {
+                return null;
+            }
+            if (left[x] !== right[y]) {
+                break;
+            }
             x += 1;
             y += 1;
         }
@@ -82,20 +95,26 @@ function backtrack(left: readonly string[], right: readonly string[], saved: rea
  * STRIDE-th state a round started in, which is what the path is read back from once the far corner
  * is reached. Null once the distance passes what is worth walking.
  */
-function walk(left: readonly string[], right: readonly string[]): Move[] | null {
+function walk(left: readonly string[], right: readonly string[], maxWork?: number): { moves: Move[] | null; limited: boolean } {
     const limit = Math.min(left.length + right.length, MAX_DISTANCE);
     const offset = limit;
     const reach = new Int32Array(2 * limit + 1);
     const saved: Int32Array[] = [];
+    // Replay visits each earlier round once; reserve half the budget for backtracking.
+    const work = maxWork === undefined ? undefined : { remaining: Math.floor(maxWork / 2) };
     for (let distance = 0; distance <= limit; distance += 1) {
         if (distance % STRIDE === 0) {
             saved.push(reach.slice());
         }
-        if (extend(left, right, reach, offset, distance)) {
-            return backtrack(left, right, saved, distance, offset);
+        const complete = extend(left, right, reach, offset, distance, work);
+        if (complete === null) {
+            return { moves: null, limited: true };
+        }
+        if (complete) {
+            return { moves: backtrack(left, right, saved, distance, offset), limited: false };
         }
     }
-    return null;
+    return { moves: null, limited: false };
 }
 
 /* The stretches the moves cover, with edits that follow each other straight away folded into one. */
@@ -130,6 +149,10 @@ function changesOf(moves: readonly Move[]): Change[] {
 
 /* Where `other` differs from `base`, in line stretches, in the order they appear. */
 export function diffLines(base: readonly string[], other: readonly string[]): Change[] {
+    return diffChanges(base, other).changes;
+}
+
+export function diffChanges(base: readonly string[], other: readonly string[], maxWork?: number): { changes: Change[]; limited: boolean } {
     let prefix = 0;
     while (prefix < base.length && prefix < other.length && base[prefix] === other[prefix]) {
         prefix += 1;
@@ -141,14 +164,17 @@ export function diffLines(base: readonly string[], other: readonly string[]): Ch
     const left = base.slice(prefix, base.length - suffix);
     const right = other.slice(prefix, other.length - suffix);
     if (left.length === 0 && right.length === 0) {
-        return [];
+        return { changes: [], limited: false };
     }
-    const moves = left.length === 0 || right.length === 0 ? null : walk(left, right);
+    const { moves, limited } = left.length === 0 || right.length === 0 ? { moves: null, limited: false } : walk(left, right, maxWork);
     const changes = moves === null ? [{ baseStart: 0, baseEnd: left.length, otherStart: 0, otherEnd: right.length }] : changesOf(moves);
-    return changes.map((change) => ({
-        baseStart: change.baseStart + prefix,
-        baseEnd: change.baseEnd + prefix,
-        otherStart: change.otherStart + prefix,
-        otherEnd: change.otherEnd + prefix
-    }));
+    return {
+        changes: changes.map((change) => ({
+            baseStart: change.baseStart + prefix,
+            baseEnd: change.baseEnd + prefix,
+            otherStart: change.otherStart + prefix,
+            otherEnd: change.otherEnd + prefix
+        })),
+        limited
+    };
 }

package/src/index.ts

@@ -2,3 +2,10 @@ export { diffLines, type Change } from './diff.ts';
 export { openBlocks, splitBlocks, type MergeBlock, type MergeBlockKind } from './blocks.ts';
 export { autoLines, bothLines, draftOf, fingerprint, sideLines, wandLines, type MergeDraft, type MergeSide, type MergeSpan } from './resolve.ts';
 export { joinLines, shapeOf, splitLines, type TextShape } from './text.ts';
+export { missingSides, patchFits } from './patch.ts';
+export { parsePatch, parseHunkHeader, type HunkHeader, type Hunk, type ParsedPatch, type PatchLine } from './patch-parser.ts';
+export { diffDocument, diffRows, type DiffDocument, type DiffGapRow, type DiffLineRef, type DiffLineRow, type DiffRow } from './diff-document.ts';
+export { patchOf } from './patch-of.ts';
+export { wordChanges, type DiffWordRange } from './word-changes.ts';
+export { diffDisplay, type DiffDisplay, type DiffDisplayGap } from './diff-display.ts';
+export { diffSplit, type DiffSplit, type DiffSplitRow } from './diff-split.ts';