@codingame/monaco-vscode-scm-service-override 4.0.0 → 4.1.0

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

@@ -1,3367 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import './media/scm.css.js';
-import { Event, Emitter } from 'vscode/vscode/vs/base/common/event';
-import { basename, dirname } from 'vscode/vscode/vs/base/common/resources';
-import { Disposable, DisposableStore, toDisposable, combinedDisposable, MutableDisposable, DisposableMap, dispose } from 'vscode/vscode/vs/base/common/lifecycle';
-import { ViewAction, ViewPane } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
-import { append, $, prepend, Dimension, trackFocus, clearNode, asCSSUrl } from 'vscode/vscode/vs/base/browser/dom';
-import { VIEW_PANE_ID, SCMInputChangeReason, ISCMViewService, ISCMService } from 'vscode/vscode/vs/workbench/contrib/scm/common/scm';
-import { ResourceLabels } from 'vscode/vscode/vs/workbench/browser/labels';
-import { CountBadge } from 'vscode/vscode/vs/base/browser/ui/countBadge/countBadge';
-import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { IContextMenuService, IContextViewService } from 'vscode/vscode/vs/platform/contextview/browser/contextView';
-import { RawContextKey, ContextKeyExpr, IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
-import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
-import { MenuId, MenuRegistry, registerAction2, Action2, MenuItemAction, IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions';
-import { Action, Separator, ActionRunner } from 'vscode/vscode/vs/base/common/actions';
-import { ActionBar } from 'vscode/vscode/vs/base/browser/ui/actionbar/actionbar';
-import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
-import { connectPrimaryMenuToInlineActionBar, connectPrimaryMenu, getActionViewItemProvider, isSCMRepository, isSCMResourceGroup, isSCMResourceNode, isSCMHistoryItemChangeNode, isSCMInput, isSCMActionButton, isSCMResource, isSCMHistoryItemGroupTreeElement, isSCMHistoryItemTreeElement, isSCMHistoryItemChangeTreeElement, toDiffEditorArguments, collectContextMenuActions, isSCMViewService, isSCMViewSeparator } from './util.js';
-import { WorkbenchCompressibleAsyncDataTree } from 'vscode/vscode/vs/platform/list/browser/listService';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { disposableTimeout, ThrottledDelayer, Sequencer, Throttler } from 'vscode/vscode/vs/base/common/async';
-import { ResourceTree } from 'vscode/vscode/vs/base/common/resourceTree';
-import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { FileKind } from 'vscode/vscode/vs/platform/files/common/files';
-import { comparePaths, compareFileNames } from 'vscode/vscode/vs/base/common/comparers';
-import { createMatches } from 'vscode/vscode/vs/base/common/filters';
-import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { flatten } from 'vscode/vscode/vs/base/common/arrays';
-import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
-import { EditorResourceAccessor, SideBySideEditor } from 'vscode/vscode/vs/workbench/common/editor';
-import { PANEL_BACKGROUND, SIDE_BAR_BACKGROUND } from 'vscode/vscode/vs/workbench/common/theme';
-import { CodeEditorWidget } from 'vscode/vscode/vs/editor/browser/widget/codeEditor/codeEditorWidget';
-import { getSimpleEditorOptions } from 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/simpleEditorOptions';
-import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
-import { EditorExtensionsRegistry } from 'vscode/vscode/vs/editor/browser/editorExtensions';
-import { MenuPreventer } from 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/menuPreventer';
-import { SelectionClipboardContributionID } from 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/selectionClipboard';
-import { EditorDictation } from 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/dictation/editorDictation';
-import { ContextMenuController } from 'vscode/vscode/vs/editor/contrib/contextmenu/browser/contextmenu';
-import { isMacintosh } from 'vscode/vscode/vs/base/common/platform';
-import { format, compare } from 'vscode/vscode/vs/base/common/strings';
-import { SuggestController } from 'vscode/vscode/vs/editor/contrib/suggest/browser/suggestController';
-import { SnippetController2 } from 'vscode/vscode/vs/editor/contrib/snippet/browser/snippetController2';
-import { ServiceCollection } from 'vscode/vscode/vs/platform/instantiation/common/serviceCollection';
-import { HoverController } from 'vscode/vscode/vs/editor/contrib/hover/browser/hover';
-import { ColorDetector } from 'vscode/vscode/vs/editor/contrib/colorPicker/browser/colorDetector';
-import { LinkDetector } from 'vscode/vscode/vs/editor/contrib/links/browser/links';
-import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
-import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
-import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/language';
-import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label';
-import { DEFAULT_FONT_FAMILY } from 'vscode/vscode/vs/base/browser/fonts';
-import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
-import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
-import { RepositoryRenderer, RepositoryActionRunner } from './scmRepositoryRenderer.js';
-import { ColorScheme } from 'vscode/vscode/vs/platform/theme/common/theme';
-import { API_OPEN_EDITOR_COMMAND_ID, API_OPEN_DIFF_EDITOR_COMMAND_ID } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorCommands';
-import { createActionViewItem, createAndFillInContextMenuActions, createAndFillInActionBarActions } from 'vscode/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
-import { MarkdownRenderer, openLinkFromMarkdown } from 'vscode/vscode/vs/editor/browser/widget/markdownRenderer/browser/markdownRenderer';
-import { ButtonWithDropdown, Button } from 'vscode/vscode/vs/base/browser/ui/button/button';
-import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
-import { RepositoryContextKeys } from './scmViewService.js';
-import { DragAndDropController } from 'vscode/vscode/vs/editor/contrib/dnd/browser/dnd';
-import { DropIntoEditorController } from 'vscode/vscode/vs/editor/contrib/dropOrPasteInto/browser/dropIntoEditorController';
-import { MessageController } from 'vscode/vscode/vs/editor/contrib/message/browser/messageController';
-import { defaultCountBadgeStyles, defaultButtonStyles } from 'vscode/vscode/vs/platform/theme/browser/defaultStyles';
-import { InlineCompletionsController } from 'vscode/vscode/vs/editor/contrib/inlineCompletions/browser/inlineCompletionsController';
-import { CodeActionController } from 'vscode/vscode/vs/editor/contrib/codeAction/browser/codeActionController';
-import { ITextModelService } from 'vscode/vscode/vs/editor/common/services/resolverService';
-import { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { fillEditorsDragData } from 'vscode/vscode/vs/workbench/browser/dnd';
-import { CodeDataTransfers } from 'vscode/vscode/vs/platform/dnd/browser/dnd';
-import { FormatOnType } from 'vscode/vscode/vs/editor/contrib/format/browser/formatActions';
-import { EditorOptions } from 'vscode/vscode/vs/editor/common/config/editorOptions';
-import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
-import { EditOperation } from 'vscode/vscode/vs/editor/common/core/editOperation';
-import { stripIcons } from 'vscode/vscode/vs/base/common/iconLabels';
-import { IconLabel } from 'vscode/vscode/vs/base/browser/ui/iconLabel/iconLabel';
-import { registerColor, transparent } from 'vscode/vscode/vs/platform/theme/common/colorUtils';
-import { foreground } from 'vscode/vscode/vs/platform/theme/common/colors/baseColors';
-import 'vscode/vscode/vs/platform/theme/common/colors/chartsColors';
-import 'vscode/vscode/vs/platform/theme/common/colors/editorColors';
-import 'vscode/vscode/vs/platform/theme/common/colors/inputColors';
-import { listActiveSelectionForeground } from 'vscode/vscode/vs/platform/theme/common/colors/listColors';
-import 'vscode/vscode/vs/platform/theme/common/colors/menuColors';
-import 'vscode/vscode/vs/platform/theme/common/colors/minimapColors';
-import 'vscode/vscode/vs/platform/theme/common/colors/miscColors';
-import 'vscode/vscode/vs/platform/theme/common/colors/quickpickColors';
-import 'vscode/vscode/vs/platform/theme/common/colors/searchColors';
-import { WorkbenchToolBar, MenuWorkbenchToolBar } from 'vscode/vscode/vs/platform/actions/browser/toolbar';
-import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
-import { DropdownWithPrimaryActionViewItem } from 'vscode/vscode/vs/platform/actions/browser/dropdownWithPrimaryActionViewItem';
-import { clamp } from 'vscode/vscode/vs/base/common/numbers';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-
-var ActionButtonRenderer_1, InputRenderer_1, ResourceGroupRenderer_1, ResourceRenderer_1, HistoryItemGroupRenderer_1, HistoryItemRenderer_1, HistoryItemChangeRenderer_1, SeparatorRenderer_1, SCMInputWidget_1;
-registerColor('scm.historyItemAdditionsForeground', {
-    dark: 'gitDecoration.addedResourceForeground',
-    light: 'gitDecoration.addedResourceForeground',
-    hcDark: 'gitDecoration.addedResourceForeground',
-    hcLight: 'gitDecoration.addedResourceForeground'
-}, ( localizeWithPath(
-    'vs/workbench/contrib/scm/browser/scmViewPane',
-    'scm.historyItemAdditionsForeground',
-    "History item additions foreground color."
-)));
-registerColor('scm.historyItemDeletionsForeground', {
-    dark: 'gitDecoration.deletedResourceForeground',
-    light: 'gitDecoration.deletedResourceForeground',
-    hcDark: 'gitDecoration.deletedResourceForeground',
-    hcLight: 'gitDecoration.deletedResourceForeground'
-}, ( localizeWithPath(
-    'vs/workbench/contrib/scm/browser/scmViewPane',
-    'scm.historyItemDeletionsForeground',
-    "History item deletions foreground color."
-)));
-registerColor('scm.historyItemStatisticsBorder', {
-    dark: ( transparent(foreground, 0.2)),
-    light: ( transparent(foreground, 0.2)),
-    hcDark: ( transparent(foreground, 0.2)),
-    hcLight: ( transparent(foreground, 0.2))
-}, ( localizeWithPath(
-    'vs/workbench/contrib/scm/browser/scmViewPane',
-    'scm.historyItemStatisticsBorder',
-    "History item statistics border color."
-)));
-registerColor('scm.historyItemSelectedStatisticsBorder', {
-    dark: ( transparent(listActiveSelectionForeground, 0.2)),
-    light: ( transparent(listActiveSelectionForeground, 0.2)),
-    hcDark: ( transparent(listActiveSelectionForeground, 0.2)),
-    hcLight: ( transparent(listActiveSelectionForeground, 0.2))
-}, ( localizeWithPath(
-    'vs/workbench/contrib/scm/browser/scmViewPane',
-    'scm.historyItemSelectedStatisticsBorder',
-    "History item selected statistics border color."
-)));
-let ActionButtonRenderer = class ActionButtonRenderer {
-    static { ActionButtonRenderer_1 = this; }
-    static { this.DEFAULT_HEIGHT = 30; }
-    static { this.TEMPLATE_ID = 'actionButton'; }
-    get templateId() { return ActionButtonRenderer_1.TEMPLATE_ID; }
-    constructor(commandService, contextMenuService, notificationService) {
-        this.commandService = commandService;
-        this.contextMenuService = contextMenuService;
-        this.notificationService = notificationService;
-        this.actionButtons = ( new Map());
-    }
-    renderTemplate(container) {
-        container.parentElement.parentElement.querySelector('.monaco-tl-twistie').classList.add('force-no-twistie');
-        container.parentElement.parentElement.classList.add('cursor-default', 'force-no-hover');
-        const buttonContainer = append(container, $('.button-container'));
-        const actionButton = ( new SCMActionButton(
-            buttonContainer,
-            this.contextMenuService,
-            this.commandService,
-            this.notificationService
-        ));
-        return { actionButton, disposable: Disposable.None, templateDisposable: actionButton };
-    }
-    renderElement(node, index, templateData, height) {
-        templateData.disposable.dispose();
-        const disposables = ( new DisposableStore());
-        const actionButton = node.element;
-        templateData.actionButton.setButton(node.element.button);
-        const renderedActionButtons = this.actionButtons.get(actionButton) ?? [];
-        this.actionButtons.set(actionButton, [...renderedActionButtons, templateData.actionButton]);
-        disposables.add({
-            dispose: () => {
-                const renderedActionButtons = this.actionButtons.get(actionButton) ?? [];
-                const renderedWidgetIndex = renderedActionButtons.findIndex(renderedActionButton => renderedActionButton === templateData.actionButton);
-                if (renderedWidgetIndex < 0) {
-                    throw new Error('Disposing unknown action button');
-                }
-                if (renderedActionButtons.length === 1) {
-                    this.actionButtons.delete(actionButton);
-                }
-                else {
-                    renderedActionButtons.splice(renderedWidgetIndex, 1);
-                }
-            }
-        });
-        templateData.disposable = disposables;
-    }
-    renderCompressedElements() {
-        throw new Error('Should never happen since node is incompressible');
-    }
-    focusActionButton(actionButton) {
-        this.actionButtons.get(actionButton)?.forEach(renderedActionButton => renderedActionButton.focus());
-    }
-    disposeElement(node, index, template) {
-        template.disposable.dispose();
-    }
-    disposeTemplate(templateData) {
-        templateData.disposable.dispose();
-        templateData.templateDisposable.dispose();
-    }
-};
-ActionButtonRenderer = ActionButtonRenderer_1 = ( __decorate([
-    ( __param(0, ICommandService)),
-    ( __param(1, IContextMenuService)),
-    ( __param(2, INotificationService))
-], ActionButtonRenderer));
-class SCMTreeDragAndDrop {
-    constructor(instantiationService) {
-        this.instantiationService = instantiationService;
-    }
-    getDragURI(element) {
-        if (isSCMResource(element)) {
-            return ( element.sourceUri.toString());
-        }
-        return null;
-    }
-    onDragStart(data, originalEvent) {
-        const items = SCMTreeDragAndDrop.getResourcesFromDragAndDropData(data);
-        if (originalEvent.dataTransfer && items?.length) {
-            this.instantiationService.invokeFunction(accessor => fillEditorsDragData(accessor, items, originalEvent));
-            const fileResources = ( items.filter(s => s.scheme === Schemas.file).map(r => r.fsPath));
-            if (fileResources.length) {
-                originalEvent.dataTransfer.setData(CodeDataTransfers.FILES, JSON.stringify(fileResources));
-            }
-        }
-    }
-    getDragLabel(elements, originalEvent) {
-        if (elements.length === 1) {
-            const element = elements[0];
-            if (isSCMResource(element)) {
-                return basename(element.sourceUri);
-            }
-        }
-        return String(elements.length);
-    }
-    onDragOver(data, targetElement, targetIndex, targetSector, originalEvent) {
-        return true;
-    }
-    drop(data, targetElement, targetIndex, targetSector, originalEvent) { }
-    static getResourcesFromDragAndDropData(data) {
-        const uris = [];
-        for (const element of [...(data.context ?? []), ...data.elements]) {
-            if (isSCMResource(element)) {
-                uris.push(element.sourceUri);
-            }
-        }
-        return uris;
-    }
-    dispose() { }
-}
-let InputRenderer = class InputRenderer {
-    static { InputRenderer_1 = this; }
-    static { this.DEFAULT_HEIGHT = 26; }
-    static { this.TEMPLATE_ID = 'input'; }
-    get templateId() { return InputRenderer_1.TEMPLATE_ID; }
-    constructor(outerLayout, overflowWidgetsDomNode, updateHeight, instantiationService) {
-        this.outerLayout = outerLayout;
-        this.overflowWidgetsDomNode = overflowWidgetsDomNode;
-        this.updateHeight = updateHeight;
-        this.instantiationService = instantiationService;
-        this.inputWidgets = ( new Map());
-        this.contentHeights = ( new WeakMap());
-        this.editorSelections = ( new WeakMap());
-    }
-    renderTemplate(container) {
-        container.parentElement.parentElement.querySelector('.monaco-tl-twistie').classList.add('force-no-twistie');
-        container.parentElement.parentElement.classList.add('force-no-hover');
-        const templateDisposable = ( new DisposableStore());
-        const inputElement = append(container, $('.scm-input'));
-        const inputWidget = this.instantiationService.createInstance(SCMInputWidget, inputElement, this.overflowWidgetsDomNode);
-        templateDisposable.add(inputWidget);
-        return { inputWidget, inputWidgetHeight: InputRenderer_1.DEFAULT_HEIGHT, elementDisposables: ( new DisposableStore()), templateDisposable };
-    }
-    renderElement(node, index, templateData) {
-        const input = node.element;
-        templateData.inputWidget.setInput(input);
-        const renderedWidgets = this.inputWidgets.get(input) ?? [];
-        this.inputWidgets.set(input, [...renderedWidgets, templateData.inputWidget]);
-        templateData.elementDisposables.add({
-            dispose: () => {
-                const renderedWidgets = this.inputWidgets.get(input) ?? [];
-                const renderedWidgetIndex = renderedWidgets.findIndex(renderedWidget => renderedWidget === templateData.inputWidget);
-                if (renderedWidgetIndex < 0) {
-                    throw new Error('Disposing unknown input widget');
-                }
-                if (renderedWidgets.length === 1) {
-                    this.inputWidgets.delete(input);
-                }
-                else {
-                    renderedWidgets.splice(renderedWidgetIndex, 1);
-                }
-            }
-        });
-        const selections = this.editorSelections.get(input);
-        if (selections) {
-            templateData.inputWidget.selections = selections;
-        }
-        templateData.elementDisposables.add(toDisposable(() => {
-            const selections = templateData.inputWidget.selections;
-            if (selections) {
-                this.editorSelections.set(input, selections);
-            }
-        }));
-        templateData.inputWidgetHeight = InputRenderer_1.DEFAULT_HEIGHT;
-        const onDidChangeContentHeight = () => {
-            const contentHeight = templateData.inputWidget.getContentHeight();
-            this.contentHeights.set(input, contentHeight);
-            if (templateData.inputWidgetHeight !== contentHeight) {
-                this.updateHeight(input, contentHeight + 10);
-                templateData.inputWidgetHeight = contentHeight;
-                templateData.inputWidget.layout();
-            }
-        };
-        const startListeningContentHeightChange = () => {
-            templateData.elementDisposables.add(templateData.inputWidget.onDidChangeContentHeight(onDidChangeContentHeight));
-            onDidChangeContentHeight();
-        };
-        disposableTimeout(startListeningContentHeightChange, 0, templateData.elementDisposables);
-        const layoutEditor = () => templateData.inputWidget.layout();
-        templateData.elementDisposables.add(this.outerLayout.onDidChange(layoutEditor));
-        layoutEditor();
-    }
-    renderCompressedElements() {
-        throw new Error('Should never happen since node is incompressible');
-    }
-    disposeElement(group, index, template) {
-        template.elementDisposables.clear();
-    }
-    disposeTemplate(templateData) {
-        templateData.templateDisposable.dispose();
-    }
-    getHeight(input) {
-        return (this.contentHeights.get(input) ?? InputRenderer_1.DEFAULT_HEIGHT) + 10;
-    }
-    getRenderedInputWidget(input) {
-        return this.inputWidgets.get(input);
-    }
-    getFocusedInput() {
-        for (const [input, inputWidgets] of this.inputWidgets) {
-            for (const inputWidget of inputWidgets) {
-                if (inputWidget.hasFocus()) {
-                    return input;
-                }
-            }
-        }
-        return undefined;
-    }
-    clearValidation() {
-        for (const [, inputWidgets] of this.inputWidgets) {
-            for (const inputWidget of inputWidgets) {
-                inputWidget.clearValidation();
-            }
-        }
-    }
-};
-InputRenderer = InputRenderer_1 = ( __decorate([
-    ( __param(3, IInstantiationService))
-], InputRenderer));
-let ResourceGroupRenderer = class ResourceGroupRenderer {
-    static { ResourceGroupRenderer_1 = this; }
-    static { this.TEMPLATE_ID = 'resource group'; }
-    get templateId() { return ResourceGroupRenderer_1.TEMPLATE_ID; }
-    constructor(actionViewItemProvider, scmViewService) {
-        this.actionViewItemProvider = actionViewItemProvider;
-        this.scmViewService = scmViewService;
-    }
-    renderTemplate(container) {
-        container.parentElement.parentElement.querySelector('.monaco-tl-twistie').classList.add('force-twistie');
-        const element = append(container, $('.resource-group'));
-        const name = append(element, $('.name'));
-        const actionsContainer = append(element, $('.actions'));
-        const actionBar = ( new ActionBar(actionsContainer, { actionViewItemProvider: this.actionViewItemProvider }));
-        const countContainer = append(element, $('.count'));
-        const count = ( new CountBadge(countContainer, {}, defaultCountBadgeStyles));
-        const disposables = combinedDisposable(actionBar);
-        return { name, count, actionBar, elementDisposables: ( new DisposableStore()), disposables };
-    }
-    renderElement(node, index, template) {
-        const group = node.element;
-        template.name.textContent = group.label;
-        template.actionBar.clear();
-        template.actionBar.context = group;
-        template.count.setCount(group.resources.length);
-        const menus = this.scmViewService.menus.getRepositoryMenus(group.provider);
-        template.elementDisposables.add(connectPrimaryMenuToInlineActionBar(menus.getResourceGroupMenu(group), template.actionBar));
-    }
-    renderCompressedElements(node, index, templateData, height) {
-        throw new Error('Should never happen since node is incompressible');
-    }
-    disposeElement(group, index, template) {
-        template.elementDisposables.clear();
-    }
-    disposeTemplate(template) {
-        template.elementDisposables.dispose();
-        template.disposables.dispose();
-    }
-};
-ResourceGroupRenderer = ResourceGroupRenderer_1 = ( __decorate([
-    ( __param(1, ISCMViewService))
-], ResourceGroupRenderer));
-class RepositoryPaneActionRunner extends ActionRunner {
-    constructor(getSelectedResources) {
-        super();
-        this.getSelectedResources = getSelectedResources;
-    }
-    async runAction(action, context) {
-        if (!(action instanceof MenuItemAction)) {
-            return super.runAction(action, context);
-        }
-        const selection = this.getSelectedResources();
-        const contextIsSelected = ( selection.some(s => s === context));
-        const actualContext = contextIsSelected ? selection : [context];
-        const args = flatten(( actualContext.map(e => ResourceTree.isResourceNode(e) ? ResourceTree.collect(e) : [e])));
-        await action.run(...args);
-    }
-}
-let ResourceRenderer = class ResourceRenderer {
-    static { ResourceRenderer_1 = this; }
-    static { this.TEMPLATE_ID = 'resource'; }
-    get templateId() { return ResourceRenderer_1.TEMPLATE_ID; }
-    constructor(viewMode, labels, actionViewItemProvider, actionRunner, labelService, scmViewService, themeService) {
-        this.viewMode = viewMode;
-        this.labels = labels;
-        this.actionViewItemProvider = actionViewItemProvider;
-        this.actionRunner = actionRunner;
-        this.labelService = labelService;
-        this.scmViewService = scmViewService;
-        this.themeService = themeService;
-        this.disposables = ( new DisposableStore());
-        this.renderedResources = ( new Map());
-        themeService.onDidColorThemeChange(this.onDidColorThemeChange, this, this.disposables);
-    }
-    renderTemplate(container) {
-        const element = append(container, $('.resource'));
-        const name = append(element, $('.name'));
-        const fileLabel = this.labels.create(name, { supportDescriptionHighlights: true, supportHighlights: true });
-        const actionsContainer = append(fileLabel.element, $('.actions'));
-        const actionBar = ( new ActionBar(actionsContainer, {
-            actionViewItemProvider: this.actionViewItemProvider,
-            actionRunner: this.actionRunner
-        }));
-        const decorationIcon = append(element, $('.decoration-icon'));
-        const actionBarMenuListener = ( new MutableDisposable());
-        const disposables = combinedDisposable(actionBar, fileLabel, actionBarMenuListener);
-        return { element, name, fileLabel, decorationIcon, actionBar, actionBarMenu: undefined, actionBarMenuListener, elementDisposables: ( new DisposableStore()), disposables };
-    }
-    renderElement(node, index, template) {
-        const resourceOrFolder = node.element;
-        const iconResource = ResourceTree.isResourceNode(resourceOrFolder) ? resourceOrFolder.element : resourceOrFolder;
-        const uri = ResourceTree.isResourceNode(resourceOrFolder) ? resourceOrFolder.uri : resourceOrFolder.sourceUri;
-        const fileKind = ResourceTree.isResourceNode(resourceOrFolder) ? FileKind.FOLDER : FileKind.FILE;
-        const tooltip = !ResourceTree.isResourceNode(resourceOrFolder) && resourceOrFolder.decorations.tooltip || '';
-        const hidePath = this.viewMode() === "tree" ;
-        let matches;
-        let descriptionMatches;
-        let strikethrough;
-        if (ResourceTree.isResourceNode(resourceOrFolder)) {
-            if (resourceOrFolder.element) {
-                const menus = this.scmViewService.menus.getRepositoryMenus(resourceOrFolder.element.resourceGroup.provider);
-                this._renderActionBar(template, resourceOrFolder, menus.getResourceMenu(resourceOrFolder.element));
-                template.element.classList.toggle('faded', resourceOrFolder.element.decorations.faded);
-                strikethrough = resourceOrFolder.element.decorations.strikeThrough;
-            }
-            else {
-                const menus = this.scmViewService.menus.getRepositoryMenus(resourceOrFolder.context.provider);
-                this._renderActionBar(template, resourceOrFolder, menus.getResourceFolderMenu(resourceOrFolder.context));
-                matches = createMatches(node.filterData);
-                template.element.classList.remove('faded');
-            }
-        }
-        else {
-            const menus = this.scmViewService.menus.getRepositoryMenus(resourceOrFolder.resourceGroup.provider);
-            this._renderActionBar(template, resourceOrFolder, menus.getResourceMenu(resourceOrFolder));
-            [matches, descriptionMatches] = this._processFilterData(uri, node.filterData);
-            template.element.classList.toggle('faded', resourceOrFolder.decorations.faded);
-            strikethrough = resourceOrFolder.decorations.strikeThrough;
-        }
-        const renderedData = {
-            tooltip, uri, fileLabelOptions: { hidePath, fileKind, matches, descriptionMatches, strikethrough }, iconResource
-        };
-        this.renderIcon(template, renderedData);
-        this.renderedResources.set(template, renderedData);
-        template.elementDisposables.add(toDisposable(() => this.renderedResources.delete(template)));
-        template.element.setAttribute('data-tooltip', tooltip);
-    }
-    disposeElement(resource, index, template) {
-        template.elementDisposables.clear();
-    }
-    renderCompressedElements(node, index, template, height) {
-        const compressed = node.element;
-        const folder = compressed.elements[compressed.elements.length - 1];
-        const label = ( compressed.elements.map(e => e.name));
-        const fileKind = FileKind.FOLDER;
-        const matches = createMatches(node.filterData);
-        template.fileLabel.setResource({ resource: folder.uri, name: label }, {
-            fileDecorations: { colors: false, badges: true },
-            fileKind,
-            matches,
-            separator: this.labelService.getSeparator(folder.uri.scheme)
-        });
-        const menus = this.scmViewService.menus.getRepositoryMenus(folder.context.provider);
-        this._renderActionBar(template, folder, menus.getResourceFolderMenu(folder.context));
-        template.name.classList.remove('strike-through');
-        template.element.classList.remove('faded');
-        template.decorationIcon.style.display = 'none';
-        template.decorationIcon.style.backgroundImage = '';
-        template.element.setAttribute('data-tooltip', '');
-    }
-    disposeCompressedElements(node, index, template, height) {
-        template.elementDisposables.clear();
-    }
-    disposeTemplate(template) {
-        template.elementDisposables.dispose();
-        template.disposables.dispose();
-    }
-    _renderActionBar(template, resourceOrFolder, menu) {
-        if (!template.actionBarMenu || template.actionBarMenu !== menu) {
-            template.actionBar.clear();
-            template.actionBarMenu = menu;
-            template.actionBarMenuListener.value = connectPrimaryMenuToInlineActionBar(menu, template.actionBar);
-        }
-        template.actionBar.context = resourceOrFolder;
-    }
-    _processFilterData(uri, filterData) {
-        if (!filterData) {
-            return [undefined, undefined];
-        }
-        if (!filterData.label) {
-            const matches = createMatches(filterData);
-            return [matches, undefined];
-        }
-        const fileName = basename(uri);
-        const label = filterData.label;
-        const pathLength = label.length - fileName.length;
-        const matches = createMatches(filterData.score);
-        if (label === fileName) {
-            return [matches, undefined];
-        }
-        const labelMatches = [];
-        const descriptionMatches = [];
-        for (const match of matches) {
-            if (match.start > pathLength) {
-                labelMatches.push({
-                    start: match.start - pathLength,
-                    end: match.end - pathLength
-                });
-            }
-            else if (match.end < pathLength) {
-                descriptionMatches.push(match);
-            }
-            else {
-                labelMatches.push({
-                    start: 0,
-                    end: match.end - pathLength
-                });
-                descriptionMatches.push({
-                    start: match.start,
-                    end: pathLength
-                });
-            }
-        }
-        return [labelMatches, descriptionMatches];
-    }
-    onDidColorThemeChange() {
-        for (const [template, data] of this.renderedResources) {
-            this.renderIcon(template, data);
-        }
-    }
-    renderIcon(template, data) {
-        const theme = this.themeService.getColorTheme();
-        const icon = theme.type === ColorScheme.LIGHT ? data.iconResource?.decorations.icon : data.iconResource?.decorations.iconDark;
-        template.fileLabel.setFile(data.uri, {
-            ...data.fileLabelOptions,
-            fileDecorations: { colors: false, badges: !icon },
-        });
-        if (icon) {
-            if (ThemeIcon.isThemeIcon(icon)) {
-                template.decorationIcon.className = `decoration-icon ${ThemeIcon.asClassName(icon)}`;
-                if (icon.color) {
-                    template.decorationIcon.style.color = theme.getColor(icon.color.id)?.toString() ?? '';
-                }
-                template.decorationIcon.style.display = '';
-                template.decorationIcon.style.backgroundImage = '';
-            }
-            else {
-                template.decorationIcon.className = 'decoration-icon';
-                template.decorationIcon.style.color = '';
-                template.decorationIcon.style.display = '';
-                template.decorationIcon.style.backgroundImage = asCSSUrl(icon);
-            }
-            template.decorationIcon.title = data.tooltip;
-        }
-        else {
-            template.decorationIcon.className = 'decoration-icon';
-            template.decorationIcon.style.color = '';
-            template.decorationIcon.style.display = 'none';
-            template.decorationIcon.style.backgroundImage = '';
-            template.decorationIcon.title = '';
-        }
-    }
-    dispose() {
-        this.disposables.dispose();
-    }
-};
-ResourceRenderer = ResourceRenderer_1 = ( __decorate([
-    ( __param(4, ILabelService)),
-    ( __param(5, ISCMViewService)),
-    ( __param(6, IThemeService))
-], ResourceRenderer));
-class HistoryItemGroupActionRunner extends ActionRunner {
-    runAction(action, context) {
-        if (!(action instanceof MenuItemAction)) {
-            return super.runAction(action, context);
-        }
-        return action.run(context.repository.provider, context.id);
-    }
-}
-let HistoryItemGroupRenderer = class HistoryItemGroupRenderer {
-    static { HistoryItemGroupRenderer_1 = this; }
-    static { this.TEMPLATE_ID = 'history-item-group'; }
-    get templateId() { return HistoryItemGroupRenderer_1.TEMPLATE_ID; }
-    constructor(actionRunner, contextKeyService, contextMenuService, keybindingService, menuService, scmViewService, telemetryService) {
-        this.actionRunner = actionRunner;
-        this.contextKeyService = contextKeyService;
-        this.contextMenuService = contextMenuService;
-        this.keybindingService = keybindingService;
-        this.menuService = menuService;
-        this.scmViewService = scmViewService;
-        this.telemetryService = telemetryService;
-    }
-    renderTemplate(container) {
-        container.parentElement.parentElement.querySelector('.monaco-tl-twistie').classList.add('force-twistie');
-        const element = append(container, $('.history-item-group'));
-        const label = ( new IconLabel(element, { supportIcons: true }));
-        const iconContainer = prepend(label.element, $('.icon-container'));
-        const templateDisposables = ( new DisposableStore());
-        const toolBar = ( new WorkbenchToolBar(
-            append(element, $('.actions')),
-            { actionRunner: this.actionRunner, menuOptions: { shouldForwardArgs: true } },
-            this.menuService,
-            this.contextKeyService,
-            this.contextMenuService,
-            this.keybindingService,
-            this.telemetryService
-        ));
-        templateDisposables.add(toolBar);
-        const countContainer = append(element, $('.count'));
-        const count = ( new CountBadge(countContainer, {}, defaultCountBadgeStyles));
-        return { iconContainer, label, toolBar, count, elementDisposables: ( new DisposableStore()), templateDisposables };
-    }
-    renderElement(node, index, templateData, height) {
-        const historyItemGroup = node.element;
-        templateData.iconContainer.className = 'icon-container';
-        if (historyItemGroup.icon && ThemeIcon.isThemeIcon(historyItemGroup.icon)) {
-            templateData.iconContainer.classList.add(...ThemeIcon.asClassNameArray(historyItemGroup.icon));
-        }
-        templateData.label.setLabel(historyItemGroup.label, historyItemGroup.description, { title: historyItemGroup.ariaLabel });
-        templateData.count.setCount(historyItemGroup.count ?? 0);
-        const repositoryMenus = this.scmViewService.menus.getRepositoryMenus(historyItemGroup.repository.provider);
-        const historyProviderMenu = repositoryMenus.historyProviderMenu;
-        if (historyProviderMenu) {
-            const menu = historyProviderMenu.getHistoryItemGroupMenu(historyItemGroup);
-            const resetMenuId = historyItemGroup.direction === 'incoming' ? MenuId.SCMIncomingChanges : MenuId.SCMOutgoingChanges;
-            templateData.elementDisposables.add(connectPrimaryMenu(menu, (primary, secondary) => {
-                templateData.toolBar.setActions(primary, secondary, [resetMenuId]);
-            }));
-            templateData.toolBar.context = historyItemGroup;
-        }
-        else {
-            templateData.toolBar.setActions([], []);
-            templateData.toolBar.context = undefined;
-        }
-    }
-    renderCompressedElements(node, index, templateData, height) {
-        throw new Error('Should never happen since node is incompressible');
-    }
-    disposeElement(node, index, templateData, height) {
-        templateData.elementDisposables.clear();
-    }
-    disposeTemplate(templateData) {
-        templateData.elementDisposables.dispose();
-        templateData.templateDisposables.dispose();
-    }
-};
-HistoryItemGroupRenderer = HistoryItemGroupRenderer_1 = ( __decorate([
-    ( __param(1, IContextKeyService)),
-    ( __param(2, IContextMenuService)),
-    ( __param(3, IKeybindingService)),
-    ( __param(4, IMenuService)),
-    ( __param(5, ISCMViewService)),
-    ( __param(6, ITelemetryService))
-], HistoryItemGroupRenderer));
-class HistoryItemActionRunner extends ActionRunner {
-    async runAction(action, context) {
-        if (!(action instanceof MenuItemAction)) {
-            return super.runAction(action, context);
-        }
-        const args = [];
-        args.push(context.historyItemGroup.repository.provider);
-        args.push({
-            id: context.id,
-            parentIds: context.parentIds,
-            label: context.label,
-            description: context.description,
-            icon: context.icon,
-            timestamp: context.timestamp,
-            statistics: context.statistics,
-        });
-        await action.run(...args);
-    }
-}
-let HistoryItemRenderer = class HistoryItemRenderer {
-    static { HistoryItemRenderer_1 = this; }
-    static { this.TEMPLATE_ID = 'history-item'; }
-    get templateId() { return HistoryItemRenderer_1.TEMPLATE_ID; }
-    constructor(actionRunner, actionViewItemProvider, scmViewService) {
-        this.actionRunner = actionRunner;
-        this.actionViewItemProvider = actionViewItemProvider;
-        this.scmViewService = scmViewService;
-    }
-    renderTemplate(container) {
-        container.parentElement.parentElement.querySelector('.monaco-tl-twistie').classList.add('force-twistie');
-        const element = append(container, $('.history-item'));
-        const iconLabel = ( new IconLabel(element, { supportIcons: true }));
-        const iconContainer = prepend(iconLabel.element, $('.icon-container'));
-        const disposables = ( new DisposableStore());
-        const actionsContainer = append(element, $('.actions'));
-        const actionBar = ( new ActionBar(
-            actionsContainer,
-            { actionRunner: this.actionRunner, actionViewItemProvider: this.actionViewItemProvider }
-        ));
-        disposables.add(actionBar);
-        const statsContainer = append(element, $('.stats-container'));
-        const filesLabel = append(statsContainer, $('.files-label'));
-        const insertionsLabel = append(statsContainer, $('.insertions-label'));
-        const deletionsLabel = append(statsContainer, $('.deletions-label'));
-        return { iconContainer, label: iconLabel, actionBar, statsContainer, filesLabel, insertionsLabel, deletionsLabel, elementDisposables: ( new DisposableStore()), disposables };
-    }
-    renderElement(node, index, templateData, height) {
-        const historyItem = node.element;
-        templateData.iconContainer.className = 'icon-container';
-        if (historyItem.icon && ThemeIcon.isThemeIcon(historyItem.icon)) {
-            templateData.iconContainer.classList.add(...ThemeIcon.asClassNameArray(historyItem.icon));
-        }
-        templateData.label.setLabel(historyItem.label, historyItem.description);
-        templateData.actionBar.clear();
-        templateData.actionBar.context = historyItem;
-        const menus = this.scmViewService.menus.getRepositoryMenus(historyItem.historyItemGroup.repository.provider);
-        if (menus.historyProviderMenu) {
-            const historyItemMenu = menus.historyProviderMenu.getHistoryItemMenu(historyItem);
-            templateData.elementDisposables.add(connectPrimaryMenuToInlineActionBar(historyItemMenu, templateData.actionBar));
-        }
-        this.renderStatistics(node, index, templateData, height);
-    }
-    renderCompressedElements(node, index, templateData, height) {
-        throw new Error('Should never happen since node is incompressible');
-    }
-    renderStatistics(node, index, templateData, height) {
-        const historyItem = node.element;
-        if (historyItem.statistics) {
-            const statsAriaLabel = [
-                historyItem.statistics.files === 1 ?
-                    ( localizeWithPath(
-                        'vs/workbench/contrib/scm/browser/scmViewPane',
-                        'fileChanged',
-                        "{0} file changed",
-                        historyItem.statistics.files
-                    )) :
-                    ( localizeWithPath(
-                        'vs/workbench/contrib/scm/browser/scmViewPane',
-                        'filesChanged',
-                        "{0} files changed",
-                        historyItem.statistics.files
-                    )),
-                historyItem.statistics.insertions === 1 ? ( localizeWithPath(
-                    'vs/workbench/contrib/scm/browser/scmViewPane',
-                    'insertion',
-                    "{0} insertion{1}",
-                    historyItem.statistics.insertions,
-                    '(+)'
-                )) :
-                    historyItem.statistics.insertions > 1 ? ( localizeWithPath(
-                        'vs/workbench/contrib/scm/browser/scmViewPane',
-                        'insertions',
-                        "{0} insertions{1}",
-                        historyItem.statistics.insertions,
-                        '(+)'
-                    )) : '',
-                historyItem.statistics.deletions === 1 ? ( localizeWithPath(
-                    'vs/workbench/contrib/scm/browser/scmViewPane',
-                    'deletion',
-                    "{0} deletion{1}",
-                    historyItem.statistics.deletions,
-                    '(-)'
-                )) :
-                    historyItem.statistics.deletions > 1 ? ( localizeWithPath(
-                        'vs/workbench/contrib/scm/browser/scmViewPane',
-                        'deletions',
-                        "{0} deletions{1}",
-                        historyItem.statistics.deletions,
-                        '(-)'
-                    )) : ''
-            ];
-            const statsTitle = statsAriaLabel
-                .filter(l => l !== '').join(', ');
-            templateData.statsContainer.title = statsTitle;
-            templateData.statsContainer.setAttribute('aria-label', statsTitle);
-            templateData.filesLabel.textContent = ( historyItem.statistics.files.toString());
-            templateData.insertionsLabel.textContent = historyItem.statistics.insertions > 0 ? `+${historyItem.statistics.insertions}` : '';
-            templateData.insertionsLabel.classList.toggle('hidden', historyItem.statistics.insertions === 0);
-            templateData.deletionsLabel.textContent = historyItem.statistics.deletions > 0 ? `-${historyItem.statistics.deletions}` : '';
-            templateData.deletionsLabel.classList.toggle('hidden', historyItem.statistics.deletions === 0);
-        }
-        templateData.statsContainer.classList.toggle('hidden', historyItem.statistics === undefined);
-    }
-    disposeElement(element, index, templateData, height) {
-        templateData.elementDisposables.clear();
-    }
-    disposeTemplate(templateData) {
-        templateData.disposables.dispose();
-    }
-};
-HistoryItemRenderer = HistoryItemRenderer_1 = ( __decorate([
-    ( __param(2, ISCMViewService))
-], HistoryItemRenderer));
-let HistoryItemChangeRenderer = class HistoryItemChangeRenderer {
-    static { HistoryItemChangeRenderer_1 = this; }
-    static { this.TEMPLATE_ID = 'historyItemChange'; }
-    get templateId() { return HistoryItemChangeRenderer_1.TEMPLATE_ID; }
-    constructor(viewMode, labels, labelService) {
-        this.viewMode = viewMode;
-        this.labels = labels;
-        this.labelService = labelService;
-    }
-    renderTemplate(container) {
-        const element = append(container, $('.change'));
-        const name = append(element, $('.name'));
-        const fileLabel = this.labels.create(name, { supportDescriptionHighlights: true, supportHighlights: true });
-        const decorationIcon = append(element, $('.decoration-icon'));
-        return { element, name, fileLabel, decorationIcon, disposables: ( new DisposableStore()) };
-    }
-    renderElement(node, index, templateData, height) {
-        const historyItemChangeOrFolder = node.element;
-        const uri = ResourceTree.isResourceNode(historyItemChangeOrFolder) ? historyItemChangeOrFolder.element?.uri ?? historyItemChangeOrFolder.uri : historyItemChangeOrFolder.uri;
-        const fileKind = ResourceTree.isResourceNode(historyItemChangeOrFolder) ? FileKind.FOLDER : FileKind.FILE;
-        const hidePath = this.viewMode() === "tree" ;
-        templateData.fileLabel.setFile(uri, { fileDecorations: { colors: false, badges: true }, fileKind, hidePath, });
-    }
-    renderCompressedElements(node, index, templateData, height) {
-        const compressed = node.element;
-        const folder = compressed.elements[compressed.elements.length - 1];
-        const label = ( compressed.elements.map(e => e.name));
-        templateData.fileLabel.setResource({ resource: folder.uri, name: label }, {
-            fileDecorations: { colors: false, badges: true },
-            fileKind: FileKind.FOLDER,
-            separator: this.labelService.getSeparator(folder.uri.scheme)
-        });
-    }
-    disposeTemplate(templateData) {
-        templateData.disposables.dispose();
-    }
-};
-HistoryItemChangeRenderer = HistoryItemChangeRenderer_1 = ( __decorate([
-    ( __param(2, ILabelService))
-], HistoryItemChangeRenderer));
-let SeparatorRenderer = class SeparatorRenderer {
-    static { SeparatorRenderer_1 = this; }
-    static { this.TEMPLATE_ID = 'separator'; }
-    get templateId() { return SeparatorRenderer_1.TEMPLATE_ID; }
-    constructor(contextKeyService, contextMenuService, keybindingService, menuService, telemetryService) {
-        this.contextKeyService = contextKeyService;
-        this.contextMenuService = contextMenuService;
-        this.keybindingService = keybindingService;
-        this.menuService = menuService;
-        this.telemetryService = telemetryService;
-    }
-    renderTemplate(container) {
-        container.parentElement.parentElement.querySelector('.monaco-tl-twistie').classList.add('force-no-twistie');
-        container.parentElement.parentElement.classList.add('cursor-default', 'force-no-hover');
-        const disposables = ( new DisposableStore());
-        const element = append(container, $('.separator-container'));
-        const label = ( new IconLabel(element, { supportIcons: true, }));
-        append(element, $('.separator'));
-        disposables.add(label);
-        const toolBar = ( new MenuWorkbenchToolBar(
-            append(element, $('.actions')),
-            MenuId.SCMChangesSeparator,
-            { moreIcon: Codicon.gear },
-            this.menuService,
-            this.contextKeyService,
-            this.contextMenuService,
-            this.keybindingService,
-            this.telemetryService
-        ));
-        disposables.add(toolBar);
-        return { label, disposables };
-    }
-    renderElement(element, index, templateData, height) {
-        templateData.label.setLabel(element.element.label, undefined, { title: element.element.ariaLabel });
-    }
-    renderCompressedElements(node, index, templateData, height) {
-        throw new Error('Should never happen since node is incompressible');
-    }
-    disposeTemplate(templateData) {
-        templateData.disposables.dispose();
-    }
-};
-SeparatorRenderer = SeparatorRenderer_1 = ( __decorate([
-    ( __param(0, IContextKeyService)),
-    ( __param(1, IContextMenuService)),
-    ( __param(2, IKeybindingService)),
-    ( __param(3, IMenuService)),
-    ( __param(4, ITelemetryService))
-], SeparatorRenderer));
-class ListDelegate {
-    constructor(inputRenderer) {
-        this.inputRenderer = inputRenderer;
-    }
-    getHeight(element) {
-        if (isSCMInput(element)) {
-            return this.inputRenderer.getHeight(element);
-        }
-        else if (isSCMActionButton(element)) {
-            return ActionButtonRenderer.DEFAULT_HEIGHT + 10;
-        }
-        else {
-            return 22;
-        }
-    }
-    getTemplateId(element) {
-        if (isSCMRepository(element)) {
-            return RepositoryRenderer.TEMPLATE_ID;
-        }
-        else if (isSCMInput(element)) {
-            return InputRenderer.TEMPLATE_ID;
-        }
-        else if (isSCMActionButton(element)) {
-            return ActionButtonRenderer.TEMPLATE_ID;
-        }
-        else if (isSCMResourceGroup(element)) {
-            return ResourceGroupRenderer.TEMPLATE_ID;
-        }
-        else if (isSCMResource(element) || isSCMResourceNode(element)) {
-            return ResourceRenderer.TEMPLATE_ID;
-        }
-        else if (isSCMHistoryItemGroupTreeElement(element)) {
-            return HistoryItemGroupRenderer.TEMPLATE_ID;
-        }
-        else if (isSCMHistoryItemTreeElement(element)) {
-            return HistoryItemRenderer.TEMPLATE_ID;
-        }
-        else if (isSCMHistoryItemChangeTreeElement(element) || isSCMHistoryItemChangeNode(element)) {
-            return HistoryItemChangeRenderer.TEMPLATE_ID;
-        }
-        else if (isSCMViewSeparator(element)) {
-            return SeparatorRenderer.TEMPLATE_ID;
-        }
-        else {
-            throw new Error('Unknown element');
-        }
-    }
-}
-class SCMTreeCompressionDelegate {
-    isIncompressible(element) {
-        if (ResourceTree.isResourceNode(element)) {
-            return element.childrenCount === 0 || !element.parent || !element.parent.parent;
-        }
-        return true;
-    }
-}
-class SCMTreeFilter {
-    filter(element) {
-        if (isSCMResourceGroup(element)) {
-            return element.resources.length > 0 || !element.hideWhenEmpty;
-        }
-        else {
-            return true;
-        }
-    }
-}
-class SCMTreeSorter {
-    constructor(viewMode, viewSortKey) {
-        this.viewMode = viewMode;
-        this.viewSortKey = viewSortKey;
-    }
-    compare(one, other) {
-        if (isSCMRepository(one)) {
-            if (!isSCMRepository(other)) {
-                throw new Error('Invalid comparison');
-            }
-            return 0;
-        }
-        if (isSCMInput(one)) {
-            return -1;
-        }
-        else if (isSCMInput(other)) {
-            return 1;
-        }
-        if (isSCMActionButton(one)) {
-            return -1;
-        }
-        else if (isSCMActionButton(other)) {
-            return 1;
-        }
-        if (isSCMResourceGroup(one)) {
-            return isSCMResourceGroup(other) ? 0 : -1;
-        }
-        if (isSCMViewSeparator(one)) {
-            return isSCMResourceGroup(other) ? 1 : -1;
-        }
-        if (isSCMHistoryItemGroupTreeElement(one)) {
-            return isSCMHistoryItemGroupTreeElement(other) ? 0 : 1;
-        }
-        if (isSCMHistoryItemTreeElement(one)) {
-            if (!isSCMHistoryItemTreeElement(other)) {
-                throw new Error('Invalid comparison');
-            }
-            return 0;
-        }
-        if (isSCMHistoryItemChangeTreeElement(one) || isSCMHistoryItemChangeNode(one)) {
-            if (this.viewMode() === "list" ) {
-                if (!isSCMHistoryItemChangeTreeElement(other)) {
-                    throw new Error('Invalid comparison');
-                }
-                return comparePaths(one.uri.fsPath, other.uri.fsPath);
-            }
-            if (!isSCMHistoryItemChangeTreeElement(other) && !isSCMHistoryItemChangeNode(other)) {
-                throw new Error('Invalid comparison');
-            }
-            const oneName = isSCMHistoryItemChangeNode(one) ? one.name : basename(one.uri);
-            const otherName = isSCMHistoryItemChangeNode(other) ? other.name : basename(other.uri);
-            return compareFileNames(oneName, otherName);
-        }
-        if (this.viewMode() === "list" ) {
-            if (this.viewSortKey() === "name" ) {
-                const oneName = basename(one.sourceUri);
-                const otherName = basename(other.sourceUri);
-                return compareFileNames(oneName, otherName);
-            }
-            if (this.viewSortKey() === "status" ) {
-                const oneTooltip = one.decorations.tooltip ?? '';
-                const otherTooltip = other.decorations.tooltip ?? '';
-                if (oneTooltip !== otherTooltip) {
-                    return compare(oneTooltip, otherTooltip);
-                }
-            }
-            const onePath = one.sourceUri.fsPath;
-            const otherPath = other.sourceUri.fsPath;
-            return comparePaths(onePath, otherPath);
-        }
-        const oneIsDirectory = ResourceTree.isResourceNode(one);
-        const otherIsDirectory = ResourceTree.isResourceNode(other);
-        if (oneIsDirectory !== otherIsDirectory) {
-            return oneIsDirectory ? -1 : 1;
-        }
-        const oneName = ResourceTree.isResourceNode(one) ? one.name : basename(one.sourceUri);
-        const otherName = ResourceTree.isResourceNode(other) ? other.name : basename(other.sourceUri);
-        return compareFileNames(oneName, otherName);
-    }
-}
-let SCMTreeKeyboardNavigationLabelProvider = class SCMTreeKeyboardNavigationLabelProvider {
-    constructor(viewMode, labelService) {
-        this.viewMode = viewMode;
-        this.labelService = labelService;
-    }
-    getKeyboardNavigationLabel(element) {
-        if (ResourceTree.isResourceNode(element)) {
-            return element.name;
-        }
-        else if (isSCMRepository(element) || isSCMInput(element) || isSCMActionButton(element)) {
-            return undefined;
-        }
-        else if (isSCMResourceGroup(element)) {
-            return element.label;
-        }
-        else if (isSCMHistoryItemGroupTreeElement(element)) {
-            return element.label;
-        }
-        else if (isSCMHistoryItemTreeElement(element)) {
-            return element.label;
-        }
-        else if (isSCMViewSeparator(element)) {
-            return element.label;
-        }
-        else {
-            if (this.viewMode() === "list" ) {
-                const uri = isSCMResource(element) ? element.sourceUri : element.uri;
-                return [basename(uri), this.labelService.getUriLabel(uri, { relative: true })];
-            }
-            else {
-                return basename(isSCMResource(element) ? element.sourceUri : element.uri);
-            }
-        }
-    }
-    getCompressedNodeKeyboardNavigationLabel(elements) {
-        const folders = elements;
-        return ( folders.map(e => e.name)).join('/');
-    }
-};
-SCMTreeKeyboardNavigationLabelProvider = ( __decorate([
-    ( __param(1, ILabelService))
-], SCMTreeKeyboardNavigationLabelProvider));
-function getSCMResourceId(element) {
-    if (isSCMRepository(element)) {
-        const provider = element.provider;
-        return `repo:${provider.id}`;
-    }
-    else if (isSCMInput(element)) {
-        const provider = element.repository.provider;
-        return `input:${provider.id}`;
-    }
-    else if (isSCMActionButton(element)) {
-        const provider = element.repository.provider;
-        return `actionButton:${provider.id}`;
-    }
-    else if (isSCMResourceGroup(element)) {
-        const provider = element.provider;
-        return `resourceGroup:${provider.id}/${element.id}`;
-    }
-    else if (isSCMResource(element)) {
-        const group = element.resourceGroup;
-        const provider = group.provider;
-        return `resource:${provider.id}/${group.id}/${( element.sourceUri.toString())}`;
-    }
-    else if (isSCMResourceNode(element)) {
-        const group = element.context;
-        return `folder:${group.provider.id}/${group.id}/$FOLDER/${( element.uri.toString())}`;
-    }
-    else if (isSCMHistoryItemGroupTreeElement(element)) {
-        const provider = element.repository.provider;
-        return `historyItemGroup:${provider.id}/${element.id}`;
-    }
-    else if (isSCMHistoryItemTreeElement(element)) {
-        const historyItemGroup = element.historyItemGroup;
-        const provider = historyItemGroup.repository.provider;
-        return `historyItem:${provider.id}/${historyItemGroup.id}/${element.id}/${element.parentIds.join(',')}`;
-    }
-    else if (isSCMHistoryItemChangeTreeElement(element)) {
-        const historyItem = element.historyItem;
-        const historyItemGroup = historyItem.historyItemGroup;
-        const provider = historyItemGroup.repository.provider;
-        return `historyItemChange:${provider.id}/${historyItemGroup.id}/${historyItem.id}/${( element.uri.toString())}`;
-    }
-    else if (isSCMHistoryItemChangeNode(element)) {
-        const historyItem = element.context;
-        const historyItemGroup = historyItem.historyItemGroup;
-        const provider = historyItemGroup.repository.provider;
-        return `folder:${provider.id}/${historyItemGroup.id}/${historyItem.id}/$FOLDER/${( element.uri.toString())}`;
-    }
-    else if (isSCMViewSeparator(element)) {
-        const provider = element.repository.provider;
-        return `separator:${provider.id}`;
-    }
-    else {
-        throw new Error('Invalid tree element');
-    }
-}
-class SCMResourceIdentityProvider {
-    getId(element) {
-        return getSCMResourceId(element);
-    }
-}
-let SCMAccessibilityProvider = class SCMAccessibilityProvider {
-    constructor(labelService) {
-        this.labelService = labelService;
-    }
-    getWidgetAriaLabel() {
-        return ( localizeWithPath(
-            'vs/workbench/contrib/scm/browser/scmViewPane',
-            'scm',
-            "Source Control Management"
-        ));
-    }
-    getAriaLabel(element) {
-        if (ResourceTree.isResourceNode(element)) {
-            return this.labelService.getUriLabel(element.uri, { relative: true, noPrefix: true }) || element.name;
-        }
-        else if (isSCMRepository(element)) {
-            return `${element.provider.name} ${element.provider.label}`;
-        }
-        else if (isSCMInput(element)) {
-            return ( localizeWithPath(
-                'vs/workbench/contrib/scm/browser/scmViewPane',
-                'input',
-                "Source Control Input"
-            ));
-        }
-        else if (isSCMActionButton(element)) {
-            return element.button?.command.title ?? '';
-        }
-        else if (isSCMResourceGroup(element)) {
-            return element.label;
-        }
-        else if (isSCMHistoryItemGroupTreeElement(element)) {
-            return element.ariaLabel ?? `${element.label.trim()}${element.description ? `, ${element.description}` : ''}`;
-        }
-        else if (isSCMHistoryItemTreeElement(element)) {
-            return `${stripIcons(element.label).trim()}${element.description ? `, ${element.description}` : ''}`;
-        }
-        else if (isSCMHistoryItemChangeTreeElement(element)) {
-            const result = [basename(element.uri)];
-            const path = this.labelService.getUriLabel(dirname(element.uri), { relative: true, noPrefix: true });
-            if (path) {
-                result.push(path);
-            }
-            return result.join(', ');
-        }
-        else if (isSCMViewSeparator(element)) {
-            return element.ariaLabel ?? element.label;
-        }
-        else {
-            const result = [];
-            result.push(basename(element.sourceUri));
-            if (element.decorations.tooltip) {
-                result.push(element.decorations.tooltip);
-            }
-            const path = this.labelService.getUriLabel(dirname(element.sourceUri), { relative: true, noPrefix: true });
-            if (path) {
-                result.push(path);
-            }
-            return result.join(', ');
-        }
-    }
-};
-SCMAccessibilityProvider = ( __decorate([
-    ( __param(0, ILabelService))
-], SCMAccessibilityProvider));
-const Menus = {
-    ViewSort: ( new MenuId('SCMViewSort')),
-    Repositories: ( new MenuId('SCMRepositories')),
-    ChangesSettings: ( new MenuId('SCMChangesSettings')),
-};
-const ContextKeys = {
-    SCMViewMode: ( new RawContextKey('scmViewMode', "list" )),
-    SCMViewSortKey: ( new RawContextKey('scmViewSortKey', "path" )),
-    SCMViewAreAllRepositoriesCollapsed: ( new RawContextKey('scmViewAreAllRepositoriesCollapsed', false)),
-    SCMViewIsAnyRepositoryCollapsible: ( new RawContextKey('scmViewIsAnyRepositoryCollapsible', false)),
-    SCMProvider: ( new RawContextKey('scmProvider', undefined)),
-    SCMProviderRootUri: ( new RawContextKey('scmProviderRootUri', undefined)),
-    SCMProviderHasRootUri: ( new RawContextKey('scmProviderHasRootUri', undefined)),
-    RepositoryCount: ( new RawContextKey('scmRepositoryCount', 0)),
-    RepositoryVisibilityCount: ( new RawContextKey('scmRepositoryVisibleCount', 0)),
-    RepositoryVisibility(repository) {
-        return ( new RawContextKey(`scmRepositoryVisible:${repository.provider.id}`, false));
-    }
-};
-MenuRegistry.appendMenuItem(MenuId.SCMTitle, {
-    title: ( localizeWithPath(
-        'vs/workbench/contrib/scm/browser/scmViewPane',
-        'sortAction',
-        "View & Sort"
-    )),
-    submenu: Menus.ViewSort,
-    when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', VIEW_PANE_ID)), ( ContextKeys.RepositoryCount.notEqualsTo(0)))),
-    group: '0_view&sort',
-    order: 1
-});
-MenuRegistry.appendMenuItem(MenuId.SCMTitle, {
-    title: ( localizeWithPath(
-        'vs/workbench/contrib/scm/browser/scmViewPane',
-        'scmChanges',
-        "Incoming & Outgoing"
-    )),
-    submenu: Menus.ChangesSettings,
-    when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', VIEW_PANE_ID)), ( ContextKeys.RepositoryCount.notEqualsTo(0)))),
-    group: '0_view&sort',
-    order: 2
-});
-MenuRegistry.appendMenuItem(Menus.ViewSort, {
-    title: ( localizeWithPath(
-        'vs/workbench/contrib/scm/browser/scmViewPane',
-        'repositories',
-        "Repositories"
-    )),
-    submenu: Menus.Repositories,
-    when: ContextKeyExpr.greater(ContextKeys.RepositoryCount.key, 1),
-    group: '0_repositories'
-});
-class SCMChangesSettingAction extends Action2 {
-    constructor(settingKey, settingValue, desc) {
-        super({
-            ...desc,
-            f1: false,
-            toggled: ( ContextKeyExpr.equals(`config.${settingKey}`, settingValue)),
-        });
-        this.settingKey = settingKey;
-        this.settingValue = settingValue;
-    }
-    run(accessor) {
-        const configurationService = accessor.get(IConfigurationService);
-        configurationService.updateValue(this.settingKey, this.settingValue);
-    }
-}
-MenuRegistry.appendMenuItem(MenuId.SCMChangesSeparator, {
-    title: ( localizeWithPath(
-        'vs/workbench/contrib/scm/browser/scmViewPane',
-        'incomingChanges',
-        "Show Incoming Changes"
-    )),
-    submenu: MenuId.SCMIncomingChangesSetting,
-    group: '1_incoming&outgoing',
-    order: 1
-});
-MenuRegistry.appendMenuItem(Menus.ChangesSettings, {
-    title: ( localizeWithPath(
-        'vs/workbench/contrib/scm/browser/scmViewPane',
-        'incomingChanges',
-        "Show Incoming Changes"
-    )),
-    submenu: MenuId.SCMIncomingChangesSetting,
-    group: '1_incoming&outgoing',
-    order: 1
-});
-registerAction2(class extends SCMChangesSettingAction {
-    constructor() {
-        super('scm.showIncomingChanges', 'always', {
-            id: 'workbench.scm.action.showIncomingChanges.always',
-            title: ( localizeWithPath('vs/workbench/contrib/scm/browser/scmViewPane', 'always', "Always")),
-            menu: { id: MenuId.SCMIncomingChangesSetting },
-        });
-    }
-});
-registerAction2(class extends SCMChangesSettingAction {
-    constructor() {
-        super('scm.showIncomingChanges', 'auto', {
-            id: 'workbench.scm.action.showIncomingChanges.auto',
-            title: ( localizeWithPath('vs/workbench/contrib/scm/browser/scmViewPane', 'auto', "Auto")),
-            menu: {
-                id: MenuId.SCMIncomingChangesSetting,
-            }
-        });
-    }
-});
-registerAction2(class extends SCMChangesSettingAction {
-    constructor() {
-        super('scm.showIncomingChanges', 'never', {
-            id: 'workbench.scm.action.showIncomingChanges.never',
-            title: ( localizeWithPath('vs/workbench/contrib/scm/browser/scmViewPane', 'never', "Never")),
-            menu: {
-                id: MenuId.SCMIncomingChangesSetting,
-            }
-        });
-    }
-});
-MenuRegistry.appendMenuItem(MenuId.SCMChangesSeparator, {
-    title: ( localizeWithPath(
-        'vs/workbench/contrib/scm/browser/scmViewPane',
-        'outgoingChanges',
-        "Show Outgoing Changes"
-    )),
-    submenu: MenuId.SCMOutgoingChangesSetting,
-    group: '1_incoming&outgoing',
-    order: 2
-});
-MenuRegistry.appendMenuItem(Menus.ChangesSettings, {
-    title: ( localizeWithPath(
-        'vs/workbench/contrib/scm/browser/scmViewPane',
-        'outgoingChanges',
-        "Show Outgoing Changes"
-    )),
-    submenu: MenuId.SCMOutgoingChangesSetting,
-    group: '1_incoming&outgoing',
-    order: 2
-});
-registerAction2(class extends SCMChangesSettingAction {
-    constructor() {
-        super('scm.showOutgoingChanges', 'always', {
-            id: 'workbench.scm.action.showOutgoingChanges.always',
-            title: ( localizeWithPath('vs/workbench/contrib/scm/browser/scmViewPane', 'always', "Always")),
-            menu: {
-                id: MenuId.SCMOutgoingChangesSetting,
-            }
-        });
-    }
-});
-registerAction2(class extends SCMChangesSettingAction {
-    constructor() {
-        super('scm.showOutgoingChanges', 'auto', {
-            id: 'workbench.scm.action.showOutgoingChanges.auto',
-            title: ( localizeWithPath('vs/workbench/contrib/scm/browser/scmViewPane', 'auto', "Auto")),
-            menu: {
-                id: MenuId.SCMOutgoingChangesSetting,
-            }
-        });
-    }
-});
-registerAction2(class extends SCMChangesSettingAction {
-    constructor() {
-        super('scm.showOutgoingChanges', 'never', {
-            id: 'workbench.scm.action.showOutgoingChanges.never',
-            title: ( localizeWithPath('vs/workbench/contrib/scm/browser/scmViewPane', 'never', "Never")),
-            menu: {
-                id: MenuId.SCMOutgoingChangesSetting,
-            }
-        });
-    }
-});
-registerAction2(class extends Action2 {
-    constructor() {
-        super({
-            id: 'workbench.scm.action.scm.showChangesSummary',
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/scm/browser/scmViewPane',
-                'showChangesSummary',
-                "Show Changes Summary"
-            )),
-            f1: false,
-            toggled: ( ContextKeyExpr.equals('config.scm.showChangesSummary', true)),
-            menu: [
-                { id: MenuId.SCMChangesSeparator, order: 3 },
-                { id: Menus.ChangesSettings, order: 3 },
-            ]
-        });
-    }
-    run(accessor) {
-        const configurationService = accessor.get(IConfigurationService);
-        const configValue = configurationService.getValue('scm.showChangesSummary') === true;
-        configurationService.updateValue('scm.showChangesSummary', !configValue);
-    }
-});
-class RepositoryVisibilityAction extends Action2 {
-    constructor(repository) {
-        super({
-            id: `workbench.scm.action.toggleRepositoryVisibility.${repository.provider.id}`,
-            title: repository.provider.name,
-            f1: false,
-            precondition: ( ContextKeyExpr.or(( ContextKeys.RepositoryVisibilityCount.notEqualsTo(1)), ( ContextKeys.RepositoryVisibility(repository).isEqualTo(false)))),
-            toggled: ( ContextKeys.RepositoryVisibility(repository).isEqualTo(true)),
-            menu: { id: Menus.Repositories, group: '0_repositories' }
-        });
-        this.repository = repository;
-    }
-    run(accessor) {
-        const scmViewService = accessor.get(ISCMViewService);
-        scmViewService.toggleVisibility(this.repository);
-    }
-}
-let RepositoryVisibilityActionController = class RepositoryVisibilityActionController {
-    constructor(contextKeyService, scmViewService, scmService) {
-        this.contextKeyService = contextKeyService;
-        this.scmViewService = scmViewService;
-        this.items = ( new Map());
-        this.disposables = ( new DisposableStore());
-        this.repositoryCountContextKey = ContextKeys.RepositoryCount.bindTo(contextKeyService);
-        this.repositoryVisibilityCountContextKey = ContextKeys.RepositoryVisibilityCount.bindTo(contextKeyService);
-        scmViewService.onDidChangeVisibleRepositories(this.onDidChangeVisibleRepositories, this, this.disposables);
-        scmService.onDidAddRepository(this.onDidAddRepository, this, this.disposables);
-        scmService.onDidRemoveRepository(this.onDidRemoveRepository, this, this.disposables);
-        for (const repository of scmService.repositories) {
-            this.onDidAddRepository(repository);
-        }
-    }
-    onDidAddRepository(repository) {
-        const action = registerAction2(class extends RepositoryVisibilityAction {
-            constructor() {
-                super(repository);
-            }
-        });
-        const contextKey = ContextKeys.RepositoryVisibility(repository).bindTo(this.contextKeyService);
-        contextKey.set(this.scmViewService.isVisible(repository));
-        this.items.set(repository, {
-            contextKey,
-            dispose() {
-                contextKey.reset();
-                action.dispose();
-            }
-        });
-        this.updateRepositoryContextKeys();
-    }
-    onDidRemoveRepository(repository) {
-        this.items.get(repository)?.dispose();
-        this.items.delete(repository);
-        this.updateRepositoryContextKeys();
-    }
-    onDidChangeVisibleRepositories() {
-        let count = 0;
-        for (const [repository, item] of this.items) {
-            const isVisible = this.scmViewService.isVisible(repository);
-            item.contextKey.set(isVisible);
-            if (isVisible) {
-                count++;
-            }
-        }
-        this.repositoryCountContextKey.set(this.items.size);
-        this.repositoryVisibilityCountContextKey.set(count);
-    }
-    updateRepositoryContextKeys() {
-        this.repositoryCountContextKey.set(this.items.size);
-        this.repositoryVisibilityCountContextKey.set(Iterable.reduce(( this.items.keys()), (r, repository) => r + (this.scmViewService.isVisible(repository) ? 1 : 0), 0));
-    }
-    dispose() {
-        this.disposables.dispose();
-        dispose(( this.items.values()));
-        this.items.clear();
-    }
-};
-RepositoryVisibilityActionController = ( __decorate([
-    ( __param(0, IContextKeyService)),
-    ( __param(1, ISCMViewService)),
-    ( __param(2, ISCMService))
-], RepositoryVisibilityActionController));
-class SetListViewModeAction extends ViewAction {
-    constructor(id = 'workbench.scm.action.setListViewMode', menu = {}) {
-        super({
-            id,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/scm/browser/scmViewPane',
-                'setListViewMode',
-                "View as List"
-            )),
-            viewId: VIEW_PANE_ID,
-            f1: false,
-            icon: Codicon.listTree,
-            toggled: ( ContextKeys.SCMViewMode.isEqualTo("list" )),
-            menu: { id: Menus.ViewSort, group: '1_viewmode', ...menu }
-        });
-    }
-    async runInView(_, view) {
-        view.viewMode = "list" ;
-    }
-}
-class SetListViewModeNavigationAction extends SetListViewModeAction {
-    constructor() {
-        super('workbench.scm.action.setListViewModeNavigation', {
-            id: MenuId.SCMTitle,
-            when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', VIEW_PANE_ID)), ( ContextKeys.RepositoryCount.notEqualsTo(0)), ( ContextKeys.SCMViewMode.isEqualTo("tree" )))),
-            group: 'navigation',
-            order: -1000
-        });
-    }
-}
-class SetTreeViewModeAction extends ViewAction {
-    constructor(id = 'workbench.scm.action.setTreeViewMode', menu = {}) {
-        super({
-            id,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/scm/browser/scmViewPane',
-                'setTreeViewMode',
-                "View as Tree"
-            )),
-            viewId: VIEW_PANE_ID,
-            f1: false,
-            icon: Codicon.listFlat,
-            toggled: ( ContextKeys.SCMViewMode.isEqualTo("tree" )),
-            menu: { id: Menus.ViewSort, group: '1_viewmode', ...menu }
-        });
-    }
-    async runInView(_, view) {
-        view.viewMode = "tree" ;
-    }
-}
-class SetTreeViewModeNavigationAction extends SetTreeViewModeAction {
-    constructor() {
-        super('workbench.scm.action.setTreeViewModeNavigation', {
-            id: MenuId.SCMTitle,
-            when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', VIEW_PANE_ID)), ( ContextKeys.RepositoryCount.notEqualsTo(0)), ( ContextKeys.SCMViewMode.isEqualTo("list" )))),
-            group: 'navigation',
-            order: -1000
-        });
-    }
-}
-registerAction2(SetListViewModeAction);
-registerAction2(SetTreeViewModeAction);
-registerAction2(SetListViewModeNavigationAction);
-registerAction2(SetTreeViewModeNavigationAction);
-class RepositorySortAction extends ViewAction {
-    constructor(sortKey, title) {
-        super({
-            id: `workbench.scm.action.repositories.setSortKey.${sortKey}`,
-            title,
-            viewId: VIEW_PANE_ID,
-            f1: false,
-            toggled: ( RepositoryContextKeys.RepositorySortKey.isEqualTo(sortKey)),
-            menu: [
-                {
-                    id: Menus.Repositories,
-                    group: '1_sort'
-                },
-                {
-                    id: MenuId.SCMSourceControlTitle,
-                    group: '1_sort',
-                },
-            ]
-        });
-        this.sortKey = sortKey;
-    }
-    runInView(accessor) {
-        accessor.get(ISCMViewService).toggleSortKey(this.sortKey);
-    }
-}
-class RepositorySortByDiscoveryTimeAction extends RepositorySortAction {
-    constructor() {
-        super("discoveryTime" , ( localizeWithPath(
-            'vs/workbench/contrib/scm/browser/scmViewPane',
-            'repositorySortByDiscoveryTime',
-            "Sort by Discovery Time"
-        )));
-    }
-}
-class RepositorySortByNameAction extends RepositorySortAction {
-    constructor() {
-        super("name" , ( localizeWithPath(
-            'vs/workbench/contrib/scm/browser/scmViewPane',
-            'repositorySortByName',
-            "Sort by Name"
-        )));
-    }
-}
-class RepositorySortByPathAction extends RepositorySortAction {
-    constructor() {
-        super("path" , ( localizeWithPath(
-            'vs/workbench/contrib/scm/browser/scmViewPane',
-            'repositorySortByPath',
-            "Sort by Path"
-        )));
-    }
-}
-registerAction2(RepositorySortByDiscoveryTimeAction);
-registerAction2(RepositorySortByNameAction);
-registerAction2(RepositorySortByPathAction);
-class SetSortKeyAction extends ViewAction {
-    constructor(sortKey, title) {
-        super({
-            id: `workbench.scm.action.setSortKey.${sortKey}`,
-            title,
-            viewId: VIEW_PANE_ID,
-            f1: false,
-            toggled: ( ContextKeys.SCMViewSortKey.isEqualTo(sortKey)),
-            precondition: ( ContextKeys.SCMViewMode.isEqualTo("list" )),
-            menu: { id: Menus.ViewSort, group: '2_sort' }
-        });
-        this.sortKey = sortKey;
-    }
-    async runInView(_, view) {
-        view.viewSortKey = this.sortKey;
-    }
-}
-class SetSortByNameAction extends SetSortKeyAction {
-    constructor() {
-        super("name" , ( localizeWithPath(
-            'vs/workbench/contrib/scm/browser/scmViewPane',
-            'sortChangesByName',
-            "Sort Changes by Name"
-        )));
-    }
-}
-class SetSortByPathAction extends SetSortKeyAction {
-    constructor() {
-        super("path" , ( localizeWithPath(
-            'vs/workbench/contrib/scm/browser/scmViewPane',
-            'sortChangesByPath',
-            "Sort Changes by Path"
-        )));
-    }
-}
-class SetSortByStatusAction extends SetSortKeyAction {
-    constructor() {
-        super("status" , ( localizeWithPath(
-            'vs/workbench/contrib/scm/browser/scmViewPane',
-            'sortChangesByStatus',
-            "Sort Changes by Status"
-        )));
-    }
-}
-registerAction2(SetSortByNameAction);
-registerAction2(SetSortByPathAction);
-registerAction2(SetSortByStatusAction);
-class CollapseAllRepositoriesAction extends ViewAction {
-    constructor() {
-        super({
-            id: `workbench.scm.action.collapseAllRepositories`,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/scm/browser/scmViewPane',
-                'collapse all',
-                "Collapse All Repositories"
-            )),
-            viewId: VIEW_PANE_ID,
-            f1: false,
-            icon: Codicon.collapseAll,
-            menu: {
-                id: MenuId.SCMTitle,
-                group: 'navigation',
-                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', VIEW_PANE_ID)), ( ContextKeys.SCMViewIsAnyRepositoryCollapsible.isEqualTo(true)), ( ContextKeys.SCMViewAreAllRepositoriesCollapsed.isEqualTo(false))))
-            }
-        });
-    }
-    async runInView(_, view) {
-        view.collapseAllRepositories();
-    }
-}
-class ExpandAllRepositoriesAction extends ViewAction {
-    constructor() {
-        super({
-            id: `workbench.scm.action.expandAllRepositories`,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/scm/browser/scmViewPane',
-                'expand all',
-                "Expand All Repositories"
-            )),
-            viewId: VIEW_PANE_ID,
-            f1: false,
-            icon: Codicon.expandAll,
-            menu: {
-                id: MenuId.SCMTitle,
-                group: 'navigation',
-                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', VIEW_PANE_ID)), ( ContextKeys.SCMViewIsAnyRepositoryCollapsible.isEqualTo(true)), ( ContextKeys.SCMViewAreAllRepositoriesCollapsed.isEqualTo(true))))
-            }
-        });
-    }
-    async runInView(_, view) {
-        view.expandAllRepositories();
-    }
-}
-registerAction2(CollapseAllRepositoriesAction);
-registerAction2(ExpandAllRepositoriesAction);
-let SCMInputWidgetActionRunner = class SCMInputWidgetActionRunner extends ActionRunner {
-    get runningActions() { return this._runningActions; }
-    constructor(input, storageService) {
-        super();
-        this.input = input;
-        this.storageService = storageService;
-        this._runningActions = ( new Set());
-    }
-    async runAction(action) {
-        try {
-            if (this.runningActions.size !== 0) {
-                this._cts?.cancel();
-                if (action.id === "scm.input.cancelAction" ) {
-                    return;
-                }
-            }
-            const context = [];
-            for (const group of this.input.repository.provider.groups) {
-                context.push({
-                    resourceGroupId: group.id,
-                    resources: [...( group.resources.map(r => r.sourceUri))]
-                });
-            }
-            this._runningActions.add(action);
-            this._cts = ( new CancellationTokenSource());
-            await action.run(...[this.input.repository.provider.rootUri, context, this._cts.token]);
-        }
-        finally {
-            this._runningActions.delete(action);
-            if (this._runningActions.size === 0) {
-                this.storageService.store("scm.input.lastActionId" , action.id, 0 , 0 );
-            }
-        }
-    }
-};
-SCMInputWidgetActionRunner = ( __decorate([
-    ( __param(1, IStorageService))
-], SCMInputWidgetActionRunner));
-let SCMInputWidgetToolbar = class SCMInputWidgetToolbar extends WorkbenchToolBar {
-    get dropdownActions() { return this._dropdownActions; }
-    get dropdownAction() { return this._dropdownAction; }
-    constructor(container, options, menuService, contextKeyService, contextMenuService, commandService, keybindingService, storageService, telemetryService) {
-        super(container, { resetMenu: MenuId.SCMInputBox, ...options }, menuService, contextKeyService, contextMenuService, keybindingService, telemetryService);
-        this.menuService = menuService;
-        this.contextKeyService = contextKeyService;
-        this.storageService = storageService;
-        this._dropdownActions = [];
-        this._onDidChange = ( new Emitter());
-        this.onDidChange = this._onDidChange.event;
-        this.repositoryDisposables = ( new DisposableStore());
-        this._dropdownAction = ( new Action('scmInputMoreActions', ( localizeWithPath(
-            'vs/workbench/contrib/scm/browser/scmViewPane',
-            'scmInputMoreActions',
-            "More Actions..."
-        )), 'codicon-chevron-down'));
-        this._cancelAction = ( new MenuItemAction({
-            id: "scm.input.cancelAction" ,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/scm/browser/scmViewPane',
-                'scmInputCancelAction',
-                "Cancel"
-            )),
-            icon: Codicon.debugStop,
-        }, undefined, undefined, undefined, contextKeyService, commandService));
-    }
-    setInput(input) {
-        this.repositoryDisposables.clear();
-        const contextKeyService = this.contextKeyService.createOverlay([
-            ['scmProvider', input.repository.provider.contextValue],
-            ['scmProviderRootUri', input.repository.provider.rootUri?.toString()],
-            ['scmProviderHasRootUri', !!input.repository.provider.rootUri]
-        ]);
-        const menu = this.repositoryDisposables.add(this.menuService.createMenu(MenuId.SCMInputBox, contextKeyService, { emitEventsForSubmenuChanges: true }));
-        const isEnabled = () => {
-            return ( input.repository.provider.groups.some(g => g.resources.length > 0));
-        };
-        const updateToolbar = () => {
-            const actions = [];
-            createAndFillInActionBarActions(menu, { shouldForwardArgs: true }, actions);
-            for (const action of actions) {
-                action.enabled = isEnabled();
-            }
-            this._dropdownAction.enabled = isEnabled();
-            let primaryAction = undefined;
-            if (actions.length === 1) {
-                primaryAction = actions[0];
-            }
-            else if (actions.length > 1) {
-                const lastActionId = this.storageService.get("scm.input.lastActionId" , 0 , '');
-                primaryAction = actions.find(a => a.id === lastActionId) ?? actions[0];
-            }
-            this._dropdownActions = actions.length === 1 ? [] : actions;
-            super.setActions(primaryAction ? [primaryAction] : [], []);
-            this._onDidChange.fire();
-        };
-        this.repositoryDisposables.add(menu.onDidChange(() => updateToolbar()));
-        this.repositoryDisposables.add(input.repository.provider.onDidChangeResources(() => updateToolbar()));
-        this.repositoryDisposables.add(this.storageService.onDidChangeValue(0 , "scm.input.lastActionId" , this.repositoryDisposables)(() => updateToolbar()));
-        this.actionRunner = ( new SCMInputWidgetActionRunner(input, this.storageService));
-        this.repositoryDisposables.add(this.actionRunner.onWillRun(e => {
-            if (this.actionRunner.runningActions.size === 0) {
-                super.setActions([this._cancelAction], []);
-                this._onDidChange.fire();
-            }
-        }));
-        this.repositoryDisposables.add(this.actionRunner.onDidRun(e => {
-            if (this.actionRunner.runningActions.size === 0) {
-                updateToolbar();
-            }
-        }));
-        updateToolbar();
-    }
-};
-SCMInputWidgetToolbar = ( __decorate([
-    ( __param(2, IMenuService)),
-    ( __param(3, IContextKeyService)),
-    ( __param(4, IContextMenuService)),
-    ( __param(5, ICommandService)),
-    ( __param(6, IKeybindingService)),
-    ( __param(7, IStorageService)),
-    ( __param(8, ITelemetryService))
-], SCMInputWidgetToolbar));
-class SCMInputWidgetEditorOptions {
-    constructor(overflowWidgetsDomNode, configurationService) {
-        this.overflowWidgetsDomNode = overflowWidgetsDomNode;
-        this.configurationService = configurationService;
-        this._onDidChange = ( new Emitter());
-        this.onDidChange = this._onDidChange.event;
-        this.defaultInputFontFamily = DEFAULT_FONT_FAMILY;
-        this._disposables = ( new DisposableStore());
-        const onDidChangeConfiguration = Event.filter(this.configurationService.onDidChangeConfiguration, e => {
-            return e.affectsConfiguration('editor.accessibilitySupport') ||
-                e.affectsConfiguration('editor.cursorBlinking') ||
-                e.affectsConfiguration('editor.fontFamily') ||
-                e.affectsConfiguration('editor.rulers') ||
-                e.affectsConfiguration('editor.wordWrap') ||
-                e.affectsConfiguration('scm.inputFontFamily') ||
-                e.affectsConfiguration('scm.inputFontSize');
-        }, this._disposables);
-        this._disposables.add(onDidChangeConfiguration(() => this._onDidChange.fire()));
-    }
-    getEditorConstructionOptions() {
-        const fontFamily = this._getEditorFontFamily();
-        const fontSize = this._getEditorFontSize();
-        const lineHeight = this._getEditorLineHeight(fontSize);
-        return {
-            ...getSimpleEditorOptions(this.configurationService),
-            ...this._getEditorLanguageConfiguration(),
-            cursorWidth: 1,
-            dragAndDrop: true,
-            dropIntoEditor: { enabled: true },
-            fontFamily: fontFamily,
-            fontSize: fontSize,
-            formatOnType: true,
-            lineDecorationsWidth: 6,
-            lineHeight: lineHeight,
-            overflowWidgetsDomNode: this.overflowWidgetsDomNode,
-            padding: { top: 2, bottom: 2 },
-            quickSuggestions: false,
-            renderWhitespace: 'none',
-            scrollbar: {
-                alwaysConsumeMouseWheel: false,
-                vertical: 'hidden'
-            },
-            wrappingIndent: 'none',
-            wrappingStrategy: 'advanced',
-        };
-    }
-    getEditorOptions() {
-        const fontFamily = this._getEditorFontFamily();
-        const fontSize = this._getEditorFontSize();
-        const lineHeight = this._getEditorLineHeight(fontSize);
-        const accessibilitySupport = this.configurationService.getValue('editor.accessibilitySupport');
-        const cursorBlinking = this.configurationService.getValue('editor.cursorBlinking');
-        return { ...this._getEditorLanguageConfiguration(), accessibilitySupport, cursorBlinking, fontFamily, fontSize, lineHeight };
-    }
-    _getEditorFontFamily() {
-        const inputFontFamily = this.configurationService.getValue('scm.inputFontFamily').trim();
-        if (inputFontFamily.toLowerCase() === 'editor') {
-            return this.configurationService.getValue('editor.fontFamily').trim();
-        }
-        if (inputFontFamily.length !== 0 && inputFontFamily.toLowerCase() !== 'default') {
-            return inputFontFamily;
-        }
-        return this.defaultInputFontFamily;
-    }
-    _getEditorFontSize() {
-        return this.configurationService.getValue('scm.inputFontSize');
-    }
-    _getEditorLanguageConfiguration() {
-        const rulersConfig = this.configurationService.inspect('editor.rulers', { overrideIdentifier: 'scminput' });
-        const rulers = rulersConfig.overrideIdentifiers?.includes('scminput') ? EditorOptions.rulers.validate(rulersConfig.value) : [];
-        const wordWrapConfig = this.configurationService.inspect('editor.wordWrap', { overrideIdentifier: 'scminput' });
-        const wordWrap = wordWrapConfig.overrideIdentifiers?.includes('scminput') ? EditorOptions.wordWrap.validate(wordWrapConfig.value) : 'on';
-        return { rulers, wordWrap };
-    }
-    _getEditorLineHeight(fontSize) {
-        return Math.round(fontSize * 1.5);
-    }
-    dispose() {
-        this._disposables.dispose();
-    }
-}
-let SCMInputWidget = class SCMInputWidget {
-    static { SCMInputWidget_1 = this; }
-    static { this.ValidationTimeouts = {
-        [2 ]: 5000,
-        [1 ]: 8000,
-        [0 ]: 10000
-    }; }
-    get input() {
-        return this.model?.input;
-    }
-    async setInput(input) {
-        if (input === this.input) {
-            return;
-        }
-        this.clearValidation();
-        this.element.classList.remove('synthetic-focus');
-        this.repositoryDisposables.clear();
-        this.repositoryIdContextKey.set(input?.repository.id);
-        if (!input) {
-            this.model?.textModelRef?.dispose();
-            this.inputEditor.setModel(undefined);
-            this.model = undefined;
-            return;
-        }
-        const uri = input.repository.provider.inputBoxDocumentUri;
-        if (this.configurationService.getValue('editor.wordBasedSuggestions', { resource: uri }) !== 'off') {
-            this.configurationService.updateValue('editor.wordBasedSuggestions', 'off', { resource: uri }, 8 );
-        }
-        const modelValue = { input, textModelRef: undefined };
-        this.model = modelValue;
-        const modelRef = await this.textModelService.createModelReference(uri);
-        if (this.model !== modelValue) {
-            modelRef.dispose();
-            return;
-        }
-        modelValue.textModelRef = modelRef;
-        const textModel = modelRef.object.textEditorModel;
-        this.inputEditor.setModel(textModel);
-        const validationDelayer = ( new ThrottledDelayer(200));
-        const validate = async () => {
-            const position = this.inputEditor.getSelection()?.getStartPosition();
-            const offset = position && textModel.getOffsetAt(position);
-            const value = textModel.getValue();
-            this.setValidation(await input.validateInput(value, offset || 0));
-        };
-        const triggerValidation = () => validationDelayer.trigger(validate);
-        this.repositoryDisposables.add(validationDelayer);
-        this.repositoryDisposables.add(this.inputEditor.onDidChangeCursorPosition(triggerValidation));
-        const opts = this.modelService.getCreationOptions(textModel.getLanguageId(), textModel.uri, textModel.isForSimpleWidget);
-        const onEnter = Event.filter(this.inputEditor.onKeyDown, e => e.keyCode === 3 , this.repositoryDisposables);
-        this.repositoryDisposables.add(onEnter(() => textModel.detectIndentation(opts.insertSpaces, opts.tabSize)));
-        textModel.setValue(input.value);
-        this.repositoryDisposables.add(input.onDidChange(({ value, reason }) => {
-            const currentValue = textModel.getValue();
-            if (value === currentValue) {
-                return;
-            }
-            textModel.pushStackElement();
-            textModel.pushEditOperations(null, [EditOperation.replaceMove(textModel.getFullModelRange(), value)], () => []);
-            const position = reason === SCMInputChangeReason.HistoryPrevious
-                ? textModel.getFullModelRange().getStartPosition()
-                : textModel.getFullModelRange().getEndPosition();
-            this.inputEditor.setPosition(position);
-            this.inputEditor.revealPositionInCenterIfOutsideViewport(position);
-        }));
-        this.repositoryDisposables.add(input.onDidChangeFocus(() => this.focus()));
-        this.repositoryDisposables.add(input.onDidChangeValidationMessage((e) => this.setValidation(e, { focus: true, timeout: true })));
-        this.repositoryDisposables.add(input.onDidChangeValidateInput((e) => triggerValidation()));
-        const updatePlaceholderVisibility = () => this.placeholderTextContainer.classList.toggle('hidden', textModel.getValueLength() > 0);
-        this.repositoryDisposables.add(textModel.onDidChangeContent(() => {
-            input.setValue(textModel.getValue(), true);
-            updatePlaceholderVisibility();
-            triggerValidation();
-        }));
-        updatePlaceholderVisibility();
-        const updatePlaceholderText = () => {
-            const binding = this.keybindingService.lookupKeybinding('scm.acceptInput');
-            const label = binding ? binding.getLabel() : (isMacintosh ? 'Cmd+Enter' : 'Ctrl+Enter');
-            const placeholderText = format(input.placeholder, label);
-            this.inputEditor.updateOptions({ ariaLabel: placeholderText });
-            this.placeholderTextContainer.textContent = placeholderText;
-        };
-        this.repositoryDisposables.add(input.onDidChangePlaceholder(updatePlaceholderText));
-        this.repositoryDisposables.add(this.keybindingService.onDidUpdateKeybindings(updatePlaceholderText));
-        updatePlaceholderText();
-        let commitTemplate = '';
-        const updateTemplate = () => {
-            if (typeof input.repository.provider.commitTemplate === 'undefined' || !input.visible) {
-                return;
-            }
-            const oldCommitTemplate = commitTemplate;
-            commitTemplate = input.repository.provider.commitTemplate;
-            const value = textModel.getValue();
-            if (value && value !== oldCommitTemplate) {
-                return;
-            }
-            textModel.setValue(commitTemplate);
-        };
-        this.repositoryDisposables.add(input.repository.provider.onDidChangeCommitTemplate(updateTemplate, this));
-        updateTemplate();
-        const updateEnablement = (enabled) => {
-            this.inputEditor.updateOptions({ readOnly: !enabled });
-        };
-        this.repositoryDisposables.add(input.onDidChangeEnablement(enabled => updateEnablement(enabled)));
-        updateEnablement(input.enabled);
-        this.toolbar.setInput(input);
-    }
-    get selections() {
-        return this.inputEditor.getSelections();
-    }
-    set selections(selections) {
-        if (selections) {
-            this.inputEditor.setSelections(selections);
-        }
-    }
-    setValidation(validation, options) {
-        if (this._validationTimer) {
-            clearTimeout(this._validationTimer);
-            this._validationTimer = 0;
-        }
-        this.validation = validation;
-        this.renderValidation();
-        if (options?.focus && !this.hasFocus()) {
-            this.focus();
-        }
-        if (validation && options?.timeout) {
-            this._validationTimer = setTimeout(() => this.setValidation(undefined), SCMInputWidget_1.ValidationTimeouts[validation.type]);
-        }
-    }
-    constructor(container, overflowWidgetsDomNode, contextKeyService, modelService, textModelService, keybindingService, configurationService, instantiationService, scmViewService, contextViewService, openerService, contextMenuService) {
-        this.modelService = modelService;
-        this.textModelService = textModelService;
-        this.keybindingService = keybindingService;
-        this.configurationService = configurationService;
-        this.instantiationService = instantiationService;
-        this.scmViewService = scmViewService;
-        this.contextViewService = contextViewService;
-        this.openerService = openerService;
-        this.contextMenuService = contextMenuService;
-        this.disposables = ( new DisposableStore());
-        this.repositoryDisposables = ( new DisposableStore());
-        this.validationDisposable = Disposable.None;
-        this.validationHasFocus = false;
-        this.lastLayoutWasTrash = false;
-        this.shouldFocusAfterLayout = false;
-        this.element = append(container, $('.scm-editor'));
-        this.editorContainer = append(this.element, $('.scm-editor-container'));
-        this.placeholderTextContainer = append(this.editorContainer, $('.scm-editor-placeholder'));
-        this.toolbarContainer = append(this.element, $('.scm-editor-toolbar'));
-        this.contextKeyService = contextKeyService.createScoped(this.element);
-        this.repositoryIdContextKey = this.contextKeyService.createKey('scmRepository', undefined);
-        this.inputEditorOptions = ( new SCMInputWidgetEditorOptions(overflowWidgetsDomNode, this.configurationService));
-        this.disposables.add(this.inputEditorOptions.onDidChange(this.onDidChangeEditorOptions, this));
-        this.disposables.add(this.inputEditorOptions);
-        const editorConstructionOptions = this.inputEditorOptions.getEditorConstructionOptions();
-        this.setPlaceholderFontStyles(editorConstructionOptions.fontFamily, editorConstructionOptions.fontSize, editorConstructionOptions.lineHeight);
-        const codeEditorWidgetOptions = {
-            isSimpleWidget: true,
-            contributions: EditorExtensionsRegistry.getSomeEditorContributions([
-                ColorDetector.ID,
-                ContextMenuController.ID,
-                DragAndDropController.ID,
-                DropIntoEditorController.ID,
-                LinkDetector.ID,
-                MenuPreventer.ID,
-                MessageController.ID,
-                HoverController.ID,
-                SelectionClipboardContributionID,
-                SnippetController2.ID,
-                SuggestController.ID,
-                InlineCompletionsController.ID,
-                CodeActionController.ID,
-                FormatOnType.ID,
-                EditorDictation.ID
-            ])
-        };
-        const services = ( new ServiceCollection([IContextKeyService, this.contextKeyService]));
-        const instantiationService2 = instantiationService.createChild(services);
-        this.inputEditor = instantiationService2.createInstance(CodeEditorWidget, this.editorContainer, editorConstructionOptions, codeEditorWidgetOptions);
-        this.disposables.add(this.inputEditor);
-        this.disposables.add(this.inputEditor.onDidFocusEditorText(() => {
-            if (this.input?.repository) {
-                this.scmViewService.focus(this.input.repository);
-            }
-            this.element.classList.add('synthetic-focus');
-            this.renderValidation();
-        }));
-        this.disposables.add(this.inputEditor.onDidBlurEditorText(() => {
-            this.element.classList.remove('synthetic-focus');
-            setTimeout(() => {
-                if (!this.validation || !this.validationHasFocus) {
-                    this.clearValidation();
-                }
-            }, 0);
-        }));
-        const firstLineKey = this.contextKeyService.createKey('scmInputIsInFirstPosition', false);
-        const lastLineKey = this.contextKeyService.createKey('scmInputIsInLastPosition', false);
-        this.disposables.add(this.inputEditor.onDidChangeCursorPosition(({ position }) => {
-            const viewModel = this.inputEditor._getViewModel();
-            const lastLineNumber = viewModel.getLineCount();
-            const lastLineCol = viewModel.getLineLength(lastLineNumber) + 1;
-            const viewPosition = viewModel.coordinatesConverter.convertModelPositionToViewPosition(position);
-            firstLineKey.set(viewPosition.lineNumber === 1 && viewPosition.column === 1);
-            lastLineKey.set(viewPosition.lineNumber === lastLineNumber && viewPosition.column === lastLineCol);
-        }));
-        this.disposables.add(this.inputEditor.onDidScrollChange(e => {
-            this.toolbarContainer.classList.toggle('scroll-decoration', e.scrollTop > 0);
-        }));
-        Event.filter(this.configurationService.onDidChangeConfiguration, e => e.affectsConfiguration('scm.showInputActionButton'))(() => this.layout(), this, this.disposables);
-        this.onDidChangeContentHeight = Event.signal(Event.filter(this.inputEditor.onDidContentSizeChange, e => e.contentHeightChanged, this.disposables));
-        this.toolbar = instantiationService2.createInstance(SCMInputWidgetToolbar, this.toolbarContainer, {
-            actionViewItemProvider: (action, options) => {
-                if (action instanceof MenuItemAction && this.toolbar.dropdownActions.length > 1) {
-                    return instantiationService.createInstance(DropdownWithPrimaryActionViewItem, action, this.toolbar.dropdownAction, this.toolbar.dropdownActions, '', this.contextMenuService, { actionRunner: this.toolbar.actionRunner, hoverDelegate: options.hoverDelegate });
-                }
-                return createActionViewItem(instantiationService, action, options);
-            },
-            menuOptions: {
-                shouldForwardArgs: true
-            }
-        });
-        this.disposables.add(this.toolbar.onDidChange(() => this.layout()));
-        this.disposables.add(this.toolbar);
-    }
-    getContentHeight() {
-        const lineHeight = this.inputEditor.getOption(67 );
-        const { top, bottom } = this.inputEditor.getOption(84 );
-        const inputMinLinesConfig = this.configurationService.getValue('scm.inputMinLineCount');
-        const inputMinLines = typeof inputMinLinesConfig === 'number' ? clamp(inputMinLinesConfig, 1, 50) : 1;
-        const editorMinHeight = inputMinLines * lineHeight + top + bottom;
-        const inputMaxLinesConfig = this.configurationService.getValue('scm.inputMaxLineCount');
-        const inputMaxLines = typeof inputMaxLinesConfig === 'number' ? clamp(inputMaxLinesConfig, 1, 50) : 10;
-        const editorMaxHeight = inputMaxLines * lineHeight + top + bottom;
-        return clamp(this.inputEditor.getContentHeight(), editorMinHeight, editorMaxHeight);
-    }
-    layout() {
-        const editorHeight = this.getContentHeight();
-        const toolbarWidth = this.getToolbarWidth();
-        const dimension = ( new Dimension(this.element.clientWidth - toolbarWidth, editorHeight));
-        if (dimension.width < 0) {
-            this.lastLayoutWasTrash = true;
-            return;
-        }
-        this.lastLayoutWasTrash = false;
-        this.inputEditor.layout(dimension);
-        this.placeholderTextContainer.style.width = `${dimension.width}px`;
-        this.renderValidation();
-        const showInputActionButton = this.configurationService.getValue('scm.showInputActionButton') === true;
-        this.toolbarContainer.classList.toggle('hidden', !showInputActionButton || this.toolbar?.isEmpty() === true);
-        if (this.shouldFocusAfterLayout) {
-            this.shouldFocusAfterLayout = false;
-            this.focus();
-        }
-    }
-    focus() {
-        if (this.lastLayoutWasTrash) {
-            this.lastLayoutWasTrash = false;
-            this.shouldFocusAfterLayout = true;
-            return;
-        }
-        this.inputEditor.focus();
-        this.element.classList.add('synthetic-focus');
-    }
-    hasFocus() {
-        return this.inputEditor.hasTextFocus();
-    }
-    onDidChangeEditorOptions() {
-        const editorOptions = this.inputEditorOptions.getEditorOptions();
-        this.inputEditor.updateOptions(editorOptions);
-        this.setPlaceholderFontStyles(editorOptions.fontFamily, editorOptions.fontSize, editorOptions.lineHeight);
-    }
-    renderValidation() {
-        this.clearValidation();
-        this.element.classList.toggle('validation-info', this.validation?.type === 2 );
-        this.element.classList.toggle('validation-warning', this.validation?.type === 1 );
-        this.element.classList.toggle('validation-error', this.validation?.type === 0 );
-        if (!this.validation || !this.inputEditor.hasTextFocus()) {
-            return;
-        }
-        const disposables = ( new DisposableStore());
-        this.validationDisposable = this.contextViewService.showContextView({
-            getAnchor: () => this.element,
-            render: container => {
-                this.element.style.borderBottomLeftRadius = '0';
-                this.element.style.borderBottomRightRadius = '0';
-                const validationContainer = append(container, $('.scm-editor-validation-container'));
-                validationContainer.classList.toggle('validation-info', this.validation.type === 2 );
-                validationContainer.classList.toggle('validation-warning', this.validation.type === 1 );
-                validationContainer.classList.toggle('validation-error', this.validation.type === 0 );
-                validationContainer.style.width = `${this.element.clientWidth + 2}px`;
-                const element = append(validationContainer, $('.scm-editor-validation'));
-                const message = this.validation.message;
-                if (typeof message === 'string') {
-                    element.textContent = message;
-                }
-                else {
-                    const tracker = trackFocus(element);
-                    disposables.add(tracker);
-                    disposables.add(tracker.onDidFocus(() => (this.validationHasFocus = true)));
-                    disposables.add(tracker.onDidBlur(() => {
-                        this.validationHasFocus = false;
-                        this.element.style.borderBottomLeftRadius = '2px';
-                        this.element.style.borderBottomRightRadius = '2px';
-                        this.contextViewService.hideContextView();
-                    }));
-                    const renderer = disposables.add(this.instantiationService.createInstance(MarkdownRenderer, {}));
-                    const renderedMarkdown = renderer.render(message, {
-                        actionHandler: {
-                            callback: (link) => {
-                                openLinkFromMarkdown(this.openerService, link, message.isTrusted);
-                                this.element.style.borderBottomLeftRadius = '2px';
-                                this.element.style.borderBottomRightRadius = '2px';
-                                this.contextViewService.hideContextView();
-                            },
-                            disposables: disposables
-                        },
-                    });
-                    disposables.add(renderedMarkdown);
-                    element.appendChild(renderedMarkdown.element);
-                }
-                const actionsContainer = append(validationContainer, $('.scm-editor-validation-actions'));
-                const actionbar = ( new ActionBar(actionsContainer));
-                const action = ( new Action('scmInputWidget.validationMessage.close', ( localizeWithPath('vs/workbench/contrib/scm/browser/scmViewPane', 'label.close', "Close")), ThemeIcon.asClassName(Codicon.close), true, () => {
-                    this.contextViewService.hideContextView();
-                    this.element.style.borderBottomLeftRadius = '2px';
-                    this.element.style.borderBottomRightRadius = '2px';
-                }));
-                disposables.add(actionbar);
-                actionbar.push(action, { icon: true, label: false });
-                return Disposable.None;
-            },
-            onHide: () => {
-                this.validationHasFocus = false;
-                this.element.style.borderBottomLeftRadius = '2px';
-                this.element.style.borderBottomRightRadius = '2px';
-                disposables.dispose();
-            },
-            anchorAlignment: 0
-        });
-    }
-    getToolbarWidth() {
-        const showInputActionButton = this.configurationService.getValue('scm.showInputActionButton');
-        if (!this.toolbar || !showInputActionButton || this.toolbar?.isEmpty() === true) {
-            return 0;
-        }
-        return this.toolbar.dropdownActions.length === 0 ?
-            26  :
-            39 ;
-    }
-    setPlaceholderFontStyles(fontFamily, fontSize, lineHeight) {
-        this.placeholderTextContainer.style.fontFamily = fontFamily;
-        this.placeholderTextContainer.style.fontSize = `${fontSize}px`;
-        this.placeholderTextContainer.style.lineHeight = `${lineHeight}px`;
-    }
-    clearValidation() {
-        this.validationDisposable.dispose();
-        this.validationHasFocus = false;
-    }
-    dispose() {
-        this.setInput(undefined);
-        this.repositoryDisposables.dispose();
-        this.clearValidation();
-        this.disposables.dispose();
-    }
-};
-SCMInputWidget = SCMInputWidget_1 = ( __decorate([
-    ( __param(2, IContextKeyService)),
-    ( __param(3, IModelService)),
-    ( __param(4, ITextModelService)),
-    ( __param(5, IKeybindingService)),
-    ( __param(6, IConfigurationService)),
-    ( __param(7, IInstantiationService)),
-    ( __param(8, ISCMViewService)),
-    ( __param(9, IContextViewService)),
-    ( __param(10, IOpenerService)),
-    ( __param(11, IContextMenuService))
-], SCMInputWidget));
-let SCMViewPane = class SCMViewPane extends ViewPane {
-    get viewMode() { return this._viewMode; }
-    set viewMode(mode) {
-        if (this._viewMode === mode) {
-            return;
-        }
-        this._viewMode = mode;
-        this.viewSortKey = this.getViewSortKey();
-        this.updateChildren();
-        this.onDidActiveEditorChange();
-        this._onDidChangeViewMode.fire(mode);
-        this.viewModeContextKey.set(mode);
-        this.updateIndentStyles(this.themeService.getFileIconTheme());
-        this.storageService.store(`scm.viewMode`, mode, 1 , 0 );
-    }
-    get viewSortKey() { return this._viewSortKey; }
-    set viewSortKey(sortKey) {
-        if (this._viewSortKey === sortKey) {
-            return;
-        }
-        this._viewSortKey = sortKey;
-        this.updateChildren();
-        this.viewSortKeyContextKey.set(sortKey);
-        this._onDidChangeViewSortKey.fire(sortKey);
-        if (this._viewMode === "list" ) {
-            this.storageService.store(`scm.viewSortKey`, sortKey, 1 , 0 );
-        }
-    }
-    constructor(options, commandService, editorService, logService, menuService, scmService, scmViewService, storageService, uriIdentityService, keybindingService, themeService, contextMenuService, instantiationService, viewDescriptorService, configurationService, contextKeyService, openerService, telemetryService) {
-        super({ ...options, titleMenuId: MenuId.SCMTitle }, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
-        this.commandService = commandService;
-        this.editorService = editorService;
-        this.logService = logService;
-        this.menuService = menuService;
-        this.scmService = scmService;
-        this.scmViewService = scmViewService;
-        this.storageService = storageService;
-        this.uriIdentityService = uriIdentityService;
-        this._onDidChangeViewMode = ( new Emitter());
-        this.onDidChangeViewMode = this._onDidChangeViewMode.event;
-        this._onDidChangeViewSortKey = ( new Emitter());
-        this.onDidChangeViewSortKey = this._onDidChangeViewSortKey.event;
-        this.items = ( new DisposableMap());
-        this.visibilityDisposables = ( new DisposableStore());
-        this.treeOperationSequencer = ( new Sequencer());
-        this.revealResourceThrottler = ( new Throttler());
-        this.updateChildrenThrottler = ( new Throttler());
-        this.disposables = ( new DisposableStore());
-        this._viewMode = this.getViewMode();
-        this._viewSortKey = this.getViewSortKey();
-        this.viewModeContextKey = ContextKeys.SCMViewMode.bindTo(contextKeyService);
-        this.viewModeContextKey.set(this._viewMode);
-        this.viewSortKeyContextKey = ContextKeys.SCMViewSortKey.bindTo(contextKeyService);
-        this.viewSortKeyContextKey.set(this.viewSortKey);
-        this.areAllRepositoriesCollapsedContextKey = ContextKeys.SCMViewAreAllRepositoriesCollapsed.bindTo(contextKeyService);
-        this.isAnyRepositoryCollapsibleContextKey = ContextKeys.SCMViewIsAnyRepositoryCollapsible.bindTo(contextKeyService);
-        this.scmProviderContextKey = ContextKeys.SCMProvider.bindTo(contextKeyService);
-        this.scmProviderRootUriContextKey = ContextKeys.SCMProviderRootUri.bindTo(contextKeyService);
-        this.scmProviderHasRootUriContextKey = ContextKeys.SCMProviderHasRootUri.bindTo(contextKeyService);
-        this._onDidLayout = ( new Emitter());
-        this.layoutCache = { height: undefined, width: undefined, onDidChange: this._onDidLayout.event };
-        this.storageService.onDidChangeValue(1 , undefined, this.disposables)(e => {
-            switch (e.key) {
-                case 'scm.viewMode':
-                    this.viewMode = this.getViewMode();
-                    break;
-                case 'scm.viewSortKey':
-                    this.viewSortKey = this.getViewSortKey();
-                    break;
-            }
-        }, this, this.disposables);
-        this.storageService.onWillSaveState(e => {
-            this.viewMode = this.getViewMode();
-            this.viewSortKey = this.getViewSortKey();
-            this.storeTreeViewState();
-        }, this, this.disposables);
-        this.disposables.add(this.instantiationService.createInstance(ScmInputContentProvider));
-        Event.any(this.scmService.onDidAddRepository, this.scmService.onDidRemoveRepository)(() => this._onDidChangeViewWelcomeState.fire(), this, this.disposables);
-        this.disposables.add(this.revealResourceThrottler);
-        this.disposables.add(this.updateChildrenThrottler);
-    }
-    layoutBody(height = this.layoutCache.height, width = this.layoutCache.width) {
-        if (height === undefined) {
-            return;
-        }
-        if (width !== undefined) {
-            super.layoutBody(height, width);
-        }
-        this.layoutCache.height = height;
-        this.layoutCache.width = width;
-        this._onDidLayout.fire();
-        this.treeContainer.style.height = `${height}px`;
-        this.tree.layout(height, width);
-    }
-    renderBody(container) {
-        super.renderBody(container);
-        this.treeContainer = append(container, $('.scm-view.show-file-icons'));
-        this.treeContainer.classList.add('file-icon-themable-tree');
-        this.treeContainer.classList.add('show-file-icons');
-        const updateActionsVisibility = () => this.treeContainer.classList.toggle('show-actions', this.configurationService.getValue('scm.alwaysShowActions'));
-        Event.filter(this.configurationService.onDidChangeConfiguration, e => e.affectsConfiguration('scm.alwaysShowActions'), this.disposables)(updateActionsVisibility, this, this.disposables);
-        updateActionsVisibility();
-        const updateProviderCountVisibility = () => {
-            const value = this.configurationService.getValue('scm.providerCountBadge');
-            this.treeContainer.classList.toggle('hide-provider-counts', value === 'hidden');
-            this.treeContainer.classList.toggle('auto-provider-counts', value === 'auto');
-        };
-        Event.filter(this.configurationService.onDidChangeConfiguration, e => e.affectsConfiguration('scm.providerCountBadge'), this.disposables)(updateProviderCountVisibility, this, this.disposables);
-        updateProviderCountVisibility();
-        const viewState = this.loadTreeViewState();
-        this.createTree(this.treeContainer, viewState);
-        this.onDidChangeBodyVisibility(async (visible) => {
-            if (visible) {
-                await this.tree.setInput(this.scmViewService, viewState);
-                Event.filter(this.configurationService.onDidChangeConfiguration, e => e.affectsConfiguration('scm.alwaysShowRepositories'), this.visibilityDisposables)(() => {
-                    this.updateActions();
-                    this.updateChildren();
-                }, this, this.visibilityDisposables);
-                Event.filter(this.configurationService.onDidChangeConfiguration, e => e.affectsConfiguration('scm.inputMinLineCount') ||
-                    e.affectsConfiguration('scm.inputMaxLineCount') ||
-                    e.affectsConfiguration('scm.showActionButton') ||
-                    e.affectsConfiguration('scm.showChangesSummary') ||
-                    e.affectsConfiguration('scm.showIncomingChanges') ||
-                    e.affectsConfiguration('scm.showOutgoingChanges'), this.visibilityDisposables)(() => this.updateChildren(), this, this.visibilityDisposables);
-                this.editorService.onDidActiveEditorChange(this.onDidActiveEditorChange, this, this.visibilityDisposables);
-                this.scmViewService.onDidChangeVisibleRepositories(this.onDidChangeVisibleRepositories, this, this.visibilityDisposables);
-                this.onDidChangeVisibleRepositories({ added: this.scmViewService.visibleRepositories, removed: Iterable.empty() });
-                if (typeof this.treeScrollTop === 'number') {
-                    this.tree.scrollTop = this.treeScrollTop;
-                    this.treeScrollTop = undefined;
-                }
-            }
-            else {
-                this.visibilityDisposables.clear();
-                this.onDidChangeVisibleRepositories({ added: Iterable.empty(), removed: [...( this.items.keys())] });
-                this.treeScrollTop = this.tree.scrollTop;
-            }
-            this.updateRepositoryCollapseAllContextKeys();
-        }, this, this.disposables);
-        this.disposables.add(this.instantiationService.createInstance(RepositoryVisibilityActionController));
-        this.themeService.onDidFileIconThemeChange(this.updateIndentStyles, this, this.disposables);
-        this.updateIndentStyles(this.themeService.getFileIconTheme());
-    }
-    createTree(container, viewState) {
-        const overflowWidgetsDomNode = $('.scm-overflow-widgets-container.monaco-editor');
-        this.inputRenderer = this.instantiationService.createInstance(InputRenderer, this.layoutCache, overflowWidgetsDomNode, (input, height) => { this.tree.updateElementHeight(input, height); });
-        this.actionButtonRenderer = this.instantiationService.createInstance(ActionButtonRenderer);
-        this.listLabels = this.instantiationService.createInstance(ResourceLabels, { onDidChangeVisibility: this.onDidChangeBodyVisibility });
-        this.disposables.add(this.listLabels);
-        const resourceActionRunner = ( new RepositoryPaneActionRunner(() => this.getSelectedResources()));
-        resourceActionRunner.onWillRun(() => this.tree.domFocus(), this, this.disposables);
-        this.disposables.add(resourceActionRunner);
-        const historyItemGroupActionRunner = ( new HistoryItemGroupActionRunner());
-        historyItemGroupActionRunner.onWillRun(() => this.tree.domFocus(), this, this.disposables);
-        this.disposables.add(historyItemGroupActionRunner);
-        const historyItemActionRunner = ( new HistoryItemActionRunner());
-        historyItemActionRunner.onWillRun(() => this.tree.domFocus(), this, this.disposables);
-        this.disposables.add(historyItemActionRunner);
-        const treeDataSource = this.instantiationService.createInstance(SCMTreeDataSource, () => this.viewMode);
-        this.disposables.add(treeDataSource);
-        this.tree = this.instantiationService.createInstance(WorkbenchCompressibleAsyncDataTree, 'SCM Tree Repo', container, ( new ListDelegate(this.inputRenderer)), ( new SCMTreeCompressionDelegate()), [
-            this.inputRenderer,
-            this.actionButtonRenderer,
-            this.instantiationService.createInstance(RepositoryRenderer, MenuId.SCMTitle, getActionViewItemProvider(this.instantiationService)),
-            this.instantiationService.createInstance(ResourceGroupRenderer, getActionViewItemProvider(this.instantiationService)),
-            this.instantiationService.createInstance(ResourceRenderer, () => this.viewMode, this.listLabels, getActionViewItemProvider(this.instantiationService), resourceActionRunner),
-            this.instantiationService.createInstance(HistoryItemGroupRenderer, historyItemGroupActionRunner),
-            this.instantiationService.createInstance(HistoryItemRenderer, historyItemActionRunner, getActionViewItemProvider(this.instantiationService)),
-            this.instantiationService.createInstance(HistoryItemChangeRenderer, () => this.viewMode, this.listLabels),
-            this.instantiationService.createInstance(SeparatorRenderer)
-        ], treeDataSource, {
-            horizontalScrolling: false,
-            setRowLineHeight: false,
-            transformOptimization: false,
-            filter: ( new SCMTreeFilter()),
-            dnd: ( new SCMTreeDragAndDrop(this.instantiationService)),
-            identityProvider: ( new SCMResourceIdentityProvider()),
-            sorter: ( new SCMTreeSorter(() => this.viewMode, () => this.viewSortKey)),
-            keyboardNavigationLabelProvider: this.instantiationService.createInstance(SCMTreeKeyboardNavigationLabelProvider, () => this.viewMode),
-            overrideStyles: {
-                listBackground: this.viewDescriptorService.getViewLocationById(this.id) === 1  ? PANEL_BACKGROUND : SIDE_BAR_BACKGROUND
-            },
-            collapseByDefault: (e) => {
-                if (isSCMRepository(e) || isSCMResourceGroup(e) || isSCMResourceNode(e) || isSCMHistoryItemChangeNode(e)) {
-                    return false;
-                }
-                return (viewState?.expanded ?? []).indexOf(getSCMResourceId(e)) === -1;
-            },
-            accessibilityProvider: this.instantiationService.createInstance(SCMAccessibilityProvider)
-        });
-        this.disposables.add(this.tree);
-        this.tree.onDidOpen(this.open, this, this.disposables);
-        this.tree.onContextMenu(this.onListContextMenu, this, this.disposables);
-        this.tree.onDidScroll(this.inputRenderer.clearValidation, this.inputRenderer, this.disposables);
-        Event.filter(this.tree.onDidChangeCollapseState, e => isSCMRepository(e.node.element?.element), this.disposables)(this.updateRepositoryCollapseAllContextKeys, this, this.disposables);
-        append(container, overflowWidgetsDomNode);
-    }
-    async open(e) {
-        if (!e.element) {
-            return;
-        }
-        else if (isSCMRepository(e.element)) {
-            this.scmViewService.focus(e.element);
-            return;
-        }
-        else if (isSCMInput(e.element)) {
-            this.scmViewService.focus(e.element.repository);
-            const widgets = this.inputRenderer.getRenderedInputWidget(e.element);
-            if (widgets) {
-                for (const widget of widgets) {
-                    widget.focus();
-                }
-                this.tree.setFocus([], e.browserEvent);
-                const selection = this.tree.getSelection();
-                if (selection.length === 1 && selection[0] === e.element) {
-                    setTimeout(() => this.tree.setSelection([]));
-                }
-            }
-            return;
-        }
-        else if (isSCMActionButton(e.element)) {
-            this.scmViewService.focus(e.element.repository);
-            this.actionButtonRenderer.focusActionButton(e.element);
-            this.tree.setFocus([], e.browserEvent);
-            return;
-        }
-        else if (isSCMResourceGroup(e.element)) {
-            const provider = e.element.provider;
-            const repository = Iterable.find(this.scmService.repositories, r => r.provider === provider);
-            if (repository) {
-                this.scmViewService.focus(repository);
-            }
-            return;
-        }
-        else if (isSCMResource(e.element)) {
-            if (e.element.command?.id === API_OPEN_EDITOR_COMMAND_ID || e.element.command?.id === API_OPEN_DIFF_EDITOR_COMMAND_ID) {
-                await this.commandService.executeCommand(e.element.command.id, ...(e.element.command.arguments || []), e);
-            }
-            else {
-                await e.element.open(!!e.editorOptions.preserveFocus);
-                if (e.editorOptions.pinned) {
-                    const activeEditorPane = this.editorService.activeEditorPane;
-                    activeEditorPane?.group.pinEditor(activeEditorPane.input);
-                }
-            }
-            const provider = e.element.resourceGroup.provider;
-            const repository = Iterable.find(this.scmService.repositories, r => r.provider === provider);
-            if (repository) {
-                this.scmViewService.focus(repository);
-            }
-        }
-        else if (isSCMResourceNode(e.element)) {
-            const provider = e.element.context.provider;
-            const repository = Iterable.find(this.scmService.repositories, r => r.provider === provider);
-            if (repository) {
-                this.scmViewService.focus(repository);
-            }
-            return;
-        }
-        else if (isSCMHistoryItemGroupTreeElement(e.element)) {
-            this.scmViewService.focus(e.element.repository);
-            return;
-        }
-        else if (isSCMHistoryItemTreeElement(e.element)) {
-            this.scmViewService.focus(e.element.historyItemGroup.repository);
-            return;
-        }
-        else if (isSCMHistoryItemChangeTreeElement(e.element)) {
-            if (e.element.originalUri && e.element.modifiedUri) {
-                await this.commandService.executeCommand(API_OPEN_DIFF_EDITOR_COMMAND_ID, ...toDiffEditorArguments(e.element.uri, e.element.originalUri, e.element.modifiedUri), e);
-            }
-            this.scmViewService.focus(e.element.historyItem.historyItemGroup.repository);
-            return;
-        }
-        else if (isSCMHistoryItemChangeNode(e.element)) {
-            this.scmViewService.focus(e.element.context.historyItemGroup.repository);
-            return;
-        }
-    }
-    onDidActiveEditorChange() {
-        if (!this.configurationService.getValue('scm.autoReveal')) {
-            return;
-        }
-        const uri = EditorResourceAccessor.getOriginalUri(this.editorService.activeEditor, { supportSideBySide: SideBySideEditor.PRIMARY });
-        if (!uri) {
-            return;
-        }
-        if (( this.tree.getFocus().some(
-            e => isSCMResource(e) && this.uriIdentityService.extUri.isEqual(e.sourceUri, uri)
-        )) &&
-            ( this.tree.getSelection().some(
-                e => isSCMResource(e) && this.uriIdentityService.extUri.isEqual(e.sourceUri, uri)
-            ))) {
-            return;
-        }
-        this.revealResourceThrottler.queue(() => this.treeOperationSequencer.queue(async () => {
-            for (const repository of this.scmViewService.visibleRepositories) {
-                const item = this.items.get(repository);
-                if (!item) {
-                    continue;
-                }
-                for (let j = repository.provider.groups.length - 1; j >= 0; j--) {
-                    const groupItem = repository.provider.groups[j];
-                    const resource = this.viewMode === "tree"
-                        ? groupItem.resourceTree.getNode(uri)?.element
-                        : groupItem.resources.find(r => this.uriIdentityService.extUri.isEqual(r.sourceUri, uri));
-                    if (resource) {
-                        await this.tree.expandTo(resource);
-                        this.tree.setSelection([resource]);
-                        this.tree.setFocus([resource]);
-                        return;
-                    }
-                }
-            }
-        }));
-    }
-    onDidChangeVisibleRepositories({ added, removed }) {
-        for (const repository of added) {
-            const repositoryDisposables = ( new DisposableStore());
-            repositoryDisposables.add(repository.provider.onDidChange(() => this.updateChildren(repository)));
-            repositoryDisposables.add(repository.input.onDidChangeVisibility(() => this.updateChildren(repository)));
-            repositoryDisposables.add(repository.provider.onDidChangeResourceGroups(() => this.updateChildren(repository)));
-            repositoryDisposables.add(Event.runAndSubscribe(repository.provider.onDidChangeHistoryProvider, () => {
-                if (!repository.provider.historyProvider) {
-                    this.logService.debug('SCMViewPane:onDidChangeVisibleRepositories - no history provider present');
-                    return;
-                }
-                repositoryDisposables.add(repository.provider.historyProvider.onDidChangeCurrentHistoryItemGroup(() => {
-                    this.updateChildren(repository);
-                    this.logService.debug('SCMViewPane:onDidChangeCurrentHistoryItemGroup - update children');
-                }));
-                this.logService.debug('SCMViewPane:onDidChangeVisibleRepositories - onDidChangeCurrentHistoryItemGroup listener added');
-            }));
-            const resourceGroupDisposables = repositoryDisposables.add(( new DisposableMap()));
-            const onDidChangeResourceGroups = () => {
-                for (const [resourceGroup] of resourceGroupDisposables) {
-                    if (!repository.provider.groups.includes(resourceGroup)) {
-                        resourceGroupDisposables.deleteAndDispose(resourceGroup);
-                    }
-                }
-                for (const resourceGroup of repository.provider.groups) {
-                    if (!( resourceGroupDisposables.has(resourceGroup))) {
-                        const disposableStore = ( new DisposableStore());
-                        disposableStore.add(resourceGroup.onDidChange(() => this.updateChildren(repository)));
-                        disposableStore.add(resourceGroup.onDidChangeResources(() => this.updateChildren(repository)));
-                        resourceGroupDisposables.set(resourceGroup, disposableStore);
-                    }
-                }
-            };
-            repositoryDisposables.add(repository.provider.onDidChangeResourceGroups(onDidChangeResourceGroups));
-            onDidChangeResourceGroups();
-            this.items.set(repository, repositoryDisposables);
-        }
-        for (const repository of removed) {
-            this.items.deleteAndDispose(repository);
-        }
-        this.updateChildren();
-        this.onDidActiveEditorChange();
-    }
-    onListContextMenu(e) {
-        if (!e.element) {
-            const menu = this.menuService.createMenu(Menus.ViewSort, this.contextKeyService);
-            const actions = [];
-            createAndFillInContextMenuActions(menu, undefined, actions);
-            return this.contextMenuService.showContextMenu({
-                getAnchor: () => e.anchor,
-                getActions: () => actions,
-                onHide: () => {
-                    menu.dispose();
-                }
-            });
-        }
-        const element = e.element;
-        let context = element;
-        let actions = [];
-        let actionRunner = ( new RepositoryPaneActionRunner(() => this.getSelectedResources()));
-        if (isSCMRepository(element)) {
-            const menus = this.scmViewService.menus.getRepositoryMenus(element.provider);
-            const menu = menus.repositoryContextMenu;
-            context = element.provider;
-            actionRunner = ( new RepositoryActionRunner(() => this.getSelectedRepositories()));
-            actions = collectContextMenuActions(menu);
-        }
-        else if (isSCMInput(element) || isSCMActionButton(element)) ;
-        else if (isSCMResourceGroup(element)) {
-            const menus = this.scmViewService.menus.getRepositoryMenus(element.provider);
-            const menu = menus.getResourceGroupMenu(element);
-            actions = collectContextMenuActions(menu);
-        }
-        else if (isSCMResource(element)) {
-            const menus = this.scmViewService.menus.getRepositoryMenus(element.resourceGroup.provider);
-            const menu = menus.getResourceMenu(element);
-            actions = collectContextMenuActions(menu);
-        }
-        else if (isSCMResourceNode(element)) {
-            if (element.element) {
-                const menus = this.scmViewService.menus.getRepositoryMenus(element.element.resourceGroup.provider);
-                const menu = menus.getResourceMenu(element.element);
-                actions = collectContextMenuActions(menu);
-            }
-            else {
-                const menus = this.scmViewService.menus.getRepositoryMenus(element.context.provider);
-                const menu = menus.getResourceFolderMenu(element.context);
-                actions = collectContextMenuActions(menu);
-            }
-        }
-        else if (isSCMHistoryItemGroupTreeElement(element)) {
-            const menus = this.scmViewService.menus.getRepositoryMenus(element.repository.provider);
-            const menu = menus.historyProviderMenu?.getHistoryItemGroupContextMenu(element);
-            if (menu) {
-                actionRunner = ( new HistoryItemGroupActionRunner());
-                createAndFillInContextMenuActions(menu, { shouldForwardArgs: true }, actions);
-            }
-        }
-        else if (isSCMHistoryItemTreeElement(element)) {
-            const menus = this.scmViewService.menus.getRepositoryMenus(element.historyItemGroup.repository.provider);
-            const menu = menus.historyProviderMenu?.getHistoryItemMenu(element);
-            if (menu) {
-                actionRunner = ( new HistoryItemActionRunner());
-                actions = collectContextMenuActions(menu);
-            }
-        }
-        actionRunner.onWillRun(() => this.tree.domFocus());
-        this.contextMenuService.showContextMenu({
-            getAnchor: () => e.anchor,
-            getActions: () => actions,
-            getActionsContext: () => context,
-            actionRunner
-        });
-    }
-    getSelectedRepositories() {
-        const focusedRepositories = this.tree.getFocus().filter(r => !!r && isSCMRepository(r));
-        const selectedRepositories = this.tree.getSelection().filter(r => !!r && isSCMRepository(r));
-        return Array.from(( new Set([...focusedRepositories, ...selectedRepositories])));
-    }
-    getSelectedResources() {
-        return this.tree.getSelection()
-            .filter(r => !!r && !isSCMResourceGroup(r));
-    }
-    getViewMode() {
-        let mode = this.configurationService.getValue('scm.defaultViewMode') === 'list' ? "list"  : "tree" ;
-        const storageMode = this.storageService.get(`scm.viewMode`, 1 );
-        if (typeof storageMode === 'string') {
-            mode = storageMode;
-        }
-        return mode;
-    }
-    getViewSortKey() {
-        if (this._viewMode === "tree" ) {
-            return "path" ;
-        }
-        let viewSortKey;
-        const viewSortKeyString = this.configurationService.getValue('scm.defaultViewSortKey');
-        switch (viewSortKeyString) {
-            case 'name':
-                viewSortKey = "name" ;
-                break;
-            case 'status':
-                viewSortKey = "status" ;
-                break;
-            default:
-                viewSortKey = "path" ;
-                break;
-        }
-        const storageSortKey = this.storageService.get(`scm.viewSortKey`, 1 );
-        if (typeof storageSortKey === 'string') {
-            viewSortKey = storageSortKey;
-        }
-        return viewSortKey;
-    }
-    loadTreeViewState() {
-        const storageViewState = this.storageService.get('scm.viewState2', 1 );
-        if (!storageViewState) {
-            return undefined;
-        }
-        try {
-            const treeViewState = JSON.parse(storageViewState);
-            return treeViewState;
-        }
-        catch {
-            return undefined;
-        }
-    }
-    storeTreeViewState() {
-        if (this.tree) {
-            this.storageService.store('scm.viewState2', JSON.stringify(this.tree.getViewState()), 1 , 1 );
-        }
-    }
-    updateChildren(element) {
-        this.updateChildrenThrottler.queue(() => this.treeOperationSequencer.queue(async () => {
-            const focusedInput = this.inputRenderer.getFocusedInput();
-            if (element && this.tree.hasNode(element)) {
-                await this.tree.updateChildren(element);
-            }
-            else {
-                await this.tree.updateChildren(undefined);
-            }
-            if (focusedInput) {
-                this.inputRenderer.getRenderedInputWidget(focusedInput)?.forEach(widget => widget.focus());
-            }
-            this.updateScmProviderContextKeys();
-            this.updateRepositoryCollapseAllContextKeys();
-        }));
-    }
-    updateIndentStyles(theme) {
-        this.treeContainer.classList.toggle('list-view-mode', this.viewMode === "list" );
-        this.treeContainer.classList.toggle('tree-view-mode', this.viewMode === "tree" );
-        this.treeContainer.classList.toggle('align-icons-and-twisties', (this.viewMode === "list"  && theme.hasFileIcons) || (theme.hasFileIcons && !theme.hasFolderIcons));
-        this.treeContainer.classList.toggle('hide-arrows', this.viewMode === "tree"  && theme.hidesExplorerArrows === true);
-    }
-    updateScmProviderContextKeys() {
-        const alwaysShowRepositories = this.configurationService.getValue('scm.alwaysShowRepositories');
-        if (!alwaysShowRepositories && this.items.size === 1) {
-            const provider = Iterable.first(( this.items.keys())).provider;
-            this.scmProviderContextKey.set(provider.contextValue);
-            this.scmProviderRootUriContextKey.set(provider.rootUri?.toString());
-            this.scmProviderHasRootUriContextKey.set(!!provider.rootUri);
-        }
-        else {
-            this.scmProviderContextKey.set(undefined);
-            this.scmProviderRootUriContextKey.set(undefined);
-            this.scmProviderHasRootUriContextKey.set(false);
-        }
-    }
-    updateRepositoryCollapseAllContextKeys() {
-        if (!this.isBodyVisible() || this.items.size === 1) {
-            this.isAnyRepositoryCollapsibleContextKey.set(false);
-            this.areAllRepositoriesCollapsedContextKey.set(false);
-            return;
-        }
-        this.isAnyRepositoryCollapsibleContextKey.set(( this.scmViewService.visibleRepositories.some(r => this.tree.hasElement(r) && this.tree.isCollapsible(r))));
-        this.areAllRepositoriesCollapsedContextKey.set(this.scmViewService.visibleRepositories.every(r => this.tree.hasElement(r) && (!this.tree.isCollapsible(r) || this.tree.isCollapsed(r))));
-    }
-    collapseAllRepositories() {
-        for (const repository of this.scmViewService.visibleRepositories) {
-            if (this.tree.isCollapsible(repository)) {
-                this.tree.collapse(repository);
-            }
-        }
-    }
-    expandAllRepositories() {
-        for (const repository of this.scmViewService.visibleRepositories) {
-            if (this.tree.isCollapsible(repository)) {
-                this.tree.expand(repository);
-            }
-        }
-    }
-    shouldShowWelcome() {
-        return this.scmService.repositoryCount === 0;
-    }
-    getActionsContext() {
-        return this.scmViewService.visibleRepositories.length === 1 ? this.scmViewService.visibleRepositories[0].provider : undefined;
-    }
-    focus() {
-        super.focus();
-        if (this.isExpanded()) {
-            if (this.tree.getFocus().length === 0) {
-                for (const repository of this.scmViewService.visibleRepositories) {
-                    const widgets = this.inputRenderer.getRenderedInputWidget(repository.input);
-                    if (widgets) {
-                        for (const widget of widgets) {
-                            widget.focus();
-                        }
-                        return;
-                    }
-                }
-            }
-            this.tree.domFocus();
-        }
-    }
-    dispose() {
-        this.visibilityDisposables.dispose();
-        this.disposables.dispose();
-        this.items.dispose();
-        super.dispose();
-    }
-};
-SCMViewPane = ( __decorate([
-    ( __param(1, ICommandService)),
-    ( __param(2, IEditorService)),
-    ( __param(3, ILogService)),
-    ( __param(4, IMenuService)),
-    ( __param(5, ISCMService)),
-    ( __param(6, ISCMViewService)),
-    ( __param(7, IStorageService)),
-    ( __param(8, IUriIdentityService)),
-    ( __param(9, IKeybindingService)),
-    ( __param(10, IThemeService)),
-    ( __param(11, IContextMenuService)),
-    ( __param(12, IInstantiationService)),
-    ( __param(13, IViewDescriptorService)),
-    ( __param(14, IConfigurationService)),
-    ( __param(15, IContextKeyService)),
-    ( __param(16, IOpenerService)),
-    ( __param(17, ITelemetryService))
-], SCMViewPane));
-let SCMTreeDataSource = class SCMTreeDataSource {
-    constructor(viewMode, configurationService, logService, scmViewService, uriIdentityService) {
-        this.viewMode = viewMode;
-        this.configurationService = configurationService;
-        this.logService = logService;
-        this.scmViewService = scmViewService;
-        this.uriIdentityService = uriIdentityService;
-        this.historyProviderCache = ( new Map());
-        this.repositoryDisposables = ( new DisposableMap());
-        this.disposables = ( new DisposableStore());
-        const onDidChangeConfiguration = Event.filter(this.configurationService.onDidChangeConfiguration, e => e.affectsConfiguration('scm.showChangesSummary'), this.disposables);
-        this.disposables.add(onDidChangeConfiguration(() => this.historyProviderCache.clear()));
-        this.scmViewService.onDidChangeVisibleRepositories(this.onDidChangeVisibleRepositories, this, this.disposables);
-        this.onDidChangeVisibleRepositories({ added: this.scmViewService.visibleRepositories, removed: Iterable.empty() });
-    }
-    hasChildren(inputOrElement) {
-        if (isSCMViewService(inputOrElement)) {
-            return this.scmViewService.visibleRepositories.length !== 0;
-        }
-        else if (isSCMRepository(inputOrElement)) {
-            return true;
-        }
-        else if (isSCMInput(inputOrElement)) {
-            return false;
-        }
-        else if (isSCMActionButton(inputOrElement)) {
-            return false;
-        }
-        else if (isSCMResourceGroup(inputOrElement)) {
-            return true;
-        }
-        else if (isSCMResource(inputOrElement)) {
-            return false;
-        }
-        else if (ResourceTree.isResourceNode(inputOrElement)) {
-            return inputOrElement.childrenCount > 0;
-        }
-        else if (isSCMHistoryItemGroupTreeElement(inputOrElement)) {
-            return true;
-        }
-        else if (isSCMHistoryItemTreeElement(inputOrElement)) {
-            return true;
-        }
-        else if (isSCMHistoryItemChangeTreeElement(inputOrElement)) {
-            return false;
-        }
-        else if (isSCMViewSeparator(inputOrElement)) {
-            return false;
-        }
-        else {
-            throw new Error('hasChildren not implemented.');
-        }
-    }
-    async getChildren(inputOrElement) {
-        const { alwaysShowRepositories, showActionButton } = this.getConfiguration();
-        const repositoryCount = this.scmViewService.visibleRepositories.length;
-        if (isSCMViewService(inputOrElement) && (repositoryCount > 1 || alwaysShowRepositories)) {
-            return this.scmViewService.visibleRepositories;
-        }
-        else if ((isSCMViewService(inputOrElement) && repositoryCount === 1 && !alwaysShowRepositories) || isSCMRepository(inputOrElement)) {
-            const children = [];
-            inputOrElement = isSCMRepository(inputOrElement) ? inputOrElement : this.scmViewService.visibleRepositories[0];
-            const actionButton = inputOrElement.provider.actionButton;
-            const resourceGroups = inputOrElement.provider.groups;
-            if (inputOrElement.input.visible) {
-                children.push(inputOrElement.input);
-            }
-            if (showActionButton && actionButton) {
-                children.push({
-                    type: 'actionButton',
-                    repository: inputOrElement,
-                    button: actionButton
-                });
-            }
-            const hasSomeChanges = ( resourceGroups.some(group => group.resources.length > 0));
-            if (hasSomeChanges || (repositoryCount === 1 && (!showActionButton || !actionButton))) {
-                children.push(...resourceGroups);
-            }
-            const historyItemGroups = await this.getHistoryItemGroups(inputOrElement);
-            if (historyItemGroups.length > 0) {
-                let label = ( localizeWithPath(
-                    'vs/workbench/contrib/scm/browser/scmViewPane',
-                    'syncSeparatorHeader',
-                    "Incoming/Outgoing"
-                ));
-                let ariaLabel = ( localizeWithPath(
-                    'vs/workbench/contrib/scm/browser/scmViewPane',
-                    'syncSeparatorHeaderAriaLabel',
-                    "Incoming and outgoing changes"
-                ));
-                const incomingHistoryItems = historyItemGroups.find(g => g.direction === 'incoming');
-                const outgoingHistoryItems = historyItemGroups.find(g => g.direction === 'outgoing');
-                if (incomingHistoryItems && !outgoingHistoryItems) {
-                    label = ( localizeWithPath(
-                        'vs/workbench/contrib/scm/browser/scmViewPane',
-                        'syncIncomingSeparatorHeader',
-                        "Incoming"
-                    ));
-                    ariaLabel = ( localizeWithPath(
-                        'vs/workbench/contrib/scm/browser/scmViewPane',
-                        'syncIncomingSeparatorHeaderAriaLabel',
-                        "Incoming changes"
-                    ));
-                }
-                else if (!incomingHistoryItems && outgoingHistoryItems) {
-                    label = ( localizeWithPath(
-                        'vs/workbench/contrib/scm/browser/scmViewPane',
-                        'syncOutgoingSeparatorHeader',
-                        "Outgoing"
-                    ));
-                    ariaLabel = ( localizeWithPath(
-                        'vs/workbench/contrib/scm/browser/scmViewPane',
-                        'syncOutgoingSeparatorHeaderAriaLabel',
-                        "Outgoing changes"
-                    ));
-                }
-                children.push({ label, ariaLabel, repository: inputOrElement, type: 'separator' });
-            }
-            children.push(...historyItemGroups);
-            return children;
-        }
-        else if (isSCMResourceGroup(inputOrElement)) {
-            if (this.viewMode() === "list" ) {
-                return inputOrElement.resources;
-            }
-            else if (this.viewMode() === "tree" ) {
-                const children = [];
-                for (const node of inputOrElement.resourceTree.root.children) {
-                    children.push(node.element && node.childrenCount === 0 ? node.element : node);
-                }
-                return children;
-            }
-        }
-        else if (isSCMResourceNode(inputOrElement) || isSCMHistoryItemChangeNode(inputOrElement)) {
-            const children = [];
-            for (const node of inputOrElement.children) {
-                children.push(node.element && node.childrenCount === 0 ? node.element : node);
-            }
-            return children;
-        }
-        else if (isSCMHistoryItemGroupTreeElement(inputOrElement)) {
-            return this.getHistoryItems(inputOrElement);
-        }
-        else if (isSCMHistoryItemTreeElement(inputOrElement)) {
-            return this.getHistoryItemChanges(inputOrElement);
-        }
-        return [];
-    }
-    async getHistoryItemGroups(element) {
-        const { showIncomingChanges, showOutgoingChanges } = this.getConfiguration();
-        const scmProvider = element.provider;
-        const historyProvider = scmProvider.historyProvider;
-        const currentHistoryItemGroup = historyProvider?.currentHistoryItemGroup;
-        if (!historyProvider || !currentHistoryItemGroup || (showIncomingChanges === 'never' && showOutgoingChanges === 'never')) {
-            return [];
-        }
-        const children = [];
-        const historyProviderCacheEntry = this.getHistoryProviderCacheEntry(element);
-        let incomingHistoryItemGroup = historyProviderCacheEntry?.incomingHistoryItemGroup;
-        let outgoingHistoryItemGroup = historyProviderCacheEntry?.outgoingHistoryItemGroup;
-        if (!incomingHistoryItemGroup && !outgoingHistoryItemGroup) {
-            const ancestor = await historyProvider.resolveHistoryItemGroupCommonAncestor(currentHistoryItemGroup.id, currentHistoryItemGroup.base?.id);
-            if (!ancestor) {
-                return [];
-            }
-            incomingHistoryItemGroup = currentHistoryItemGroup.base ? {
-                id: currentHistoryItemGroup.base.id,
-                label: currentHistoryItemGroup.base.label,
-                ariaLabel: ( localizeWithPath(
-                    'vs/workbench/contrib/scm/browser/scmViewPane',
-                    'incomingChangesAriaLabel',
-                    "Incoming changes from {0}",
-                    currentHistoryItemGroup.base.label
-                )),
-                icon: Codicon.arrowCircleDown,
-                direction: 'incoming',
-                ancestor: ancestor.id,
-                count: ancestor.behind,
-                repository: element,
-                type: 'historyItemGroup'
-            } : undefined;
-            outgoingHistoryItemGroup = {
-                id: currentHistoryItemGroup.id,
-                label: currentHistoryItemGroup.label,
-                ariaLabel: ( localizeWithPath(
-                    'vs/workbench/contrib/scm/browser/scmViewPane',
-                    'outgoingChangesAriaLabel',
-                    "Outgoing changes to {0}",
-                    currentHistoryItemGroup.label
-                )),
-                icon: Codicon.arrowCircleUp,
-                direction: 'outgoing',
-                ancestor: ancestor.id,
-                count: ancestor.ahead,
-                repository: element,
-                type: 'historyItemGroup'
-            };
-            this.historyProviderCache.set(element, {
-                ...historyProviderCacheEntry,
-                incomingHistoryItemGroup,
-                outgoingHistoryItemGroup
-            });
-        }
-        if (incomingHistoryItemGroup &&
-            (showIncomingChanges === 'always' ||
-                (showIncomingChanges === 'auto' && (incomingHistoryItemGroup.count ?? 0) > 0))) {
-            children.push(incomingHistoryItemGroup);
-        }
-        if (outgoingHistoryItemGroup &&
-            (showOutgoingChanges === 'always' ||
-                (showOutgoingChanges === 'auto' && (outgoingHistoryItemGroup.count ?? 0) > 0))) {
-            children.push(outgoingHistoryItemGroup);
-        }
-        return children;
-    }
-    async getHistoryItems(element) {
-        const repository = element.repository;
-        const historyProvider = repository.provider.historyProvider;
-        if (!historyProvider) {
-            return [];
-        }
-        const historyProviderCacheEntry = this.getHistoryProviderCacheEntry(repository);
-        const historyItemsMap = historyProviderCacheEntry.historyItems;
-        let historyItemsElement = historyProviderCacheEntry.historyItems.get(element.id);
-        if (!historyItemsElement) {
-            const historyItems = (await historyProvider.provideHistoryItems(element.id, { limit: { id: element.ancestor } })) ?? [];
-            const { showChangesSummary } = this.getConfiguration();
-            const allChanges = showChangesSummary && historyItems.length >= 2 ?
-                await historyProvider.provideHistoryItemSummary(historyItems[0].id, element.ancestor) : undefined;
-            historyItemsElement = [allChanges, historyItems];
-            this.historyProviderCache.set(repository, {
-                ...historyProviderCacheEntry,
-                historyItems: historyItemsMap.set(element.id, historyItemsElement)
-            });
-        }
-        const children = [];
-        if (historyItemsElement[0]) {
-            children.push({
-                ...historyItemsElement[0],
-                icon: historyItemsElement[0].icon ?? Codicon.files,
-                label: ( localizeWithPath(
-                    'vs/workbench/contrib/scm/browser/scmViewPane',
-                    'allChanges',
-                    "All Changes"
-                )),
-                historyItemGroup: element,
-                type: 'allChanges'
-            });
-        }
-        children.push(...( historyItemsElement[1]
-            .map(historyItem => ({
-            ...historyItem,
-            historyItemGroup: element,
-            type: 'historyItem'
-        }))));
-        return children;
-    }
-    async getHistoryItemChanges(element) {
-        const repository = element.historyItemGroup.repository;
-        const historyProvider = repository.provider.historyProvider;
-        if (!historyProvider) {
-            return [];
-        }
-        const historyProviderCacheEntry = this.getHistoryProviderCacheEntry(repository);
-        const historyItemChangesMap = historyProviderCacheEntry.historyItemChanges;
-        const historyItemParentId = element.parentIds.length > 0 ? element.parentIds[0] : undefined;
-        let historyItemChanges = historyItemChangesMap.get(`${element.id}/${historyItemParentId}`);
-        if (!historyItemChanges) {
-            const historyItemParentId = element.parentIds.length > 0 ? element.parentIds[0] : undefined;
-            historyItemChanges = (await historyProvider.provideHistoryItemChanges(element.id, historyItemParentId)) ?? [];
-            this.historyProviderCache.set(repository, {
-                ...historyProviderCacheEntry,
-                historyItemChanges: historyItemChangesMap.set(`${element.id}/${historyItemParentId}`, historyItemChanges)
-            });
-        }
-        if (this.viewMode() === "list" ) {
-            return ( historyItemChanges.map(change => ({
-                ...change,
-                historyItem: element,
-                type: 'historyItemChange'
-            })));
-        }
-        const tree = ( new ResourceTree(
-            element,
-            repository.provider.rootUri ?? URI.file('/'),
-            this.uriIdentityService.extUri
-        ));
-        for (const change of historyItemChanges) {
-            tree.add(change.uri, {
-                ...change,
-                historyItem: element,
-                type: 'historyItemChange'
-            });
-        }
-        const children = [];
-        for (const node of tree.root.children) {
-            children.push(node.element ?? node);
-        }
-        return children;
-    }
-    getParent(element) {
-        if (isSCMResourceNode(element)) {
-            if (element.parent === element.context.resourceTree.root) {
-                return element.context;
-            }
-            else if (element.parent) {
-                return element.parent;
-            }
-            else {
-                throw new Error('Invalid element passed to getParent');
-            }
-        }
-        else if (isSCMResource(element)) {
-            if (this.viewMode() === "list" ) {
-                return element.resourceGroup;
-            }
-            const node = element.resourceGroup.resourceTree.getNode(element.sourceUri);
-            const result = node?.parent;
-            if (!result) {
-                throw new Error('Invalid element passed to getParent');
-            }
-            if (result === element.resourceGroup.resourceTree.root) {
-                return element.resourceGroup;
-            }
-            return result;
-        }
-        else {
-            throw new Error('Unexpected call to getParent');
-        }
-    }
-    getConfiguration() {
-        return {
-            alwaysShowRepositories: this.configurationService.getValue('scm.alwaysShowRepositories'),
-            showActionButton: this.configurationService.getValue('scm.showActionButton'),
-            showChangesSummary: this.configurationService.getValue('scm.showChangesSummary'),
-            showIncomingChanges: this.configurationService.getValue('scm.showIncomingChanges'),
-            showOutgoingChanges: this.configurationService.getValue('scm.showOutgoingChanges')
-        };
-    }
-    onDidChangeVisibleRepositories({ added, removed }) {
-        for (const repository of added) {
-            const repositoryDisposables = ( new DisposableStore());
-            repositoryDisposables.add(Event.runAndSubscribe(repository.provider.onDidChangeHistoryProvider, () => {
-                if (!repository.provider.historyProvider) {
-                    this.logService.debug('SCMTreeDataSource:onDidChangeVisibleRepositories - no history provider present');
-                    return;
-                }
-                repositoryDisposables.add(repository.provider.historyProvider.onDidChangeCurrentHistoryItemGroup(() => {
-                    this.historyProviderCache.delete(repository);
-                    this.logService.debug('SCMTreeDataSource:onDidChangeCurrentHistoryItemGroup - cache cleared');
-                }));
-                this.logService.debug('SCMTreeDataSource:onDidChangeVisibleRepositories - onDidChangeCurrentHistoryItemGroup listener added');
-            }));
-            this.repositoryDisposables.set(repository, repositoryDisposables);
-        }
-        for (const repository of removed) {
-            this.repositoryDisposables.deleteAndDispose(repository);
-            this.historyProviderCache.delete(repository);
-        }
-    }
-    getHistoryProviderCacheEntry(repository) {
-        return this.historyProviderCache.get(repository) ?? {
-            incomingHistoryItemGroup: undefined,
-            outgoingHistoryItemGroup: undefined,
-            historyItems: ( new Map()),
-            historyItemChanges: ( new Map())
-        };
-    }
-    dispose() {
-        this.repositoryDisposables.dispose();
-        this.disposables.dispose();
-    }
-};
-SCMTreeDataSource = ( __decorate([
-    ( __param(1, IConfigurationService)),
-    ( __param(2, ILogService)),
-    ( __param(3, ISCMViewService)),
-    ( __param(4, IUriIdentityService))
-], SCMTreeDataSource));
-class SCMActionButton {
-    constructor(container, contextMenuService, commandService, notificationService) {
-        this.container = container;
-        this.contextMenuService = contextMenuService;
-        this.commandService = commandService;
-        this.notificationService = notificationService;
-        this.disposables = ( new MutableDisposable());
-    }
-    dispose() {
-        this.disposables?.dispose();
-    }
-    setButton(button) {
-        this.clear();
-        if (!button) {
-            return;
-        }
-        if (button.secondaryCommands?.length) {
-            const actions = [];
-            for (let index = 0; index < button.secondaryCommands.length; index++) {
-                const commands = button.secondaryCommands[index];
-                for (const command of commands) {
-                    actions.push(( new Action(
-                        command.id,
-                        command.title,
-                        undefined,
-                        true,
-                        async () => await this.executeCommand(command.id, ...(command.arguments || []))
-                    )));
-                }
-                if (commands.length) {
-                    actions.push(( new Separator()));
-                }
-            }
-            actions.pop();
-            this.button = ( new ButtonWithDropdown(this.container, {
-                actions: actions,
-                addPrimaryActionToDropdown: false,
-                contextMenuProvider: this.contextMenuService,
-                title: button.command.tooltip,
-                supportIcons: true,
-                ...defaultButtonStyles
-            }));
-        }
-        else {
-            this.button = ( new Button(
-                this.container,
-                { supportIcons: true, supportShortLabel: !!button.description, title: button.command.tooltip, ...defaultButtonStyles }
-            ));
-        }
-        this.button.enabled = button.enabled;
-        this.button.label = button.command.title;
-        if (this.button instanceof Button && button.description) {
-            this.button.labelShort = button.description;
-        }
-        this.button.onDidClick(async () => await this.executeCommand(button.command.id, ...(button.command.arguments || [])), null, this.disposables.value);
-        this.disposables.value.add(this.button);
-    }
-    focus() {
-        this.button?.focus();
-    }
-    clear() {
-        this.disposables.value = ( new DisposableStore());
-        this.button = undefined;
-        clearNode(this.container);
-    }
-    async executeCommand(commandId, ...args) {
-        try {
-            await this.commandService.executeCommand(commandId, ...args);
-        }
-        catch (ex) {
-            this.notificationService.error(ex);
-        }
-    }
-}
-let ScmInputContentProvider = class ScmInputContentProvider extends Disposable {
-    constructor(textModelService, _modelService, _languageService) {
-        super();
-        this._modelService = _modelService;
-        this._languageService = _languageService;
-        this._register(textModelService.registerTextModelContentProvider(Schemas.vscodeSourceControl, this));
-    }
-    async provideTextContent(resource) {
-        const existing = this._modelService.getModel(resource);
-        if (existing) {
-            return existing;
-        }
-        return this._modelService.createModel('', this._languageService.createById('scminput'), resource);
-    }
-};
-ScmInputContentProvider = ( __decorate([
-    ( __param(0, ITextModelService)),
-    ( __param(1, IModelService)),
-    ( __param(2, ILanguageService))
-], ScmInputContentProvider));
-
-export { ActionButtonRenderer, SCMAccessibilityProvider, SCMActionButton, SCMTreeKeyboardNavigationLabelProvider, SCMTreeSorter, SCMViewPane };