@lapismd/design-core 0.1.2 → 0.3.0

package/dist/shared/diff/core/merge/one-way.d.ts

@@ -0,0 +1,2 @@
+import type { MergeModel, MergeOptions } from "./types.js";
+export declare function assembleOneWayMerge(left: string, right: string, options?: MergeOptions): MergeModel;

package/dist/shared/diff/core/merge/one-way.js

@@ -0,0 +1,67 @@
+import { createBlock, recomputeModel } from "./blocks.js";
+import { diffSequences } from "./diff.js";
+import { splitLines } from "./lines.js";
+import { normalizeOptions } from "./options.js";
+export function assembleOneWayMerge(left, right, options) {
+    const normalizedOptions = normalizeOptions(options);
+    const leftLines = splitLines(left);
+    const rightLines = splitLines(right);
+    const ops = diffSequences(leftLines, rightLines, normalizedOptions);
+    const blocks = [];
+    let leftLine = 0;
+    let rightLine = 0;
+    let pendingLeft = [];
+    let pendingRight = [];
+    let pendingLeftStart = 0;
+    let pendingRightStart = 0;
+    function flushPending() {
+        if (pendingLeft.length === 0 && pendingRight.length === 0) {
+            return;
+        }
+        const kind = pendingLeft.length > 0 && pendingRight.length > 0
+            ? "modified"
+            : pendingLeft.length > 0
+                ? "removed"
+                : "added";
+        blocks.push(createBlock(blocks.length, kind, true, { left: pendingLeft, right: pendingRight, base: pendingRight }, {
+            left: pendingLeftStart,
+            right: pendingRightStart,
+            base: pendingRightStart,
+        }, normalizedOptions));
+        pendingLeft = [];
+        pendingRight = [];
+    }
+    for (const op of ops) {
+        if (op.kind === "same") {
+            flushPending();
+            blocks.push(createBlock(blocks.length, "unchanged", true, { left: [op.left], right: [op.right], base: [op.right] }, { left: leftLine, right: rightLine, base: rightLine }, normalizedOptions));
+            leftLine += 1;
+            rightLine += 1;
+            continue;
+        }
+        if (pendingLeft.length === 0 && pendingRight.length === 0) {
+            pendingLeftStart = leftLine;
+            pendingRightStart = rightLine;
+        }
+        if (op.kind === "left") {
+            pendingLeft.push(op.value);
+            leftLine += 1;
+        }
+        else {
+            pendingRight.push(op.value);
+            rightLine += 1;
+        }
+    }
+    flushPending();
+    return recomputeModel({
+        mode: "one-way",
+        left,
+        base: right,
+        right,
+        sourceBase: right,
+        blocks,
+        options: normalizedOptions,
+        conflictCount: 0,
+        unresolvedConflictCount: 0,
+    }, blocks);
+}

package/dist/shared/diff/core/merge/options.d.ts

@@ -0,0 +1,4 @@
+import type { MergeOptions } from "./types.js";
+export declare const DEFAULT_OPTIONS: Required<MergeOptions>;
+export declare function normalizeOptions(options?: MergeOptions): Required<MergeOptions>;
+export declare function normalizeComparableLine(line: string, options: Required<MergeOptions>): string;

package/dist/shared/diff/core/merge/options.js

@@ -0,0 +1,16 @@
+export const DEFAULT_OPTIONS = {
+    ignoreWhitespace: false,
+    ignoreCase: false,
+    lineDiffAlgorithm: "words_with_space",
+    workingCopyCenter: false,
+};
+export function normalizeOptions(options) {
+    return { ...DEFAULT_OPTIONS, ...options };
+}
+export function normalizeComparableLine(line, options) {
+    let normalized = options.ignoreWhitespace ? line.replace(/\s+/g, "") : line;
+    if (options.ignoreCase) {
+        normalized = normalized.toLocaleLowerCase();
+    }
+    return normalized;
+}

package/dist/shared/diff/core/merge/render-model.d.ts

@@ -0,0 +1,45 @@
+import type { MergeBlock, MergeLine, MergeModel, MergeSide } from "./types.js";
+export type RenderVisualKind = "unchanged" | "added" | "removed" | "modified" | "conflict" | "resolved";
+export type RenderActionKind = "merge" | "delete" | "resolve";
+export interface RenderAction {
+    kind: RenderActionKind;
+    side: MergeSide;
+    blockId: string;
+}
+export interface RenderComponent {
+    id: string;
+    blockId: string;
+    side: MergeSide;
+    blockKind: MergeBlock["kind"];
+    visualKind: RenderVisualKind;
+    lines: MergeLine[];
+    lineStart: number;
+    placeholder: boolean;
+    resolved: boolean;
+    acceptedInCenter: boolean;
+    action?: RenderAction;
+}
+export interface RenderConnection {
+    id: string;
+    fromComponentId: string;
+    toComponentId: string;
+    fromSide: MergeSide;
+    toSide: MergeSide;
+    visualKind: RenderVisualKind;
+}
+export interface MergeRenderModel {
+    sides: Record<MergeSide, RenderComponent[]>;
+    components: RenderComponent[];
+    leftConnections: RenderConnection[];
+    rightConnections: RenderConnection[];
+}
+export interface MergeNavigationTarget {
+    blockId: string;
+    componentId: string;
+    side: MergeSide;
+}
+export declare function pendingMergeNavigationTargets(renderModel: MergeRenderModel): MergeNavigationTarget[];
+export declare function navigationIndexForLine(targets: readonly MergeNavigationTarget[], renderModel: MergeRenderModel, side: MergeSide, lineNumber: number): number;
+export declare function mergeRenderComponentIntoCenter(model: MergeModel, component: RenderComponent): MergeModel;
+export declare function deleteMergedRenderComponentFromCenter(model: MergeModel, component: RenderComponent): MergeModel;
+export declare function createMergeRenderModel(model: MergeModel, sides?: readonly MergeSide[]): MergeRenderModel;

package/dist/shared/diff/core/merge/render-model.js

@@ -0,0 +1,386 @@
+import { cloneBlockWithBaseLines, recomputeModel } from "./blocks.js";
+const NAVIGATION_SIDE_ORDER = ["left", "base", "right"];
+function isPendingNavigationComponent(component) {
+    if (component.placeholder || !component.action) {
+        return false;
+    }
+    if (component.action.kind === "merge") {
+        return true;
+    }
+    return component.action.kind === "resolve" && !component.resolved;
+}
+function preferPendingComponent(candidates) {
+    const preferred = candidates.find((component) => component.side === "left" && component.action?.kind === "merge") ??
+        candidates.find((component) => component.side === "right" && component.action?.kind === "merge") ??
+        candidates[0];
+    if (!preferred) {
+        throw new Error("Pending merge navigation requires a component");
+    }
+    return preferred;
+}
+export function pendingMergeNavigationTargets(renderModel) {
+    const blockCount = Math.max(renderModel.sides.left.length, renderModel.sides.base.length, renderModel.sides.right.length);
+    const targets = [];
+    const seen = new Set();
+    for (let index = 0; index < blockCount; index += 1) {
+        const candidates = NAVIGATION_SIDE_ORDER.map((side) => renderModel.sides[side][index]).filter((component) => Boolean(component && isPendingNavigationComponent(component)));
+        if (candidates.length === 0) {
+            continue;
+        }
+        const preferred = preferPendingComponent(candidates);
+        if (seen.has(preferred.blockId)) {
+            continue;
+        }
+        seen.add(preferred.blockId);
+        targets.push({
+            blockId: preferred.blockId,
+            componentId: preferred.id,
+            side: preferred.side,
+        });
+    }
+    return targets;
+}
+export function navigationIndexForLine(targets, renderModel, side, lineNumber) {
+    return targets.findIndex((target) => {
+        const component = renderModel.sides[side].find((candidate) => candidate.blockId === target.blockId);
+        if (!component || component.placeholder || component.lines.length === 0) {
+            return false;
+        }
+        return (lineNumber >= component.lineStart &&
+            lineNumber < component.lineStart + component.lines.length);
+    });
+}
+const EMPTY_SIDES = {
+    left: [],
+    base: [],
+    right: [],
+};
+function lineTexts(block, side) {
+    return (block.sides[side] ?? []).map((line) => line.text);
+}
+function startsWithSequence(lines, sequence) {
+    if (sequence.length > lines.length) {
+        return false;
+    }
+    return sequence.every((line, index) => lines[index] === line);
+}
+function endsWithSequence(lines, sequence) {
+    if (sequence.length > lines.length) {
+        return false;
+    }
+    const offset = lines.length - sequence.length;
+    return sequence.every((line, index) => lines[offset + index] === line);
+}
+function isSequenceMerged(block, side) {
+    if (side === "base") {
+        return false;
+    }
+    const sourceLines = lineTexts(block, side);
+    const centerLines = lineTexts(block, "base");
+    if (sourceLines.length === 0 || centerLines.length === 0) {
+        return false;
+    }
+    return side === "left"
+        ? startsWithSequence(centerLines, sourceLines)
+        : endsWithSequence(centerLines, sourceLines);
+}
+function hasMergedIntoCenter(block, side, workingCopyCenter = false) {
+    if (!isSequenceMerged(block, side)) {
+        return false;
+    }
+    if (!workingCopyCenter) {
+        return true;
+    }
+    const sourceLines = lineTexts(block, side);
+    const centerLines = lineTexts(block, "base");
+    if (sourceLines.length !== centerLines.length ||
+        sourceLines.some((line, index) => line !== centerLines[index])) {
+        return true;
+    }
+    const other = oppositeSide(side);
+    return other !== null && isSequenceMerged(block, other);
+}
+function centerIncludesMergedChange(block, workingCopyCenter = false) {
+    return (hasMergedIntoCenter(block, "left", workingCopyCenter) ||
+        hasMergedIntoCenter(block, "right", workingCopyCenter));
+}
+function oppositeSide(side) {
+    if (side === "left") {
+        return "right";
+    }
+    if (side === "right") {
+        return "left";
+    }
+    return null;
+}
+function visualKindFor(block, side, placeholder, workingCopyCenter = false) {
+    if (block.kind === "unchanged") {
+        return "unchanged";
+    }
+    if (block.kind === "conflict") {
+        if (block.resolved) {
+            return "resolved";
+        }
+        if (side !== "base" &&
+            hasMergedIntoCenter(block, side, workingCopyCenter)) {
+            return "added";
+        }
+        return "conflict";
+    }
+    if (block.kind === "modified") {
+        if (side === "base") {
+            return centerIncludesMergedChange(block, workingCopyCenter)
+                ? "added"
+                : "modified";
+        }
+        if (hasMergedIntoCenter(block, side, workingCopyCenter)) {
+            return "added";
+        }
+        if (centerIncludesMergedChange(block, workingCopyCenter)) {
+            return "removed";
+        }
+        if (workingCopyCenter &&
+            lineTexts(block, side).join("\n") === lineTexts(block, "base").join("\n")) {
+            return "unchanged";
+        }
+        return "modified";
+    }
+    if (placeholder) {
+        return block.kind;
+    }
+    return block.kind;
+}
+function linesForComponent(component) {
+    return component.lines.map((line) => line.text);
+}
+function originalCenterLines(block) {
+    return [...(block.originalBaseLines ?? lineTexts(block, "base"))];
+}
+function sideMatchesOriginalCenter(block, side, sourceLines) {
+    const originalLines = originalCenterLines(block);
+    return side === "left"
+        ? startsWithSequence(originalLines, sourceLines)
+        : endsWithSequence(originalLines, sourceLines);
+}
+function updateBlockCenterLines(model, blockId, lines, resolved) {
+    const blocks = model.blocks.map((block) => block.id === blockId
+        ? cloneBlockWithBaseLines(block, lines, resolved ?? block.resolved, model.options)
+        : block);
+    return recomputeModel(model, blocks);
+}
+export function mergeRenderComponentIntoCenter(model, component) {
+    const block = model.blocks.find((candidate) => candidate.id === component.blockId);
+    if (!block || component.side === "base") {
+        return model;
+    }
+    const sourceLines = linesForComponent(component);
+    const centerLines = lineTexts(block, "base");
+    if (sourceLines.length === 0) {
+        return model;
+    }
+    if (block.kind !== "modified" && block.kind !== "conflict") {
+        return updateBlockCenterLines(model, block.id, sourceLines, true);
+    }
+    if (hasMergedIntoCenter(block, component.side)) {
+        return model;
+    }
+    if (component.side === "left") {
+        if (startsWithSequence(centerLines, sourceLines)) {
+            return model;
+        }
+        return updateBlockCenterLines(model, block.id, [
+            ...sourceLines,
+            ...centerLines,
+        ]);
+    }
+    if (endsWithSequence(centerLines, sourceLines)) {
+        return model;
+    }
+    return updateBlockCenterLines(model, block.id, [
+        ...centerLines,
+        ...sourceLines,
+    ]);
+}
+export function deleteMergedRenderComponentFromCenter(model, component) {
+    const block = model.blocks.find((candidate) => candidate.id === component.blockId);
+    if (!block || component.side === "base") {
+        return model;
+    }
+    const sourceLines = linesForComponent(component);
+    const centerLines = lineTexts(block, "base");
+    if (sourceLines.length === 0) {
+        return model;
+    }
+    const otherSide = oppositeSide(component.side);
+    const otherSideIsMerged = otherSide
+        ? hasMergedIntoCenter(block, otherSide)
+        : false;
+    if (component.side === "left" &&
+        startsWithSequence(centerLines, sourceLines)) {
+        if (!otherSideIsMerged &&
+            !sideMatchesOriginalCenter(block, "left", sourceLines)) {
+            return updateBlockCenterLines(model, block.id, originalCenterLines(block));
+        }
+        return updateBlockCenterLines(model, block.id, centerLines.slice(sourceLines.length));
+    }
+    if (component.side === "right" &&
+        endsWithSequence(centerLines, sourceLines)) {
+        if (!otherSideIsMerged &&
+            !sideMatchesOriginalCenter(block, "right", sourceLines)) {
+            return updateBlockCenterLines(model, block.id, originalCenterLines(block));
+        }
+        return updateBlockCenterLines(model, block.id, centerLines.slice(0, centerLines.length - sourceLines.length));
+    }
+    return model;
+}
+function actionFor(block, side, visualKind, mode, workingCopyCenter = false) {
+    if (block.kind === "unchanged") {
+        return undefined;
+    }
+    if (mode === "one-way") {
+        if (side === "base" ||
+            visualKind === "unchanged" ||
+            lineTexts(block, side).length === 0) {
+            return undefined;
+        }
+        return { kind: "merge", side, blockId: block.id };
+    }
+    if (side === "base") {
+        if (block.kind === "conflict") {
+            return { kind: "resolve", side, blockId: block.id };
+        }
+        if (block.kind === "added") {
+            return { kind: "delete", side, blockId: block.id };
+        }
+        return undefined;
+    }
+    if (block.kind === "removed") {
+        if (lineTexts(block, side).length === 0) {
+            return undefined;
+        }
+        return {
+            kind: hasMergedIntoCenter(block, side, workingCopyCenter)
+                ? "delete"
+                : "merge",
+            side,
+            blockId: block.id,
+        };
+    }
+    if (block.kind !== "modified" && block.kind !== "conflict") {
+        return undefined;
+    }
+    if (visualKind === "unchanged") {
+        return undefined;
+    }
+    return {
+        kind: hasMergedIntoCenter(block, side, workingCopyCenter)
+            ? "delete"
+            : "merge",
+        side,
+        blockId: block.id,
+    };
+}
+function connectionVisualKind(from, to) {
+    if (from.visualKind === "resolved" || to.visualKind === "resolved") {
+        return "resolved";
+    }
+    if (from.visualKind === "conflict" || to.visualKind === "conflict") {
+        return "conflict";
+    }
+    if (from.visualKind === "added" || to.visualKind === "added") {
+        return "added";
+    }
+    if (from.visualKind === "removed" || to.visualKind === "removed") {
+        return "removed";
+    }
+    if (from.visualKind === "modified" || to.visualKind === "modified") {
+        return "modified";
+    }
+    return "unchanged";
+}
+function shouldConnect(from, to) {
+    if (from.blockKind === "unchanged" && to.blockKind === "unchanged") {
+        return false;
+    }
+    if (from.visualKind === "unchanged" && to.visualKind === "unchanged") {
+        return false;
+    }
+    return true;
+}
+export function createMergeRenderModel(model, sides = ["left", "base", "right"]) {
+    const renderSides = {
+        left: [],
+        base: [],
+        right: [],
+    };
+    const lineStarts = { left: 1, base: 1, right: 1 };
+    const leftConnections = [];
+    const rightConnections = [];
+    const workingCopyCenter = model.options.workingCopyCenter;
+    for (const block of model.blocks) {
+        const blockComponents = new Map();
+        for (const side of sides) {
+            const lines = block.sides[side] ?? [];
+            const placeholder = lines.length === 0 && block.kind !== "unchanged";
+            const visualKind = visualKindFor(block, side, placeholder, workingCopyCenter);
+            const action = actionFor(block, side, visualKind, model.mode, workingCopyCenter);
+            const component = {
+                id: `${block.id}:${side}`,
+                blockId: block.id,
+                side,
+                blockKind: block.kind,
+                visualKind,
+                lines,
+                lineStart: lineStarts[side],
+                placeholder,
+                resolved: block.resolved,
+                acceptedInCenter: side === "base" &&
+                    block.kind === "modified" &&
+                    centerIncludesMergedChange(block, workingCopyCenter),
+                ...(action === undefined ? {} : { action }),
+            };
+            renderSides[side].push(component);
+            blockComponents.set(side, component);
+            lineStarts[side] += Math.max(lines.length, 0);
+        }
+        const left = blockComponents.get("left");
+        const base = blockComponents.get("base");
+        const right = blockComponents.get("right");
+        if (left && base && shouldConnect(left, base)) {
+            leftConnections.push({
+                id: `${block.id}:left-base`,
+                fromComponentId: left.id,
+                toComponentId: base.id,
+                fromSide: "left",
+                toSide: "base",
+                visualKind: connectionVisualKind(left, base),
+            });
+        }
+        if (base && right && shouldConnect(base, right)) {
+            rightConnections.push({
+                id: `${block.id}:base-right`,
+                fromComponentId: base.id,
+                toComponentId: right.id,
+                fromSide: "base",
+                toSide: "right",
+                visualKind: connectionVisualKind(base, right),
+            });
+        }
+        if (!base && left && right && shouldConnect(left, right)) {
+            leftConnections.push({
+                id: `${block.id}:left-right`,
+                fromComponentId: left.id,
+                toComponentId: right.id,
+                fromSide: "left",
+                toSide: "right",
+                visualKind: connectionVisualKind(left, right),
+            });
+        }
+    }
+    return {
+        sides: { ...EMPTY_SIDES, ...renderSides },
+        components: sides.flatMap((side) => renderSides[side]),
+        leftConnections,
+        rightConnections,
+    };
+}

package/dist/shared/diff/core/merge/three-way.d.ts

@@ -0,0 +1,2 @@
+import type { MergeModel, MergeOptions } from "./types.js";
+export declare function assembleThreeWayMerge(left: string, base: string, right: string, options?: MergeOptions): MergeModel;

package/dist/shared/diff/core/merge/three-way.js

@@ -0,0 +1,157 @@
+import { createBlock, recomputeModel } from "./blocks.js";
+import { diffSequences } from "./diff.js";
+import { linesEqual, splitLines } from "./lines.js";
+import { normalizeOptions } from "./options.js";
+function diffBaseToSide(baseLines, sideLines, options) {
+    const ops = diffSequences(baseLines, sideLines, options);
+    const changes = [];
+    let baseIndex = 0;
+    let current = null;
+    function startChange() {
+        if (!current) {
+            current = { baseStart: baseIndex, baseEnd: baseIndex, lines: [] };
+        }
+        return current;
+    }
+    function flush() {
+        if (current) {
+            changes.push(current);
+            current = null;
+        }
+    }
+    for (const op of ops) {
+        if (op.kind === "same") {
+            flush();
+            baseIndex += 1;
+        }
+        else if (op.kind === "left") {
+            const change = startChange();
+            baseIndex += 1;
+            change.baseEnd = baseIndex;
+        }
+        else {
+            const change = startChange();
+            change.lines.push(op.value);
+        }
+    }
+    flush();
+    return changes;
+}
+function findInsertion(changes, baseIndex) {
+    return (changes.find((change) => change.baseStart === baseIndex && change.baseEnd === baseIndex) ?? null);
+}
+function findCoveringChange(changes, baseIndex) {
+    return (changes.find((change) => change.baseStart <= baseIndex && baseIndex < change.baseEnd) ?? null);
+}
+function sideLinesForRange(change, baseLines, start, end) {
+    if (!change) {
+        return [...baseLines.slice(start, end)];
+    }
+    return [...change.lines];
+}
+function workingCopyHunkKind(centerLines, sideLines) {
+    if (centerLines.length === 0 && sideLines.length > 0) {
+        return "removed";
+    }
+    if (centerLines.length > 0 && sideLines.length === 0) {
+        return "added";
+    }
+    return "modified";
+}
+function createThreeWayChangeBlock(blocks, baseLines, leftChange, rightChange, start, end, options) {
+    const originalBaseLines = [...baseLines.slice(start, end)];
+    const leftResolvedLines = sideLinesForRange(leftChange, baseLines, start, end);
+    const rightResolvedLines = sideLinesForRange(rightChange, baseLines, start, end);
+    const leftChanged = Boolean(leftChange) &&
+        !linesEqual(leftResolvedLines, originalBaseLines, options);
+    const rightChanged = Boolean(rightChange) &&
+        !linesEqual(rightResolvedLines, originalBaseLines, options);
+    let centerLines = originalBaseLines;
+    let kind = "modified";
+    let resolved = true;
+    if (leftChanged && !rightChanged) {
+        if (options.workingCopyCenter) {
+            kind = workingCopyHunkKind(originalBaseLines, leftResolvedLines);
+        }
+        else {
+            centerLines = leftResolvedLines;
+        }
+    }
+    else if (rightChanged && !leftChanged) {
+        if (options.workingCopyCenter) {
+            kind = workingCopyHunkKind(originalBaseLines, rightResolvedLines);
+        }
+        else {
+            centerLines = rightResolvedLines;
+        }
+    }
+    else if (leftChanged &&
+        rightChanged &&
+        linesEqual(leftResolvedLines, rightResolvedLines, options)) {
+        if (options.workingCopyCenter &&
+            !linesEqual(originalBaseLines, leftResolvedLines, options)) {
+            kind = workingCopyHunkKind(originalBaseLines, leftResolvedLines);
+        }
+        else {
+            centerLines = leftResolvedLines;
+        }
+    }
+    else if (leftChanged || rightChanged) {
+        kind = "conflict";
+        resolved = false;
+    }
+    else {
+        kind = "unchanged";
+    }
+    blocks.push(createBlock(blocks.length, kind, resolved, { left: leftResolvedLines, base: centerLines, right: rightResolvedLines }, { left: null, base: start, right: null }, options));
+}
+export function assembleThreeWayMerge(left, base, right, options) {
+    const normalizedOptions = normalizeOptions(options);
+    const leftLines = splitLines(left);
+    const baseLines = splitLines(base);
+    const rightLines = splitLines(right);
+    const leftChanges = diffBaseToSide(baseLines, leftLines, normalizedOptions);
+    const rightChanges = diffBaseToSide(baseLines, rightLines, normalizedOptions);
+    const blocks = [];
+    let baseIndex = 0;
+    while (baseIndex <= baseLines.length) {
+        const leftInsertion = findInsertion(leftChanges, baseIndex);
+        const rightInsertion = findInsertion(rightChanges, baseIndex);
+        if (leftInsertion || rightInsertion) {
+            createThreeWayChangeBlock(blocks, baseLines, leftInsertion, rightInsertion, baseIndex, baseIndex, normalizedOptions);
+        }
+        if (baseIndex === baseLines.length) {
+            break;
+        }
+        const leftChange = findCoveringChange(leftChanges, baseIndex);
+        const rightChange = findCoveringChange(rightChanges, baseIndex);
+        if (!leftChange && !rightChange) {
+            const start = baseIndex;
+            baseIndex += 1;
+            while (baseIndex < baseLines.length &&
+                !findCoveringChange(leftChanges, baseIndex) &&
+                !findCoveringChange(rightChanges, baseIndex) &&
+                !findInsertion(leftChanges, baseIndex) &&
+                !findInsertion(rightChanges, baseIndex)) {
+                baseIndex += 1;
+            }
+            const lines = [...baseLines.slice(start, baseIndex)];
+            blocks.push(createBlock(blocks.length, "unchanged", true, { left: lines, base: lines, right: lines }, { left: start, base: start, right: start }, normalizedOptions));
+            continue;
+        }
+        const end = Math.max(leftChange?.baseEnd ?? baseIndex + 1, rightChange?.baseEnd ?? baseIndex + 1);
+        createThreeWayChangeBlock(blocks, baseLines, leftChange, rightChange, baseIndex, end, normalizedOptions);
+        baseIndex = end;
+    }
+    return recomputeModel({
+        mode: "three-way",
+        left,
+        base,
+        right,
+        sourceBase: base,
+        blocks,
+        options: normalizedOptions,
+        conflictCount: 0,
+        unresolvedConflictCount: 0,
+    }, blocks);
+}