@codingame/monaco-vscode-extensions-service-override 1.85.0 → 1.85.2

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

@@ -1,309 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,167 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

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