@theia/scm 1.64.0-next.28 → 1.64.0

package/src/browser/merge-editor/model/range-mapping.ts

@@ -0,0 +1,396 @@
+// *****************************************************************************
+// Copyright (C) 2025 1C-Soft LLC and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+// copied and modified from https://github.com/microsoft/vscode/blob/1.96.3/src/vs/workbench/contrib/mergeEditor/browser/model/mapping.ts
+
+import { ArrayUtils } from '@theia/core';
+import { Position, Range, TextEditorDocument } from '@theia/editor/lib/browser/editor';
+import { LineRange } from './line-range';
+import { LineRangeEdit } from './range-editing';
+import { PositionUtils, RangeUtils } from './range-utils';
+
+/**
+ * Maps a line range in the original text document to a line range in the modified text document.
+ */
+export class LineRangeMapping {
+
+    static join(mappings: readonly LineRangeMapping[]): LineRangeMapping | undefined {
+        return mappings.reduce<undefined | LineRangeMapping>((acc, cur) => acc ? acc.join(cur) : cur, undefined);
+    }
+
+    constructor(
+        readonly originalRange: LineRange,
+        readonly modifiedRange: LineRange
+    ) { }
+
+    toString(): string {
+        return `${this.originalRange.toString()} -> ${this.modifiedRange.toString()}`;
+    }
+
+    join(other: LineRangeMapping): LineRangeMapping {
+        return new LineRangeMapping(
+            this.originalRange.join(other.originalRange),
+            this.modifiedRange.join(other.modifiedRange)
+        );
+    }
+
+    addModifiedLineDelta(delta: number): LineRangeMapping {
+        return new LineRangeMapping(
+            this.originalRange,
+            this.modifiedRange.delta(delta)
+        );
+    }
+
+    addOriginalLineDelta(delta: number): LineRangeMapping {
+        return new LineRangeMapping(
+            this.originalRange.delta(delta),
+            this.modifiedRange
+        );
+    }
+
+    reverse(): LineRangeMapping {
+        return new LineRangeMapping(this.modifiedRange, this.originalRange);
+    }
+}
+
+/**
+ * Represents a total monotonous mapping of line ranges in one document to another document.
+ */
+export class DocumentLineRangeMap {
+
+    static betweenModifiedSides(
+        side1Diff: readonly LineRangeMapping[],
+        side2Diff: readonly LineRangeMapping[]
+    ): DocumentLineRangeMap {
+        const alignments = MappingAlignment.computeAlignments(side1Diff, side2Diff);
+        const mappings = alignments.map(alignment => new LineRangeMapping(alignment.side1Range, alignment.side2Range));
+        return new DocumentLineRangeMap(mappings);
+    }
+
+    constructor(
+        /**
+         * The line range mappings that define this document mapping.
+         * The number of lines between two adjacent original ranges must equal the number of lines between their corresponding modified ranges.
+         */
+        readonly lineRangeMappings: readonly LineRangeMapping[]
+    ) {
+        if (!ArrayUtils.checkAdjacentItems(lineRangeMappings,
+            (m1, m2) => m1.originalRange.isBefore(m2.originalRange) && m1.modifiedRange.isBefore(m2.modifiedRange) &&
+                m2.originalRange.startLineNumber - m1.originalRange.endLineNumberExclusive === m2.modifiedRange.startLineNumber - m1.modifiedRange.endLineNumberExclusive
+        )) {
+            throw new Error('Illegal line range mappings');
+        }
+    }
+
+    /**
+     * @param lineNumber 0-based line number in the original text document
+     */
+    projectLine(lineNumber: number): LineRangeMapping {
+        const lastBefore = ArrayUtils.findLast(this.lineRangeMappings, m => m.originalRange.startLineNumber <= lineNumber);
+        if (!lastBefore) {
+            return new LineRangeMapping(
+                new LineRange(lineNumber, 1),
+                new LineRange(lineNumber, 1)
+            );
+        }
+
+        if (lastBefore.originalRange.containsLine(lineNumber)) {
+            return lastBefore;
+        }
+
+        return new LineRangeMapping(
+            new LineRange(lineNumber, 1),
+            new LineRange(lineNumber + lastBefore.modifiedRange.endLineNumberExclusive - lastBefore.originalRange.endLineNumberExclusive, 1)
+        );
+    }
+
+    reverse(): DocumentLineRangeMap {
+        return new DocumentLineRangeMap(
+            this.lineRangeMappings.map(m => m.reverse())
+        );
+    }
+}
+
+/**
+ * Aligns mappings for two modified sides with a common base range.
+ */
+export class MappingAlignment<T extends LineRangeMapping> {
+
+    static computeAlignments<T extends LineRangeMapping>(
+        side1Mappings: readonly T[],
+        side2Mappings: readonly T[]
+    ): MappingAlignment<T>[] {
+        const combinedMappings =
+            side1Mappings.map(mapping => ({ source: 0, mapping })).concat(
+                side2Mappings.map(mapping => ({ source: 1, mapping }))).sort(
+                    (a, b) => LineRange.compareByStart(a.mapping.originalRange, b.mapping.originalRange));
+
+        const currentMappings = [new Array<T>(), new Array<T>()];
+        const currentDelta = [0, 0];
+
+        const alignments = new Array<MappingAlignment<T>>();
+
+        function pushAlignment(baseRange: LineRange): void {
+            const mapping1 = LineRangeMapping.join(currentMappings[0]) || new LineRangeMapping(baseRange, baseRange.delta(currentDelta[0]));
+            const mapping2 = LineRangeMapping.join(currentMappings[1]) || new LineRangeMapping(baseRange, baseRange.delta(currentDelta[1]));
+
+            function getAlignedModifiedRange(m: LineRangeMapping): LineRange {
+                const startDelta = baseRange.startLineNumber - m.originalRange.startLineNumber;
+                const endDelta = baseRange.endLineNumberExclusive - m.originalRange.endLineNumberExclusive;
+                return new LineRange(
+                    m.modifiedRange.startLineNumber + startDelta,
+                    m.modifiedRange.lineCount - startDelta + endDelta
+                );
+            }
+
+            alignments.push(
+                new MappingAlignment(
+                    baseRange,
+                    getAlignedModifiedRange(mapping1),
+                    currentMappings[0],
+                    getAlignedModifiedRange(mapping2),
+                    currentMappings[1]
+                )
+            );
+            currentMappings[0] = [];
+            currentMappings[1] = [];
+        }
+
+        let currentBaseRange: LineRange | undefined;
+
+        for (const current of combinedMappings) {
+            const { originalRange, modifiedRange } = current.mapping;
+            if (currentBaseRange && !currentBaseRange.touches(originalRange)) {
+                pushAlignment(currentBaseRange);
+                currentBaseRange = undefined;
+            }
+            currentBaseRange = currentBaseRange ? currentBaseRange.join(originalRange) : originalRange;
+            currentMappings[current.source].push(current.mapping);
+            currentDelta[current.source] = modifiedRange.endLineNumberExclusive - originalRange.endLineNumberExclusive;
+        }
+        if (currentBaseRange) {
+            pushAlignment(currentBaseRange);
+        }
+
+        return alignments;
+    }
+
+    constructor(
+        readonly baseRange: LineRange,
+        readonly side1Range: LineRange,
+        readonly side1Mappings: readonly T[],
+        readonly side2Range: LineRange,
+        readonly side2Mappings: readonly T[]
+    ) { }
+
+    toString(): string {
+        return `${this.side1Range} <- ${this.baseRange} -> ${this.side2Range}`;
+    }
+}
+
+/**
+ * A line range mapping with inner range mappings.
+ */
+export class DetailedLineRangeMapping extends LineRangeMapping {
+
+    static override join(mappings: readonly DetailedLineRangeMapping[]): DetailedLineRangeMapping | undefined {
+        return mappings.reduce<undefined | DetailedLineRangeMapping>((acc, cur) => acc ? acc.join(cur) : cur, undefined);
+    }
+
+    readonly rangeMappings: readonly RangeMapping[];
+
+    constructor(
+        originalRange: LineRange,
+        readonly originalDocument: TextEditorDocument,
+        modifiedRange: LineRange,
+        readonly modifiedDocument: TextEditorDocument,
+        rangeMappings?: readonly RangeMapping[]
+    ) {
+        super(originalRange, modifiedRange);
+
+        this.rangeMappings = rangeMappings || [new RangeMapping(originalRange.toRange(), modifiedRange.toRange())];
+    }
+
+    override join(other: DetailedLineRangeMapping): DetailedLineRangeMapping {
+        return new DetailedLineRangeMapping(
+            this.originalRange.join(other.originalRange),
+            this.originalDocument,
+            this.modifiedRange.join(other.modifiedRange),
+            this.modifiedDocument
+        );
+    }
+
+    override addModifiedLineDelta(delta: number): DetailedLineRangeMapping {
+        return new DetailedLineRangeMapping(
+            this.originalRange,
+            this.originalDocument,
+            this.modifiedRange.delta(delta),
+            this.modifiedDocument,
+            this.rangeMappings.map(m => m.addModifiedLineDelta(delta))
+        );
+    }
+
+    override addOriginalLineDelta(delta: number): DetailedLineRangeMapping {
+        return new DetailedLineRangeMapping(
+            this.originalRange.delta(delta),
+            this.originalDocument,
+            this.modifiedRange,
+            this.modifiedDocument,
+            this.rangeMappings.map(m => m.addOriginalLineDelta(delta))
+        );
+    }
+
+    override reverse(): DetailedLineRangeMapping {
+        return new DetailedLineRangeMapping(
+            this.modifiedRange,
+            this.modifiedDocument,
+            this.originalRange,
+            this.originalDocument,
+            this.rangeMappings.map(m => m.reverse())
+        );
+    }
+
+    getLineEdit(): LineRangeEdit {
+        return new LineRangeEdit(this.originalRange, this.getModifiedLines());
+    }
+
+    getReverseLineEdit(): LineRangeEdit {
+        return new LineRangeEdit(this.modifiedRange, this.getOriginalLines());
+    }
+
+    getModifiedLines(): string[] {
+        return this.modifiedRange.getLines(this.modifiedDocument);
+    }
+
+    getOriginalLines(): string[] {
+        return this.originalRange.getLines(this.originalDocument);
+    }
+}
+
+/**
+ * Maps a range in the original text document to a range in the modified text document.
+ */
+export class RangeMapping {
+
+    constructor(
+        readonly originalRange: Readonly<Range>,
+        readonly modifiedRange: Readonly<Range>
+    ) { }
+
+    toString(): string {
+        function rangeToString(range: Range): string {
+            return `[${range.start.line}:${range.start.character}, ${range.end.line}:${range.end.character})`;
+        }
+
+        return `${rangeToString(this.originalRange)} -> ${rangeToString(this.modifiedRange)}`;
+    }
+
+    addModifiedLineDelta(deltaLines: number): RangeMapping {
+        return new RangeMapping(
+            this.originalRange,
+            Range.create(
+                this.modifiedRange.start.line + deltaLines,
+                this.modifiedRange.start.character,
+                this.modifiedRange.end.line + deltaLines,
+                this.modifiedRange.end.character
+            )
+        );
+    }
+
+    addOriginalLineDelta(deltaLines: number): RangeMapping {
+        return new RangeMapping(
+            Range.create(
+                this.originalRange.start.line + deltaLines,
+                this.originalRange.start.character,
+                this.originalRange.end.line + deltaLines,
+                this.originalRange.end.character
+            ),
+            this.modifiedRange
+        );
+    }
+
+    reverse(): RangeMapping {
+        return new RangeMapping(this.modifiedRange, this.originalRange);
+    }
+}
+
+/**
+ * Represents a total monotonous mapping of ranges in one document to another document.
+ */
+export class DocumentRangeMap {
+
+    constructor(
+        /**
+         * The range mappings that define this document mapping.
+         */
+        readonly rangeMappings: readonly RangeMapping[]
+    ) {
+        if (!ArrayUtils.checkAdjacentItems(
+            rangeMappings,
+            (m1, m2) =>
+                RangeUtils.isBeforeOrTouching(m1.originalRange, m2.originalRange) &&
+                RangeUtils.isBeforeOrTouching(m1.modifiedRange, m2.modifiedRange)
+        )) {
+            throw new Error('Illegal range mappings');
+        }
+    }
+
+    /**
+     * @param position position in the original text document
+     */
+    projectPosition(position: Position): RangeMapping {
+        const lastBefore = ArrayUtils.findLast(this.rangeMappings, m => PositionUtils.isBeforeOrEqual(m.originalRange.start, position));
+        if (!lastBefore) {
+            return new RangeMapping(
+                Range.create(position, position),
+                Range.create(position, position)
+            );
+        }
+
+        if (RangeUtils.containsPosition(lastBefore.originalRange, position)) {
+            return lastBefore;
+        }
+
+        const relativePosition = PositionUtils.relativize(lastBefore.originalRange.end, position);
+        const modifiedRangePosition = PositionUtils.resolve(lastBefore.modifiedRange.end, relativePosition);
+
+        return new RangeMapping(
+            Range.create(position, position),
+            Range.create(modifiedRangePosition, modifiedRangePosition)
+        );
+    }
+
+    /**
+     * @param range range in the original text document
+     */
+    projectRange(range: Range): RangeMapping {
+        const start = this.projectPosition(range.start);
+        const end = this.projectPosition(range.end);
+        return new RangeMapping(
+            RangeUtils.union(start.originalRange, end.originalRange),
+            RangeUtils.union(start.modifiedRange, end.modifiedRange)
+        );
+    }
+
+    reverse(): DocumentRangeMap {
+        return new DocumentRangeMap(
+            this.rangeMappings.map(m => m.reverse())
+        );
+    }
+}

package/src/browser/merge-editor/model/range-utils.ts

@@ -0,0 +1,115 @@
+// *****************************************************************************
+// Copyright (C) 2025 1C-Soft LLC and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+// copied and modified from https://github.com/microsoft/vscode/blob/1.96.3/src/vs/workbench/contrib/mergeEditor/browser/model/rangeUtils.ts,
+// https://github.com/microsoft/vscode/blob/1.96.3/src/vs/editor/common/core/range.ts,
+// https://github.com/microsoft/vscode/blob/1.96.3/src/vs/editor/common/core/position.ts,
+// https://github.com/microsoft/vscode/blob/1.96.3/src/vs/editor/common/core/textLength.ts
+
+import { Position, Range } from '@theia/core/shared/vscode-languageserver-protocol';
+
+export namespace RangeUtils {
+
+    export function isEmpty(range: Range): boolean {
+        return range.start.line === range.end.line && range.start.character === range.end.character;
+    }
+
+    export function containsPosition(range: Range, position: Position): boolean {
+        if (position.line < range.start.line || position.line > range.end.line) {
+            return false;
+        }
+        if (position.line === range.start.line && position.character < range.start.character) {
+            return false;
+        }
+        if (position.line === range.end.line && position.character >= range.end.character) {
+            return false;
+        }
+        return true;
+    }
+
+    export function isBeforeOrTouching(range: Range, other: Range): boolean {
+        return (
+            range.end.line < other.start.line ||
+            (range.end.line === other.start.line &&
+                range.end.character <= other.start.character)
+        );
+    }
+
+    export function union(range: Range, other: Range): Range {
+        const start = PositionUtils.isBeforeOrEqual(range.start, other.start) ? range.start : other.start;
+        const end = PositionUtils.isBeforeOrEqual(range.end, other.end) ? other.end : range.end;
+        return { start, end };
+    }
+
+    /**
+     * A function that compares ranges, useful for sorting ranges.
+     * It will first compare ranges on the start position and then on the end position.
+     */
+    export function compareUsingStarts(range: Range, other: Range): number {
+        if (range.start.line === other.start.line) {
+            if (range.start.character === other.start.character) {
+                if (range.end.line === other.end.line) {
+                    return range.end.character - other.end.character;
+                }
+                return range.end.line - other.end.line;
+            }
+            return range.start.character - other.start.character;
+        }
+        return range.start.line - other.start.line;
+    }
+}
+
+export namespace PositionUtils {
+
+    export function isBeforeOrEqual(position: Position, other: Position): boolean {
+        return compare(position, other) <= 0;
+    }
+
+    export function compare(position: Position, other: Position): number {
+        if (position.line === other.line) {
+            return position.character - other.character;
+        }
+        return position.line - other.line;
+    }
+
+    /**
+     * Given two positions, computes the relative position of the greater position against the lesser position.
+     */
+    export function relativize(position: Position, other: Position): Position {
+        if (compare(position, other) > 0) {
+            [position, other] = [other, position];
+        }
+        if (position.line === other.line) {
+            return Position.create(0, other.character - position.character);
+        } else {
+            return Position.create(other.line - position.line, other.character);
+        }
+    }
+
+    /**
+     * Resolves the given relative position against the given position and returns the resulting position.
+     */
+    export function resolve(position: Position, relativePosition: Position): Position {
+        if (relativePosition.line === 0) {
+            return Position.create(position.line, position.character + relativePosition.character);
+        } else {
+            return Position.create(position.line + relativePosition.line, relativePosition.character);
+        }
+    }
+}

package/src/browser/merge-editor/view/diff-spacers.ts

@@ -0,0 +1,160 @@
+// *****************************************************************************
+// Copyright (C) 2025 1C-Soft LLC and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { injectable } from '@theia/core/shared/inversify';
+import { ArrayUtils } from '@theia/core';
+import { LineRangeMapping } from '../model/range-mapping';
+
+export interface DiffSpacers {
+    /**
+     * An array representing spacers in the original side of the diff.
+     * Indices are line numbers in the original document, and values are the height in lines of the spacer directly above the given line.
+     * If a value is missing for a line number, the corresponding spacer is assumed to have zero height.
+     */
+    originalSpacers: number[];
+    /**
+     * An array representing spacers in the modified side of the diff.
+     * Indices are line numbers in the modified document, and values are the height in lines of the spacer directly above the given line.
+     * If a value is missing for a line number, the corresponding spacer is assumed to have zero height.
+     */
+    modifiedSpacers: number[];
+    /**
+     * An array respresenting a mapping of line numbers for the diff.
+     * Indices are line numbers in the original document, and values are the corresponding line numbers in the modified document.
+     * If a value is missing for a line number, it is assumed that the line was deleted.
+     */
+    lineMapping: number[];
+}
+
+export type ModifiedSideSpacers = Omit<DiffSpacers, 'originalSpacers'>;
+
+export interface CombinedMultiDiffSpacers {
+    originalSpacers: number[];
+    modifiedSides: ModifiedSideSpacers[];
+}
+
+@injectable()
+export class DiffSpacerService {
+
+    computeDiffSpacers(changes: readonly LineRangeMapping[], originalLineCount: number): DiffSpacers {
+        const lineMapping: number[] = [];
+        const originalSpacers: number[] = [];
+        const modifiedSpacers: number[] = [];
+        let originalLine = 0;
+        let deltaSum = 0;
+        for (const { originalRange, modifiedRange } of changes) {
+            while (originalLine < originalRange.startLineNumber + Math.min(originalRange.lineCount, modifiedRange.lineCount)) {
+                lineMapping[originalLine] = originalLine + deltaSum;
+                originalLine++;
+            }
+            const delta = modifiedRange.lineCount - originalRange.lineCount;
+            deltaSum += delta;
+            if (delta > 0) {
+                originalSpacers[originalLine] = delta;
+            }
+            if (delta < 0) {
+                modifiedSpacers[modifiedRange.endLineNumberExclusive] = -delta;
+                originalLine += -delta;
+            }
+        }
+        while (originalLine <= originalLineCount) {
+            lineMapping[originalLine] = originalLine + deltaSum;
+            originalLine++;
+        }
+        return { originalSpacers, modifiedSpacers, lineMapping };
+    }
+
+    /**
+     * Combines multiple {@link DiffSpacers} objects into a {@link CombinedMultiDiffSpacers} object with the appropriately adjusted spacers.
+     * The given {@link DiffSpacers} objects are not modified.
+     *
+     * It is assumed that all of the given {@link DiffSpacers} objects have been computed from diffs against the same original side.
+     */
+    combineMultiDiffSpacers(multiDiffSpacers: DiffSpacers[]): CombinedMultiDiffSpacers {
+        if (multiDiffSpacers.length < 2) {
+            throw new Error('At least two items are required');
+        }
+        this.checkLineMappingsHaveEqualLength(multiDiffSpacers);
+        const originalSpacers: number[] = [];
+        const modifiedSides: ModifiedSideSpacers[] = [];
+        for (const { modifiedSpacers, lineMapping } of multiDiffSpacers) {
+            const modifiedSpacersCopy = modifiedSpacers.concat(); // note: copying by concat() preserves empty slots of the sparse array
+            modifiedSides.push({ modifiedSpacers: modifiedSpacersCopy, lineMapping });
+        }
+        const originalLineCount = modifiedSides[0].lineMapping.length;
+        for (let originalLine = 0; originalLine < originalLineCount; originalLine++) {
+            const max = Math.max(...multiDiffSpacers.map(diffSpacers => diffSpacers.originalSpacers[originalLine] ?? 0));
+            if (max > 0) {
+                originalSpacers[originalLine] = max;
+                for (let i = 0; i < multiDiffSpacers.length; i++) {
+                    const delta = max - (multiDiffSpacers[i].originalSpacers[originalLine] ?? 0);
+                    if (delta > 0) {
+                        const { modifiedSpacers, lineMapping } = modifiedSides[i];
+                        const modifiedLine = this.projectLine(originalLine, lineMapping);
+                        modifiedSpacers[modifiedLine] = (modifiedSpacers[modifiedLine] ?? 0) + delta;
+                    }
+                }
+            }
+        }
+        return { originalSpacers, modifiedSides };
+    }
+
+    /**
+     * Given a {@link CombinedMultiDiffSpacers} object, excludes the original side, returning the modified sides with the appropriately adjusted spacers.
+     * The given {@link CombinedMultiDiffSpacers} object is not modified.
+     */
+    excludeOriginalSide({ modifiedSides }: CombinedMultiDiffSpacers): { modifiedSides: { modifiedSpacers: number[] }[] } {
+        if (modifiedSides.length < 2) {
+            throw new Error('At least two modified sides are required');
+        }
+        this.checkLineMappingsHaveEqualLength(modifiedSides);
+        const modifiedSidesCopy: { modifiedSpacers: number[] }[] = [];
+        for (const { modifiedSpacers } of modifiedSides) {
+            const modifiedSpacersCopy = modifiedSpacers.concat(); // note: copying by concat() preserves empty slots of the sparse array
+            modifiedSidesCopy.push({ modifiedSpacers: modifiedSpacersCopy });
+        }
+        // When the original side is excluded, the adjoining spacers in the modified sides can be deflated by removing their intersecting parts.
+        const originalLineCount = modifiedSides[0].lineMapping.length;
+        for (let originalLine = 0; originalLine < originalLineCount; originalLine++) {
+            if (modifiedSides.every(({ lineMapping }) => lineMapping[originalLine] === undefined)) {
+                modifiedSides.forEach(({ lineMapping }, index) => {
+                    const modifiedLine = this.projectLine(originalLine, lineMapping);
+                    const { modifiedSpacers } = modifiedSidesCopy[index];
+                    modifiedSpacers[modifiedLine]--;
+                });
+            }
+        }
+        return { modifiedSides: modifiedSidesCopy };
+    }
+
+    protected checkLineMappingsHaveEqualLength(items: { lineMapping: number[] }[]): void {
+        if (!ArrayUtils.checkAdjacentItems(items, (item1, item2) => item1.lineMapping.length === item2.lineMapping.length)) {
+            throw new Error('Line mappings must have equal length');
+        }
+    }
+
+    protected projectLine(originalLine: number, lineMapping: number[]): number {
+        let modifiedLine: number | undefined;
+        const originalLineCount = lineMapping.length;
+        while (originalLine < originalLineCount) {
+            modifiedLine = lineMapping[originalLine++];
+            if (modifiedLine !== undefined) {
+                return modifiedLine;
+            }
+        }
+        throw new Error('Assertion failed');
+    }
+}

package/src/browser/merge-editor/view/merge-editor-panes/index.ts

@@ -0,0 +1,21 @@
+// *****************************************************************************
+// Copyright (C) 2025 1C-Soft LLC and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+export * from './merge-editor-pane';
+export * from './merge-editor-pane-header';
+export * from './merge-editor-base-pane';
+export * from './merge-editor-side-pane';
+export * from './merge-editor-result-pane';