@codingame/monaco-vscode-210e86a9-a91b-5273-b05d-390c776dde1f-common 15.0.0

package/empty.js

@@ -0,0 +1 @@
+export {}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@codingame/monaco-vscode-210e86a9-a91b-5273-b05d-390c776dde1f-common",
+  "version": "15.0.0",
+  "private": false,
+  "description": "VSCode public API plugged on the monaco editor - common package (chat, extensions, interactive, notebook, terminal, view-common)",
+  "keywords": [],
+  "author": {
+    "name": "CodinGame",
+    "url": "http://www.codingame.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/CodinGame/monaco-vscode-api.git"
+  },
+  "type": "module",
+  "dependencies": {
+    "@codingame/monaco-vscode-api": "15.0.0"
+  },
+  "exports": {
+    ".": {
+      "default": "./empty.js"
+    },
+    "./vscode/*": {
+      "types": "./vscode/src/*.d.ts",
+      "default": "./vscode/src/*.js"
+    },
+    "./*": {
+      "types": "./*.d.ts",
+      "default": "./*.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "vscode/*": [
+        "./vscode/src/*.d.ts"
+      ]
+    }
+  }
+}

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/model/editing.d.ts

@@ -0,0 +1,21 @@
+import { Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+import { IIdentifiedSingleEditOperation } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+import { LineRange } from "./lineRange.js";
+export declare class LineRangeEdit {
+    readonly range: LineRange;
+    readonly newLines: string[];
+    constructor(range: LineRange, newLines: string[]);
+    equals(other: LineRangeEdit): boolean;
+    toEdits(modelLineCount: number): IIdentifiedSingleEditOperation[];
+}
+export declare class RangeEdit {
+    readonly range: Range;
+    readonly newText: string;
+    constructor(range: Range, newText: string);
+    equals(other: RangeEdit): boolean;
+}
+export declare class LineEdits {
+    readonly edits: readonly LineRangeEdit[];
+    constructor(edits: readonly LineRangeEdit[]);
+    toEdits(modelLineCount: number): IIdentifiedSingleEditOperation[];
+}

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/model/editing.js

@@ -0,0 +1,57 @@
+
+import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+
+class LineRangeEdit {
+    constructor(range, newLines) {
+        this.range = range;
+        this.newLines = newLines;
+    }
+    equals(other) {
+        return this.range.equals(other.range) && equals(this.newLines, other.newLines);
+    }
+    toEdits(modelLineCount) {
+        return ( new LineEdits([this])).toEdits(modelLineCount);
+    }
+}
+class RangeEdit {
+    constructor(range, newText) {
+        this.range = range;
+        this.newText = newText;
+    }
+    equals(other) {
+        return Range.equalsRange(this.range, other.range) && this.newText === other.newText;
+    }
+}
+class LineEdits {
+    constructor(edits) {
+        this.edits = edits;
+    }
+    toEdits(modelLineCount) {
+        return ( this.edits.map((e) => {
+            if (e.range.endLineNumberExclusive <= modelLineCount) {
+                return {
+                    range: ( new Range(e.range.startLineNumber, 1, e.range.endLineNumberExclusive, 1)),
+                    text: ( e.newLines.map(s => s + '\n')).join(''),
+                };
+            }
+            if (e.range.startLineNumber === 1) {
+                return {
+                    range: ( new Range(1, 1, modelLineCount, Number.MAX_SAFE_INTEGER)),
+                    text: e.newLines.join('\n'),
+                };
+            }
+            return {
+                range: ( new Range(
+                    e.range.startLineNumber - 1,
+                    Number.MAX_SAFE_INTEGER,
+                    modelLineCount,
+                    Number.MAX_SAFE_INTEGER
+                )),
+                text: ( e.newLines.map(s => '\n' + s)).join(''),
+            };
+        }));
+    }
+}
+
+export { LineEdits, LineRangeEdit, RangeEdit };

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/model/lineRange.d.ts

@@ -0,0 +1,29 @@
+import { Comparator } from "@codingame/monaco-vscode-api/vscode/vs/base/common/arrays";
+import { Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+export declare class LineRange {
+    readonly startLineNumber: number;
+    readonly lineCount: number;
+    static readonly compareByStart: Comparator<LineRange>;
+    static join(ranges: LineRange[]): LineRange | undefined;
+    static fromLineNumbers(startLineNumber: number, endExclusiveLineNumber: number): LineRange;
+    constructor(startLineNumber: number, lineCount: number);
+    join(other: LineRange): LineRange;
+    get endLineNumberExclusive(): number;
+    get isEmpty(): boolean;
+    touches(other: LineRange): boolean;
+    isAfter(range: LineRange): boolean;
+    isBefore(range: LineRange): boolean;
+    delta(lineDelta: number): LineRange;
+    toString(): string;
+    equals(originalRange: LineRange): boolean;
+    contains(lineNumber: number): boolean;
+    deltaEnd(delta: number): LineRange;
+    deltaStart(lineDelta: number): LineRange;
+    getLines(model: ITextModel): string[];
+    containsRange(range: LineRange): boolean;
+    toRange(): Range;
+    toInclusiveRange(): Range | undefined;
+    toInclusiveRangeOrEmpty(): Range;
+    intersects(lineRange: LineRange): boolean;
+}

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/model/lineRange.js

@@ -0,0 +1,112 @@
+
+import { compareBy, numberComparator } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { BugIndicatingError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Constants } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uint';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+
+class LineRange {
+    static { this.compareByStart = compareBy(l => l.startLineNumber, numberComparator); }
+    static join(ranges) {
+        if (ranges.length === 0) {
+            return undefined;
+        }
+        let startLineNumber = Number.MAX_SAFE_INTEGER;
+        let endLineNumber = 0;
+        for (const range of ranges) {
+            startLineNumber = Math.min(startLineNumber, range.startLineNumber);
+            endLineNumber = Math.max(endLineNumber, range.startLineNumber + range.lineCount);
+        }
+        return ( new LineRange(startLineNumber, endLineNumber - startLineNumber));
+    }
+    static fromLineNumbers(startLineNumber, endExclusiveLineNumber) {
+        return ( new LineRange(startLineNumber, endExclusiveLineNumber - startLineNumber));
+    }
+    constructor(startLineNumber, lineCount) {
+        this.startLineNumber = startLineNumber;
+        this.lineCount = lineCount;
+        if (lineCount < 0) {
+            throw ( new BugIndicatingError());
+        }
+    }
+    join(other) {
+        return ( new LineRange(
+            Math.min(this.startLineNumber, other.startLineNumber),
+            Math.max(this.endLineNumberExclusive, other.endLineNumberExclusive) - this.startLineNumber
+        ));
+    }
+    get endLineNumberExclusive() {
+        return this.startLineNumber + this.lineCount;
+    }
+    get isEmpty() {
+        return this.lineCount === 0;
+    }
+    touches(other) {
+        return (this.endLineNumberExclusive >= other.startLineNumber &&
+            other.endLineNumberExclusive >= this.startLineNumber);
+    }
+    isAfter(range) {
+        return this.startLineNumber >= range.endLineNumberExclusive;
+    }
+    isBefore(range) {
+        return range.startLineNumber >= this.endLineNumberExclusive;
+    }
+    delta(lineDelta) {
+        return ( new LineRange(this.startLineNumber + lineDelta, this.lineCount));
+    }
+    toString() {
+        return `[${this.startLineNumber},${this.endLineNumberExclusive})`;
+    }
+    equals(originalRange) {
+        return this.startLineNumber === originalRange.startLineNumber && this.lineCount === originalRange.lineCount;
+    }
+    contains(lineNumber) {
+        return this.startLineNumber <= lineNumber && lineNumber < this.endLineNumberExclusive;
+    }
+    deltaEnd(delta) {
+        return ( new LineRange(this.startLineNumber, this.lineCount + delta));
+    }
+    deltaStart(lineDelta) {
+        return ( new LineRange(this.startLineNumber + lineDelta, this.lineCount - lineDelta));
+    }
+    getLines(model) {
+        const result = ( new Array(this.lineCount));
+        for (let i = 0; i < this.lineCount; i++) {
+            result[i] = model.getLineContent(this.startLineNumber + i);
+        }
+        return result;
+    }
+    containsRange(range) {
+        return this.startLineNumber <= range.startLineNumber && range.endLineNumberExclusive <= this.endLineNumberExclusive;
+    }
+    toRange() {
+        return ( new Range(this.startLineNumber, 1, this.endLineNumberExclusive, 1));
+    }
+    toInclusiveRange() {
+        if (this.isEmpty) {
+            return undefined;
+        }
+        return ( new Range(
+            this.startLineNumber,
+            1,
+            this.endLineNumberExclusive - 1,
+            Constants.MAX_SAFE_SMALL_INTEGER
+        ));
+    }
+    toInclusiveRangeOrEmpty() {
+        if (this.isEmpty) {
+            return ( new Range(this.startLineNumber, 1, this.startLineNumber, 1));
+        }
+        return ( new Range(
+            this.startLineNumber,
+            1,
+            this.endLineNumberExclusive - 1,
+            Constants.MAX_SAFE_SMALL_INTEGER
+        ));
+    }
+    intersects(lineRange) {
+        return this.startLineNumber <= lineRange.endLineNumberExclusive
+            && lineRange.startLineNumber <= this.endLineNumberExclusive;
+    }
+}
+
+export { LineRange };

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/model/mapping.d.ts

@@ -0,0 +1,69 @@
+import { Position } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position";
+import { Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+import { LineRangeEdit } from "./editing.js";
+import { LineRange } from "./lineRange.js";
+export declare class LineRangeMapping {
+    readonly inputRange: LineRange;
+    readonly outputRange: LineRange;
+    static join(mappings: readonly LineRangeMapping[]): LineRangeMapping | undefined;
+    constructor(inputRange: LineRange, outputRange: LineRange);
+    extendInputRange(extendedInputRange: LineRange): LineRangeMapping;
+    join(other: LineRangeMapping): LineRangeMapping;
+    get resultingDeltaFromOriginalToModified(): number;
+    toString(): string;
+    addOutputLineDelta(delta: number): LineRangeMapping;
+    addInputLineDelta(delta: number): LineRangeMapping;
+    reverse(): LineRangeMapping;
+}
+export declare class DocumentLineRangeMap {
+    readonly lineRangeMappings: LineRangeMapping[];
+    readonly inputLineCount: number;
+    static betweenOutputs(inputToOutput1: readonly LineRangeMapping[], inputToOutput2: readonly LineRangeMapping[], inputLineCount: number): DocumentLineRangeMap;
+    constructor(lineRangeMappings: LineRangeMapping[], inputLineCount: number);
+    project(lineNumber: number): LineRangeMapping;
+    get outputLineCount(): number;
+    reverse(): DocumentLineRangeMap;
+}
+export declare class MappingAlignment<T extends LineRangeMapping> {
+    readonly inputRange: LineRange;
+    readonly output1Range: LineRange;
+    readonly output1LineMappings: T[];
+    readonly output2Range: LineRange;
+    readonly output2LineMappings: T[];
+    static compute<T extends LineRangeMapping>(fromInputToOutput1: readonly T[], fromInputToOutput2: readonly T[]): MappingAlignment<T>[];
+    constructor(inputRange: LineRange, output1Range: LineRange, output1LineMappings: T[], output2Range: LineRange, output2LineMappings: T[]);
+    toString(): string;
+}
+export declare class DetailedLineRangeMapping extends LineRangeMapping {
+    readonly inputTextModel: ITextModel;
+    readonly outputTextModel: ITextModel;
+    static join(mappings: readonly DetailedLineRangeMapping[]): DetailedLineRangeMapping | undefined;
+    readonly rangeMappings: readonly RangeMapping[];
+    constructor(inputRange: LineRange, inputTextModel: ITextModel, outputRange: LineRange, outputTextModel: ITextModel, rangeMappings?: readonly RangeMapping[]);
+    addOutputLineDelta(delta: number): DetailedLineRangeMapping;
+    addInputLineDelta(delta: number): DetailedLineRangeMapping;
+    join(other: DetailedLineRangeMapping): DetailedLineRangeMapping;
+    getLineEdit(): LineRangeEdit;
+    getReverseLineEdit(): LineRangeEdit;
+    private getOutputLines;
+    private getInputLines;
+}
+export declare class RangeMapping {
+    readonly inputRange: Range;
+    readonly outputRange: Range;
+    constructor(inputRange: Range, outputRange: Range);
+    toString(): string;
+    addOutputLineDelta(deltaLines: number): RangeMapping;
+    addInputLineDelta(deltaLines: number): RangeMapping;
+    reverse(): RangeMapping;
+}
+export declare class DocumentRangeMap {
+    readonly rangeMappings: RangeMapping[];
+    readonly inputLineCount: number;
+    constructor(rangeMappings: RangeMapping[], inputLineCount: number);
+    project(position: Position): RangeMapping;
+    projectRange(range: Range): RangeMapping;
+    get outputLineCount(): number;
+    reverse(): DocumentRangeMap;
+}

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/model/mapping.js

@@ -0,0 +1,261 @@
+
+import { compareBy, numberComparator } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { findLast } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arraysFind';
+import { assertFn, checkAdjacentItems } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { BugIndicatingError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { concatArrays } from '../utils.js';
+import { LineRangeEdit } from './editing.js';
+import { LineRange } from './lineRange.js';
+import { rangeIsBeforeOrTouching, rangeContainsPosition, lengthBetweenPositions, addLength } from './rangeUtils.js';
+
+class LineRangeMapping {
+    static join(mappings) {
+        return mappings.reduce((acc, cur) => acc ? acc.join(cur) : cur, undefined);
+    }
+    constructor(inputRange, outputRange) {
+        this.inputRange = inputRange;
+        this.outputRange = outputRange;
+    }
+    extendInputRange(extendedInputRange) {
+        if (!extendedInputRange.containsRange(this.inputRange)) {
+            throw ( new BugIndicatingError());
+        }
+        const startDelta = extendedInputRange.startLineNumber - this.inputRange.startLineNumber;
+        const endDelta = extendedInputRange.endLineNumberExclusive - this.inputRange.endLineNumberExclusive;
+        return ( new LineRangeMapping(extendedInputRange, ( new LineRange(
+            this.outputRange.startLineNumber + startDelta,
+            this.outputRange.lineCount - startDelta + endDelta
+        ))));
+    }
+    join(other) {
+        return ( new LineRangeMapping(
+            this.inputRange.join(other.inputRange),
+            this.outputRange.join(other.outputRange)
+        ));
+    }
+    get resultingDeltaFromOriginalToModified() {
+        return this.outputRange.endLineNumberExclusive - this.inputRange.endLineNumberExclusive;
+    }
+    toString() {
+        return `${( this.inputRange.toString())} -> ${( this.outputRange.toString())}`;
+    }
+    addOutputLineDelta(delta) {
+        return ( new LineRangeMapping(this.inputRange, this.outputRange.delta(delta)));
+    }
+    addInputLineDelta(delta) {
+        return ( new LineRangeMapping(this.inputRange.delta(delta), this.outputRange));
+    }
+    reverse() {
+        return ( new LineRangeMapping(this.outputRange, this.inputRange));
+    }
+}
+class DocumentLineRangeMap {
+    static betweenOutputs(inputToOutput1, inputToOutput2, inputLineCount) {
+        const alignments = MappingAlignment.compute(inputToOutput1, inputToOutput2);
+        const mappings = ( alignments.map((m) => ( new LineRangeMapping(m.output1Range, m.output2Range))));
+        return ( new DocumentLineRangeMap(mappings, inputLineCount));
+    }
+    constructor(
+    lineRangeMappings, inputLineCount) {
+        this.lineRangeMappings = lineRangeMappings;
+        this.inputLineCount = inputLineCount;
+        assertFn(() => {
+            return checkAdjacentItems(lineRangeMappings, (m1, m2) => m1.inputRange.isBefore(m2.inputRange) && m1.outputRange.isBefore(m2.outputRange) &&
+                m2.inputRange.startLineNumber - m1.inputRange.endLineNumberExclusive === m2.outputRange.startLineNumber - m1.outputRange.endLineNumberExclusive);
+        });
+    }
+    project(lineNumber) {
+        const lastBefore = findLast(this.lineRangeMappings, r => r.inputRange.startLineNumber <= lineNumber);
+        if (!lastBefore) {
+            return ( new LineRangeMapping(( new LineRange(lineNumber, 1)), ( new LineRange(lineNumber, 1))));
+        }
+        if (lastBefore.inputRange.contains(lineNumber)) {
+            return lastBefore;
+        }
+        const containingRange = ( new LineRange(lineNumber, 1));
+        const mappedRange = ( new LineRange(lineNumber +
+            lastBefore.outputRange.endLineNumberExclusive -
+            lastBefore.inputRange.endLineNumberExclusive, 1));
+        return ( new LineRangeMapping(containingRange, mappedRange));
+    }
+    get outputLineCount() {
+        const last = this.lineRangeMappings.at(-1);
+        const diff = last ? last.outputRange.endLineNumberExclusive - last.inputRange.endLineNumberExclusive : 0;
+        return this.inputLineCount + diff;
+    }
+    reverse() {
+        return ( new DocumentLineRangeMap(( this.lineRangeMappings.map(r => r.reverse())), this.outputLineCount));
+    }
+}
+class MappingAlignment {
+    static compute(fromInputToOutput1, fromInputToOutput2) {
+        const compareByStartLineNumber = compareBy((d) => d.inputRange.startLineNumber, numberComparator);
+        const combinedDiffs = concatArrays(( fromInputToOutput1.map((diff) => ({ source: 0, diff }))), ( fromInputToOutput2.map((diff) => ({ source: 1, diff })))).sort(compareBy((d) => d.diff, compareByStartLineNumber));
+        const currentDiffs = [( new Array()), ( new Array())];
+        const deltaFromBaseToInput = [0, 0];
+        const alignments = ( new Array());
+        function pushAndReset(inputRange) {
+            const mapping1 = LineRangeMapping.join(currentDiffs[0]) || ( new LineRangeMapping(inputRange, inputRange.delta(deltaFromBaseToInput[0])));
+            const mapping2 = LineRangeMapping.join(currentDiffs[1]) || ( new LineRangeMapping(inputRange, inputRange.delta(deltaFromBaseToInput[1])));
+            alignments.push(( new MappingAlignment(
+                currentInputRange,
+                mapping1.extendInputRange(currentInputRange).outputRange,
+                currentDiffs[0],
+                mapping2.extendInputRange(currentInputRange).outputRange,
+                currentDiffs[1]
+            )));
+            currentDiffs[0] = [];
+            currentDiffs[1] = [];
+        }
+        let currentInputRange;
+        for (const diff of combinedDiffs) {
+            const range = diff.diff.inputRange;
+            if (currentInputRange && !currentInputRange.touches(range)) {
+                pushAndReset(currentInputRange);
+                currentInputRange = undefined;
+            }
+            deltaFromBaseToInput[diff.source] =
+                diff.diff.resultingDeltaFromOriginalToModified;
+            currentInputRange = currentInputRange ? currentInputRange.join(range) : range;
+            currentDiffs[diff.source].push(diff.diff);
+        }
+        if (currentInputRange) {
+            pushAndReset(currentInputRange);
+        }
+        return alignments;
+    }
+    constructor(inputRange, output1Range, output1LineMappings, output2Range, output2LineMappings) {
+        this.inputRange = inputRange;
+        this.output1Range = output1Range;
+        this.output1LineMappings = output1LineMappings;
+        this.output2Range = output2Range;
+        this.output2LineMappings = output2LineMappings;
+    }
+    toString() {
+        return `${this.output1Range} <- ${this.inputRange} -> ${this.output2Range}`;
+    }
+}
+class DetailedLineRangeMapping extends LineRangeMapping {
+    static join(mappings) {
+        return mappings.reduce((acc, cur) => acc ? acc.join(cur) : cur, undefined);
+    }
+    constructor(inputRange, inputTextModel, outputRange, outputTextModel, rangeMappings) {
+        super(inputRange, outputRange);
+        this.inputTextModel = inputTextModel;
+        this.outputTextModel = outputTextModel;
+        this.rangeMappings = rangeMappings || [( new RangeMapping(this.inputRange.toRange(), this.outputRange.toRange()))];
+    }
+    addOutputLineDelta(delta) {
+        return ( new DetailedLineRangeMapping(
+            this.inputRange,
+            this.inputTextModel,
+            this.outputRange.delta(delta),
+            this.outputTextModel,
+            ( this.rangeMappings.map(d => d.addOutputLineDelta(delta)))
+        ));
+    }
+    addInputLineDelta(delta) {
+        return ( new DetailedLineRangeMapping(
+            this.inputRange.delta(delta),
+            this.inputTextModel,
+            this.outputRange,
+            this.outputTextModel,
+            ( this.rangeMappings.map(d => d.addInputLineDelta(delta)))
+        ));
+    }
+    join(other) {
+        return ( new DetailedLineRangeMapping(
+            this.inputRange.join(other.inputRange),
+            this.inputTextModel,
+            this.outputRange.join(other.outputRange),
+            this.outputTextModel
+        ));
+    }
+    getLineEdit() {
+        return ( new LineRangeEdit(this.inputRange, this.getOutputLines()));
+    }
+    getReverseLineEdit() {
+        return ( new LineRangeEdit(this.outputRange, this.getInputLines()));
+    }
+    getOutputLines() {
+        return this.outputRange.getLines(this.outputTextModel);
+    }
+    getInputLines() {
+        return this.inputRange.getLines(this.inputTextModel);
+    }
+}
+class RangeMapping {
+    constructor(inputRange, outputRange) {
+        this.inputRange = inputRange;
+        this.outputRange = outputRange;
+    }
+    toString() {
+        function rangeToString(range) {
+            return `[${range.startLineNumber}:${range.startColumn}, ${range.endLineNumber}:${range.endColumn})`;
+        }
+        return `${rangeToString(this.inputRange)} -> ${rangeToString(this.outputRange)}`;
+    }
+    addOutputLineDelta(deltaLines) {
+        return ( new RangeMapping(this.inputRange, ( new Range(
+            this.outputRange.startLineNumber + deltaLines,
+            this.outputRange.startColumn,
+            this.outputRange.endLineNumber + deltaLines,
+            this.outputRange.endColumn
+        ))));
+    }
+    addInputLineDelta(deltaLines) {
+        return ( new RangeMapping(( new Range(
+            this.inputRange.startLineNumber + deltaLines,
+            this.inputRange.startColumn,
+            this.inputRange.endLineNumber + deltaLines,
+            this.inputRange.endColumn
+        )), this.outputRange));
+    }
+    reverse() {
+        return ( new RangeMapping(this.outputRange, this.inputRange));
+    }
+}
+class DocumentRangeMap {
+    constructor(
+    rangeMappings, inputLineCount) {
+        this.rangeMappings = rangeMappings;
+        this.inputLineCount = inputLineCount;
+        assertFn(() => checkAdjacentItems(rangeMappings, (m1, m2) => rangeIsBeforeOrTouching(m1.inputRange, m2.inputRange) &&
+            rangeIsBeforeOrTouching(m1.outputRange, m2.outputRange)
+));
+    }
+    project(position) {
+        const lastBefore = findLast(this.rangeMappings, r => r.inputRange.getStartPosition().isBeforeOrEqual(position));
+        if (!lastBefore) {
+            return ( new RangeMapping(
+                Range.fromPositions(position, position),
+                Range.fromPositions(position, position)
+            ));
+        }
+        if (rangeContainsPosition(lastBefore.inputRange, position)) {
+            return lastBefore;
+        }
+        const dist = lengthBetweenPositions(lastBefore.inputRange.getEndPosition(), position);
+        const outputPos = addLength(lastBefore.outputRange.getEndPosition(), dist);
+        return ( new RangeMapping(Range.fromPositions(position), Range.fromPositions(outputPos)));
+    }
+    projectRange(range) {
+        const start = this.project(range.getStartPosition());
+        const end = this.project(range.getEndPosition());
+        return ( new RangeMapping(
+            start.inputRange.plusRange(end.inputRange),
+            start.outputRange.plusRange(end.outputRange)
+        ));
+    }
+    get outputLineCount() {
+        const last = this.rangeMappings.at(-1);
+        const diff = last ? last.outputRange.endLineNumber - last.inputRange.endLineNumber : 0;
+        return this.inputLineCount + diff;
+    }
+    reverse() {
+        return ( new DocumentRangeMap(( this.rangeMappings.map(m => m.reverse())), this.outputLineCount));
+    }
+}
+
+export { DetailedLineRangeMapping, DocumentLineRangeMap, DocumentRangeMap, LineRangeMapping, MappingAlignment, RangeMapping };

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/model/modifiedBaseRange.d.ts

@@ -0,0 +1,112 @@
+import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+import { LineRangeEdit } from "./editing.js";
+import { LineRange } from "./lineRange.js";
+import { DetailedLineRangeMapping } from "./mapping.js";
+export declare class ModifiedBaseRange {
+    readonly baseRange: LineRange;
+    readonly baseTextModel: ITextModel;
+    readonly input1Range: LineRange;
+    readonly input1TextModel: ITextModel;
+    readonly input1Diffs: readonly DetailedLineRangeMapping[];
+    readonly input2Range: LineRange;
+    readonly input2TextModel: ITextModel;
+    readonly input2Diffs: readonly DetailedLineRangeMapping[];
+    static fromDiffs(diffs1: readonly DetailedLineRangeMapping[], diffs2: readonly DetailedLineRangeMapping[], baseTextModel: ITextModel, input1TextModel: ITextModel, input2TextModel: ITextModel): ModifiedBaseRange[];
+    readonly input1CombinedDiff: DetailedLineRangeMapping | undefined;
+    readonly input2CombinedDiff: DetailedLineRangeMapping | undefined;
+    readonly isEqualChange: boolean;
+    constructor(baseRange: LineRange, baseTextModel: ITextModel, input1Range: LineRange, input1TextModel: ITextModel, input1Diffs: readonly DetailedLineRangeMapping[], input2Range: LineRange, input2TextModel: ITextModel, input2Diffs: readonly DetailedLineRangeMapping[]);
+    getInputRange(inputNumber: 1 | 2): LineRange;
+    getInputCombinedDiff(inputNumber: 1 | 2): DetailedLineRangeMapping | undefined;
+    getInputDiffs(inputNumber: 1 | 2): readonly DetailedLineRangeMapping[];
+    get isConflicting(): boolean;
+    get canBeCombined(): boolean;
+    get isOrderRelevant(): boolean;
+    getEditForBase(state: ModifiedBaseRangeState): {
+        edit: LineRangeEdit | undefined;
+        effectiveState: ModifiedBaseRangeState;
+    };
+    private smartInput1LineRangeEdit;
+    private smartInput2LineRangeEdit;
+    private smartCombineInputs;
+    private dumbInput1LineRangeEdit;
+    private dumbInput2LineRangeEdit;
+    private dumbCombineInputs;
+}
+export declare enum ModifiedBaseRangeStateKind {
+    base = 0,
+    input1 = 1,
+    input2 = 2,
+    both = 3,
+    unrecognized = 4
+}
+export type InputNumber = 1 | 2;
+export declare function getOtherInputNumber(inputNumber: InputNumber): InputNumber;
+export declare abstract class AbstractModifiedBaseRangeState {
+    constructor();
+    abstract get kind(): ModifiedBaseRangeStateKind;
+    get includesInput1(): boolean;
+    get includesInput2(): boolean;
+    includesInput(inputNumber: InputNumber): boolean;
+    isInputIncluded(inputNumber: InputNumber): boolean;
+    abstract toString(): string;
+    abstract swap(): ModifiedBaseRangeState;
+    abstract withInputValue(inputNumber: InputNumber, value: boolean, smartCombination?: boolean): ModifiedBaseRangeState;
+    abstract equals(other: ModifiedBaseRangeState): boolean;
+    toggle(inputNumber: InputNumber): ModifiedBaseRangeState;
+    getInput(inputNumber: 1 | 2): InputState;
+}
+export declare class ModifiedBaseRangeStateBase extends AbstractModifiedBaseRangeState {
+    get kind(): ModifiedBaseRangeStateKind.base;
+    toString(): string;
+    swap(): ModifiedBaseRangeState;
+    withInputValue(inputNumber: InputNumber, value: boolean, smartCombination?: boolean): ModifiedBaseRangeState;
+    equals(other: ModifiedBaseRangeState): boolean;
+}
+export declare class ModifiedBaseRangeStateInput1 extends AbstractModifiedBaseRangeState {
+    get kind(): ModifiedBaseRangeStateKind.input1;
+    get includesInput1(): boolean;
+    toString(): string;
+    swap(): ModifiedBaseRangeState;
+    withInputValue(inputNumber: InputNumber, value: boolean, smartCombination?: boolean): ModifiedBaseRangeState;
+    equals(other: ModifiedBaseRangeState): boolean;
+}
+export declare class ModifiedBaseRangeStateInput2 extends AbstractModifiedBaseRangeState {
+    get kind(): ModifiedBaseRangeStateKind.input2;
+    get includesInput2(): boolean;
+    toString(): string;
+    swap(): ModifiedBaseRangeState;
+    withInputValue(inputNumber: InputNumber, value: boolean, smartCombination?: boolean): ModifiedBaseRangeState;
+    equals(other: ModifiedBaseRangeState): boolean;
+}
+export declare class ModifiedBaseRangeStateBoth extends AbstractModifiedBaseRangeState {
+    readonly firstInput: InputNumber;
+    readonly smartCombination: boolean;
+    constructor(firstInput: InputNumber, smartCombination: boolean);
+    get kind(): ModifiedBaseRangeStateKind.both;
+    get includesInput1(): boolean;
+    get includesInput2(): boolean;
+    toString(): string;
+    swap(): ModifiedBaseRangeState;
+    withInputValue(inputNumber: InputNumber, value: boolean, smartCombination?: boolean): ModifiedBaseRangeState;
+    equals(other: ModifiedBaseRangeState): boolean;
+    getInput(inputNumber: 1 | 2): InputState;
+}
+export declare class ModifiedBaseRangeStateUnrecognized extends AbstractModifiedBaseRangeState {
+    get kind(): ModifiedBaseRangeStateKind.unrecognized;
+    toString(): string;
+    swap(): ModifiedBaseRangeState;
+    withInputValue(inputNumber: InputNumber, value: boolean, smartCombination?: boolean): ModifiedBaseRangeState;
+    equals(other: ModifiedBaseRangeState): boolean;
+}
+export type ModifiedBaseRangeState = ModifiedBaseRangeStateBase | ModifiedBaseRangeStateInput1 | ModifiedBaseRangeStateInput2 | ModifiedBaseRangeStateInput2 | ModifiedBaseRangeStateBoth | ModifiedBaseRangeStateUnrecognized;
+export declare namespace ModifiedBaseRangeState {
+    const base: ModifiedBaseRangeStateBase;
+    const unrecognized: ModifiedBaseRangeStateUnrecognized;
+}
+export declare enum InputState {
+    excluded = 0,
+    first = 1,
+    second = 2,
+    unrecognized = 3
+}

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/model/modifiedBaseRange.js

@@ -0,0 +1,315 @@
+
+import { equals, tieBreakComparators, compareBy, numberComparator } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { BugIndicatingError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { splitLines } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { Constants } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uint';
+import { Position } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { RangeEdit, LineRangeEdit } from './editing.js';
+import { MappingAlignment, DetailedLineRangeMapping } from './mapping.js';
+import { concatArrays } from '../utils.js';
+
+class ModifiedBaseRange {
+    static fromDiffs(diffs1, diffs2, baseTextModel, input1TextModel, input2TextModel) {
+        const alignments = MappingAlignment.compute(diffs1, diffs2);
+        return ( alignments.map((a) => ( new ModifiedBaseRange(
+            a.inputRange,
+            baseTextModel,
+            a.output1Range,
+            input1TextModel,
+            a.output1LineMappings,
+            a.output2Range,
+            input2TextModel,
+            a.output2LineMappings
+        ))));
+    }
+    constructor(baseRange, baseTextModel, input1Range, input1TextModel,
+    input1Diffs, input2Range, input2TextModel,
+    input2Diffs) {
+        this.baseRange = baseRange;
+        this.baseTextModel = baseTextModel;
+        this.input1Range = input1Range;
+        this.input1TextModel = input1TextModel;
+        this.input1Diffs = input1Diffs;
+        this.input2Range = input2Range;
+        this.input2TextModel = input2TextModel;
+        this.input2Diffs = input2Diffs;
+        this.input1CombinedDiff = DetailedLineRangeMapping.join(this.input1Diffs);
+        this.input2CombinedDiff = DetailedLineRangeMapping.join(this.input2Diffs);
+        this.isEqualChange = equals(this.input1Diffs, this.input2Diffs, (a, b) => a.getLineEdit().equals(b.getLineEdit()));
+        this.smartInput1LineRangeEdit = null;
+        this.smartInput2LineRangeEdit = null;
+        this.dumbInput1LineRangeEdit = null;
+        this.dumbInput2LineRangeEdit = null;
+        if (this.input1Diffs.length === 0 && this.input2Diffs.length === 0) {
+            throw ( new BugIndicatingError('must have at least one diff'));
+        }
+    }
+    getInputRange(inputNumber) {
+        return inputNumber === 1 ? this.input1Range : this.input2Range;
+    }
+    getInputCombinedDiff(inputNumber) {
+        return inputNumber === 1 ? this.input1CombinedDiff : this.input2CombinedDiff;
+    }
+    getInputDiffs(inputNumber) {
+        return inputNumber === 1 ? this.input1Diffs : this.input2Diffs;
+    }
+    get isConflicting() {
+        return this.input1Diffs.length > 0 && this.input2Diffs.length > 0;
+    }
+    get canBeCombined() {
+        return this.smartCombineInputs(1) !== undefined;
+    }
+    get isOrderRelevant() {
+        const input1 = this.smartCombineInputs(1);
+        const input2 = this.smartCombineInputs(2);
+        if (!input1 || !input2) {
+            return false;
+        }
+        return !input1.equals(input2);
+    }
+    getEditForBase(state) {
+        const diffs = [];
+        if (state.includesInput1 && this.input1CombinedDiff) {
+            diffs.push({ diff: this.input1CombinedDiff, inputNumber: 1 });
+        }
+        if (state.includesInput2 && this.input2CombinedDiff) {
+            diffs.push({ diff: this.input2CombinedDiff, inputNumber: 2 });
+        }
+        if (diffs.length === 0) {
+            return { edit: undefined, effectiveState: ModifiedBaseRangeState.base };
+        }
+        if (diffs.length === 1) {
+            return { edit: diffs[0].diff.getLineEdit(), effectiveState: ModifiedBaseRangeState.base.withInputValue(diffs[0].inputNumber, true, false) };
+        }
+        if (state.kind !== ModifiedBaseRangeStateKind.both) {
+            throw ( new BugIndicatingError());
+        }
+        const smartCombinedEdit = state.smartCombination ? this.smartCombineInputs(state.firstInput) : this.dumbCombineInputs(state.firstInput);
+        if (smartCombinedEdit) {
+            return { edit: smartCombinedEdit, effectiveState: state };
+        }
+        return {
+            edit: diffs[getOtherInputNumber(state.firstInput) - 1].diff.getLineEdit(),
+            effectiveState: ModifiedBaseRangeState.base.withInputValue(getOtherInputNumber(state.firstInput), true, false),
+        };
+    }
+    smartCombineInputs(firstInput) {
+        if (firstInput === 1 && this.smartInput1LineRangeEdit !== null) {
+            return this.smartInput1LineRangeEdit;
+        }
+        else if (firstInput === 2 && this.smartInput2LineRangeEdit !== null) {
+            return this.smartInput2LineRangeEdit;
+        }
+        const combinedDiffs = concatArrays(this.input1Diffs.flatMap((diffs) => ( diffs.rangeMappings.map((diff) => ({ diff, input: 1 })))), this.input2Diffs.flatMap((diffs) => ( diffs.rangeMappings.map((diff) => ({ diff, input: 2 }))))).sort(tieBreakComparators(compareBy((d) => d.diff.inputRange, Range.compareRangesUsingStarts), compareBy((d) => (d.input === firstInput ? 1 : 2), numberComparator)));
+        const sortedEdits = ( combinedDiffs.map(d => {
+            const sourceTextModel = d.input === 1 ? this.input1TextModel : this.input2TextModel;
+            return ( new RangeEdit(d.diff.inputRange, sourceTextModel.getValueInRange(d.diff.outputRange)));
+        }));
+        const result = editsToLineRangeEdit(this.baseRange, sortedEdits, this.baseTextModel);
+        if (firstInput === 1) {
+            this.smartInput1LineRangeEdit = result;
+        }
+        else {
+            this.smartInput2LineRangeEdit = result;
+        }
+        return result;
+    }
+    dumbCombineInputs(firstInput) {
+        if (firstInput === 1 && this.dumbInput1LineRangeEdit !== null) {
+            return this.dumbInput1LineRangeEdit;
+        }
+        else if (firstInput === 2 && this.dumbInput2LineRangeEdit !== null) {
+            return this.dumbInput2LineRangeEdit;
+        }
+        let input1Lines = this.input1Range.getLines(this.input1TextModel);
+        let input2Lines = this.input2Range.getLines(this.input2TextModel);
+        if (firstInput === 2) {
+            [input1Lines, input2Lines] = [input2Lines, input1Lines];
+        }
+        const result = ( new LineRangeEdit(this.baseRange, input1Lines.concat(input2Lines)));
+        if (firstInput === 1) {
+            this.dumbInput1LineRangeEdit = result;
+        }
+        else {
+            this.dumbInput2LineRangeEdit = result;
+        }
+        return result;
+    }
+}
+function editsToLineRangeEdit(range, sortedEdits, textModel) {
+    let text = '';
+    const startsLineBefore = range.startLineNumber > 1;
+    let currentPosition = startsLineBefore
+        ? ( new Position(
+        range.startLineNumber - 1,
+        textModel.getLineMaxColumn(range.startLineNumber - 1)
+    ))
+        : ( new Position(range.startLineNumber, 1));
+    for (const edit of sortedEdits) {
+        const diffStart = edit.range.getStartPosition();
+        if (!currentPosition.isBeforeOrEqual(diffStart)) {
+            return undefined;
+        }
+        let originalText = textModel.getValueInRange(Range.fromPositions(currentPosition, diffStart));
+        if (diffStart.lineNumber > textModel.getLineCount()) {
+            originalText += '\n';
+        }
+        text += originalText;
+        text += edit.newText;
+        currentPosition = edit.range.getEndPosition();
+    }
+    const endsLineAfter = range.endLineNumberExclusive <= textModel.getLineCount();
+    const end = endsLineAfter ? ( new Position(range.endLineNumberExclusive, 1)) : ( new Position(range.endLineNumberExclusive - 1, Constants.MAX_SAFE_SMALL_INTEGER));
+    const originalText = textModel.getValueInRange(Range.fromPositions(currentPosition, end));
+    text += originalText;
+    const lines = splitLines(text);
+    if (startsLineBefore) {
+        if (lines[0] !== '') {
+            return undefined;
+        }
+        lines.shift();
+    }
+    if (endsLineAfter) {
+        if (lines[lines.length - 1] !== '') {
+            return undefined;
+        }
+        lines.pop();
+    }
+    return ( new LineRangeEdit(range, lines));
+}
+var ModifiedBaseRangeStateKind;
+(function (ModifiedBaseRangeStateKind) {
+    ModifiedBaseRangeStateKind[ModifiedBaseRangeStateKind["base"] = 0] = "base";
+    ModifiedBaseRangeStateKind[ModifiedBaseRangeStateKind["input1"] = 1] = "input1";
+    ModifiedBaseRangeStateKind[ModifiedBaseRangeStateKind["input2"] = 2] = "input2";
+    ModifiedBaseRangeStateKind[ModifiedBaseRangeStateKind["both"] = 3] = "both";
+    ModifiedBaseRangeStateKind[ModifiedBaseRangeStateKind["unrecognized"] = 4] = "unrecognized";
+})(ModifiedBaseRangeStateKind || (ModifiedBaseRangeStateKind = {}));
+function getOtherInputNumber(inputNumber) {
+    return inputNumber === 1 ? 2 : 1;
+}
+class AbstractModifiedBaseRangeState {
+    constructor() { }
+    get includesInput1() { return false; }
+    get includesInput2() { return false; }
+    includesInput(inputNumber) {
+        return inputNumber === 1 ? this.includesInput1 : this.includesInput2;
+    }
+    isInputIncluded(inputNumber) {
+        return inputNumber === 1 ? this.includesInput1 : this.includesInput2;
+    }
+    toggle(inputNumber) {
+        return this.withInputValue(inputNumber, !this.includesInput(inputNumber), true);
+    }
+    getInput(inputNumber) {
+        if (!this.isInputIncluded(inputNumber)) {
+            return InputState.excluded;
+        }
+        return InputState.first;
+    }
+}
+class ModifiedBaseRangeStateBase extends AbstractModifiedBaseRangeState {
+    get kind() { return ModifiedBaseRangeStateKind.base; }
+    toString() { return 'base'; }
+    swap() { return this; }
+    withInputValue(inputNumber, value, smartCombination = false) {
+        if (inputNumber === 1) {
+            return value ? ( new ModifiedBaseRangeStateInput1()) : this;
+        }
+        else {
+            return value ? ( new ModifiedBaseRangeStateInput2()) : this;
+        }
+    }
+    equals(other) {
+        return other.kind === ModifiedBaseRangeStateKind.base;
+    }
+}
+class ModifiedBaseRangeStateInput1 extends AbstractModifiedBaseRangeState {
+    get kind() { return ModifiedBaseRangeStateKind.input1; }
+    get includesInput1() { return true; }
+    toString() { return '1✓'; }
+    swap() { return ( new ModifiedBaseRangeStateInput2()); }
+    withInputValue(inputNumber, value, smartCombination = false) {
+        if (inputNumber === 1) {
+            return value ? this : ( new ModifiedBaseRangeStateBase());
+        }
+        else {
+            return value ? ( new ModifiedBaseRangeStateBoth(1, smartCombination)) : ( new ModifiedBaseRangeStateInput2());
+        }
+    }
+    equals(other) {
+        return other.kind === ModifiedBaseRangeStateKind.input1;
+    }
+}
+class ModifiedBaseRangeStateInput2 extends AbstractModifiedBaseRangeState {
+    get kind() { return ModifiedBaseRangeStateKind.input2; }
+    get includesInput2() { return true; }
+    toString() { return '2✓'; }
+    swap() { return ( new ModifiedBaseRangeStateInput1()); }
+    withInputValue(inputNumber, value, smartCombination = false) {
+        if (inputNumber === 2) {
+            return value ? this : ( new ModifiedBaseRangeStateBase());
+        }
+        else {
+            return value ? ( new ModifiedBaseRangeStateBoth(2, smartCombination)) : ( new ModifiedBaseRangeStateInput2());
+        }
+    }
+    equals(other) {
+        return other.kind === ModifiedBaseRangeStateKind.input2;
+    }
+}
+class ModifiedBaseRangeStateBoth extends AbstractModifiedBaseRangeState {
+    constructor(firstInput, smartCombination) {
+        super();
+        this.firstInput = firstInput;
+        this.smartCombination = smartCombination;
+    }
+    get kind() { return ModifiedBaseRangeStateKind.both; }
+    get includesInput1() { return true; }
+    get includesInput2() { return true; }
+    toString() {
+        return '2✓';
+    }
+    swap() { return ( new ModifiedBaseRangeStateBoth(getOtherInputNumber(this.firstInput), this.smartCombination)); }
+    withInputValue(inputNumber, value, smartCombination = false) {
+        if (value) {
+            return this;
+        }
+        return inputNumber === 1 ? ( new ModifiedBaseRangeStateInput2()) : ( new ModifiedBaseRangeStateInput1());
+    }
+    equals(other) {
+        return other.kind === ModifiedBaseRangeStateKind.both && this.firstInput === other.firstInput && this.smartCombination === other.smartCombination;
+    }
+    getInput(inputNumber) {
+        return inputNumber === this.firstInput ? InputState.first : InputState.second;
+    }
+}
+class ModifiedBaseRangeStateUnrecognized extends AbstractModifiedBaseRangeState {
+    get kind() { return ModifiedBaseRangeStateKind.unrecognized; }
+    toString() { return 'unrecognized'; }
+    swap() { return this; }
+    withInputValue(inputNumber, value, smartCombination = false) {
+        if (!value) {
+            return this;
+        }
+        return inputNumber === 1 ? ( new ModifiedBaseRangeStateInput1()) : ( new ModifiedBaseRangeStateInput2());
+    }
+    equals(other) {
+        return other.kind === ModifiedBaseRangeStateKind.unrecognized;
+    }
+}
+var ModifiedBaseRangeState;
+(function (ModifiedBaseRangeState) {
+    ModifiedBaseRangeState.base = ( new ModifiedBaseRangeStateBase());
+    ModifiedBaseRangeState.unrecognized = ( new ModifiedBaseRangeStateUnrecognized());
+})(ModifiedBaseRangeState || (ModifiedBaseRangeState = {}));
+var InputState;
+(function (InputState) {
+    InputState[InputState["excluded"] = 0] = "excluded";
+    InputState[InputState["first"] = 1] = "first";
+    InputState[InputState["second"] = 2] = "second";
+    InputState[InputState["unrecognized"] = 3] = "unrecognized";
+})(InputState || (InputState = {}));
+
+export { AbstractModifiedBaseRangeState, InputState, ModifiedBaseRange, ModifiedBaseRangeState, ModifiedBaseRangeStateBase, ModifiedBaseRangeStateBoth, ModifiedBaseRangeStateInput1, ModifiedBaseRangeStateInput2, ModifiedBaseRangeStateKind, ModifiedBaseRangeStateUnrecognized, getOtherInputNumber };

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/model/rangeUtils.d.ts

@@ -0,0 +1,8 @@
+import { Position } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position";
+import { Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+import { TextLength } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/textLength";
+export declare function rangeContainsPosition(range: Range, position: Position): boolean;
+export declare function lengthOfRange(range: Range): TextLength;
+export declare function lengthBetweenPositions(position1: Position, position2: Position): TextLength;
+export declare function addLength(position: Position, length: TextLength): Position;
+export declare function rangeIsBeforeOrTouching(range: Range, other: Range): boolean;

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/model/rangeUtils.js

@@ -0,0 +1,47 @@
+
+import { Position } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position';
+import { TextLength } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/textLength';
+
+function rangeContainsPosition(range, position) {
+    if (position.lineNumber < range.startLineNumber || position.lineNumber > range.endLineNumber) {
+        return false;
+    }
+    if (position.lineNumber === range.startLineNumber && position.column < range.startColumn) {
+        return false;
+    }
+    if (position.lineNumber === range.endLineNumber && position.column >= range.endColumn) {
+        return false;
+    }
+    return true;
+}
+function lengthOfRange(range) {
+    if (range.startLineNumber === range.endLineNumber) {
+        return ( new TextLength(0, range.endColumn - range.startColumn));
+    }
+    else {
+        return ( new TextLength(range.endLineNumber - range.startLineNumber, range.endColumn - 1));
+    }
+}
+function lengthBetweenPositions(position1, position2) {
+    if (position1.lineNumber === position2.lineNumber) {
+        return ( new TextLength(0, position2.column - position1.column));
+    }
+    else {
+        return ( new TextLength(position2.lineNumber - position1.lineNumber, position2.column - 1));
+    }
+}
+function addLength(position, length) {
+    if (length.lineCount === 0) {
+        return ( new Position(position.lineNumber, position.column + length.columnCount));
+    }
+    else {
+        return ( new Position(position.lineNumber + length.lineCount, length.columnCount + 1));
+    }
+}
+function rangeIsBeforeOrTouching(range, other) {
+    return (range.endLineNumber < other.startLineNumber ||
+        (range.endLineNumber === other.startLineNumber &&
+            range.endColumn <= other.startColumn));
+}
+
+export { addLength, lengthBetweenPositions, lengthOfRange, rangeContainsPosition, rangeIsBeforeOrTouching };

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/utils.d.ts

@@ -0,0 +1,35 @@
+import { CompareResult } from "@codingame/monaco-vscode-api/vscode/vs/base/common/arrays";
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { CodeEditorWidget } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/widget/codeEditor/codeEditorWidget";
+import { IModelDeltaDecoration } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+export declare function setStyle(element: HTMLElement, style: {
+    width?: number | string;
+    height?: number | string;
+    left?: number | string;
+    top?: number | string;
+}): void;
+export declare function applyObservableDecorations(editor: CodeEditorWidget, decorations: IObservable<IModelDeltaDecoration[]>): IDisposable;
+export declare function leftJoin<TLeft, TRight>(left: Iterable<TLeft>, right: readonly TRight[], compare: (left: TLeft, right: TRight) => CompareResult): IterableIterator<{
+    left: TLeft;
+    rights: TRight[];
+}>;
+export declare function join<TLeft, TRight>(left: Iterable<TLeft>, right: readonly TRight[], compare: (left: TLeft, right: TRight) => CompareResult): IterableIterator<{
+    left?: TLeft;
+    rights: TRight[];
+}>;
+export declare function concatArrays<TArr extends any[]>(...arrays: TArr): TArr[number][number][];
+export declare function elementAtOrUndefined<T>(arr: T[], index: number): T | undefined;
+export declare function thenIfNotDisposed<T>(promise: Promise<T>, then: () => void): IDisposable;
+export declare function setFields<T extends {}>(obj: T, fields: Partial<T>): T;
+export declare function deepMerge<T extends {}>(source1: T, source2: Partial<T>): T;
+export declare class PersistentStore<T> {
+    private readonly key;
+    private readonly storageService;
+    private hasValue;
+    private value;
+    constructor(key: string, storageService: IStorageService);
+    get(): Readonly<T> | undefined;
+    set(newValue: T | undefined): void;
+}

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/utils.js

@@ -0,0 +1,121 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { ArrayQueue, CompareResult } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { onUnexpectedError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { autorunOpts } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/autorun';
+
+function setStyle(element, style) {
+    Object.entries(style).forEach(([key, value]) => {
+        element.style.setProperty(key, toSize(value));
+    });
+}
+function toSize(value) {
+    return typeof value === 'number' ? `${value}px` : value;
+}
+function applyObservableDecorations(editor, decorations) {
+    const d = ( new DisposableStore());
+    let decorationIds = [];
+    d.add(autorunOpts({ debugName: () => `Apply decorations from ${decorations.debugName}` }, reader => {
+        const d = decorations.read(reader);
+        editor.changeDecorations(a => {
+            decorationIds = a.deltaDecorations(decorationIds, d);
+        });
+    }));
+    d.add({
+        dispose: () => {
+            editor.changeDecorations(a => {
+                decorationIds = a.deltaDecorations(decorationIds, []);
+            });
+        }
+    });
+    return d;
+}
+function* leftJoin(left, right, compare) {
+    const rightQueue = ( new ArrayQueue(right));
+    for (const leftElement of left) {
+        rightQueue.takeWhile(rightElement => CompareResult.isGreaterThan(compare(leftElement, rightElement)));
+        const equals = rightQueue.takeWhile(rightElement => CompareResult.isNeitherLessOrGreaterThan(compare(leftElement, rightElement)));
+        yield { left: leftElement, rights: equals || [] };
+    }
+}
+function* join(left, right, compare) {
+    const rightQueue = ( new ArrayQueue(right));
+    for (const leftElement of left) {
+        const skipped = rightQueue.takeWhile(rightElement => CompareResult.isGreaterThan(compare(leftElement, rightElement)));
+        if (skipped) {
+            yield { rights: skipped };
+        }
+        const equals = rightQueue.takeWhile(rightElement => CompareResult.isNeitherLessOrGreaterThan(compare(leftElement, rightElement)));
+        yield { left: leftElement, rights: equals || [] };
+    }
+}
+function concatArrays(...arrays) {
+    return [].concat(...arrays);
+}
+function thenIfNotDisposed(promise, then) {
+    let disposed = false;
+    promise.then(() => {
+        if (disposed) {
+            return;
+        }
+        then();
+    });
+    return toDisposable(() => {
+        disposed = true;
+    });
+}
+function setFields(obj, fields) {
+    return Object.assign(obj, fields);
+}
+function deepMerge(source1, source2) {
+    const result = {};
+    for (const key in source1) {
+        result[key] = source1[key];
+    }
+    for (const key in source2) {
+        const source2Value = source2[key];
+        if (typeof result[key] === 'object' && source2Value && typeof source2Value === 'object') {
+            result[key] = deepMerge(result[key], source2Value);
+        }
+        else {
+            result[key] = source2Value;
+        }
+    }
+    return result;
+}
+let PersistentStore = class PersistentStore {
+    constructor(key, storageService) {
+        this.key = key;
+        this.storageService = storageService;
+        this.hasValue = false;
+        this.value = undefined;
+    }
+    get() {
+        if (!this.hasValue) {
+            const value = this.storageService.get(this.key, StorageScope.PROFILE);
+            if (value !== undefined) {
+                try {
+                    this.value = JSON.parse(value);
+                }
+                catch (e) {
+                    onUnexpectedError(e);
+                }
+            }
+            this.hasValue = true;
+        }
+        return this.value;
+    }
+    set(newValue) {
+        this.value = newValue;
+        this.storageService.store(this.key, JSON.stringify(this.value), StorageScope.PROFILE, StorageTarget.USER);
+    }
+};
+PersistentStore = ( __decorate([
+    ( __param(1, IStorageService))
+], PersistentStore));
+
+export { PersistentStore, applyObservableDecorations, concatArrays, deepMerge, join, leftJoin, setFields, setStyle, thenIfNotDisposed };