@codingame/monaco-vscode-api 3.2.3 → 4.1.0

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

@@ -0,0 +1,3365 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/scm.css.js';
+import { Event, Emitter } from '../../../../base/common/event.js';
+import { basename, dirname } from '../../../../base/common/resources.js';
+import { Disposable, DisposableStore, toDisposable, combinedDisposable, MutableDisposable, DisposableMap, dispose } from '../../../../base/common/lifecycle.js';
+import { ViewPane, ViewAction } from '../../../browser/parts/views/viewPane.js';
+import { append, $, asCSSUrl, prepend, Dimension, trackFocus, clearNode } from '../../../../base/browser/dom.js';
+import { VIEW_PANE_ID, SCMInputChangeReason, ISCMViewService, ISCMService } from '../common/scm.js';
+import { ResourceLabels } from '../../../browser/labels.js';
+import { CountBadge } from '../../../../base/browser/ui/countBadge/countBadge.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IContextMenuService, IContextViewService } from '../../../../platform/contextview/browser/contextView.js';
+import { ContextKeyExpr, RawContextKey, IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { ICommandService } from '../../../../platform/commands/common/commands.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { MenuId, MenuRegistry, registerAction2, MenuItemAction, IMenuService, Action2 } from '../../../../platform/actions/common/actions.js';
+import { Action, ActionRunner, Separator } from '../../../../base/common/actions.js';
+import { ActionBar } from '../../../../base/browser/ui/actionbar/actionbar.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.js';
+import { connectPrimaryMenuToInlineActionBar, connectPrimaryMenu, getActionViewItemProvider, isSCMRepository, isSCMResourceGroup, isSCMResourceNode, isSCMHistoryItemChangeNode, isSCMInput, isSCMActionButton, isSCMResource, isSCMHistoryItemGroupTreeElement, isSCMHistoryItemTreeElement, isSCMHistoryItemChangeTreeElement, toDiffEditorArguments, collectContextMenuActions, isSCMViewService, isSCMViewSeparator } from './util.js';
+import { WorkbenchCompressibleAsyncDataTree } from '../../../../platform/list/browser/listService.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { disposableTimeout, ThrottledDelayer, Sequencer, Throttler } from '../../../../base/common/async.js';
+import { ResourceTree } from '../../../../base/common/resourceTree.js';
+import { Iterable } from '../../../../base/common/iterator.js';
+import { URI } from '../../../../base/common/uri.js';
+import { FileKind } from '../../../../platform/files/common/files.js';
+import { comparePaths, compareFileNames } from '../../../../base/common/comparers.js';
+import { createMatches } from '../../../../base/common/filters.js';
+import { IViewDescriptorService } from '../../../common/views.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { flatten } from '../../../../base/common/arrays.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.js';
+import { EditorResourceAccessor, SideBySideEditor } from '../../../common/editor.js';
+import { PANEL_BACKGROUND, SIDE_BAR_BACKGROUND } from '../../../common/theme.js';
+import { CodeEditorWidget } from '../../../../editor/browser/widget/codeEditor/codeEditorWidget.js';
+import { getSimpleEditorOptions } from '../../codeEditor/browser/simpleEditorOptions.js';
+import { IModelService } from '../../../../editor/common/services/model.js';
+import { EditorExtensionsRegistry } from '../../../../editor/browser/editorExtensions.js';
+import { MenuPreventer } from '../../codeEditor/browser/menuPreventer.js';
+import { SelectionClipboardContributionID } from '../../codeEditor/browser/selectionClipboard.js';
+import { EditorDictation } from '../../codeEditor/browser/dictation/editorDictation.js';
+import { ContextMenuController } from '../../../../editor/contrib/contextmenu/browser/contextmenu.js';
+import { isMacintosh } from '../../../../base/common/platform.js';
+import { format, compare } from '../../../../base/common/strings.js';
+import { SuggestController } from '../../../../editor/contrib/suggest/browser/suggestController.js';
+import { SnippetController2 } from '../../../../editor/contrib/snippet/browser/snippetController2.js';
+import { ServiceCollection } from '../../../../platform/instantiation/common/serviceCollection.js';
+import { HoverController } from '../../../../editor/contrib/hover/browser/hover.js';
+import { ColorDetector } from '../../../../editor/contrib/colorPicker/browser/colorDetector.js';
+import { LinkDetector } from '../../../../editor/contrib/links/browser/links.js';
+import { IOpenerService } from '../../../../platform/opener/common/opener.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
+import { ILanguageService } from '../../../../editor/common/languages/language.js';
+import { ILabelService } from '../../../../platform/label/common/label.js';
+import { DEFAULT_FONT_FAMILY } from '../../../../base/browser/fonts.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+import { RepositoryRenderer, RepositoryActionRunner } from './scmRepositoryRenderer.js';
+import { ColorScheme } from '../../../../platform/theme/common/theme.js';
+import { API_OPEN_EDITOR_COMMAND_ID, API_OPEN_DIFF_EDITOR_COMMAND_ID } from '../../../browser/parts/editor/editorCommands.js';
+import { createActionViewItem, createAndFillInContextMenuActions, createAndFillInActionBarActions } from '../../../../platform/actions/browser/menuEntryActionViewItem.js';
+import { MarkdownRenderer, openLinkFromMarkdown } from '../../../../editor/browser/widget/markdownRenderer/browser/markdownRenderer.js';
+import { ButtonWithDropdown, Button } from '../../../../base/browser/ui/button/button.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.js';
+import { RepositoryContextKeys } from './scmViewService.js';
+import { DragAndDropController } from '../../../../editor/contrib/dnd/browser/dnd.js';
+import { DropIntoEditorController } from '../../../../editor/contrib/dropOrPasteInto/browser/dropIntoEditorController.js';
+import { MessageController } from '../../../../editor/contrib/message/browser/messageController.js';
+import { defaultCountBadgeStyles, defaultButtonStyles } from '../../../../platform/theme/browser/defaultStyles.js';
+import { InlineCompletionsController } from '../../../../editor/contrib/inlineCompletions/browser/inlineCompletionsController.js';
+import { CodeActionController } from '../../../../editor/contrib/codeAction/browser/codeActionController.js';
+import { ITextModelService } from '../../../../editor/common/services/resolverService.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { fillEditorsDragData } from '../../../browser/dnd.js';
+import { CodeDataTransfers } from '../../../../platform/dnd/browser/dnd.js';
+import { FormatOnType } from '../../../../editor/contrib/format/browser/formatActions.js';
+import { EditorOptions } from '../../../../editor/common/config/editorOptions.js';
+import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
+import { EditOperation } from '../../../../editor/common/core/editOperation.js';
+import { stripIcons } from '../../../../base/common/iconLabels.js';
+import { IconLabel } from '../../../../base/browser/ui/iconLabel/iconLabel.js';
+import { registerColor, transparent } from '../../../../platform/theme/common/colorUtils.js';
+import { foreground } from '../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../platform/theme/common/colors/chartsColors.js';
+import '../../../../platform/theme/common/colors/editorColors.js';
+import '../../../../platform/theme/common/colors/inputColors.js';
+import { listActiveSelectionForeground } from '../../../../platform/theme/common/colors/listColors.js';
+import '../../../../platform/theme/common/colors/menuColors.js';
+import '../../../../platform/theme/common/colors/minimapColors.js';
+import '../../../../platform/theme/common/colors/miscColors.js';
+import '../../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../../platform/theme/common/colors/searchColors.js';
+import { MenuWorkbenchToolBar, WorkbenchToolBar } from '../../../../platform/actions/browser/toolbar.js';
+import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
+import { DropdownWithPrimaryActionViewItem } from '../../../../platform/actions/browser/dropdownWithPrimaryActionViewItem.js';
+import { clamp } from '../../../../base/common/numbers.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+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 };