@codingame/monaco-vscode-api 25.1.2 → 26.0.1

package/vscode/src/vs/workbench/browser/parts/views/treeView.js

@@ -79,20 +79,43 @@ import { IAccessibleViewInformationService } from '../../../services/accessibili
 var TreeRenderer_1;
 registerCss(views);
 let TreeViewPane = class TreeViewPane extends ViewPane {
-    constructor(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, notificationService, hoverService, accessibleViewService) {
-        super({ ...options, titleMenuId: MenuId.ViewTitle, donotForwardArgs: false }, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, hoverService, accessibleViewService);
-        const { treeView } = ( Registry.as(Extensions.ViewsRegistry)).getView(options.id);
+    constructor(
+        options,
+        keybindingService,
+        contextMenuService,
+        configurationService,
+        contextKeyService,
+        viewDescriptorService,
+        instantiationService,
+        openerService,
+        themeService,
+        notificationService,
+        hoverService,
+        accessibleViewService
+    ) {
+        super({
+            ...options,
+            titleMenuId: MenuId.ViewTitle,
+            donotForwardArgs: false
+        }, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, hoverService, accessibleViewService);
+        const {
+            treeView
+        } = ( Registry.as(Extensions.ViewsRegistry)).getView(options.id);
         this.treeView = treeView;
         this._register(this.treeView.onDidChangeActions(() => this.updateActions(), this));
-        this._register(this.treeView.onDidChangeTitle((newTitle) => this.updateTitle(newTitle)));
-        this._register(this.treeView.onDidChangeDescription((newDescription) => this.updateTitleDescription(newDescription)));
+        this._register(this.treeView.onDidChangeTitle(newTitle => this.updateTitle(newTitle)));
+        this._register(
+            this.treeView.onDidChangeDescription(newDescription => this.updateTitleDescription(newDescription))
+        );
         this._register(toDisposable(() => {
             if (this._container && this.treeView.container && (this._container === this.treeView.container)) {
                 this.treeView.setVisibility(false);
             }
         }));
         this._register(this.onDidChangeBodyVisibility(() => this.updateTreeVisibility()));
-        this._register(this.treeView.onDidChangeWelcomeState(() => this._onDidChangeViewWelcomeState.fire()));
+        this._register(
+            this.treeView.onDidChangeWelcomeState(() => this._onDidChangeViewWelcomeState.fire())
+        );
         if (options.title !== this.treeView.title) {
             this.updateTitle(this.treeView.title);
         }
@@ -112,7 +135,7 @@ let TreeViewPane = class TreeViewPane extends ViewPane {
         this.renderTreeView(container);
     }
     shouldShowWelcome() {
-        return ((this.treeView.dataProvider === undefined) || !!this.treeView.dataProvider.isTreeEmpty) && ((this.treeView.message === undefined) || (this.treeView.message === ''));
+        return ((this.treeView.dataProvider === undefined) || !!this.treeView.dataProvider.isTreeEmpty) && ((this.treeView.message === undefined) || (this.treeView.message === ""));
     }
     layoutBody(height, width) {
         super.layoutBody(height, width);
@@ -134,26 +157,20 @@ let TreeViewPane = class TreeViewPane extends ViewPane {
         return this._actionRunner;
     }
     getActionsContext() {
-        return { $treeViewId: this.id, $focusedTreeItem: true, $selectedTreeItems: true };
+        return {
+            $treeViewId: this.id,
+            $focusedTreeItem: true,
+            $selectedTreeItems: true
+        };
     }
 };
-TreeViewPane = ( __decorate([
-    ( __param(1, IKeybindingService)),
-    ( __param(2, IContextMenuService)),
-    ( __param(3, IConfigurationService)),
-    ( __param(4, IContextKeyService)),
-    ( __param(5, IViewDescriptorService)),
-    ( __param(6, IInstantiationService)),
-    ( __param(7, IOpenerService)),
-    ( __param(8, IThemeService)),
-    ( __param(9, INotificationService)),
-    ( __param(10, IHoverService)),
-    ( __param(11, IAccessibleViewInformationService))
-], TreeViewPane));
+TreeViewPane = ( __decorate([( __param(1, IKeybindingService)), ( __param(2, IContextMenuService)), ( __param(3, IConfigurationService)), ( __param(4, IContextKeyService)), ( __param(5, IViewDescriptorService)), ( __param(6, IInstantiationService)), ( __param(7, IOpenerService)), ( __param(8, IThemeService)), ( __param(9, INotificationService)), ( __param(10, IHoverService)), ( __param(11, IAccessibleViewInformationService))], TreeViewPane));
 class Root {
     constructor() {
-        this.label = { label: 'root' };
-        this.handle = '0';
+        this.label = {
+            label: "root"
+        };
+        this.handle = "0";
         this.parentHandle = undefined;
         this.collapsibleState = TreeItemCollapsibleState.Expanded;
         this.children = undefined;
@@ -176,23 +193,58 @@ function isTreeCommandEnabled(treeCommand, contextKeyService) {
     return true;
 }
 function isRenderedMessageValue(messageValue) {
-    return !!messageValue && typeof messageValue !== 'string' && !!messageValue.element && !!messageValue.disposables;
-}
-const noDataProviderMessage = ( localize(3690, "There is no data provider registered that can provide view data."));
-const RawCustomTreeViewContextKey = ( new RawContextKey('customTreeView', false));
-class Tree extends WorkbenchAsyncDataTree {
+    return !!messageValue && typeof messageValue !== "string" && !!messageValue.element && !!messageValue.disposables;
 }
+const noDataProviderMessage = ( localize(3695, "There is no data provider registered that can provide view data."));
+const RawCustomTreeViewContextKey = ( new RawContextKey("customTreeView", false));
+class Tree extends WorkbenchAsyncDataTree {}
 let AbstractTreeView = class AbstractTreeView extends Disposable {
-    get onDidExpandItem() { return this._onDidExpandItem.event; }
-    get onDidCollapseItem() { return this._onDidCollapseItem.event; }
-    get onDidChangeSelectionAndFocus() { return this._onDidChangeSelectionAndFocus.event; }
-    get onDidChangeVisibility() { return this._onDidChangeVisibility.event; }
-    get onDidChangeActions() { return this._onDidChangeActions.event; }
-    get onDidChangeWelcomeState() { return this._onDidChangeWelcomeState.event; }
-    get onDidChangeTitle() { return this._onDidChangeTitle.event; }
-    get onDidChangeDescription() { return this._onDidChangeDescription.event; }
-    get onDidChangeCheckboxState() { return this._onDidChangeCheckboxState.event; }
-    constructor(id, _title, themeService, instantiationService, commandService, configurationService, progressService, contextMenuService, keybindingService, notificationService, viewDescriptorService, hoverService, contextKeyService, activityService, logService, openerService, markdownRendererService) {
+    get onDidExpandItem() {
+        return this._onDidExpandItem.event;
+    }
+    get onDidCollapseItem() {
+        return this._onDidCollapseItem.event;
+    }
+    get onDidChangeSelectionAndFocus() {
+        return this._onDidChangeSelectionAndFocus.event;
+    }
+    get onDidChangeVisibility() {
+        return this._onDidChangeVisibility.event;
+    }
+    get onDidChangeActions() {
+        return this._onDidChangeActions.event;
+    }
+    get onDidChangeWelcomeState() {
+        return this._onDidChangeWelcomeState.event;
+    }
+    get onDidChangeTitle() {
+        return this._onDidChangeTitle.event;
+    }
+    get onDidChangeDescription() {
+        return this._onDidChangeDescription.event;
+    }
+    get onDidChangeCheckboxState() {
+        return this._onDidChangeCheckboxState.event;
+    }
+    constructor(
+        id,
+        _title,
+        themeService,
+        instantiationService,
+        commandService,
+        configurationService,
+        progressService,
+        contextMenuService,
+        keybindingService,
+        notificationService,
+        viewDescriptorService,
+        hoverService,
+        contextKeyService,
+        activityService,
+        logService,
+        openerService,
+        markdownRendererService
+    ) {
         super();
         this.id = id;
         this._title = _title;
@@ -254,13 +306,21 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
             this.treeViewDnd.controller = this._dragAndDropController;
         }
         this._register(this.configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration('explorer.decorations')) {
+            if (e.affectsConfiguration("explorer.decorations")) {
                 this.doRefresh([this.root]);
             }
         }));
-        this._register(this.viewDescriptorService.onDidChangeLocation(({ views, from, to }) => {
+        this._register(this.viewDescriptorService.onDidChangeLocation((
+            {
+                views,
+                from,
+                to
+            }
+        ) => {
             if (( views.some(v => v.id === this.id))) {
-                this.tree?.updateOptions({ overrideStyles: getLocationBasedViewColors(this.viewLocation).listOverrideStyles });
+                this.tree?.updateOptions({
+                    overrideStyles: getLocationBasedViewColors(this.viewLocation).listOverrideStyles
+                });
             }
         }));
         this.registerActions();
@@ -333,10 +393,9 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
                 async getChildrenBatch(nodes) {
                     let childrenGroups;
                     let checkboxesUpdated = [];
-                    if (nodes?.every((node) => !!node.children)) {
+                    if (nodes?.every(node => !!node.children)) {
                         childrenGroups = ( nodes.map(node => node.children));
-                    }
-                    else {
+                    } else {
                         nodes = nodes ?? [self.root];
                         const batchedChildren = await (nodes.length === 1 && nodes[0] instanceof Root ? doGetChildrenOrBatch(dataProvider, undefined) : doGetChildrenOrBatch(dataProvider, nodes));
                         for (let i = 0; i < nodes.length; i++) {
@@ -352,7 +411,7 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
                     }
                     return childrenGroups;
                 }
-            });
+            })();
             if (this._dataProvider.onDidChangeEmpty) {
                 this._register(this._dataProvider.onDidChangeEmpty(() => {
                     this.updateCollapseAllToggle();
@@ -361,8 +420,7 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
             }
             this.updateMessage();
             this.refresh();
-        }
-        else {
+        } else {
             this._dataProvider = undefined;
             this.treeDisposables.clear();
             this.activated = false;
@@ -399,8 +457,7 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
         return this._badge;
     }
     set badge(badge) {
-        if (this._badge?.value === badge?.value &&
-            this._badge?.tooltip === badge?.tooltip) {
+        if (this._badge?.value === badge?.value && this._badge?.tooltip === badge?.tooltip) {
             return;
         }
         this._badge = badge;
@@ -410,8 +467,7 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
                 priority: 50
             };
             this._activity.value = this.activityService.showViewActivity(this.id, activity);
-        }
-        else {
+        } else {
             this._activity.clear();
         }
     }
@@ -422,7 +478,9 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
         const oldCanSelectMany = this._canSelectMany;
         this._canSelectMany = canSelectMany;
         if (this._canSelectMany !== oldCanSelectMany) {
-            this.tree?.updateOptions({ multipleSelectionSupport: this.canSelectMany });
+            this.tree?.updateOptions({
+                multipleSelectionSupport: this.canSelectMany
+            });
         }
     }
     get manuallyManageCheckboxes() {
@@ -442,7 +500,7 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
     }
     initializeShowCollapseAllAction(startingValue = false) {
         if (!this.collapseAllContext) {
-            this.collapseAllContextKey = ( new RawContextKey(`treeView.${this.id}.enableCollapseAll`, startingValue, ( localize(3691, "Whether the tree view with id {0} enables collapse all.", this.id))));
+            this.collapseAllContextKey = ( new RawContextKey(`treeView.${this.id}.enableCollapseAll`, startingValue, ( localize(3696, "Whether the tree view with id {0} enables collapse all.", this.id))));
             this.collapseAllContext = this.collapseAllContextKey.bindTo(this.contextKeyService);
         }
         return true;
@@ -457,7 +515,7 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
     }
     initializeShowRefreshAction(startingValue = false) {
         if (!this.refreshContext) {
-            this.refreshContextKey = ( new RawContextKey(`treeView.${this.id}.enableRefresh`, startingValue, ( localize(3692, "Whether the tree view with id {0} enables refresh.", this.id))));
+            this.refreshContextKey = ( new RawContextKey(`treeView.${this.id}.enableRefresh`, startingValue, ( localize(3697, "Whether the tree view with id {0} enables refresh.", this.id))));
             this.refreshContext = this.refreshContextKey.bindTo(this.contextKeyService);
         }
     }
@@ -475,12 +533,12 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
             constructor() {
                 super({
                     id: `workbench.actions.treeView.${that.id}.refresh`,
-                    title: ( localize(3693, "Refresh")),
+                    title: ( localize(3698, "Refresh")),
                     menu: {
                         id: MenuId.ViewTitle,
-                        when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', that.id)), that.refreshContextKey)),
-                        group: 'navigation',
-                        order: Number.MAX_SAFE_INTEGER - 1,
+                        when: ( ContextKeyExpr.and(( ContextKeyExpr.equals("view", that.id)), that.refreshContextKey)),
+                        group: "navigation",
+                        order: Number.MAX_SAFE_INTEGER - 1
                     },
                     icon: Codicon.refresh
                 });
@@ -493,12 +551,12 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
             constructor() {
                 super({
                     id: `workbench.actions.treeView.${that.id}.collapseAll`,
-                    title: ( localize(3694, "Collapse All")),
+                    title: ( localize(3699, "Collapse All")),
                     menu: {
                         id: MenuId.ViewTitle,
-                        when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', that.id)), that.collapseAllContextKey)),
-                        group: 'navigation',
-                        order: Number.MAX_SAFE_INTEGER,
+                        when: ( ContextKeyExpr.and(( ContextKeyExpr.equals("view", that.id)), that.collapseAllContextKey)),
+                        group: "navigation",
+                        order: Number.MAX_SAFE_INTEGER
                     },
                     precondition: that.collapseAllToggleContextKey,
                     icon: Codicon.collapseAll
@@ -521,8 +579,7 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
         if (this.tree) {
             if (this.isVisible) {
                 show(this.tree.getHTMLElement());
-            }
-            else {
+            } else {
                 hide(this.tree.getHTMLElement());
             }
             if (this.isVisible && this.elementsToRefresh.length && this.dataProvider) {
@@ -546,11 +603,9 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
                 this.tree.reveal(element, 0.5);
             }
             this.tree.domFocus();
-        }
-        else if (this.tree && this.treeContainer && !this.treeContainer.classList.contains('hide')) {
+        } else if (this.tree && this.treeContainer && !this.treeContainer.classList.contains("hide")) {
             this.tree.domFocus();
-        }
-        else {
+        } else {
             this.domNode.focus();
         }
     }
@@ -559,11 +614,11 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
         append(container, this.domNode);
     }
     create() {
-        this.domNode = $('.tree-explorer-viewlet-tree-view');
-        this.messageElement = append(this.domNode, $('.message'));
+        this.domNode = $(".tree-explorer-viewlet-tree-view");
+        this.messageElement = append(this.domNode, $(".message"));
         this.updateMessage();
-        this.treeContainer = append(this.domNode, $('.customview-tree'));
-        this.treeContainer.classList.add('file-icon-themable-tree', 'show-file-icons');
+        this.treeContainer = append(this.domNode, $(".customview-tree"));
+        this.treeContainer.classList.add("file-icon-themable-tree", "show-file-icons");
         const focusTracker = this._register(trackFocus(this.domNode));
         this._register(focusTracker.onDidFocus(() => this.focused = true));
         this._register(focusTracker.onDidBlur(() => this.focused = false));
@@ -573,63 +628,79 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
         const actionViewItemProvider = createActionViewItem.bind(undefined, this.instantiationService);
         const treeMenus = this.treeDisposables.add(this.instantiationService.createInstance(TreeMenus, this.id));
         this.treeLabels = this.treeDisposables.add(this.instantiationService.createInstance(ResourceLabels, this));
-        const dataSource = this.instantiationService.createInstance(TreeDataSource, this, (task) => this.progressService.withProgress({ location: this.id }, () => task));
+        const dataSource = this.instantiationService.createInstance(TreeDataSource, this, task => this.progressService.withProgress({
+            location: this.id
+        }, () => task));
         const aligner = this.treeDisposables.add(( new Aligner(this.themeService, this.logService)));
         const checkboxStateHandler = this.treeDisposables.add(( new CheckboxStateHandler()));
-        const renderer = this.treeDisposables.add(this.instantiationService.createInstance(TreeRenderer, this.id, treeMenus, this.treeLabels, actionViewItemProvider, aligner, checkboxStateHandler, () => this.manuallyManageCheckboxes));
-        this.treeDisposables.add(renderer.onDidChangeCheckboxState(e => this._onDidChangeCheckboxState.fire(e)));
+        const renderer = this.treeDisposables.add(this.instantiationService.createInstance(
+            TreeRenderer,
+            this.id,
+            treeMenus,
+            this.treeLabels,
+            actionViewItemProvider,
+            aligner,
+            checkboxStateHandler,
+            () => this.manuallyManageCheckboxes
+        ));
+        this.treeDisposables.add(
+            renderer.onDidChangeCheckboxState(e => this._onDidChangeCheckboxState.fire(e))
+        );
         const widgetAriaLabel = this._title;
-        this.tree = this.treeDisposables.add(this.instantiationService.createInstance(Tree, this.id, this.treeContainer, ( new TreeViewDelegate()), [renderer], dataSource, {
-            identityProvider: ( new TreeViewIdentityProvider()),
-            accessibilityProvider: {
-                getAriaLabel(element) {
-                    if (element.accessibilityInformation) {
-                        return element.accessibilityInformation.label;
-                    }
-                    if (isString(element.tooltip)) {
-                        return element.tooltip;
-                    }
-                    else {
-                        if (element.resourceUri && !element.label) {
-                            return null;
+        this.tree = this.treeDisposables.add(
+            this.instantiationService.createInstance(Tree, this.id, this.treeContainer, ( new TreeViewDelegate()), [renderer], dataSource, {
+                identityProvider: ( new TreeViewIdentityProvider()),
+                accessibilityProvider: {
+                    getAriaLabel(element) {
+                        if (element.accessibilityInformation) {
+                            return element.accessibilityInformation.label;
                         }
-                        let buildAriaLabel = '';
-                        if (element.label) {
-                            const labelText = isMarkdownString(element.label.label) ? element.label.label.value : element.label.label;
-                            buildAriaLabel += labelText + ' ';
+                        if (isString(element.tooltip)) {
+                            return element.tooltip;
+                        } else {
+                            if (element.resourceUri && !element.label) {
+                                return null;
+                            }
+                            let buildAriaLabel = "";
+                            if (element.label) {
+                                const labelText = isMarkdownString(element.label.label) ? element.label.label.value : element.label.label;
+                                buildAriaLabel += labelText + " ";
+                            }
+                            if (element.description) {
+                                buildAriaLabel += element.description;
+                            }
+                            return buildAriaLabel;
                         }
-                        if (element.description) {
-                            buildAriaLabel += element.description;
+                    },
+                    getRole(element) {
+                        return element.accessibilityInformation?.role ?? "treeitem";
+                    },
+                    getWidgetAriaLabel() {
+                        return widgetAriaLabel;
+                    }
+                },
+                keyboardNavigationLabelProvider: {
+                    getKeyboardNavigationLabel: item => {
+                        if (item.label) {
+                            return isMarkdownString(item.label.label) ? item.label.label.value : item.label.label;
                         }
-                        return buildAriaLabel;
+                        return item.resourceUri ? basename(URI.revive(item.resourceUri)) : undefined;
                     }
                 },
-                getRole(element) {
-                    return element.accessibilityInformation?.role ?? 'treeitem';
+                expandOnlyOnTwistieClick: e => {
+                    return !!e.command || !!e.checkbox || this.configurationService.getValue("workbench.tree.expandMode") === "doubleClick";
                 },
-                getWidgetAriaLabel() {
-                    return widgetAriaLabel;
-                }
-            },
-            keyboardNavigationLabelProvider: {
-                getKeyboardNavigationLabel: (item) => {
-                    if (item.label) {
-                        return isMarkdownString(item.label.label) ? item.label.label.value : item.label.label;
-                    }
-                    return item.resourceUri ? basename(URI.revive(item.resourceUri)) : undefined;
-                }
-            },
-            expandOnlyOnTwistieClick: (e) => {
-                return !!e.command || !!e.checkbox || this.configurationService.getValue('workbench.tree.expandMode') === 'doubleClick';
-            },
-            collapseByDefault: (e) => {
-                return e.collapsibleState !== TreeItemCollapsibleState.Expanded;
-            },
-            multipleSelectionSupport: this.canSelectMany,
-            dnd: this.treeViewDnd,
-            overrideStyles: getLocationBasedViewColors(this.viewLocation).listOverrideStyles
-        }));
-        this.treeDisposables.add(renderer.onDidChangeMenuContext(e => e.forEach(e => this.tree?.rerender(e))));
+                collapseByDefault: e => {
+                    return e.collapsibleState !== TreeItemCollapsibleState.Expanded;
+                },
+                multipleSelectionSupport: this.canSelectMany,
+                dnd: this.treeViewDnd,
+                overrideStyles: getLocationBasedViewColors(this.viewLocation).listOverrideStyles
+            })
+        );
+        this.treeDisposables.add(
+            renderer.onDidChangeMenuContext(e => e.forEach(e => this.tree?.rerender(e)))
+        );
         this.treeDisposables.add(this.tree);
         treeMenus.setContextKeyService(this.tree.contextKeyService);
         aligner.tree = this.tree;
@@ -638,17 +709,25 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
         this.tree.contextKeyService.createKey(this.id, true);
         const customTreeKey = RawCustomTreeViewContextKey.bindTo(this.tree.contextKeyService);
         customTreeKey.set(true);
-        this.treeDisposables.add(this.tree.onContextMenu(e => this.onContextMenu(treeMenus, e, actionRunner)));
+        this.treeDisposables.add(
+            this.tree.onContextMenu(e => this.onContextMenu(treeMenus, e, actionRunner))
+        );
         this.treeDisposables.add(this.tree.onDidChangeSelection(e => {
             this.lastSelection = e.elements;
             this.lastActive = this.tree?.getFocus()[0] ?? this.lastActive;
-            this._onDidChangeSelectionAndFocus.fire({ selection: this.lastSelection, focus: this.lastActive });
+            this._onDidChangeSelectionAndFocus.fire({
+                selection: this.lastSelection,
+                focus: this.lastActive
+            });
         }));
         this.treeDisposables.add(this.tree.onDidChangeFocus(e => {
             if (e.elements.length && (e.elements[0] !== this.lastActive)) {
                 this.lastActive = e.elements[0];
                 this.lastSelection = this.tree?.getSelection() ?? this.lastSelection;
-                this._onDidChangeSelectionAndFocus.fire({ selection: this.lastSelection, focus: this.lastActive });
+                this._onDidChangeSelectionAndFocus.fire({
+                    selection: this.lastSelection,
+                    focus: this.lastActive
+                });
             }
         }));
         this.treeDisposables.add(this.tree.onDidChangeCollapseState(e => {
@@ -658,13 +737,12 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
             const element = Array.isArray(e.node.element.element) ? e.node.element.element[0] : e.node.element.element;
             if (e.node.collapsed) {
                 this._onDidCollapseItem.fire(element);
-            }
-            else {
+            } else {
                 this._onDidExpandItem.fire(element);
             }
         }));
         this.tree.setInput(this.root).then(() => this.updateContentAreas());
-        this.treeDisposables.add(this.tree.onDidOpen(async (e) => {
+        this.treeDisposables.add(this.tree.onDidOpen(async e => {
             if (!e.browserEvent) {
                 return;
             }
@@ -680,13 +758,12 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
                 }
                 try {
                     await this.commandService.executeCommand(command.id, ...args);
-                }
-                catch (err) {
+                } catch (err) {
                     this.notificationService.error(err);
                 }
             }
         }));
-        this.treeDisposables.add(treeMenus.onDidChange((changed) => {
+        this.treeDisposables.add(treeMenus.onDidChange(changed => {
             if (this.tree?.hasNode(changed)) {
                 this.tree?.rerender(changed);
             }
@@ -723,51 +800,59 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
         this.contextMenuService.showContextMenu({
             getAnchor: () => treeEvent.anchor,
             getActions: () => actions,
-            getActionViewItem: (action) => {
+            getActionViewItem: action => {
                 const keybinding = this.keybindingService.lookupKeybinding(action.id);
                 if (keybinding) {
-                    return ( new ActionViewItem(action, action, { label: true, keybinding: keybinding.getLabel() }));
+                    return ( new ActionViewItem(action, action, {
+                        label: true,
+                        keybinding: keybinding.getLabel()
+                    }));
                 }
                 return undefined;
             },
-            onHide: (wasCancelled) => {
+            onHide: wasCancelled => {
                 if (wasCancelled) {
                     this.tree.domFocus();
                 }
             },
-            getActionsContext: () => ({ $treeViewId: this.id, $treeItemHandle: node.handle }),
+            getActionsContext: () => ({
+                $treeViewId: this.id,
+                $treeItemHandle: node.handle
+            }),
             actionRunner
         });
     }
     updateMessage() {
         if (this._message) {
             this.showMessage(this._message);
-        }
-        else if (!this.dataProvider) {
+        } else if (!this.dataProvider) {
             this.showMessage(noDataProviderMessage);
-        }
-        else {
+        } else {
             this.hideMessage();
         }
         this.updateContentAreas();
     }
     processMessage(message, disposables) {
-        const lines = message.value.split('\n');
+        const lines = message.value.split("\n");
         const result = [];
         let hasFoundButton = false;
         for (const line of lines) {
             const linkedText = parseLinkedText(line);
-            if (linkedText.nodes.length === 1 && typeof linkedText.nodes[0] !== 'string') {
+            if (linkedText.nodes.length === 1 && typeof linkedText.nodes[0] !== "string") {
                 const node = linkedText.nodes[0];
-                const buttonContainer = createElement('div');
-                buttonContainer.classList.add('button-container');
-                const button = ( new Button(
-                    buttonContainer,
-                    { title: node.title, secondary: hasFoundButton, supportIcons: true, ...defaultButtonStyles }
-                ));
+                const buttonContainer = createElement("div");
+                buttonContainer.classList.add("button-container");
+                const button = ( new Button(buttonContainer, {
+                    title: node.title,
+                    secondary: hasFoundButton,
+                    supportIcons: true,
+                    ...defaultButtonStyles
+                }));
                 button.label = node.label;
                 button.onDidClick(_ => {
-                    this.openerService.open(node.href, { allowCommands: true });
+                    this.openerService.open(node.href, {
+                        allowCommands: true
+                    });
                 }, null, disposables);
                 const href = ( URI.parse(node.href));
                 if (href.scheme === Schemas.command) {
@@ -784,24 +869,23 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
                 disposables.add(button);
                 hasFoundButton = true;
                 result.push(buttonContainer);
-            }
-            else {
+            } else {
                 hasFoundButton = false;
-                const rendered = this.markdownRendererService.render(( new MarkdownString(
-                    line,
-                    { isTrusted: message.isTrusted, supportThemeIcons: message.supportThemeIcons, supportHtml: message.supportHtml }
-                )));
+                const rendered = this.markdownRendererService.render(( new MarkdownString(line, {
+                    isTrusted: message.isTrusted,
+                    supportThemeIcons: message.supportThemeIcons,
+                    supportHtml: message.supportHtml
+                })));
                 result.push(rendered.element);
                 disposables.add(rendered);
             }
         }
-        const container = createElement('div');
-        container.classList.add('rendered-message');
+        const container = createElement("div");
+        container.classList.add("rendered-message");
         for (const child of result) {
             if (isHTMLElement(child)) {
                 container.appendChild(child);
-            }
-            else {
+            } else {
                 container.appendChild(child.element);
             }
         }
@@ -814,27 +898,28 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
         if (isMarkdownString(message)) {
             const disposables = ( new DisposableStore());
             const renderedMessage = this.processMessage(message, disposables);
-            this._messageValue = { element: renderedMessage, disposables };
-        }
-        else {
+            this._messageValue = {
+                element: renderedMessage,
+                disposables
+            };
+        } else {
             this._messageValue = message;
         }
         if (!this.messageElement) {
             return;
         }
-        this.messageElement.classList.remove('hide');
+        this.messageElement.classList.remove("hide");
         this.resetMessageElement();
-        if (typeof this._messageValue === 'string' && !isFalsyOrWhitespace(this._messageValue)) {
+        if (typeof this._messageValue === "string" && !isFalsyOrWhitespace(this._messageValue)) {
             this.messageElement.textContent = this._messageValue;
-        }
-        else if (isRenderedMessageValue(this._messageValue)) {
+        } else if (isRenderedMessageValue(this._messageValue)) {
             this.messageElement.appendChild(this._messageValue.element);
         }
         this.layout(this._height, this._width);
     }
     hideMessage() {
         this.resetMessageElement();
-        this.messageElement?.classList.add('hide');
+        this.messageElement?.classList.add("hide");
         this.layout(this._height, this._width);
     }
     resetMessageElement() {
@@ -847,14 +932,14 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
             this._height = height;
             this._width = width;
             const treeHeight = height - getTotalHeight(this.messageElement);
-            this.treeContainer.style.height = treeHeight + 'px';
+            this.treeContainer.style.height = treeHeight + "px";
             this.tree?.layout(treeHeight, width);
         }
     }
     getOptimalWidth() {
         if (this.tree) {
             const parentNode = this.tree.getHTMLElement();
-            const childNodes = [].slice.call(parentNode.querySelectorAll('.outline-item-label > a'));
+            const childNodes = [].slice.call(parentNode.querySelectorAll(".outline-item-label > a"));
             return getLargestChildWidth(parentNode, childNodes);
         }
         return 0;
@@ -877,8 +962,7 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
             if (this.isVisible) {
                 const affectedElements = this.updateCheckboxes(checkboxes ?? []);
                 return this.doRefresh(elements.concat(affectedElements));
-            }
-            else {
+            } else {
                 if (this.elementsToRefresh.length) {
                     const seen = ( new Set());
                     this.elementsToRefresh.forEach(element => seen.add(element.handle));
@@ -887,8 +971,7 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
                             this.elementsToRefresh.push(element);
                         }
                     }
-                }
-                else {
+                } else {
                     this.elementsToRefresh.push(...elements);
                 }
             }
@@ -905,9 +988,7 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
             for (const element of itemOrItems) {
                 await tree.expand(element, false);
             }
-        }
-        catch (e) {
-        }
+        } catch (e) {}
     }
     isCollapsed(item) {
         return !!this.tree?.isCollapsed(item);
@@ -923,8 +1004,7 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
             if (item) {
                 this.focus(true, item);
                 this.tree.setFocus([item]);
-            }
-            else if (this.tree.getFocus().length === 0) {
+            } else if (this.tree.getFocus().length === 0) {
                 this.tree.setFocus([]);
             }
         }
@@ -941,14 +1021,16 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
             const oldSelection = tree.getSelection();
             try {
                 await Promise.all(( elements.map(element => tree.updateChildren(element, true, true))));
-            }
-            catch (e) {
+            } catch (e) {
                 this.logService.error(e);
             }
             const newSelection = tree.getSelection();
             if (oldSelection.length !== newSelection.length || ( oldSelection.some((value, index) => value.handle !== newSelection[index].handle))) {
                 this.lastSelection = newSelection;
-                this._onDidChangeSelectionAndFocus.fire({ selection: this.lastSelection, focus: this.lastActive });
+                this._onDidChangeSelectionAndFocus.fire({
+                    selection: this.lastSelection,
+                    focus: this.lastActive
+                });
             }
             this.refreshing = false;
             this._onDidCompleteRefresh.fire();
@@ -962,7 +1044,7 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
     initializeCollapseAllToggle() {
         if (!this.collapseAllToggleContext) {
             this.collapseAllToggleContextKey = ( new RawContextKey(`treeView.${this.id}.toggleCollapseAll`, false, ( localize(
-                3695,
+                3700,
                 "Whether collapse all is toggled for the tree view with id {0}.",
                 this.id
             ))));
@@ -972,47 +1054,29 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
     updateCollapseAllToggle() {
         if (this.showCollapseAllAction) {
             this.initializeCollapseAllToggle();
-            this.collapseAllToggleContext?.set(!!this.root.children && (this.root.children.length > 0) &&
-                ( this.root.children.some(value => value.collapsibleState !== TreeItemCollapsibleState.None)));
+            this.collapseAllToggleContext?.set(!!this.root.children && (this.root.children.length > 0) && ( this.root.children.some(value => value.collapsibleState !== TreeItemCollapsibleState.None)));
         }
     }
     updateContentAreas() {
         const isTreeEmpty = !this.root.children || this.root.children.length === 0;
         if (this._messageValue && isTreeEmpty && !this.refreshing && this.treeContainer) {
             if (!this.dragAndDropController) {
-                this.treeContainer.classList.add('hide');
+                this.treeContainer.classList.add("hide");
             }
-            this.domNode.setAttribute('tabindex', '0');
-        }
-        else if (this.treeContainer) {
-            this.treeContainer.classList.remove('hide');
+            this.domNode.setAttribute("tabindex", "0");
+        } else if (this.treeContainer) {
+            this.treeContainer.classList.remove("hide");
             if (this.domNode === getActiveElement()) {
                 this.focus();
             }
-            this.domNode.removeAttribute('tabindex');
+            this.domNode.removeAttribute("tabindex");
         }
     }
     get container() {
         return this._container;
     }
 };
-AbstractTreeView = ( __decorate([
-    ( __param(2, IThemeService)),
-    ( __param(3, IInstantiationService)),
-    ( __param(4, ICommandService)),
-    ( __param(5, IConfigurationService)),
-    ( __param(6, IProgressService)),
-    ( __param(7, IContextMenuService)),
-    ( __param(8, IKeybindingService)),
-    ( __param(9, INotificationService)),
-    ( __param(10, IViewDescriptorService)),
-    ( __param(11, IHoverService)),
-    ( __param(12, IContextKeyService)),
-    ( __param(13, IActivityService)),
-    ( __param(14, ILogService)),
-    ( __param(15, IOpenerService)),
-    ( __param(16, IMarkdownRendererService))
-], AbstractTreeView));
+AbstractTreeView = ( __decorate([( __param(2, IThemeService)), ( __param(3, IInstantiationService)), ( __param(4, ICommandService)), ( __param(5, IConfigurationService)), ( __param(6, IProgressService)), ( __param(7, IContextMenuService)), ( __param(8, IKeybindingService)), ( __param(9, INotificationService)), ( __param(10, IViewDescriptorService)), ( __param(11, IHoverService)), ( __param(12, IContextKeyService)), ( __param(13, IActivityService)), ( __param(14, ILogService)), ( __param(15, IOpenerService)), ( __param(16, IMarkdownRendererService))], AbstractTreeView));
 class TreeViewIdentityProvider {
     getId(element) {
         return element.handle;
@@ -1029,12 +1093,10 @@ class TreeViewDelegate {
 async function doGetChildrenOrBatch(dataProvider, nodes) {
     if (dataProvider.getChildrenBatch) {
         return dataProvider.getChildrenBatch(nodes);
-    }
-    else {
+    } else {
         if (nodes) {
             return Promise.all(( nodes.map(node => dataProvider.getChildren(node).then(children => children ?? []))));
-        }
-        else {
+        } else {
             return [await dataProvider.getChildren()].filter(children => children !== undefined);
         }
     }
@@ -1055,8 +1117,7 @@ class TreeDataSource {
         if (this.batch === undefined) {
             this.batch = [element];
             this.batchPromise = undefined;
-        }
-        else {
+        } else {
             this.batch.push(element);
         }
         const indexInBatch = this.batch.length - 1;
@@ -1070,9 +1131,8 @@ class TreeDataSource {
                 try {
                     const result = await this.batchPromise;
                     resolve((result && (indexInBatch < result.length)) ? result[indexInBatch] : []);
-                }
-                catch (e) {
-                    if (!e.message.startsWith('Bad progress location:')) {
+                } catch (e) {
+                    if (!e.message.startsWith("Bad progress location:")) {
                         reject(e);
                     }
                 }
@@ -1081,10 +1141,30 @@ class TreeDataSource {
     }
 }
 let TreeRenderer = class TreeRenderer extends Disposable {
-    static { TreeRenderer_1 = this; }
-    static { this.ITEM_HEIGHT = 22; }
-    static { this.TREE_TEMPLATE_ID = 'treeExplorer'; }
-    constructor(treeViewId, menus, labels, actionViewItemProvider, aligner, checkboxStateHandler, manuallyManageCheckboxes, themeService, configurationService, labelService, contextKeyService, hoverService, instantiationService) {
+    static {
+        TreeRenderer_1 = this;
+    }
+    static {
+        this.ITEM_HEIGHT = 22;
+    }
+    static {
+        this.TREE_TEMPLATE_ID = "treeExplorer";
+    }
+    constructor(
+        treeViewId,
+        menus,
+        labels,
+        actionViewItemProvider,
+        aligner,
+        checkboxStateHandler,
+        manuallyManageCheckboxes,
+        themeService,
+        configurationService,
+        labelService,
+        contextKeyService,
+        hoverService,
+        instantiationService
+    ) {
         super();
         this.treeViewId = treeViewId;
         this.menus = menus;
@@ -1104,7 +1184,9 @@ let TreeRenderer = class TreeRenderer extends Disposable {
         this.onDidChangeMenuContext = this._onDidChangeMenuContext.event;
         this._hasCheckbox = false;
         this._renderedElements = ( new Map());
-        this._hoverDelegate = this._register(instantiationService.createInstance(WorkbenchHoverDelegate, 'mouse', undefined, {}));
+        this._hoverDelegate = this._register(
+            instantiationService.createInstance(WorkbenchHoverDelegate, "mouse", undefined, {})
+        );
         this._register(this.themeService.onDidFileIconThemeChange(() => this.rerender()));
         this._register(this.themeService.onDidColorThemeChange(() => this.rerender()));
         this._register(checkboxStateHandler.onDidChangeCheckboxState(items => {
@@ -1119,52 +1201,63 @@ let TreeRenderer = class TreeRenderer extends Disposable {
         this._actionRunner = actionRunner;
     }
     renderTemplate(container) {
-        container.classList.add('custom-view-tree-node-item');
-        const checkboxContainer = append(container, $(''));
-        const resourceLabel = this.labels.create(container, { supportHighlights: true, hoverDelegate: this._hoverDelegate });
-        const icon = prepend(resourceLabel.element, $('.custom-view-tree-node-item-icon'));
-        const actionsContainer = append(resourceLabel.element, $('.actions'));
+        container.classList.add("custom-view-tree-node-item");
+        const checkboxContainer = append(container, $(""));
+        const resourceLabel = this.labels.create(container, {
+            supportHighlights: true,
+            hoverDelegate: this._hoverDelegate
+        });
+        const icon = prepend(resourceLabel.element, $(".custom-view-tree-node-item-icon"));
+        const actionsContainer = append(resourceLabel.element, $(".actions"));
         const actionBar = ( new ActionBar(actionsContainer, {
             actionViewItemProvider: this.actionViewItemProvider
         }));
-        return { resourceLabel, icon, checkboxContainer, actionBar, container };
+        return {
+            resourceLabel,
+            icon,
+            checkboxContainer,
+            actionBar,
+            container
+        };
     }
     getHover(label, resource, node) {
         if (!(node instanceof ResolvableTreeItem) || !node.hasResolve) {
             if (resource && !node.tooltip) {
                 return undefined;
-            }
-            else if (node.tooltip === undefined) {
+            } else if (node.tooltip === undefined) {
                 if (isMarkdownString(label)) {
-                    return { markdown: label, markdownNotSupportedFallback: label.value };
-                }
-                else {
+                    return {
+                        markdown: label,
+                        markdownNotSupportedFallback: label.value
+                    };
+                } else {
                     return label;
                 }
-            }
-            else if (!isString(node.tooltip)) {
-                return { markdown: node.tooltip, markdownNotSupportedFallback: resource ? undefined : renderAsPlaintext(node.tooltip) };
-            }
-            else if (node.tooltip !== '') {
+            } else if (!isString(node.tooltip)) {
+                return {
+                    markdown: node.tooltip,
+                    markdownNotSupportedFallback: resource ? undefined : renderAsPlaintext(node.tooltip)
+                };
+            } else if (node.tooltip !== "") {
                 return node.tooltip;
-            }
-            else {
+            } else {
                 return undefined;
             }
         }
         return {
-            markdown: typeof node.tooltip === 'string' ? node.tooltip :
-                (token) => {
-                    return ( new Promise((resolve) => {
-                        node.resolve(token).then(() => resolve(node.tooltip));
-                    }));
-                },
-            markdownNotSupportedFallback: resource ? undefined : (label ? (isMarkdownString(label) ? label.value : label) : '')
+            markdown: typeof node.tooltip === "string" ? node.tooltip : token => {
+                return ( new Promise(resolve => {
+                    node.resolve(token).then(() => resolve(node.tooltip));
+                }));
+            },
+            markdownNotSupportedFallback: resource ? undefined : (label ? (isMarkdownString(label) ? label.value : label) : "")
         };
     }
     processLabel(label, matches) {
         if (!isMarkdownString(label)) {
-            return { label };
+            return {
+                label
+            };
         }
         let text = label.value.trim();
         let bold = false;
@@ -1178,17 +1271,38 @@ let TreeRenderer = class TreeRenderer extends Disposable {
                 }
             }
         }
-        const syntaxes = [
-            { open: '~~', close: '~~', mark: () => { strikethrough = true; } },
-            { open: '**', close: '**', mark: () => { bold = true; } },
-            { open: '*', close: '*', mark: () => { italic = true; } },
-            { open: '_', close: '_', mark: () => { italic = true; } }
-        ];
+        const syntaxes = [{
+            open: "~~",
+            close: "~~",
+            mark: () => {
+                strikethrough = true;
+            }
+        }, {
+            open: "**",
+            close: "**",
+            mark: () => {
+                bold = true;
+            }
+        }, {
+            open: "*",
+            close: "*",
+            mark: () => {
+                italic = true;
+            }
+        }, {
+            open: "_",
+            close: "_",
+            mark: () => {
+                italic = true;
+            }
+        }];
         function checkSyntaxes() {
             let didChange = false;
             for (const syntax of syntaxes) {
                 if (text.startsWith(syntax.open) && text.endsWith(syntax.close)) {
-                    if (matches?.some(match => match.start < syntax.open.length || match.end > text.length - syntax.close.length)) {
+                    if (matches?.some(
+                        match => match.start < syntax.open.length || match.end > text.length - syntax.close.length
+                    )) {
                         return false;
                     }
                     syntax.mark();
@@ -1215,8 +1329,12 @@ let TreeRenderer = class TreeRenderer extends Disposable {
     renderElement(element, index, templateData) {
         const node = element.element;
         const resource = node.resourceUri ? URI.revive(node.resourceUri) : null;
-        const treeItemLabel = node.label ? node.label : (resource ? { label: basename(resource) } : undefined);
-        const description = isString(node.description) ? node.description : resource && node.description === true ? this.labelService.getUriLabel(dirname(resource), { relative: true }) : undefined;
+        const treeItemLabel = node.label ? node.label : (resource ? {
+            label: basename(resource)
+        } : undefined);
+        const description = isString(node.description) ? node.description : resource && node.description === true ? this.labelService.getUriLabel(dirname(resource), {
+            relative: true
+        }) : undefined;
         const labelStr = treeItemLabel ? isMarkdownString(treeItemLabel.label) ? treeItemLabel.label.value : treeItemLabel.label : undefined;
         const matches = (treeItemLabel?.highlights && labelStr) ? ( treeItemLabel.highlights.map(([start, end]) => {
             if (start < 0) {
@@ -1226,35 +1344,51 @@ let TreeRenderer = class TreeRenderer extends Disposable {
                 end = labelStr.length + end;
             }
             if ((start >= labelStr.length) || (end > labelStr.length)) {
-                return ({ start: 0, end: 0 });
+                return ({
+                    start: 0,
+                    end: 0
+                });
             }
             if (start > end) {
                 const swap = start;
                 start = end;
                 end = swap;
             }
-            return ({ start, end });
+            return ({
+                start,
+                end
+            });
         })) : undefined;
-        const { label, bold, italic, strikethrough, supportIcons } = this.processLabel(treeItemLabel?.label, matches);
+        const {
+            label,
+            bold,
+            italic,
+            strikethrough,
+            supportIcons
+        } = this.processLabel(treeItemLabel?.label, matches);
         const icon = !isDark(this.themeService.getColorTheme().type) ? node.icon : node.iconDark;
         const iconUrl = icon ? URI.revive(icon) : undefined;
         const title = this.getHover(treeItemLabel?.label, resource, node);
         templateData.actionBar.clear();
-        templateData.icon.style.color = '';
+        templateData.icon.style.color = "";
         let commandEnabled = true;
         if (node.command) {
             commandEnabled = isTreeCommandEnabled(node.command, this.contextKeyService);
         }
         this.renderCheckbox(node, templateData);
         if (resource) {
-            const fileDecorations = this.configurationService.getValue('explorer.decorations');
-            const labelResource = resource ? resource : ( URI.parse('missing:_icon_resource'));
-            templateData.resourceLabel.setResource({ name: label, description, resource: labelResource }, {
+            const fileDecorations = this.configurationService.getValue("explorer.decorations");
+            const labelResource = resource ? resource : ( URI.parse("missing:_icon_resource"));
+            templateData.resourceLabel.setResource({
+                name: label,
+                description,
+                resource: labelResource
+            }, {
                 fileKind: this.getFileKind(node),
                 title,
                 hideIcon: this.shouldHideResourceLabelIcon(iconUrl, node.themeIcon),
                 fileDecorations,
-                extraClasses: ['custom-view-tree-node-item-resourceLabel'],
+                extraClasses: ["custom-view-tree-node-item-resourceLabel"],
                 matches: matches ? matches : createMatches(element.filterData),
                 bold,
                 italic,
@@ -1264,12 +1398,14 @@ let TreeRenderer = class TreeRenderer extends Disposable {
                 forceLabel: !!node.label,
                 supportIcons
             });
-        }
-        else {
-            templateData.resourceLabel.setResource({ name: label, description }, {
+        } else {
+            templateData.resourceLabel.setResource({
+                name: label,
+                description
+            }, {
                 title,
                 hideIcon: true,
-                extraClasses: ['custom-view-tree-node-item-resourceLabel'],
+                extraClasses: ["custom-view-tree-node-item-resourceLabel"],
                 matches: matches ? matches : createMatches(element.filterData),
                 bold,
                 italic,
@@ -1280,35 +1416,43 @@ let TreeRenderer = class TreeRenderer extends Disposable {
             });
         }
         if (iconUrl) {
-            templateData.icon.className = 'custom-view-tree-node-item-icon';
+            templateData.icon.className = "custom-view-tree-node-item-icon";
             templateData.icon.style.backgroundImage = asCSSUrl(iconUrl);
-        }
-        else {
+        } else {
             let iconClass;
             if (this.shouldShowThemeIcon(!!resource, node.themeIcon)) {
                 iconClass = ThemeIcon.asClassName(node.themeIcon);
                 if (node.themeIcon.color) {
-                    templateData.icon.style.color = this.themeService.getColorTheme().getColor(node.themeIcon.color.id)?.toString() ?? '';
+                    templateData.icon.style.color = this.themeService.getColorTheme().getColor(node.themeIcon.color.id)?.toString() ?? "";
                 }
             }
-            templateData.icon.className = iconClass ? `custom-view-tree-node-item-icon ${iconClass}` : '';
-            templateData.icon.style.backgroundImage = '';
+            templateData.icon.className = iconClass ? `custom-view-tree-node-item-icon ${iconClass}` : "";
+            templateData.icon.style.backgroundImage = "";
         }
         if (!commandEnabled) {
-            templateData.icon.className = templateData.icon.className + ' disabled';
+            templateData.icon.className = templateData.icon.className + " disabled";
             if (templateData.container.parentElement) {
-                templateData.container.parentElement.className = templateData.container.parentElement.className + ' disabled';
+                templateData.container.parentElement.className = templateData.container.parentElement.className + " disabled";
             }
         }
-        templateData.actionBar.context = { $treeViewId: this.treeViewId, $treeItemHandle: node.handle };
+        templateData.actionBar.context = {
+            $treeViewId: this.treeViewId,
+            $treeItemHandle: node.handle
+        };
         const menuActions = this.menus.getResourceActions([node]);
-        templateData.actionBar.push(menuActions, { icon: true, label: false });
+        templateData.actionBar.push(menuActions, {
+            icon: true,
+            label: false
+        });
         if (this._actionRunner) {
             templateData.actionBar.actionRunner = this._actionRunner;
         }
         this.setAlignment(templateData.container, node);
         const renderedItems = this._renderedElements.get(element.element.handle) ?? [];
-        this._renderedElements.set(element.element.handle, [...renderedItems, { original: element, rendered: templateData }]);
+        this._renderedElements.set(element.element.handle, [...renderedItems, {
+            original: element,
+            rendered: templateData
+        }]);
     }
     rerender() {
         const keys = ( new Set(( this._renderedElements.keys())));
@@ -1336,14 +1480,13 @@ let TreeRenderer = class TreeRenderer extends Disposable {
                 templateData.checkbox = checkbox;
             }
             templateData.checkbox.render(node);
-        }
-        else if (templateData.checkbox) {
+        } else if (templateData.checkbox) {
             templateData.checkbox.dispose();
             templateData.checkbox = undefined;
         }
     }
     setAlignment(container, treeItem) {
-        container.parentElement.classList.toggle('align-icon-with-twisty', this.aligner.alignIconWithTwisty(treeItem));
+        container.parentElement.classList.toggle("align-icon-with-twisty", this.aligner.alignIconWithTwisty(treeItem));
     }
     shouldHideResourceLabelIcon(iconUrl, icon) {
         return (!!iconUrl || (!!icon && !this.isFileKindThemeIcon(icon)));
@@ -1360,10 +1503,10 @@ let TreeRenderer = class TreeRenderer extends Disposable {
     getFileKind(node) {
         if (node.themeIcon) {
             switch (node.themeIcon.id) {
-                case FileThemeIcon.id:
-                    return FileKind.FILE;
-                case FolderThemeIcon.id:
-                    return FileKind.FOLDER;
+            case FileThemeIcon.id:
+                return FileKind.FILE;
+            case FolderThemeIcon.id:
+                return FileKind.FOLDER;
             }
         }
         return node.collapsibleState === TreeItemCollapsibleState.Collapsed || node.collapsibleState === TreeItemCollapsibleState.Expanded ? FileKind.FOLDER : FileKind.FILE;
@@ -1386,8 +1529,7 @@ let TreeRenderer = class TreeRenderer extends Disposable {
         let allItems = [];
         if (!this.manuallyManageCheckboxes()) {
             allItems = setCascadingCheckboxUpdates(items);
-        }
-        else {
+        } else {
             allItems = items;
         }
         allItems.forEach(item => {
@@ -1403,8 +1545,7 @@ let TreeRenderer = class TreeRenderer extends Disposable {
         const renderedIndex = itemRenders.findIndex(renderedItem => templateData === renderedItem.rendered);
         if (itemRenders.length === 1) {
             this._renderedElements.delete(resource.element.handle);
-        }
-        else if (itemRenders.length > 0) {
+        } else if (itemRenders.length > 0) {
             itemRenders.splice(renderedIndex, 1);
         }
         templateData.checkbox?.dispose();
@@ -1415,14 +1556,7 @@ let TreeRenderer = class TreeRenderer extends Disposable {
         templateData.actionBar.dispose();
     }
 };
-TreeRenderer = TreeRenderer_1 = ( __decorate([
-    ( __param(7, IThemeService)),
-    ( __param(8, IConfigurationService)),
-    ( __param(9, ILabelService)),
-    ( __param(10, IContextKeyService)),
-    ( __param(11, IHoverService)),
-    ( __param(12, IInstantiationService))
-], TreeRenderer));
+TreeRenderer = TreeRenderer_1 = ( __decorate([( __param(7, IThemeService)), ( __param(8, IConfigurationService)), ( __param(9, ILabelService)), ( __param(10, IContextKeyService)), ( __param(11, IHoverService)), ( __param(12, IInstantiationService))], TreeRenderer));
 class Aligner extends Disposable {
     constructor(themeService, logService) {
         super();
@@ -1444,8 +1578,7 @@ class Aligner extends Disposable {
             let parent;
             try {
                 parent = this._tree.getParentElement(treeItem) || root;
-            }
-            catch (error) {
+            } catch (error) {
                 this.logService.error(`[TreeView] Failed to resolve parent for ${treeItem.handle}`, error);
                 return false;
             }
@@ -1454,9 +1587,10 @@ class Aligner extends Disposable {
                     c => c.collapsibleState !== TreeItemCollapsibleState.None && !this.hasIconOrCheckbox(c)
                 ));
             }
-            return !!parent.children && parent.children.every(c => c.collapsibleState === TreeItemCollapsibleState.None || !this.hasIconOrCheckbox(c));
-        }
-        else {
+            return !!parent.children && parent.children.every(
+                c => c.collapsibleState === TreeItemCollapsibleState.None || !this.hasIconOrCheckbox(c)
+            );
+        } else {
             return false;
         }
     }
@@ -1486,8 +1620,8 @@ class MultipleSelectionActionRunner extends ActionRunner {
         this._register(this.onDidRun(e => {
             if (e.error && !isCancellationError(e.error)) {
                 notificationService.error(( localize(
-                    3696,
-                    'Error running command {1}: {0}. This is likely caused by the extension that contributes {1}.',
+                    3701,
+                    "Error running command {1}: {0}. This is likely caused by the extension that contributes {1}.",
                     e.error.message,
                     e.action.id
                 )));
@@ -1503,7 +1637,10 @@ class MultipleSelectionActionRunner extends ActionRunner {
                 if ((selected.handle === context.$treeItemHandle) || context.$selectedTreeItems) {
                     actionInSelected = true;
                 }
-                return { $treeViewId: context.$treeViewId, $treeItemHandle: selected.handle };
+                return {
+                    $treeViewId: context.$treeViewId,
+                    $treeItemHandle: selected.handle
+                };
             }));
         }
         if (!actionInSelected && selectionHandleArgs) {
@@ -1559,8 +1696,7 @@ let TreeMenus = class TreeMenus {
             if (action instanceof Separator) {
                 groups.push(group);
                 group = ( new Map());
-            }
-            else {
+            } else {
                 group.set(action.id, action);
             }
         }
@@ -1568,10 +1704,7 @@ let TreeMenus = class TreeMenus {
         return groups;
     }
     getElementOverlayContexts(element) {
-        return ( new Map([
-            ['view', this.id],
-            ['viewItem', element.contextValue]
-        ]));
+        return ( new Map([["view", this.id], ["viewItem", element.contextValue]]));
     }
     getEntireMenuContexts() {
         return this.menuService.getMenuContexts(this.getMenuId());
@@ -1581,75 +1714,101 @@ let TreeMenus = class TreeMenus {
     }
     getActions(menuId, elements) {
         if (!this.contextKeyService) {
-            return { primary: [], secondary: [] };
+            return {
+                primary: [],
+                secondary: []
+            };
         }
         let primaryGroups = [];
         let secondaryGroups = [];
         for (let i = 0; i < elements.length; i++) {
             const element = elements[i];
             const contextKeyService = this.contextKeyService.createOverlay(this.getElementOverlayContexts(element));
-            const menuData = this.menuService.getMenuActions(menuId, contextKeyService, { shouldForwardArgs: true });
-            const result = getContextMenuActions(menuData, 'inline');
+            const menuData = this.menuService.getMenuActions(menuId, contextKeyService, {
+                shouldForwardArgs: true
+            });
+            const result = getContextMenuActions(menuData, "inline");
             if (i === 0) {
                 primaryGroups = this.createGroups(result.primary);
                 secondaryGroups = this.createGroups(result.secondary);
-            }
-            else {
+            } else {
                 this.filterNonUniversalActions(primaryGroups, result.primary);
                 this.filterNonUniversalActions(secondaryGroups, result.secondary);
             }
         }
-        return { primary: this.buildMenu(primaryGroups), secondary: this.buildMenu(secondaryGroups) };
+        return {
+            primary: this.buildMenu(primaryGroups),
+            secondary: this.buildMenu(secondaryGroups)
+        };
     }
     dispose() {
         this.contextKeyService = undefined;
     }
 };
-TreeMenus = ( __decorate([
-    ( __param(1, IMenuService))
-], TreeMenus));
+TreeMenus = ( __decorate([( __param(1, IMenuService))], TreeMenus));
 let CustomTreeView = class CustomTreeView extends AbstractTreeView {
-    constructor(id, title, extensionId, themeService, instantiationService, commandService, configurationService, progressService, contextMenuService, keybindingService, notificationService, viewDescriptorService, contextKeyService, hoverService, extensionService, activityService, telemetryService, logService, openerService, markdownRendererService) {
-        super(id, title, themeService, instantiationService, commandService, configurationService, progressService, contextMenuService, keybindingService, notificationService, viewDescriptorService, hoverService, contextKeyService, activityService, logService, openerService, markdownRendererService);
+    constructor(
+        id,
+        title,
+        extensionId,
+        themeService,
+        instantiationService,
+        commandService,
+        configurationService,
+        progressService,
+        contextMenuService,
+        keybindingService,
+        notificationService,
+        viewDescriptorService,
+        contextKeyService,
+        hoverService,
+        extensionService,
+        activityService,
+        telemetryService,
+        logService,
+        openerService,
+        markdownRendererService
+    ) {
+        super(
+            id,
+            title,
+            themeService,
+            instantiationService,
+            commandService,
+            configurationService,
+            progressService,
+            contextMenuService,
+            keybindingService,
+            notificationService,
+            viewDescriptorService,
+            hoverService,
+            contextKeyService,
+            activityService,
+            logService,
+            openerService,
+            markdownRendererService
+        );
         this.extensionId = extensionId;
         this.extensionService = extensionService;
         this.telemetryService = telemetryService;
     }
     activate() {
         if (!this.activated) {
-            this.telemetryService.publicLog2('Extension:ViewActivate', {
+            this.telemetryService.publicLog2("Extension:ViewActivate", {
                 extensionId: ( new TelemetryTrustedValue(this.extensionId)),
-                id: this.id,
+                id: this.id
             });
             this.createTree();
-            this.progressService.withProgress({ location: this.id }, () => this.extensionService.activateByEvent(`onView:${this.id}`))
-                .then(() => timeout(2000))
-                .then(() => {
+            this.progressService.withProgress({
+                location: this.id
+            }, () => this.extensionService.activateByEvent(`onView:${this.id}`)).then(() => timeout(2000)).then(() => {
                 this.updateMessage();
             });
             this.activated = true;
         }
     }
 };
-CustomTreeView = ( __decorate([
-    ( __param(3, IThemeService)),
-    ( __param(4, IInstantiationService)),
-    ( __param(5, ICommandService)),
-    ( __param(6, IConfigurationService)),
-    ( __param(7, IProgressService)),
-    ( __param(8, IContextMenuService)),
-    ( __param(9, IKeybindingService)),
-    ( __param(10, INotificationService)),
-    ( __param(11, IViewDescriptorService)),
-    ( __param(12, IContextKeyService)),
-    ( __param(13, IHoverService)),
-    ( __param(14, IExtensionService)),
-    ( __param(15, IActivityService)),
-    ( __param(16, ITelemetryService)),
-    ( __param(17, ILogService)),
-    ( __param(18, IOpenerService)),
-    ( __param(19, IMarkdownRendererService))
-], CustomTreeView));
+CustomTreeView = ( __decorate([( __param(3, IThemeService)), ( __param(4, IInstantiationService)), ( __param(5, ICommandService)), ( __param(6, IConfigurationService)), ( __param(7, IProgressService)), ( __param(8, IContextMenuService)), ( __param(9, IKeybindingService)), ( __param(10, INotificationService)), ( __param(11, IViewDescriptorService)), ( __param(12, IContextKeyService)), ( __param(13, IHoverService)), ( __param(14, IExtensionService)), ( __param(15, IActivityService)), ( __param(16, ITelemetryService)), ( __param(17, ILogService)), ( __param(18, IOpenerService)), ( __param(19, IMarkdownRendererService))], CustomTreeView));
 class TreeView extends AbstractTreeView {
     activate() {
         if (!this.activated) {
@@ -1659,7 +1818,13 @@ class TreeView extends AbstractTreeView {
     }
 }
 let CustomTreeViewDragAndDrop = class CustomTreeViewDragAndDrop {
-    constructor(treeId, labelService, instantiationService, treeViewsDragAndDropService, logService) {
+    constructor(
+        treeId,
+        labelService,
+        instantiationService,
+        treeViewsDragAndDropService,
+        logService
+    ) {
         this.treeId = treeId;
         this.labelService = labelService;
         this.instantiationService = instantiationService;
@@ -1681,7 +1846,9 @@ let CustomTreeViewDragAndDrop = class CustomTreeViewDragAndDrop {
                     }
                 }
                 if (unlistedTypes.length) {
-                    this.logService.warn(`Drag and drop controller for tree ${this.treeId} adds the following data transfer types but does not declare them in dragMimeTypes: ${unlistedTypes.join(', ')}`);
+                    this.logService.warn(
+                        `Drag and drop controller for tree ${this.treeId} adds the following data transfer types but does not declare them in dragMimeTypes: ${unlistedTypes.join(", ")}`
+                    );
                 }
             }
             return additionalDataTransfer;
@@ -1693,14 +1860,17 @@ let CustomTreeViewDragAndDrop = class CustomTreeViewDragAndDrop {
         }
         const uuid = generateUuid();
         this.dragCancellationToken = ( new CancellationTokenSource());
-        this.treeViewsDragAndDropService.addDragOperationTransfer(uuid, this.handleDragAndLog(this.dndController, itemHandles, uuid, this.dragCancellationToken.token));
+        this.treeViewsDragAndDropService.addDragOperationTransfer(
+            uuid,
+            this.handleDragAndLog(this.dndController, itemHandles, uuid, this.dragCancellationToken.token)
+        );
         this.treeItemsTransfer.setData([( new DraggedTreeItemsIdentifier(uuid))], DraggedTreeItemsIdentifier.prototype);
         originalEvent.dataTransfer.clearData(Mimes.text);
-        if (this.dndController.dragMimeTypes.find((element) => element === Mimes.uriList)) {
-            originalEvent.dataTransfer?.setData(DataTransfers.RESOURCES, '');
+        if (this.dndController.dragMimeTypes.find(element => element === Mimes.uriList)) {
+            originalEvent.dataTransfer?.setData(DataTransfers.RESOURCES, "");
         }
         this.dndController.dragMimeTypes.forEach(supportedType => {
-            originalEvent.dataTransfer?.setData(supportedType, '');
+            originalEvent.dataTransfer?.setData(supportedType, "");
         });
     }
     addResourceInfoToTransfer(originalEvent, resources) {
@@ -1733,9 +1903,8 @@ let CustomTreeViewDragAndDrop = class CustomTreeViewDragAndDrop {
     }
     debugLog(types) {
         if (types.size) {
-            this.logService.debug(`TreeView dragged mime types: ${Array.from(types).join(', ')}`);
-        }
-        else {
+            this.logService.debug(`TreeView dragged mime types: ${Array.from(types).join(", ")}`);
+        } else {
             this.logService.debug(`TreeView dragged with no supported mime types.`);
         }
     }
@@ -1744,7 +1913,7 @@ let CustomTreeViewDragAndDrop = class CustomTreeViewDragAndDrop {
         const types = ( new Set(Array.from(dataTransfer, x => x[0])));
         if (originalEvent.dataTransfer) {
             for (const item of originalEvent.dataTransfer.items) {
-                if (item.kind === 'file' || item.type === DataTransfers.RESOURCES.toLowerCase()) {
+                if (item.kind === "file" || item.type === DataTransfers.RESOURCES.toLowerCase()) {
                     types.add(Mimes.uriList);
                     break;
                 }
@@ -1758,13 +1927,16 @@ let CustomTreeViewDragAndDrop = class CustomTreeViewDragAndDrop {
         const dragContainersSupportedType = ( Array.from(types).some((value, index) => {
             if (value === this.treeMimeType) {
                 return true;
-            }
-            else {
+            } else {
                 return dndController.dropMimeTypes.indexOf(value) >= 0;
             }
         }));
         if (dragContainersSupportedType) {
-            return { accept: true, bubble: TreeDragOverBubble.Down, autoExpand: true };
+            return {
+                accept: true,
+                bubble: TreeDragOverBubble.Down,
+                autoExpand: true
+            };
         }
         return false;
     }
@@ -1805,9 +1977,7 @@ let CustomTreeViewDragAndDrop = class CustomTreeViewDragAndDrop {
                 if (type === this.treeMimeType) {
                     try {
                         treeSourceInfo = JSON.parse(await item.asString());
-                    }
-                    catch {
-                    }
+                    } catch {}
                 }
             }
         }
@@ -1817,26 +1987,28 @@ let CustomTreeViewDragAndDrop = class CustomTreeViewDragAndDrop {
                 outDataTransfer.append(type, item);
             }
         }
-        return dndController.handleDrop(outDataTransfer, targetNode, CancellationToken.None, willDropUuid, treeSourceInfo?.id, treeSourceInfo?.itemHandles);
+        return dndController.handleDrop(
+            outDataTransfer,
+            targetNode,
+            CancellationToken.None,
+            willDropUuid,
+            treeSourceInfo?.id,
+            treeSourceInfo?.itemHandles
+        );
     }
     onDragEnd(originalEvent) {
-        if (originalEvent.dataTransfer?.dropEffect === 'none') {
+        if (originalEvent.dataTransfer?.dropEffect === "none") {
             this.dragCancellationToken?.cancel();
         }
     }
-    dispose() { }
+    dispose() {}
 };
-CustomTreeViewDragAndDrop = ( __decorate([
-    ( __param(1, ILabelService)),
-    ( __param(2, IInstantiationService)),
-    ( __param(3, ITreeViewsDnDService)),
-    ( __param(4, ILogService))
-], CustomTreeViewDragAndDrop));
+CustomTreeViewDragAndDrop = ( __decorate([( __param(1, ILabelService)), ( __param(2, IInstantiationService)), ( __param(3, ITreeViewsDnDService)), ( __param(4, ILogService))], CustomTreeViewDragAndDrop));
 function setCascadingCheckboxUpdates(items) {
     const additionalItems = [];
     for (const item of items) {
         if (item.checkbox !== undefined) {
-            const checkChildren = (currentItem) => {
+            const checkChildren = currentItem => {
                 for (const child of (currentItem.children ?? [])) {
                     if ((child.checkbox !== undefined) && (currentItem.checkbox !== undefined) && (child.checkbox.isChecked !== currentItem.checkbox.isChecked)) {
                         child.checkbox.isChecked = currentItem.checkbox.isChecked;
@@ -1847,12 +2019,11 @@ function setCascadingCheckboxUpdates(items) {
             };
             checkChildren(item);
             const visitedParents = ( new Set());
-            const checkParents = (currentItem) => {
+            const checkParents = currentItem => {
                 if (currentItem.parent?.checkbox !== undefined && currentItem.parent.children) {
                     if (( visitedParents.has(currentItem.parent))) {
                         return;
-                    }
-                    else {
+                    } else {
                         visitedParents.add(currentItem.parent);
                     }
                     let someUnchecked = false;
@@ -1864,8 +2035,7 @@ function setCascadingCheckboxUpdates(items) {
                         if (child.checkbox !== undefined) {
                             if (child.checkbox.isChecked) {
                                 someChecked = true;
-                            }
-                            else {
+                            } else {
                                 someUnchecked = true;
                             }
                         }
@@ -1874,8 +2044,7 @@ function setCascadingCheckboxUpdates(items) {
                         currentItem.parent.checkbox.isChecked = true;
                         additionalItems.push(currentItem.parent);
                         checkParents(currentItem.parent);
-                    }
-                    else if (someUnchecked && (currentItem.parent.checkbox.isChecked !== false)) {
+                    } else if (someUnchecked && (currentItem.parent.checkbox.isChecked !== false)) {
                         currentItem.parent.checkbox.isChecked = false;
                         additionalItems.push(currentItem.parent);
                         checkParents(currentItem.parent);