@codingame/monaco-vscode-extensions-service-override 1.83.7 → 1.83.9

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

@@ -0,0 +1,309 @@
+import { equals, tieBreakComparators, compareBy, numberComparator } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { BugIndicatingError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { splitLines } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { Position } from 'monaco-editor/esm/vs/editor/common/core/position.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+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,
+        1073741824
+    ));
+    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 0 ;
+        }
+        return 1 ;
+    }
+}
+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 ? 1  : 2 ;
+    }
+}
+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 = {})));
+
+export { AbstractModifiedBaseRangeState, ModifiedBaseRange, ModifiedBaseRangeState, ModifiedBaseRangeStateBase, ModifiedBaseRangeStateBoth, ModifiedBaseRangeStateInput1, ModifiedBaseRangeStateInput2, ModifiedBaseRangeStateKind, ModifiedBaseRangeStateUnrecognized, getOtherInputNumber };

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

@@ -0,0 +1,38 @@
+import { Position } from 'monaco-editor/esm/vs/editor/common/core/position.js';
+import { LengthObj } from 'monaco-editor/esm/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/length.js';
+
+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 lengthBetweenPositions(position1, position2) {
+    if (position1.lineNumber === position2.lineNumber) {
+        return ( new LengthObj(0, position2.column - position1.column));
+    }
+    else {
+        return ( new LengthObj(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, rangeContainsPosition, rangeIsBeforeOrTouching };

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

@@ -0,0 +1,167 @@
+import { compareBy, numberComparator } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { BugIndicatingError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { DetailedLineRangeMapping } from './mapping.js';
+import { LineRangeEdit } from './editing.js';
+import { LineRange } from './lineRange.js';
+import { ReentrancyBarrier } from '../utils.js';
+import { observableValue, observableSignal, autorun, transaction } from 'monaco-editor/esm/vs/base/common/observable.js';
+
+class TextModelDiffs extends Disposable {
+    get isApplyingChange() {
+        return this.barrier.isActive;
+    }
+    constructor(baseTextModel, textModel, diffComputer) {
+        super();
+        this.baseTextModel = baseTextModel;
+        this.textModel = textModel;
+        this.diffComputer = diffComputer;
+        this.recomputeCount = 0;
+        this._state = observableValue(this, 1 );
+        this._diffs = observableValue(this, []);
+        this.barrier = ( new ReentrancyBarrier());
+        this.isDisposed = false;
+        this.isInitializing = true;
+        const recomputeSignal = observableSignal('recompute');
+        this._register(autorun(reader => {
+            recomputeSignal.read(reader);
+            this.recompute(reader);
+        }));
+        this._register(baseTextModel.onDidChangeContent(this.barrier.makeExclusive(() => {
+            recomputeSignal.trigger(undefined);
+        })));
+        this._register(textModel.onDidChangeContent(this.barrier.makeExclusive(() => {
+            recomputeSignal.trigger(undefined);
+        })));
+        this._register(toDisposable(() => {
+            this.isDisposed = true;
+        }));
+    }
+    get state() {
+        return this._state;
+    }
+    get diffs() {
+        return this._diffs;
+    }
+    recompute(reader) {
+        this.recomputeCount++;
+        const currentRecomputeIdx = this.recomputeCount;
+        if (this._state.get() === 1 ) {
+            this.isInitializing = true;
+        }
+        transaction(tx => {
+            this._state.set(this.isInitializing ? 1  : 3 , tx, 0 );
+        });
+        const result = this.diffComputer.computeDiff(this.baseTextModel, this.textModel, reader);
+        result.then((result) => {
+            if (this.isDisposed) {
+                return;
+            }
+            if (currentRecomputeIdx !== this.recomputeCount) {
+                return;
+            }
+            transaction(tx => {
+                if (result.diffs) {
+                    this._state.set(2 , tx, 1 );
+                    this._diffs.set(result.diffs, tx, 1 );
+                }
+                else {
+                    this._state.set(4 , tx, 1 );
+                }
+                this.isInitializing = false;
+            });
+        });
+    }
+    ensureUpToDate() {
+        if (this.state.get() !== 2 ) {
+            throw new BugIndicatingError('Cannot remove diffs when the model is not up to date');
+        }
+    }
+    removeDiffs(diffToRemoves, transaction, group) {
+        this.ensureUpToDate();
+        diffToRemoves.sort(compareBy((d) => d.inputRange.startLineNumber, numberComparator));
+        diffToRemoves.reverse();
+        let diffs = this._diffs.get();
+        for (const diffToRemove of diffToRemoves) {
+            const len = diffs.length;
+            diffs = diffs.filter((d) => d !== diffToRemove);
+            if (len === diffs.length) {
+                throw new BugIndicatingError();
+            }
+            this.barrier.runExclusivelyOrThrow(() => {
+                const edits = diffToRemove.getReverseLineEdit().toEdits(this.textModel.getLineCount());
+                this.textModel.pushEditOperations(null, edits, () => null, group);
+            });
+            diffs = ( diffs.map((d) => d.outputRange.isAfter(diffToRemove.outputRange)
+                ? d.addOutputLineDelta(diffToRemove.inputRange.lineCount - diffToRemove.outputRange.lineCount)
+                : d));
+        }
+        this._diffs.set(diffs, transaction, 0 );
+    }
+    applyEditRelativeToOriginal(edit, transaction, group) {
+        this.ensureUpToDate();
+        const editMapping = ( new DetailedLineRangeMapping(edit.range, this.baseTextModel, ( new LineRange(edit.range.startLineNumber, edit.newLines.length)), this.textModel));
+        let firstAfter = false;
+        let delta = 0;
+        const newDiffs = ( new Array());
+        for (const diff of this.diffs.get()) {
+            if (diff.inputRange.touches(edit.range)) {
+                throw new BugIndicatingError('Edit must be conflict free.');
+            }
+            else if (diff.inputRange.isAfter(edit.range)) {
+                if (!firstAfter) {
+                    firstAfter = true;
+                    newDiffs.push(editMapping.addOutputLineDelta(delta));
+                }
+                newDiffs.push(diff.addOutputLineDelta(edit.newLines.length - edit.range.lineCount));
+            }
+            else {
+                newDiffs.push(diff);
+            }
+            if (!firstAfter) {
+                delta += diff.outputRange.lineCount - diff.inputRange.lineCount;
+            }
+        }
+        if (!firstAfter) {
+            firstAfter = true;
+            newDiffs.push(editMapping.addOutputLineDelta(delta));
+        }
+        this.barrier.runExclusivelyOrThrow(() => {
+            const edits = ( new LineRangeEdit(edit.range.delta(delta), edit.newLines)).toEdits(this.textModel.getLineCount());
+            this.textModel.pushEditOperations(null, edits, () => null, group);
+        });
+        this._diffs.set(newDiffs, transaction, 0 );
+    }
+    findTouchingDiffs(baseRange) {
+        return this.diffs.get().filter(d => d.inputRange.touches(baseRange));
+    }
+    getResultLine(lineNumber, reader) {
+        let offset = 0;
+        const diffs = reader ? this.diffs.read(reader) : this.diffs.get();
+        for (const diff of diffs) {
+            if (diff.inputRange.contains(lineNumber) || diff.inputRange.endLineNumberExclusive === lineNumber) {
+                return diff;
+            }
+            else if (diff.inputRange.endLineNumberExclusive < lineNumber) {
+                offset = diff.resultingDeltaFromOriginalToModified;
+            }
+            else {
+                break;
+            }
+        }
+        return lineNumber + offset;
+    }
+    getResultLineRange(baseRange, reader) {
+        let start = this.getResultLine(baseRange.startLineNumber, reader);
+        if (typeof start !== 'number') {
+            start = start.outputRange.startLineNumber;
+        }
+        let endExclusive = this.getResultLine(baseRange.endLineNumberExclusive, reader);
+        if (typeof endExclusive !== 'number') {
+            endExclusive = endExclusive.outputRange.endLineNumberExclusive;
+        }
+        return LineRange.fromLineNumbers(start, endExclusive);
+    }
+}
+
+export { TextModelDiffs };

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

@@ -0,0 +1,80 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+
+let MergeEditorTelemetry = class MergeEditorTelemetry {
+    constructor(telemetryService) {
+        this.telemetryService = telemetryService;
+    }
+    reportMergeEditorOpened(args) {
+        this.telemetryService.publicLog2('mergeEditor.opened', {
+            conflictCount: args.conflictCount,
+            combinableConflictCount: args.combinableConflictCount,
+            baseVisible: args.baseVisible,
+            isColumnView: args.isColumnView,
+            baseTop: args.baseTop,
+        });
+    }
+    reportLayoutChange(args) {
+        this.telemetryService.publicLog2('mergeEditor.layoutChanged', {
+            baseVisible: args.baseVisible,
+            isColumnView: args.isColumnView,
+            baseTop: args.baseTop,
+        });
+    }
+    reportMergeEditorClosed(args) {
+        this.telemetryService.publicLog2('mergeEditor.closed', {
+            conflictCount: args.conflictCount,
+            combinableConflictCount: args.combinableConflictCount,
+            durationOpenedSecs: args.durationOpenedSecs,
+            remainingConflictCount: args.remainingConflictCount,
+            accepted: args.accepted,
+            conflictsResolvedWithBase: args.conflictsResolvedWithBase,
+            conflictsResolvedWithInput1: args.conflictsResolvedWithInput1,
+            conflictsResolvedWithInput2: args.conflictsResolvedWithInput2,
+            conflictsResolvedWithSmartCombination: args.conflictsResolvedWithSmartCombination,
+            manuallySolvedConflictCountThatEqualNone: args.manuallySolvedConflictCountThatEqualNone,
+            manuallySolvedConflictCountThatEqualSmartCombine: args.manuallySolvedConflictCountThatEqualSmartCombine,
+            manuallySolvedConflictCountThatEqualInput1: args.manuallySolvedConflictCountThatEqualInput1,
+            manuallySolvedConflictCountThatEqualInput2: args.manuallySolvedConflictCountThatEqualInput2,
+            manuallySolvedConflictCountThatEqualNoneAndStartedWithBase: args.manuallySolvedConflictCountThatEqualNoneAndStartedWithBase,
+            manuallySolvedConflictCountThatEqualNoneAndStartedWithInput1: args.manuallySolvedConflictCountThatEqualNoneAndStartedWithInput1,
+            manuallySolvedConflictCountThatEqualNoneAndStartedWithInput2: args.manuallySolvedConflictCountThatEqualNoneAndStartedWithInput2,
+            manuallySolvedConflictCountThatEqualNoneAndStartedWithBothNonSmart: args.manuallySolvedConflictCountThatEqualNoneAndStartedWithBothNonSmart,
+            manuallySolvedConflictCountThatEqualNoneAndStartedWithBothSmart: args.manuallySolvedConflictCountThatEqualNoneAndStartedWithBothSmart,
+        });
+    }
+    reportAcceptInvoked(inputNumber, otherAccepted) {
+        this.telemetryService.publicLog2('mergeEditor.action.accept', {
+            otherAccepted: otherAccepted,
+            isInput1: inputNumber === 1,
+        });
+    }
+    reportSmartCombinationInvoked(otherAccepted) {
+        this.telemetryService.publicLog2('mergeEditor.action.smartCombination', {
+            otherAccepted: otherAccepted,
+        });
+    }
+    reportRemoveInvoked(inputNumber, otherAccepted) {
+        this.telemetryService.publicLog2('mergeEditor.action.remove', {
+            otherAccepted: otherAccepted,
+            isInput1: inputNumber === 1,
+        });
+    }
+    reportResetToBaseInvoked() {
+        this.telemetryService.publicLog2('mergeEditor.action.resetToBase', {});
+    }
+    reportNavigationToNextConflict() {
+        this.telemetryService.publicLog2('mergeEditor.action.goToNextConflict', {});
+    }
+    reportNavigationToPreviousConflict() {
+        this.telemetryService.publicLog2('mergeEditor.action.goToPreviousConflict', {});
+    }
+    reportConflictCounterClicked() {
+        this.telemetryService.publicLog2('mergeEditor.action.conflictCounterClicked', {});
+    }
+};
+MergeEditorTelemetry = ( __decorate([
+    ( __param(0, ITelemetryService))
+], MergeEditorTelemetry));
+
+export { MergeEditorTelemetry };

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

@@ -0,0 +1,70 @@
+import { ArrayQueue, CompareResult } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { BugIndicatingError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { observableFromEvent } from 'monaco-editor/esm/vs/base/common/observable.js';
+
+class ReentrancyBarrier {
+    constructor() {
+        this._isActive = false;
+    }
+    get isActive() {
+        return this._isActive;
+    }
+    makeExclusive(fn) {
+        return ((...args) => {
+            if (this._isActive) {
+                return;
+            }
+            this._isActive = true;
+            try {
+                return fn(...args);
+            }
+            finally {
+                this._isActive = false;
+            }
+        });
+    }
+    runExclusively(fn) {
+        if (this._isActive) {
+            return;
+        }
+        this._isActive = true;
+        try {
+            fn();
+        }
+        finally {
+            this._isActive = false;
+        }
+    }
+    runExclusivelyOrThrow(fn) {
+        if (this._isActive) {
+            throw new BugIndicatingError();
+        }
+        this._isActive = true;
+        try {
+            fn();
+        }
+        finally {
+            this._isActive = false;
+        }
+    }
+}
+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 concatArrays(...arrays) {
+    return [].concat(...arrays);
+}
+function observableConfigValue(key, defaultValue, configurationService) {
+    return observableFromEvent((handleChange) => configurationService.onDidChangeConfiguration(e => {
+        if (e.affectsConfiguration(key)) {
+            handleChange(e);
+        }
+    }), () => configurationService.getValue(key) ?? defaultValue);
+}
+
+export { ReentrancyBarrier, concatArrays, leftJoin, observableConfigValue };

package/vscode/src/vs/workbench/contrib/mergeEditor/common/mergeEditor.js

@@ -0,0 +1,3 @@
+const StorageCloseWithConflicts = 'mergeEditorCloseWithConflicts';
+
+export { StorageCloseWithConflicts };