@codingame/monaco-vscode-scm-service-override 37.0.0 → 37.2.0

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

@@ -0,0 +1,933 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { prepend, $ } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { createStyleSheet } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/domStylesheets';
+import { Action, ActionRunner } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { IContextViewService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
+import { SelectActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems';
+import { defaultSelectBoxStyles } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/browser/defaultStyles';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import { peekViewTitleBackground, PeekViewWidget, peekViewBorder, peekViewTitleInfoForeground, peekViewTitleForeground } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/peekView/browser/peekView';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colorUtils';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/baseColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/chartsColors';
+import { editorBackground } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/editorColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/inputColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/listColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/menuColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/minimapColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/miscColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/quickpickColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/searchColors';
+import { MenuItemAction, MenuId, MenuRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions.service';
+import { MouseTargetType } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser';
+import { EditorAction, registerEditorAction } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorExtensions';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { EmbeddedDiffEditorWidget } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/widget/diffEditor/embeddedDiffEditorWidget';
+import { ScrollType } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/editorCommon';
+import { IQuickDiffModelService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/scm/browser/quickDiffModel.service';
+import { Disposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { RawContextKey, ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { rot } from '@codingame/monaco-vscode-api/vscode/vs/base/common/numbers';
+import { getModifiedEndLineNumber, getChangeHeight, getChangeType, getChangeTypeColor, lineIntersectsChange, ChangeType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/scm/common/quickDiff';
+import { IQuickDiffService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/scm/common/quickDiff.service';
+import { ICodeEditorService } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/codeEditorService.service';
+import { TextCompareEditorActiveContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contextkeys';
+import { EditorContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/editorContextKeys';
+import { KeybindingWeight, KeybindingsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybindingsRegistry';
+import { AccessibilitySignal } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService';
+import { IAccessibilitySignalService } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService.service';
+import { IAccessibilityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/common/accessibility.service';
+import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
+import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { EditorOption } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/config/editorOptions';
+import { Position } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position';
+import { getFlatActionBarActions } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { gotoPreviousLocation, gotoNextLocation } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/iconRegistry';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Color } from '@codingame/monaco-vscode-api/vscode/vs/base/common/color';
+import { KeyMod, KeyCode, KeyChord } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { getOuterEditor } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/widget/codeEditor/embeddedCodeEditorWidget';
+import { quickDiffDecorationCount } from './quickDiffDecorator.js';
+import { hasNativeContextMenu } from '@codingame/monaco-vscode-api/vscode/vs/platform/window/common/window';
+
+var QuickDiffEditorController_1;
+const isQuickDiffVisible = ( new RawContextKey("dirtyDiffVisible", false));
+let QuickDiffPickerViewItem = class QuickDiffPickerViewItem extends SelectActionViewItem {
+    constructor(action, contextViewService, themeService, configurationService) {
+        const styles = {
+            ...defaultSelectBoxStyles
+        };
+        const theme = themeService.getColorTheme();
+        const editorBackgroundColor = theme.getColor(editorBackground);
+        const peekTitleColor = theme.getColor(peekViewTitleBackground);
+        const opaqueTitleColor = peekTitleColor?.makeOpaque(editorBackgroundColor) ?? editorBackgroundColor;
+        styles.selectBackground = ( ( opaqueTitleColor.lighten(.6)).toString());
+        super(null, action, [], 0, contextViewService, styles, {
+            ariaLabel: ( localize(15653, "Switch quick diff base")),
+            useCustomDrawn: !hasNativeContextMenu(configurationService)
+        });
+        this.optionsItems = [];
+    }
+    setSelection(quickDiffs, providerId) {
+        this.optionsItems = ( quickDiffs.map(quickDiff => ({
+            providerId: quickDiff.id,
+            text: quickDiff.label
+        })));
+        const index = this.optionsItems.findIndex(item => item.providerId === providerId);
+        this.setOptions(this.optionsItems, index);
+    }
+    getActionContext(_, index) {
+        return this.optionsItems[index];
+    }
+    render(container) {
+        super.render(container);
+        this.setFocusable(true);
+    }
+};
+QuickDiffPickerViewItem = ( __decorate([( __param(1, IContextViewService)), ( __param(2, IThemeService)), ( __param(3, IConfigurationService))], QuickDiffPickerViewItem));
+class QuickDiffPickerBaseAction extends Action {
+    static {
+        this.ID = "quickDiff.base.switch";
+    }
+    static {
+        this.LABEL = ( localize(15654, "Switch Quick Diff Base"));
+    }
+    constructor(callback) {
+        super(
+            QuickDiffPickerBaseAction.ID,
+            QuickDiffPickerBaseAction.LABEL,
+            undefined,
+            undefined
+        );
+        this.callback = callback;
+    }
+    async run(event) {
+        return this.callback(event);
+    }
+}
+class QuickDiffWidgetActionRunner extends ActionRunner {
+    runAction(action, context) {
+        if (action instanceof MenuItemAction) {
+            return action.run(...context);
+        }
+        return super.runAction(action, context);
+    }
+}
+let QuickDiffWidgetEditorAction = class QuickDiffWidgetEditorAction extends Action {
+    constructor(editor, action, cssClass, keybindingService, instantiationService) {
+        const label = keybindingService.appendKeybinding(action.label, action.id);
+        super(action.id, label, cssClass);
+        this.instantiationService = instantiationService;
+        this.action = action;
+        this.editor = editor;
+    }
+    run() {
+        return Promise.resolve(
+            this.instantiationService.invokeFunction(accessor => this.action.run(accessor, this.editor, null))
+        );
+    }
+};
+QuickDiffWidgetEditorAction = ( __decorate([( __param(3, IKeybindingService)), ( __param(4, IInstantiationService))], QuickDiffWidgetEditorAction));
+let QuickDiffWidget = class QuickDiffWidget extends PeekViewWidget {
+    constructor(
+        editor,
+        model,
+        themeService,
+        instantiationService,
+        menuService,
+        contextKeyService,
+        quickDiffService
+    ) {
+        super(editor, {
+            isResizeable: true,
+            frameWidth: 1,
+            keepEditorSelection: true,
+            className: "dirty-diff"
+        }, instantiationService);
+        this.model = model;
+        this.themeService = themeService;
+        this.menuService = menuService;
+        this.contextKeyService = contextKeyService;
+        this.quickDiffService = quickDiffService;
+        this._index = 0;
+        this._providerId = "";
+        this.height = undefined;
+        this._disposables.add(themeService.onDidColorThemeChange(this._applyTheme, this));
+        this._applyTheme(themeService.getColorTheme());
+        if (!Iterable.isEmpty(this.model.originalTextModels)) {
+            contextKeyService = contextKeyService.createOverlay([[
+                "originalResourceScheme",
+                Iterable.first(this.model.originalTextModels)?.uri.scheme
+            ], ["originalResourceSchemes", ( Iterable.map(this.model.originalTextModels, textModel => textModel.uri.scheme))]]);
+        }
+        this.create();
+        if (editor.hasModel()) {
+            this.title = basename(editor.getModel().uri);
+        } else {
+            this.title = "";
+        }
+        this.setTitle(this.title);
+    }
+    get providerId() {
+        return this._providerId;
+    }
+    get index() {
+        return this._index;
+    }
+    get visibleRange() {
+        const visibleRanges = this.diffEditor.getModifiedEditor().getVisibleRanges();
+        return visibleRanges.length >= 0 ? visibleRanges[0] : undefined;
+    }
+    showChange(index, usePosition = true) {
+        const labeledChange = this.model.changes[index];
+        const change = labeledChange.change;
+        this._index = index;
+        this.contextKeyService.createKey("originalResource", ( this.model.changes[index].original.toString()));
+        this.contextKeyService.createKey("originalResourceScheme", this.model.changes[index].original.scheme);
+        this.updateActions();
+        this.change = change;
+        this._providerId = labeledChange.providerId;
+        if (Iterable.isEmpty(this.model.originalTextModels)) {
+            return;
+        }
+        const onFirstDiffUpdate = Event.once(this.diffEditor.onDidUpdateDiff);
+        onFirstDiffUpdate(() => setTimeout(() => this.revealChange(change), 0));
+        const diffEditorModel = this.model.getDiffEditorModel(labeledChange.original);
+        if (!diffEditorModel) {
+            return;
+        }
+        this.diffEditor.setModel(diffEditorModel);
+        const position = ( new Position(getModifiedEndLineNumber(change), 1));
+        const lineHeight = this.editor.getOption(EditorOption.lineHeight);
+        const editorHeight = this.editor.getLayoutInfo().height;
+        const editorHeightInLines = Math.floor(editorHeight / lineHeight);
+        const height = Math.min(
+            getChangeHeight(change) + 2  + 6,
+            Math.floor(editorHeightInLines / 3)
+        );
+        this.renderTitle();
+        this.updateDropdown();
+        const changeType = getChangeType(change);
+        const changeTypeColor = getChangeTypeColor(this.themeService.getColorTheme(), changeType);
+        this.style({
+            frameColor: changeTypeColor,
+            arrowColor: changeTypeColor
+        });
+        const providerSpecificChanges = [];
+        let contextIndex = index;
+        for (const change of this.model.changes) {
+            if (change.providerId === this.model.changes[this._index].providerId) {
+                providerSpecificChanges.push(change.change);
+                if (labeledChange === change) {
+                    contextIndex = providerSpecificChanges.length - 1;
+                }
+            }
+        }
+        this._actionbarWidget.context = [diffEditorModel.modified.uri, providerSpecificChanges, contextIndex];
+        if (usePosition) {
+            this.show(position, height + (1 / lineHeight));
+            this.editor.setPosition(position);
+            this.editor.focus();
+        }
+    }
+    renderTitle() {
+        const providerChanges = this.model.quickDiffChanges.get(this._providerId);
+        const providerIndex = providerChanges.indexOf(this._index);
+        let detail;
+        if (!this.shouldUseDropdown()) {
+            const label = this.model.quickDiffs.find(quickDiff => quickDiff.id === this._providerId)?.label ?? "";
+            detail = this.model.changes.length > 1 ? ( localize(
+                15655,
+                "{0} - {1} of {2} changes",
+                label,
+                providerIndex + 1,
+                providerChanges.length
+            )) : ( localize(
+                15656,
+                "{0} - {1} of {2} change",
+                label,
+                providerIndex + 1,
+                providerChanges.length
+            ));
+            this.dropdownContainer.style.display = "none";
+        } else {
+            detail = this.model.changes.length > 1 ? ( localize(15657, "{0} of {1} changes", providerIndex + 1, providerChanges.length)) : ( localize(15658, "{0} of {1} change", providerIndex + 1, providerChanges.length));
+            this.dropdownContainer.style.display = "inherit";
+        }
+        this.setTitle(this.title, detail);
+    }
+    switchQuickDiff(event) {
+        const newProviderId = event?.providerId;
+        if (newProviderId === this.model.changes[this._index].providerId) {
+            return;
+        }
+        let closestGreaterIndex = this._index < this.model.changes.length - 1 ? this._index + 1 : 0;
+        for (let i = closestGreaterIndex; i !== this._index; i < this.model.changes.length - 1 ? i++ : i = 0) {
+            if (this.model.changes[i].providerId === newProviderId) {
+                closestGreaterIndex = i;
+                break;
+            }
+        }
+        let closestLesserIndex = this._index > 0 ? this._index - 1 : this.model.changes.length - 1;
+        for (let i = closestLesserIndex; i !== this._index; i > 0 ? i-- : i = this.model.changes.length - 1) {
+            if (this.model.changes[i].providerId === newProviderId) {
+                closestLesserIndex = i;
+                break;
+            }
+        }
+        const closestIndex = Math.abs(
+            this.model.changes[closestGreaterIndex].change.modifiedEndLineNumber - this.model.changes[this._index].change.modifiedEndLineNumber
+        ) < Math.abs(
+            this.model.changes[closestLesserIndex].change.modifiedEndLineNumber - this.model.changes[this._index].change.modifiedEndLineNumber
+        ) ? closestGreaterIndex : closestLesserIndex;
+        this.showChange(closestIndex, false);
+    }
+    shouldUseDropdown() {
+        const quickDiffs = this.getQuickDiffsContainingChange();
+        return quickDiffs.length > 1;
+    }
+    updateActions() {
+        if (!this._actionbarWidget) {
+            return;
+        }
+        const previous = this.instantiationService.createInstance(QuickDiffWidgetEditorAction, this.editor, ( new ShowPreviousChangeAction(this.editor)), ThemeIcon.asClassName(gotoPreviousLocation));
+        const next = this.instantiationService.createInstance(QuickDiffWidgetEditorAction, this.editor, ( new ShowNextChangeAction(this.editor)), ThemeIcon.asClassName(gotoNextLocation));
+        this._disposables.add(previous);
+        this._disposables.add(next);
+        if (this.menu) {
+            this.menu.dispose();
+        }
+        this.menu = this.menuService.createMenu(MenuId.SCMChangeContext, this.contextKeyService);
+        const actions = getFlatActionBarActions(this.menu.getActions({
+            shouldForwardArgs: true
+        }));
+        this._actionbarWidget.clear();
+        this._actionbarWidget.push(actions.reverse(), {
+            label: false,
+            icon: true
+        });
+        this._actionbarWidget.push([next, previous], {
+            label: false,
+            icon: true
+        });
+        this._actionbarWidget.push(this._disposables.add(( new Action("peekview.close", ( localize(15659, "Close")), ThemeIcon.asClassName(Codicon.close), true, () => this.dispose()))), {
+            label: false,
+            icon: true
+        });
+    }
+    updateDropdown() {
+        const quickDiffs = this.getQuickDiffsContainingChange();
+        this.dropdown?.setSelection(quickDiffs, this._providerId);
+    }
+    getQuickDiffsContainingChange() {
+        const change = this.model.changes[this._index];
+        const quickDiffsWithChange = ( this.model.changes.filter(c => change.change2.modified.intersectsOrTouches(c.change2.modified)).map(c => c.providerId));
+        return this.model.quickDiffs.filter(
+            quickDiff => quickDiffsWithChange.includes(quickDiff.id) && this.quickDiffService.isQuickDiffProviderVisible(quickDiff.id)
+        );
+    }
+    _fillHead(container) {
+        super._fillHead(container, true);
+        const action = ( new QuickDiffPickerBaseAction(event => this.switchQuickDiff(event)));
+        this._disposables.add(action);
+        this.dropdownContainer = prepend(this._titleElement, $(".dropdown"));
+        this.dropdown = this.instantiationService.createInstance(QuickDiffPickerViewItem, action);
+        this.dropdown.render(this.dropdownContainer);
+    }
+    _getActionBarOptions() {
+        const actionRunner = ( new QuickDiffWidgetActionRunner());
+        this._disposables.add(actionRunner);
+        this._disposables.add(actionRunner.onDidRun(e => {
+            if (!(e.action instanceof QuickDiffWidgetEditorAction) && !e.error) {
+                this.dispose();
+            }
+        }));
+        return {
+            ...super._getActionBarOptions(),
+            actionRunner
+        };
+    }
+    _fillBody(container) {
+        const options = {
+            diffAlgorithm: "advanced",
+            fixedOverflowWidgets: true,
+            ignoreTrimWhitespace: false,
+            minimap: {
+                enabled: false
+            },
+            readOnly: false,
+            renderGutterMenu: false,
+            renderIndicators: false,
+            renderOverviewRuler: false,
+            renderSideBySide: false,
+            scrollbar: {
+                verticalScrollbarSize: 14,
+                horizontal: "auto",
+                useShadows: true,
+                verticalHasArrows: false,
+                horizontalHasArrows: false
+            },
+            scrollBeyondLastLine: false,
+            stickyScroll: {
+                enabled: false
+            }
+        };
+        this.diffEditor = this.instantiationService.createInstance(EmbeddedDiffEditorWidget, container, options, {}, this.editor);
+        this._disposables.add(this.diffEditor);
+    }
+    _onWidth(width) {
+        if (typeof this.height === "undefined") {
+            return;
+        }
+        this.diffEditor.layout({
+            height: this.height,
+            width
+        });
+    }
+    _doLayoutBody(height, width) {
+        super._doLayoutBody(height, width);
+        this.diffEditor.layout({
+            height,
+            width
+        });
+        if (typeof this.height === "undefined" && this.change) {
+            this.revealChange(this.change);
+        }
+        this.height = height;
+    }
+    revealChange(change) {
+        let start, end;
+        if (change.modifiedEndLineNumber === 0) {
+            start = change.modifiedStartLineNumber;
+            end = change.modifiedStartLineNumber + 1;
+        } else if (change.originalEndLineNumber > 0) {
+            start = change.modifiedStartLineNumber - 1;
+            end = change.modifiedEndLineNumber + 1;
+        } else {
+            start = change.modifiedStartLineNumber;
+            end = change.modifiedEndLineNumber;
+        }
+        this.diffEditor.revealLinesInCenter(start, end, ScrollType.Immediate);
+    }
+    _applyTheme(theme) {
+        const borderColor = theme.getColor(peekViewBorder) || Color.transparent;
+        this.style({
+            arrowColor: borderColor,
+            frameColor: borderColor,
+            headerBackgroundColor: theme.getColor(peekViewTitleBackground) || Color.transparent,
+            primaryHeadingColor: theme.getColor(peekViewTitleForeground),
+            secondaryHeadingColor: theme.getColor(peekViewTitleInfoForeground)
+        });
+    }
+    revealRange(range) {
+        this.editor.revealLineInCenterIfOutsideViewport(range.endLineNumber, ScrollType.Smooth);
+    }
+    hasFocus() {
+        return this.diffEditor.hasTextFocus();
+    }
+    toggleFocus() {
+        if (this.diffEditor.hasTextFocus()) {
+            this.editor.focus();
+        } else {
+            this.diffEditor.focus();
+        }
+    }
+    dispose() {
+        this.dropdown?.dispose();
+        this.menu?.dispose();
+        super.dispose();
+    }
+};
+QuickDiffWidget = ( __decorate([( __param(2, IThemeService)), ( __param(3, IInstantiationService)), ( __param(4, IMenuService)), ( __param(5, IContextKeyService)), ( __param(6, IQuickDiffService))], QuickDiffWidget));
+let QuickDiffEditorController = class QuickDiffEditorController extends Disposable {
+    static {
+        QuickDiffEditorController_1 = this;
+    }
+    static {
+        this.ID = "editor.contrib.quickdiff";
+    }
+    static get(editor) {
+        return editor.getContribution(QuickDiffEditorController_1.ID);
+    }
+    constructor(
+        editor,
+        contextKeyService,
+        configurationService,
+        quickDiffModelService,
+        instantiationService
+    ) {
+        super();
+        this.editor = editor;
+        this.configurationService = configurationService;
+        this.quickDiffModelService = quickDiffModelService;
+        this.instantiationService = instantiationService;
+        this.model = null;
+        this.widget = null;
+        this.session = Disposable.None;
+        this.mouseDownInfo = null;
+        this.enabled = false;
+        this.gutterActionDisposables = ( new DisposableStore());
+        this.enabled = !contextKeyService.getContextKeyValue("isInDiffEditor");
+        this.stylesheet = createStyleSheet(undefined, undefined, this._store);
+        if (this.enabled) {
+            this.isQuickDiffVisible = isQuickDiffVisible.bindTo(contextKeyService);
+            this._register(editor.onDidChangeModel(() => this.close()));
+            const onDidChangeGutterAction = Event.filter(
+                configurationService.onDidChangeConfiguration,
+                e => e.affectsConfiguration("scm.diffDecorationsGutterAction")
+            );
+            this._register(onDidChangeGutterAction(this.onDidChangeGutterAction, this));
+            this.onDidChangeGutterAction();
+        }
+    }
+    onDidChangeGutterAction() {
+        const gutterAction = this.configurationService.getValue("scm.diffDecorationsGutterAction");
+        this.gutterActionDisposables.clear();
+        if (gutterAction === "diff") {
+            this.gutterActionDisposables.add(this.editor.onMouseDown(e => this.onEditorMouseDown(e)));
+            this.gutterActionDisposables.add(this.editor.onMouseUp(e => this.onEditorMouseUp(e)));
+            this.stylesheet.textContent = `
+                .monaco-editor .dirty-diff-glyph {
+                    cursor: pointer;
+                }
+
+                .monaco-editor .margin-view-overlays .dirty-diff-glyph:hover::before {
+                    height: 100%;
+                    width: 6px;
+                    left: -6px;
+                }
+
+                .monaco-editor .margin-view-overlays .dirty-diff-deleted:hover::after {
+                    bottom: 0;
+                    border-top-width: 0;
+                    border-bottom-width: 0;
+                }
+            `;
+        } else {
+            this.stylesheet.textContent = ``;
+        }
+    }
+    canNavigate() {
+        return !this.widget || (this.widget?.index === -1) || (!!this.model && this.model.changes.length > 1);
+    }
+    refresh() {
+        this.widget?.showChange(this.widget.index, false);
+    }
+    toggleFocus() {
+        if (this.widget) {
+            this.widget.toggleFocus();
+        }
+    }
+    next(lineNumber) {
+        if (!this.assertWidget()) {
+            return;
+        }
+        if (!this.widget || !this.model) {
+            return;
+        }
+        let index;
+        if (this.editor.hasModel() && (typeof lineNumber === "number" || !this.widget.providerId)) {
+            index = this.model.findNextClosestChange(
+                typeof lineNumber === "number" ? lineNumber : this.editor.getPosition().lineNumber,
+                true,
+                this.widget.providerId
+            );
+        } else {
+            const providerChanges = this.model.quickDiffChanges.get(this.widget.providerId) ?? ( this.model.quickDiffChanges.values()).next().value;
+            const mapIndex = providerChanges.findIndex(value => value === this.widget.index);
+            index = providerChanges[rot(mapIndex + 1, providerChanges.length)];
+        }
+        this.widget.showChange(index);
+    }
+    previous(lineNumber) {
+        if (!this.assertWidget()) {
+            return;
+        }
+        if (!this.widget || !this.model) {
+            return;
+        }
+        let index;
+        if (this.editor.hasModel() && (typeof lineNumber === "number" || !this.widget.providerId)) {
+            index = this.model.findPreviousClosestChange(
+                typeof lineNumber === "number" ? lineNumber : this.editor.getPosition().lineNumber,
+                true,
+                this.widget.providerId
+            );
+        } else {
+            const providerChanges = this.model.quickDiffChanges.get(this.widget.providerId) ?? ( this.model.quickDiffChanges.values()).next().value;
+            const mapIndex = providerChanges.findIndex(value => value === this.widget.index);
+            index = providerChanges[rot(mapIndex - 1, providerChanges.length)];
+        }
+        this.widget.showChange(index);
+    }
+    close() {
+        this.session.dispose();
+        this.session = Disposable.None;
+    }
+    assertWidget() {
+        if (!this.enabled) {
+            return false;
+        }
+        if (this.widget) {
+            if (!this.model || this.model.changes.length === 0) {
+                this.close();
+                return false;
+            }
+            return true;
+        }
+        const editorModel = this.editor.getModel();
+        if (!editorModel) {
+            return false;
+        }
+        const modelRef = this.quickDiffModelService.createQuickDiffModelReference(editorModel.uri);
+        if (!modelRef) {
+            return false;
+        }
+        if (modelRef.object.changes.length === 0) {
+            modelRef.dispose();
+            return false;
+        }
+        this.model = modelRef.object;
+        this.widget = this.instantiationService.createInstance(QuickDiffWidget, this.editor, this.model);
+        this.isQuickDiffVisible.set(true);
+        const disposables = ( new DisposableStore());
+        disposables.add(Event.once(this.widget.onDidClose)(this.close, this));
+        const onDidModelChange = Event.chain(this.model.onDidChange, $ => ( $.filter(e => e.diff.length > 0).map(e => e.diff)));
+        onDidModelChange(this.onDidModelChange, this, disposables);
+        disposables.add(modelRef);
+        disposables.add(this.widget);
+        disposables.add(toDisposable(() => {
+            this.model = null;
+            this.widget = null;
+            this.isQuickDiffVisible.set(false);
+            this.editor.focus();
+        }));
+        this.session = disposables;
+        return true;
+    }
+    onDidModelChange(splices) {
+        if (!this.model || !this.widget || this.widget.hasFocus()) {
+            return;
+        }
+        for (const splice of splices) {
+            if (splice.start <= this.widget.index) {
+                this.next();
+                return;
+            }
+        }
+        this.refresh();
+    }
+    onEditorMouseDown(e) {
+        this.mouseDownInfo = null;
+        const range = e.target.range;
+        if (!range) {
+            return;
+        }
+        if (!e.event.leftButton) {
+            return;
+        }
+        if (e.target.type !== MouseTargetType.GUTTER_LINE_DECORATIONS) {
+            return;
+        }
+        if (!e.target.element) {
+            return;
+        }
+        if (e.target.element.className.indexOf("dirty-diff-glyph") < 0) {
+            return;
+        }
+        const data = e.target.detail;
+        const offsetLeftInGutter = e.target.element.offsetLeft;
+        const gutterOffsetX = data.offsetX - offsetLeftInGutter;
+        if (gutterOffsetX < -3 || gutterOffsetX > 3) {
+            return;
+        }
+        this.mouseDownInfo = {
+            lineNumber: range.startLineNumber
+        };
+    }
+    onEditorMouseUp(e) {
+        if (!this.mouseDownInfo) {
+            return;
+        }
+        const {
+            lineNumber
+        } = this.mouseDownInfo;
+        this.mouseDownInfo = null;
+        const range = e.target.range;
+        if (!range || range.startLineNumber !== lineNumber) {
+            return;
+        }
+        if (e.target.type !== MouseTargetType.GUTTER_LINE_DECORATIONS) {
+            return;
+        }
+        const editorModel = this.editor.getModel();
+        if (!editorModel) {
+            return;
+        }
+        const modelRef = this.quickDiffModelService.createQuickDiffModelReference(editorModel.uri);
+        if (!modelRef) {
+            return;
+        }
+        try {
+            const index = modelRef.object.changes.findIndex(change => lineIntersectsChange(lineNumber, change.change));
+            if (index < 0) {
+                return;
+            }
+            if (index === this.widget?.index) {
+                this.close();
+            } else {
+                this.next(lineNumber);
+            }
+        } finally {
+            modelRef.dispose();
+        }
+    }
+    dispose() {
+        this.gutterActionDisposables.dispose();
+        super.dispose();
+    }
+};
+QuickDiffEditorController = QuickDiffEditorController_1 = ( __decorate([( __param(1, IContextKeyService)), ( __param(2, IConfigurationService)), ( __param(3, IQuickDiffModelService)), ( __param(4, IInstantiationService))], QuickDiffEditorController));
+class ShowPreviousChangeAction extends EditorAction {
+    constructor(outerEditor) {
+        super({
+            id: "editor.action.dirtydiff.previous",
+            label: ( localize2(15660, "Show Previous Change")),
+            precondition: ( TextCompareEditorActiveContext.toNegated()),
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: KeyMod.Shift | KeyMod.Alt | KeyCode.F3,
+                weight: KeybindingWeight.EditorContrib
+            }
+        });
+        this.outerEditor = outerEditor;
+    }
+    run(accessor) {
+        const outerEditor = this.outerEditor ?? getOuterEditorFromDiffEditor(accessor);
+        if (!outerEditor) {
+            return;
+        }
+        const controller = QuickDiffEditorController.get(outerEditor);
+        if (!controller) {
+            return;
+        }
+        if (!controller.canNavigate()) {
+            return;
+        }
+        controller.previous();
+    }
+}
+registerEditorAction(ShowPreviousChangeAction);
+class ShowNextChangeAction extends EditorAction {
+    constructor(outerEditor) {
+        super({
+            id: "editor.action.dirtydiff.next",
+            label: ( localize2(15661, "Show Next Change")),
+            precondition: ( TextCompareEditorActiveContext.toNegated()),
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: KeyMod.Alt | KeyCode.F3,
+                weight: KeybindingWeight.EditorContrib
+            }
+        });
+        this.outerEditor = outerEditor;
+    }
+    run(accessor) {
+        const outerEditor = this.outerEditor ?? getOuterEditorFromDiffEditor(accessor);
+        if (!outerEditor) {
+            return;
+        }
+        const controller = QuickDiffEditorController.get(outerEditor);
+        if (!controller) {
+            return;
+        }
+        if (!controller.canNavigate()) {
+            return;
+        }
+        controller.next();
+    }
+}
+registerEditorAction(ShowNextChangeAction);
+class GotoPreviousChangeAction extends EditorAction {
+    constructor() {
+        super({
+            id: "workbench.action.editor.previousChange",
+            label: ( localize2(15662, "Go to Previous Change")),
+            precondition: ( ContextKeyExpr.and(( TextCompareEditorActiveContext.toNegated()), ( quickDiffDecorationCount.notEqualsTo(0)))),
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: KeyMod.Shift | KeyMod.Alt | KeyCode.F5,
+                weight: KeybindingWeight.EditorContrib
+            }
+        });
+    }
+    async run(accessor) {
+        const outerEditor = getOuterEditorFromDiffEditor(accessor);
+        const accessibilitySignalService = accessor.get(IAccessibilitySignalService);
+        const accessibilityService = accessor.get(IAccessibilityService);
+        const codeEditorService = accessor.get(ICodeEditorService);
+        const quickDiffModelService = accessor.get(IQuickDiffModelService);
+        if (!outerEditor || !outerEditor.hasModel()) {
+            return;
+        }
+        const modelRef = quickDiffModelService.createQuickDiffModelReference(outerEditor.getModel().uri);
+        try {
+            if (!modelRef || modelRef.object.changes.length === 0) {
+                return;
+            }
+            const lineNumber = outerEditor.getPosition().lineNumber;
+            const index = modelRef.object.findPreviousClosestChange(lineNumber, false);
+            const change = modelRef.object.changes[index];
+            await playAccessibilitySymbolForChange(change.change, accessibilitySignalService);
+            setPositionAndSelection(change.change, outerEditor, accessibilityService, codeEditorService);
+        } finally {
+            modelRef?.dispose();
+        }
+    }
+}
+registerEditorAction(GotoPreviousChangeAction);
+class GotoNextChangeAction extends EditorAction {
+    constructor() {
+        super({
+            id: "workbench.action.editor.nextChange",
+            label: ( localize2(15663, "Go to Next Change")),
+            precondition: ( ContextKeyExpr.and(( TextCompareEditorActiveContext.toNegated()), ( quickDiffDecorationCount.notEqualsTo(0)))),
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: KeyMod.Alt | KeyCode.F5,
+                weight: KeybindingWeight.EditorContrib
+            }
+        });
+    }
+    async run(accessor) {
+        const accessibilitySignalService = accessor.get(IAccessibilitySignalService);
+        const outerEditor = getOuterEditorFromDiffEditor(accessor);
+        const accessibilityService = accessor.get(IAccessibilityService);
+        const codeEditorService = accessor.get(ICodeEditorService);
+        const quickDiffModelService = accessor.get(IQuickDiffModelService);
+        if (!outerEditor || !outerEditor.hasModel()) {
+            return;
+        }
+        const modelRef = quickDiffModelService.createQuickDiffModelReference(outerEditor.getModel().uri);
+        try {
+            if (!modelRef || modelRef.object.changes.length === 0) {
+                return;
+            }
+            const lineNumber = outerEditor.getPosition().lineNumber;
+            const index = modelRef.object.findNextClosestChange(lineNumber, false);
+            const change = modelRef.object.changes[index].change;
+            await playAccessibilitySymbolForChange(change, accessibilitySignalService);
+            setPositionAndSelection(change, outerEditor, accessibilityService, codeEditorService);
+        } finally {
+            modelRef?.dispose();
+        }
+    }
+}
+registerEditorAction(GotoNextChangeAction);
+MenuRegistry.appendMenuItem(MenuId.MenubarGoMenu, {
+    group: "7_change_nav",
+    command: {
+        id: "editor.action.dirtydiff.next",
+        title: ( localize(15664, "Next &&Change"))
+    },
+    order: 1
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarGoMenu, {
+    group: "7_change_nav",
+    command: {
+        id: "editor.action.dirtydiff.previous",
+        title: ( localize(15665, "Previous &&Change"))
+    },
+    order: 2
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: "closeQuickDiff",
+    weight: KeybindingWeight.EditorContrib + 50,
+    primary: KeyCode.Escape,
+    secondary: [KeyMod.Shift | KeyCode.Escape],
+    when: ( ContextKeyExpr.and(isQuickDiffVisible)),
+    handler: accessor => {
+        const outerEditor = getOuterEditorFromDiffEditor(accessor);
+        if (!outerEditor) {
+            return;
+        }
+        const controller = QuickDiffEditorController.get(outerEditor);
+        if (!controller) {
+            return;
+        }
+        controller.close();
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: "toggleQuickDiffWidgetFocus",
+    weight: KeybindingWeight.EditorContrib,
+    primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyCode.F2),
+    when: isQuickDiffVisible,
+    handler: accessor => {
+        const outerEditor = getOuterEditorFromDiffEditor(accessor);
+        if (!outerEditor) {
+            return;
+        }
+        const controller = QuickDiffEditorController.get(outerEditor);
+        if (!controller) {
+            return;
+        }
+        controller.toggleFocus();
+    }
+});
+function setPositionAndSelection(change, editor, accessibilityService, codeEditorService) {
+    const position = ( new Position(change.modifiedStartLineNumber, 1));
+    editor.setPosition(position);
+    editor.revealPositionInCenter(position);
+    if (accessibilityService.isScreenReaderOptimized()) {
+        editor.setSelection({
+            startLineNumber: change.modifiedStartLineNumber,
+            startColumn: 0,
+            endLineNumber: change.modifiedStartLineNumber,
+            endColumn: Number.MAX_VALUE
+        });
+        codeEditorService.getActiveCodeEditor()?.writeScreenReaderContent("diff-navigation");
+    }
+}
+async function playAccessibilitySymbolForChange(change, accessibilitySignalService) {
+    const changeType = getChangeType(change);
+    switch (changeType) {
+    case ChangeType.Add:
+        accessibilitySignalService.playSignal(AccessibilitySignal.diffLineInserted, {
+            allowManyInParallel: true,
+            source: "quickDiffDecoration"
+        });
+        break;
+    case ChangeType.Delete:
+        accessibilitySignalService.playSignal(AccessibilitySignal.diffLineDeleted, {
+            allowManyInParallel: true,
+            source: "quickDiffDecoration"
+        });
+        break;
+    case ChangeType.Modify:
+        accessibilitySignalService.playSignal(AccessibilitySignal.diffLineModified, {
+            allowManyInParallel: true,
+            source: "quickDiffDecoration"
+        });
+        break;
+    }
+}
+function getOuterEditorFromDiffEditor(accessor) {
+    const diffEditors = accessor.get(ICodeEditorService).listDiffEditors();
+    for (const diffEditor of diffEditors) {
+        if (diffEditor.hasTextFocus() && diffEditor instanceof EmbeddedDiffEditorWidget) {
+            return diffEditor.getParentEditor();
+        }
+    }
+    return getOuterEditor(accessor);
+}
+
+export { GotoNextChangeAction, GotoPreviousChangeAction, QuickDiffEditorController, QuickDiffPickerBaseAction, QuickDiffPickerViewItem, ShowNextChangeAction, ShowPreviousChangeAction, isQuickDiffVisible };