@codingame/monaco-vscode-api 1.83.7 → 1.83.9

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

@@ -1,480 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { assertFn } from 'monaco-editor/esm/vs/base/common/assert.js';
-import { BugIndicatingError } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { observableValue, observableFromEvent, derived } from 'monaco-editor/esm/vs/base/common/observable.js';
-import { basename, isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
-import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
-import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
-import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
-import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
-import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { SaveSourceRegistry } from '../../../common/editor.js';
-import { EditorModel } from '../../../common/editor/editorModel.js';
-import { conflictMarkers } from './mergeMarkers/mergeMarkersController.js';
-import { MergeDiffComputer } from './model/diffComputer.js';
-import { MergeEditorModel } from './model/mergeEditorModel.js';
-import { StorageCloseWithConflicts } from '../common/mergeEditor.js';
-import { IEditorService } from '../../../services/editor/common/editorService.js';
-import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
-import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
-var WorkspaceMergeEditorModeFactory_1;
-let TempFileMergeEditorModeFactory = class TempFileMergeEditorModeFactory {
-    constructor(_mergeEditorTelemetry, _instantiationService, _textModelService, _modelService) {
-        this._mergeEditorTelemetry = _mergeEditorTelemetry;
-        this._instantiationService = _instantiationService;
-        this._textModelService = _textModelService;
-        this._modelService = _modelService;
-    }
-    async createInputModel(args) {
-        const store = ( new DisposableStore());
-        const [base, result, input1Data, input2Data,] = await Promise.all([
-            this._textModelService.createModelReference(args.base),
-            this._textModelService.createModelReference(args.result),
-            toInputData(args.input1, this._textModelService, store),
-            toInputData(args.input2, this._textModelService, store),
-        ]);
-        store.add(base);
-        store.add(result);
-        const tempResultUri = result.object.textEditorModel.uri.with({ scheme: 'merge-result' });
-        const temporaryResultModel = this._modelService.createModel('', {
-            languageId: result.object.textEditorModel.getLanguageId(),
-            onDidChange: Event.None,
-        }, tempResultUri);
-        store.add(temporaryResultModel);
-        const mergeDiffComputer = this._instantiationService.createInstance(MergeDiffComputer);
-        const model = this._instantiationService.createInstance(MergeEditorModel, base.object.textEditorModel, input1Data, input2Data, temporaryResultModel, mergeDiffComputer, {
-            resetResult: true,
-        }, this._mergeEditorTelemetry);
-        store.add(model);
-        await model.onInitialized;
-        return this._instantiationService.createInstance(TempFileMergeEditorInputModel, model, store, result.object, args.result);
-    }
-};
-TempFileMergeEditorModeFactory = ( __decorate([
-    ( __param(1, IInstantiationService)),
-    ( __param(2, ITextModelService)),
-    ( __param(3, IModelService))
-], TempFileMergeEditorModeFactory));
-let TempFileMergeEditorInputModel = class TempFileMergeEditorInputModel extends EditorModel {
-    constructor(model, disposable, result, resultUri, textFileService, dialogService, editorService) {
-        super();
-        this.model = model;
-        this.disposable = disposable;
-        this.result = result;
-        this.resultUri = resultUri;
-        this.textFileService = textFileService;
-        this.dialogService = dialogService;
-        this.editorService = editorService;
-        this.savedAltVersionId = observableValue(this, this.model.resultTextModel.getAlternativeVersionId());
-        this.altVersionId = observableFromEvent(e => this.model.resultTextModel.onDidChangeContent(e), () =>
-         this.model.resultTextModel.getAlternativeVersionId());
-        this.isDirty = derived(this, (reader) => this.altVersionId.read(reader) !== this.savedAltVersionId.read(reader));
-        this.finished = false;
-    }
-    dispose() {
-        this.disposable.dispose();
-        super.dispose();
-    }
-    async accept() {
-        const value = await this.model.resultTextModel.getValue();
-        this.result.textEditorModel.setValue(value);
-        this.savedAltVersionId.set(this.model.resultTextModel.getAlternativeVersionId(), undefined);
-        await this.textFileService.save(this.result.textEditorModel.uri);
-        this.finished = true;
-    }
-    async _discard() {
-        await this.textFileService.revert(this.model.resultTextModel.uri);
-        this.savedAltVersionId.set(this.model.resultTextModel.getAlternativeVersionId(), undefined);
-        this.finished = true;
-    }
-    shouldConfirmClose() {
-        return true;
-    }
-    async confirmClose(inputModels) {
-        assertFn(() => ( inputModels.some((m) => m === this)));
-        const someDirty = ( inputModels.some((m) => m.isDirty.get()));
-        let choice;
-        if (someDirty) {
-            const isMany = inputModels.length > 1;
-            const message = isMany
-                ? ( localizeWithPath(
-                'vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel',
-                'messageN',
-                'Do you want keep the merge result of {0} files?',
-                inputModels.length
-            ))
-                : ( localizeWithPath(
-                'vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel',
-                'message1',
-                'Do you want keep the merge result of {0}?',
-                basename(inputModels[0].model.resultTextModel.uri)
-            ));
-            const hasUnhandledConflicts = ( inputModels.some((m) => m.model.hasUnhandledConflicts.get()));
-            const buttons = [
-                {
-                    label: hasUnhandledConflicts ?
-                        ( localizeWithPath(
-                            'vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel',
-                            { key: 'saveWithConflict', comment: ['&& denotes a mnemonic'] },
-                            "&&Save With Conflicts"
-                        )) :
-                        ( localizeWithPath(
-                            'vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel',
-                            { key: 'save', comment: ['&& denotes a mnemonic'] },
-                            "&&Save"
-                        )),
-                    run: () => 0
-                },
-                {
-                    label: ( localizeWithPath(
-                        'vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel',
-                        { key: 'discard', comment: ['&& denotes a mnemonic'] },
-                        "Do&&n't Save"
-                    )),
-                    run: () => 1
-                }
-            ];
-            choice = (await this.dialogService.prompt({
-                type: Severity.Info,
-                message,
-                detail: hasUnhandledConflicts
-                    ? isMany
-                        ? ( localizeWithPath(
-                    'vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel',
-                    'detailNConflicts',
-                    "The files contain unhandled conflicts. The merge results will be lost if you don't save them."
-                ))
-                        : ( localizeWithPath(
-                    'vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel',
-                    'detail1Conflicts',
-                    "The file contains unhandled conflicts. The merge result will be lost if you don't save it."
-                ))
-                    : isMany
-                        ? ( localizeWithPath(
-                    'vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel',
-                    'detailN',
-                    "The merge results will be lost if you don't save them."
-                ))
-                        : ( localizeWithPath(
-                    'vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel',
-                    'detail1',
-                    "The merge result will be lost if you don't save it."
-                )),
-                buttons,
-                cancelButton: {
-                    run: () => 2
-                }
-            })).result;
-        }
-        else {
-            choice = 1 ;
-        }
-        if (choice === 0 ) {
-            await Promise.all(( inputModels.map(m => m.accept())));
-        }
-        else if (choice === 1 ) {
-            await Promise.all(( inputModels.map(m => m._discard())));
-        }
-        else ;
-        return choice;
-    }
-    async save(options) {
-        if (this.finished) {
-            return;
-        }
-        (async () => {
-            const { confirmed } = await this.dialogService.confirm({
-                message: ( localizeWithPath(
-                    'vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel',
-                    'saveTempFile.message',
-                    "Do you want to accept the merge result?"
-                )),
-                detail: ( localizeWithPath(
-                    'vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel',
-                    'saveTempFile.detail',
-                    "This will write the merge result to the original file and close the merge editor."
-                )),
-                primaryButton: ( localizeWithPath(
-                    'vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel',
-                    { key: 'acceptMerge', comment: ['&& denotes a mnemonic'] },
-                    '&&Accept Merge'
-                ))
-            });
-            if (confirmed) {
-                await this.accept();
-                const editors = this.editorService.findEditors(this.resultUri).filter(e => e.editor.typeId === 'mergeEditor.Input');
-                await this.editorService.closeEditors(editors);
-            }
-        })();
-    }
-    async revert(options) {
-    }
-};
-TempFileMergeEditorInputModel = ( __decorate([
-    ( __param(4, ITextFileService)),
-    ( __param(5, IDialogService)),
-    ( __param(6, IEditorService))
-], TempFileMergeEditorInputModel));
-let WorkspaceMergeEditorModeFactory = class WorkspaceMergeEditorModeFactory {
-    static { WorkspaceMergeEditorModeFactory_1 = this; }
-    constructor(_mergeEditorTelemetry, _instantiationService, _textModelService, textFileService) {
-        this._mergeEditorTelemetry = _mergeEditorTelemetry;
-        this._instantiationService = _instantiationService;
-        this._textModelService = _textModelService;
-        this.textFileService = textFileService;
-    }
-    static { this.FILE_SAVED_SOURCE = SaveSourceRegistry.registerSource('merge-editor.source', ( localizeWithPath(
-        'vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel',
-        'merge-editor.source',
-        "Before Resolving Conflicts In Merge Editor"
-    ))); }
-    async createInputModel(args) {
-        const store = ( new DisposableStore());
-        let resultTextFileModel = undefined;
-        const modelListener = store.add(( new DisposableStore()));
-        const handleDidCreate = (model) => {
-            if (isEqual(args.result, model.resource)) {
-                modelListener.clear();
-                resultTextFileModel = model;
-            }
-        };
-        modelListener.add(this.textFileService.files.onDidCreate(handleDidCreate));
-        this.textFileService.files.models.forEach(handleDidCreate);
-        const [base, result, input1Data, input2Data,] = await Promise.all([
-            this._textModelService.createModelReference(args.base),
-            this._textModelService.createModelReference(args.result),
-            toInputData(args.input1, this._textModelService, store),
-            toInputData(args.input2, this._textModelService, store),
-        ]);
-        store.add(base);
-        store.add(result);
-        if (!resultTextFileModel) {
-            throw new BugIndicatingError();
-        }
-        await resultTextFileModel.save({ source: WorkspaceMergeEditorModeFactory_1.FILE_SAVED_SOURCE });
-        const lines = resultTextFileModel.textEditorModel.getLinesContent();
-        const hasConflictMarkers = ( lines.some(l => l.startsWith(conflictMarkers.start)));
-        const resetResult = hasConflictMarkers;
-        const mergeDiffComputer = this._instantiationService.createInstance(MergeDiffComputer);
-        const model = this._instantiationService.createInstance(MergeEditorModel, base.object.textEditorModel, input1Data, input2Data, result.object.textEditorModel, mergeDiffComputer, {
-            resetResult
-        }, this._mergeEditorTelemetry);
-        store.add(model);
-        await model.onInitialized;
-        return this._instantiationService.createInstance(WorkspaceMergeEditorInputModel, model, store, resultTextFileModel, this._mergeEditorTelemetry);
-    }
-};
-WorkspaceMergeEditorModeFactory = WorkspaceMergeEditorModeFactory_1 = ( __decorate([
-    ( __param(1, IInstantiationService)),
-    ( __param(2, ITextModelService)),
-    ( __param(3, ITextFileService))
-], WorkspaceMergeEditorModeFactory));
-let WorkspaceMergeEditorInputModel = class WorkspaceMergeEditorInputModel extends EditorModel {
-    constructor(model, disposableStore, resultTextFileModel, telemetry, _dialogService, _storageService) {
-        super();
-        this.model = model;
-        this.disposableStore = disposableStore;
-        this.resultTextFileModel = resultTextFileModel;
-        this.telemetry = telemetry;
-        this._dialogService = _dialogService;
-        this._storageService = _storageService;
-        this.isDirty = observableFromEvent(Event.any(this.resultTextFileModel.onDidChangeDirty, this.resultTextFileModel.onDidSaveError), () =>  this.resultTextFileModel.isDirty());
-        this.reported = false;
-        this.dateTimeOpened = ( new Date());
-    }
-    dispose() {
-        this.disposableStore.dispose();
-        super.dispose();
-        this.reportClose(false);
-    }
-    reportClose(accepted) {
-        if (!this.reported) {
-            const remainingConflictCount = this.model.unhandledConflictsCount.get();
-            const durationOpenedMs = ( new Date()).getTime() - this.dateTimeOpened.getTime();
-            this.telemetry.reportMergeEditorClosed({
-                durationOpenedSecs: durationOpenedMs / 1000,
-                remainingConflictCount,
-                accepted,
-                conflictCount: this.model.conflictCount,
-                combinableConflictCount: this.model.combinableConflictCount,
-                conflictsResolvedWithBase: this.model.conflictsResolvedWithBase,
-                conflictsResolvedWithInput1: this.model.conflictsResolvedWithInput1,
-                conflictsResolvedWithInput2: this.model.conflictsResolvedWithInput2,
-                conflictsResolvedWithSmartCombination: this.model.conflictsResolvedWithSmartCombination,
-                manuallySolvedConflictCountThatEqualNone: this.model.manuallySolvedConflictCountThatEqualNone,
-                manuallySolvedConflictCountThatEqualSmartCombine: this.model.manuallySolvedConflictCountThatEqualSmartCombine,
-                manuallySolvedConflictCountThatEqualInput1: this.model.manuallySolvedConflictCountThatEqualInput1,
-                manuallySolvedConflictCountThatEqualInput2: this.model.manuallySolvedConflictCountThatEqualInput2,
-                manuallySolvedConflictCountThatEqualNoneAndStartedWithBase: this.model.manuallySolvedConflictCountThatEqualNoneAndStartedWithBase,
-                manuallySolvedConflictCountThatEqualNoneAndStartedWithInput1: this.model.manuallySolvedConflictCountThatEqualNoneAndStartedWithInput1,
-                manuallySolvedConflictCountThatEqualNoneAndStartedWithInput2: this.model.manuallySolvedConflictCountThatEqualNoneAndStartedWithInput2,
-                manuallySolvedConflictCountThatEqualNoneAndStartedWithBothNonSmart: this.model.manuallySolvedConflictCountThatEqualNoneAndStartedWithBothNonSmart,
-                manuallySolvedConflictCountThatEqualNoneAndStartedWithBothSmart: this.model.manuallySolvedConflictCountThatEqualNoneAndStartedWithBothSmart,
-            });
-            this.reported = true;
-        }
-    }
-    async accept() {
-        this.reportClose(true);
-        await this.resultTextFileModel.save();
-    }
-    get resultUri() {
-        return this.resultTextFileModel.resource;
-    }
-    async save(options) {
-        await this.resultTextFileModel.save(options);
-    }
-    async revert(options) {
-        await this.resultTextFileModel.revert(options);
-    }
-    shouldConfirmClose() {
-        return true;
-    }
-    async confirmClose(inputModels) {
-        const isMany = inputModels.length > 1;
-        const someDirty = ( inputModels.some(m => m.isDirty.get()));
-        const someUnhandledConflicts = ( inputModels.some(m => m.model.hasUnhandledConflicts.get()));
-        if (someDirty) {
-            const message = isMany
-                ? ( localizeWithPath(
-                'vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel',
-                'workspace.messageN',
-                'Do you want to save the changes you made to {0} files?',
-                inputModels.length
-            ))
-                : ( localizeWithPath(
-                'vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel',
-                'workspace.message1',
-                'Do you want to save the changes you made to {0}?',
-                basename(inputModels[0].resultUri)
-            ));
-            const { result } = await this._dialogService.prompt({
-                type: Severity.Info,
-                message,
-                detail: someUnhandledConflicts ?
-                    isMany
-                        ? ( localizeWithPath(
-                        'vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel',
-                        'workspace.detailN.unhandled',
-                        "The files contain unhandled conflicts. Your changes will be lost if you don't save them."
-                    ))
-                        : ( localizeWithPath(
-                        'vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel',
-                        'workspace.detail1.unhandled',
-                        "The file contains unhandled conflicts. Your changes will be lost if you don't save them."
-                    ))
-                    : isMany
-                        ? ( localizeWithPath(
-                    'vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel',
-                    'workspace.detailN.handled',
-                    "Your changes will be lost if you don't save them."
-                ))
-                        : ( localizeWithPath(
-                    'vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel',
-                    'workspace.detail1.handled',
-                    "Your changes will be lost if you don't save them."
-                )),
-                buttons: [
-                    {
-                        label: someUnhandledConflicts
-                            ? ( localizeWithPath(
-                            'vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel',
-                            { key: 'workspace.saveWithConflict', comment: ['&& denotes a mnemonic'] },
-                            '&&Save with Conflicts'
-                        ))
-                            : ( localizeWithPath(
-                            'vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel',
-                            { key: 'workspace.save', comment: ['&& denotes a mnemonic'] },
-                            '&&Save'
-                        )),
-                        run: () => 0
-                    },
-                    {
-                        label: ( localizeWithPath(
-                            'vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel',
-                            { key: 'workspace.doNotSave', comment: ['&& denotes a mnemonic'] },
-                            "Do&&n't Save"
-                        )),
-                        run: () => 1
-                    }
-                ],
-                cancelButton: {
-                    run: () => 2
-                }
-            });
-            return result;
-        }
-        else if (someUnhandledConflicts && !this._storageService.getBoolean(StorageCloseWithConflicts, 0 , false)) {
-            const { confirmed, checkboxChecked } = await this._dialogService.confirm({
-                message: isMany
-                    ? ( localizeWithPath(
-                    'vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel',
-                    'workspace.messageN.nonDirty',
-                    'Do you want to close {0} merge editors?',
-                    inputModels.length
-                ))
-                    : ( localizeWithPath(
-                    'vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel',
-                    'workspace.message1.nonDirty',
-                    'Do you want to close the merge editor for {0}?',
-                    basename(inputModels[0].resultUri)
-                )),
-                detail: someUnhandledConflicts ?
-                    isMany
-                        ? ( localizeWithPath(
-                        'vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel',
-                        'workspace.detailN.unhandled.nonDirty',
-                        "The files contain unhandled conflicts."
-                    ))
-                        : ( localizeWithPath(
-                        'vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel',
-                        'workspace.detail1.unhandled.nonDirty',
-                        "The file contains unhandled conflicts."
-                    ))
-                    : undefined,
-                primaryButton: someUnhandledConflicts
-                    ? ( localizeWithPath(
-                    'vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel',
-                    { key: 'workspace.closeWithConflicts', comment: ['&& denotes a mnemonic'] },
-                    '&&Close with Conflicts'
-                ))
-                    : ( localizeWithPath(
-                    'vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel',
-                    { key: 'workspace.close', comment: ['&& denotes a mnemonic'] },
-                    '&&Close'
-                )),
-                checkbox: { label: ( localizeWithPath(
-                    'vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel',
-                    'noMoreWarn',
-                    "Don't ask again"
-                )) }
-            });
-            if (checkboxChecked) {
-                this._storageService.store(StorageCloseWithConflicts, true, 0 , 0 );
-            }
-            return confirmed ? 0  : 2 ;
-        }
-        else {
-            return 0 ;
-        }
-    }
-};
-WorkspaceMergeEditorInputModel = ( __decorate([
-    ( __param(4, IDialogService)),
-    ( __param(5, IStorageService))
-], WorkspaceMergeEditorInputModel));
-async function toInputData(data, textModelService, store) {
-    const ref = await textModelService.createModelReference(data.uri);
-    store.add(ref);
-    return {
-        textModel: ref.object.textEditorModel,
-        title: data.title,
-        description: data.description,
-        detail: data.detail,
-    };
-}
-export { TempFileMergeEditorModeFactory, WorkspaceMergeEditorModeFactory };

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/mergeMarkers/mergeMarkersController.js

@@ -1,5 +0,0 @@
-const conflictMarkers = {
-    start: '<<<<<<<',
-    end: '>>>>>>>',
-};
-export { conflictMarkers };

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

@@ -1,83 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { assertFn, checkAdjacentItems } from 'monaco-editor/esm/vs/base/common/assert.js';
-import { IEditorWorkerService } from 'monaco-editor/esm/vs/editor/common/services/editorWorker.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { LineRange } from './lineRange.js';
-import { DetailedLineRangeMapping, RangeMapping } from './mapping.js';
-import { observableConfigValue } from '../utils.js';
-let MergeDiffComputer = class MergeDiffComputer {
-    constructor(editorWorkerService, configurationService) {
-        this.editorWorkerService = editorWorkerService;
-        this.configurationService = configurationService;
-        this.mergeAlgorithm = ( observableConfigValue('mergeEditor.diffAlgorithm', 'advanced', this.configurationService)
-            .map(v => v === 'smart' ? 'legacy' : v === 'experimental' ? 'advanced' : v));
-    }
-    async computeDiff(textModel1, textModel2, reader) {
-        const diffAlgorithm = this.mergeAlgorithm.read(reader);
-        const result = await this.editorWorkerService.computeDiff(textModel1.uri, textModel2.uri, {
-            ignoreTrimWhitespace: false,
-            maxComputationTimeMs: 0,
-            computeMoves: false,
-        }, diffAlgorithm);
-        if (!result) {
-            throw new Error('Diff computation failed');
-        }
-        if (textModel1.isDisposed() || textModel2.isDisposed()) {
-            return { diffs: null };
-        }
-        const changes = ( result.changes.map(c => ( new DetailedLineRangeMapping(
-            toLineRange(c.original),
-            textModel1,
-            toLineRange(c.modified),
-            textModel2,
-            c.innerChanges?.map(ic => toRangeMapping(ic))
-        ))));
-        assertFn(() => {
-            for (const c of changes) {
-                const inputRange = c.inputRange;
-                const outputRange = c.outputRange;
-                const inputTextModel = c.inputTextModel;
-                const outputTextModel = c.outputTextModel;
-                for (const map of c.rangeMappings) {
-                    let inputRangesValid = inputRange.startLineNumber - 1 <= map.inputRange.startLineNumber
-                        && map.inputRange.endLineNumber <= inputRange.endLineNumberExclusive;
-                    if (inputRangesValid && map.inputRange.startLineNumber === inputRange.startLineNumber - 1) {
-                        inputRangesValid = map.inputRange.endColumn >= inputTextModel.getLineMaxColumn(map.inputRange.startLineNumber);
-                    }
-                    if (inputRangesValid && map.inputRange.endLineNumber === inputRange.endLineNumberExclusive) {
-                        inputRangesValid = map.inputRange.endColumn === 1;
-                    }
-                    let outputRangesValid = outputRange.startLineNumber - 1 <= map.outputRange.startLineNumber
-                        && map.outputRange.endLineNumber <= outputRange.endLineNumberExclusive;
-                    if (outputRangesValid && map.outputRange.startLineNumber === outputRange.startLineNumber - 1) {
-                        outputRangesValid = map.outputRange.endColumn >= outputTextModel.getLineMaxColumn(map.outputRange.endLineNumber);
-                    }
-                    if (outputRangesValid && map.outputRange.endLineNumber === outputRange.endLineNumberExclusive) {
-                        outputRangesValid = map.outputRange.endColumn === 1;
-                    }
-                    if (!inputRangesValid || !outputRangesValid) {
-                        return false;
-                    }
-                }
-            }
-            return changes.length === 0 || (changes[0].inputRange.startLineNumber === changes[0].outputRange.startLineNumber &&
-                checkAdjacentItems(changes, (m1, m2) => m2.inputRange.startLineNumber - m1.inputRange.endLineNumberExclusive === m2.outputRange.startLineNumber - m1.outputRange.endLineNumberExclusive &&
-                    m1.inputRange.endLineNumberExclusive < m2.inputRange.startLineNumber &&
-                    m1.outputRange.endLineNumberExclusive < m2.outputRange.startLineNumber));
-        });
-        return {
-            diffs: changes
-        };
-    }
-};
-MergeDiffComputer = ( __decorate([
-    ( __param(0, IEditorWorkerService)),
-    ( __param(1, IConfigurationService))
-], MergeDiffComputer));
-function toLineRange(range) {
-    return ( new LineRange(range.startLineNumber, range.length));
-}
-function toRangeMapping(mapping) {
-    return ( new RangeMapping(mapping.originalRange, mapping.modifiedRange));
-}
-export { MergeDiffComputer, toLineRange, toRangeMapping };

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

@@ -1,54 +0,0 @@
-import { equals } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
-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 };