@codingame/monaco-vscode-api 1.83.15-next.0 → 1.83.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-api",
-  "version": "1.83.15-next.0",
+  "version": "1.83.15",
   "description": "VSCode public API plugged on the monaco editor",
   "keywords": [],
   "author": {
@@ -100,10 +100,10 @@
   "dependencies": {
     "monaco-editor": "0.44.0",
     "vscode-semver": "npm:semver@=5.5.0",
-    "@codingame/monaco-vscode-extensions-service-override": "1.83.15-next.0",
-    "@codingame/monaco-vscode-files-service-override": "1.83.15-next.0",
-    "@codingame/monaco-vscode-layout-service-override": "1.83.15-next.0",
-    "@codingame/monaco-vscode-environment-service-override": "1.83.15-next.0",
-    "@codingame/monaco-vscode-quickaccess-service-override": "1.83.15-next.0"
+    "@codingame/monaco-vscode-files-service-override": "1.83.15",
+    "@codingame/monaco-vscode-layout-service-override": "1.83.15",
+    "@codingame/monaco-vscode-environment-service-override": "1.83.15",
+    "@codingame/monaco-vscode-extensions-service-override": "1.83.15",
+    "@codingame/monaco-vscode-quickaccess-service-override": "1.83.15"
   }
 }

package/vscode/src/vs/workbench/contrib/scm/browser/dirtydiffDecorator.js

@@ -1,12 +1,18 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import * as nls from 'monaco-editor/esm/vs/nls.js';
 import './media/dirtydiffDecorator.css.js';
-import { Disposable, DisposableStore, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { ThrottledDelayer } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Disposable, DisposableStore, toDisposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.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 { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ISCMService } from '../common/scm.js';
+import { ModelDecorationOptions } from 'monaco-editor/esm/vs/editor/common/model/textModel.js';
+import { IThemeService, themeColorFromId } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
 import { registerColor, editorErrorForeground, transparent } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { isCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
 import { registerEditorAction, registerEditorContribution, EditorAction } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
 import { getOuterEditor, PeekViewWidget, peekViewBorder, peekViewTitleBackground, peekViewTitleForeground, peekViewTitleInfoForeground } from 'monaco-editor/esm/vs/editor/contrib/peekView/browser/peekView.js';
 import { ContextKeyExpr, RawContextKey, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
@@ -20,17 +26,25 @@ import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/com
 import { basename } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { MenuRegistry, MenuId, IMenuService, MenuItemAction } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
 import { createAndFillInActionBarActions } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+import { shouldSynchronizeModel, OverviewRulerLane, MinimapPosition } from 'monaco-editor/esm/vs/editor/common/model.js';
+import { sortedDiff, equals } from 'monaco-editor/esm/vs/base/common/arrays.js';
 import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
 import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { isTextFileEditorModel, ITextFileService } from '../../../services/textfile/common/textfiles.js';
 import { gotoPreviousLocation, gotoNextLocation } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
 import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
 import { TextCompareEditorActiveContext } from '../../../common/contextkeys.js';
+import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
 import { Color } from 'monaco-editor/esm/vs/base/common/color.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
 import { IAudioCueService, AudioCue } from 'monaco-editor/esm/vs/platform/audioCues/browser/audioCueService.js';
 import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
+import { IQuickDiffService } from '../common/quickDiff.js';
 import { SwitchQuickDiffViewItem, SwitchQuickDiffBaseAction } from './dirtyDiffSwitcher.js';
-var DirtyDiffController_1;
+var DirtyDiffController_1, DirtyDiffDecorator_1;
 class DiffActionRunner extends ActionRunner {
     runAction(action, context) {
         if (action instanceof MenuItemAction) {
@@ -872,7 +886,7 @@ const editorGutterDeletedBackground = registerColor('editorGutter.deletedBackgro
     'editorGutterDeletedBackground',
     "Editor gutter background color for lines that are deleted."
 )));
-registerColor('minimapGutter.modifiedBackground', {
+const minimapGutterModifiedBackground = registerColor('minimapGutter.modifiedBackground', {
     dark: editorGutterModifiedBackground,
     light: editorGutterModifiedBackground,
     hcDark: editorGutterModifiedBackground,
@@ -882,7 +896,7 @@ registerColor('minimapGutter.modifiedBackground', {
     'minimapGutterModifiedBackground',
     "Minimap gutter background color for lines that are modified."
 )));
-registerColor('minimapGutter.addedBackground', {
+const minimapGutterAddedBackground = registerColor('minimapGutter.addedBackground', {
     dark: editorGutterAddedBackground,
     light: editorGutterAddedBackground,
     hcDark: editorGutterAddedBackground,
@@ -892,7 +906,7 @@ registerColor('minimapGutter.addedBackground', {
     'minimapGutterAddedBackground',
     "Minimap gutter background color for lines that are added."
 )));
-registerColor('minimapGutter.deletedBackground', {
+const minimapGutterDeletedBackground = registerColor('minimapGutter.deletedBackground', {
     dark: editorGutterDeletedBackground,
     light: editorGutterDeletedBackground,
     hcDark: editorGutterDeletedBackground,
@@ -902,24 +916,563 @@ registerColor('minimapGutter.deletedBackground', {
     'minimapGutterDeletedBackground',
     "Minimap gutter background color for lines that are deleted."
 )));
-registerColor('editorOverviewRuler.modifiedForeground', { dark: ( transparent(editorGutterModifiedBackground, 0.6)), light: ( transparent(editorGutterModifiedBackground, 0.6)), hcDark: ( transparent(editorGutterModifiedBackground, 0.6)), hcLight: ( transparent(editorGutterModifiedBackground, 0.6)) }, ( nls.localizeWithPath(
+const overviewRulerModifiedForeground = registerColor('editorOverviewRuler.modifiedForeground', { dark: ( transparent(editorGutterModifiedBackground, 0.6)), light: ( transparent(editorGutterModifiedBackground, 0.6)), hcDark: ( transparent(editorGutterModifiedBackground, 0.6)), hcLight: ( transparent(editorGutterModifiedBackground, 0.6)) }, ( nls.localizeWithPath(
     'vs/workbench/contrib/scm/browser/dirtydiffDecorator',
     'overviewRulerModifiedForeground',
     'Overview ruler marker color for modified content.'
 )));
-registerColor('editorOverviewRuler.addedForeground', { dark: ( transparent(editorGutterAddedBackground, 0.6)), light: ( transparent(editorGutterAddedBackground, 0.6)), hcDark: ( transparent(editorGutterAddedBackground, 0.6)), hcLight: ( transparent(editorGutterAddedBackground, 0.6)) }, ( nls.localizeWithPath(
+const overviewRulerAddedForeground = registerColor('editorOverviewRuler.addedForeground', { dark: ( transparent(editorGutterAddedBackground, 0.6)), light: ( transparent(editorGutterAddedBackground, 0.6)), hcDark: ( transparent(editorGutterAddedBackground, 0.6)), hcLight: ( transparent(editorGutterAddedBackground, 0.6)) }, ( nls.localizeWithPath(
     'vs/workbench/contrib/scm/browser/dirtydiffDecorator',
     'overviewRulerAddedForeground',
     'Overview ruler marker color for added content.'
 )));
-registerColor('editorOverviewRuler.deletedForeground', { dark: ( transparent(editorGutterDeletedBackground, 0.6)), light: ( transparent(editorGutterDeletedBackground, 0.6)), hcDark: ( transparent(editorGutterDeletedBackground, 0.6)), hcLight: ( transparent(editorGutterDeletedBackground, 0.6)) }, ( nls.localizeWithPath(
+const overviewRulerDeletedForeground = registerColor('editorOverviewRuler.deletedForeground', { dark: ( transparent(editorGutterDeletedBackground, 0.6)), light: ( transparent(editorGutterDeletedBackground, 0.6)), hcDark: ( transparent(editorGutterDeletedBackground, 0.6)), hcLight: ( transparent(editorGutterDeletedBackground, 0.6)) }, ( nls.localizeWithPath(
     'vs/workbench/contrib/scm/browser/dirtydiffDecorator',
     'overviewRulerDeletedForeground',
     'Overview ruler marker color for deleted content.'
 )));
+let DirtyDiffDecorator = DirtyDiffDecorator_1 = class DirtyDiffDecorator extends Disposable {
+    static createDecoration(className, options) {
+        const decorationOptions = {
+            description: 'dirty-diff-decoration',
+            isWholeLine: options.isWholeLine,
+        };
+        if (options.gutter) {
+            decorationOptions.linesDecorationsClassName = `dirty-diff-glyph ${className}`;
+        }
+        if (options.overview.active) {
+            decorationOptions.overviewRuler = {
+                color: themeColorFromId(options.overview.color),
+                position: OverviewRulerLane.Left
+            };
+        }
+        if (options.minimap.active) {
+            decorationOptions.minimap = {
+                color: themeColorFromId(options.minimap.color),
+                position: MinimapPosition.Gutter
+            };
+        }
+        return ModelDecorationOptions.createDynamic(decorationOptions);
+    }
+    constructor(editorModel, codeEditor, model, configurationService) {
+        super();
+        this.codeEditor = codeEditor;
+        this.model = model;
+        this.configurationService = configurationService;
+        this.editorModel = editorModel;
+        const decorations = configurationService.getValue('scm.diffDecorations');
+        const gutter = decorations === 'all' || decorations === 'gutter';
+        const overview = decorations === 'all' || decorations === 'overview';
+        const minimap = decorations === 'all' || decorations === 'minimap';
+        this.addedOptions = DirtyDiffDecorator_1.createDecoration('dirty-diff-added', {
+            gutter,
+            overview: { active: overview, color: overviewRulerAddedForeground },
+            minimap: { active: minimap, color: minimapGutterAddedBackground },
+            isWholeLine: true
+        });
+        this.addedPatternOptions = DirtyDiffDecorator_1.createDecoration('dirty-diff-added-pattern', {
+            gutter,
+            overview: { active: overview, color: overviewRulerAddedForeground },
+            minimap: { active: minimap, color: minimapGutterAddedBackground },
+            isWholeLine: true
+        });
+        this.modifiedOptions = DirtyDiffDecorator_1.createDecoration('dirty-diff-modified', {
+            gutter,
+            overview: { active: overview, color: overviewRulerModifiedForeground },
+            minimap: { active: minimap, color: minimapGutterModifiedBackground },
+            isWholeLine: true
+        });
+        this.modifiedPatternOptions = DirtyDiffDecorator_1.createDecoration('dirty-diff-modified-pattern', {
+            gutter,
+            overview: { active: overview, color: overviewRulerModifiedForeground },
+            minimap: { active: minimap, color: minimapGutterModifiedBackground },
+            isWholeLine: true
+        });
+        this.deletedOptions = DirtyDiffDecorator_1.createDecoration('dirty-diff-deleted', {
+            gutter,
+            overview: { active: overview, color: overviewRulerDeletedForeground },
+            minimap: { active: minimap, color: minimapGutterDeletedBackground },
+            isWholeLine: false
+        });
+        this._register(configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('scm.diffDecorationsGutterPattern')) {
+                this.onDidChange();
+            }
+        }));
+        this._register(model.onDidChange(this.onDidChange, this));
+    }
+    onDidChange() {
+        if (!this.editorModel) {
+            return;
+        }
+        const pattern = this.configurationService.getValue('scm.diffDecorationsGutterPattern');
+        const decorations = ( this.model.changes.map((labeledChange) => {
+            const change = labeledChange.change;
+            const changeType = getChangeType(change);
+            const startLineNumber = change.modifiedStartLineNumber;
+            const endLineNumber = change.modifiedEndLineNumber || startLineNumber;
+            switch (changeType) {
+                case ChangeType.Add:
+                    return {
+                        range: {
+                            startLineNumber: startLineNumber, startColumn: 1,
+                            endLineNumber: endLineNumber, endColumn: 1
+                        },
+                        options: pattern.added ? this.addedPatternOptions : this.addedOptions
+                    };
+                case ChangeType.Delete:
+                    return {
+                        range: {
+                            startLineNumber: startLineNumber, startColumn: Number.MAX_VALUE,
+                            endLineNumber: startLineNumber, endColumn: Number.MAX_VALUE
+                        },
+                        options: this.deletedOptions
+                    };
+                case ChangeType.Modify:
+                    return {
+                        range: {
+                            startLineNumber: startLineNumber, startColumn: 1,
+                            endLineNumber: endLineNumber, endColumn: 1
+                        },
+                        options: pattern.modified ? this.modifiedPatternOptions : this.modifiedOptions
+                    };
+            }
+        }));
+        if (!this.decorationsCollection) {
+            this.decorationsCollection = this.codeEditor.createDecorationsCollection(decorations);
+        }
+        else {
+            this.decorationsCollection.set(decorations);
+        }
+    }
+    dispose() {
+        super.dispose();
+        if (this.decorationsCollection) {
+            this.decorationsCollection?.clear();
+        }
+        this.editorModel = null;
+        this.decorationsCollection = undefined;
+    }
+};
+DirtyDiffDecorator = DirtyDiffDecorator_1 = ( __decorate([
+    ( __param(3, IConfigurationService))
+], DirtyDiffDecorator));
+function compareChanges(a, b) {
+    let result = a.modifiedStartLineNumber - b.modifiedStartLineNumber;
+    if (result !== 0) {
+        return result;
+    }
+    result = a.modifiedEndLineNumber - b.modifiedEndLineNumber;
+    if (result !== 0) {
+        return result;
+    }
+    result = a.originalStartLineNumber - b.originalStartLineNumber;
+    if (result !== 0) {
+        return result;
+    }
+    return a.originalEndLineNumber - b.originalEndLineNumber;
+}
 async function getOriginalResource(quickDiffService, uri, language, isSynchronized) {
     const quickDiffs = await quickDiffService.getQuickDiffs(uri, language, isSynchronized);
     return quickDiffs.length > 0 ? quickDiffs[0].originalResource : null;
 }
+let DirtyDiffModel = class DirtyDiffModel extends Disposable {
+    get original() { return this._originalTextModels; }
+    get changes() { return this._changes; }
+    get mapChanges() { return this._mapChanges; }
+    constructor(textFileModel, scmService, quickDiffService, editorWorkerService, configurationService, textModelResolverService, progressService) {
+        super();
+        this.scmService = scmService;
+        this.quickDiffService = quickDiffService;
+        this.editorWorkerService = editorWorkerService;
+        this.configurationService = configurationService;
+        this.textModelResolverService = textModelResolverService;
+        this.progressService = progressService;
+        this._quickDiffs = [];
+        this._originalModels = ( new Map());
+        this._originalTextModels = [];
+        this.diffDelayer = ( new ThrottledDelayer(200));
+        this.repositoryDisposables = ( new Set());
+        this.originalModelDisposables = this._register(( new DisposableStore()));
+        this._disposed = false;
+        this._onDidChange = ( new Emitter());
+        this.onDidChange = this._onDidChange.event;
+        this._changes = [];
+        this._mapChanges = ( new Map());
+        this._model = textFileModel;
+        this._register(textFileModel.textEditorModel.onDidChangeContent(() => this.triggerDiff()));
+        this._register(Event.filter(configurationService.onDidChangeConfiguration, e => e.affectsConfiguration('scm.diffDecorationsIgnoreTrimWhitespace') || e.affectsConfiguration('diffEditor.ignoreTrimWhitespace'))(this.triggerDiff, this));
+        this._register(scmService.onDidAddRepository(this.onDidAddRepository, this));
+        for (const r of scmService.repositories) {
+            this.onDidAddRepository(r);
+        }
+        this._register(this._model.onDidChangeEncoding(() => {
+            this.diffDelayer.cancel();
+            this._quickDiffs = [];
+            this._originalModels.clear();
+            this._originalTextModels = [];
+            this._quickDiffsPromise = undefined;
+            this.setChanges([], ( new Map()));
+            this.triggerDiff();
+        }));
+        this._register(this.quickDiffService.onDidChangeQuickDiffProviders(() => this.triggerDiff()));
+        this.triggerDiff();
+    }
+    get quickDiffs() {
+        return this._quickDiffs;
+    }
+    getDiffEditorModel(originalUri) {
+        if (!( this._originalModels.has(originalUri))) {
+            return;
+        }
+        const original = this._originalModels.get(originalUri);
+        return {
+            modified: this._model.textEditorModel,
+            original: original.textEditorModel
+        };
+    }
+    onDidAddRepository(repository) {
+        const disposables = ( new DisposableStore());
+        this.repositoryDisposables.add(disposables);
+        disposables.add(toDisposable(() => this.repositoryDisposables.delete(disposables)));
+        const onDidChange = Event.any(repository.provider.onDidChange, repository.provider.onDidChangeResources);
+        disposables.add(onDidChange(this.triggerDiff, this));
+        const onDidRemoveThis = Event.filter(this.scmService.onDidRemoveRepository, r => r === repository);
+        disposables.add(onDidRemoveThis(() => dispose(disposables), null));
+        this.triggerDiff();
+    }
+    triggerDiff() {
+        if (!this.diffDelayer) {
+            return Promise.resolve(null);
+        }
+        return this.diffDelayer
+            .trigger(() => this.diff())
+            .then((result) => {
+            const originalModels = Array.from(( this._originalModels.values()));
+            if (!result || this._disposed || this._model.isDisposed() || ( originalModels.some(originalModel => originalModel.isDisposed()))) {
+                return;
+            }
+            if (originalModels.every(originalModel => originalModel.textEditorModel.getValueLength() === 0)) {
+                result.changes = [];
+            }
+            if (!result.changes) {
+                result.changes = [];
+            }
+            this.setChanges(result.changes, result.mapChanges);
+        }, (err) => onUnexpectedError(err));
+    }
+    setChanges(changes, mapChanges) {
+        const diff = sortedDiff(this._changes, changes, (a, b) => compareChanges(a.change, b.change));
+        this._changes = changes;
+        this._mapChanges = mapChanges;
+        this._onDidChange.fire({ changes, diff });
+    }
+    diff() {
+        return this.progressService.withProgress({ location: 3 , delay: 250 }, async () => {
+            const originalURIs = await this.getQuickDiffsPromise();
+            if (this._disposed || this._model.isDisposed() || (originalURIs.length === 0)) {
+                return Promise.resolve({ changes: [], mapChanges: ( new Map()) });
+            }
+            const filteredToDiffable = originalURIs.filter(quickDiff => this.editorWorkerService.canComputeDirtyDiff(quickDiff.originalResource, this._model.resource));
+            if (filteredToDiffable.length === 0) {
+                return Promise.resolve({ changes: [], mapChanges: ( new Map()) });
+            }
+            const ignoreTrimWhitespaceSetting = this.configurationService.getValue('scm.diffDecorationsIgnoreTrimWhitespace');
+            const ignoreTrimWhitespace = ignoreTrimWhitespaceSetting === 'inherit'
+                ? this.configurationService.getValue('diffEditor.ignoreTrimWhitespace')
+                : ignoreTrimWhitespaceSetting !== 'false';
+            const allDiffs = [];
+            for (const quickDiff of filteredToDiffable) {
+                const dirtyDiff = await this.editorWorkerService.computeDirtyDiff(quickDiff.originalResource, this._model.resource, ignoreTrimWhitespace);
+                if (dirtyDiff) {
+                    for (const diff of dirtyDiff) {
+                        if (diff) {
+                            allDiffs.push({ change: diff, label: quickDiff.label, uri: quickDiff.originalResource });
+                        }
+                    }
+                }
+            }
+            const sorted = allDiffs.sort((a, b) => compareChanges(a.change, b.change));
+            const map = ( new Map());
+            for (let i = 0; i < sorted.length; i++) {
+                const label = sorted[i].label;
+                if (!( map.has(label))) {
+                    map.set(label, []);
+                }
+                map.get(label).push(i);
+            }
+            return { changes: sorted, mapChanges: map };
+        });
+    }
+    getQuickDiffsPromise() {
+        if (this._quickDiffsPromise) {
+            return this._quickDiffsPromise;
+        }
+        this._quickDiffsPromise = this.getOriginalResource().then(async (quickDiffs) => {
+            if (this._disposed) {
+                return [];
+            }
+            if (quickDiffs.length === 0) {
+                this._quickDiffs = [];
+                this._originalModels.clear();
+                this._originalTextModels = [];
+                return [];
+            }
+            if (equals(this._quickDiffs, quickDiffs, (a, b) => ( a.originalResource.toString()) === ( b.originalResource.toString()) && a.label === b.label)) {
+                return quickDiffs;
+            }
+            this.originalModelDisposables.clear();
+            this._originalModels.clear();
+            this._originalTextModels = [];
+            this._quickDiffs = quickDiffs;
+            return (await Promise.all(( quickDiffs.map(async (quickDiff) => {
+                try {
+                    const ref = await this.textModelResolverService.createModelReference(quickDiff.originalResource);
+                    if (this._disposed) {
+                        ref.dispose();
+                        return [];
+                    }
+                    this._originalModels.set(( quickDiff.originalResource.toString()), ref.object);
+                    this._originalTextModels.push(ref.object.textEditorModel);
+                    if (isTextFileEditorModel(ref.object)) {
+                        const encoding = this._model.getEncoding();
+                        if (encoding) {
+                            ref.object.setEncoding(encoding, 1 );
+                        }
+                    }
+                    this.originalModelDisposables.add(ref);
+                    this.originalModelDisposables.add(ref.object.textEditorModel.onDidChangeContent(() => this.triggerDiff()));
+                    return quickDiff;
+                }
+                catch (error) {
+                    return [];
+                }
+            })))).flat();
+        });
+        return this._quickDiffsPromise.finally(() => {
+            this._quickDiffsPromise = undefined;
+        });
+    }
+    async getOriginalResource() {
+        if (this._disposed) {
+            return Promise.resolve([]);
+        }
+        const uri = this._model.resource;
+        return this.quickDiffService.getQuickDiffs(uri, this._model.getLanguageId(), this._model.textEditorModel ? shouldSynchronizeModel(this._model.textEditorModel) : undefined);
+    }
+    findNextClosestChange(lineNumber, inclusive = true, provider) {
+        let preferredProvider;
+        if (!provider && inclusive) {
+            preferredProvider = this.quickDiffs.find(value => value.isSCM)?.label;
+        }
+        const possibleChanges = [];
+        for (let i = 0; i < this.changes.length; i++) {
+            if (provider && this.changes[i].label !== provider) {
+                continue;
+            }
+            const change = this.changes[i];
+            const possibleChangesLength = possibleChanges.length;
+            if (inclusive) {
+                if (getModifiedEndLineNumber(change.change) >= lineNumber) {
+                    if (preferredProvider && change.label !== preferredProvider) {
+                        possibleChanges.push(i);
+                    }
+                    else {
+                        return i;
+                    }
+                }
+            }
+            else {
+                if (change.change.modifiedStartLineNumber > lineNumber) {
+                    return i;
+                }
+            }
+            if ((possibleChanges.length > 0) && (possibleChanges.length === possibleChangesLength)) {
+                return possibleChanges[0];
+            }
+        }
+        return possibleChanges.length > 0 ? possibleChanges[0] : 0;
+    }
+    findPreviousClosestChange(lineNumber, inclusive = true, provider) {
+        for (let i = this.changes.length - 1; i >= 0; i--) {
+            if (provider && this.changes[i].label !== provider) {
+                continue;
+            }
+            const change = this.changes[i].change;
+            if (inclusive) {
+                if (change.modifiedStartLineNumber <= lineNumber) {
+                    return i;
+                }
+            }
+            else {
+                if (getModifiedEndLineNumber(change) < lineNumber) {
+                    return i;
+                }
+            }
+        }
+        return this.changes.length - 1;
+    }
+    dispose() {
+        super.dispose();
+        this._disposed = true;
+        this._quickDiffs = [];
+        this._originalModels.clear();
+        this._originalTextModels = [];
+        this.diffDelayer.cancel();
+        this.repositoryDisposables.forEach(d => dispose(d));
+        this.repositoryDisposables.clear();
+    }
+};
+DirtyDiffModel = ( __decorate([
+    ( __param(1, ISCMService)),
+    ( __param(2, IQuickDiffService)),
+    ( __param(3, IEditorWorkerService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, ITextModelService)),
+    ( __param(6, IProgressService))
+], DirtyDiffModel));
+class DirtyDiffItem {
+    constructor(model, decorator) {
+        this.model = model;
+        this.decorator = decorator;
+    }
+    dispose() {
+        this.decorator.dispose();
+        this.model.dispose();
+    }
+}
+let DirtyDiffWorkbenchController = class DirtyDiffWorkbenchController extends Disposable {
+    constructor(editorService, instantiationService, configurationService, textFileService) {
+        super();
+        this.editorService = editorService;
+        this.instantiationService = instantiationService;
+        this.configurationService = configurationService;
+        this.textFileService = textFileService;
+        this.enabled = false;
+        this.viewState = { width: 3, visibility: 'always' };
+        this.items = ( new ResourceMap());
+        this.transientDisposables = this._register(( new DisposableStore()));
+        this.stylesheet = dom.createStyleSheet();
+        this._register(toDisposable(() => this.stylesheet.parentElement.removeChild(this.stylesheet)));
+        const onDidChangeConfiguration = Event.filter(configurationService.onDidChangeConfiguration, e => e.affectsConfiguration('scm.diffDecorations'));
+        this._register(onDidChangeConfiguration(this.onDidChangeConfiguration, this));
+        this.onDidChangeConfiguration();
+        const onDidChangeDiffWidthConfiguration = Event.filter(configurationService.onDidChangeConfiguration, e => e.affectsConfiguration('scm.diffDecorationsGutterWidth'));
+        onDidChangeDiffWidthConfiguration(this.onDidChangeDiffWidthConfiguration, this);
+        this.onDidChangeDiffWidthConfiguration();
+        const onDidChangeDiffVisibilityConfiguration = Event.filter(configurationService.onDidChangeConfiguration, e => e.affectsConfiguration('scm.diffDecorationsGutterVisibility'));
+        onDidChangeDiffVisibilityConfiguration(this.onDidChangeDiffVisibiltiyConfiguration, this);
+        this.onDidChangeDiffVisibiltiyConfiguration();
+    }
+    onDidChangeConfiguration() {
+        const enabled = this.configurationService.getValue('scm.diffDecorations') !== 'none';
+        if (enabled) {
+            this.enable();
+        }
+        else {
+            this.disable();
+        }
+    }
+    onDidChangeDiffWidthConfiguration() {
+        let width = this.configurationService.getValue('scm.diffDecorationsGutterWidth');
+        if (isNaN(width) || width <= 0 || width > 5) {
+            width = 3;
+        }
+        this.setViewState({ ...this.viewState, width });
+    }
+    onDidChangeDiffVisibiltiyConfiguration() {
+        const visibility = this.configurationService.getValue('scm.diffDecorationsGutterVisibility');
+        this.setViewState({ ...this.viewState, visibility });
+    }
+    setViewState(state) {
+        this.viewState = state;
+        this.stylesheet.textContent = `
+			.monaco-editor .dirty-diff-added,
+			.monaco-editor .dirty-diff-modified {
+				border-left-width:${state.width}px;
+			}
+			.monaco-editor .dirty-diff-added-pattern,
+			.monaco-editor .dirty-diff-added-pattern:before,
+			.monaco-editor .dirty-diff-modified-pattern,
+			.monaco-editor .dirty-diff-modified-pattern:before {
+				background-size: ${state.width}px ${state.width}px;
+			}
+			.monaco-editor .dirty-diff-added,
+			.monaco-editor .dirty-diff-added-pattern,
+			.monaco-editor .dirty-diff-modified,
+			.monaco-editor .dirty-diff-modified-pattern,
+			.monaco-editor .dirty-diff-deleted {
+				opacity: ${state.visibility === 'always' ? 1 : 0};
+			}
+		`;
+    }
+    enable() {
+        if (this.enabled) {
+            this.disable();
+        }
+        this.transientDisposables.add(Event.any(this.editorService.onDidCloseEditor, this.editorService.onDidVisibleEditorsChange)(() => this.onEditorsChanged()));
+        this.onEditorsChanged();
+        this.enabled = true;
+    }
+    disable() {
+        if (!this.enabled) {
+            return;
+        }
+        this.transientDisposables.clear();
+        for (const [, dirtyDiff] of this.items) {
+            dispose(( dirtyDiff.values()));
+        }
+        this.items.clear();
+        this.enabled = false;
+    }
+    onEditorsChanged() {
+        for (const editor of this.editorService.visibleTextEditorControls) {
+            if (isCodeEditor(editor)) {
+                const textModel = editor.getModel();
+                const controller = DirtyDiffController.get(editor);
+                if (controller) {
+                    controller.modelRegistry = this;
+                }
+                if (textModel && (!( this.items.has(textModel.uri)) || !( this.items.get(textModel.uri).has(editor.getId())))) {
+                    const textFileModel = this.textFileService.files.get(textModel.uri);
+                    if (textFileModel?.isResolved()) {
+                        const dirtyDiffModel = this.instantiationService.createInstance(DirtyDiffModel, textFileModel);
+                        const decorator = ( new DirtyDiffDecorator(
+                            textFileModel.textEditorModel,
+                            editor,
+                            dirtyDiffModel,
+                            this.configurationService
+                        ));
+                        if (!( this.items.has(textModel.uri))) {
+                            this.items.set(textModel.uri, ( new Map()));
+                        }
+                        this.items.get(textModel.uri)?.set(editor.getId(), ( new DirtyDiffItem(dirtyDiffModel, decorator)));
+                    }
+                }
+            }
+        }
+        for (const [uri, item] of this.items) {
+            for (const editorId of ( item.keys())) {
+                if (!this.editorService.visibleTextEditorControls.find(editor => isCodeEditor(editor) && editor.getModel()?.uri.toString() === ( uri.toString()) && editor.getId() === editorId)) {
+                    dispose(( item.values()));
+                    this.items.delete(uri);
+                }
+            }
+        }
+    }
+    getModel(editorModel, codeEditor) {
+        return this.items.get(editorModel.uri)?.get(codeEditor.getId())?.model;
+    }
+    dispose() {
+        this.disable();
+        super.dispose();
+    }
+};
+DirtyDiffWorkbenchController = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, ITextFileService))
+], DirtyDiffWorkbenchController));
 registerEditorContribution(DirtyDiffController.ID, DirtyDiffController, 1 );
-export { DirtyDiffController, GotoNextChangeAction, GotoPreviousChangeAction, ShowNextChangeAction, ShowPreviousChangeAction, getOriginalResource, isDirtyDiffVisible };
+export { DirtyDiffController, DirtyDiffModel, DirtyDiffWorkbenchController, GotoNextChangeAction, GotoPreviousChangeAction, ShowNextChangeAction, ShowPreviousChangeAction, getOriginalResource, isDirtyDiffVisible };