@adecore/merge 0.22.1 → 0.23.0

package/dist/diff-display.d.ts

@@ -0,0 +1,12 @@
+import { type DiffDocument, type DiffGapRow, type DiffLineRow } from './diff-document.ts';
+export interface DiffDisplayGap {
+    readonly before: number;
+    readonly row: DiffGapRow;
+}
+export interface DiffDisplay {
+    readonly text: string;
+    readonly lines: readonly string[];
+    readonly rows: readonly DiffLineRow[];
+    readonly gaps: readonly DiffDisplayGap[];
+}
+export declare function diffDisplay(document: DiffDocument, unfolded?: ReadonlyMap<number, number>): DiffDisplay;

package/dist/diff-display.js

@@ -0,0 +1,17 @@
+import { diffRows } from './diff-document.js';
+export function diffDisplay(document, unfolded) {
+    const lines = [];
+    const rows = [];
+    const gaps = [];
+    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/dist/diff-document.d.ts

@@ -0,0 +1,47 @@
+import type { Hunk, ParsedPatch } from './patch-parser.ts';
+import { 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;
+}
+export declare function diffDocument(parsed: ParsedPatch, contents: {
+    old: string;
+    new: string;
+} | undefined, ignoreWhitespace?: boolean): DiffDocument;
+export declare function diffRows(document: DiffDocument, layout: 'unified' | 'split', unfolded?: ReadonlyMap<number, number>): DiffRow[];

package/dist/diff-document.js

@@ -0,0 +1,199 @@
+import { shapeOf, splitLines } from './text.js';
+function sourceText(line) {
+    return line.noNewline ? line.text : line.text.replace(/\r$/, '');
+}
+function snapshotsFit(parsed, contents, ignoreWhitespace) {
+    if (parsed.partial || parsed.hunks.length === 0) {
+        return false;
+    }
+    const rawLines = (text) => {
+        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, right) => (ignoreWhitespace ? left.replace(/\s+/g, '') === right.replace(/\s+/g, '') : left === right);
+    let oldAt = 0;
+    let newAt = 0;
+    const gapFits = (oldEnd, newEnd) => {
+        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, contents, ignoreWhitespace = false) {
+    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 = [];
+    const fresh = [];
+    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, fresh) {
+    return old || fresh ? { noNewline: old && fresh ? 'both' : old ? 'old' : 'new' } : {};
+}
+function hunkRows(document, index, layout) {
+    const hunk = document.hunks[index];
+    const offset = document.offsets[index];
+    let oldAt = 0;
+    let newAt = 0;
+    const rows = [];
+    const deletes = [];
+    const inserts = [];
+    const flush = () => {
+        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 = {
+            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, layout, unfolded = new Map()) {
+    const rows = [];
+    const gap = (id, oldStart, newStart, oldCount, newCount, position) => {
+        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, to) => {
+            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/dist/diff-split.d.ts

@@ -0,0 +1,17 @@
+import { 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[];
+}
+export declare function diffSplit(document: DiffDocument, unfolded?: ReadonlyMap<number, number>): DiffSplit;

package/dist/diff-split.js

@@ -0,0 +1,31 @@
+import { diffRows } from './diff-document.js';
+/* Each side contains only source text; alignment rows never enter selection, copy or Find. */
+export function diffSplit(document, unfolded) {
+    const old = { lines: [], rows: [], gaps: [] };
+    const fresh = { lines: [], rows: [], gaps: [] };
+    const aligned = [];
+    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',
+            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/dist/diff.d.ts

@@ -5,3 +5,7 @@ export interface Change {
     otherEnd: number;
 }
 export declare function diffLines(base: readonly string[], other: readonly string[]): Change[];
+export declare function diffChanges(base: readonly string[], other: readonly string[], maxWork?: number): {
+    changes: Change[];
+    limited: boolean;
+};

package/dist/diff.js

@@ -8,12 +8,21 @@ function cameDown(reach, offset, diagonal, distance) {
     return diagonal === -distance || (diagonal !== distance && reach[offset + diagonal - 1] < reach[offset + diagonal + 1]);
 }
 /* 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, right, reach, offset, distance) {
+function extend(left, right, reach, offset, distance, work) {
     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;
         }
@@ -58,20 +67,26 @@ function backtrack(left, right, saved, distance, offset) {
  * 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, right) {
+function walk(left, right, maxWork) {
     const limit = Math.min(left.length + right.length, MAX_DISTANCE);
     const offset = limit;
     const reach = new Int32Array(2 * limit + 1);
     const saved = [];
+    // 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. */
 function changesOf(moves) {
@@ -105,6 +120,9 @@ function changesOf(moves) {
 }
 /* Where `other` differs from `base`, in line stretches, in the order they appear. */
 export function diffLines(base, other) {
+    return diffChanges(base, other).changes;
+}
+export function diffChanges(base, other, maxWork) {
     let prefix = 0;
     while (prefix < base.length && prefix < other.length && base[prefix] === other[prefix]) {
         prefix += 1;
@@ -116,14 +134,17 @@ export function diffLines(base, other) {
     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/dist/index.d.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';

package/dist/index.js

@@ -2,3 +2,10 @@ export { diffLines } from './diff.js';
 export { openBlocks, splitBlocks } from './blocks.js';
 export { autoLines, bothLines, draftOf, fingerprint, sideLines, wandLines } from './resolve.js';
 export { joinLines, shapeOf, splitLines } from './text.js';
+export { missingSides, patchFits } from './patch.js';
+export { parsePatch, parseHunkHeader } from './patch-parser.js';
+export { diffDocument, diffRows } from './diff-document.js';
+export { patchOf } from './patch-of.js';
+export { wordChanges } from './word-changes.js';
+export { diffDisplay } from './diff-display.js';
+export { diffSplit } from './diff-split.js';

package/dist/patch-of.d.ts

@@ -0,0 +1,4 @@
+import type { ParsedPatch } from './patch-parser.ts';
+export declare function patchOf(oldText: string, newText: string, context?: number, options?: {
+    readonly maxWork?: number;
+}): ParsedPatch;

package/dist/patch-of.js

@@ -0,0 +1,122 @@
+import { diffChanges } from './diff.js';
+import { shapeOf } from './text.js';
+function fileLines(text) {
+    if (text === '') {
+        return [];
+    }
+    const lines = text.split('\n');
+    if (text.endsWith('\n')) {
+        lines.pop();
+    }
+    return lines;
+}
+function keysOf(lines, finalNewline) {
+    return lines.map((line, index) => `${index === lines.length - 1 && !finalNewline ? 'unterminated:' : 'terminated:'}${line}`);
+}
+function alignChanges(changes, old, fresh) {
+    for (const [index, change] of changes.entries()) {
+        const previous = changes[index - 1];
+        const oldBound = previous?.baseEnd ?? 0;
+        const newBound = previous?.otherEnd ?? 0;
+        const insert = change.baseStart === change.baseEnd;
+        const remove = change.otherStart === change.otherEnd;
+        if (!insert && !remove) {
+            continue;
+        }
+        // Move a repeated blank from the end of an edit to its start, between adjacent functions.
+        while (change.baseStart > oldBound && change.otherStart > newBound) {
+            const tail = insert ? fresh[change.otherEnd - 1] : old[change.baseEnd - 1];
+            if (tail.slice(tail.indexOf(':') + 1).trim() !== '' || old[change.baseStart - 1] !== tail || fresh[change.otherStart - 1] !== tail) {
+                break;
+            }
+            change.baseStart -= 1;
+            change.baseEnd -= 1;
+            change.otherStart -= 1;
+            change.otherEnd -= 1;
+        }
+    }
+}
+function rangeText(start, count) {
+    return `${start + (count === 0 ? 0 : 1)},${count}`;
+}
+export function patchOf(oldText, newText, context = 3, options) {
+    if (!Number.isSafeInteger(context) || context < 0) {
+        throw new RangeError('Patch context must be a nonnegative safe integer.');
+    }
+    const maxWork = options?.maxWork;
+    if (maxWork !== undefined && (!Number.isSafeInteger(maxWork) || maxWork < 0)) {
+        throw new RangeError('Patch work budget must be a nonnegative safe integer.');
+    }
+    const old = fileLines(oldText);
+    const fresh = fileLines(newText);
+    const oldShape = shapeOf(oldText);
+    const newShape = shapeOf(newText);
+    const oldKeys = keysOf(old, oldShape.finalNewline);
+    const newKeys = keysOf(fresh, newShape.finalNewline);
+    const { changes, limited } = diffChanges(oldKeys, newKeys, maxWork);
+    alignChanges(changes, oldKeys, newKeys);
+    const hunks = [];
+    let group = [];
+    const finish = () => {
+        if (group.length === 0) {
+            return;
+        }
+        const first = group[0];
+        const last = group.at(-1);
+        const before = Math.min(context, first.baseStart, first.otherStart);
+        const after = Math.min(context, old.length - last.baseEnd, fresh.length - last.otherEnd);
+        const oldStart = first.baseStart - before;
+        const newStart = first.otherStart - before;
+        const lines = [];
+        const line = (kind, at) => {
+            const source = kind === 'insert' ? fresh : old;
+            const shape = kind === 'insert' ? newShape : oldShape;
+            lines.push({ kind, text: source[at], ...(at === source.length - 1 && !shape.finalNewline ? { noNewline: true } : {}) });
+        };
+        let oldAt = oldStart;
+        for (const change of group) {
+            for (; oldAt < change.baseStart; oldAt++) {
+                line('context', oldAt);
+            }
+            for (; oldAt < change.baseEnd; oldAt++) {
+                line('delete', oldAt);
+            }
+            for (let newAt = change.otherStart; newAt < change.otherEnd; newAt++) {
+                line('insert', newAt);
+            }
+        }
+        for (; oldAt < last.baseEnd + after; oldAt++) {
+            line('context', oldAt);
+        }
+        const coarse = limited || group.some((change) => change.baseEnd - change.baseStart + change.otherEnd - change.otherStart > 4000);
+        hunks.push({
+            oldStart,
+            newStart,
+            oldCount: last.baseEnd + after - oldStart,
+            newCount: last.otherEnd + after - newStart,
+            section: '',
+            lines,
+            ...(coarse ? { coarse: true } : {})
+        });
+        group = [];
+    };
+    for (const change of changes) {
+        const previous = group.at(-1);
+        if (previous !== undefined && change.baseStart - previous.baseEnd > 2 * context) {
+            finish();
+        }
+        group.push(change);
+    }
+    finish();
+    const parts = [];
+    for (const hunk of hunks) {
+        parts.push(`@@ -${rangeText(hunk.oldStart, hunk.oldCount)} +${rangeText(hunk.newStart, hunk.newCount)} @@`);
+        for (const line of hunk.lines) {
+            parts.push(`${line.kind === 'context' ? ' ' : line.kind === 'delete' ? '-' : '+'}${line.text}`);
+            if (line.noNewline) {
+                parts.push('\');
+            }
+        }
+    }
+    return { text: parts.length === 0 ? '' : `${parts.join('\n')}\n`, hunks, missing: { old: false, new: false }, partial: false };
+}

package/dist/patch-parser.d.ts

@@ -0,0 +1,32 @@
+export interface PatchLine {
+    readonly kind: 'context' | 'delete' | 'insert';
+    readonly text: string;
+    readonly noNewline?: true;
+}
+export interface Hunk {
+    readonly oldStart: number;
+    readonly oldCount: number;
+    readonly newStart: number;
+    readonly newCount: number;
+    readonly section: string;
+    readonly coarse?: true;
+    readonly lines: readonly PatchLine[];
+}
+export interface ParsedPatch {
+    readonly text: string;
+    readonly hunks: readonly Hunk[];
+    readonly missing: {
+        readonly old: boolean;
+        readonly new: boolean;
+    };
+    readonly partial: boolean;
+}
+export interface HunkHeader {
+    readonly oldStart: number;
+    readonly oldCount: number;
+    readonly newStart: number;
+    readonly newCount: number;
+    readonly section: string;
+}
+export declare function parseHunkHeader(line: string): HunkHeader | undefined;
+export declare function parsePatch(patch: string): ParsedPatch;