@codingame/monaco-vscode-api 25.1.1 → 26.0.0

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

@@ -30,7 +30,12 @@ import { derived } from '../../../../base/common/observableInternal/observables/
 
 var WorkspaceMergeEditorModeFactory_1;
 let TempFileMergeEditorModeFactory = class TempFileMergeEditorModeFactory {
-    constructor(_mergeEditorTelemetry, _instantiationService, _textModelService, _modelService) {
+    constructor(
+        _mergeEditorTelemetry,
+        _instantiationService,
+        _textModelService,
+        _modelService
+    ) {
         this._mergeEditorTelemetry = _mergeEditorTelemetry;
         this._instantiationService = _instantiationService;
         this._textModelService = _textModelService;
@@ -38,36 +43,51 @@ let TempFileMergeEditorModeFactory = class TempFileMergeEditorModeFactory {
     }
     async createInputModel(args) {
         const store = ( new DisposableStore());
-        const [base, result, input1Data, input2Data,] = await Promise.all([
+        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),
+            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('', {
+        const tempResultUri = result.object.textEditorModel.uri.with({
+            scheme: "merge-result"
+        });
+        const temporaryResultModel = this._modelService.createModel("", {
             languageId: result.object.textEditorModel.getLanguageId(),
-            onDidChange: Event.None,
+            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);
+        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));
+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) {
+    constructor(
+        model,
+        disposable,
+        result,
+        resultUri,
+        textFileService,
+        dialogService,
+        editorService
+    ) {
         super();
         this.model = model;
         this.disposable = disposable;
@@ -77,8 +97,15 @@ let TempFileMergeEditorInputModel = class TempFileMergeEditorInputModel extends
         this.dialogService = dialogService;
         this.editorService = editorService;
         this.savedAltVersionId = observableValue(this, this.model.resultTextModel.getAlternativeVersionId());
-        this.altVersionId = observableFromEvent(this, e => this.model.resultTextModel.onDidChangeContent(e), () =>  this.model.resultTextModel.getAlternativeVersionId());
-        this.isDirty = derived(this, (reader) => this.altVersionId.read(reader) !== this.savedAltVersionId.read(reader));
+        this.altVersionId = observableFromEvent(
+            this,
+            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() {
@@ -101,67 +128,52 @@ let TempFileMergeEditorInputModel = class TempFileMergeEditorInputModel extends
         return true;
     }
     async confirmClose(inputModels) {
-        assertFn(() => ( inputModels.some((m) => m === this)));
-        const someDirty = ( inputModels.some((m) => m.isDirty.get()));
+        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
-                ? ( localize(
-                9117,
-                'Do you want keep the merge result of {0} files?',
+            const message = isMany ? ( localize(
+                9437,
+                "Do you want keep the merge result of {0} files?",
                 inputModels.length
-            ))
-                : ( localize(
-                9118,
-                'Do you want keep the merge result of {0}?',
+            )) : ( localize(
+                9438,
+                "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 ?
-                        ( localize(9119, "&&Save With Conflicts")) :
-                        ( localize(9120, "&&Save")),
-                    run: () => ConfirmResult.SAVE
-                },
-                {
-                    label: ( localize(9121, "Do&&n't Save")),
-                    run: () => ConfirmResult.DONT_SAVE
-                }
-            ];
+            const hasUnhandledConflicts = ( inputModels.some(m => m.model.hasUnhandledConflicts.get()));
+            const buttons = [{
+                label: hasUnhandledConflicts ? ( localize(9439, "&&Save With Conflicts")) : ( localize(9440, "&&Save")),
+                run: () => ConfirmResult.SAVE
+            }, {
+                label: ( localize(9441, "Do&&n't Save")),
+                run: () => ConfirmResult.DONT_SAVE
+            }];
             choice = (await this.dialogService.prompt({
                 type: Severity$1.Info,
                 message,
-                detail: hasUnhandledConflicts
-                    ? isMany
-                        ? ( localize(
-                    9122,
+                detail: hasUnhandledConflicts ? isMany ? ( localize(
+                    9442,
                     "The files contain unhandled conflicts. The merge results will be lost if you don't save them."
-                ))
-                        : ( localize(
-                    9123,
+                )) : ( localize(
+                    9443,
                     "The file contains unhandled conflicts. The merge result will be lost if you don't save it."
-                ))
-                    : isMany
-                        ? ( localize(9124, "The merge results will be lost if you don't save them."))
-                        : ( localize(9125, "The merge result will be lost if you don't save it.")),
+                )) : isMany ? ( localize(9444, "The merge results will be lost if you don't save them.")) : ( localize(9445, "The merge result will be lost if you don't save it.")),
                 buttons,
                 cancelButton: {
                     run: () => ConfirmResult.CANCEL
                 }
             })).result;
-        }
-        else {
+        } else {
             choice = ConfirmResult.DONT_SAVE;
         }
         if (choice === ConfirmResult.SAVE) {
             await Promise.all(( inputModels.map(m => m.accept())));
-        }
-        else if (choice === ConfirmResult.DONT_SAVE) {
+        } else if (choice === ConfirmResult.DONT_SAVE) {
             await Promise.all(( inputModels.map(m => m._discard())));
-        }
-        else ;
+        } else
+            ;
         return choice;
     }
     async save(options) {
@@ -169,32 +181,38 @@ let TempFileMergeEditorInputModel = class TempFileMergeEditorInputModel extends
             return;
         }
         (async () => {
-            const { confirmed } = await this.dialogService.confirm({
-                message: ( localize(9126, "Do you want to accept the merge result?")),
+            const {
+                confirmed
+            } = await this.dialogService.confirm({
+                message: ( localize(9446, "Do you want to accept the merge result?")),
                 detail: ( localize(
-                    9127,
+                    9447,
                     "This will write the merge result to the original file and close the merge editor."
                 )),
-                primaryButton: ( localize(9128, '&&Accept Merge'))
+                primaryButton: ( localize(9448, "&&Accept Merge"))
             });
             if (confirmed) {
                 await this.accept();
-                const editors = this.editorService.findEditors(this.resultUri).filter(e => e.editor.typeId === 'mergeEditor.Input');
+                const editors = this.editorService.findEditors(this.resultUri).filter(e => e.editor.typeId === "mergeEditor.Input");
                 await this.editorService.closeEditors(editors);
             }
         })();
     }
-    async revert(options) {
-    }
+    async revert(options) {}
 };
-TempFileMergeEditorInputModel = ( __decorate([
-    ( __param(4, ITextFileService)),
-    ( __param(5, IDialogService)),
-    ( __param(6, IEditorService))
-], TempFileMergeEditorInputModel));
+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, _modelService, _languageService) {
+    static {
+        WorkspaceMergeEditorModeFactory_1 = this;
+    }
+    constructor(
+        _mergeEditorTelemetry,
+        _instantiationService,
+        _textModelService,
+        textFileService,
+        _modelService,
+        _languageService
+    ) {
         this._mergeEditorTelemetry = _mergeEditorTelemetry;
         this._instantiationService = _instantiationService;
         this._textModelService = _textModelService;
@@ -202,26 +220,25 @@ let WorkspaceMergeEditorModeFactory = class WorkspaceMergeEditorModeFactory {
         this._modelService = _modelService;
         this._languageService = _languageService;
     }
-    static { this.FILE_SAVED_SOURCE = SaveSourceRegistry.registerSource('merge-editor.source', ( localize(9129, "Before Resolving Conflicts In Merge Editor"))); }
+    static {
+        this.FILE_SAVED_SOURCE = SaveSourceRegistry.registerSource("merge-editor.source", ( localize(9449, "Before Resolving Conflicts In Merge Editor")));
+    }
     async createInputModel(args) {
         const store = ( new DisposableStore());
-        let [base, result, input1Data, input2Data,] = await Promise.all([
-            this._textModelService.createModelReference(args.base).then(v => ({
-                object: v.object.textEditorModel,
-                dispose: () => v.dispose(),
-            })).catch(e => {
-                onUnexpectedError(e);
-                console.error(e);
-                return undefined;
-            }),
-            this._textModelService.createModelReference(args.result),
-            toInputData(args.input1, this._textModelService, store),
-            toInputData(args.input2, this._textModelService, store),
-        ]);
+        let [base, result, input1Data, input2Data] = await Promise.all([this._textModelService.createModelReference(args.base).then(v => ({
+            object: v.object.textEditorModel,
+            dispose: () => v.dispose()
+        })).catch(e => {
+            onUnexpectedError(e);
+            console.error(e);
+            return undefined;
+        }), this._textModelService.createModelReference(args.result), toInputData(args.input1, this._textModelService, store), toInputData(args.input2, this._textModelService, store)]);
         if (base === undefined) {
-            const tm = this._modelService.createModel('', this._languageService.createById(result.object.getLanguageId()));
+            const tm = this._modelService.createModel("", this._languageService.createById(result.object.getLanguageId()));
             base = {
-                dispose: () => { tm.dispose(); },
+                dispose: () => {
+                    tm.dispose();
+                },
                 object: tm
             };
         }
@@ -231,28 +248,46 @@ let WorkspaceMergeEditorModeFactory = class WorkspaceMergeEditorModeFactory {
         if (!resultTextFileModel) {
             throw ( new BugIndicatingError());
         }
-        await resultTextFileModel.save({ source: WorkspaceMergeEditorModeFactory_1.FILE_SAVED_SOURCE });
+        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, input1Data, input2Data, result.object.textEditorModel, mergeDiffComputer, {
-            resetResult
-        }, this._mergeEditorTelemetry);
+        const model = this._instantiationService.createInstance(
+            MergeEditorModel,
+            base.object,
+            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);
+        return this._instantiationService.createInstance(
+            WorkspaceMergeEditorInputModel,
+            model,
+            store,
+            resultTextFileModel,
+            this._mergeEditorTelemetry
+        );
     }
 };
-WorkspaceMergeEditorModeFactory = WorkspaceMergeEditorModeFactory_1 = ( __decorate([
-    ( __param(1, IInstantiationService)),
-    ( __param(2, ITextModelService)),
-    ( __param(3, ITextFileService)),
-    ( __param(4, IModelService)),
-    ( __param(5, ILanguageService))
-], WorkspaceMergeEditorModeFactory));
+WorkspaceMergeEditorModeFactory = WorkspaceMergeEditorModeFactory_1 = ( __decorate([( __param(1, IInstantiationService)), ( __param(2, ITextModelService)), ( __param(3, ITextFileService)), ( __param(4, IModelService)), ( __param(5, ILanguageService))], WorkspaceMergeEditorModeFactory));
 let WorkspaceMergeEditorInputModel = class WorkspaceMergeEditorInputModel extends EditorModel {
-    constructor(model, disposableStore, resultTextFileModel, telemetry, _dialogService, _storageService) {
+    constructor(
+        model,
+        disposableStore,
+        resultTextFileModel,
+        telemetry,
+        _dialogService,
+        _storageService
+    ) {
         super();
         this.model = model;
         this.disposableStore = disposableStore;
@@ -260,7 +295,10 @@ let WorkspaceMergeEditorInputModel = class WorkspaceMergeEditorInputModel extend
         this.telemetry = telemetry;
         this._dialogService = _dialogService;
         this._storageService = _storageService;
-        this.isDirty = observableFromEvent(this, Event.any(this.resultTextFileModel.onDidChangeDirty, this.resultTextFileModel.onDidSaveError), () =>  this.resultTextFileModel.isDirty());
+        this.isDirty = observableFromEvent(this, Event.any(
+            this.resultTextFileModel.onDidChangeDirty,
+            this.resultTextFileModel.onDidSaveError
+        ), () =>  this.resultTextFileModel.isDirty());
         this.reported = false;
         this.dateTimeOpened = ( new Date());
     }
@@ -291,7 +329,7 @@ let WorkspaceMergeEditorInputModel = class WorkspaceMergeEditorInputModel extend
                 manuallySolvedConflictCountThatEqualNoneAndStartedWithInput1: this.model.manuallySolvedConflictCountThatEqualNoneAndStartedWithInput1,
                 manuallySolvedConflictCountThatEqualNoneAndStartedWithInput2: this.model.manuallySolvedConflictCountThatEqualNoneAndStartedWithInput2,
                 manuallySolvedConflictCountThatEqualNoneAndStartedWithBothNonSmart: this.model.manuallySolvedConflictCountThatEqualNoneAndStartedWithBothNonSmart,
-                manuallySolvedConflictCountThatEqualNoneAndStartedWithBothSmart: this.model.manuallySolvedConflictCountThatEqualNoneAndStartedWithBothSmart,
+                manuallySolvedConflictCountThatEqualNoneAndStartedWithBothSmart: this.model.manuallySolvedConflictCountThatEqualNoneAndStartedWithBothSmart
             });
             this.reported = true;
         }
@@ -317,84 +355,65 @@ let WorkspaceMergeEditorInputModel = class WorkspaceMergeEditorInputModel extend
         const someDirty = ( inputModels.some(m => m.isDirty.get()));
         const someUnhandledConflicts = ( inputModels.some(m => m.model.hasUnhandledConflicts.get()));
         if (someDirty) {
-            const message = isMany
-                ? ( localize(
-                9130,
-                'Do you want to save the changes you made to {0} files?',
+            const message = isMany ? ( localize(
+                9450,
+                "Do you want to save the changes you made to {0} files?",
                 inputModels.length
-            ))
-                : ( localize(
-                9131,
-                'Do you want to save the changes you made to {0}?',
+            )) : ( localize(
+                9451,
+                "Do you want to save the changes you made to {0}?",
                 basename(inputModels[0].resultUri)
             ));
-            const { result } = await this._dialogService.prompt({
+            const {
+                result
+            } = await this._dialogService.prompt({
                 type: Severity$1.Info,
                 message,
-                detail: someUnhandledConflicts ?
-                    isMany
-                        ? ( localize(
-                        9132,
-                        "The files contain unhandled conflicts. Your changes will be lost if you don't save them."
-                    ))
-                        : ( localize(
-                        9133,
-                        "The file contains unhandled conflicts. Your changes will be lost if you don't save them."
-                    ))
-                    : isMany
-                        ? ( localize(9134, "Your changes will be lost if you don't save them."))
-                        : ( localize(9135, "Your changes will be lost if you don't save them.")),
-                buttons: [
-                    {
-                        label: someUnhandledConflicts
-                            ? ( localize(9136, '&&Save with Conflicts'))
-                            : ( localize(9137, '&&Save')),
-                        run: () => ConfirmResult.SAVE
-                    },
-                    {
-                        label: ( localize(9138, "Do&&n't Save")),
-                        run: () => ConfirmResult.DONT_SAVE
-                    }
-                ],
+                detail: someUnhandledConflicts ? isMany ? ( localize(
+                    9452,
+                    "The files contain unhandled conflicts. Your changes will be lost if you don't save them."
+                )) : ( localize(
+                    9453,
+                    "The file contains unhandled conflicts. Your changes will be lost if you don't save them."
+                )) : isMany ? ( localize(9454, "Your changes will be lost if you don't save them.")) : ( localize(9455, "Your changes will be lost if you don't save them.")),
+                buttons: [{
+                    label: someUnhandledConflicts ? ( localize(9456, "&&Save with Conflicts")) : ( localize(9457, "&&Save")),
+                    run: () => ConfirmResult.SAVE
+                }, {
+                    label: ( localize(9458, "Do&&n't Save")),
+                    run: () => ConfirmResult.DONT_SAVE
+                }],
                 cancelButton: {
                     run: () => ConfirmResult.CANCEL
                 }
             });
             return result;
-        }
-        else if (someUnhandledConflicts && !this._storageService.getBoolean(StorageCloseWithConflicts, StorageScope.PROFILE, false)) {
-            const { confirmed, checkboxChecked } = await this._dialogService.confirm({
-                message: isMany
-                    ? ( localize(9139, 'Do you want to close {0} merge editors?', inputModels.length))
-                    : ( localize(
-                    9140,
-                    'Do you want to close the merge editor for {0}?',
+        } else if (someUnhandledConflicts && !this._storageService.getBoolean(StorageCloseWithConflicts, StorageScope.PROFILE, false)) {
+            const {
+                confirmed,
+                checkboxChecked
+            } = await this._dialogService.confirm({
+                message: isMany ? ( localize(9459, "Do you want to close {0} merge editors?", inputModels.length)) : ( localize(
+                    9460,
+                    "Do you want to close the merge editor for {0}?",
                     basename(inputModels[0].resultUri)
                 )),
-                detail: someUnhandledConflicts ?
-                    isMany
-                        ? ( localize(9141, "The files contain unhandled conflicts."))
-                        : ( localize(9142, "The file contains unhandled conflicts."))
-                    : undefined,
-                primaryButton: someUnhandledConflicts
-                    ? ( localize(9143, '&&Close with Conflicts'))
-                    : ( localize(9144, '&&Close')),
-                checkbox: { label: ( localize(9145, "Do not ask me again")) }
+                detail: someUnhandledConflicts ? isMany ? ( localize(9461, "The files contain unhandled conflicts.")) : ( localize(9462, "The file contains unhandled conflicts.")) : undefined,
+                primaryButton: someUnhandledConflicts ? ( localize(9463, "&&Close with Conflicts")) : ( localize(9464, "&&Close")),
+                checkbox: {
+                    label: ( localize(9465, "Do not ask me again"))
+                }
             });
             if (checkboxChecked) {
                 this._storageService.store(StorageCloseWithConflicts, true, StorageScope.PROFILE, StorageTarget.USER);
             }
             return confirmed ? ConfirmResult.SAVE : ConfirmResult.CANCEL;
-        }
-        else {
+        } else {
             return ConfirmResult.SAVE;
         }
     }
 };
-WorkspaceMergeEditorInputModel = ( __decorate([
-    ( __param(4, IDialogService)),
-    ( __param(5, IStorageService))
-], WorkspaceMergeEditorInputModel));
+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);
@@ -402,7 +421,7 @@ async function toInputData(data, textModelService, store) {
         textModel: ref.object.textEditorModel,
         title: data.title,
         description: data.description,
-        detail: data.detail,
+        detail: data.detail
     };
 }
 

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

@@ -7,6 +7,6 @@ import '../../../../../editor/common/core/ranges/lineRange.js';
 import '../../../../../nls.js';
 
 const conflictMarkers = {
-    start: '<<<<<<<'};
+    start: "<<<<<<<"};
 
 export { conflictMarkers };

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

@@ -11,8 +11,7 @@ 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));
+        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);
@@ -21,13 +20,15 @@ let MergeDiffComputer = class MergeDiffComputer {
         const result = await this.editorWorkerService.computeDiff(textModel1.uri, textModel2.uri, {
             ignoreTrimWhitespace: false,
             maxComputationTimeMs: 0,
-            computeMoves: false,
+            computeMoves: false
         }, diffAlgorithm);
         if (!result) {
-            throw ( new Error('Diff computation failed'));
+            throw ( new Error("Diff computation failed"));
         }
         if (textModel1.isDisposed() || textModel2.isDisposed()) {
-            return { diffs: null };
+            return {
+                diffs: null
+            };
         }
         const changes = ( result.changes.map(c => ( new DetailedLineRangeMapping(
             toLineRange(c.original),
@@ -39,23 +40,23 @@ let MergeDiffComputer = class MergeDiffComputer {
         const newInputVersion = textModel1.getVersionId();
         const newOutputVersion = textModel2.getVersionId();
         if (inputVersion !== newInputVersion || outputVersion !== newOutputVersion) {
-            return { diffs: null };
+            return {
+                diffs: null
+            };
         }
         assertFn(() => {
-            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 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));
+MergeDiffComputer = ( __decorate([( __param(0, IEditorWorkerService)), ( __param(1, IConfigurationService))], MergeDiffComputer));
 function toLineRange(range) {
     return MergeEditorLineRange.fromLength(range.startLineNumber, range.length);
 }

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

@@ -28,17 +28,17 @@ class LineEdits {
         this.edits = edits;
     }
     toEdits(modelLineCount) {
-        return ( this.edits.map((e) => {
+        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(''),
+                    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'),
+                    text: e.newLines.join("\n")
                 };
             }
             return {
@@ -48,7 +48,7 @@ class LineEdits {
                     modelLineCount,
                     Number.MAX_SAFE_INTEGER
                 )),
-                text: ( e.newLines.map(s => '\n' + s)).join(''),
+                text: ( e.newLines.map(s => "\n" + s)).join("")
             };
         }));
     }

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

@@ -11,7 +11,10 @@ class MergeEditorLineRange extends LineRange {
         return ( new MergeEditorLineRange(startLineNumber, startLineNumber + length));
     }
     join(other) {
-        return MergeEditorLineRange.fromLineNumbers(Math.min(this.startLineNumber, other.startLineNumber), Math.max(this.endLineNumberExclusive, other.endLineNumberExclusive));
+        return MergeEditorLineRange.fromLineNumbers(
+            Math.min(this.startLineNumber, other.startLineNumber),
+            Math.max(this.endLineNumberExclusive, other.endLineNumberExclusive)
+        );
     }
     isAfter(range) {
         return this.startLineNumber >= range.endLineNumberExclusive;