@adecore/merge 0.38.0 → 0.40.0

package/dist/blocks.d.ts

@@ -5,4 +5,5 @@ export interface MergeBlock {
     ours: string[];
     theirs: string[];
 }
+export declare function same(left: readonly string[], right: readonly string[]): boolean;
 export declare function splitBlocks(base: readonly string[], ours: readonly string[], theirs: readonly string[]): MergeBlock[];

package/dist/blocks.js

@@ -1,5 +1,5 @@
 import { diffLines } from './diff.js';
-function same(left, right) {
+export function same(left, right) {
     return left.length === right.length && left.every((line, index) => line === right[index]);
 }
 function kindOf(base, ours, theirs) {

package/dist/diff-document.js

@@ -1,4 +1,4 @@
-import { shapeOf, splitLines } from './text.js';
+import { lineMatcher, rawLines, shapeOf, splitLines } from './text.js';
 function sourceText(line) {
     return line.noNewline ? line.text : line.text.replace(/\r$/, '');
 }
@@ -6,21 +6,11 @@ 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);
+    const same = lineMatcher(ignoreWhitespace);
     let oldAt = 0;
     let newAt = 0;
     const gapFits = (oldEnd, newEnd) => {
@@ -184,14 +174,14 @@ export function diffRows(document, layout, unfolded = new Map()) {
     };
     let oldAt = 0;
     let newAt = 0;
-    document.hunks.forEach((hunk, index) => {
+    for (const [index, hunk] of document.hunks.entries()) {
         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');
     }

package/dist/patch-of.js

@@ -1,15 +1,5 @@
 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;
-}
+import { rawLines, shapeOf } from './text.js';
 function keysOf(lines, finalNewline) {
     return lines.map((line, index) => `${index === lines.length - 1 && !finalNewline ? 'unterminated:' : 'terminated:'}${line}`);
 }
@@ -47,8 +37,8 @@ export function patchOf(oldText, newText, context = 3, options) {
     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 old = rawLines(oldText);
+    const fresh = rawLines(newText);
     const oldShape = shapeOf(oldText);
     const newShape = shapeOf(newText);
     const oldKeys = keysOf(old, oldShape.finalNewline);

package/dist/patch.js

@@ -1,4 +1,5 @@
 import { parsePatch } from './patch-parser.js';
+import { lineMatcher } from './text.js';
 /* 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);
@@ -6,16 +7,14 @@ export function missingSides(patch) {
     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. A patch cut off before its hunks end fits nothing. */
+/* A patch cut off before its hunks end fits nothing. */
 export function patchFits(patch, oldText, newText, ignoreWhitespace) {
     if (parsePatch(patch).partial) {
         return false;
     }
     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;
+    const same = lineMatcher(ignoreWhitespace);
     let oldAt = -1;
     let newAt = -1;
     let hunks = 0;

package/dist/resolve.d.ts

@@ -1,4 +1,4 @@
-import type { MergeBlock } from './blocks.ts';
+import { type MergeBlock } from './blocks.ts';
 export type MergeSide = 'ours' | 'theirs';
 export declare function sideLines(block: MergeBlock, side: MergeSide): string[];
 export declare function bothLines(block: MergeBlock, first: MergeSide): string[];

package/dist/resolve.js

@@ -1,5 +1,6 @@
+import { same } from './blocks.js';
 export function sideLines(block, side) {
-    return side === 'ours' ? [...block.ours] : [...block.theirs];
+    return [...block[side]];
 }
 /* Both sides, one after the other, for the conflict where the two additions both belong. */
 export function bothLines(block, first) {
@@ -32,8 +33,11 @@ function runIn(outer, inner) {
  * what `outer` adds is one `inner` deleted, and taking `outer` would put it back.
  */
 function covers(base, outer, inner) {
+    if (inner.length === 0) {
+        return false;
+    }
     const start = runIn(outer, inner);
-    if (inner.length === 0 || start < 0) {
+    if (start < 0) {
         return false;
     }
     const added = [...outer.slice(0, start), ...outer.slice(start + inner.length)];
@@ -48,10 +52,7 @@ export function wandLines(block) {
     if (block.kind !== 'conflict') {
         return autoLines(block);
     }
-    if (block.ours.length === block.theirs.length && block.ours.every((line, index) => line === block.theirs[index])) {
-        return [...block.ours];
-    }
-    if (covers(block.base, block.ours, block.theirs)) {
+    if (same(block.ours, block.theirs) || covers(block.base, block.ours, block.theirs)) {
         return [...block.ours];
     }
     if (covers(block.base, block.theirs, block.ours)) {

package/dist/text.d.ts

@@ -4,4 +4,6 @@ export interface TextShape {
 }
 export declare function shapeOf(text: string): TextShape;
 export declare function splitLines(text: string): string[];
+export declare function rawLines(text: string): string[];
+export declare function lineMatcher(ignoreWhitespace: boolean): (shown: string, actual: string | undefined) => boolean;
 export declare function joinLines(lines: readonly string[], shape: TextShape): string;

package/dist/text.js

@@ -17,6 +17,23 @@ export function splitLines(text) {
     }
     return lines;
 }
+/* The lines of a file split on `\n` alone, so a `\r` stays part of its line. */
+export function rawLines(text) {
+    if (text === '') {
+        return [];
+    }
+    const lines = text.split('\n');
+    if (text.endsWith('\n')) {
+        lines.pop();
+    }
+    return lines;
+}
+/* Git's --ignore-all-space may show either side's spacing, so a shown line matches by its non-space characters. */
+export function lineMatcher(ignoreWhitespace) {
+    return ignoreWhitespace
+        ? (shown, actual) => actual !== undefined && shown.replace(/\s+/g, '') === actual.replace(/\s+/g, '')
+        : (shown, actual) => shown === actual;
+}
 export function joinLines(lines, shape) {
     return lines.length === 0 ? '' : lines.join(shape.eol) + (shape.finalNewline ? shape.eol : '');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/merge",
-  "version": "0.38.0",
+  "version": "0.40.0",
   "description": "Pure line diffs, three-way merge blocks and conflict resolution.",
   "license": "FSL-1.1-MIT",
   "author": "Bas Milius",
@@ -36,8 +36,8 @@
     "test:memory": "bun --config=scripts/memory.bunfig.toml test src/diff-memory.integration.test.ts"
   },
   "devDependencies": {
-    "@types/bun": "^1.4.2",
-    "@types/node": "^24.13.6",
+    "@types/bun": "^1.4.4",
+    "@types/node": "^24.19.2",
     "typescript": "^7.0.2"
   }
 }

package/src/blocks.ts

@@ -14,7 +14,7 @@ export interface MergeBlock {
     theirs: string[];
 }
 
-function same(left: readonly string[], right: readonly string[]): boolean {
+export function same(left: readonly string[], right: readonly string[]): boolean {
     return left.length === right.length && left.every((line, index) => line === right[index]);
 }
 
@@ -22,12 +22,15 @@ function kindOf(base: readonly string[], ours: readonly string[], theirs: readon
     if (same(ours, theirs)) {
         return same(base, ours) ? 'stable' : 'both';
     }
+
     if (same(base, ours)) {
         return 'theirs';
     }
+
     if (same(base, theirs)) {
         return 'ours';
     }
+
     return 'conflict';
 }
 
@@ -54,9 +57,11 @@ export function splitBlocks(base: readonly string[], ours: readonly string[], th
 
     const push = (baseEnd: number, ourEnd: number, theirEnd: number): void => {
         const stretch = { base: base.slice(baseAt, baseEnd), ours: ours.slice(ourAt, ourEnd), theirs: theirs.slice(theirAt, theirEnd) };
+
         if (stretch.base.length > 0 || stretch.ours.length > 0 || stretch.theirs.length > 0) {
             blocks.push({ kind: kindOf(stretch.base, stretch.ours, stretch.theirs), ...stretch });
         }
+
         baseAt = baseEnd;
         ourAt = ourEnd;
         theirAt = theirEnd;
@@ -64,19 +69,24 @@ export function splitBlocks(base: readonly string[], ours: readonly string[], th
 
     while (ourNext < ourChanges.length || theirNext < theirChanges.length) {
         const start = Math.min(ourChanges[ourNext]?.baseStart ?? Infinity, theirChanges[theirNext]?.baseStart ?? Infinity);
+
         if (start > baseAt) {
             const length = start - baseAt;
             push(start, ourAt + length, theirAt + length);
         }
+
         let end = baseAt;
         let ourGrowth = 0;
         let theirGrowth = 0;
+
         /* The stretch grows while a change of either side reaches into it: two changes that overlap
            in the base are one thing a person has to look at, however far apart they started. */
         for (let taken = true; taken;) {
             taken = false;
+
             const reaches = (change: Change | undefined): boolean =>
                 change !== undefined && change.baseStart <= end && (change.baseStart < end || end === baseAt);
+
             while (reaches(ourChanges[ourNext])) {
                 const change = ourChanges[ourNext]!;
                 end = Math.max(end, change.baseEnd);
@@ -84,6 +94,7 @@ export function splitBlocks(base: readonly string[], ours: readonly string[], th
                 ourNext += 1;
                 taken = true;
             }
+
             while (reaches(theirChanges[theirNext])) {
                 const change = theirChanges[theirNext]!;
                 end = Math.max(end, change.baseEnd);
@@ -92,8 +103,11 @@ export function splitBlocks(base: readonly string[], ours: readonly string[], th
                 taken = true;
             }
         }
+
         push(end, ourAt + (end - baseAt) + ourGrowth, theirAt + (end - baseAt) + theirGrowth);
     }
+
     push(base.length, ours.length, theirs.length);
+
     return blocks;
 }

package/src/diff-display.ts

@@ -18,6 +18,7 @@ export function diffDisplay(document: DiffDocument, unfolded?: ReadonlyMap<numbe
     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 });
@@ -27,5 +28,6 @@ export function diffDisplay(document: DiffDocument, unfolded?: ReadonlyMap<numbe
             rows.push(row);
         }
     }
+
     return { text: lines.join('\n'), lines, rows, gaps };
 }

package/src/diff-document.ts

@@ -1,5 +1,5 @@
 import type { Hunk, ParsedPatch, PatchLine } from './patch-parser.ts';
-import { shapeOf, splitLines, type TextShape } from './text.ts';
+import { lineMatcher, rawLines, shapeOf, splitLines, type TextShape } from './text.ts';
 
 export interface DiffLineRef {
     readonly index: number;
@@ -45,56 +45,58 @@ function snapshotsFit(parsed: ParsedPatch, contents: { old: string; new: string
     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);
+    const same = lineMatcher(ignoreWhitespace);
     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);
 }
 
@@ -110,20 +112,26 @@ export function diffDocument(parsed: ParsedPatch, contents: { old: string; new:
             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 };
 }
 
@@ -139,10 +147,12 @@ function hunkRows(document: DiffDocument, index: number, layout: 'unified' | 'sp
     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',
@@ -152,12 +162,15 @@ function hunkRows(document: DiffDocument, index: number, layout: 'unified' | 'sp
                 ...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,
@@ -166,8 +179,10 @@ function hunkRows(document: DiffDocument, index: number, layout: 'unified' | 'sp
             ...(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') {
@@ -177,29 +192,37 @@ function hunkRows(document: DiffDocument, index: number, layout: 'unified' | 'sp
             (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',
@@ -212,7 +235,9 @@ export function diffRows(document: DiffDocument, layout: 'unified' | 'split', un
                 });
             }
         };
+
         context(0, leading);
+
         if (oldCount - leading - trailing > 0 || newCount - leading - trailing > 0) {
             rows.push({
                 kind: 'gap',
@@ -224,20 +249,27 @@ export function diffRows(document: DiffDocument, layout: 'unified' | 'split', un
                 unfoldable
             });
         }
+
         context(oldCount - trailing, oldCount);
     };
+
     let oldAt = 0;
     let newAt = 0;
-    document.hunks.forEach((hunk, index) => {
+
+    for (const [index, hunk] of document.hunks.entries()) {
         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

@@ -16,28 +16,35 @@ export function diffSplit(document: DiffDocument, unfolded?: ReadonlyMap<number,
     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

@@ -39,24 +39,31 @@ function extend(left: readonly string[], right: readonly string[], reach: Int32A
         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) {
             if (work !== undefined && work.remaining-- <= 0) {
                 return null;
             }
+
             if (left[x] !== right[y]) {
                 break;
             }
+
             x += 1;
             y += 1;
         }
+
         reach[offset + diagonal] = x;
+
         if (x >= left.length && y >= right.length) {
             return true;
         }
     }
+
     return false;
 }
 
@@ -66,15 +73,18 @@ function backtrack(left: readonly string[], right: readonly string[], saved: rea
     let x = left.length;
     let y = right.length;
     const states = Array.from({ length: Math.min(distance, STRIDE) + 1 }, () => new Int32Array(2 * offset + 1));
+
     for (let step = distance; step > 0;) {
         // The states the rounds from the saved one below this step started in, walked again.
         const first = Math.floor((step - 1) / STRIDE) * STRIDE;
         states[0]!.set(saved[first / STRIDE]!);
+
         for (let round = first; round < step; round += 1) {
             const next = states[round - first + 1]!;
             next.set(states[round - first]!);
             extend(left, right, next, offset, round);
         }
+
         for (; step > first; step -= 1) {
             const state = states[step - first]!;
             const diagonal = x - y;
@@ -87,6 +97,7 @@ function backtrack(left: readonly string[], right: readonly string[], saved: rea
             y = prevY;
         }
     }
+
     return moves.reverse();
 }
 
@@ -102,18 +113,23 @@ function walk(left: readonly string[], right: readonly string[], maxWork?: numbe
     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());
         }
+
         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 { moves: null, limited: false };
 }
 
@@ -121,11 +137,13 @@ function walk(left: readonly string[], right: readonly string[], maxWork?: numbe
 function changesOf(moves: readonly Move[]): Change[] {
     const changes: Change[] = [];
     let current: Change | null = null;
+
     for (const move of moves) {
         // A delete moves along the base side and so raises the diagonal; an insert lowers it.
         const deleted = move.x - move.y > move.prevX - move.prevY;
         const editX = deleted ? move.prevX + 1 : move.prevX;
         const editY = deleted ? move.prevY : move.prevY + 1;
+
         if (current !== null && current.baseEnd === move.prevX && current.otherEnd === move.prevY) {
             current.baseEnd = editX;
             current.otherEnd = editY;
@@ -133,17 +151,21 @@ function changesOf(moves: readonly Move[]): Change[] {
             if (current !== null) {
                 changes.push(current);
             }
+
             current = { baseStart: move.prevX, baseEnd: editX, otherStart: move.prevY, otherEnd: editY };
         }
+
         // What follows the edit is a run of equal lines, which ends the stretch.
         if (move.x !== editX || move.y !== editY) {
             changes.push(current);
             current = null;
         }
     }
+
     if (current !== null) {
         changes.push(current);
     }
+
     return changes;
 }
 
@@ -154,20 +176,27 @@ export function diffLines(base: readonly string[], other: readonly string[]): Ch
 
 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;
     }
+
     let suffix = 0;
+
     while (suffix < base.length - prefix && suffix < other.length - prefix && base[base.length - 1 - suffix] === other[other.length - 1 - suffix]) {
         suffix += 1;
     }
+
     const left = base.slice(prefix, base.length - suffix);
     const right = other.slice(prefix, other.length - suffix);
+
     if (left.length === 0 && right.length === 0) {
         return { changes: [], limited: false };
     }
+
     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: changes.map((change) => ({
             baseStart: change.baseStart + prefix,

package/src/patch-of.ts

@@ -1,17 +1,6 @@
 import { diffChanges, type Change } from './diff.ts';
 import type { Hunk, ParsedPatch, PatchLine } from './patch-parser.ts';
-import { shapeOf } from './text.ts';
-
-function fileLines(text: string): string[] {
-    if (text === '') {
-        return [];
-    }
-    const lines = text.split('\n');
-    if (text.endsWith('\n')) {
-        lines.pop();
-    }
-    return lines;
-}
+import { rawLines, shapeOf } from './text.ts';
 
 function keysOf(lines: readonly string[], finalNewline: boolean): string[] {
     return lines.map((line, index) => `${index === lines.length - 1 && !finalNewline ? 'unterminated:' : 'terminated:'}${line}`);
@@ -24,15 +13,19 @@ function alignChanges(changes: Change[], old: readonly string[], fresh: readonly
         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;
@@ -49,12 +42,15 @@ export function patchOf(oldText: string, newText: string, 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 old = rawLines(oldText);
+    const fresh = rawLines(newText);
     const oldShape = shapeOf(oldText);
     const newShape = shapeOf(newText);
     const oldKeys = keysOf(old, oldShape.finalNewline);
@@ -63,10 +59,12 @@ export function patchOf(oldText: string, newText: string, context = 3, options?:
     alignChanges(changes, oldKeys, newKeys);
     const hunks: Hunk[] = [];
     let group: Change[] = [];
+
     const finish = (): void => {
         if (group.length === 0) {
             return;
         }
+
         const first = group[0]!;
         const last = group.at(-1)!;
         const before = Math.min(context, first.baseStart, first.otherStart);
@@ -74,27 +72,35 @@ export function patchOf(oldText: string, newText: string, context = 3, options?:
         const oldStart = first.baseStart - before;
         const newStart = first.otherStart - before;
         const lines: PatchLine[] = [];
+
         const line = (kind: PatchLine['kind'], at: number): void => {
             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 as const } : {}) });
         };
+
         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,
@@ -104,25 +110,34 @@ export function patchOf(oldText: string, newText: string, context = 3, options?:
             lines,
             ...(coarse ? { coarse: true as const } : {})
         });
+
         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: string[] = [];
+
     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/src/patch-parser.ts

@@ -35,9 +35,11 @@ export interface HunkHeader {
 /* Reads one `@@ -a,b +c,d @@ section` line without its line ending; undefined when it is not a hunk header. */
 export function parseHunkHeader(line: string): HunkHeader | undefined {
     const match = HEADER.exec(line);
+
     if (match === null) {
         return undefined;
     }
+
     return {
         oldStart: Number(match[1]),
         oldCount: Number(match[2] ?? 1),
@@ -57,59 +59,78 @@ export function parsePatch(patch: string): ParsedPatch {
     let oldEnded = false;
     let newEnded = false;
     const header: string[] = [];
+
     const finish = (): void => {
         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 {
@@ -117,28 +138,38 @@ export function parsePatch(patch: string): ParsedPatch {
                 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,

package/src/patch.ts

@@ -1,56 +1,67 @@
 import { parsePatch } from './patch-parser.ts';
+import { lineMatcher } from './text.ts';
 
 /* 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: string): { old: boolean; new: boolean } {
     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. A patch cut off before its hunks end fits nothing. */
+/* A patch cut off before its hunks end fits nothing. */
 export function patchFits(patch: string, oldText: string, newText: string, ignoreWhitespace: boolean): boolean {
     if (parsePatch(patch).partial) {
         return false;
     }
+
     const oldLines = oldText.split('\n');
     const newLines = newText.split('\n');
-    const same = ignoreWhitespace
-        ? (shown: string, actual: string | undefined): boolean => actual !== undefined && shown.replace(/\s+/g, '') === actual.replace(/\s+/g, '')
-        : (shown: string, actual: string | undefined): boolean => shown === actual;
+    const same = lineMatcher(ignoreWhitespace);
     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/src/resolve.ts

@@ -1,9 +1,9 @@
-import type { MergeBlock } from './blocks.ts';
+import { same, type MergeBlock } from './blocks.ts';
 
 export type MergeSide = 'ours' | 'theirs';
 
 export function sideLines(block: MergeBlock, side: MergeSide): string[] {
-    return side === 'ours' ? [...block.ours] : [...block.theirs];
+    return [...block[side]];
 }
 
 /* Both sides, one after the other, for the conflict where the two additions both belong. */
@@ -32,6 +32,7 @@ function runIn(outer: readonly string[], inner: readonly string[]): number {
             return start;
         }
     }
+
     return -1;
 }
 
@@ -40,11 +41,18 @@ function runIn(outer: readonly string[], inner: readonly string[]): number {
  * what `outer` adds is one `inner` deleted, and taking `outer` would put it back.
  */
 function covers(base: readonly string[], outer: readonly string[], inner: readonly string[]): boolean {
+    if (inner.length === 0) {
+        return false;
+    }
+
     const start = runIn(outer, inner);
-    if (inner.length === 0 || start < 0) {
+
+    if (start < 0) {
         return false;
     }
+
     const added = [...outer.slice(0, start), ...outer.slice(start + inner.length)];
+
     return added.every((line) => !base.includes(line) || inner.includes(line));
 }
 
@@ -57,15 +65,15 @@ export function wandLines(block: MergeBlock): string[] | null {
     if (block.kind !== 'conflict') {
         return autoLines(block);
     }
-    if (block.ours.length === block.theirs.length && block.ours.every((line, index) => line === block.theirs[index])) {
-        return [...block.ours];
-    }
-    if (covers(block.base, block.ours, block.theirs)) {
+
+    if (same(block.ours, block.theirs) || covers(block.base, block.ours, block.theirs)) {
         return [...block.ours];
     }
+
     if (covers(block.base, block.theirs, block.ours)) {
         return [...block.theirs];
     }
+
     return null;
 }
 
@@ -76,12 +84,15 @@ export function wandLines(block: MergeBlock): string[] | null {
  */
 export function fingerprint(block: MergeBlock): string {
     let hash = 0x811c9dc5;
+
     for (const line of [...block.ours, '\u0000', ...block.theirs]) {
         for (let index = 0; index < line.length; index += 1) {
             hash = Math.imul(hash ^ line.charCodeAt(index), 0x01000193);
         }
+
         hash = Math.imul(hash ^ 0x0a, 0x01000193);
     }
+
     return (hash >>> 0).toString(16).padStart(8, '0');
 }
 
@@ -106,13 +117,17 @@ export interface MergeDraft {
 export function draftOf(blocks: readonly MergeBlock[], answered: ReadonlyMap<number, readonly string[]> = new Map()): MergeDraft {
     const lines: string[] = [];
     const spans: MergeSpan[] = [];
+
     for (const [index, block] of blocks.entries()) {
         const from = lines.length;
+
         // One push per line: a block of a few hundred thousand lines is more arguments than V8 takes in one call.
         for (const line of answered.get(index) ?? autoLines(block) ?? block.ours) {
             lines.push(line);
         }
+
         spans.push({ block: index, kind: block.kind, from, to: lines.length });
     }
+
     return { lines, spans };
 }

package/src/text.ts

@@ -10,6 +10,7 @@ export interface TextShape {
 /* The line ending a file uses, by the first one in it, and whether it ends on one. */
 export function shapeOf(text: string): TextShape {
     const line = text.indexOf('\n');
+
     return {
         eol: line > 0 && text[line - 1] === '\r' ? '\r\n' : '\n',
         finalNewline: text === '' || text.endsWith('\n')
@@ -21,13 +22,38 @@ export function splitLines(text: string): string[] {
     if (text === '') {
         return [];
     }
+
     const lines = text.split(/\r\n|\n/);
+
     if (lines[lines.length - 1] === '') {
         lines.pop();
     }
+
     return lines;
 }
 
+/* The lines of a file split on `\n` alone, so a `\r` stays part of its line. */
+export function rawLines(text: string): string[] {
+    if (text === '') {
+        return [];
+    }
+
+    const lines = text.split('\n');
+
+    if (text.endsWith('\n')) {
+        lines.pop();
+    }
+
+    return lines;
+}
+
+/* Git's --ignore-all-space may show either side's spacing, so a shown line matches by its non-space characters. */
+export function lineMatcher(ignoreWhitespace: boolean): (shown: string, actual: string | undefined) => boolean {
+    return ignoreWhitespace
+        ? (shown, actual) => actual !== undefined && shown.replace(/\s+/g, '') === actual.replace(/\s+/g, '')
+        : (shown, actual) => shown === actual;
+}
+
 export function joinLines(lines: readonly string[], shape: TextShape): string {
     return lines.length === 0 ? '' : lines.join(shape.eol) + (shape.finalNewline ? shape.eol : '');
 }

package/src/word-changes.ts

@@ -11,16 +11,21 @@ export function wordChanges(oldLine: string, newLine: string): { old: DiffWordRa
     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: readonly Intl.SegmentData[], text: string, from: number, to: number): DiffWordRange[] =>
         from === to ? [] : [{ from: segments[from]!.index, to: segments[to]?.index ?? text.length }];
+
     const old: DiffWordRange[] = [];
     const fresh: DiffWordRange[] = [];
+
     for (const change of diffLines(
         before.map((part) => part.segment),
         after.map((part) => part.segment)
@@ -28,5 +33,6 @@ export function wordChanges(oldLine: string, newLine: string): { old: DiffWordRa
         old.push(...range(before, oldLine, change.baseStart, change.baseEnd));
         fresh.push(...range(after, newLine, change.otherStart, change.otherEnd));
     }
+
     return { old, new: fresh };
 }